projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Properly configure routing - based on advice by Keith Whitwell.
[mesa.git] / src / mesa / drivers / dri / r300 / r300_state.c
1 /*
2 Copyright (C) The Weather Channel, Inc. 2002.
3 Copyright (C) 2004 Nicolai Haehnle.
4 All Rights Reserved.
5
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.
9
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:
17
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.
21
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.
29
30 **************************************************************************/
31
32 /*
33 * Authors:
34 * Nicolai Haehnle <prefect_@gmx.net>
35 */
36
37 #include "glheader.h"
38 #include "state.h"
39 #include "imports.h"
40 #include "enums.h"
41 #include "macros.h"
42 #include "context.h"
43 #include "dd.h"
44 #include "simple_list.h"
45
46 #include "api_arrayelt.h"
47 #include "swrast/swrast.h"
48 #include "swrast_setup/swrast_setup.h"
49 #include "array_cache/acache.h"
50 #include "tnl/tnl.h"
51 #include "texformat.h"
52
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"
58 #include "r300_reg.h"
59 #include "r300_program.h"
60 #include "r300_emit.h"
61 #include "r300_fixed_pipelines.h"
62
63 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
64 {
65 r300ContextPtr rmesa = R300_CONTEXT(ctx);
66 int pp_misc = rmesa->hw.at.cmd[R300_AT_ALPHA_TEST];
67 GLubyte refByte;
68
69 CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
70
71 R300_STATECHANGE(rmesa, at);
72
73 pp_misc &= ~(R300_ALPHA_TEST_OP_MASK | R300_REF_ALPHA_MASK);
74 pp_misc |= (refByte & R300_REF_ALPHA_MASK);
75
76 switch (func) {
77 case GL_NEVER:
78 pp_misc |= R300_ALPHA_TEST_FAIL;
79 break;
80 case GL_LESS:
81 pp_misc |= R300_ALPHA_TEST_LESS;
82 break;
83 case GL_EQUAL:
84 pp_misc |= R300_ALPHA_TEST_EQUAL;
85 break;
86 case GL_LEQUAL:
87 pp_misc |= R300_ALPHA_TEST_LEQUAL;
88 break;
89 case GL_GREATER:
90 pp_misc |= R300_ALPHA_TEST_GREATER;
91 break;
92 case GL_NOTEQUAL:
93 pp_misc |= R300_ALPHA_TEST_NEQUAL;
94 break;
95 case GL_GEQUAL:
96 pp_misc |= R300_ALPHA_TEST_GEQUAL;
97 break;
98 case GL_ALWAYS:
99 pp_misc |= R300_ALPHA_TEST_PASS;
100 break;
101 }
102
103 rmesa->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
104 }
105
106 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
107 {
108 GLubyte color[4];
109 r300ContextPtr rmesa = R300_CONTEXT(ctx);
110 fprintf(stderr, "%s:%s is not implemented yet. Fixme !\n", __FILE__, __FUNCTION__);
111 #if 0
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]);
120 #endif
121 }
122
123 /**
124 * Calculate the hardware blend factor setting. This same function is used
125 * for source and destination of both alpha and RGB.
126 *
127 * \returns
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.
131 *
132 * \todo
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.
136 */
137 static int blend_factor(GLenum factor, GLboolean is_src)
138 {
139 int func;
140
141 switch (factor) {
142 case GL_ZERO:
143 func = R200_BLEND_GL_ZERO;
144 break;
145 case GL_ONE:
146 func = R200_BLEND_GL_ONE;
147 break;
148 case GL_DST_COLOR:
149 func = R200_BLEND_GL_DST_COLOR;
150 break;
151 case GL_ONE_MINUS_DST_COLOR:
152 func = R200_BLEND_GL_ONE_MINUS_DST_COLOR;
153 break;
154 case GL_SRC_COLOR:
155 func = R200_BLEND_GL_SRC_COLOR;
156 break;
157 case GL_ONE_MINUS_SRC_COLOR:
158 func = R200_BLEND_GL_ONE_MINUS_SRC_COLOR;
159 break;
160 case GL_SRC_ALPHA:
161 func = R200_BLEND_GL_SRC_ALPHA;
162 break;
163 case GL_ONE_MINUS_SRC_ALPHA:
164 func = R200_BLEND_GL_ONE_MINUS_SRC_ALPHA;
165 break;
166 case GL_DST_ALPHA:
167 func = R200_BLEND_GL_DST_ALPHA;
168 break;
169 case GL_ONE_MINUS_DST_ALPHA:
170 func = R200_BLEND_GL_ONE_MINUS_DST_ALPHA;
171 break;
172 case GL_SRC_ALPHA_SATURATE:
173 func =
174 (is_src) ? R200_BLEND_GL_SRC_ALPHA_SATURATE :
175 R200_BLEND_GL_ZERO;
176 break;
177 case GL_CONSTANT_COLOR:
178 func = R200_BLEND_GL_CONST_COLOR;
179 break;
180 case GL_ONE_MINUS_CONSTANT_COLOR:
181 func = R200_BLEND_GL_ONE_MINUS_CONST_COLOR;
182 break;
183 case GL_CONSTANT_ALPHA:
184 func = R200_BLEND_GL_CONST_ALPHA;
185 break;
186 case GL_ONE_MINUS_CONSTANT_ALPHA:
187 func = R200_BLEND_GL_ONE_MINUS_CONST_ALPHA;
188 break;
189 default:
190 func = (is_src) ? R200_BLEND_GL_ONE : R200_BLEND_GL_ZERO;
191 }
192 return func;
193 }
194
195 /**
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
203 * unknown reasons.
204 */
205
206 /* helper function */
207 static void r300_set_blend_cntl(r300ContextPtr rmesa, int func, int eqn, int cbits, int funcA, int eqnA)
208 {
209 GLuint new_ablend, new_cblend;
210
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;
215 }
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;
221 }
222 }
223
224 static void r300_set_blend_state(GLcontext * ctx)
225 {
226 r300ContextPtr rmesa = R300_CONTEXT(ctx);
227 #if 0
228 GLuint cntl = rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &
229 ~(R300_ROP_ENABLE | R300_ALPHA_BLEND_ENABLE |
230 R300_SEPARATE_ALPHA_ENABLE);
231 #endif
232
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;
239
240
241 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
242 if (ctx->Color._LogicOpEnabled) {
243 #if 0
244 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
245 cntl | R300_ROP_ENABLE;
246 #endif
247 r300_set_blend_cntl(rmesa,
248 func, eqn, 0,
249 func, eqn);
250 return;
251 } else if (ctx->Color.BlendEnabled) {
252 #if 0
253 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
254 cntl | R300_ALPHA_BLEND_ENABLE |
255 R300_SEPARATE_ALPHA_ENABLE;
256 #endif
257 } else {
258 #if 0
259 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
260 #endif
261 r300_set_blend_cntl(rmesa,
262 func, eqn, 0,
263 func, eqn);
264 return;
265 }
266 } else {
267 if (ctx->Color._LogicOpEnabled) {
268 #if 0
269 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
270 cntl | R300_ROP_ENABLE;
271 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
272 #endif
273 return;
274 } else if (ctx->Color.BlendEnabled) {
275 #if 0
276 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
277 cntl | R300_ALPHA_BLEND_ENABLE;
278 #endif
279 } else {
280 #if 0
281 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
282 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
283 #endif
284 r300_set_blend_cntl(rmesa,
285 func, eqn, 0,
286 func, eqn);
287 return;
288 }
289 }
290
291 func =
292 (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
293 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
294 GL_FALSE) <<
295 R200_DST_BLEND_SHIFT);
296
297 switch (ctx->Color.BlendEquationRGB) {
298 case GL_FUNC_ADD:
299 eqn = R300_COMB_FCN_ADD_CLAMP;
300 break;
301
302 case GL_FUNC_SUBTRACT:
303 eqn = R300_COMB_FCN_SUB_CLAMP;
304 break;
305
306 case GL_FUNC_REVERSE_SUBTRACT:
307 eqn = R200_COMB_FCN_RSUB_CLAMP;
308 break;
309
310 case GL_MIN:
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);
314 break;
315
316 case GL_MAX:
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);
320 break;
321
322 default:
323 fprintf(stderr,
324 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
325 __func__, __LINE__, ctx->Color.BlendEquationRGB);
326 return;
327 }
328
329 if (!rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
330 #if 0
331 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
332 #endif
333 return;
334 }
335
336 funcA =
337 (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
338 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
339 GL_FALSE) <<
340 R200_DST_BLEND_SHIFT);
341
342 switch (ctx->Color.BlendEquationA) {
343 case GL_FUNC_ADD:
344 eqnA = R300_COMB_FCN_ADD_CLAMP;
345 break;
346
347 case GL_FUNC_SUBTRACT:
348 eqnA = R300_COMB_FCN_SUB_CLAMP;
349 break;
350
351 case GL_FUNC_REVERSE_SUBTRACT:
352 eqnA = R200_COMB_FCN_RSUB_CLAMP;
353 break;
354
355 case GL_MIN:
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);
359 break;
360
361 case GL_MAX:
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);
365 break;
366
367 default:
368 fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n",
369 __func__, __LINE__, ctx->Color.BlendEquationA);
370 return;
371 }
372
373 r300_set_blend_cntl(rmesa,
374 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
375 funcA, eqnA);
376 r300_set_blend_cntl(rmesa,
377 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
378 funcA, eqnA);
379 }
380
381 static void r300BlendEquationSeparate(GLcontext * ctx,
382 GLenum modeRGB, GLenum modeA)
383 {
384 r300_set_blend_state(ctx);
385 }
386
387 static void r300BlendFuncSeparate(GLcontext * ctx,
388 GLenum sfactorRGB, GLenum dfactorRGB,
389 GLenum sfactorA, GLenum dfactorA)
390 {
391 r300_set_blend_state(ctx);
392 }
393
394 /**
395 * Update our tracked culling state based on Mesa's state.
396 */
397 static void r300UpdateCulling(GLcontext* ctx)
398 {
399 r300ContextPtr r300 = R300_CONTEXT(ctx);
400 uint32_t val = 0;
401
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;
408 else
409 val = R300_CULL_BACK;
410
411 if (ctx->Polygon.FrontFace == GL_CW)
412 val |= R300_FRONT_FACE_CW;
413 else
414 val |= R300_FRONT_FACE_CCW;
415 }
416
417 r300->hw.cul.cmd[R300_CUL_CULL] = val;
418 }
419
420
421 /**
422 * Handle glEnable()/glDisable().
423 *
424 * \note Mesa already filters redundant calls to glEnable/glDisable.
425 */
426 static void r300Enable(GLcontext* ctx, GLenum cap, GLboolean state)
427 {
428 r300ContextPtr r300 = R300_CONTEXT(ctx);
429 uint32_t newval;
430
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");
435
436 switch (cap) {
437 /* Fast track this one...
438 */
439 case GL_TEXTURE_1D:
440 case GL_TEXTURE_2D:
441 case GL_TEXTURE_3D:
442 break;
443
444 case GL_ALPHA_TEST:
445 R200_STATECHANGE(r300, at);
446 if (state) {
447 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
448 R300_ALPHA_TEST_ENABLE;
449 } else {
450 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
451 ~R300_ALPHA_TEST_ENABLE;
452 }
453 break;
454
455 case GL_BLEND:
456 case GL_COLOR_LOGIC_OP:
457 r300_set_blend_state(ctx);
458 break;
459
460 case GL_DEPTH_TEST:
461 R300_STATECHANGE(r300, zs);
462
463 if (state) {
464 if (ctx->Depth.Mask)
465 newval = R300_RB3D_Z_TEST_AND_WRITE;
466 else
467 newval = R300_RB3D_Z_TEST;
468 } else
469 newval = 0;
470
471 r300->hw.zs.cmd[R300_ZS_CNTL_0] = newval;
472 break;
473
474 case GL_STENCIL_TEST:
475
476 {
477 static int stencil=1;
478 if(stencil){
479 fprintf(stderr, "%s:%s - do not know how to enable stencil. Help me !\n",
480 __FILE__, __FUNCTION__);
481 stencil=0;
482 }
483 }
484
485 if (r300->state.hw_stencil) {
486 //fprintf(stderr, "Stencil %s\n", state ? "enabled" : "disabled");
487 R300_STATECHANGE(r300, zs);
488 if (state) {
489 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
490 R300_STENCIL_ENABLE;
491 } else {
492 r300->hw.zs.cmd[R300_ZS_CNTL_0] &=
493 ~R300_STENCIL_ENABLE;
494 }
495 } else {
496 FALLBACK(&r300->radeon, RADEON_FALLBACK_STENCIL, state);
497 }
498 break;
499
500 case GL_CULL_FACE:
501 r300UpdateCulling(ctx);
502 break;
503
504 default:
505 radeonEnable(ctx, cap, state);
506 return;
507 }
508 }
509
510
511 /**
512 * Change the culling mode.
513 *
514 * \note Mesa already filters redundant calls to this function.
515 */
516 static void r300CullFace(GLcontext* ctx, GLenum mode)
517 {
518 (void)mode;
519
520 r300UpdateCulling(ctx);
521 }
522
523
524 /**
525 * Change the polygon orientation.
526 *
527 * \note Mesa already filters redundant calls to this function.
528 */
529 static void r300FrontFace(GLcontext* ctx, GLenum mode)
530 {
531 (void)mode;
532
533 r300UpdateCulling(ctx);
534 }
535
536
537 /**
538 * Change the depth testing function.
539 *
540 * \note Mesa already filters redundant calls to this function.
541 */
542 static void r300DepthFunc(GLcontext* ctx, GLenum func)
543 {
544 r300ContextPtr r300 = R300_CONTEXT(ctx);
545
546 R300_STATECHANGE(r300, zs);
547
548 r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
549
550 switch(func) {
551 case GL_NEVER:
552 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NEVER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
553 break;
554 case GL_LESS:
555 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LESS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
556 break;
557 case GL_EQUAL:
558 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_EQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
559 break;
560 case GL_LEQUAL:
561 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
562 break;
563 case GL_GREATER:
564 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GREATER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
565 break;
566 case GL_NOTEQUAL:
567 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NOTEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
568 break;
569 case GL_GEQUAL:
570 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
571 break;
572 case GL_ALWAYS:
573 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_ALWAYS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
574 break;
575 }
576
577 }
578
579
580 /**
581 * Enable/Disable depth writing.
582 *
583 * \note Mesa already filters redundant calls to this function.
584 */
585 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
586 {
587 r300ContextPtr r300 = R300_CONTEXT(ctx);
588
589 if (!ctx->Depth.Test)
590 return;
591
592 R300_STATECHANGE(r300, zs);
593 r300->hw.zs.cmd[R300_ZS_CNTL_0] = mask
594 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
595 }
596
597
598 /**
599 * Handle glColorMask()
600 */
601 static void r300ColorMask(GLcontext* ctx,
602 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
603 {
604 r300ContextPtr r300 = R300_CONTEXT(ctx);
605 int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
606
607 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
608 R300_STATECHANGE(r300, cmk);
609 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
610 }
611 }
612
613 /* =============================================================
614 * Point state
615 */
616 static void r300PointSize(GLcontext * ctx, GLfloat size)
617 {
618 r300ContextPtr r300 = R300_CONTEXT(ctx);
619
620 /* This might need fixing later */
621 R300_STATECHANGE(r300, vps);
622 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
623 }
624 /* =============================================================
625 * Stencil
626 */
627
628 static int translate_stencil_func(int func)
629 {
630 switch (func) {
631 case GL_NEVER:
632 return R300_ZS_NEVER;
633 break;
634 case GL_LESS:
635 return R300_ZS_LESS;
636 break;
637 case GL_EQUAL:
638 return R300_ZS_EQUAL;
639 break;
640 case GL_LEQUAL:
641 return R300_ZS_LEQUAL;
642 break;
643 case GL_GREATER:
644 return R300_ZS_GREATER;
645 break;
646 case GL_NOTEQUAL:
647 return R300_ZS_NOTEQUAL;
648 break;
649 case GL_GEQUAL:
650 return R300_ZS_GEQUAL;
651 break;
652 case GL_ALWAYS:
653 return R300_ZS_ALWAYS;
654 break;
655 }
656 return 0;
657 }
658
659 static int translate_stencil_op(int op)
660 {
661 switch (op) {
662 case GL_KEEP:
663 return R300_ZS_KEEP;
664 case GL_ZERO:
665 return R300_ZS_ZERO;
666 case GL_REPLACE:
667 return R300_ZS_REPLACE;
668 case GL_INCR:
669 return R300_ZS_INCR;
670 case GL_DECR:
671 return R300_ZS_DECR;
672 case GL_INCR_WRAP_EXT:
673 return R300_ZS_INCR_WRAP;
674 case GL_DECR_WRAP_EXT:
675 return R300_ZS_DECR_WRAP;
676 case GL_INVERT:
677 return R300_ZS_INVERT;
678 }
679 }
680
681 static void r300StencilFunc(GLcontext * ctx, GLenum func,
682 GLint ref, GLuint mask)
683 {
684 r300ContextPtr rmesa = R300_CONTEXT(ctx);
685 GLuint refmask = ((ctx->Stencil.Ref[0] << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
686 (ctx->Stencil.
687 ValueMask[0] << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
688 GLuint func;
689
690 R200_STATECHANGE(rmesa, zs);
691
692 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(
693 (R300_ZS_MASK << R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
694 | (R300_ZS_MASK << R300_RB3D_ZS1_BACK_FUNC_SHIFT));
695 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &= ~((R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
696 (R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
697
698 func = translate_stencil_func(ctx->Stencil.Function[0]);
699
700 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |= (func << R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
701 | (func << R300_RB3D_ZS1_BACK_FUNC_SHIFT);
702 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
703 }
704
705 static void r300StencilMask(GLcontext * ctx, GLuint mask)
706 {
707 r300ContextPtr rmesa = R300_CONTEXT(ctx);
708
709 R200_STATECHANGE(rmesa, zs);
710 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &= ~(R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT);
711 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= ctx->Stencil.WriteMask[0] << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT;
712 }
713
714
715 static void r300StencilOp(GLcontext * ctx, GLenum fail,
716 GLenum zfail, GLenum zpass)
717 {
718 r300ContextPtr rmesa = R300_CONTEXT(ctx);
719
720 R200_STATECHANGE(rmesa, zs);
721 /* It is easier to mask what's left.. */
722 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= (R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
723
724 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
725 (translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_FRONT_FAIL_OP_SHIFT)
726 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_FRONT_ZFAIL_OP_SHIFT)
727 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_FRONT_ZPASS_OP_SHIFT)
728 |(translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_BACK_FAIL_OP_SHIFT)
729 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_BACK_ZFAIL_OP_SHIFT)
730 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_BACK_ZPASS_OP_SHIFT);
731
732 }
733
734 static void r300ClearStencil(GLcontext * ctx, GLint s)
735 {
736 r300ContextPtr rmesa = R300_CONTEXT(ctx);
737
738 /* Not sure whether this is correct.. */
739 R200_STATECHANGE(rmesa, zs);
740 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] =
741 ((GLuint) ctx->Stencil.Clear |
742 (0xff << R200_STENCIL_MASK_SHIFT) |
743 (ctx->Stencil.WriteMask[0] << R200_STENCIL_WRITEMASK_SHIFT));
744 }
745
746 /* =============================================================
747 * Window position and viewport transformation
748 */
749
750 /*
751 * To correctly position primitives:
752 */
753 #define SUBPIXEL_X 0.125
754 #define SUBPIXEL_Y 0.125
755
756 void r300UpdateWindow(GLcontext * ctx)
757 {
758 r300ContextPtr rmesa = R300_CONTEXT(ctx);
759 __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
760 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
761 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
762 const GLfloat *v = ctx->Viewport._WindowMap.m;
763
764 GLfloat sx = v[MAT_SX];
765 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
766 GLfloat sy = -v[MAT_SY];
767 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
768 GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
769 GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
770
771 R300_FIREVERTICES(rmesa);
772 R300_STATECHANGE(rmesa, vpt);
773
774 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
775 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
776 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
777 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
778 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
779 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
780 }
781
782 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
783 GLsizei width, GLsizei height)
784 {
785 /* Don't pipeline viewport changes, conflict with window offset
786 * setting below. Could apply deltas to rescue pipelined viewport
787 * values, or keep the originals hanging around.
788 */
789 R200_FIREVERTICES(R200_CONTEXT(ctx));
790 r300UpdateWindow(ctx);
791 }
792
793 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
794 {
795 r300UpdateWindow(ctx);
796 }
797
798 /* Routing and texture-related */
799
800 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
801 {
802 int i, count=0,reg=0;
803 GLuint dw, mask;
804 TNLcontext *tnl = TNL_CONTEXT(ctx);
805 struct vertex_buffer *VB = &tnl->vb;
806 r300ContextPtr r300 = R300_CONTEXT(ctx);
807
808
809 /* Stage 1 - input to VAP */
810
811 /* Assign register number automatically, retaining it in rmesa->state.reg */
812
813 /* Note: immediate vertex data includes all coordinates.
814 To save bandwidth use either VBUF or state-based vertex generation */
815
816 #define CONFIGURE_AOS(v, o, r, f) \
817 {\
818 if (RADEON_DEBUG & DEBUG_STATE)fprintf(stderr, "Enabling "#r "\n"); \
819 if(immediate){ \
820 r300->state.aos[count].element_size=4; \
821 r300->state.aos[count].stride=4; \
822 r300->state.aos[count].ncomponents=4; \
823 } else { \
824 r300->state.aos[count].element_size=v->size; \
825 r300->state.aos[count].stride=v->size; \
826 r300->state.aos[count].ncomponents=v->size; \
827 } \
828 r300->state.aos[count].offset=o; \
829 r300->state.aos[count].reg=reg; \
830 r300->state.aos[count].format=(f); \
831 r300->state.vap_reg.r=reg; \
832 count++; \
833 reg++; \
834 }
835
836 /* All offsets are 0 - for use by immediate mode.
837 Should change later to handle vertex buffers */
838 if(tnl->render_inputs & _TNL_BIT_POS)
839 CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
840 if(tnl->render_inputs & _TNL_BIT_NORMAL)
841 CONFIGURE_AOS(VB->NormalPtr, 0, i_normal, AOS_FORMAT_FLOAT);
842
843 if(tnl->render_inputs & _TNL_BIT_COLOR0)
844 CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
845 if(tnl->render_inputs & _TNL_BIT_COLOR1)
846 CONFIGURE_AOS(VB->ColorPtr[1], 0, i_color[1], AOS_FORMAT_FLOAT_COLOR);
847
848 if(tnl->render_inputs & _TNL_BIT_FOG)
849 CONFIGURE_AOS(VB->FogCoordPtr, 0, i_fog, AOS_FORMAT_FLOAT);
850
851 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
852 if(tnl->render_inputs & (_TNL_BIT_TEX0<<i))
853 CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
854
855 if(tnl->render_inputs & _TNL_BIT_INDEX)
856 CONFIGURE_AOS(VB->IndexPtr[0], 0, i_index, AOS_FORMAT_FLOAT);
857 if(tnl->render_inputs & _TNL_BIT_POINTSIZE)
858 CONFIGURE_AOS(VB->PointSizePtr, 0, i_pointsize, AOS_FORMAT_FLOAT);
859
860 r300->state.aos_count=count;
861
862 if (RADEON_DEBUG & DEBUG_STATE)
863 fprintf(stderr, "aos_count=%d\n", count);
864
865 if(count>R300_MAX_AOS_ARRAYS){
866 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
867 exit(-1);
868 }
869
870 /* Implement AOS */
871
872 /* setup INPUT_ROUTE */
873 R300_STATECHANGE(r300, vir[0]);
874 for(i=0;i+1<count;i+=2){
875 dw=(r300->state.aos[i].ncomponents-1)
876 | ((r300->state.aos[i].reg)<<8)
877 | (r300->state.aos[i].format<<14)
878 | (((r300->state.aos[i+1].ncomponents-1)
879 | ((r300->state.aos[i+1].reg)<<8)
880 | (r300->state.aos[i+1].format<<14))<<16);
881
882 if(i+2==count){
883 dw|=(1<<(13+16));
884 }
885 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
886 }
887 if(count & 1){
888 dw=(r300->state.aos[count-1].ncomponents-1)
889 | (r300->state.aos[count-1].format<<14)
890 | ((r300->state.aos[count-1].reg)<<8)
891 | (1<<13);
892 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
893 //fprintf(stderr, "vir0 dw=%08x\n", dw);
894 }
895 /* Set the rest of INPUT_ROUTE_0 to 0 */
896 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
897 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
898
899
900 /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
901 #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
902 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
903 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
904 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
905
906 #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
907 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
908 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
909 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
910
911 R300_STATECHANGE(r300, vir[1]);
912
913 for(i=0;i+1<count;i+=2){
914 /* do i first.. */
915 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
916 dw=(ALL_COMPONENTS & mask)
917 | (ALL_DEFAULT & ~mask)
918 | R300_INPUT_ROUTE_ENABLE;
919
920 /* i+1 */
921 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
922 dw|=(
923 (ALL_COMPONENTS & mask)
924 | (ALL_DEFAULT & ~mask)
925 | R300_INPUT_ROUTE_ENABLE
926 )<<16;
927
928 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
929 }
930 if(count & 1){
931 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
932 dw=(ALL_COMPONENTS & mask)
933 | (ALL_DEFAULT & ~mask)
934 | R300_INPUT_ROUTE_ENABLE;
935 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
936 //fprintf(stderr, "vir1 dw=%08x\n", dw);
937 }
938 /* Set the rest of INPUT_ROUTE_1 to 0 */
939 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
940 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
941
942 /* Set up input_cntl */
943
944 R300_STATECHANGE(r300, vic);
945 r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555; /* Hard coded value, no idea what it means */
946
947 r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
948 | R300_INPUT_CNTL_COLOR;
949
950 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
951 if(ctx->Texture.Unit[i].Enabled)
952 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
953
954 /* Stage 3: VAP output */
955 R300_STATECHANGE(r300, vof);
956 r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
957 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
958
959 r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
960 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
961 if(ctx->Texture.Unit[i].Enabled)
962 r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
963
964 }
965
966 static r300TexObj default_tex_obj={
967 filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
968 pitch: 0x8000,
969 size: (0xff << R300_TX_WIDTHMASK_SHIFT)
970 | (0xff << R300_TX_HEIGHTMASK_SHIFT)
971 | (0x8 << R300_TX_SIZE_SHIFT),
972 format: 0x88a0c,
973 offset: 0x0,
974 unknown4: 0x0,
975 unknown5: 0x0
976 };
977
978 /* there is probably a system to these value, but, for now,
979 we just try by hand */
980
981 static int inline translate_src(int src)
982 {
983 switch (src) {
984 case GL_TEXTURE:
985 return 1;
986 break;
987 case GL_CONSTANT:
988 return 2;
989 break;
990 case GL_PRIMARY_COLOR:
991 return 3;
992 break;
993 case GL_PREVIOUS:
994 return 4;
995 break;
996 case GL_ZERO:
997 return 5;
998 break;
999 case GL_ONE:
1000 return 6;
1001 break;
1002 default:
1003 return 0;
1004 }
1005 }
1006
1007 /* I think 357 and 457 are prime numbers.. wiggle them if you get coincidences */
1008 #define FORMAT_HASH(opRGB, srcRGB, modeRGB, opA, srcA, modeA, format, intFormat) ( \
1009 (\
1010 ((opRGB)<<30) | ((opA)<<28) | \
1011 ((srcRGB)<< 25) | ((srcA)<<22) | \
1012 ((modeRGB)) \
1013 ) \
1014 ^ ((modeA)*357) \
1015 ^ (((format)) *457) \
1016 ^ ((intFormat) * 7) \
1017 )
1018
1019
1020 static GLuint translate_texture_format(GLcontext *ctx, GLint tex_unit, GLuint format, GLint IntFormat,
1021 struct gl_texture_format *tex_format)
1022 {
1023 const struct gl_texture_unit *texUnit= &ctx->Texture.Unit[tex_unit];
1024 int i=0; /* number of alpha args .. */
1025 GLuint fmt;
1026
1027 #if 0
1028 fprintf(stderr, "_ReallyEnabled=%d EnvMode=%s\n",
1029 texUnit->_ReallyEnabled,
1030 _mesa_lookup_enum_by_nr(texUnit->EnvMode));
1031 #endif
1032
1033 if(tex_format==NULL){
1034 fprintf(stderr, "Aeiii ! tex_format==NULL !!\n");
1035 return 0;
1036 }
1037
1038 switch(tex_format->MesaFormat){
1039 case MESA_FORMAT_RGBA8888:
1040 return R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8);
1041 default:
1042 fprintf(stderr, "Do not know format %s\n", _mesa_lookup_enum_by_nr(tex_format->MesaFormat));
1043 return 0;
1044 }
1045
1046 switch(IntFormat){
1047 case 4:
1048 case GL_RGBA:
1049 case GL_RGBA8:
1050 break;
1051 case 3:
1052 case GL_RGB8:
1053 fmt=R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1054 break;
1055 default:
1056 return 0;
1057 }
1058 #if 1
1059 //fmt &= 0x00fff;
1060 //fmt |= ((format) & 0xff00)<<4;
1061 fprintf(stderr, "NumArgsRGB=%d NumArgsA=%d\n",
1062 texUnit->_CurrentCombine->_NumArgsRGB,
1063 texUnit->_CurrentCombine->_NumArgsA);
1064
1065 fprintf(stderr, "fmt=%08x\n", fmt);
1066 #endif
1067 return fmt;
1068 /* Size field in format specific first */
1069 switch(FORMAT_HASH(
1070 texUnit->_CurrentCombine->OperandRGB[i] -GL_SRC_COLOR,
1071 translate_src(texUnit->_CurrentCombine->SourceRGB[i]),
1072 texUnit->_CurrentCombine->ModeRGB,
1073 texUnit->_CurrentCombine->OperandA[i] -GL_SRC_ALPHA,
1074 translate_src(texUnit->_CurrentCombine->SourceA[i]),
1075 texUnit->_CurrentCombine->ModeA,
1076 format,
1077 IntFormat
1078 )){
1079 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA):
1080 /* tested with:
1081 kfiresaver.kss
1082 */
1083 return R300_EASY_TX_FORMAT(X, X, CUT_W, W, W8Z8Y8X8);
1084 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA8):
1085 /* tested with:
1086 Quake3demo
1087 */
1088 /* Quake3demo -small font on the bottom */
1089 return fmt;
1090 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, GL_RGBA8):
1091 /* Quake3demo - mouse cursor*/
1092 return fmt;
1093 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, 4):
1094 /* tested with:
1095 kfiresaver.kss
1096 */
1097 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1098 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, 4):
1099 /* tested with:
1100 kfiresaver.kss
1101 kfountain.kss
1102 */
1103 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1104 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008847, 3):
1105 /* tested with
1106 lesson 06
1107 lesson 07
1108 */
1109 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, 0x00000003):
1110 /* Tested with NeHe lesson 08 */
1111 //case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x0005547, 0):
1112 /* Can't remember what I tested this with..
1113 try putting return 0 of you see broken textures which
1114 are not being complained about */
1115 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00009947, GL_RGB8):
1116 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, GL_RGB8):
1117 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00003347, GL_RGB8):
1118 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, 3):
1119 /* Tested with:
1120 Quake3demo
1121 */
1122 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
1123 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007847, GL_RGBA8):
1124 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006747, GL_RGBA8):
1125 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006647, GL_RGBA8):
1126 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, GL_RGBA8):
1127 /* Tested with:
1128 Quake3demo
1129 */
1130 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
1131 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, GL_RGBA8):
1132 return R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) ;
1133 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008845, 0x00008056):
1134 //return 0;
1135 fprintf(stderr, "***\n");
1136 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
1137 }
1138
1139
1140 {
1141 static int warn_once=1;
1142 if(warn_once){
1143 fprintf(stderr, "%s:%s Do not know how to translate texture format - help me !\n",
1144 __FILE__, __FUNCTION__);
1145 warn_once=0;
1146 }
1147 }
1148 return 0;
1149 }
1150
1151 void r300_setup_textures(GLcontext *ctx)
1152 {
1153 int i, mtu;
1154 struct r300_tex_obj *t;
1155 r300ContextPtr r300 = R300_CONTEXT(ctx);
1156 int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
1157 struct gl_texture_unit *texUnit;
1158
1159 R300_STATECHANGE(r300, txe);
1160 R300_STATECHANGE(r300, tex.filter);
1161 R300_STATECHANGE(r300, tex.unknown1);
1162 R300_STATECHANGE(r300, tex.size);
1163 R300_STATECHANGE(r300, tex.format);
1164 R300_STATECHANGE(r300, tex.offset);
1165 R300_STATECHANGE(r300, tex.unknown4);
1166 R300_STATECHANGE(r300, tex.unknown5);
1167 R300_STATECHANGE(r300, tex.border_color);
1168
1169 r300->state.texture.tc_count=0;
1170
1171 r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
1172
1173 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1174 if (RADEON_DEBUG & DEBUG_STATE)
1175 fprintf(stderr, "mtu=%d\n", mtu);
1176
1177 if(mtu>R300_MAX_TEXTURE_UNITS){
1178 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1179 mtu, R300_MAX_TEXTURE_UNITS);
1180 exit(-1);
1181 }
1182 for(i=0;i<mtu;i++){
1183 if(ctx->Texture.Unit[i].Enabled){
1184 t=r300->state.texture.unit[i].texobj;
1185 fprintf(stderr, "format=%08x\n", r300->state.texture.unit[i].format);
1186 r300->state.texture.tc_count++;
1187 if(t==NULL){
1188 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1189 //exit(-1);
1190 t=&default_tex_obj;
1191 }
1192 if (RADEON_DEBUG & DEBUG_STATE)
1193 fprintf(stderr, "Activating texture unit %d\n", i);
1194 max_texture_unit=i;
1195 r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1196
1197 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=t->filter;
1198
1199 /* No idea why linear filtered textures shake when puting random data */
1200 /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1201 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1202 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1203 //fprintf(stderr, "t->format=%08x\n", t->format);
1204 r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
1205 r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1206 r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
1207 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0+i]=t->pp_border_color;
1208
1209 /* We don't know how to set this yet */
1210 //value from r300_lib.c for RGB24
1211 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x88a0c;
1212 #if 0
1213 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=translate_texture_format(ctx, i, t->format,
1214 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->IntFormat:3,
1215 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->TexFormat:NULL);
1216 #endif
1217
1218 #if 0
1219 fprintf(stderr, "Format=%s IntFormat=%08x MesaFormat=%08x BaseFormat=%s IsCompressed=%d Target=%s\n",
1220 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->Format),
1221 t->base.tObj->Image[0][0]->IntFormat,
1222 t->base.tObj->Image[0][0]->TexFormat->MesaFormat,
1223 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->TexFormat->BaseFormat),
1224 t->base.tObj->Image[0][0]->IsCompressed,
1225 _mesa_lookup_enum_by_nr(t->base.tObj->Target));
1226
1227 fprintf(stderr, "pitch=%08x filter=%08x format=%08x\n", t->pitch, t->filter, r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]);
1228 fprintf(stderr, "unknown1=%08x size=%08x\n", r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i],
1229 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]);
1230 #endif
1231 /* Use the code below to quickly find matching texture
1232 formats. Requires an app that displays the same texture
1233 repeatedly */
1234 #if 0
1235 if(r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]==0){
1236 static int fmt=0x0;
1237 static int k=0;
1238 k++;
1239 if(k>20){
1240 k=0;
1241 fmt++;
1242 texUnit = &ctx->Texture.Unit[i];
1243 fprintf(stderr, "Want to set FORMAT_HASH(%d, %d, 0x%04x, %d, %d, 0x%04x, 0x%08x, %s(%08x))\n",
1244 texUnit->_CurrentCombine->OperandRGB[0] -GL_SRC_COLOR,
1245 translate_src(texUnit->_CurrentCombine->SourceRGB[0]),
1246 texUnit->_CurrentCombine->ModeRGB,
1247 texUnit->_CurrentCombine->OperandA[0] -GL_SRC_ALPHA,
1248 translate_src(texUnit->_CurrentCombine->SourceA[0]),
1249 texUnit->_CurrentCombine->ModeA,
1250 t->format,
1251 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->IntFormat),
1252 t->base.tObj->Image[0][0]->IntFormat
1253 );
1254 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);
1255 fprintf(stderr, "\t_ReallyEnabled=%08x EnvMode=%08x IntFormat=%08x\n", texUnit->_ReallyEnabled, texUnit->EnvMode, t->base.tObj->Image[0][0]->IntFormat);
1256 if(fmt>0xfff){
1257 fmt=0;
1258 }
1259 //sleep(1);
1260 fprintf(stderr, "Now trying format %08x\n",
1261 fmt);
1262 fprintf(stderr, "size=%08x\n", t->size);
1263 }
1264 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=known_formats[fmt];
1265 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=
1266 R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) | (fmt<<24);
1267 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x08a0c | (fmt<<16);
1268 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x58a00 | (fmt);
1269 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x53a0c | (fmt<<24);
1270 }
1271 #endif
1272
1273 }
1274
1275 }
1276 ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1277 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1278 ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1279 ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1280 ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1281 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1282 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1283 ((drm_r300_cmd_header_t*)r300->hw.tex.border_color.cmd)->unchecked_state.count = max_texture_unit+1;
1284
1285 if (RADEON_DEBUG & DEBUG_STATE)
1286 fprintf(stderr, "TX_ENABLE: %08x max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1287 }
1288
1289 void r300_setup_rs_unit(GLcontext *ctx)
1290 {
1291 r300ContextPtr r300 = R300_CONTEXT(ctx);
1292 int i;
1293
1294 /* This needs to be rewritten - it is a hack at best */
1295
1296 R300_STATECHANGE(r300, ri);
1297 R300_STATECHANGE(r300, rc);
1298 R300_STATECHANGE(r300, rr);
1299
1300 for(i = 1; i <= 8; ++i)
1301 r300->hw.ri.cmd[i] = 0x00d10000;
1302 r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1303 r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1304 r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1305
1306 #if 1
1307 for(i = 2; i <= 8; ++i)
1308 r300->hw.ri.cmd[i] |= 4;
1309 #endif
1310
1311 for(i = 1; i <= 8; ++i)
1312 r300->hw.rr.cmd[i] = 0;
1313 /* textures enabled ? */
1314 if(r300->state.texture.tc_count>0){
1315
1316 /* This code only really works with one set of texture coordinates */
1317
1318 /* The second constant is needed to get glxgears display anything .. */
1319 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1320 | R300_RS_CNTL_0_UNKNOWN_18
1321 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1322 r300->hw.rc.cmd[2] = 0xc0;
1323
1324
1325 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1326 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1327
1328 } else {
1329
1330 /* The second constant is needed to get glxgears display anything .. */
1331 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1332 r300->hw.rc.cmd[2] = 0;
1333
1334 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1335 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1336
1337 }
1338 }
1339
1340 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1341
1342 #define bump_vpu_count(ptr, new_count) do{\
1343 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1344 int _nc=(new_count)/4; \
1345 if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1346 }while(0)
1347
1348 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1349 {
1350 int i;
1351
1352 if(vsf->length==0)return;
1353
1354 if(vsf->length & 0x3){
1355 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1356 exit(-1);
1357 }
1358
1359 switch((dest>>8) & 0xf){
1360 case 0:
1361 R300_STATECHANGE(r300, vpi);
1362 for(i=0;i<vsf->length;i++)
1363 r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1364 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1365 break;
1366
1367 case 2:
1368 R300_STATECHANGE(r300, vpp);
1369 for(i=0;i<vsf->length;i++)
1370 r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1371 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1372 break;
1373 case 4:
1374 R300_STATECHANGE(r300, vps);
1375 for(i=0;i<vsf->length;i++)
1376 r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1377 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1378 break;
1379 default:
1380 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1381 exit(-1);
1382 }
1383 }
1384
1385
1386 void r300SetupVertexShader(r300ContextPtr rmesa)
1387 {
1388 GLcontext* ctx = rmesa->radeon.glCtx;
1389
1390 /* Reset state, in case we don't use something */
1391 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1392 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1393 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1394
1395
1396 /* This needs to be replaced by vertex shader generation code */
1397
1398
1399 /* textures enabled ? */
1400 if(rmesa->state.texture.tc_count>0){
1401 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1402 } else {
1403 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1404 }
1405
1406
1407 rmesa->state.vertex_shader.matrix[0].length=16;
1408 memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1409
1410 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1411
1412 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1413 #if 0
1414 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1415 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1416
1417 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1418 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1419 #endif
1420
1421 #if 0
1422 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1423 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1424 #endif
1425
1426 R300_STATECHANGE(rmesa, pvs);
1427 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1428 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1429 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1430 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1431 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1432 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1433 | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1434
1435 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1436 so I leave it as a reminder */
1437 #if 0
1438 reg_start(R300_VAP_PVS_WAITIDLE,0);
1439 e32(0x00000000);
1440 #endif
1441 }
1442
1443 void r300SetupPixelShader(r300ContextPtr rmesa)
1444 {
1445 int i,k;
1446
1447 /* This needs to be replaced by pixel shader generation code */
1448
1449 /* textures enabled ? */
1450 if(rmesa->state.texture.tc_count>0){
1451 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1452 } else {
1453 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1454 }
1455
1456 R300_STATECHANGE(rmesa, fpt);
1457 for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1458 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1459 rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1460
1461 #define OUTPUT_FIELD(st, reg, field) \
1462 R300_STATECHANGE(rmesa, st); \
1463 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1464 rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1465 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1466
1467 OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1468 OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1469 OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1470 OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1471 #undef OUTPUT_FIELD
1472
1473 R300_STATECHANGE(rmesa, fp);
1474 for(i=0;i<4;i++){
1475 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1476 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1477 | (rmesa->state.pixel_shader.program.node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
1478 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1479 | (rmesa->state.pixel_shader.program.node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
1480 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1481 }
1482
1483 /* PFS_CNTL_0 */
1484 rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1485 (rmesa->state.pixel_shader.program.active_nodes-1)
1486 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1487 /* PFS_CNTL_1 */
1488 rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1489 /* PFS_CNTL_2 */
1490 rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1491 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1492 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1493 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1494 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1495
1496 R300_STATECHANGE(rmesa, fpp);
1497 for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1498 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1499 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1500 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1501 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1502 }
1503 rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1504
1505 }
1506
1507 /**
1508 * Called by Mesa after an internal state update.
1509 */
1510 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1511 {
1512 r300ContextPtr r300 = R300_CONTEXT(ctx);
1513
1514 _swrast_InvalidateState(ctx, new_state);
1515 _swsetup_InvalidateState(ctx, new_state);
1516 _ac_InvalidateState(ctx, new_state);
1517 _tnl_InvalidateState(ctx, new_state);
1518 _ae_invalidate_state(ctx, new_state);
1519
1520 /* Go inefficiency! */
1521 r300ResetHwState(r300);
1522 }
1523
1524
1525 /**
1526 * Completely recalculates hardware state based on the Mesa state.
1527 */
1528 void r300ResetHwState(r300ContextPtr r300)
1529 {
1530 GLcontext* ctx = r300->radeon.glCtx;
1531 int i;
1532
1533 if (RADEON_DEBUG & DEBUG_STATE)
1534 fprintf(stderr, "%s\n", __FUNCTION__);
1535
1536 /* This is a place to initialize registers which
1537 have bitfields accessed by different functions
1538 and not all bits are used */
1539 #if 0
1540 r300->hw.zs.cmd[R300_ZS_CNTL_0] = 0;
1541 r300->hw.zs.cmd[R300_ZS_CNTL_1] = 0;
1542 r300->hw.zs.cmd[R300_ZS_CNTL_2] = 0xffff00;
1543 #endif
1544
1545 /* go and compute register values from GL state */
1546
1547 r300UpdateWindow(ctx);
1548
1549 r300ColorMask(ctx,
1550 ctx->Color.ColorMask[RCOMP],
1551 ctx->Color.ColorMask[GCOMP],
1552 ctx->Color.ColorMask[BCOMP],
1553 ctx->Color.ColorMask[ACOMP]);
1554
1555 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1556 r300DepthMask(ctx, ctx->Depth.Mask);
1557 r300DepthFunc(ctx, ctx->Depth.Func);
1558
1559 r300UpdateCulling(ctx);
1560
1561 r300_setup_routing(ctx, GL_TRUE);
1562
1563 r300UpdateTextureState(ctx);
1564 r300_setup_textures(ctx);
1565 r300_setup_rs_unit(ctx);
1566
1567 r300SetupVertexShader(r300);
1568 r300SetupPixelShader(r300);
1569
1570 r300_set_blend_state(ctx);
1571 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1572
1573 /* Initialize magic registers
1574 TODO : learn what they really do, or get rid of
1575 those we don't have to touch */
1576 r300->hw.unk2080.cmd[1] = 0x0030045A;
1577
1578 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1579 | R300_VPORT_X_OFFSET_ENA
1580 | R300_VPORT_Y_SCALE_ENA
1581 | R300_VPORT_Y_OFFSET_ENA
1582 | R300_VPORT_Z_SCALE_ENA
1583 | R300_VPORT_Z_OFFSET_ENA
1584 | R300_VTX_W0_FMT;
1585 r300->hw.vte.cmd[2] = 0x00000008;
1586
1587 r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1588 r300->hw.unk2134.cmd[2] = 0x00000000;
1589
1590 r300->hw.unk2140.cmd[1] = 0x00000000;
1591
1592 #if 0 /* Done in setup routing */
1593 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1594 r300->hw.vir[0].cmd[1] = 0x21030003;
1595
1596 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1597 r300->hw.vir[1].cmd[1] = 0xF688F688;
1598
1599 r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1600 r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1601 #endif
1602
1603 r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1604
1605 r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1606
1607 r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1608 r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1609 r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1610 r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1611
1612 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1613 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1614 else
1615 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1616
1617 #if 0
1618 r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1619 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1620 r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1621
1622
1623 r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1624 r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1625 r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1626 #endif
1627
1628 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1629 | R300_GB_LINE_STUFF_ENABLE
1630 | R300_GB_TRIANGLE_STUFF_ENABLE;
1631
1632 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1633 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1634 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1635 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1636 | R300_GB_TILE_PIPE_COUNT_R300
1637 | R300_GB_TILE_SIZE_16;
1638 else
1639 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1640 | R300_GB_TILE_PIPE_COUNT_RV300
1641 | R300_GB_TILE_SIZE_16;
1642 r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1643 r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1644
1645 //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1646
1647 r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1648 r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1649 r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1650 r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1651
1652 r300->hw.unk4214.cmd[1] = 0x00050005;
1653
1654 r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1655 (6 << R300_POINTSIZE_Y_SHIFT);
1656
1657 r300->hw.unk4230.cmd[1] = 0x01800000;
1658 r300->hw.unk4230.cmd[2] = 0x00020006;
1659 r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1660
1661 r300->hw.unk4260.cmd[1] = 0;
1662 r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1663 r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1664
1665 r300->hw.unk4274.cmd[1] = 0x00000002;
1666 r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1667 r300->hw.unk4274.cmd[3] = 0x00000000;
1668 r300->hw.unk4274.cmd[4] = 0x00000000;
1669
1670 r300->hw.unk4288.cmd[1] = 0x00000000;
1671 r300->hw.unk4288.cmd[2] = 0x00000001;
1672 r300->hw.unk4288.cmd[3] = 0x00000000;
1673 r300->hw.unk4288.cmd[4] = 0x00000000;
1674 r300->hw.unk4288.cmd[5] = 0x00000000;
1675
1676 r300->hw.unk42A0.cmd[1] = 0x00000000;
1677
1678 r300->hw.unk42B4.cmd[1] = 0x00000000;
1679
1680 r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1681 r300->hw.unk42C0.cmd[2] = 0x00000000;
1682
1683
1684 r300->hw.unk43A4.cmd[1] = 0x0000001C;
1685 r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1686
1687 r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1688
1689 #if 0
1690 r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1691 r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1692 r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1693 r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1694 r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1695 r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1696 r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1697 #endif
1698
1699 r300->hw.unk46A4.cmd[1] = 0x00001B01;
1700 r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1701 r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1702 r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1703 r300->hw.unk46A4.cmd[5] = 0x00000001;
1704
1705 #if 0
1706 for(i = 1; i <= 64; ++i) {
1707 /* create NOP instructions */
1708 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1709 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1710 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1711 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1712 }
1713 #endif
1714
1715 r300->hw.unk4BC0.cmd[1] = 0;
1716
1717 r300->hw.unk4BC8.cmd[1] = 0;
1718 r300->hw.unk4BC8.cmd[2] = 0;
1719 r300->hw.unk4BC8.cmd[3] = 0;
1720
1721 #if 0
1722 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1723 #endif
1724
1725 r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
1726 r300->hw.unk4BD8.cmd[1] = 0;
1727
1728 r300->hw.unk4E00.cmd[1] = 0;
1729
1730 #if 0
1731 r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1732 r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1733 #endif
1734
1735 r300->hw.unk4E10.cmd[1] = 0;
1736 r300->hw.unk4E10.cmd[2] = 0;
1737 r300->hw.unk4E10.cmd[3] = 0;
1738
1739 r300->hw.cb.cmd[R300_CB_OFFSET] =
1740 r300->radeon.radeonScreen->backOffset +
1741 r300->radeon.radeonScreen->fbLocation;
1742 r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1743 | R300_COLOR_UNKNOWN_22_23;
1744
1745 r300->hw.unk4E50.cmd[1] = 0;
1746 r300->hw.unk4E50.cmd[2] = 0;
1747 r300->hw.unk4E50.cmd[3] = 0;
1748 r300->hw.unk4E50.cmd[4] = 0;
1749 r300->hw.unk4E50.cmd[5] = 0;
1750 r300->hw.unk4E50.cmd[6] = 0;
1751 r300->hw.unk4E50.cmd[7] = 0;
1752 r300->hw.unk4E50.cmd[8] = 0;
1753 r300->hw.unk4E50.cmd[9] = 0;
1754
1755 r300->hw.unk4E88.cmd[1] = 0;
1756
1757 r300->hw.unk4EA0.cmd[1] = 0x00000000;
1758 r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1759
1760 r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1761 r300->hw.unk4F10.cmd[2] = 0x00000000;
1762 r300->hw.unk4F10.cmd[3] = 0x00000003;
1763 r300->hw.unk4F10.cmd[4] = 0x00000000;
1764
1765 /* experiment a bit */
1766 r300->hw.unk4F10.cmd[2] = 0x00000001; // depthbuffer format?
1767
1768 r300->hw.zb.cmd[R300_ZB_OFFSET] =
1769 r300->radeon.radeonScreen->depthOffset +
1770 r300->radeon.radeonScreen->fbLocation;
1771 r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1772
1773 r300->hw.unk4F28.cmd[1] = 0;
1774
1775 r300->hw.unk4F30.cmd[1] = 0;
1776 r300->hw.unk4F30.cmd[2] = 0;
1777
1778 r300->hw.unk4F44.cmd[1] = 0;
1779
1780 r300->hw.unk4F54.cmd[1] = 0;
1781
1782 #if 0
1783 ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1784 for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1785 /* MOV t0, t0 */
1786 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1787 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1788 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1789 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1790 }
1791
1792 ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1793 for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1794 r300->hw.vpp.cmd[i] = 0;
1795 #endif
1796
1797 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1798 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1799 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1800 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1801
1802 //END: TODO
1803
1804 r300->hw.all_dirty = GL_TRUE;
1805 }
1806
1807
1808
1809 /**
1810 * Calculate initial hardware state and register state functions.
1811 * Assumes that the command buffer and state atoms have been
1812 * initialized already.
1813 */
1814 void r300InitState(r300ContextPtr r300)
1815 {
1816 GLcontext *ctx = r300->radeon.glCtx;
1817 GLuint depth_fmt;
1818
1819 radeonInitState(&r300->radeon);
1820
1821 switch (ctx->Visual.depthBits) {
1822 case 16:
1823 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1824 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1825 //r300->state.stencil.clear = 0x00000000;
1826 break;
1827 case 24:
1828 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1829 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1830 //r300->state.stencil.clear = 0xff000000;
1831 break;
1832 default:
1833 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1834 ctx->Visual.depthBits);
1835 exit(-1);
1836 }
1837
1838 /* Only have hw stencil when depth buffer is 24 bits deep */
1839 r300->state.hw_stencil = (ctx->Visual.stencilBits > 0 &&
1840 ctx->Visual.depthBits == 24);
1841
1842 memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1843
1844 r300ResetHwState(r300);
1845 }
1846
1847
1848
1849 /**
1850 * Initialize driver's state callback functions
1851 */
1852 void r300InitStateFuncs(struct dd_function_table* functions)
1853 {
1854 radeonInitStateFuncs(functions);
1855
1856 functions->UpdateState = r300InvalidateState;
1857 functions->AlphaFunc = r300AlphaFunc;
1858 functions->BlendColor = r300BlendColor;
1859 functions->BlendEquationSeparate = r300BlendEquationSeparate;
1860 functions->BlendFuncSeparate = r300BlendFuncSeparate;
1861 functions->Enable = r300Enable;
1862 functions->ColorMask = r300ColorMask;
1863 functions->DepthFunc = r300DepthFunc;
1864 functions->DepthMask = r300DepthMask;
1865 functions->CullFace = r300CullFace;
1866 functions->FrontFace = r300FrontFace;
1867
1868 /* Stencil related */
1869 functions->ClearStencil = r300ClearStencil;
1870 functions->StencilFunc = r300StencilFunc;
1871 functions->StencilMask = r300StencilMask;
1872 functions->StencilOp = r300StencilOp;
1873
1874 /* Viewport related */
1875 functions->Viewport = r300Viewport;
1876 functions->DepthRange = r300DepthRange;
1877 functions->PointSize = r300PointSize;
1878 }
1879