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"
52 #include "radeon_ioctl.h"
53 #include "radeon_state.h"
54 #include "r300_context.h"
55 #include "r300_ioctl.h"
56 #include "r300_state.h"
58 #include "r300_program.h"
59 #include "r300_emit.h"
60 #include "r300_fixed_pipelines.h"
62 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
64 r300ContextPtr rmesa = R300_CONTEXT(ctx);
65 int pp_misc = rmesa->hw.at.cmd[R300_AT_ALPHA_TEST];
68 CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
70 R300_STATECHANGE(rmesa, at);
72 pp_misc &= ~(R300_ALPHA_TEST_OP_MASK | R300_REF_ALPHA_MASK);
73 pp_misc |= (refByte & R300_REF_ALPHA_MASK);
77 pp_misc |= R300_ALPHA_TEST_FAIL;
80 pp_misc |= R300_ALPHA_TEST_LESS;
83 pp_misc |= R300_ALPHA_TEST_EQUAL;
86 pp_misc |= R300_ALPHA_TEST_LEQUAL;
89 pp_misc |= R300_ALPHA_TEST_GREATER;
92 pp_misc |= R300_ALPHA_TEST_NEQUAL;
95 pp_misc |= R300_ALPHA_TEST_GEQUAL;
98 pp_misc |= R300_ALPHA_TEST_PASS;
102 rmesa->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
105 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
108 r300ContextPtr rmesa = R300_CONTEXT(ctx);
109 fprintf(stderr, "%s:%s is not implemented yet. Fixme !\n", __FILE__, __FUNCTION__);
111 R200_STATECHANGE(rmesa, ctx);
112 CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
113 CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
114 CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
115 CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
116 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor)
117 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCOLOR] =
118 radeonPackColor(4, color[0], color[1], color[2], color[3]);
123 * Calculate the hardware blend factor setting. This same function is used
124 * for source and destination of both alpha and RGB.
127 * The hardware register value for the specified blend factor. This value
128 * will need to be shifted into the correct position for either source or
129 * destination factor.
132 * Since the two cases where source and destination are handled differently
133 * are essentially error cases, they should never happen. Determine if these
134 * cases can be removed.
136 static int blend_factor(GLenum factor, GLboolean is_src)
142 func = R200_BLEND_GL_ZERO;
145 func = R200_BLEND_GL_ONE;
148 func = R200_BLEND_GL_DST_COLOR;
150 case GL_ONE_MINUS_DST_COLOR:
151 func = R200_BLEND_GL_ONE_MINUS_DST_COLOR;
154 func = R200_BLEND_GL_SRC_COLOR;
156 case GL_ONE_MINUS_SRC_COLOR:
157 func = R200_BLEND_GL_ONE_MINUS_SRC_COLOR;
160 func = R200_BLEND_GL_SRC_ALPHA;
162 case GL_ONE_MINUS_SRC_ALPHA:
163 func = R200_BLEND_GL_ONE_MINUS_SRC_ALPHA;
166 func = R200_BLEND_GL_DST_ALPHA;
168 case GL_ONE_MINUS_DST_ALPHA:
169 func = R200_BLEND_GL_ONE_MINUS_DST_ALPHA;
171 case GL_SRC_ALPHA_SATURATE:
173 (is_src) ? R200_BLEND_GL_SRC_ALPHA_SATURATE :
176 case GL_CONSTANT_COLOR:
177 func = R200_BLEND_GL_CONST_COLOR;
179 case GL_ONE_MINUS_CONSTANT_COLOR:
180 func = R200_BLEND_GL_ONE_MINUS_CONST_COLOR;
182 case GL_CONSTANT_ALPHA:
183 func = R200_BLEND_GL_CONST_ALPHA;
185 case GL_ONE_MINUS_CONSTANT_ALPHA:
186 func = R200_BLEND_GL_ONE_MINUS_CONST_ALPHA;
189 func = (is_src) ? R200_BLEND_GL_ONE : R200_BLEND_GL_ZERO;
195 * Sets both the blend equation and the blend function.
196 * This is done in a single
197 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
198 * change the interpretation of the blend function.
199 * Also, make sure that blend function and blend equation are set to their default
200 * value if color blending is not enabled, since at least blend equations GL_MIN
201 * and GL_FUNC_REVERSE_SUBTRACT will cause wrong results otherwise for
205 /* helper function */
206 static void r300_set_blend_cntl(r300ContextPtr rmesa, int func, int eqn, int cbits, int funcA, int eqnA)
208 GLuint new_ablend, new_cblend;
210 new_ablend = eqnA | funcA;
211 new_cblend = eqn | func | cbits;
212 if(rmesa->hw.bld.cmd[R300_BLD_ABLEND] == rmesa->hw.bld.cmd[R300_BLD_CBLEND]){
213 new_cblend |= R300_BLEND_NO_SEPARATE;
215 if((new_ablend != rmesa->hw.bld.cmd[R300_BLD_ABLEND])
216 || (new_cblend != rmesa->hw.bld.cmd[R300_BLD_CBLEND])){
217 R300_STATECHANGE(rmesa, bld);
218 rmesa->hw.bld.cmd[R300_BLD_ABLEND]=new_ablend;
219 rmesa->hw.bld.cmd[R300_BLD_CBLEND]=new_cblend;
223 static void r300_set_blend_state(GLcontext * ctx)
225 r300ContextPtr rmesa = R300_CONTEXT(ctx);
227 GLuint cntl = rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &
228 ~(R300_ROP_ENABLE | R300_ALPHA_BLEND_ENABLE |
229 R300_SEPARATE_ALPHA_ENABLE);
232 int func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
233 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
234 int eqn = R200_COMB_FCN_ADD_CLAMP;
235 int funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
236 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
237 int eqnA = R200_COMB_FCN_ADD_CLAMP;
240 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
241 if (ctx->Color._LogicOpEnabled) {
243 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
244 cntl | R300_ROP_ENABLE;
246 r300_set_blend_cntl(rmesa,
250 } else if (ctx->Color.BlendEnabled) {
252 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
253 cntl | R300_ALPHA_BLEND_ENABLE |
254 R300_SEPARATE_ALPHA_ENABLE;
258 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
260 r300_set_blend_cntl(rmesa,
266 if (ctx->Color._LogicOpEnabled) {
268 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
269 cntl | R300_ROP_ENABLE;
270 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
273 } else if (ctx->Color.BlendEnabled) {
275 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
276 cntl | R300_ALPHA_BLEND_ENABLE;
280 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
281 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
283 r300_set_blend_cntl(rmesa,
291 (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
292 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
294 R200_DST_BLEND_SHIFT);
296 switch (ctx->Color.BlendEquationRGB) {
298 eqn = R300_COMB_FCN_ADD_CLAMP;
301 case GL_FUNC_SUBTRACT:
302 eqn = R300_COMB_FCN_SUB_CLAMP;
305 case GL_FUNC_REVERSE_SUBTRACT:
306 eqn = R200_COMB_FCN_RSUB_CLAMP;
310 eqn = R200_COMB_FCN_MIN;
311 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
312 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
316 eqn = R200_COMB_FCN_MAX;
317 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
318 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
323 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
324 __func__, __LINE__, ctx->Color.BlendEquationRGB);
328 if (!rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
330 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
336 (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
337 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
339 R200_DST_BLEND_SHIFT);
341 switch (ctx->Color.BlendEquationA) {
343 eqnA = R300_COMB_FCN_ADD_CLAMP;
346 case GL_FUNC_SUBTRACT:
347 eqnA = R300_COMB_FCN_SUB_CLAMP;
350 case GL_FUNC_REVERSE_SUBTRACT:
351 eqnA = R200_COMB_FCN_RSUB_CLAMP;
355 eqnA = R200_COMB_FCN_MIN;
356 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
357 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
361 eqnA = R200_COMB_FCN_MAX;
362 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
363 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
367 fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n",
368 __func__, __LINE__, ctx->Color.BlendEquationA);
372 r300_set_blend_cntl(rmesa,
373 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
375 r300_set_blend_cntl(rmesa,
376 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
380 static void r300BlendEquationSeparate(GLcontext * ctx,
381 GLenum modeRGB, GLenum modeA)
383 r300_set_blend_state(ctx);
386 static void r300BlendFuncSeparate(GLcontext * ctx,
387 GLenum sfactorRGB, GLenum dfactorRGB,
388 GLenum sfactorA, GLenum dfactorA)
390 r300_set_blend_state(ctx);
394 * Update our tracked culling state based on Mesa's state.
396 static void r300UpdateCulling(GLcontext* ctx)
398 r300ContextPtr r300 = R300_CONTEXT(ctx);
401 R300_STATECHANGE(r300, cul);
402 if (ctx->Polygon.CullFlag) {
403 if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
404 val = R300_CULL_FRONT|R300_CULL_BACK;
405 else if (ctx->Polygon.CullFaceMode == GL_FRONT)
406 val = R300_CULL_FRONT;
408 val = R300_CULL_BACK;
410 if (ctx->Polygon.FrontFace == GL_CW)
411 val |= R300_FRONT_FACE_CW;
413 val |= R300_FRONT_FACE_CCW;
416 r300->hw.cul.cmd[R300_CUL_CULL] = val;
421 * Handle glEnable()/glDisable().
423 * \note Mesa already filters redundant calls to glEnable/glDisable.
425 static void r300Enable(GLcontext* ctx, GLenum cap, GLboolean state)
427 r300ContextPtr r300 = R300_CONTEXT(ctx);
430 if (RADEON_DEBUG & DEBUG_STATE)
431 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
432 _mesa_lookup_enum_by_nr(cap),
433 state ? "GL_TRUE" : "GL_FALSE");
436 /* Fast track this one...
444 R200_STATECHANGE(r300, at);
446 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
447 R300_ALPHA_TEST_ENABLE;
449 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
450 ~R300_ALPHA_TEST_ENABLE;
455 case GL_COLOR_LOGIC_OP:
456 r300_set_blend_state(ctx);
460 R300_STATECHANGE(r300, zc);
464 newval = R300_RB3D_Z_TEST_AND_WRITE;
466 newval = R300_RB3D_Z_TEST;
470 r300->hw.zc.cmd[R300_ZC_CNTL_0] = newval;
474 r300UpdateCulling(ctx);
478 radeonEnable(ctx, cap, state);
485 * Change the culling mode.
487 * \note Mesa already filters redundant calls to this function.
489 static void r300CullFace(GLcontext* ctx, GLenum mode)
493 r300UpdateCulling(ctx);
498 * Change the polygon orientation.
500 * \note Mesa already filters redundant calls to this function.
502 static void r300FrontFace(GLcontext* ctx, GLenum mode)
506 r300UpdateCulling(ctx);
511 * Change the depth testing function.
513 * \note Mesa already filters redundant calls to this function.
515 static void r300DepthFunc(GLcontext* ctx, GLenum func)
517 r300ContextPtr r300 = R300_CONTEXT(ctx);
519 R300_STATECHANGE(r300, zc);
523 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_NEVER;
526 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_LESS;
529 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_EQUAL;
532 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_LEQUAL;
535 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_GREATER;
538 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_NEQUAL;
541 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_GEQUAL;
544 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_ALWAYS;
551 * Enable/Disable depth writing.
553 * \note Mesa already filters redundant calls to this function.
555 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
557 r300ContextPtr r300 = R300_CONTEXT(ctx);
559 if (!ctx->Depth.Test)
562 R300_STATECHANGE(r300, zc);
563 r300->hw.zc.cmd[R300_ZC_CNTL_0] = mask
564 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
569 * Handle glColorMask()
571 static void r300ColorMask(GLcontext* ctx,
572 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
574 r300ContextPtr r300 = R300_CONTEXT(ctx);
575 int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
577 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
578 R300_STATECHANGE(r300, cmk);
579 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
583 /* =============================================================
586 static void r300PointSize(GLcontext * ctx, GLfloat size)
588 r300ContextPtr r300 = R300_CONTEXT(ctx);
590 /* This might need fixing later */
591 R300_STATECHANGE(r300, vps);
592 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
595 /* =============================================================
596 * Window position and viewport transformation
600 * To correctly position primitives:
602 #define SUBPIXEL_X 0.125
603 #define SUBPIXEL_Y 0.125
605 void r300UpdateWindow(GLcontext * ctx)
607 r300ContextPtr rmesa = R300_CONTEXT(ctx);
608 __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
609 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
610 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
611 const GLfloat *v = ctx->Viewport._WindowMap.m;
613 GLfloat sx = v[MAT_SX];
614 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
615 GLfloat sy = -v[MAT_SY];
616 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
617 GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
618 GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
620 R300_FIREVERTICES(rmesa);
621 R300_STATECHANGE(rmesa, vpt);
623 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
624 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
625 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
626 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
627 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
628 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
631 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
632 GLsizei width, GLsizei height)
634 /* Don't pipeline viewport changes, conflict with window offset
635 * setting below. Could apply deltas to rescue pipelined viewport
636 * values, or keep the originals hanging around.
638 R200_FIREVERTICES(R200_CONTEXT(ctx));
639 r300UpdateWindow(ctx);
642 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
644 r300UpdateWindow(ctx);
647 /* Routing and texture-related */
649 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
651 int i, count=0,reg=0;
653 TNLcontext *tnl = TNL_CONTEXT(ctx);
654 struct vertex_buffer *VB = &tnl->vb;
655 r300ContextPtr r300 = R300_CONTEXT(ctx);
658 /* Stage 1 - input to VAP */
660 /* Assign register number automatically, retaining it in rmesa->state.reg */
662 /* Note: immediate vertex data includes all coordinates.
663 To save bandwidth use either VBUF or state-based vertex generation */
665 #define CONFIGURE_AOS(v, o, r, f) \
668 r300->state.aos[count].element_size=4; \
669 r300->state.aos[count].stride=4; \
670 r300->state.aos[count].ncomponents=4; \
672 r300->state.aos[count].element_size=v->size; \
673 r300->state.aos[count].stride=v->size; \
674 r300->state.aos[count].ncomponents=v->size; \
676 r300->state.aos[count].offset=o; \
677 r300->state.aos[count].reg=reg; \
678 r300->state.aos[count].format=(f); \
679 r300->state.vap_reg.r=reg; \
684 /* All offsets are 0 - for use by immediate mode.
685 Should change later to handle vertex buffers */
686 CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
687 CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
688 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
689 if(ctx->Texture.Unit[i].Enabled)
690 CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
692 r300->state.aos_count=count;
694 if (RADEON_DEBUG & DEBUG_STATE)
695 fprintf(stderr, "aos_count=%d\n", count);
697 if(count>R300_MAX_AOS_ARRAYS){
698 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
704 /* setup INPUT_ROUTE */
705 R300_STATECHANGE(r300, vir[0]);
706 for(i=0;i+1<count;i+=2){
707 dw=(r300->state.aos[i].ncomponents-1)
708 | ((r300->state.aos[i].reg)<<8)
709 | (r300->state.aos[i].format<<14)
710 | (((r300->state.aos[i+1].ncomponents-1)
711 | ((r300->state.aos[i+1].reg)<<8)
712 | (r300->state.aos[i+1].format<<14))<<16);
717 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
720 dw=(r300->state.aos[count-1].ncomponents-1)
721 | (r300->state.aos[count-1].format<<14)
722 | ((r300->state.aos[count-1].reg)<<8)
724 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
725 //fprintf(stderr, "vir0 dw=%08x\n", dw);
727 /* Set the rest of INPUT_ROUTE_0 to 0 */
728 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
729 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
732 /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
733 #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
734 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
735 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
736 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
738 #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
739 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
740 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
741 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
743 R300_STATECHANGE(r300, vir[1]);
745 for(i=0;i+1<count;i+=2){
747 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
748 dw=(ALL_COMPONENTS & mask)
749 | (ALL_DEFAULT & ~mask)
750 | R300_INPUT_ROUTE_ENABLE;
753 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
755 (ALL_COMPONENTS & mask)
756 | (ALL_DEFAULT & ~mask)
757 | R300_INPUT_ROUTE_ENABLE
760 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
763 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
764 dw=(ALL_COMPONENTS & mask)
765 | (ALL_DEFAULT & ~mask)
766 | R300_INPUT_ROUTE_ENABLE;
767 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
768 //fprintf(stderr, "vir1 dw=%08x\n", dw);
770 /* Set the rest of INPUT_ROUTE_1 to 0 */
771 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
772 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
774 /* Set up input_cntl */
776 R300_STATECHANGE(r300, vic);
777 r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555; /* Hard coded value, no idea what it means */
779 r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
780 | R300_INPUT_CNTL_COLOR;
782 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
783 if(ctx->Texture.Unit[i].Enabled)
784 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
786 /* Stage 3: VAP output */
787 R300_STATECHANGE(r300, vof);
788 r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
789 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
791 r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
792 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
793 if(ctx->Texture.Unit[i].Enabled)
794 r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
798 static r300TexObj default_tex_obj={
799 filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
801 size: (0xff << R300_TX_WIDTHMASK_SHIFT)
802 | (0xff << R300_TX_HEIGHTMASK_SHIFT)
803 | (0x8 << R300_TX_SIZE_SHIFT),
810 /* there is probably a system to these value, but, for now,
811 we just try by hand */
813 static int inline translate_src(int src)
822 case GL_PRIMARY_COLOR:
839 /* I think 357 and 457 are prime numbers.. wiggle them if you get coincidences */
840 #define FORMAT_HASH(opRGB, srcRGB, modeRGB, opA, srcA, modeA, format, intFormat) ( \
842 ((opRGB)<<30) | ((opA)<<28) | \
843 ((srcRGB)<< 25) | ((srcA)<<22) | \
847 ^ (((format)) *457) \
848 ^ ((intFormat) * 7) \
852 static GLuint translate_texture_format(GLcontext *ctx, GLint tex_unit, GLuint format, GLint IntFormat)
854 const struct gl_texture_unit *texUnit= &ctx->Texture.Unit[tex_unit];
855 int i=0; /* number of alpha args .. */
859 fprintf(stderr, "_ReallyEnabled=%d EnvMode=%s\n",
860 texUnit->_ReallyEnabled,
861 _mesa_lookup_enum_by_nr(texUnit->EnvMode));
868 fmt=R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8);
872 fmt=R300_EASY_TX_FORMAT(Z, Y, X, ONE, W8Z8Y8X8);
879 //fmt |= ((format) & 0xff00)<<4;
880 fprintf(stderr, "NumArgsRGB=%d NumArgsA=%d\n",
881 texUnit->_CurrentCombine->_NumArgsRGB,
882 texUnit->_CurrentCombine->_NumArgsA);
884 fprintf(stderr, "fmt=%08x\n", fmt);
887 /* Size field in format specific first */
889 texUnit->_CurrentCombine->OperandRGB[i] -GL_SRC_COLOR,
890 translate_src(texUnit->_CurrentCombine->SourceRGB[i]),
891 texUnit->_CurrentCombine->ModeRGB,
892 texUnit->_CurrentCombine->OperandA[i] -GL_SRC_ALPHA,
893 translate_src(texUnit->_CurrentCombine->SourceA[i]),
894 texUnit->_CurrentCombine->ModeA,
898 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA):
902 return R300_EASY_TX_FORMAT(X, X, CUT_W, W, W8Z8Y8X8);
903 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA8):
907 /* Quake3demo -small font on the bottom */
909 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, GL_RGBA8):
910 /* Quake3demo - mouse cursor*/
912 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, 4):
916 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
917 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, 4):
922 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
923 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008847, 3):
928 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, 0x00000003):
929 /* Tested with NeHe lesson 08 */
930 //case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x0005547, 0):
931 /* Can't remember what I tested this with..
932 try putting return 0 of you see broken textures which
933 are not being complained about */
934 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00009947, GL_RGB8):
935 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, GL_RGB8):
936 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00003347, GL_RGB8):
937 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, 3):
941 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
942 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007847, GL_RGBA8):
943 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006747, GL_RGBA8):
944 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006647, GL_RGBA8):
945 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, GL_RGBA8):
949 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
950 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, GL_RGBA8):
951 return R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) ;
952 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008845, 0x00008056):
954 fprintf(stderr, "***\n");
955 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
960 static int warn_once=1;
962 fprintf(stderr, "%s:%s Do not know how to translate texture format - help me !\n",
963 __FILE__, __FUNCTION__);
970 void r300_setup_textures(GLcontext *ctx)
973 struct r300_tex_obj *t;
974 r300ContextPtr r300 = R300_CONTEXT(ctx);
975 int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
976 struct gl_texture_unit *texUnit;
978 R300_STATECHANGE(r300, txe);
979 R300_STATECHANGE(r300, tex.filter);
980 R300_STATECHANGE(r300, tex.unknown1);
981 R300_STATECHANGE(r300, tex.size);
982 R300_STATECHANGE(r300, tex.format);
983 R300_STATECHANGE(r300, tex.offset);
984 R300_STATECHANGE(r300, tex.unknown4);
985 R300_STATECHANGE(r300, tex.unknown5);
987 r300->state.texture.tc_count=0;
989 r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
991 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
992 if (RADEON_DEBUG & DEBUG_STATE)
993 fprintf(stderr, "mtu=%d\n", mtu);
995 if(mtu>R300_MAX_TEXTURE_UNITS){
996 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
997 mtu, R300_MAX_TEXTURE_UNITS);
1001 if(ctx->Texture.Unit[i].Enabled){
1002 t=r300->state.texture.unit[i].texobj;
1003 r300->state.texture.tc_count++;
1005 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1009 if (RADEON_DEBUG & DEBUG_STATE)
1010 fprintf(stderr, "Activating texture unit %d\n", i);
1012 r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1014 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=t->filter;
1016 /* Turn off rest of the bits that are wrong */
1017 t->filter &= R300_TX_MIN_FILTER_MASK | R300_TX_MAG_FILTER_MASK;
1019 /* No idea why linear filtered textures shake when puting random data */
1020 /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1021 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1022 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1023 r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
1024 r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1025 r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
1027 /* We don't know how to set this yet */
1028 //value from r300_lib.c for RGB24
1029 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x88a0c;
1030 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=translate_texture_format(ctx, i, t->format,
1031 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->IntFormat:3);
1035 fprintf(stderr, "Format=%s IntFormat=%08x MesaFormat=%08x BaseFormat=%s IsCompressed=%d Target=%s\n",
1036 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->Format),
1037 t->base.tObj->Image[0][0]->IntFormat,
1038 t->base.tObj->Image[0][0]->TexFormat->MesaFormat,
1039 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->TexFormat->BaseFormat),
1040 t->base.tObj->Image[0][0]->IsCompressed,
1041 _mesa_lookup_enum_by_nr(t->base.tObj->Target));
1043 fprintf(stderr, "pitch=%08x filter=%08x format=%08x\n", t->pitch, t->filter, r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]);
1044 fprintf(stderr, "unknown1=%08x size=%08x\n", r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i],
1045 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]);
1047 /* Use the code below to quickly find matching texture
1048 formats. Requires an app that displays the same texture
1051 if(r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]==0){
1058 texUnit = &ctx->Texture.Unit[i];
1059 fprintf(stderr, "Want to set FORMAT_HASH(%d, %d, 0x%04x, %d, %d, 0x%04x, 0x%08x, %s(%08x))\n",
1060 texUnit->_CurrentCombine->OperandRGB[0] -GL_SRC_COLOR,
1061 translate_src(texUnit->_CurrentCombine->SourceRGB[0]),
1062 texUnit->_CurrentCombine->ModeRGB,
1063 texUnit->_CurrentCombine->OperandA[0] -GL_SRC_ALPHA,
1064 translate_src(texUnit->_CurrentCombine->SourceA[0]),
1065 texUnit->_CurrentCombine->ModeA,
1067 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->IntFormat),
1068 t->base.tObj->Image[0][0]->IntFormat
1070 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);
1071 fprintf(stderr, "\t_ReallyEnabled=%08x EnvMode=%08x IntFormat=%08x\n", texUnit->_ReallyEnabled, texUnit->EnvMode, t->base.tObj->Image[0][0]->IntFormat);
1076 fprintf(stderr, "Now trying format %08x\n",
1078 fprintf(stderr, "size=%08x\n", t->size);
1080 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=known_formats[fmt];
1081 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=
1082 R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) | (fmt<<24);
1083 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x08a0c | (fmt<<16);
1084 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x58a00 | (fmt);
1085 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x53a0c | (fmt<<24);
1092 ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1093 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1094 ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1095 ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1096 ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1097 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1098 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1100 if (RADEON_DEBUG & DEBUG_STATE)
1101 fprintf(stderr, "TX_ENABLE: %08x max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1104 void r300_setup_rs_unit(GLcontext *ctx)
1106 r300ContextPtr r300 = R300_CONTEXT(ctx);
1109 /* This needs to be rewritten - it is a hack at best */
1111 R300_STATECHANGE(r300, ri);
1112 R300_STATECHANGE(r300, rc);
1113 R300_STATECHANGE(r300, rr);
1115 for(i = 1; i <= 8; ++i)
1116 r300->hw.ri.cmd[i] = 0x00d10000;
1117 r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1118 r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1119 r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1122 for(i = 2; i <= 8; ++i)
1123 r300->hw.ri.cmd[i] |= 4;
1126 for(i = 1; i <= 8; ++i)
1127 r300->hw.rr.cmd[i] = 0;
1128 /* textures enabled ? */
1129 if(r300->state.texture.tc_count>0){
1131 /* This code only really works with one set of texture coordinates */
1133 /* The second constant is needed to get glxgears display anything .. */
1134 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1135 | R300_RS_CNTL_0_UNKNOWN_18
1136 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1137 r300->hw.rc.cmd[2] = 0xc0;
1140 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1141 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1145 /* The second constant is needed to get glxgears display anything .. */
1146 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1147 r300->hw.rc.cmd[2] = 0;
1149 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1150 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1155 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1157 #define bump_vpu_count(ptr, new_count) do{\
1158 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1159 int _nc=(new_count)/4; \
1160 if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1163 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1167 if(vsf->length==0)return;
1169 if(vsf->length & 0x3){
1170 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1174 switch((dest>>8) & 0xf){
1176 R300_STATECHANGE(r300, vpi);
1177 for(i=0;i<vsf->length;i++)
1178 r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1179 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1183 R300_STATECHANGE(r300, vpp);
1184 for(i=0;i<vsf->length;i++)
1185 r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1186 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1189 R300_STATECHANGE(r300, vps);
1190 for(i=0;i<vsf->length;i++)
1191 r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1192 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1195 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1201 void r300SetupVertexShader(r300ContextPtr rmesa)
1203 GLcontext* ctx = rmesa->radeon.glCtx;
1205 /* Reset state, in case we don't use something */
1206 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1207 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1208 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1211 /* This needs to be replaced by vertex shader generation code */
1214 /* textures enabled ? */
1215 if(rmesa->state.texture.tc_count>0){
1216 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1218 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1222 rmesa->state.vertex_shader.matrix[0].length=16;
1223 memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1225 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1227 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1229 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1230 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1232 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1233 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1237 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1238 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1241 R300_STATECHANGE(rmesa, pvs);
1242 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1243 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1244 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1245 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1246 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1247 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1248 | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1250 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1251 so I leave it as a reminder */
1253 reg_start(R300_VAP_PVS_WAITIDLE,0);
1258 void r300SetupPixelShader(r300ContextPtr rmesa)
1262 /* This needs to be replaced by pixel shader generation code */
1264 /* textures enabled ? */
1265 if(rmesa->state.texture.tc_count>0){
1266 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1268 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1271 R300_STATECHANGE(rmesa, fpt);
1272 for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1273 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1274 rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1276 #define OUTPUT_FIELD(st, reg, field) \
1277 R300_STATECHANGE(rmesa, st); \
1278 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1279 rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1280 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1282 OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1283 OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1284 OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1285 OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1288 R300_STATECHANGE(rmesa, fp);
1290 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1291 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1292 | (rmesa->state.pixel_shader.program.node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
1293 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1294 | (rmesa->state.pixel_shader.program.node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
1295 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1299 rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1300 (rmesa->state.pixel_shader.program.active_nodes-1)
1301 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1303 rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1305 rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1306 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1307 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1308 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1309 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1311 R300_STATECHANGE(rmesa, fpp);
1312 for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1313 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1314 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1315 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1316 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1318 rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1323 * Called by Mesa after an internal state update.
1325 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1327 r300ContextPtr r300 = R300_CONTEXT(ctx);
1329 _swrast_InvalidateState(ctx, new_state);
1330 _swsetup_InvalidateState(ctx, new_state);
1331 _ac_InvalidateState(ctx, new_state);
1332 _tnl_InvalidateState(ctx, new_state);
1333 _ae_invalidate_state(ctx, new_state);
1335 /* Go inefficiency! */
1336 r300ResetHwState(r300);
1341 * Completely recalculates hardware state based on the Mesa state.
1343 void r300ResetHwState(r300ContextPtr r300)
1345 GLcontext* ctx = r300->radeon.glCtx;
1348 if (RADEON_DEBUG & DEBUG_STATE)
1349 fprintf(stderr, "%s\n", __FUNCTION__);
1351 r300UpdateWindow(ctx);
1354 ctx->Color.ColorMask[RCOMP],
1355 ctx->Color.ColorMask[GCOMP],
1356 ctx->Color.ColorMask[BCOMP],
1357 ctx->Color.ColorMask[ACOMP]);
1359 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1360 r300DepthMask(ctx, ctx->Depth.Mask);
1361 r300DepthFunc(ctx, ctx->Depth.Func);
1363 r300UpdateCulling(ctx);
1365 r300_setup_routing(ctx, GL_TRUE);
1367 r300UpdateTextureState(ctx);
1368 r300_setup_textures(ctx);
1369 r300_setup_rs_unit(ctx);
1371 r300SetupVertexShader(r300);
1372 r300SetupPixelShader(r300);
1374 r300_set_blend_state(ctx);
1375 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1378 r300->hw.unk2080.cmd[1] = 0x0030045A;
1380 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1381 | R300_VPORT_X_OFFSET_ENA
1382 | R300_VPORT_Y_SCALE_ENA
1383 | R300_VPORT_Y_OFFSET_ENA
1384 | R300_VPORT_Z_SCALE_ENA
1385 | R300_VPORT_Z_OFFSET_ENA
1387 r300->hw.vte.cmd[2] = 0x00000008;
1389 r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1390 r300->hw.unk2134.cmd[2] = 0x00000000;
1392 r300->hw.unk2140.cmd[1] = 0x00000000;
1394 #if 0 /* Done in setup routing */
1395 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1396 r300->hw.vir[0].cmd[1] = 0x21030003;
1398 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1399 r300->hw.vir[1].cmd[1] = 0xF688F688;
1401 r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1402 r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1405 r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1407 r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1409 r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1410 r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1411 r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1412 r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1414 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1415 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1417 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1420 r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1421 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1422 r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1425 r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1426 r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1427 r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1430 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1431 | R300_GB_LINE_STUFF_ENABLE
1432 | R300_GB_TRIANGLE_STUFF_ENABLE;
1434 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1435 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1436 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1437 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1438 | R300_GB_TILE_PIPE_COUNT_R300
1439 | R300_GB_TILE_SIZE_16;
1441 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1442 | R300_GB_TILE_PIPE_COUNT_RV300
1443 | R300_GB_TILE_SIZE_16;
1444 r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1445 r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1447 //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1449 r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1450 r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1451 r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1452 r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1454 r300->hw.unk4214.cmd[1] = 0x00050005;
1456 r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1457 (6 << R300_POINTSIZE_Y_SHIFT);
1459 r300->hw.unk4230.cmd[1] = 0x01800000;
1460 r300->hw.unk4230.cmd[2] = 0x00020006;
1461 r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1463 r300->hw.unk4260.cmd[1] = 0;
1464 r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1465 r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1467 r300->hw.unk4274.cmd[1] = 0x00000002;
1468 r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1469 r300->hw.unk4274.cmd[3] = 0x00000000;
1470 r300->hw.unk4274.cmd[4] = 0x00000000;
1472 r300->hw.unk4288.cmd[1] = 0x00000000;
1473 r300->hw.unk4288.cmd[2] = 0x00000001;
1474 r300->hw.unk4288.cmd[3] = 0x00000000;
1475 r300->hw.unk4288.cmd[4] = 0x00000000;
1476 r300->hw.unk4288.cmd[5] = 0x00000000;
1478 r300->hw.unk42A0.cmd[1] = 0x00000000;
1480 r300->hw.unk42B4.cmd[1] = 0x00000000;
1482 r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1483 r300->hw.unk42C0.cmd[2] = 0x00000000;
1486 r300->hw.unk43A4.cmd[1] = 0x0000001C;
1487 r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1489 r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1492 r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1493 r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1494 r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1495 r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1496 r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1497 r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1498 r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1501 r300->hw.unk46A4.cmd[1] = 0x00001B01;
1502 r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1503 r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1504 r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1505 r300->hw.unk46A4.cmd[5] = 0x00000001;
1508 for(i = 1; i <= 64; ++i) {
1509 /* create NOP instructions */
1510 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1511 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1512 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1513 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1517 r300->hw.unk4BC0.cmd[1] = 0;
1519 r300->hw.unk4BC8.cmd[1] = 0;
1520 r300->hw.unk4BC8.cmd[2] = 0;
1521 r300->hw.unk4BC8.cmd[3] = 0;
1524 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1527 r300->hw.unk4BD8.cmd[1] = 0;
1529 r300->hw.unk4E00.cmd[1] = 0;
1532 r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1533 r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1536 r300->hw.unk4E10.cmd[1] = 0;
1537 r300->hw.unk4E10.cmd[2] = 0;
1538 r300->hw.unk4E10.cmd[3] = 0;
1540 r300->hw.cb.cmd[R300_CB_OFFSET] =
1541 r300->radeon.radeonScreen->backOffset +
1542 r300->radeon.radeonScreen->fbLocation;
1543 r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1544 | R300_COLOR_UNKNOWN_22_23;
1546 r300->hw.unk4E50.cmd[1] = 0;
1547 r300->hw.unk4E50.cmd[2] = 0;
1548 r300->hw.unk4E50.cmd[3] = 0;
1549 r300->hw.unk4E50.cmd[4] = 0;
1550 r300->hw.unk4E50.cmd[5] = 0;
1551 r300->hw.unk4E50.cmd[6] = 0;
1552 r300->hw.unk4E50.cmd[7] = 0;
1553 r300->hw.unk4E50.cmd[8] = 0;
1554 r300->hw.unk4E50.cmd[9] = 0;
1556 r300->hw.unk4E88.cmd[1] = 0;
1558 r300->hw.unk4EA0.cmd[1] = 0x00000000;
1559 r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1561 r300->hw.unk4F08.cmd[1] = 0x00FFFF00;
1563 r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1564 r300->hw.unk4F10.cmd[2] = 0x00000000;
1565 r300->hw.unk4F10.cmd[3] = 0x00000003;
1566 r300->hw.unk4F10.cmd[4] = 0x00000000;
1568 r300->hw.zb.cmd[R300_ZB_OFFSET] =
1569 r300->radeon.radeonScreen->depthOffset +
1570 r300->radeon.radeonScreen->fbLocation;
1571 r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1573 r300->hw.unk4F28.cmd[1] = 0;
1575 r300->hw.unk4F30.cmd[1] = 0;
1576 r300->hw.unk4F30.cmd[2] = 0;
1578 r300->hw.unk4F44.cmd[1] = 0;
1580 r300->hw.unk4F54.cmd[1] = 0;
1583 ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1584 for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1586 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1587 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1588 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1589 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1592 ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1593 for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1594 r300->hw.vpp.cmd[i] = 0;
1597 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1598 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1599 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1600 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1604 r300->hw.all_dirty = GL_TRUE;
1610 * Calculate initial hardware state and register state functions.
1611 * Assumes that the command buffer and state atoms have been
1612 * initialized already.
1614 void r300InitState(r300ContextPtr r300)
1616 GLcontext *ctx = r300->radeon.glCtx;
1619 radeonInitState(&r300->radeon);
1621 switch (ctx->Visual.depthBits) {
1623 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1624 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1625 //r300->state.stencil.clear = 0x00000000;
1628 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1629 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1630 //r300->state.stencil.clear = 0xff000000;
1633 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1634 ctx->Visual.depthBits);
1638 memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1640 r300ResetHwState(r300);
1646 * Initialize driver's state callback functions
1648 void r300InitStateFuncs(struct dd_function_table* functions)
1650 radeonInitStateFuncs(functions);
1652 functions->UpdateState = r300InvalidateState;
1653 functions->AlphaFunc = r300AlphaFunc;
1654 functions->BlendColor = r300BlendColor;
1655 functions->BlendEquationSeparate = r300BlendEquationSeparate;
1656 functions->BlendFuncSeparate = r300BlendFuncSeparate;
1657 functions->Enable = r300Enable;
1658 functions->ColorMask = r300ColorMask;
1659 functions->DepthFunc = r300DepthFunc;
1660 functions->DepthMask = r300DepthMask;
1661 functions->CullFace = r300CullFace;
1662 functions->FrontFace = r300FrontFace;
1664 /* Viewport related */
1665 functions->Viewport = r300Viewport;
1666 functions->DepthRange = r300DepthRange;
1667 functions->PointSize = r300PointSize;