#include "radeon_reg.h"
#include "r300_reg.h"
#include "r300_cmdbuf.h"
+#include "r300_emit.h"
// Set this to 1 for extremely verbose debugging of command buffers
r300->hw.all_dirty = GL_FALSE;
}
+#if 0
static __inline__ uint32_t cmducs(int reg, int count)
{
return cmd.u;
}
+#endif
#define CHECK( NM, COUNT ) \
static int check_##NM( r300ContextPtr r300, \
cmd[0].wait.flags = flags;
}
}
+
+void r300EmitLOAD_VBPNTR(r300ContextPtr rmesa, int start)
+{
+int i, a, count;
+GLuint dw;
+LOCAL_VARS
+
+count=rmesa->state.aos_count;
+
+a=1+(count>>1)*3+(count & 1)*2;
+start_packet3(RADEON_CP_PACKET3_3D_LOAD_VBPNTR, a-1);
+e32(count);
+for(i=0;i+1<count;i+=2){
+ e32( (rmesa->state.aos[i].element_size << 0)
+ |(rmesa->state.aos[i].stride << 8)
+ |(rmesa->state.aos[i+1].element_size << 16)
+ |(rmesa->state.aos[i+1].stride << 24)
+ );
+ e32(rmesa->state.aos[i].offset+start*4*rmesa->state.aos[i].stride);
+ e32(rmesa->state.aos[i+1].offset+start*4*rmesa->state.aos[i+1].stride);
+ }
+if(count & 1){
+ e32( (rmesa->state.aos[count-1].element_size << 0)
+ |(rmesa->state.aos[count-1].stride << 8)
+ );
+ e32(rmesa->state.aos[count-1].offset+start*4*rmesa->state.aos[count-1].stride);
+ }
+
+/* delay ? */
+#if 0
+e32(RADEON_CP_PACKET2);
+e32(RADEON_CP_PACKET2);
+#endif
+}
+
+void static inline upload_vertex_shader_fragment(PREFIX int dest, struct r300_vertex_shader_fragment *vsf)
+{
+int i;
+LOCAL_VARS
+
+if(vsf->length==0)return;
+
+if(vsf->length & 0x3){
+ fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
+ exit(-1);
+ }
+
+vsf_start_fragment(dest, vsf->length);
+for(i=0;i<vsf->length;i++)
+ e32(vsf->body.d[i]);
+
+}
+
+void r300EmitVertexShader(r300ContextPtr rmesa)
+{
+LOCAL_VARS
+
+upload_vertex_shader_fragment(PASS_PREFIX VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
+
+upload_vertex_shader_fragment(PASS_PREFIX VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
+upload_vertex_shader_fragment(PASS_PREFIX VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
+upload_vertex_shader_fragment(PASS_PREFIX VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
+
+upload_vertex_shader_fragment(PASS_PREFIX VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
+upload_vertex_shader_fragment(PASS_PREFIX VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
+
+upload_vertex_shader_fragment(PASS_PREFIX VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
+upload_vertex_shader_fragment(PASS_PREFIX VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
+
+reg_start(R300_VAP_PVS_CNTL_1, 2);
+e32( (rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
+ | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
+ | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT)
+ );
+e32( (rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
+ | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT)
+ );
+e32( (rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
+ | (rmesa->state.vertex_shader.unknown_ptr3 << 0));
+
+reg_start(R300_VAP_PVS_WAITIDLE,0);
+ e32(0x00000000);
+}
+
+void r300EmitPixelShader(r300ContextPtr rmesa)
+{
+int i,k;
+LOCAL_VARS
+
+if(rmesa->state.pixel_shader.program.tex.length>0){
+ reg_start(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length-1);
+ for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
+ e32(rmesa->state.pixel_shader.program.tex.inst[i]);
+ }
+
+if(rmesa->state.pixel_shader.program.alu.length>0){
+ #define OUTPUT_FIELD(reg, field) \
+ reg_start(reg,rmesa->state.pixel_shader.program.alu.length-1); \
+ for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
+ e32(rmesa->state.pixel_shader.program.alu.inst[i].field);
+
+ OUTPUT_FIELD(R300_PFS_INSTR0_0, inst0);
+ OUTPUT_FIELD(R300_PFS_INSTR1_0, inst1);
+ OUTPUT_FIELD(R300_PFS_INSTR2_0, inst2);
+ OUTPUT_FIELD(R300_PFS_INSTR3_0, inst3);
+ #undef OUTPUT_FIELD
+ }
+
+reg_start(R300_PFS_NODE_0, 3);
+for(i=0;i<4;i++){
+ e32( (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
+ | (rmesa->state.pixel_shader.program.node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
+ | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
+ | (rmesa->state.pixel_shader.program.node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
+ | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0)
+ );
+ }
+
+reg_start(R300_PFS_CNTL_0, 2);
+ /* PFS_CNTL_0 */
+e32((rmesa->state.pixel_shader.program.active_nodes-1) | (rmesa->state.pixel_shader.program.first_node_has_tex<<3));
+ /* PFS_CNTL_1 */
+e32(rmesa->state.pixel_shader.program.temp_register_count);
+ /* PFS_CNTL_2 */
+e32( (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
+ | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
+ | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
+ | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT)
+ );
+
+if(rmesa->state.pixel_shader.param_length>0){
+ reg_start(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length*4-1);
+ for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
+ efloat(rmesa->state.pixel_shader.param[i].x);
+ efloat(rmesa->state.pixel_shader.param[i].y);
+ efloat(rmesa->state.pixel_shader.param[i].z);
+ efloat(rmesa->state.pixel_shader.param[i].w);
+ }
+ }
+
+}
#include "radeon_lock.h"
#include "mm.h"
+
typedef GLuint uint32_t;
typedef GLubyte uint8_t;
+ /* We should probably change types within vertex_shader
+ and pixel_shader structure later on */
+#define CARD32 GLuint
+#include "vertex_shader.h"
+#include "pixel_shader.h"
+#undef CARD32
static __inline__ uint32_t r300PackFloat32(float fl)
{
struct r300_state_atom vof; /* VAP output format register 0x4000 */
struct r300_state_atom gb_enable; /* (4008) */
struct r300_state_atom gb_misc; /* Multisampling position shifts ? (4010) */
- struct r300_state_atom txe; /* tex enable (4104) */
struct r300_state_atom unk4200; /* (4200) */
struct r300_state_atom unk4214; /* (4214) */
struct r300_state_atom ps; /* pointsize (421C) */
struct r300_state_atom unknown4;
struct r300_state_atom unknown5;
} tex;
+ struct r300_state_atom txe; /* tex enable (4104) */
};
GLfloat scale;
};
+struct r300_vap_reg_state {
+ /* input register assigments */
+ int i_coords;
+ int i_color[2];
+ int i_tex[R300_MAX_TEXTURE_UNITS];
+ };
+
+/* Vertex shader state */
+
+/* 64 appears to be the maximum */
+#define VSF_MAX_FRAGMENT_LENGTH 64
+
+
+struct r300_vertex_shader_fragment {
+ int length;
+ union {
+ GLuint d[VSF_MAX_FRAGMENT_LENGTH];
+ float f[VSF_MAX_FRAGMENT_LENGTH];
+ VERTEX_SHADER_INSTRUCTION i[VSF_MAX_FRAGMENT_LENGTH/4];
+ } body;
+ };
+
+#define VSF_DEST_PROGRAM 0x0
+#define VSF_DEST_MATRIX0 0x200
+#define VSF_DEST_MATRIX1 0x204
+#define VSF_DEST_MATRIX2 0x208
+#define VSF_DEST_VECTOR0 0x20c
+#define VSF_DEST_VECTOR1 0x20d
+#define VSF_DEST_UNKNOWN1 0x400
+#define VSF_DEST_UNKNOWN2 0x406
+
+struct r300_vertex_shader_state {
+ struct r300_vertex_shader_fragment program;
+
+ /* a bit of a waste - each uses only a subset of allocated space..
+ but easier to program */
+ struct r300_vertex_shader_fragment matrix[3];
+ struct r300_vertex_shader_fragment vector[2];
+
+ struct r300_vertex_shader_fragment unknown1;
+ struct r300_vertex_shader_fragment unknown2;
+
+ int program_start;
+ int unknown_ptr1; /* pointer within program space */
+ int program_end;
+
+ int param_offset;
+ int param_count;
+
+ int unknown_ptr2; /* pointer within program space */
+ int unknown_ptr3; /* pointer within program space */
+ };
+
+/* 64 appears to be the maximum */
+#define PSF_MAX_PROGRAM_LENGTH 64
+
+struct r300_pixel_shader_program {
+ struct {
+ int length;
+ GLuint inst[PSF_MAX_PROGRAM_LENGTH];
+ } tex;
+
+ /* ALU intructions (logic and integer) */
+ struct {
+ int length;
+ struct {
+ GLuint inst0;
+ GLuint inst1;
+ GLuint inst2;
+ GLuint inst3;
+ } inst[PSF_MAX_PROGRAM_LENGTH];
+ } alu;
+
+ /* node information */
+ /* nodes are used to synchronize ALU and TEX streams */
+ /* There could be up to 4 nodes each consisting of
+ a number of TEX instructions followed by some ALU
+ instructions */
+ /* the last node of a program should always be node3 */
+ struct {
+ int tex_offset;
+ int tex_end;
+ int alu_offset;
+ int alu_end;
+ } node[4];
+
+ int active_nodes; /* must be between 1 and 4, inclusive */
+ int first_node_has_tex; /* other nodes always have it */
+
+ int temp_register_count; /* magic value goes into PFS_CNTL_1 */
+
+ /* entire program */
+ int tex_offset;
+ int tex_end;
+ int alu_offset;
+ int alu_end;
+
+ };
+
+ #define MAX_PIXEL_SHADER_PARAMS 32
+struct r300_pixel_shader_state {
+ struct r300_pixel_shader_program program;
+
+ /* parameters */
+ int param_length; /* to limit the number of unnecessary writes */
+ struct {
+ float x;
+ float y;
+ float z;
+ float w;
+ } param[MAX_PIXEL_SHADER_PARAMS];
+ };
+
+/* 8 is somewhat bogus... it is probably something like 24 */
+#define R300_MAX_AOS_ARRAYS 8
+
+struct r300_aos_rec {
+ GLuint offset;
+ int element_size; /* in dwords */
+ int stride; /* distance between elements, in dwords */
+
+ #define AOS_FORMAT_FLOAT 1
+ #define AOS_FORMAT_UBYTE 2
+ #define AOS_FORMAT_FLOAT_COLOR 3
+ int format;
+
+ int ncomponents; /* number of components - between 1 and 4, inclusive */
+
+ /* just guesses */
+ #define REG_COORDS 0
+ #define REG_COLOR0 1
+ #define REG_TEX0 2
+ int reg; /* which register they are assigned to. */
+
+ };
+
struct r300_state {
struct r300_depthbuffer_state depth;
struct r300_texture_state texture;
+ struct r300_vap_reg_state vap_reg;
+ struct r300_vertex_shader_state vertex_shader;
+ struct r300_pixel_shader_state pixel_shader;
+ struct r300_aos_rec aos[R300_MAX_AOS_ARRAYS];
+ int aos_count;
+
};
return type;
}
+/* This function compiles GL context into state registers that
+ describe data routing inside of R300 pipeline.
+
+ In particular, it programs input_route, output_vtx_fmt, texture
+ unit configuration and gb_output_vtx_fmt
+
+ This function encompasses setup_AOS() from r300_lib.c
+*/
+
+
+
+static void inline r300_setup_routing(r300ContextPtr r300, GLcontext *ctx, GLboolean immediate)
+{
+int i, count=0,reg=0;
+GLuint dw, mask;
+TNLcontext *tnl = TNL_CONTEXT(ctx);
+struct vertex_buffer *VB = &tnl->vb;
+
+
+/* Stage 1 - input to VAP */
+
+/* Assign register number automatically, retaining it in rmesa->state.reg */
+
+ /* Note: immediate vertex data includes all coordinates.
+ To save bandwidth use either VBUF or state-based vertex generation */
+
+#define CONFIGURE_AOS(v, o, r, f) \
+ {\
+ if(immediate){ \
+ r300->state.aos[count].element_size=4; \
+ r300->state.aos[count].stride=4; \
+ r300->state.aos[count].ncomponents=4; \
+ } else { \
+ r300->state.aos[count].element_size=v->size; \
+ r300->state.aos[count].stride=v->size; \
+ r300->state.aos[count].ncomponents=v->size; \
+ } \
+ r300->state.aos[count].offset=o; \
+ r300->state.aos[count].reg=reg; \
+ r300->state.aos[count].format=(f); \
+ r300->state.vap_reg.r=reg; \
+ count++; \
+ reg++; \
+ }
+
+ /* All offsets are 0 - for use by immediate mode.
+ Should change later to handle vertex buffers */
+CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
+CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
+for(i=0;i < ctx->Const.MaxTextureUnits;i++)
+ if(ctx->Texture.Unit[i].Enabled)
+ CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
+
+r300->state.aos_count=count;
+if(count>R300_MAX_AOS_ARRAYS){
+ fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
+ exit(-1);
+ }
+
+/* Implement AOS */
+
+
+/* setup INPUT_ROUTE */
+
+R300_STATECHANGE(r300, vir[0]);
+for(i=0;i+1<count;i+=2){
+ dw=(r300->state.aos[i].ncomponents-1)
+ | ((r300->state.aos[i].reg)<<8)
+ | (r300->state.aos[i].format<<14)
+ | (((r300->state.aos[i+1].ncomponents-1)
+ | ((r300->state.aos[i+1].reg)<<8)
+ | (r300->state.aos[i+1].format<<14))<<16);
+
+ if(i+2==count){
+ dw|=(1<<(13+16));
+ }
+ r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
+ }
+if(count & 1){
+ dw=(r300->state.aos[count-1].ncomponents-1)
+ | (r300->state.aos[count-1].format<<14)
+ | ((r300->state.aos[count-1].reg)<<8)
+ | (1<<13);
+ r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=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);
+
+/* 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+1<count;i+=2){
+ /* do i first.. */
+ mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
+ dw=(ALL_COMPONENTS & mask)
+ | (ALL_DEFAULT & ~mask)
+ | R300_INPUT_ROUTE_ENABLE;
+
+ /* i+1 */
+ mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
+ dw|=(
+ (ALL_COMPONENTS & mask)
+ | (ALL_DEFAULT & ~mask)
+ | R300_INPUT_ROUTE_ENABLE
+ )<<16;
+
+ r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
+ }
+if(count & 1){
+ mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
+ dw=(ALL_COMPONENTS & mask)
+ | (ALL_DEFAULT & ~mask)
+ | R300_INPUT_ROUTE_ENABLE;
+ r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=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);
+
+/* Set up input_cntl */
+
+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]=R300_INPUT_CNTL_POS
+ | R300_INPUT_CNTL_COLOR;
+
+for(i=0;i < ctx->Const.MaxTextureUnits;i++)
+ if(ctx->Texture.Unit[i].Enabled)
+ r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
+
+/* Stage 3: VAP output */
+R300_STATECHANGE(r300, vof);
+r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
+ | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
+
+r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
+for(i=0;i < ctx->Const.MaxTextureUnits;i++)
+ if(ctx->Texture.Unit[i].Enabled)
+ r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
+}
+
+static inline void r300_setup_textures(r300ContextPtr r300, GLcontext *ctx)
+{
+int i;
+struct r300_tex_obj *t;
+
+R300_STATECHANGE(r300, txe);
+R300_STATECHANGE(r300, tex.filter);
+R300_STATECHANGE(r300, tex.unknown1);
+R300_STATECHANGE(r300, tex.size);
+R300_STATECHANGE(r300, tex.format);
+R300_STATECHANGE(r300, tex.offset);
+R300_STATECHANGE(r300, tex.unknown4);
+R300_STATECHANGE(r300, tex.unknown5);
+
+r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
+
+for(i=0;i<R300_MAX_TEXTURE_UNITS;i++){
+ if((t=r300->state.texture.unit[i].texobj)!=NULL){
+ r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
+
+ r300->hw.tex.filter.cmd[R300_TEX_CMD_0+i]=t->filter;
+ r300->hw.tex.unknown1.cmd[R300_TEX_CMD_0+i]=t->pitch;
+ r300->hw.tex.size.cmd[R300_TEX_CMD_0+i]=t->size;
+ r300->hw.tex.format.cmd[R300_TEX_CMD_0+i]=t->format;
+ r300->hw.tex.offset.cmd[R300_TEX_CMD_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
+ r300->hw.tex.unknown4.cmd[R300_TEX_CMD_0+i]=0x0;
+ r300->hw.tex.unknown5.cmd[R300_TEX_CMD_0+i]=0x0;
+
+ /* We don't know how to set this yet */
+ r300->hw.tex.format.cmd[R300_TEX_CMD_0+i]=0x88a0c;
+ }
+ }
+}
/* Immediate implementation - vertex data is sent via command stream */
}
+static void assign_pipeline(r300ContextPtr rmesa, R300_PIPELINE *p)
+{
+ /* Watch out ! This is buggy .. but will do for now */
+
+ /* At least one sanity check is in order */
+ if(sizeof(rmesa->state.vertex_shader) != sizeof(p->vertex_shader)){
+ fprintf(stderr, "Aieee ! vertex_shader sizes don't match.\n");
+ exit(-1);
+ }
+ if(sizeof(rmesa->state.pixel_shader) != sizeof(p->pixel_shader)){
+ fprintf(stderr, "Aieee ! vertex_shader sizes don't match.\n");
+ exit(-1);
+ }
+
+ memcpy(&rmesa->state.vertex_shader, &(p->vertex_shader), sizeof(rmesa->state.vertex_shader));
+ memcpy(&rmesa->state.pixel_shader, &(p->pixel_shader), sizeof(rmesa->state.pixel_shader));
+
+}
+
static GLboolean r300_run_flat_render(GLcontext *ctx,
struct tnl_pipeline_stage *stage)
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb;
GLuint i;
- AOS_DATA vb_arrays[2];
LOCAL_VARS
/* Flush state - make sure command buffer is nice and large */
if (RADEON_DEBUG == DEBUG_PRIMS)
fprintf(stderr, "%s\n", __FUNCTION__);
- /* setup array of structures data */
-
- /* Note: immediate vertex data includes all coordinates.
- To save bandwidth use either VBUF or state-based vertex generation */
- /* xyz */
- vb_arrays[0].element_size=4;
- vb_arrays[0].stride=4;
- vb_arrays[0].offset=0; /* Not used */
- vb_arrays[0].format=AOS_FORMAT_FLOAT;
- vb_arrays[0].ncomponents=4;
- vb_arrays[0].reg=REG_COORDS;
-
- /* color */
- vb_arrays[1].element_size=4;
- vb_arrays[1].stride=4;
- vb_arrays[1].offset=0; /* Not used */
- vb_arrays[1].format=AOS_FORMAT_FLOAT_COLOR;
- vb_arrays[1].ncomponents=4;
- vb_arrays[1].reg=REG_COLOR0;
-
-
/* needed before starting 3d operation .. */
reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
e32(0x0000000a);
| R300_VPORT_Y_OFFSET_ENA
| R300_VTX_W0_FMT;
R300_STATECHANGE(rmesa, vte);
-
+
+ r300_setup_routing(rmesa, ctx, GL_TRUE);
+ r300_setup_textures(rmesa, ctx);
+
r300EmitState(rmesa);
- FLAT_COLOR_PIPELINE.vertex_shader.matrix[0].length=16;
- memcpy(FLAT_COLOR_PIPELINE.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
-
- FLAT_COLOR_PIPELINE.vertex_shader.unknown2.length=4;
- FLAT_COLOR_PIPELINE.vertex_shader.unknown2.body.f[0]=0.0;
- FLAT_COLOR_PIPELINE.vertex_shader.unknown2.body.f[1]=0.0;
- FLAT_COLOR_PIPELINE.vertex_shader.unknown2.body.f[2]=1.0;
- FLAT_COLOR_PIPELINE.vertex_shader.unknown2.body.f[3]=0.0;
+ assign_pipeline(rmesa, &FLAT_COLOR_PIPELINE);
- program_pipeline(PASS_PREFIX &FLAT_COLOR_PIPELINE);
+ rmesa->state.vertex_shader.matrix[0].length=16;
+ memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
+
+ rmesa->state.vertex_shader.unknown2.length=4;
+ rmesa->state.vertex_shader.unknown2.body.f[0]=0.0;
+ rmesa->state.vertex_shader.unknown2.body.f[1]=0.0;
+ rmesa->state.vertex_shader.unknown2.body.f[2]=1.0;
+ rmesa->state.vertex_shader.unknown2.body.f[3]=0.0;
- /* We need LOAD_VBPNTR to setup AOS_ATTR fields.. the offsets are irrelevant */
- setup_AOS(PASS_PREFIX vb_arrays, 2);
+ r300EmitVertexShader(rmesa);
+ r300EmitPixelShader(rmesa);
+
+ /* We need LOAD_VBPNTR to setup AOS_ATTR fields.. the offsets are irrelevant */
+ r300EmitLOAD_VBPNTR(rmesa, 0);
for(i=0; i < VB->PrimitiveCount; i++){
GLuint prim = VB->Primitive[i].mode;
/* We use the start part of GART texture buffer for vertices */
-/* 8 is somewhat bogus... it is probably something like 24 */
-#define R300_MAX_AOS_ARRAYS 8
static void upload_vertex_buffer(r300ContextPtr rmesa,
GLcontext *ctx, AOS_DATA *array, int *n_arrays)
reg_start(0x4f18,0);
e32(0x00000003);
+ r300_setup_routing(rmesa, ctx, GL_FALSE);
+
r300EmitState(rmesa);
FLAT_COLOR_PIPELINE.vertex_shader.matrix[0].length=16;
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb;
GLuint i;
- AOS_DATA vb_arrays[3];
/* Only do 2d textures */
struct gl_texture_object *to=ctx->Texture.Unit[0].Current2D;
r300TexObjPtr t=to->DriverData;
All the time for now.. */
r300UpdateTextureState(ctx);
+ r300_setup_routing(rmesa, ctx, GL_TRUE);
+ r300_setup_textures(rmesa, ctx);
+ exit(-1);
+
/* Flush state - make sure command buffer is nice and large */
r300Flush(ctx);
if (RADEON_DEBUG == DEBUG_PRIMS)
fprintf(stderr, "%s\n", __FUNCTION__);
- /* setup array of structures data */
-
- /* Note: immediate vertex data includes all coordinates.
- To save bandwidth use either VBUF or state-based vertex generation */
- /* xyzw */
- vb_arrays[0].element_size=4;
- vb_arrays[0].stride=4;
- vb_arrays[0].offset=0; /* Not used */
- vb_arrays[0].format=AOS_FORMAT_FLOAT;
- vb_arrays[0].ncomponents=4;
- vb_arrays[0].reg=REG_COORDS;
-
- /* color */
- vb_arrays[1].element_size=4;
- vb_arrays[1].stride=4;
- vb_arrays[1].offset=0; /* Not used */
- vb_arrays[1].format=AOS_FORMAT_FLOAT_COLOR;
- vb_arrays[1].ncomponents=4;
- vb_arrays[1].reg=REG_COLOR0;
-
- /* texture coordinates */
- vb_arrays[2].element_size=4;
- vb_arrays[2].stride=4;
- vb_arrays[2].offset=0; /* Not used */
- vb_arrays[2].format=AOS_FORMAT_FLOAT;
- vb_arrays[2].ncomponents=4;
- vb_arrays[2].reg=REG_TEX0;
-
/* needed before starting 3d operation .. */
reg_start(R300_RB3D_DSTCACHE_CTLSTAT,0);
SINGLE_TEXTURE_PIPELINE.texture_unit[0].filter=t->filter;
- /* Upload texture, a hack, really we can do a lot better */
- #if 0
- memcpy(rsp->gartTextures.map, to->Image[0][0]->Data, to->Image[0][0]->RowStride*to->Image[0][0]->Height*4);
- #endif
-
/* Program RS unit. This needs to be moved into R300 pipeline */
reg_start(R300_RS_CNTL_0,1);
/* R300_RS_CNTL_0(4300) */
program_pipeline(PASS_PREFIX &SINGLE_TEXTURE_PIPELINE);
/* We need LOAD_VBPNTR to setup AOS_ATTR fields.. the offsets are irrelevant */
- setup_AOS(PASS_PREFIX vb_arrays, 3);
+ r300EmitLOAD_VBPNTR(rmesa, 0);
for(i=0; i < VB->PrimitiveCount; i++){
GLuint prim = VB->Primitive[i].mode;
if (RADEON_DEBUG == DEBUG_PRIMS)
fprintf(stderr, "%s\n", __FUNCTION__);
+
#if 1
/* Just switch between pipelines.. We could possibly do better.. (?) */
if(ctx->Texture.Unit[0].Enabled)
//FALLBACK_IF(ctx->Color.DitherFlag);
/* I'm almost certain I forgot something here */
+ #if 0 /* This should work now.. */
FALLBACK_IF(ctx->Color.AlphaEnabled); // GL_ALPHA_TEST
+ #endif
FALLBACK_IF(ctx->Color.BlendEnabled); // GL_BLEND
FALLBACK_IF(ctx->Fog.Enabled); // GL_FOG
FALLBACK_IF(ctx->Line.SmoothFlag); // GL_LINE_SMOOTH
projects / mesa.git / commitdiff