r300_maos.c

mesa-6.5-minigui源码

			inputs |= _TNL_BIT_FOG;
			rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_FOG];
		}
		if(ctx->Const.MaxTextureUnits > 8) { /* Not sure if this can even happen... */
			fprintf(stderr, "%s: Cant handle that many inputs\n", __FUNCTION__);
			exit(-1);
		}
		for (i=0;i<ctx->Const.MaxTextureUnits;i++) {
			if (InputsRead & (1<<(VERT_ATTRIB_TEX0+i))) {
				inputs |= _TNL_BIT_TEX0<<i;
				rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_TEX0+i];
			}
		}
		nr = 0;
	} else {
		inputs = TNL_CONTEXT(ctx)->render_inputs;
	}
	rmesa->state.render_inputs = inputs;

	if (inputs & _TNL_BIT_POS) {
		CONFIGURE_AOS(i_coords,	AOS_FORMAT_FLOAT,
						VB->AttribPtr[VERT_ATTRIB_POS],
						immd ? 4 : VB->AttribPtr[VERT_ATTRIB_POS].size,
						count);

		vic_1 |= R300_INPUT_CNTL_POS;
	}

	if (inputs & _TNL_BIT_NORMAL) {
		CONFIGURE_AOS(i_normal,	AOS_FORMAT_FLOAT,
						VB->AttribPtr[VERT_ATTRIB_NORMAL],
						immd ? 4 : VB->AttribPtr[VERT_ATTRIB_NORMAL].size,
						count);

		vic_1 |= R300_INPUT_CNTL_NORMAL;
	}

	if (inputs & _TNL_BIT_COLOR0) {
		int emitsize=4;

		if (!immd) {
			if (VB->AttribPtr[VERT_ATTRIB_COLOR0].size == 4 &&
			    (VB->AttribPtr[VERT_ATTRIB_COLOR0].stride != 0 ||
			     ((float*)VB->AttribPtr[VERT_ATTRIB_COLOR0].data)[3] != 1.0)) {
				emitsize = 4;
			} else {
				emitsize = 3;
			}//emitsize = VB->AttribPtr[VERT_ATTRIB_COLOR0].size;
		}
		if(VB->AttribPtr[VERT_ATTRIB_COLOR0].type == GL_UNSIGNED_BYTE)
			emitsize = 1;

		CONFIGURE_AOS(i_color[0], VB->AttribPtr[VERT_ATTRIB_COLOR0].type == GL_UNSIGNED_BYTE ? AOS_FORMAT_UBYTE : AOS_FORMAT_FLOAT_COLOR,
						VB->AttribPtr[VERT_ATTRIB_COLOR0],
						immd ? 4 : emitsize,
						count);

		vic_1 |= R300_INPUT_CNTL_COLOR;
	}

	if (inputs & _TNL_BIT_COLOR1) {
		int emitsize=4;

		if (!immd) {
			if (VB->AttribPtr[VERT_ATTRIB_COLOR1].size == 4 &&
			    (VB->AttribPtr[VERT_ATTRIB_COLOR1].stride != 0 ||
			     ((float*)VB->AttribPtr[VERT_ATTRIB_COLOR1].data)[3] != 1.0)) {
				emitsize = 4;
			} else {
				emitsize = 3;
			}//emitsize = VB->AttribPtr[VERT_ATTRIB_COLOR1].size;
		}
		if(VB->AttribPtr[VERT_ATTRIB_COLOR1].type == GL_UNSIGNED_BYTE)
			emitsize = 1;

		CONFIGURE_AOS(i_color[1], VB->AttribPtr[VERT_ATTRIB_COLOR1].type == GL_UNSIGNED_BYTE ? AOS_FORMAT_UBYTE : AOS_FORMAT_FLOAT_COLOR,
						VB->AttribPtr[VERT_ATTRIB_COLOR1],
						immd ? 4 : VB->AttribPtr[VERT_ATTRIB_COLOR1].size,
						count);
	}

#if 0
	if (inputs & _TNL_BIT_FOG) {
		CONFIGURE_AOS(	AOS_FORMAT_FLOAT,
						VB->FogCoordPtr,
						immd ? 4 : VB->FogCoordPtr->size,
						count);
	}
#endif

	r300->state.texture.tc_count = 0;
	for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
		if (inputs & (_TNL_BIT_TEX0 << i)) {
			CONFIGURE_AOS(i_tex[i], AOS_FORMAT_FLOAT,
							VB->AttribPtr[VERT_ATTRIB_TEX0+i],
							immd ? 4 : VB->AttribPtr[VERT_ATTRIB_TEX0+i].size,
							count);

			vic_1 |= R300_INPUT_CNTL_TC0 << i;
			r300->state.texture.tc_count++;
		}
	}
	for(i=0; i < nr; i++)
		if(r300->state.aos[i].aos_format == 2){
			assert(r300->state.aos[i].aos_size == 1);
			r300->state.aos[i].aos_size=5;
		}
	
#define SHOW_INFO(n) do { \
	if (RADEON_DEBUG & DEBUG_ALL) { \
	fprintf(stderr, "RR[%d] - sz=%d, reg=%d, fmt=%d -- st=%d, of=0x%08x\n", \
		n, \
		r300->state.aos[n].aos_size, \
		r300->state.aos[n].aos_reg, \
		r300->state.aos[n].aos_format, \
		r300->state.aos[n].aos_stride, \
		r300->state.aos[n].aos_offset); \
	} \
} while(0);

	/* setup INPUT_ROUTE */
	R300_STATECHANGE(r300, vir[0]);
	for(i=0;i+1<nr;i+=2){
		SHOW_INFO(i)
		SHOW_INFO(i+1)
		dw=(r300->state.aos[i].aos_size-1)
		| ((r300->state.aos[i].aos_reg)<<8)
		| (r300->state.aos[i].aos_format<<14)
		| (((r300->state.aos[i+1].aos_size-1)
		| ((r300->state.aos[i+1].aos_reg)<<8)
		| (r300->state.aos[i+1].aos_format<<14))<<16);

		if(i+2==nr){
			dw|=(1<<(13+16));
			}
		r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
		}
	if(nr & 1){
		SHOW_INFO(nr-1)
		dw=(r300->state.aos[nr-1].aos_size-1)
		| (r300->state.aos[nr-1].aos_format<<14)
		| ((r300->state.aos[nr-1].aos_reg)<<8)
		| (1<<13);
		r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(nr>>1)]=dw;
		//fprintf(stderr, "vir0 dw=%08x\n", dw);
		}
	/* Set the rest of INPUT_ROUTE_0 to 0 */
	//for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
	((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->packet0.count = (nr+1)>>1;


	/* Mesa assumes that all missing components are from (0, 0, 0, 1) */
#define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
		| (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
		| (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
		| (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))

#define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
		| (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
		| (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
		| (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))

	R300_STATECHANGE(r300, vir[1]);

	for(i=0; i < nr; i++)
		if(r300->state.aos[i].aos_format == 2){
			assert(r300->state.aos[i].aos_size == 5);
			r300->state.aos[i].aos_size=/*3*/4; /* XXX */
		}
		
		
	for(i=0;i+1<nr;i+=2){
		/* do i first.. */
		mask=(1<<(r300->state.aos[i].aos_size*3))-1;
		dw=(ALL_COMPONENTS & mask)
		| (ALL_DEFAULT & ~mask)
		| R300_INPUT_ROUTE_ENABLE;

		/* i+1 */
		mask=(1<<(r300->state.aos[i+1].aos_size*3))-1;
		dw|=(
		(ALL_COMPONENTS & mask)
		| (ALL_DEFAULT & ~mask)
		| R300_INPUT_ROUTE_ENABLE
		)<<16;

		//fprintf(stderr, "vir1 dw=%08x\n", dw);
		r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
		}
	if(nr & 1){
		mask=(1<<(r300->state.aos[nr-1].aos_size*3))-1;
		dw=(ALL_COMPONENTS & mask)
		| (ALL_DEFAULT & ~mask)
		| R300_INPUT_ROUTE_ENABLE;
		r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(nr>>1)]=dw;
		//fprintf(stderr, "vir1 dw=%08x\n", dw);
		}
	/* Set the rest of INPUT_ROUTE_1 to 0 */
	//for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
	((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->packet0.count = (nr+1)>>1;

	/* Set up input_cntl */
	/* I don't think this is needed for vertex buffers, but it doesn't hurt anything */
	R300_STATECHANGE(r300, vic);
	r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555;  /* Hard coded value, no idea what it means */
	r300->hw.vic.cmd[R300_VIC_CNTL_1]=vic_1;

	for(i=0; i < nr; i++)
		if(r300->state.aos[i].aos_format == 2){
			assert(r300->state.aos[i].aos_size == /*3*/4); /* XXX */
			r300->state.aos[i].aos_size=1;
		}
#if 0
	r300->hw.vic.cmd[R300_VIC_CNTL_1]=0;

	if(r300->state.render_inputs & _TNL_BIT_POS)
		r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_POS;

	if(r300->state.render_inputs & _TNL_BIT_NORMAL)
		r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_NORMAL;

	if(r300->state.render_inputs & _TNL_BIT_COLOR0)
		r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_COLOR;

	for(i=0;i < ctx->Const.MaxTextureUnits;i++)
		if(r300->state.render_inputs & (_TNL_BIT_TEX0<<i))
			r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
#endif

	/* Stage 3: VAP output */
	
	R300_STATECHANGE(r300, vof);
	
	r300->hw.vof.cmd[R300_VOF_CNTL_0]=0;
	r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
	if (hw_tcl_on){
		GLuint OutputsWritten = CURRENT_VERTEX_SHADER(ctx)->Base.OutputsWritten;
		
		if(OutputsWritten & (1<<VERT_RESULT_HPOS))
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT;
		if(OutputsWritten & (1<<VERT_RESULT_COL0))
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
		if(OutputsWritten & (1<<VERT_RESULT_COL1))
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT;
		/*if(OutputsWritten & (1<<VERT_RESULT_BFC0))
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_2_PRESENT;
		if(OutputsWritten & (1<<VERT_RESULT_BFC1))
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_3_PRESENT;*/
		//if(OutputsWritten & (1<<VERT_RESULT_FOGC))

		if(OutputsWritten & (1<<VERT_RESULT_PSIZ))
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT;

		for(i=0;i < ctx->Const.MaxTextureUnits;i++)
			if(OutputsWritten & (1<<(VERT_RESULT_TEX0+i)))
				r300->hw.vof.cmd[R300_VOF_CNTL_1] |= (4<<(3*i));
	} else {
		if(inputs & _TNL_BIT_POS)
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT;
		if(inputs & _TNL_BIT_COLOR0)
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
		if(inputs & _TNL_BIT_COLOR1)
			r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT;

		for(i=0;i < ctx->Const.MaxTextureUnits;i++)
			if(inputs & (_TNL_BIT_TEX0<<i))
				r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
	}

	rmesa->state.aos_count = nr;
}

#ifdef USER_BUFFERS
void r300UseArrays(GLcontext * ctx)
{
	r300ContextPtr rmesa = R300_CONTEXT(ctx);
	int i;
	
	if(rmesa->state.elt_dma.buf)
		radeon_mm_use(rmesa, rmesa->state.elt_dma.buf->id);
	
	for (i=0; i < rmesa->state.aos_count;i++) {
		if (rmesa->state.aos[i].buf)
			radeon_mm_use(rmesa, rmesa->state.aos[i].buf->id);
	}
	
#ifdef HW_VBOS
	
#define USE_VBO(a) if (ctx->Array.a.BufferObj->Name && ctx->Array.a.Enabled) \
		radeon_mm_use(rmesa, ((struct r300_buffer_object *)ctx->Array.a.BufferObj)->id)
	
	if (ctx->Array.ElementArrayBufferObj->Name && ctx->Array.ElementArrayBufferObj->OnCard)
		radeon_mm_use(rmesa, ((struct r300_buffer_object *)ctx->Array.ElementArrayBufferObj)->id);
	
	USE_VBO(Vertex);
	USE_VBO(Normal);
	USE_VBO(Color);
	USE_VBO(SecondaryColor);
	USE_VBO(FogCoord);
	
	for (i=0; i < MAX_TEXTURE_COORD_UNITS; i++)
		USE_VBO(TexCoord[i]);
#endif
	
}
#endif

void r300ReleaseArrays(GLcontext * ctx)
{
	r300ContextPtr rmesa = R300_CONTEXT(ctx);
	int i;

	r300ReleaseDmaRegion(rmesa, &rmesa->state.elt_dma, __FUNCTION__);
	for (i=0;i<rmesa->state.aos_count;i++) {
		r300ReleaseDmaRegion(rmesa, &rmesa->state.aos[i], __FUNCTION__);
	}
}