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;
474 case GL_STENCIL_TEST:
475 if (r300->state.hw_stencil) {
476 R300_STATECHANGE(r300, zs);
478 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
481 r300->hw.zs.cmd[R300_ZS_CNTL_0] &=
482 ~R300_STENCIL_ENABLE;
485 FALLBACK(&r300->radeon, RADEON_FALLBACK_STENCIL, state);
490 r300UpdateCulling(ctx);
494 radeonEnable(ctx, cap, state);
501 * Change the culling mode.
503 * \note Mesa already filters redundant calls to this function.
505 static void r300CullFace(GLcontext* ctx, GLenum mode)
509 r300UpdateCulling(ctx);
514 * Change the polygon orientation.
516 * \note Mesa already filters redundant calls to this function.
518 static void r300FrontFace(GLcontext* ctx, GLenum mode)
522 r300UpdateCulling(ctx);
527 * Change the depth testing function.
529 * \note Mesa already filters redundant calls to this function.
531 static void r300DepthFunc(GLcontext* ctx, GLenum func)
533 r300ContextPtr r300 = R300_CONTEXT(ctx);
535 R300_STATECHANGE(r300, zs);
537 r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
541 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NEVER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
544 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LESS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
547 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_EQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
550 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
553 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GREATER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
556 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NOTEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
559 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
562 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_ALWAYS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
570 * Enable/Disable depth writing.
572 * \note Mesa already filters redundant calls to this function.
574 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
576 r300ContextPtr r300 = R300_CONTEXT(ctx);
578 if (!ctx->Depth.Test)
581 R300_STATECHANGE(r300, zs);
582 r300->hw.zs.cmd[R300_ZS_CNTL_0] = mask
583 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
588 * Handle glColorMask()
590 static void r300ColorMask(GLcontext* ctx,
591 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
593 r300ContextPtr r300 = R300_CONTEXT(ctx);
594 int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
596 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
597 R300_STATECHANGE(r300, cmk);
598 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
602 /* =============================================================
605 static void r300PointSize(GLcontext * ctx, GLfloat size)
607 r300ContextPtr r300 = R300_CONTEXT(ctx);
609 /* This might need fixing later */
610 R300_STATECHANGE(r300, vps);
611 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
613 /* =============================================================
617 static void r300StencilFunc(GLcontext * ctx, GLenum func,
618 GLint ref, GLuint mask)
620 r300ContextPtr rmesa = R300_CONTEXT(ctx);
621 GLuint refmask = ((ctx->Stencil.Ref[0] << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
623 ValueMask[0] << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
625 R200_STATECHANGE(rmesa, zs);
627 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT);
628 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &= ~((R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
629 (R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
631 switch (ctx->Stencil.Function[0]) {
633 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
634 R300_ZS_NEVER << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT;
637 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
638 R300_ZS_LESS << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT;
641 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
642 R300_ZS_EQUAL << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT;
645 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
646 R300_ZS_LEQUAL << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT;
649 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
650 R300_ZS_GREATER << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT;
653 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
654 R300_ZS_NOTEQUAL << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT;
657 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
658 R300_ZS_GEQUAL << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT;
661 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
662 R300_ZS_ALWAYS << R300_RB3D_ZS1_STENCIL_FUNC_SHIFT;
666 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
669 static void r300StencilMask(GLcontext * ctx, GLuint mask)
671 r300ContextPtr rmesa = R300_CONTEXT(ctx);
673 R200_STATECHANGE(rmesa, zs);
674 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &= ~(R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT);
675 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= ctx->Stencil.WriteMask[0] << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT;
678 static int translate_stencil_op(int op)
686 return R300_ZS_REPLACE;
691 case GL_INCR_WRAP_EXT:
692 return R300_ZS_INCR_WRAP;
693 case GL_DECR_WRAP_EXT:
694 return R300_ZS_DECR_WRAP;
696 return R300_ZS_INVERT;
700 static void r300StencilOp(GLcontext * ctx, GLenum fail,
701 GLenum zfail, GLenum zpass)
703 r300ContextPtr rmesa = R300_CONTEXT(ctx);
705 R200_STATECHANGE(rmesa, zs);
706 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~((R300_ZS_MASK << R300_RB3D_ZS1_STENCIL_FAIL_OP_SHIFT)
707 | (R300_ZS_MASK << R300_RB3D_ZS1_STENCIL_ZPASS_OP_SHIFT)
708 | (R300_ZS_MASK << R300_RB3D_ZS1_STENCIL_ZFAIL_OP_SHIFT)
711 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
712 (translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_STENCIL_FAIL_OP_SHIFT)
713 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_STENCIL_ZFAIL_OP_SHIFT)
714 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_STENCIL_ZPASS_OP_SHIFT);
718 static void r300ClearStencil(GLcontext * ctx, GLint s)
720 r300ContextPtr rmesa = R300_CONTEXT(ctx);
722 /* Not sure whether this is correct.. */
723 R200_STATECHANGE(rmesa, zs);
724 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] =
725 ((GLuint) ctx->Stencil.Clear |
726 (0xff << R200_STENCIL_MASK_SHIFT) |
727 (ctx->Stencil.WriteMask[0] << R200_STENCIL_WRITEMASK_SHIFT));
730 /* =============================================================
731 * Window position and viewport transformation
735 * To correctly position primitives:
737 #define SUBPIXEL_X 0.125
738 #define SUBPIXEL_Y 0.125
740 void r300UpdateWindow(GLcontext * ctx)
742 r300ContextPtr rmesa = R300_CONTEXT(ctx);
743 __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
744 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
745 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
746 const GLfloat *v = ctx->Viewport._WindowMap.m;
748 GLfloat sx = v[MAT_SX];
749 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
750 GLfloat sy = -v[MAT_SY];
751 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
752 GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
753 GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
755 R300_FIREVERTICES(rmesa);
756 R300_STATECHANGE(rmesa, vpt);
758 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
759 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
760 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
761 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
762 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
763 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
766 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
767 GLsizei width, GLsizei height)
769 /* Don't pipeline viewport changes, conflict with window offset
770 * setting below. Could apply deltas to rescue pipelined viewport
771 * values, or keep the originals hanging around.
773 R200_FIREVERTICES(R200_CONTEXT(ctx));
774 r300UpdateWindow(ctx);
777 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
779 r300UpdateWindow(ctx);
782 /* Routing and texture-related */
784 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
786 int i, count=0,reg=0;
788 TNLcontext *tnl = TNL_CONTEXT(ctx);
789 struct vertex_buffer *VB = &tnl->vb;
790 r300ContextPtr r300 = R300_CONTEXT(ctx);
793 /* Stage 1 - input to VAP */
795 /* Assign register number automatically, retaining it in rmesa->state.reg */
797 /* Note: immediate vertex data includes all coordinates.
798 To save bandwidth use either VBUF or state-based vertex generation */
800 #define CONFIGURE_AOS(v, o, r, f) \
803 r300->state.aos[count].element_size=4; \
804 r300->state.aos[count].stride=4; \
805 r300->state.aos[count].ncomponents=4; \
807 r300->state.aos[count].element_size=v->size; \
808 r300->state.aos[count].stride=v->size; \
809 r300->state.aos[count].ncomponents=v->size; \
811 r300->state.aos[count].offset=o; \
812 r300->state.aos[count].reg=reg; \
813 r300->state.aos[count].format=(f); \
814 r300->state.vap_reg.r=reg; \
819 /* All offsets are 0 - for use by immediate mode.
820 Should change later to handle vertex buffers */
821 CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
822 CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
823 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
824 if(ctx->Texture.Unit[i].Enabled)
825 CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
827 r300->state.aos_count=count;
829 if (RADEON_DEBUG & DEBUG_STATE)
830 fprintf(stderr, "aos_count=%d\n", count);
832 if(count>R300_MAX_AOS_ARRAYS){
833 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
839 /* setup INPUT_ROUTE */
840 R300_STATECHANGE(r300, vir[0]);
841 for(i=0;i+1<count;i+=2){
842 dw=(r300->state.aos[i].ncomponents-1)
843 | ((r300->state.aos[i].reg)<<8)
844 | (r300->state.aos[i].format<<14)
845 | (((r300->state.aos[i+1].ncomponents-1)
846 | ((r300->state.aos[i+1].reg)<<8)
847 | (r300->state.aos[i+1].format<<14))<<16);
852 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
855 dw=(r300->state.aos[count-1].ncomponents-1)
856 | (r300->state.aos[count-1].format<<14)
857 | ((r300->state.aos[count-1].reg)<<8)
859 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
860 //fprintf(stderr, "vir0 dw=%08x\n", dw);
862 /* Set the rest of INPUT_ROUTE_0 to 0 */
863 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
864 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
867 /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
868 #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
869 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
870 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
871 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
873 #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
874 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
875 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
876 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
878 R300_STATECHANGE(r300, vir[1]);
880 for(i=0;i+1<count;i+=2){
882 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
883 dw=(ALL_COMPONENTS & mask)
884 | (ALL_DEFAULT & ~mask)
885 | R300_INPUT_ROUTE_ENABLE;
888 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
890 (ALL_COMPONENTS & mask)
891 | (ALL_DEFAULT & ~mask)
892 | R300_INPUT_ROUTE_ENABLE
895 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
898 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
899 dw=(ALL_COMPONENTS & mask)
900 | (ALL_DEFAULT & ~mask)
901 | R300_INPUT_ROUTE_ENABLE;
902 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
903 //fprintf(stderr, "vir1 dw=%08x\n", dw);
905 /* Set the rest of INPUT_ROUTE_1 to 0 */
906 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
907 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
909 /* Set up input_cntl */
911 R300_STATECHANGE(r300, vic);
912 r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555; /* Hard coded value, no idea what it means */
914 r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
915 | R300_INPUT_CNTL_COLOR;
917 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
918 if(ctx->Texture.Unit[i].Enabled)
919 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
921 /* Stage 3: VAP output */
922 R300_STATECHANGE(r300, vof);
923 r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
924 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
926 r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
927 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
928 if(ctx->Texture.Unit[i].Enabled)
929 r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
933 static r300TexObj default_tex_obj={
934 filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
936 size: (0xff << R300_TX_WIDTHMASK_SHIFT)
937 | (0xff << R300_TX_HEIGHTMASK_SHIFT)
938 | (0x8 << R300_TX_SIZE_SHIFT),
945 /* there is probably a system to these value, but, for now,
946 we just try by hand */
948 static int inline translate_src(int src)
957 case GL_PRIMARY_COLOR:
974 /* I think 357 and 457 are prime numbers.. wiggle them if you get coincidences */
975 #define FORMAT_HASH(opRGB, srcRGB, modeRGB, opA, srcA, modeA, format, intFormat) ( \
977 ((opRGB)<<30) | ((opA)<<28) | \
978 ((srcRGB)<< 25) | ((srcA)<<22) | \
982 ^ (((format)) *457) \
983 ^ ((intFormat) * 7) \
987 static GLuint translate_texture_format(GLcontext *ctx, GLint tex_unit, GLuint format, GLint IntFormat,
988 struct gl_texture_format *tex_format)
990 const struct gl_texture_unit *texUnit= &ctx->Texture.Unit[tex_unit];
991 int i=0; /* number of alpha args .. */
995 fprintf(stderr, "_ReallyEnabled=%d EnvMode=%s\n",
996 texUnit->_ReallyEnabled,
997 _mesa_lookup_enum_by_nr(texUnit->EnvMode));
1000 if(tex_format==NULL){
1001 fprintf(stderr, "Aeiii ! tex_format==NULL !!\n");
1005 switch(tex_format->MesaFormat){
1006 case MESA_FORMAT_RGBA8888:
1007 return R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8);
1009 fprintf(stderr, "Do not know format %s\n", _mesa_lookup_enum_by_nr(tex_format->MesaFormat));
1020 fmt=R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1027 //fmt |= ((format) & 0xff00)<<4;
1028 fprintf(stderr, "NumArgsRGB=%d NumArgsA=%d\n",
1029 texUnit->_CurrentCombine->_NumArgsRGB,
1030 texUnit->_CurrentCombine->_NumArgsA);
1032 fprintf(stderr, "fmt=%08x\n", fmt);
1035 /* Size field in format specific first */
1037 texUnit->_CurrentCombine->OperandRGB[i] -GL_SRC_COLOR,
1038 translate_src(texUnit->_CurrentCombine->SourceRGB[i]),
1039 texUnit->_CurrentCombine->ModeRGB,
1040 texUnit->_CurrentCombine->OperandA[i] -GL_SRC_ALPHA,
1041 translate_src(texUnit->_CurrentCombine->SourceA[i]),
1042 texUnit->_CurrentCombine->ModeA,
1046 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA):
1050 return R300_EASY_TX_FORMAT(X, X, CUT_W, W, W8Z8Y8X8);
1051 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA8):
1055 /* Quake3demo -small font on the bottom */
1057 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, GL_RGBA8):
1058 /* Quake3demo - mouse cursor*/
1060 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, 4):
1064 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1065 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, 4):
1070 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1071 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008847, 3):
1076 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, 0x00000003):
1077 /* Tested with NeHe lesson 08 */
1078 //case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x0005547, 0):
1079 /* Can't remember what I tested this with..
1080 try putting return 0 of you see broken textures which
1081 are not being complained about */
1082 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00009947, GL_RGB8):
1083 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, GL_RGB8):
1084 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00003347, GL_RGB8):
1085 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, 3):
1089 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1090 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007847, GL_RGBA8):
1091 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006747, GL_RGBA8):
1092 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006647, GL_RGBA8):
1093 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, GL_RGBA8):
1097 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
1098 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, GL_RGBA8):
1099 return R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) ;
1100 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008845, 0x00008056):
1102 fprintf(stderr, "***\n");
1103 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
1108 static int warn_once=1;
1110 fprintf(stderr, "%s:%s Do not know how to translate texture format - help me !\n",
1111 __FILE__, __FUNCTION__);
1118 void r300_setup_textures(GLcontext *ctx)
1121 struct r300_tex_obj *t;
1122 r300ContextPtr r300 = R300_CONTEXT(ctx);
1123 int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
1124 struct gl_texture_unit *texUnit;
1126 R300_STATECHANGE(r300, txe);
1127 R300_STATECHANGE(r300, tex.filter);
1128 R300_STATECHANGE(r300, tex.unknown1);
1129 R300_STATECHANGE(r300, tex.size);
1130 R300_STATECHANGE(r300, tex.format);
1131 R300_STATECHANGE(r300, tex.offset);
1132 R300_STATECHANGE(r300, tex.unknown4);
1133 R300_STATECHANGE(r300, tex.unknown5);
1134 R300_STATECHANGE(r300, tex.border_color);
1136 r300->state.texture.tc_count=0;
1138 r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
1140 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1141 if (RADEON_DEBUG & DEBUG_STATE)
1142 fprintf(stderr, "mtu=%d\n", mtu);
1144 if(mtu>R300_MAX_TEXTURE_UNITS){
1145 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1146 mtu, R300_MAX_TEXTURE_UNITS);
1150 if(ctx->Texture.Unit[i].Enabled){
1151 t=r300->state.texture.unit[i].texobj;
1152 fprintf(stderr, "format=%08x\n", r300->state.texture.unit[i].format);
1153 r300->state.texture.tc_count++;
1155 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1159 if (RADEON_DEBUG & DEBUG_STATE)
1160 fprintf(stderr, "Activating texture unit %d\n", i);
1162 r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1164 t->filter &= R300_TX_MAG_FILTER_MASK | R300_TX_MIN_FILTER_MASK | R300_TX_MAX_ANISO_MASK
1165 | R300_TX_WRAP_S_MASK | R300_TX_WRAP_T_MASK | R300_TX_WRAP_Q_MASK;
1167 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=t->filter;
1169 /* No idea why linear filtered textures shake when puting random data */
1170 /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1171 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1172 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1173 //fprintf(stderr, "t->format=%08x\n", t->format);
1174 r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
1175 r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1176 r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
1177 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0+i]=t->pp_border_color;
1179 /* We don't know how to set this yet */
1180 //value from r300_lib.c for RGB24
1181 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x88a0c;
1183 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=translate_texture_format(ctx, i, t->format,
1184 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->IntFormat:3,
1185 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->TexFormat:NULL);
1189 fprintf(stderr, "Format=%s IntFormat=%08x MesaFormat=%08x BaseFormat=%s IsCompressed=%d Target=%s\n",
1190 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->Format),
1191 t->base.tObj->Image[0][0]->IntFormat,
1192 t->base.tObj->Image[0][0]->TexFormat->MesaFormat,
1193 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->TexFormat->BaseFormat),
1194 t->base.tObj->Image[0][0]->IsCompressed,
1195 _mesa_lookup_enum_by_nr(t->base.tObj->Target));
1197 fprintf(stderr, "pitch=%08x filter=%08x format=%08x\n", t->pitch, t->filter, r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]);
1198 fprintf(stderr, "unknown1=%08x size=%08x\n", r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i],
1199 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]);
1201 /* Use the code below to quickly find matching texture
1202 formats. Requires an app that displays the same texture
1205 if(r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]==0){
1212 texUnit = &ctx->Texture.Unit[i];
1213 fprintf(stderr, "Want to set FORMAT_HASH(%d, %d, 0x%04x, %d, %d, 0x%04x, 0x%08x, %s(%08x))\n",
1214 texUnit->_CurrentCombine->OperandRGB[0] -GL_SRC_COLOR,
1215 translate_src(texUnit->_CurrentCombine->SourceRGB[0]),
1216 texUnit->_CurrentCombine->ModeRGB,
1217 texUnit->_CurrentCombine->OperandA[0] -GL_SRC_ALPHA,
1218 translate_src(texUnit->_CurrentCombine->SourceA[0]),
1219 texUnit->_CurrentCombine->ModeA,
1221 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->IntFormat),
1222 t->base.tObj->Image[0][0]->IntFormat
1224 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);
1225 fprintf(stderr, "\t_ReallyEnabled=%08x EnvMode=%08x IntFormat=%08x\n", texUnit->_ReallyEnabled, texUnit->EnvMode, t->base.tObj->Image[0][0]->IntFormat);
1230 fprintf(stderr, "Now trying format %08x\n",
1232 fprintf(stderr, "size=%08x\n", t->size);
1234 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=known_formats[fmt];
1235 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=
1236 R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) | (fmt<<24);
1237 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x08a0c | (fmt<<16);
1238 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x58a00 | (fmt);
1239 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x53a0c | (fmt<<24);
1246 ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1247 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1248 ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1249 ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1250 ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1251 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1252 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1253 ((drm_r300_cmd_header_t*)r300->hw.tex.border_color.cmd)->unchecked_state.count = max_texture_unit+1;
1255 if (RADEON_DEBUG & DEBUG_STATE)
1256 fprintf(stderr, "TX_ENABLE: %08x max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1259 void r300_setup_rs_unit(GLcontext *ctx)
1261 r300ContextPtr r300 = R300_CONTEXT(ctx);
1264 /* This needs to be rewritten - it is a hack at best */
1266 R300_STATECHANGE(r300, ri);
1267 R300_STATECHANGE(r300, rc);
1268 R300_STATECHANGE(r300, rr);
1270 for(i = 1; i <= 8; ++i)
1271 r300->hw.ri.cmd[i] = 0x00d10000;
1272 r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1273 r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1274 r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1277 for(i = 2; i <= 8; ++i)
1278 r300->hw.ri.cmd[i] |= 4;
1281 for(i = 1; i <= 8; ++i)
1282 r300->hw.rr.cmd[i] = 0;
1283 /* textures enabled ? */
1284 if(r300->state.texture.tc_count>0){
1286 /* This code only really works with one set of texture coordinates */
1288 /* The second constant is needed to get glxgears display anything .. */
1289 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1290 | R300_RS_CNTL_0_UNKNOWN_18
1291 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1292 r300->hw.rc.cmd[2] = 0xc0;
1295 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1296 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1300 /* The second constant is needed to get glxgears display anything .. */
1301 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1302 r300->hw.rc.cmd[2] = 0;
1304 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1305 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1310 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1312 #define bump_vpu_count(ptr, new_count) do{\
1313 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1314 int _nc=(new_count)/4; \
1315 if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1318 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1322 if(vsf->length==0)return;
1324 if(vsf->length & 0x3){
1325 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1329 switch((dest>>8) & 0xf){
1331 R300_STATECHANGE(r300, vpi);
1332 for(i=0;i<vsf->length;i++)
1333 r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1334 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1338 R300_STATECHANGE(r300, vpp);
1339 for(i=0;i<vsf->length;i++)
1340 r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1341 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1344 R300_STATECHANGE(r300, vps);
1345 for(i=0;i<vsf->length;i++)
1346 r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1347 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1350 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1356 void r300SetupVertexShader(r300ContextPtr rmesa)
1358 GLcontext* ctx = rmesa->radeon.glCtx;
1360 /* Reset state, in case we don't use something */
1361 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1362 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1363 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1366 /* This needs to be replaced by vertex shader generation code */
1369 /* textures enabled ? */
1370 if(rmesa->state.texture.tc_count>0){
1371 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1373 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1377 rmesa->state.vertex_shader.matrix[0].length=16;
1378 memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1380 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1382 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1384 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1385 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1387 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1388 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1392 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1393 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1396 R300_STATECHANGE(rmesa, pvs);
1397 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1398 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1399 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1400 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1401 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1402 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1403 | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1405 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1406 so I leave it as a reminder */
1408 reg_start(R300_VAP_PVS_WAITIDLE,0);
1413 void r300SetupPixelShader(r300ContextPtr rmesa)
1417 /* This needs to be replaced by pixel shader generation code */
1419 /* textures enabled ? */
1420 if(rmesa->state.texture.tc_count>0){
1421 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1423 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1426 R300_STATECHANGE(rmesa, fpt);
1427 for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1428 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1429 rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1431 #define OUTPUT_FIELD(st, reg, field) \
1432 R300_STATECHANGE(rmesa, st); \
1433 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1434 rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1435 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1437 OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1438 OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1439 OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1440 OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1443 R300_STATECHANGE(rmesa, fp);
1445 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1446 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1447 | (rmesa->state.pixel_shader.program.node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
1448 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1449 | (rmesa->state.pixel_shader.program.node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
1450 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1454 rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1455 (rmesa->state.pixel_shader.program.active_nodes-1)
1456 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1458 rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1460 rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1461 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1462 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1463 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1464 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1466 R300_STATECHANGE(rmesa, fpp);
1467 for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1468 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1469 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1470 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1471 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1473 rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1478 * Called by Mesa after an internal state update.
1480 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1482 r300ContextPtr r300 = R300_CONTEXT(ctx);
1484 _swrast_InvalidateState(ctx, new_state);
1485 _swsetup_InvalidateState(ctx, new_state);
1486 _ac_InvalidateState(ctx, new_state);
1487 _tnl_InvalidateState(ctx, new_state);
1488 _ae_invalidate_state(ctx, new_state);
1490 /* Go inefficiency! */
1491 r300ResetHwState(r300);
1496 * Completely recalculates hardware state based on the Mesa state.
1498 void r300ResetHwState(r300ContextPtr r300)
1500 GLcontext* ctx = r300->radeon.glCtx;
1503 if (RADEON_DEBUG & DEBUG_STATE)
1504 fprintf(stderr, "%s\n", __FUNCTION__);
1506 /* This is a place to initialize registers which
1507 have bitfields accessed by different functions
1508 and not all bits are used */
1510 r300->hw.zs.cmd[R300_ZS_CNTL_0] = 0;
1511 r300->hw.zs.cmd[R300_ZS_CNTL_1] = 0;
1512 r300->hw.zs.cmd[R300_ZS_CNTL_2] = 0xffff00;
1515 /* go and compute register values from GL state */
1517 r300UpdateWindow(ctx);
1520 ctx->Color.ColorMask[RCOMP],
1521 ctx->Color.ColorMask[GCOMP],
1522 ctx->Color.ColorMask[BCOMP],
1523 ctx->Color.ColorMask[ACOMP]);
1525 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1526 r300DepthMask(ctx, ctx->Depth.Mask);
1527 r300DepthFunc(ctx, ctx->Depth.Func);
1529 r300UpdateCulling(ctx);
1531 r300_setup_routing(ctx, GL_TRUE);
1533 r300UpdateTextureState(ctx);
1534 r300_setup_textures(ctx);
1535 r300_setup_rs_unit(ctx);
1537 r300SetupVertexShader(r300);
1538 r300SetupPixelShader(r300);
1540 r300_set_blend_state(ctx);
1541 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1543 /* Initialize magic registers
1544 TODO : learn what they really do, or get rid of
1545 those we don't have to touch */
1546 r300->hw.unk2080.cmd[1] = 0x0030045A;
1548 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1549 | R300_VPORT_X_OFFSET_ENA
1550 | R300_VPORT_Y_SCALE_ENA
1551 | R300_VPORT_Y_OFFSET_ENA
1552 | R300_VPORT_Z_SCALE_ENA
1553 | R300_VPORT_Z_OFFSET_ENA
1555 r300->hw.vte.cmd[2] = 0x00000008;
1557 r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1558 r300->hw.unk2134.cmd[2] = 0x00000000;
1560 r300->hw.unk2140.cmd[1] = 0x00000000;
1562 #if 0 /* Done in setup routing */
1563 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1564 r300->hw.vir[0].cmd[1] = 0x21030003;
1566 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1567 r300->hw.vir[1].cmd[1] = 0xF688F688;
1569 r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1570 r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1573 r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1575 r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1577 r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1578 r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1579 r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1580 r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1582 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1583 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1585 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1588 r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1589 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1590 r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1593 r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1594 r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1595 r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1598 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1599 | R300_GB_LINE_STUFF_ENABLE
1600 | R300_GB_TRIANGLE_STUFF_ENABLE;
1602 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1603 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1604 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1605 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1606 | R300_GB_TILE_PIPE_COUNT_R300
1607 | R300_GB_TILE_SIZE_16;
1609 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1610 | R300_GB_TILE_PIPE_COUNT_RV300
1611 | R300_GB_TILE_SIZE_16;
1612 r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1613 r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1615 //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1617 r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1618 r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1619 r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1620 r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1622 r300->hw.unk4214.cmd[1] = 0x00050005;
1624 r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1625 (6 << R300_POINTSIZE_Y_SHIFT);
1627 r300->hw.unk4230.cmd[1] = 0x01800000;
1628 r300->hw.unk4230.cmd[2] = 0x00020006;
1629 r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1631 r300->hw.unk4260.cmd[1] = 0;
1632 r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1633 r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1635 r300->hw.unk4274.cmd[1] = 0x00000002;
1636 r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1637 r300->hw.unk4274.cmd[3] = 0x00000000;
1638 r300->hw.unk4274.cmd[4] = 0x00000000;
1640 r300->hw.unk4288.cmd[1] = 0x00000000;
1641 r300->hw.unk4288.cmd[2] = 0x00000001;
1642 r300->hw.unk4288.cmd[3] = 0x00000000;
1643 r300->hw.unk4288.cmd[4] = 0x00000000;
1644 r300->hw.unk4288.cmd[5] = 0x00000000;
1646 r300->hw.unk42A0.cmd[1] = 0x00000000;
1648 r300->hw.unk42B4.cmd[1] = 0x00000000;
1650 r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1651 r300->hw.unk42C0.cmd[2] = 0x00000000;
1654 r300->hw.unk43A4.cmd[1] = 0x0000001C;
1655 r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1657 r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1660 r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1661 r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1662 r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1663 r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1664 r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1665 r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1666 r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1669 r300->hw.unk46A4.cmd[1] = 0x00001B01;
1670 r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1671 r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1672 r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1673 r300->hw.unk46A4.cmd[5] = 0x00000001;
1676 for(i = 1; i <= 64; ++i) {
1677 /* create NOP instructions */
1678 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1679 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1680 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1681 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1685 r300->hw.unk4BC0.cmd[1] = 0;
1687 r300->hw.unk4BC8.cmd[1] = 0;
1688 r300->hw.unk4BC8.cmd[2] = 0;
1689 r300->hw.unk4BC8.cmd[3] = 0;
1692 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1695 r300->hw.unk4BD8.cmd[1] = 0;
1697 r300->hw.unk4E00.cmd[1] = 0;
1700 r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1701 r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1704 r300->hw.unk4E10.cmd[1] = 0;
1705 r300->hw.unk4E10.cmd[2] = 0;
1706 r300->hw.unk4E10.cmd[3] = 0;
1708 r300->hw.cb.cmd[R300_CB_OFFSET] =
1709 r300->radeon.radeonScreen->backOffset +
1710 r300->radeon.radeonScreen->fbLocation;
1711 r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1712 | R300_COLOR_UNKNOWN_22_23;
1714 r300->hw.unk4E50.cmd[1] = 0;
1715 r300->hw.unk4E50.cmd[2] = 0;
1716 r300->hw.unk4E50.cmd[3] = 0;
1717 r300->hw.unk4E50.cmd[4] = 0;
1718 r300->hw.unk4E50.cmd[5] = 0;
1719 r300->hw.unk4E50.cmd[6] = 0;
1720 r300->hw.unk4E50.cmd[7] = 0;
1721 r300->hw.unk4E50.cmd[8] = 0;
1722 r300->hw.unk4E50.cmd[9] = 0;
1724 r300->hw.unk4E88.cmd[1] = 0;
1726 r300->hw.unk4EA0.cmd[1] = 0x00000000;
1727 r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1729 r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1730 r300->hw.unk4F10.cmd[2] = 0x00000000;
1731 r300->hw.unk4F10.cmd[3] = 0x00000003;
1732 r300->hw.unk4F10.cmd[4] = 0x00000000;
1734 r300->hw.zb.cmd[R300_ZB_OFFSET] =
1735 r300->radeon.radeonScreen->depthOffset +
1736 r300->radeon.radeonScreen->fbLocation;
1737 r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1739 r300->hw.unk4F28.cmd[1] = 0;
1741 r300->hw.unk4F30.cmd[1] = 0;
1742 r300->hw.unk4F30.cmd[2] = 0;
1744 r300->hw.unk4F44.cmd[1] = 0;
1746 r300->hw.unk4F54.cmd[1] = 0;
1749 ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1750 for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1752 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1753 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1754 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1755 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1758 ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1759 for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1760 r300->hw.vpp.cmd[i] = 0;
1763 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1764 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1765 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1766 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1770 r300->hw.all_dirty = GL_TRUE;
1776 * Calculate initial hardware state and register state functions.
1777 * Assumes that the command buffer and state atoms have been
1778 * initialized already.
1780 void r300InitState(r300ContextPtr r300)
1782 GLcontext *ctx = r300->radeon.glCtx;
1785 radeonInitState(&r300->radeon);
1787 switch (ctx->Visual.depthBits) {
1789 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1790 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1791 //r300->state.stencil.clear = 0x00000000;
1794 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1795 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1796 //r300->state.stencil.clear = 0xff000000;
1799 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1800 ctx->Visual.depthBits);
1804 /* Only have hw stencil when depth buffer is 24 bits deep */
1805 r300->state.hw_stencil = (ctx->Visual.stencilBits > 0 &&
1806 ctx->Visual.depthBits == 24);
1808 memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1810 r300ResetHwState(r300);
1816 * Initialize driver's state callback functions
1818 void r300InitStateFuncs(struct dd_function_table* functions)
1820 radeonInitStateFuncs(functions);
1822 functions->UpdateState = r300InvalidateState;
1823 functions->AlphaFunc = r300AlphaFunc;
1824 functions->BlendColor = r300BlendColor;
1825 functions->BlendEquationSeparate = r300BlendEquationSeparate;
1826 functions->BlendFuncSeparate = r300BlendFuncSeparate;
1827 functions->Enable = r300Enable;
1828 functions->ColorMask = r300ColorMask;
1829 functions->DepthFunc = r300DepthFunc;
1830 functions->DepthMask = r300DepthMask;
1831 functions->CullFace = r300CullFace;
1832 functions->FrontFace = r300FrontFace;
1834 /* Stencil related */
1835 functions->ClearStencil = r300ClearStencil;
1836 functions->StencilFunc = r300StencilFunc;
1837 functions->StencilMask = r300StencilMask;
1838 functions->StencilOp = r300StencilOp;
1840 /* Viewport related */
1841 functions->Viewport = r300Viewport;
1842 functions->DepthRange = r300DepthRange;
1843 functions->PointSize = r300PointSize;