r300_vertexprog.c

mesa-6.5-minigui源码

/* TODO: Get rid of t_src_class call */
#define CMP_SRCS(a, b) (a.Index != b.Index && \
		       ((t_src_class(a.File) == VSF_IN_CLASS_PARAM && \
			 t_src_class(b.File) == VSF_IN_CLASS_PARAM) || \
			(t_src_class(a.File) == VSF_IN_CLASS_ATTR && \
			 t_src_class(b.File) == VSF_IN_CLASS_ATTR))) \
			 
#define ZERO_SRC_0 MAKE_VSF_SOURCE(t_src_index(vp, &src[0]), \
				   SWIZZLE_ZERO, SWIZZLE_ZERO, \
				   SWIZZLE_ZERO, SWIZZLE_ZERO, \
				   t_src_class(src[0].File), VSF_FLAG_NONE)
				   
#define ZERO_SRC_1 MAKE_VSF_SOURCE(t_src_index(vp, &src[1]), \
				   SWIZZLE_ZERO, SWIZZLE_ZERO, \
				   SWIZZLE_ZERO, SWIZZLE_ZERO, \
				   t_src_class(src[1].File), VSF_FLAG_NONE)

#define ZERO_SRC_2 MAKE_VSF_SOURCE(t_src_index(vp, &src[2]), \
				   SWIZZLE_ZERO, SWIZZLE_ZERO, \
				   SWIZZLE_ZERO, SWIZZLE_ZERO, \
				   t_src_class(src[2].File), VSF_FLAG_NONE)
				   
#define ONE_SRC_0 MAKE_VSF_SOURCE(t_src_index(vp, &src[0]), \
				   SWIZZLE_ONE, SWIZZLE_ONE, \
				   SWIZZLE_ONE, SWIZZLE_ONE, \
				   t_src_class(src[0].File), VSF_FLAG_NONE)
				   
#define ONE_SRC_1 MAKE_VSF_SOURCE(t_src_index(vp, &src[1]), \
				   SWIZZLE_ONE, SWIZZLE_ONE, \
				   SWIZZLE_ONE, SWIZZLE_ONE, \
				   t_src_class(src[1].File), VSF_FLAG_NONE)

#define ONE_SRC_2 MAKE_VSF_SOURCE(t_src_index(vp, &src[2]), \
				   SWIZZLE_ONE, SWIZZLE_ONE, \
				   SWIZZLE_ONE, SWIZZLE_ONE, \
				   t_src_class(src[2].File), VSF_FLAG_NONE)
				   
/* DP4 version seems to trigger some hw peculiarity */
//#define PREFER_DP4

#define FREE_TEMPS() \
	do { \
		if(u_temp_i < vp->num_temporaries) { \
			WARN_ONCE("Ran out of temps, num temps %d, us %d\n", vp->num_temporaries, u_temp_i); \
			vp->native = GL_FALSE; \
		} \
		u_temp_i=VSF_MAX_FRAGMENT_TEMPS-1; \
	} while (0)

void r300_translate_vertex_shader(struct r300_vertex_program *vp)
{
	struct vertex_program *mesa_vp=(void *)vp;
	struct prog_instruction *vpi;
	int i, cur_reg=0;
	VERTEX_SHADER_INSTRUCTION *o_inst;
	unsigned long operands;
	int are_srcs_scalar;
	unsigned long hw_op;
	/* Initial value should be last tmp reg that hw supports.
	   Strangely enough r300 doesnt mind even though these would be out of range.
	   Smart enough to realize that it doesnt need it? */
	int u_temp_i=VSF_MAX_FRAGMENT_TEMPS-1;
	struct prog_src_register src[3];

	if (getenv("R300_VP_SAFETY")) {
		WARN_ONCE("R300_VP_SAFETY enabled.\n");
		
		vpi = malloc((mesa_vp->Base.NumInstructions + VSF_MAX_FRAGMENT_TEMPS) * sizeof(struct prog_instruction));
		memset(vpi, 0, VSF_MAX_FRAGMENT_TEMPS * sizeof(struct prog_instruction));
		
		for (i=0; i < VSF_MAX_FRAGMENT_TEMPS; i++) {
			vpi[i].Opcode = OPCODE_MOV;
			vpi[i].StringPos = 0;
			vpi[i].Data = 0;
			
			vpi[i].DstReg.File = PROGRAM_TEMPORARY;
			vpi[i].DstReg.Index = i;
			vpi[i].DstReg.WriteMask = WRITEMASK_XYZW;
			vpi[i].DstReg.CondMask = COND_TR;
					
			vpi[i].SrcReg[0].File = PROGRAM_STATE_VAR;
			vpi[i].SrcReg[0].Index = 0;
			vpi[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_ONE, SWIZZLE_ONE, SWIZZLE_ONE, SWIZZLE_ONE);
		}
		
		memcpy(&vpi[i], mesa_vp->Base.Instructions, mesa_vp->Base.NumInstructions * sizeof(struct prog_instruction));
		
		free(mesa_vp->Base.Instructions);
		
		mesa_vp->Base.Instructions = vpi;
		
		mesa_vp->Base.NumInstructions += VSF_MAX_FRAGMENT_TEMPS;
		vpi = &mesa_vp->Base.Instructions[mesa_vp->Base.NumInstructions-1];
		
		assert(vpi->Opcode == OPCODE_END);
	}
	
	if (mesa_vp->IsPositionInvariant) {
		struct program_parameter_list *paramList;
		GLint tokens[6] = { STATE_MATRIX, STATE_MVP, 0, 0, 0, STATE_MATRIX };

#ifdef PREFER_DP4
		tokens[5] = STATE_MATRIX;
#else
		tokens[5] = STATE_MATRIX_TRANSPOSE;
#endif
		paramList = mesa_vp->Base.Parameters;
		
		vpi = malloc((mesa_vp->Base.NumInstructions + 4) * sizeof(struct prog_instruction));
		memset(vpi, 0, 4 * sizeof(struct prog_instruction));
		
		for (i=0; i < 4; i++) {
			GLint idx;
			tokens[3] = tokens[4] = i;
			idx = _mesa_add_state_reference(paramList, tokens);
#ifdef PREFER_DP4
			vpi[i].Opcode = OPCODE_DP4;
			vpi[i].StringPos = 0;
			vpi[i].Data = 0;
			
			vpi[i].DstReg.File = PROGRAM_OUTPUT;
			vpi[i].DstReg.Index = VERT_RESULT_HPOS;
			vpi[i].DstReg.WriteMask = 1 << i;
			vpi[i].DstReg.CondMask = COND_TR;
					
			vpi[i].SrcReg[0].File = PROGRAM_STATE_VAR;
			vpi[i].SrcReg[0].Index = idx;
			vpi[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
			
			vpi[i].SrcReg[1].File = PROGRAM_INPUT;
			vpi[i].SrcReg[1].Index = VERT_ATTRIB_POS;
			vpi[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
#else
			if (i == 0)
				vpi[i].Opcode = OPCODE_MUL;
			else
				vpi[i].Opcode = OPCODE_MAD;
			
			vpi[i].StringPos = 0;
			vpi[i].Data = 0;
			
			if (i == 3)
				vpi[i].DstReg.File = PROGRAM_OUTPUT;
			else
				vpi[i].DstReg.File = PROGRAM_TEMPORARY;
			vpi[i].DstReg.Index = 0;
			vpi[i].DstReg.WriteMask = 0xf;
			vpi[i].DstReg.CondMask = COND_TR;
					
			vpi[i].SrcReg[0].File = PROGRAM_STATE_VAR;
			vpi[i].SrcReg[0].Index = idx;
			vpi[i].SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
			
			vpi[i].SrcReg[1].File = PROGRAM_INPUT;
			vpi[i].SrcReg[1].Index = VERT_ATTRIB_POS;
			vpi[i].SrcReg[1].Swizzle = MAKE_SWIZZLE4(i, i, i, i);
			
			if (i > 0) {
				vpi[i].SrcReg[2].File = PROGRAM_TEMPORARY;
				vpi[i].SrcReg[2].Index = 0;
				vpi[i].SrcReg[2].Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W);
			}
#endif					
		}
		
		memcpy(&vpi[i], mesa_vp->Base.Instructions, mesa_vp->Base.NumInstructions * sizeof(struct prog_instruction));
		
		free(mesa_vp->Base.Instructions);
		
		mesa_vp->Base.Instructions = vpi;
		
		mesa_vp->Base.NumInstructions += 4;
		vpi = &mesa_vp->Base.Instructions[mesa_vp->Base.NumInstructions-1];
		
		assert(vpi->Opcode == OPCODE_END);
		
		mesa_vp->Base.InputsRead |= (1 << VERT_ATTRIB_POS);
		mesa_vp->Base.OutputsWritten |= (1 << VERT_RESULT_HPOS);
		
		//fprintf(stderr, "IsPositionInvariant is set!\n");
		//_mesa_print_program(&mesa_vp->Base);
	}
	
	vp->pos_end=0; /* Not supported yet */
	vp->program.length=0;
	vp->num_temporaries=mesa_vp->Base.NumTemporaries;
	
	for(i=0; i < VERT_ATTRIB_MAX; i++)
		vp->inputs[i] = -1;

	for(i=0; i < VERT_RESULT_MAX; i++)
		vp->outputs[i] = -1;
	
	assert(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_HPOS));
	
	/* Assign outputs */
	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_HPOS))
		vp->outputs[VERT_RESULT_HPOS] = cur_reg++;
	
	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_PSIZ))
		vp->outputs[VERT_RESULT_PSIZ] = cur_reg++;
	
	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_COL0))
		vp->outputs[VERT_RESULT_COL0] = cur_reg++;
	
	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_COL1))
		vp->outputs[VERT_RESULT_COL1] = cur_reg++;
	
#if 0 /* Not supported yet */
	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_BFC0))
		vp->outputs[VERT_RESULT_BFC0] = cur_reg++;
	
	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_BFC1))
		vp->outputs[VERT_RESULT_BFC1] = cur_reg++;
	
	if(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_FOGC))
		vp->outputs[VERT_RESULT_FOGC] = cur_reg++;
#endif
	
	for(i=VERT_RESULT_TEX0; i <= VERT_RESULT_TEX7; i++)
		if(mesa_vp->Base.OutputsWritten & (1 << i))
			vp->outputs[i] = cur_reg++;
	
	vp->translated = GL_TRUE;
	vp->native = GL_TRUE;
	
	o_inst=vp->program.body.i;
	for(vpi=mesa_vp->Base.Instructions; vpi->Opcode != OPCODE_END; vpi++, o_inst++){
		FREE_TEMPS();
		
		operands=op_operands(vpi->Opcode);
		are_srcs_scalar=operands & SCALAR_FLAG;
		operands &= OP_MASK;
		
		for(i=0; i < operands; i++)
			src[i]=vpi->SrcReg[i];
		
		if(operands == 3){ /* TODO: scalars */
			if( CMP_SRCS(src[1], src[2]) || CMP_SRCS(src[0], src[2]) ){
				o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, u_temp_i,
						VSF_FLAG_ALL, VSF_OUT_CLASS_TMP);
				
				o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[2]),
						SWIZZLE_X, SWIZZLE_Y,
						SWIZZLE_Z, SWIZZLE_W,
						t_src_class(src[2].File), VSF_FLAG_NONE);

				o_inst->src2=ZERO_SRC_2;
				o_inst->src3=ZERO_SRC_2;
				o_inst++;
						
				src[2].File=PROGRAM_TEMPORARY;
				src[2].Index=u_temp_i;
				u_temp_i--;
			}
			
		}
		
		if(operands >= 2){
			if( CMP_SRCS(src[1], src[0]) ){
				o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, u_temp_i,
						VSF_FLAG_ALL, VSF_OUT_CLASS_TMP);
				
				o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
						SWIZZLE_X, SWIZZLE_Y,
						SWIZZLE_Z, SWIZZLE_W,
						t_src_class(src[0].File), VSF_FLAG_NONE);

				o_inst->src2=ZERO_SRC_0;
				o_inst->src3=ZERO_SRC_0;
				o_inst++;
						
				src[0].File=PROGRAM_TEMPORARY;
				src[0].Index=u_temp_i;
				u_temp_i--;
			}
		}
		
		/* These ops need special handling. */
		switch(vpi->Opcode){
		case OPCODE_ARL:
			o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ARL, t_dst_index(vp, &vpi->DstReg),
					t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
			o_inst->src1=t_src_scalar(vp, &src[0]);
			o_inst->src2=ZERO_SRC_0;
			o_inst->src3=ZERO_SRC_0;
			goto next;
			
		case OPCODE_POW:
			o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_POW, t_dst_index(vp, &vpi->DstReg),
					t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
			o_inst->src1=t_src_scalar(vp, &src[0]);
			o_inst->src2=ZERO_SRC_0;
			o_inst->src3=t_src_scalar(vp, &src[1]);
			goto next;
			
		case OPCODE_MOV://ADD RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{} {ZERO ZERO ZERO ZERO} 
#if 1
			o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, t_dst_index(vp, &vpi->DstReg),
					t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
			o_inst->src1=t_src(vp, &src[0]);
			o_inst->src2=ZERO_SRC_0;
			o_inst->src3=ZERO_SRC_0;
#else
			hw_op=(src[0].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
			
			o_inst->op=MAKE_VSF_OP(hw_op, t_dst_index(vp, &vpi->DstReg),
				t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
			o_inst->src1=t_src(vp, &src[0]);
			o_inst->src2=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
					SWIZZLE_ONE, SWIZZLE_ONE,
					SWIZZLE_ONE, SWIZZLE_ONE,
					t_src_class(src[0].File), VSF_FLAG_NONE);


			o_inst->src3=ZERO_SRC_0;
#endif			

			goto next;
			
		case OPCODE_ADD:
#if 1
			hw_op=(src[0].File == PROGRAM_TEMPORARY &&
				src[1].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
			
			o_inst->op=MAKE_VSF_OP(hw_op, t_dst_index(vp, &vpi->DstReg),
				t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
			o_inst->src1=ONE_SRC_0;
			o_inst->src2=t_src(vp, &src[0]);
			o_inst->src3=t_src(vp, &src[1]);
#else