2 Copyright (C) The Weather Channel, Inc. 2002.
3 Copyright (C) 2004 Nicolai Haehnle.
6 The Weather Channel (TM) funded Tungsten Graphics to develop the
7 initial release of the Radeon 8500 driver under the XFree86 license.
8 This notice must be preserved.
10 Permission is hereby granted, free of charge, to any person obtaining
11 a copy of this software and associated documentation files (the
12 "Software"), to deal in the Software without restriction, including
13 without limitation the rights to use, copy, modify, merge, publish,
14 distribute, sublicense, and/or sell copies of the Software, and to
15 permit persons to whom the Software is furnished to do so, subject to
16 the following conditions:
18 The above copyright notice and this permission notice (including the
19 next paragraph) shall be included in all copies or substantial
20 portions of the Software.
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
26 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 **************************************************************************/
34 * Nicolai Haehnle <prefect_@gmx.net>
44 #include "simple_list.h"
46 #include "api_arrayelt.h"
47 #include "swrast/swrast.h"
48 #include "swrast_setup/swrast_setup.h"
49 #include "array_cache/acache.h"
51 #include "texformat.h"
53 #include "radeon_ioctl.h"
54 #include "radeon_state.h"
55 #include "r300_context.h"
56 #include "r300_ioctl.h"
57 #include "r300_state.h"
59 #include "r300_program.h"
60 #include "r300_emit.h"
61 #include "r300_fixed_pipelines.h"
63 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
65 r300ContextPtr rmesa = R300_CONTEXT(ctx);
66 int pp_misc = rmesa->hw.at.cmd[R300_AT_ALPHA_TEST];
69 CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
71 R300_STATECHANGE(rmesa, at);
73 pp_misc &= ~(R300_ALPHA_TEST_OP_MASK | R300_REF_ALPHA_MASK);
74 pp_misc |= (refByte & R300_REF_ALPHA_MASK);
78 pp_misc |= R300_ALPHA_TEST_FAIL;
81 pp_misc |= R300_ALPHA_TEST_LESS;
84 pp_misc |= R300_ALPHA_TEST_EQUAL;
87 pp_misc |= R300_ALPHA_TEST_LEQUAL;
90 pp_misc |= R300_ALPHA_TEST_GREATER;
93 pp_misc |= R300_ALPHA_TEST_NEQUAL;
96 pp_misc |= R300_ALPHA_TEST_GEQUAL;
99 pp_misc |= R300_ALPHA_TEST_PASS;
103 rmesa->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
106 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
109 r300ContextPtr rmesa = R300_CONTEXT(ctx);
110 fprintf(stderr, "%s:%s is not implemented yet. Fixme !\n", __FILE__, __FUNCTION__);
112 R200_STATECHANGE(rmesa, ctx);
113 CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
114 CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
115 CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
116 CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
117 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor)
118 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCOLOR] =
119 radeonPackColor(4, color[0], color[1], color[2], color[3]);
124 * Calculate the hardware blend factor setting. This same function is used
125 * for source and destination of both alpha and RGB.
128 * The hardware register value for the specified blend factor. This value
129 * will need to be shifted into the correct position for either source or
130 * destination factor.
133 * Since the two cases where source and destination are handled differently
134 * are essentially error cases, they should never happen. Determine if these
135 * cases can be removed.
137 static int blend_factor(GLenum factor, GLboolean is_src)
143 func = R200_BLEND_GL_ZERO;
146 func = R200_BLEND_GL_ONE;
149 func = R200_BLEND_GL_DST_COLOR;
151 case GL_ONE_MINUS_DST_COLOR:
152 func = R200_BLEND_GL_ONE_MINUS_DST_COLOR;
155 func = R200_BLEND_GL_SRC_COLOR;
157 case GL_ONE_MINUS_SRC_COLOR:
158 func = R200_BLEND_GL_ONE_MINUS_SRC_COLOR;
161 func = R200_BLEND_GL_SRC_ALPHA;
163 case GL_ONE_MINUS_SRC_ALPHA:
164 func = R200_BLEND_GL_ONE_MINUS_SRC_ALPHA;
167 func = R200_BLEND_GL_DST_ALPHA;
169 case GL_ONE_MINUS_DST_ALPHA:
170 func = R200_BLEND_GL_ONE_MINUS_DST_ALPHA;
172 case GL_SRC_ALPHA_SATURATE:
174 (is_src) ? R200_BLEND_GL_SRC_ALPHA_SATURATE :
177 case GL_CONSTANT_COLOR:
178 func = R200_BLEND_GL_CONST_COLOR;
180 case GL_ONE_MINUS_CONSTANT_COLOR:
181 func = R200_BLEND_GL_ONE_MINUS_CONST_COLOR;
183 case GL_CONSTANT_ALPHA:
184 func = R200_BLEND_GL_CONST_ALPHA;
186 case GL_ONE_MINUS_CONSTANT_ALPHA:
187 func = R200_BLEND_GL_ONE_MINUS_CONST_ALPHA;
190 func = (is_src) ? R200_BLEND_GL_ONE : R200_BLEND_GL_ZERO;
196 * Sets both the blend equation and the blend function.
197 * This is done in a single
198 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
199 * change the interpretation of the blend function.
200 * Also, make sure that blend function and blend equation are set to their default
201 * value if color blending is not enabled, since at least blend equations GL_MIN
202 * and GL_FUNC_REVERSE_SUBTRACT will cause wrong results otherwise for
206 /* helper function */
207 static void r300_set_blend_cntl(r300ContextPtr rmesa, int func, int eqn, int cbits, int funcA, int eqnA)
209 GLuint new_ablend, new_cblend;
211 new_ablend = eqnA | funcA;
212 new_cblend = eqn | func | cbits;
213 if(rmesa->hw.bld.cmd[R300_BLD_ABLEND] == rmesa->hw.bld.cmd[R300_BLD_CBLEND]){
214 new_cblend |= R300_BLEND_NO_SEPARATE;
216 if((new_ablend != rmesa->hw.bld.cmd[R300_BLD_ABLEND])
217 || (new_cblend != rmesa->hw.bld.cmd[R300_BLD_CBLEND])){
218 R300_STATECHANGE(rmesa, bld);
219 rmesa->hw.bld.cmd[R300_BLD_ABLEND]=new_ablend;
220 rmesa->hw.bld.cmd[R300_BLD_CBLEND]=new_cblend;
224 static void r300_set_blend_state(GLcontext * ctx)
226 r300ContextPtr rmesa = R300_CONTEXT(ctx);
228 GLuint cntl = rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &
229 ~(R300_ROP_ENABLE | R300_ALPHA_BLEND_ENABLE |
230 R300_SEPARATE_ALPHA_ENABLE);
233 int func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
234 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
235 int eqn = R200_COMB_FCN_ADD_CLAMP;
236 int funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
237 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
238 int eqnA = R200_COMB_FCN_ADD_CLAMP;
241 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
242 if (ctx->Color._LogicOpEnabled) {
244 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
245 cntl | R300_ROP_ENABLE;
247 r300_set_blend_cntl(rmesa,
251 } else if (ctx->Color.BlendEnabled) {
253 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
254 cntl | R300_ALPHA_BLEND_ENABLE |
255 R300_SEPARATE_ALPHA_ENABLE;
259 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
261 r300_set_blend_cntl(rmesa,
267 if (ctx->Color._LogicOpEnabled) {
269 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
270 cntl | R300_ROP_ENABLE;
271 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
274 } else if (ctx->Color.BlendEnabled) {
276 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
277 cntl | R300_ALPHA_BLEND_ENABLE;
281 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
282 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
284 r300_set_blend_cntl(rmesa,
292 (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
293 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
295 R200_DST_BLEND_SHIFT);
297 switch (ctx->Color.BlendEquationRGB) {
299 eqn = R300_COMB_FCN_ADD_CLAMP;
302 case GL_FUNC_SUBTRACT:
303 eqn = R300_COMB_FCN_SUB_CLAMP;
306 case GL_FUNC_REVERSE_SUBTRACT:
307 eqn = R200_COMB_FCN_RSUB_CLAMP;
311 eqn = R200_COMB_FCN_MIN;
312 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
313 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
317 eqn = R200_COMB_FCN_MAX;
318 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
319 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
324 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
325 __func__, __LINE__, ctx->Color.BlendEquationRGB);
329 if (!rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
331 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
337 (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
338 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
340 R200_DST_BLEND_SHIFT);
342 switch (ctx->Color.BlendEquationA) {
344 eqnA = R300_COMB_FCN_ADD_CLAMP;
347 case GL_FUNC_SUBTRACT:
348 eqnA = R300_COMB_FCN_SUB_CLAMP;
351 case GL_FUNC_REVERSE_SUBTRACT:
352 eqnA = R200_COMB_FCN_RSUB_CLAMP;
356 eqnA = R200_COMB_FCN_MIN;
357 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
358 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
362 eqnA = R200_COMB_FCN_MAX;
363 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
364 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
368 fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n",
369 __func__, __LINE__, ctx->Color.BlendEquationA);
373 r300_set_blend_cntl(rmesa,
374 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
376 r300_set_blend_cntl(rmesa,
377 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
381 static void r300BlendEquationSeparate(GLcontext * ctx,
382 GLenum modeRGB, GLenum modeA)
384 r300_set_blend_state(ctx);
387 static void r300BlendFuncSeparate(GLcontext * ctx,
388 GLenum sfactorRGB, GLenum dfactorRGB,
389 GLenum sfactorA, GLenum dfactorA)
391 r300_set_blend_state(ctx);
395 * Update our tracked culling state based on Mesa's state.
397 static void r300UpdateCulling(GLcontext* ctx)
399 r300ContextPtr r300 = R300_CONTEXT(ctx);
402 R300_STATECHANGE(r300, cul);
403 if (ctx->Polygon.CullFlag) {
404 if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
405 val = R300_CULL_FRONT|R300_CULL_BACK;
406 else if (ctx->Polygon.CullFaceMode == GL_FRONT)
407 val = R300_CULL_FRONT;
409 val = R300_CULL_BACK;
411 if (ctx->Polygon.FrontFace == GL_CW)
412 val |= R300_FRONT_FACE_CW;
414 val |= R300_FRONT_FACE_CCW;
417 r300->hw.cul.cmd[R300_CUL_CULL] = val;
422 * Handle glEnable()/glDisable().
424 * \note Mesa already filters redundant calls to glEnable/glDisable.
426 static void r300Enable(GLcontext* ctx, GLenum cap, GLboolean state)
428 r300ContextPtr r300 = R300_CONTEXT(ctx);
431 if (RADEON_DEBUG & DEBUG_STATE)
432 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
433 _mesa_lookup_enum_by_nr(cap),
434 state ? "GL_TRUE" : "GL_FALSE");
437 /* Fast track this one...
445 R200_STATECHANGE(r300, at);
447 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
448 R300_ALPHA_TEST_ENABLE;
450 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
451 ~R300_ALPHA_TEST_ENABLE;
456 case GL_COLOR_LOGIC_OP:
457 r300_set_blend_state(ctx);
461 R300_STATECHANGE(r300, zs);
465 newval = R300_RB3D_Z_TEST_AND_WRITE;
467 newval = R300_RB3D_Z_TEST;
471 r300->hw.zs.cmd[R300_ZS_CNTL_0] = newval;
475 r300UpdateCulling(ctx);
479 radeonEnable(ctx, cap, state);
486 * Change the culling mode.
488 * \note Mesa already filters redundant calls to this function.
490 static void r300CullFace(GLcontext* ctx, GLenum mode)
494 r300UpdateCulling(ctx);
499 * Change the polygon orientation.
501 * \note Mesa already filters redundant calls to this function.
503 static void r300FrontFace(GLcontext* ctx, GLenum mode)
507 r300UpdateCulling(ctx);
512 * Change the depth testing function.
514 * \note Mesa already filters redundant calls to this function.
516 static void r300DepthFunc(GLcontext* ctx, GLenum func)
518 r300ContextPtr r300 = R300_CONTEXT(ctx);
520 R300_STATECHANGE(r300, zs);
522 r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
526 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NEVER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
529 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LESS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
532 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_EQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
535 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
538 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GREATER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
541 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NOTEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
544 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
547 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_ALWAYS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
551 fprintf(stderr, "ZS_CNTL_1=%08x\n", r300->hw.zs.cmd[R300_ZS_CNTL_1]);
556 * Enable/Disable depth writing.
558 * \note Mesa already filters redundant calls to this function.
560 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
562 r300ContextPtr r300 = R300_CONTEXT(ctx);
564 if (!ctx->Depth.Test)
567 R300_STATECHANGE(r300, zs);
568 r300->hw.zs.cmd[R300_ZS_CNTL_0] = mask
569 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
574 * Handle glColorMask()
576 static void r300ColorMask(GLcontext* ctx,
577 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
579 r300ContextPtr r300 = R300_CONTEXT(ctx);
580 int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
582 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
583 R300_STATECHANGE(r300, cmk);
584 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
588 /* =============================================================
591 static void r300PointSize(GLcontext * ctx, GLfloat size)
593 r300ContextPtr r300 = R300_CONTEXT(ctx);
595 /* This might need fixing later */
596 R300_STATECHANGE(r300, vps);
597 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
600 /* =============================================================
601 * Window position and viewport transformation
605 * To correctly position primitives:
607 #define SUBPIXEL_X 0.125
608 #define SUBPIXEL_Y 0.125
610 void r300UpdateWindow(GLcontext * ctx)
612 r300ContextPtr rmesa = R300_CONTEXT(ctx);
613 __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
614 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
615 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
616 const GLfloat *v = ctx->Viewport._WindowMap.m;
618 GLfloat sx = v[MAT_SX];
619 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
620 GLfloat sy = -v[MAT_SY];
621 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
622 GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
623 GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
625 R300_FIREVERTICES(rmesa);
626 R300_STATECHANGE(rmesa, vpt);
628 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
629 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
630 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
631 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
632 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
633 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
636 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
637 GLsizei width, GLsizei height)
639 /* Don't pipeline viewport changes, conflict with window offset
640 * setting below. Could apply deltas to rescue pipelined viewport
641 * values, or keep the originals hanging around.
643 R200_FIREVERTICES(R200_CONTEXT(ctx));
644 r300UpdateWindow(ctx);
647 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
649 r300UpdateWindow(ctx);
652 /* Routing and texture-related */
654 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
656 int i, count=0,reg=0;
658 TNLcontext *tnl = TNL_CONTEXT(ctx);
659 struct vertex_buffer *VB = &tnl->vb;
660 r300ContextPtr r300 = R300_CONTEXT(ctx);
663 /* Stage 1 - input to VAP */
665 /* Assign register number automatically, retaining it in rmesa->state.reg */
667 /* Note: immediate vertex data includes all coordinates.
668 To save bandwidth use either VBUF or state-based vertex generation */
670 #define CONFIGURE_AOS(v, o, r, f) \
673 r300->state.aos[count].element_size=4; \
674 r300->state.aos[count].stride=4; \
675 r300->state.aos[count].ncomponents=4; \
677 r300->state.aos[count].element_size=v->size; \
678 r300->state.aos[count].stride=v->size; \
679 r300->state.aos[count].ncomponents=v->size; \
681 r300->state.aos[count].offset=o; \
682 r300->state.aos[count].reg=reg; \
683 r300->state.aos[count].format=(f); \
684 r300->state.vap_reg.r=reg; \
689 /* All offsets are 0 - for use by immediate mode.
690 Should change later to handle vertex buffers */
691 CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
692 CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
693 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
694 if(ctx->Texture.Unit[i].Enabled)
695 CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
697 r300->state.aos_count=count;
699 if (RADEON_DEBUG & DEBUG_STATE)
700 fprintf(stderr, "aos_count=%d\n", count);
702 if(count>R300_MAX_AOS_ARRAYS){
703 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
709 /* setup INPUT_ROUTE */
710 R300_STATECHANGE(r300, vir[0]);
711 for(i=0;i+1<count;i+=2){
712 dw=(r300->state.aos[i].ncomponents-1)
713 | ((r300->state.aos[i].reg)<<8)
714 | (r300->state.aos[i].format<<14)
715 | (((r300->state.aos[i+1].ncomponents-1)
716 | ((r300->state.aos[i+1].reg)<<8)
717 | (r300->state.aos[i+1].format<<14))<<16);
722 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
725 dw=(r300->state.aos[count-1].ncomponents-1)
726 | (r300->state.aos[count-1].format<<14)
727 | ((r300->state.aos[count-1].reg)<<8)
729 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
730 //fprintf(stderr, "vir0 dw=%08x\n", dw);
732 /* Set the rest of INPUT_ROUTE_0 to 0 */
733 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
734 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
737 /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
738 #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
739 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
740 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
741 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
743 #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
744 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
745 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
746 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
748 R300_STATECHANGE(r300, vir[1]);
750 for(i=0;i+1<count;i+=2){
752 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
753 dw=(ALL_COMPONENTS & mask)
754 | (ALL_DEFAULT & ~mask)
755 | R300_INPUT_ROUTE_ENABLE;
758 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
760 (ALL_COMPONENTS & mask)
761 | (ALL_DEFAULT & ~mask)
762 | R300_INPUT_ROUTE_ENABLE
765 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
768 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
769 dw=(ALL_COMPONENTS & mask)
770 | (ALL_DEFAULT & ~mask)
771 | R300_INPUT_ROUTE_ENABLE;
772 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
773 //fprintf(stderr, "vir1 dw=%08x\n", dw);
775 /* Set the rest of INPUT_ROUTE_1 to 0 */
776 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
777 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
779 /* Set up input_cntl */
781 R300_STATECHANGE(r300, vic);
782 r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555; /* Hard coded value, no idea what it means */
784 r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
785 | R300_INPUT_CNTL_COLOR;
787 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
788 if(ctx->Texture.Unit[i].Enabled)
789 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
791 /* Stage 3: VAP output */
792 R300_STATECHANGE(r300, vof);
793 r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
794 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
796 r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
797 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
798 if(ctx->Texture.Unit[i].Enabled)
799 r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
803 static r300TexObj default_tex_obj={
804 filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
806 size: (0xff << R300_TX_WIDTHMASK_SHIFT)
807 | (0xff << R300_TX_HEIGHTMASK_SHIFT)
808 | (0x8 << R300_TX_SIZE_SHIFT),
815 /* there is probably a system to these value, but, for now,
816 we just try by hand */
818 static int inline translate_src(int src)
827 case GL_PRIMARY_COLOR:
844 /* I think 357 and 457 are prime numbers.. wiggle them if you get coincidences */
845 #define FORMAT_HASH(opRGB, srcRGB, modeRGB, opA, srcA, modeA, format, intFormat) ( \
847 ((opRGB)<<30) | ((opA)<<28) | \
848 ((srcRGB)<< 25) | ((srcA)<<22) | \
852 ^ (((format)) *457) \
853 ^ ((intFormat) * 7) \
857 static GLuint translate_texture_format(GLcontext *ctx, GLint tex_unit, GLuint format, GLint IntFormat,
858 struct gl_texture_format *tex_format)
860 const struct gl_texture_unit *texUnit= &ctx->Texture.Unit[tex_unit];
861 int i=0; /* number of alpha args .. */
865 fprintf(stderr, "_ReallyEnabled=%d EnvMode=%s\n",
866 texUnit->_ReallyEnabled,
867 _mesa_lookup_enum_by_nr(texUnit->EnvMode));
870 if(tex_format==NULL){
871 fprintf(stderr, "Aeiii ! tex_format==NULL !!\n");
875 switch(tex_format->MesaFormat){
876 case MESA_FORMAT_RGBA8888:
877 return R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8);
879 fprintf(stderr, "Do not know format %s\n", _mesa_lookup_enum_by_nr(tex_format->MesaFormat));
890 fmt=R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
897 //fmt |= ((format) & 0xff00)<<4;
898 fprintf(stderr, "NumArgsRGB=%d NumArgsA=%d\n",
899 texUnit->_CurrentCombine->_NumArgsRGB,
900 texUnit->_CurrentCombine->_NumArgsA);
902 fprintf(stderr, "fmt=%08x\n", fmt);
905 /* Size field in format specific first */
907 texUnit->_CurrentCombine->OperandRGB[i] -GL_SRC_COLOR,
908 translate_src(texUnit->_CurrentCombine->SourceRGB[i]),
909 texUnit->_CurrentCombine->ModeRGB,
910 texUnit->_CurrentCombine->OperandA[i] -GL_SRC_ALPHA,
911 translate_src(texUnit->_CurrentCombine->SourceA[i]),
912 texUnit->_CurrentCombine->ModeA,
916 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA):
920 return R300_EASY_TX_FORMAT(X, X, CUT_W, W, W8Z8Y8X8);
921 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA8):
925 /* Quake3demo -small font on the bottom */
927 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, GL_RGBA8):
928 /* Quake3demo - mouse cursor*/
930 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, 4):
934 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
935 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, 4):
940 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
941 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008847, 3):
946 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, 0x00000003):
947 /* Tested with NeHe lesson 08 */
948 //case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x0005547, 0):
949 /* Can't remember what I tested this with..
950 try putting return 0 of you see broken textures which
951 are not being complained about */
952 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00009947, GL_RGB8):
953 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, GL_RGB8):
954 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00003347, GL_RGB8):
955 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, 3):
959 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
960 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007847, GL_RGBA8):
961 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006747, GL_RGBA8):
962 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006647, GL_RGBA8):
963 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, GL_RGBA8):
967 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
968 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, GL_RGBA8):
969 return R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) ;
970 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008845, 0x00008056):
972 fprintf(stderr, "***\n");
973 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
978 static int warn_once=1;
980 fprintf(stderr, "%s:%s Do not know how to translate texture format - help me !\n",
981 __FILE__, __FUNCTION__);
988 void r300_setup_textures(GLcontext *ctx)
991 struct r300_tex_obj *t;
992 r300ContextPtr r300 = R300_CONTEXT(ctx);
993 int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
994 struct gl_texture_unit *texUnit;
996 R300_STATECHANGE(r300, txe);
997 R300_STATECHANGE(r300, tex.filter);
998 R300_STATECHANGE(r300, tex.unknown1);
999 R300_STATECHANGE(r300, tex.size);
1000 R300_STATECHANGE(r300, tex.format);
1001 R300_STATECHANGE(r300, tex.offset);
1002 R300_STATECHANGE(r300, tex.unknown4);
1003 R300_STATECHANGE(r300, tex.unknown5);
1004 R300_STATECHANGE(r300, tex.border_color);
1006 r300->state.texture.tc_count=0;
1008 r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
1010 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1011 if (RADEON_DEBUG & DEBUG_STATE)
1012 fprintf(stderr, "mtu=%d\n", mtu);
1014 if(mtu>R300_MAX_TEXTURE_UNITS){
1015 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1016 mtu, R300_MAX_TEXTURE_UNITS);
1020 if(ctx->Texture.Unit[i].Enabled){
1021 t=r300->state.texture.unit[i].texobj;
1022 fprintf(stderr, "format=%08x\n", r300->state.texture.unit[i].format);
1023 r300->state.texture.tc_count++;
1025 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1029 if (RADEON_DEBUG & DEBUG_STATE)
1030 fprintf(stderr, "Activating texture unit %d\n", i);
1032 r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1034 /* Turn off rest of the bits that are wrong. Im going to get rid of this soon, dont worry :) */
1035 t->filter &= R300_TX_MIN_FILTER_MASK | R300_TX_MAG_FILTER_MASK
1036 |R300_TX_WRAP_S_MASK | R300_TX_WRAP_T_MASK |
1037 R300_TX_WRAP_Q_MASK | R300_TX_MAX_ANISO_MASK;
1039 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=t->filter;
1041 /* No idea why linear filtered textures shake when puting random data */
1042 /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1043 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1044 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1045 //fprintf(stderr, "t->format=%08x\n", t->format);
1046 r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
1047 r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1048 r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
1049 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0+i]=t->pp_border_color;
1051 /* We don't know how to set this yet */
1052 //value from r300_lib.c for RGB24
1053 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x88a0c;
1055 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=translate_texture_format(ctx, i, t->format,
1056 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->IntFormat:3,
1057 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->TexFormat:NULL);
1061 fprintf(stderr, "Format=%s IntFormat=%08x MesaFormat=%08x BaseFormat=%s IsCompressed=%d Target=%s\n",
1062 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->Format),
1063 t->base.tObj->Image[0][0]->IntFormat,
1064 t->base.tObj->Image[0][0]->TexFormat->MesaFormat,
1065 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->TexFormat->BaseFormat),
1066 t->base.tObj->Image[0][0]->IsCompressed,
1067 _mesa_lookup_enum_by_nr(t->base.tObj->Target));
1069 fprintf(stderr, "pitch=%08x filter=%08x format=%08x\n", t->pitch, t->filter, r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]);
1070 fprintf(stderr, "unknown1=%08x size=%08x\n", r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i],
1071 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]);
1073 /* Use the code below to quickly find matching texture
1074 formats. Requires an app that displays the same texture
1077 if(r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]==0){
1084 texUnit = &ctx->Texture.Unit[i];
1085 fprintf(stderr, "Want to set FORMAT_HASH(%d, %d, 0x%04x, %d, %d, 0x%04x, 0x%08x, %s(%08x))\n",
1086 texUnit->_CurrentCombine->OperandRGB[0] -GL_SRC_COLOR,
1087 translate_src(texUnit->_CurrentCombine->SourceRGB[0]),
1088 texUnit->_CurrentCombine->ModeRGB,
1089 texUnit->_CurrentCombine->OperandA[0] -GL_SRC_ALPHA,
1090 translate_src(texUnit->_CurrentCombine->SourceA[0]),
1091 texUnit->_CurrentCombine->ModeA,
1093 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->IntFormat),
1094 t->base.tObj->Image[0][0]->IntFormat
1096 fprintf(stderr, "Also known: format_x=%08x border_color=%08x cubic_faces=%08x\n", t->format_x, t->pp_border_color, t->pp_cubic_faces);
1097 fprintf(stderr, "\t_ReallyEnabled=%08x EnvMode=%08x IntFormat=%08x\n", texUnit->_ReallyEnabled, texUnit->EnvMode, t->base.tObj->Image[0][0]->IntFormat);
1102 fprintf(stderr, "Now trying format %08x\n",
1104 fprintf(stderr, "size=%08x\n", t->size);
1106 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=known_formats[fmt];
1107 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=
1108 R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) | (fmt<<24);
1109 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x08a0c | (fmt<<16);
1110 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x58a00 | (fmt);
1111 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x53a0c | (fmt<<24);
1118 ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1119 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1120 ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1121 ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1122 ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1123 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1124 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1125 ((drm_r300_cmd_header_t*)r300->hw.tex.border_color.cmd)->unchecked_state.count = max_texture_unit+1;
1127 if (RADEON_DEBUG & DEBUG_STATE)
1128 fprintf(stderr, "TX_ENABLE: %08x max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1131 void r300_setup_rs_unit(GLcontext *ctx)
1133 r300ContextPtr r300 = R300_CONTEXT(ctx);
1136 /* This needs to be rewritten - it is a hack at best */
1138 R300_STATECHANGE(r300, ri);
1139 R300_STATECHANGE(r300, rc);
1140 R300_STATECHANGE(r300, rr);
1142 for(i = 1; i <= 8; ++i)
1143 r300->hw.ri.cmd[i] = 0x00d10000;
1144 r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1145 r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1146 r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1149 for(i = 2; i <= 8; ++i)
1150 r300->hw.ri.cmd[i] |= 4;
1153 for(i = 1; i <= 8; ++i)
1154 r300->hw.rr.cmd[i] = 0;
1155 /* textures enabled ? */
1156 if(r300->state.texture.tc_count>0){
1158 /* This code only really works with one set of texture coordinates */
1160 /* The second constant is needed to get glxgears display anything .. */
1161 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1162 | R300_RS_CNTL_0_UNKNOWN_18
1163 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1164 r300->hw.rc.cmd[2] = 0xc0;
1167 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1168 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1172 /* The second constant is needed to get glxgears display anything .. */
1173 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1174 r300->hw.rc.cmd[2] = 0;
1176 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1177 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1182 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1184 #define bump_vpu_count(ptr, new_count) do{\
1185 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1186 int _nc=(new_count)/4; \
1187 if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1190 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1194 if(vsf->length==0)return;
1196 if(vsf->length & 0x3){
1197 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1201 switch((dest>>8) & 0xf){
1203 R300_STATECHANGE(r300, vpi);
1204 for(i=0;i<vsf->length;i++)
1205 r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1206 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1210 R300_STATECHANGE(r300, vpp);
1211 for(i=0;i<vsf->length;i++)
1212 r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1213 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1216 R300_STATECHANGE(r300, vps);
1217 for(i=0;i<vsf->length;i++)
1218 r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1219 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1222 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1228 void r300SetupVertexShader(r300ContextPtr rmesa)
1230 GLcontext* ctx = rmesa->radeon.glCtx;
1232 /* Reset state, in case we don't use something */
1233 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1234 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1235 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1238 /* This needs to be replaced by vertex shader generation code */
1241 /* textures enabled ? */
1242 if(rmesa->state.texture.tc_count>0){
1243 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1245 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1249 rmesa->state.vertex_shader.matrix[0].length=16;
1250 memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1252 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1254 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1256 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1257 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1259 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1260 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1264 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1265 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1268 R300_STATECHANGE(rmesa, pvs);
1269 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1270 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1271 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1272 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1273 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1274 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1275 | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1277 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1278 so I leave it as a reminder */
1280 reg_start(R300_VAP_PVS_WAITIDLE,0);
1285 void r300SetupPixelShader(r300ContextPtr rmesa)
1289 /* This needs to be replaced by pixel shader generation code */
1291 /* textures enabled ? */
1292 if(rmesa->state.texture.tc_count>0){
1293 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1295 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1298 R300_STATECHANGE(rmesa, fpt);
1299 for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1300 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1301 rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1303 #define OUTPUT_FIELD(st, reg, field) \
1304 R300_STATECHANGE(rmesa, st); \
1305 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1306 rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1307 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1309 OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1310 OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1311 OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1312 OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1315 R300_STATECHANGE(rmesa, fp);
1317 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1318 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1319 | (rmesa->state.pixel_shader.program.node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
1320 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1321 | (rmesa->state.pixel_shader.program.node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
1322 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1326 rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1327 (rmesa->state.pixel_shader.program.active_nodes-1)
1328 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1330 rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1332 rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1333 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1334 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1335 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1336 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1338 R300_STATECHANGE(rmesa, fpp);
1339 for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1340 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1341 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1342 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1343 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1345 rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1350 * Called by Mesa after an internal state update.
1352 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1354 r300ContextPtr r300 = R300_CONTEXT(ctx);
1356 _swrast_InvalidateState(ctx, new_state);
1357 _swsetup_InvalidateState(ctx, new_state);
1358 _ac_InvalidateState(ctx, new_state);
1359 _tnl_InvalidateState(ctx, new_state);
1360 _ae_invalidate_state(ctx, new_state);
1362 /* Go inefficiency! */
1363 r300ResetHwState(r300);
1368 * Completely recalculates hardware state based on the Mesa state.
1370 void r300ResetHwState(r300ContextPtr r300)
1372 GLcontext* ctx = r300->radeon.glCtx;
1375 if (RADEON_DEBUG & DEBUG_STATE)
1376 fprintf(stderr, "%s\n", __FUNCTION__);
1378 /* This is a place to initialize registers which
1379 have bitfields accessed by different functions
1380 and not all bits are used */
1382 r300->hw.zs.cmd[R300_ZS_CNTL_0] = 0;
1383 r300->hw.zs.cmd[R300_ZS_CNTL_1] = 0;
1384 r300->hw.zs.cmd[R300_ZS_CNTL_2] = 0xffff00;
1387 /* go and compute register values from GL state */
1389 r300UpdateWindow(ctx);
1392 ctx->Color.ColorMask[RCOMP],
1393 ctx->Color.ColorMask[GCOMP],
1394 ctx->Color.ColorMask[BCOMP],
1395 ctx->Color.ColorMask[ACOMP]);
1397 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1398 r300DepthMask(ctx, ctx->Depth.Mask);
1399 r300DepthFunc(ctx, ctx->Depth.Func);
1401 r300UpdateCulling(ctx);
1403 r300_setup_routing(ctx, GL_TRUE);
1405 r300UpdateTextureState(ctx);
1406 r300_setup_textures(ctx);
1407 r300_setup_rs_unit(ctx);
1409 r300SetupVertexShader(r300);
1410 r300SetupPixelShader(r300);
1412 r300_set_blend_state(ctx);
1413 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1415 /* Initialize magic registers
1416 TODO : learn what they really do, or get rid of
1417 those we don't have to touch */
1418 r300->hw.unk2080.cmd[1] = 0x0030045A;
1420 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1421 | R300_VPORT_X_OFFSET_ENA
1422 | R300_VPORT_Y_SCALE_ENA
1423 | R300_VPORT_Y_OFFSET_ENA
1424 | R300_VPORT_Z_SCALE_ENA
1425 | R300_VPORT_Z_OFFSET_ENA
1427 r300->hw.vte.cmd[2] = 0x00000008;
1429 r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1430 r300->hw.unk2134.cmd[2] = 0x00000000;
1432 r300->hw.unk2140.cmd[1] = 0x00000000;
1434 #if 0 /* Done in setup routing */
1435 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1436 r300->hw.vir[0].cmd[1] = 0x21030003;
1438 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1439 r300->hw.vir[1].cmd[1] = 0xF688F688;
1441 r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1442 r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1445 r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1447 r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1449 r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1450 r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1451 r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1452 r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1454 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1455 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1457 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1460 r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1461 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1462 r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1465 r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1466 r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1467 r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1470 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1471 | R300_GB_LINE_STUFF_ENABLE
1472 | R300_GB_TRIANGLE_STUFF_ENABLE;
1474 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1475 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1476 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1477 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1478 | R300_GB_TILE_PIPE_COUNT_R300
1479 | R300_GB_TILE_SIZE_16;
1481 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1482 | R300_GB_TILE_PIPE_COUNT_RV300
1483 | R300_GB_TILE_SIZE_16;
1484 r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1485 r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1487 //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1489 r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1490 r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1491 r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1492 r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1494 r300->hw.unk4214.cmd[1] = 0x00050005;
1496 r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1497 (6 << R300_POINTSIZE_Y_SHIFT);
1499 r300->hw.unk4230.cmd[1] = 0x01800000;
1500 r300->hw.unk4230.cmd[2] = 0x00020006;
1501 r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1503 r300->hw.unk4260.cmd[1] = 0;
1504 r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1505 r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1507 r300->hw.unk4274.cmd[1] = 0x00000002;
1508 r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1509 r300->hw.unk4274.cmd[3] = 0x00000000;
1510 r300->hw.unk4274.cmd[4] = 0x00000000;
1512 r300->hw.unk4288.cmd[1] = 0x00000000;
1513 r300->hw.unk4288.cmd[2] = 0x00000001;
1514 r300->hw.unk4288.cmd[3] = 0x00000000;
1515 r300->hw.unk4288.cmd[4] = 0x00000000;
1516 r300->hw.unk4288.cmd[5] = 0x00000000;
1518 r300->hw.unk42A0.cmd[1] = 0x00000000;
1520 r300->hw.unk42B4.cmd[1] = 0x00000000;
1522 r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1523 r300->hw.unk42C0.cmd[2] = 0x00000000;
1526 r300->hw.unk43A4.cmd[1] = 0x0000001C;
1527 r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1529 r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1532 r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1533 r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1534 r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1535 r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1536 r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1537 r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1538 r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1541 r300->hw.unk46A4.cmd[1] = 0x00001B01;
1542 r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1543 r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1544 r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1545 r300->hw.unk46A4.cmd[5] = 0x00000001;
1548 for(i = 1; i <= 64; ++i) {
1549 /* create NOP instructions */
1550 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1551 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1552 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1553 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1557 r300->hw.unk4BC0.cmd[1] = 0;
1559 r300->hw.unk4BC8.cmd[1] = 0;
1560 r300->hw.unk4BC8.cmd[2] = 0;
1561 r300->hw.unk4BC8.cmd[3] = 0;
1564 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1567 r300->hw.unk4BD8.cmd[1] = 0;
1569 r300->hw.unk4E00.cmd[1] = 0;
1572 r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1573 r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1576 r300->hw.unk4E10.cmd[1] = 0;
1577 r300->hw.unk4E10.cmd[2] = 0;
1578 r300->hw.unk4E10.cmd[3] = 0;
1580 r300->hw.cb.cmd[R300_CB_OFFSET] =
1581 r300->radeon.radeonScreen->backOffset +
1582 r300->radeon.radeonScreen->fbLocation;
1583 r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1584 | R300_COLOR_UNKNOWN_22_23;
1586 r300->hw.unk4E50.cmd[1] = 0;
1587 r300->hw.unk4E50.cmd[2] = 0;
1588 r300->hw.unk4E50.cmd[3] = 0;
1589 r300->hw.unk4E50.cmd[4] = 0;
1590 r300->hw.unk4E50.cmd[5] = 0;
1591 r300->hw.unk4E50.cmd[6] = 0;
1592 r300->hw.unk4E50.cmd[7] = 0;
1593 r300->hw.unk4E50.cmd[8] = 0;
1594 r300->hw.unk4E50.cmd[9] = 0;
1596 r300->hw.unk4E88.cmd[1] = 0;
1598 r300->hw.unk4EA0.cmd[1] = 0x00000000;
1599 r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1601 r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1602 r300->hw.unk4F10.cmd[2] = 0x00000000;
1603 r300->hw.unk4F10.cmd[3] = 0x00000003;
1604 r300->hw.unk4F10.cmd[4] = 0x00000000;
1606 r300->hw.zb.cmd[R300_ZB_OFFSET] =
1607 r300->radeon.radeonScreen->depthOffset +
1608 r300->radeon.radeonScreen->fbLocation;
1609 r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1611 r300->hw.unk4F28.cmd[1] = 0;
1613 r300->hw.unk4F30.cmd[1] = 0;
1614 r300->hw.unk4F30.cmd[2] = 0;
1616 r300->hw.unk4F44.cmd[1] = 0;
1618 r300->hw.unk4F54.cmd[1] = 0;
1621 ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1622 for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1624 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1625 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1626 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1627 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1630 ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1631 for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1632 r300->hw.vpp.cmd[i] = 0;
1635 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1636 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1637 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1638 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1642 r300->hw.all_dirty = GL_TRUE;
1648 * Calculate initial hardware state and register state functions.
1649 * Assumes that the command buffer and state atoms have been
1650 * initialized already.
1652 void r300InitState(r300ContextPtr r300)
1654 GLcontext *ctx = r300->radeon.glCtx;
1657 radeonInitState(&r300->radeon);
1659 switch (ctx->Visual.depthBits) {
1661 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1662 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1663 //r300->state.stencil.clear = 0x00000000;
1666 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1667 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1668 //r300->state.stencil.clear = 0xff000000;
1671 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1672 ctx->Visual.depthBits);
1676 memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1678 r300ResetHwState(r300);
1684 * Initialize driver's state callback functions
1686 void r300InitStateFuncs(struct dd_function_table* functions)
1688 radeonInitStateFuncs(functions);
1690 functions->UpdateState = r300InvalidateState;
1691 functions->AlphaFunc = r300AlphaFunc;
1692 functions->BlendColor = r300BlendColor;
1693 functions->BlendEquationSeparate = r300BlendEquationSeparate;
1694 functions->BlendFuncSeparate = r300BlendFuncSeparate;
1695 functions->Enable = r300Enable;
1696 functions->ColorMask = r300ColorMask;
1697 functions->DepthFunc = r300DepthFunc;
1698 functions->DepthMask = r300DepthMask;
1699 functions->CullFace = r300CullFace;
1700 functions->FrontFace = r300FrontFace;
1702 /* Viewport related */
1703 functions->Viewport = r300Viewport;
1704 functions->DepthRange = r300DepthRange;
1705 functions->PointSize = r300PointSize;