projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
-Fix first frame -bug
[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 #if USE_ARB_F_P == 1
62 #include "r300_fragprog.h"
63 #else
64 #include "r300_fixed_pipelines.h"
65 #include "r300_texprog.h"
66 #endif
67 #include "r300_tex.h"
68 #include "r300_maos.h"
69
70 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
71 {
72 r300ContextPtr rmesa = R300_CONTEXT(ctx);
73 int pp_misc = rmesa->hw.at.cmd[R300_AT_ALPHA_TEST];
74 GLubyte refByte;
75
76 CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
77
78 R300_STATECHANGE(rmesa, at);
79
80 pp_misc &= ~(R300_ALPHA_TEST_OP_MASK | R300_REF_ALPHA_MASK);
81 pp_misc |= (refByte & R300_REF_ALPHA_MASK);
82
83 switch (func) {
84 case GL_NEVER:
85 pp_misc |= R300_ALPHA_TEST_FAIL;
86 break;
87 case GL_LESS:
88 pp_misc |= R300_ALPHA_TEST_LESS;
89 break;
90 case GL_EQUAL:
91 pp_misc |= R300_ALPHA_TEST_EQUAL;
92 break;
93 case GL_LEQUAL:
94 pp_misc |= R300_ALPHA_TEST_LEQUAL;
95 break;
96 case GL_GREATER:
97 pp_misc |= R300_ALPHA_TEST_GREATER;
98 break;
99 case GL_NOTEQUAL:
100 pp_misc |= R300_ALPHA_TEST_NEQUAL;
101 break;
102 case GL_GEQUAL:
103 pp_misc |= R300_ALPHA_TEST_GEQUAL;
104 break;
105 case GL_ALWAYS:
106 pp_misc |= R300_ALPHA_TEST_PASS;
107 //pp_misc &= ~R300_ALPHA_TEST_ENABLE;
108 break;
109 }
110
111 rmesa->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
112 }
113
114 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
115 {
116 GLubyte color[4];
117 r300ContextPtr rmesa = R300_CONTEXT(ctx);
118
119 R300_STATECHANGE(rmesa, unk4E10);
120
121 CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
122 CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
123 CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
124 CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
125
126 rmesa->hw.unk4E10.cmd[1] = r300PackColor(4, color[3], color[0],
127 color[1], color[2]);
128 }
129
130 /**
131 * Calculate the hardware blend factor setting. This same function is used
132 * for source and destination of both alpha and RGB.
133 *
134 * \returns
135 * The hardware register value for the specified blend factor. This value
136 * will need to be shifted into the correct position for either source or
137 * destination factor.
138 *
139 * \todo
140 * Since the two cases where source and destination are handled differently
141 * are essentially error cases, they should never happen. Determine if these
142 * cases can be removed.
143 */
144 static int blend_factor(GLenum factor, GLboolean is_src)
145 {
146 int func;
147
148 switch (factor) {
149 case GL_ZERO:
150 func = R200_BLEND_GL_ZERO;
151 break;
152 case GL_ONE:
153 func = R200_BLEND_GL_ONE;
154 break;
155 case GL_DST_COLOR:
156 func = R200_BLEND_GL_DST_COLOR;
157 break;
158 case GL_ONE_MINUS_DST_COLOR:
159 func = R200_BLEND_GL_ONE_MINUS_DST_COLOR;
160 break;
161 case GL_SRC_COLOR:
162 func = R200_BLEND_GL_SRC_COLOR;
163 break;
164 case GL_ONE_MINUS_SRC_COLOR:
165 func = R200_BLEND_GL_ONE_MINUS_SRC_COLOR;
166 break;
167 case GL_SRC_ALPHA:
168 func = R200_BLEND_GL_SRC_ALPHA;
169 break;
170 case GL_ONE_MINUS_SRC_ALPHA:
171 func = R200_BLEND_GL_ONE_MINUS_SRC_ALPHA;
172 break;
173 case GL_DST_ALPHA:
174 func = R200_BLEND_GL_DST_ALPHA;
175 break;
176 case GL_ONE_MINUS_DST_ALPHA:
177 func = R200_BLEND_GL_ONE_MINUS_DST_ALPHA;
178 break;
179 case GL_SRC_ALPHA_SATURATE:
180 func =
181 (is_src) ? R200_BLEND_GL_SRC_ALPHA_SATURATE :
182 R200_BLEND_GL_ZERO;
183 break;
184 case GL_CONSTANT_COLOR:
185 func = R200_BLEND_GL_CONST_COLOR;
186 break;
187 case GL_ONE_MINUS_CONSTANT_COLOR:
188 func = R200_BLEND_GL_ONE_MINUS_CONST_COLOR;
189 break;
190 case GL_CONSTANT_ALPHA:
191 func = R200_BLEND_GL_CONST_ALPHA;
192 break;
193 case GL_ONE_MINUS_CONSTANT_ALPHA:
194 func = R200_BLEND_GL_ONE_MINUS_CONST_ALPHA;
195 break;
196 default:
197 fprintf(stderr, "unknown blend factor %x\n", factor);
198 func = (is_src) ? R200_BLEND_GL_ONE : R200_BLEND_GL_ZERO;
199 }
200 return func;
201 }
202
203 /**
204 * Sets both the blend equation and the blend function.
205 * This is done in a single
206 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
207 * change the interpretation of the blend function.
208 * Also, make sure that blend function and blend equation are set to their default
209 * value if color blending is not enabled, since at least blend equations GL_MIN
210 * and GL_FUNC_REVERSE_SUBTRACT will cause wrong results otherwise for
211 * unknown reasons.
212 */
213
214 /* helper function */
215 static void r300_set_blend_cntl(r300ContextPtr r300, int func, int eqn, int cbits, int funcA, int eqnA)
216 {
217 GLuint new_ablend, new_cblend;
218
219 #if 0
220 fprintf(stderr, "eqnA=%08x funcA=%08x eqn=%08x func=%08x cbits=%08x\n", eqnA, funcA, eqn, func, cbits);
221 #endif
222 new_ablend = eqnA | funcA;
223 new_cblend = eqn | func;
224
225 /* Some blend factor combinations don't seem to work when the
226 * BLEND_NO_SEPARATE bit is set.
227 *
228 * Especially problematic candidates are the ONE_MINUS_* flags,
229 * but I can't see a real pattern.
230 */
231 #if 0
232 if (new_ablend == new_cblend) {
233 new_cblend |= R300_BLEND_NO_SEPARATE;
234 }
235 #endif
236 new_cblend |= cbits;
237
238 if((new_ablend != r300->hw.bld.cmd[R300_BLD_ABLEND]) ||
239 (new_cblend != r300->hw.bld.cmd[R300_BLD_CBLEND])) {
240 R300_STATECHANGE(r300, bld);
241 r300->hw.bld.cmd[R300_BLD_ABLEND]=new_ablend;
242 r300->hw.bld.cmd[R300_BLD_CBLEND]=new_cblend;
243 }
244 }
245
246
247 static void r300_set_blend_state(GLcontext * ctx)
248 {
249 r300ContextPtr r300 = R300_CONTEXT(ctx);
250 int func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
251 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
252 int eqn = R200_COMB_FCN_ADD_CLAMP;
253 int funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
254 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
255 int eqnA = R200_COMB_FCN_ADD_CLAMP;
256
257 if (ctx->Color._LogicOpEnabled || !ctx->Color.BlendEnabled) {
258 r300_set_blend_cntl(r300,
259 func, eqn, 0,
260 func, eqn);
261 return;
262 }
263
264 func = (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) << R200_SRC_BLEND_SHIFT) |
265 (blend_factor(ctx->Color.BlendDstRGB, GL_FALSE) << R200_DST_BLEND_SHIFT);
266
267 switch (ctx->Color.BlendEquationRGB) {
268 case GL_FUNC_ADD:
269 eqn = R300_COMB_FCN_ADD_CLAMP;
270 break;
271
272 case GL_FUNC_SUBTRACT:
273 eqn = R300_COMB_FCN_SUB_CLAMP;
274 break;
275
276 case GL_FUNC_REVERSE_SUBTRACT:
277 eqn = R200_COMB_FCN_RSUB_CLAMP;
278 break;
279
280 case GL_MIN:
281 eqn = R200_COMB_FCN_MIN;
282 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
283 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
284 break;
285
286 case GL_MAX:
287 eqn = R200_COMB_FCN_MAX;
288 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
289 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
290 break;
291
292 default:
293 fprintf(stderr,
294 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
295 __func__, __LINE__, ctx->Color.BlendEquationRGB);
296 return;
297 }
298
299
300 funcA = (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) << R200_SRC_BLEND_SHIFT) |
301 (blend_factor(ctx->Color.BlendDstA, GL_FALSE) << R200_DST_BLEND_SHIFT);
302
303 switch (ctx->Color.BlendEquationA) {
304 case GL_FUNC_ADD:
305 eqnA = R300_COMB_FCN_ADD_CLAMP;
306 break;
307
308 case GL_FUNC_SUBTRACT:
309 eqnA = R300_COMB_FCN_SUB_CLAMP;
310 break;
311
312 case GL_FUNC_REVERSE_SUBTRACT:
313 eqnA = R200_COMB_FCN_RSUB_CLAMP;
314 break;
315
316 case GL_MIN:
317 eqnA = R200_COMB_FCN_MIN;
318 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
319 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
320 break;
321
322 case GL_MAX:
323 eqnA = R200_COMB_FCN_MAX;
324 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
325 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
326 break;
327
328 default:
329 fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n",
330 __func__, __LINE__, ctx->Color.BlendEquationA);
331 return;
332 }
333
334 r300_set_blend_cntl(r300,
335 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
336 funcA, eqnA);
337 }
338
339 static void r300BlendEquationSeparate(GLcontext * ctx,
340 GLenum modeRGB, GLenum modeA)
341 {
342 r300_set_blend_state(ctx);
343 }
344
345 static void r300BlendFuncSeparate(GLcontext * ctx,
346 GLenum sfactorRGB, GLenum dfactorRGB,
347 GLenum sfactorA, GLenum dfactorA)
348 {
349 r300_set_blend_state(ctx);
350 }
351
352 /**
353 * Update our tracked culling state based on Mesa's state.
354 */
355 static void r300UpdateCulling(GLcontext* ctx)
356 {
357 r300ContextPtr r300 = R300_CONTEXT(ctx);
358 uint32_t val = 0;
359
360 R300_STATECHANGE(r300, cul);
361 if (ctx->Polygon.CullFlag) {
362 if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
363 val = R300_CULL_FRONT|R300_CULL_BACK;
364 else if (ctx->Polygon.CullFaceMode == GL_FRONT)
365 val = R300_CULL_FRONT;
366 else
367 val = R300_CULL_BACK;
368
369 if (ctx->Polygon.FrontFace == GL_CW)
370 val |= R300_FRONT_FACE_CW;
371 else
372 val |= R300_FRONT_FACE_CCW;
373 }
374 r300->hw.cul.cmd[R300_CUL_CULL] = val;
375 }
376
377 static void update_early_z(GLcontext* ctx)
378 {
379 /* updates register 0x4f14
380 if depth test is not enabled it should be 0x00000000
381 if depth is enabled and alpha not it should be 0x00000001
382 if depth and alpha is enabled it should be 0x00000000
383 */
384 r300ContextPtr r300 = R300_CONTEXT(ctx);
385
386 R300_STATECHANGE(r300, unk4F10);
387 if (ctx->Color.AlphaEnabled)
388 /* disable early Z */
389 r300->hw.unk4F10.cmd[2] = 0x00000000;
390 else {
391 if (ctx->Depth.Test)
392 /* enable early Z */
393 r300->hw.unk4F10.cmd[2] = 0x00000001;
394 else
395 /* disable early Z */
396 r300->hw.unk4F10.cmd[2] = 0x00000000;
397 }
398 }
399
400 /**
401 * Handle glEnable()/glDisable().
402 *
403 * \note Mesa already filters redundant calls to glEnable/glDisable.
404 */
405 static void r300Enable(GLcontext* ctx, GLenum cap, GLboolean state)
406 {
407 r300ContextPtr r300 = R300_CONTEXT(ctx);
408 uint32_t newval;
409
410 if (RADEON_DEBUG & DEBUG_STATE)
411 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
412 _mesa_lookup_enum_by_nr(cap),
413 state ? "GL_TRUE" : "GL_FALSE");
414
415 switch (cap) {
416 /* Fast track this one...
417 */
418 case GL_TEXTURE_1D:
419 case GL_TEXTURE_2D:
420 case GL_TEXTURE_3D:
421 break;
422
423 case GL_ALPHA_TEST:
424 R300_STATECHANGE(r300, at);
425 if (state) {
426 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
427 R300_ALPHA_TEST_ENABLE;
428 } else {
429 r300->hw.at.cmd[R300_AT_ALPHA_TEST] &=
430 ~R300_ALPHA_TEST_ENABLE;
431 }
432 update_early_z(ctx);
433 break;
434
435 case GL_BLEND:
436 case GL_COLOR_LOGIC_OP:
437 r300_set_blend_state(ctx);
438 break;
439
440 case GL_DEPTH_TEST:
441 R300_STATECHANGE(r300, zs);
442
443 if (state) {
444 if (ctx->Depth.Mask)
445 newval = R300_RB3D_Z_TEST_AND_WRITE;
446 else
447 newval = R300_RB3D_Z_TEST;
448 } else
449 newval = R300_RB3D_Z_DISABLED_1;
450
451 r300->hw.zs.cmd[R300_ZS_CNTL_0] &= R300_RB3D_STENCIL_ENABLE;
452 r300->hw.zs.cmd[R300_ZS_CNTL_0] |= newval;
453 update_early_z(ctx);
454 break;
455
456 case GL_STENCIL_TEST:
457 WARN_ONCE("TODO - double side stencil !\n");
458 if (r300->state.stencil.hw_stencil) {
459 R300_STATECHANGE(r300, zs);
460 if (state) {
461 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
462 R300_RB3D_STENCIL_ENABLE;
463 } else {
464 r300->hw.zs.cmd[R300_ZS_CNTL_0] &=
465 ~R300_RB3D_STENCIL_ENABLE;
466 }
467 } else {
468 #if R200_MERGED
469 FALLBACK(&r300->radeon, RADEON_FALLBACK_STENCIL, state);
470 #endif
471 }
472 break;
473
474 case GL_CULL_FACE:
475 r300UpdateCulling(ctx);
476 break;
477
478 case GL_POLYGON_OFFSET_POINT:
479 case GL_POLYGON_OFFSET_LINE:
480 break;
481
482 case GL_POLYGON_OFFSET_FILL:
483 R300_STATECHANGE(r300, unk42B4);
484 if(state){
485 r300->hw.unk42B4.cmd[1] |= (3<<0);
486 } else {
487 r300->hw.unk42B4.cmd[1] &= ~(3<<0);
488 }
489 break;
490 default:
491 radeonEnable(ctx, cap, state);
492 return;
493 }
494 }
495
496
497 static void r300UpdatePolygonMode(GLcontext *ctx)
498 {
499 r300ContextPtr r300 = R300_CONTEXT(ctx);
500 uint32_t hw_mode=0;
501
502 if (ctx->Polygon.FrontMode != GL_FILL ||
503 ctx->Polygon.BackMode != GL_FILL) {
504 GLenum f, b;
505
506 if (ctx->Polygon.FrontFace == GL_CCW) {
507 f = ctx->Polygon.FrontMode;
508 b = ctx->Polygon.BackMode;
509 } else {
510 f = ctx->Polygon.BackMode;
511 b = ctx->Polygon.FrontMode;
512 }
513
514 hw_mode |= R300_PM_ENABLED;
515
516 switch (f) {
517 case GL_LINE:
518 hw_mode |= R300_PM_FRONT_LINE;
519 break;
520 case GL_POINT: /* noop */
521 hw_mode |= R300_PM_FRONT_POINT;
522 break;
523 case GL_FILL:
524 hw_mode |= R300_PM_FRONT_FILL;
525 break;
526 }
527
528 switch (b) {
529 case GL_LINE:
530 hw_mode |= R300_PM_BACK_LINE;
531 break;
532 case GL_POINT: /* noop */
533 hw_mode |= R300_PM_BACK_POINT;
534 break;
535 case GL_FILL:
536 hw_mode |= R300_PM_BACK_FILL;
537 break;
538 }
539 }
540
541 if (r300->hw.unk4288.cmd[1] != hw_mode) {
542 R300_STATECHANGE(r300, unk4288);
543 r300->hw.unk4288.cmd[1] = hw_mode;
544 }
545 }
546
547 /**
548 * Change the culling mode.
549 *
550 * \note Mesa already filters redundant calls to this function.
551 */
552 static void r300CullFace(GLcontext* ctx, GLenum mode)
553 {
554 (void)mode;
555
556 r300UpdateCulling(ctx);
557 }
558
559
560 /**
561 * Change the polygon orientation.
562 *
563 * \note Mesa already filters redundant calls to this function.
564 */
565 static void r300FrontFace(GLcontext* ctx, GLenum mode)
566 {
567 (void)mode;
568
569 r300UpdateCulling(ctx);
570 r300UpdatePolygonMode(ctx);
571 }
572
573
574 /**
575 * Change the depth testing function.
576 *
577 * \note Mesa already filters redundant calls to this function.
578 */
579 static void r300DepthFunc(GLcontext* ctx, GLenum func)
580 {
581 r300ContextPtr r300 = R300_CONTEXT(ctx);
582
583 R300_STATECHANGE(r300, zs);
584
585 r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
586
587 switch(func) {
588 case GL_NEVER:
589 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NEVER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
590 break;
591 case GL_LESS:
592 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LESS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
593 break;
594 case GL_EQUAL:
595 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_EQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
596 break;
597 case GL_LEQUAL:
598 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
599 break;
600 case GL_GREATER:
601 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GREATER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
602 break;
603 case GL_NOTEQUAL:
604 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NOTEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
605 break;
606 case GL_GEQUAL:
607 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
608 break;
609 case GL_ALWAYS:
610 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_ALWAYS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
611 break;
612 }
613 }
614
615
616 /**
617 * Enable/Disable depth writing.
618 *
619 * \note Mesa already filters redundant calls to this function.
620 */
621 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
622 {
623 r300ContextPtr r300 = R300_CONTEXT(ctx);
624 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
625 }
626
627
628 /**
629 * Handle glColorMask()
630 */
631 static void r300ColorMask(GLcontext* ctx,
632 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
633 {
634 r300ContextPtr r300 = R300_CONTEXT(ctx);
635 int mask = (r ? R300_COLORMASK0_R : 0) |
636 (g ? R300_COLORMASK0_G : 0) |
637 (b ? R300_COLORMASK0_B : 0) |
638 (a ? R300_COLORMASK0_A : 0);
639
640 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
641 R300_STATECHANGE(r300, cmk);
642 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
643 }
644 }
645
646 /* =============================================================
647 * Point state
648 */
649 static void r300PointSize(GLcontext * ctx, GLfloat size)
650 {
651 r300ContextPtr r300 = R300_CONTEXT(ctx);
652
653 size = ctx->Point._Size;
654
655 R300_STATECHANGE(r300, ps);
656 r300->hw.ps.cmd[R300_PS_POINTSIZE] =
657 ((int)(size * 6) << R300_POINTSIZE_X_SHIFT) |
658 ((int)(size * 6) << R300_POINTSIZE_Y_SHIFT);
659 }
660
661 /* =============================================================
662 * Line state
663 */
664 static void r300LineWidth(GLcontext *ctx, GLfloat widthf)
665 {
666 r300ContextPtr r300 = R300_CONTEXT(ctx);
667
668 widthf = ctx->Line._Width;
669
670 R300_STATECHANGE(r300, lcntl);
671 r300->hw.lcntl.cmd[1] = (int)(widthf * 6.0);
672 r300->hw.lcntl.cmd[1] |= R300_LINE_CNT_VE;
673 }
674
675 static void r300PolygonMode(GLcontext *ctx, GLenum face, GLenum mode)
676 {
677 (void)face;
678 (void)mode;
679
680 r300UpdatePolygonMode(ctx);
681 }
682
683 /* =============================================================
684 * Stencil
685 */
686
687 static int translate_stencil_func(int func)
688 {
689 switch (func) {
690 case GL_NEVER:
691 return R300_ZS_NEVER;
692 case GL_LESS:
693 return R300_ZS_LESS;
694 case GL_EQUAL:
695 return R300_ZS_EQUAL;
696 case GL_LEQUAL:
697 return R300_ZS_LEQUAL;
698 case GL_GREATER:
699 return R300_ZS_GREATER;
700 case GL_NOTEQUAL:
701 return R300_ZS_NOTEQUAL;
702 case GL_GEQUAL:
703 return R300_ZS_GEQUAL;
704 case GL_ALWAYS:
705 return R300_ZS_ALWAYS;
706 }
707 return 0;
708 }
709
710 static int translate_stencil_op(int op)
711 {
712 switch (op) {
713 case GL_KEEP:
714 return R300_ZS_KEEP;
715 case GL_ZERO:
716 return R300_ZS_ZERO;
717 case GL_REPLACE:
718 return R300_ZS_REPLACE;
719 case GL_INCR:
720 return R300_ZS_INCR;
721 case GL_DECR:
722 return R300_ZS_DECR;
723 case GL_INCR_WRAP_EXT:
724 return R300_ZS_INCR_WRAP;
725 case GL_DECR_WRAP_EXT:
726 return R300_ZS_DECR_WRAP;
727 case GL_INVERT:
728 return R300_ZS_INVERT;
729 default:
730 WARN_ONCE("Do not know how to translate stencil op");
731 return R300_ZS_KEEP;
732 }
733 return 0;
734 }
735
736 static void r300ShadeModel(GLcontext * ctx, GLenum mode)
737 {
738 r300ContextPtr rmesa = R300_CONTEXT(ctx);
739
740 R300_STATECHANGE(rmesa, unk4274);
741 switch (mode) {
742 case GL_FLAT:
743 rmesa->hw.unk4274.cmd[2] = R300_RE_SHADE_MODEL_FLAT;
744 break;
745 case GL_SMOOTH:
746 rmesa->hw.unk4274.cmd[2] = R300_RE_SHADE_MODEL_SMOOTH;
747 break;
748 default:
749 return;
750 }
751 }
752
753 static void r300StencilFuncSeparate(GLcontext * ctx, GLenum face,
754 GLenum func, GLint ref, GLuint mask)
755 {
756 r300ContextPtr rmesa = R300_CONTEXT(ctx);
757 GLuint refmask = ((ctx->Stencil.Ref[0] << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
758 (ctx->Stencil.ValueMask[0] << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
759
760 GLuint flag;
761
762 R300_STATECHANGE(rmesa, zs);
763
764 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(
765 (R300_ZS_MASK << R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
766 | (R300_ZS_MASK << R300_RB3D_ZS1_BACK_FUNC_SHIFT));
767
768 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &= ~((R300_RB3D_ZS2_STENCIL_MASK << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
769 (R300_RB3D_ZS2_STENCIL_MASK << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
770
771 flag = translate_stencil_func(ctx->Stencil.Function[0]);
772
773 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |= (flag << R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
774 | (flag << R300_RB3D_ZS1_BACK_FUNC_SHIFT);
775 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
776 }
777
778 static void r300StencilMaskSeparate(GLcontext * ctx, GLenum face, GLuint mask)
779 {
780 r300ContextPtr rmesa = R300_CONTEXT(ctx);
781
782 R300_STATECHANGE(rmesa, zs);
783 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &= ~(R300_RB3D_ZS2_STENCIL_MASK << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT);
784 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= ctx->Stencil.WriteMask[0] << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT;
785 }
786
787
788 static void r300StencilOpSeparate(GLcontext * ctx, GLenum face, GLenum fail,
789 GLenum zfail, GLenum zpass)
790 {
791 r300ContextPtr rmesa = R300_CONTEXT(ctx);
792
793 R300_STATECHANGE(rmesa, zs);
794 /* It is easier to mask what's left.. */
795 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &=
796 (R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT) |
797 (R300_ZS_MASK << R300_RB3D_ZS1_FRONT_FUNC_SHIFT) |
798 (R300_ZS_MASK << R300_RB3D_ZS1_BACK_FUNC_SHIFT);
799
800 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
801 (translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_FRONT_FAIL_OP_SHIFT)
802 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_FRONT_ZFAIL_OP_SHIFT)
803 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_FRONT_ZPASS_OP_SHIFT)
804 |(translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_BACK_FAIL_OP_SHIFT)
805 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_BACK_ZFAIL_OP_SHIFT)
806 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_BACK_ZPASS_OP_SHIFT);
807 }
808
809 static void r300ClearStencil(GLcontext * ctx, GLint s)
810 {
811 r300ContextPtr rmesa = R300_CONTEXT(ctx);
812
813 rmesa->state.stencil.clear =
814 ((GLuint) ctx->Stencil.Clear |
815 (R300_RB3D_ZS2_STENCIL_MASK << R300_RB3D_ZS2_STENCIL_MASK_SHIFT) |
816 (ctx->Stencil.WriteMask[0] << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT));
817 }
818
819 /* =============================================================
820 * Window position and viewport transformation
821 */
822
823 /*
824 * To correctly position primitives:
825 */
826 #define SUBPIXEL_X 0.125
827 #define SUBPIXEL_Y 0.125
828
829 static void r300UpdateWindow(GLcontext * ctx)
830 {
831 r300ContextPtr rmesa = R300_CONTEXT(ctx);
832 __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
833 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
834 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
835 const GLfloat *v = ctx->Viewport._WindowMap.m;
836
837 GLfloat sx = v[MAT_SX];
838 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
839 GLfloat sy = -v[MAT_SY];
840 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
841 GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
842 GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
843
844 R300_FIREVERTICES(rmesa);
845 R300_STATECHANGE(rmesa, vpt);
846
847 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
848 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
849 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
850 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
851 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
852 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
853 }
854
855 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
856 GLsizei width, GLsizei height)
857 {
858 /* Don't pipeline viewport changes, conflict with window offset
859 * setting below. Could apply deltas to rescue pipelined viewport
860 * values, or keep the originals hanging around.
861 */
862 R300_FIREVERTICES(R300_CONTEXT(ctx));
863 r300UpdateWindow(ctx);
864 }
865
866 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
867 {
868 r300UpdateWindow(ctx);
869 }
870
871 /* =============================================================
872 * Polygon state
873 */
874 static void r300PolygonOffset(GLcontext * ctx, GLfloat factor, GLfloat units)
875 {
876 r300ContextPtr rmesa = R300_CONTEXT(ctx);
877 GLfloat constant = units;
878
879 switch (ctx->Visual.depthBits) {
880 case 16:
881 constant *= 4.0;
882 break;
883 case 24:
884 constant *= 2.0;
885 break;
886 }
887
888 factor *= 12.0;
889
890 /* fprintf(stderr, "%s f:%f u:%f\n", __FUNCTION__, factor, constant); */
891
892 R300_STATECHANGE(rmesa, zbs);
893 rmesa->hw.zbs.cmd[R300_ZBS_T_FACTOR] = r300PackFloat32(factor);
894 rmesa->hw.zbs.cmd[R300_ZBS_T_CONSTANT] = r300PackFloat32(constant);
895 rmesa->hw.zbs.cmd[R300_ZBS_W_FACTOR] = r300PackFloat32(factor);
896 rmesa->hw.zbs.cmd[R300_ZBS_W_CONSTANT] = r300PackFloat32(constant);
897 }
898
899 /* Routing and texture-related */
900
901 static r300TexObj default_tex_obj={
902 filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
903 pitch: 0x8000,
904 size: (0xff << R300_TX_WIDTHMASK_SHIFT)
905 | (0xff << R300_TX_HEIGHTMASK_SHIFT)
906 | (0x8 << R300_TX_SIZE_SHIFT),
907 format: 0x88a0c,
908 offset: 0x0,
909 unknown4: 0x0,
910 unknown5: 0x0
911 };
912
913 /* there is probably a system to these value, but, for now,
914 we just try by hand */
915
916 static int inline translate_src(int src)
917 {
918 switch (src) {
919 case GL_TEXTURE:
920 return 1;
921 break;
922 case GL_CONSTANT:
923 return 2;
924 break;
925 case GL_PRIMARY_COLOR:
926 return 3;
927 break;
928 case GL_PREVIOUS:
929 return 4;
930 break;
931 case GL_ZERO:
932 return 5;
933 break;
934 case GL_ONE:
935 return 6;
936 break;
937 default:
938 return 0;
939 }
940 }
941
942 /* r300 doesnt handle GL_CLAMP and GL_MIRROR_CLAMP_EXT correctly when filter is NEAREST.
943 * Since texwrap produces same results for GL_CLAMP and GL_CLAMP_TO_EDGE we use them instead.
944 * We need to recalculate wrap modes whenever filter mode is changed because someone might do:
945 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
946 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
947 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
948 * Since r300 completely ignores R300_TX_CLAMP when either min or mag is nearest it cant handle
949 * combinations where only one of them is nearest.
950 */
951 static unsigned long gen_fixed_filter(unsigned long f)
952 {
953 unsigned long mag, min, needs_fixing=0;
954 //return f;
955
956 /* We ignore MIRROR bit so we dont have to do everything twice */
957 if((f & ((7-1) << R300_TX_WRAP_S_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_S_SHIFT)){
958 needs_fixing |= 1;
959 }
960 if((f & ((7-1) << R300_TX_WRAP_T_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_T_SHIFT)){
961 needs_fixing |= 2;
962 }
963 if((f & ((7-1) << R300_TX_WRAP_Q_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_Q_SHIFT)){
964 needs_fixing |= 4;
965 }
966
967 if(!needs_fixing)
968 return f;
969
970 mag=f & R300_TX_MAG_FILTER_MASK;
971 min=f & R300_TX_MIN_FILTER_MASK;
972
973 /* TODO: Check for anisto filters too */
974 if((mag != R300_TX_MAG_FILTER_NEAREST) && (min != R300_TX_MIN_FILTER_NEAREST))
975 return f;
976
977 /* r300 cant handle these modes hence we force nearest to linear */
978 if((mag == R300_TX_MAG_FILTER_NEAREST) && (min != R300_TX_MIN_FILTER_NEAREST)){
979 f &= ~R300_TX_MAG_FILTER_NEAREST;
980 f |= R300_TX_MAG_FILTER_LINEAR;
981 return f;
982 }
983
984 if((min == R300_TX_MIN_FILTER_NEAREST) && (mag != R300_TX_MAG_FILTER_NEAREST)){
985 f &= ~R300_TX_MIN_FILTER_NEAREST;
986 f |= R300_TX_MIN_FILTER_LINEAR;
987 return f;
988 }
989
990 /* Both are nearest */
991 if(needs_fixing & 1){
992 f &= ~((7-1) << R300_TX_WRAP_S_SHIFT);
993 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_S_SHIFT;
994 }
995 if(needs_fixing & 2){
996 f &= ~((7-1) << R300_TX_WRAP_T_SHIFT);
997 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_T_SHIFT;
998 }
999 if(needs_fixing & 4){
1000 f &= ~((7-1) << R300_TX_WRAP_Q_SHIFT);
1001 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_Q_SHIFT;
1002 }
1003 return f;
1004 }
1005
1006 void r300_setup_textures(GLcontext *ctx)
1007 {
1008 int i, mtu;
1009 struct r300_tex_obj *t;
1010 r300ContextPtr r300 = R300_CONTEXT(ctx);
1011 int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
1012 GLuint OutputsWritten;
1013
1014 if(hw_tcl_on)
1015 OutputsWritten = CURRENT_VERTEX_SHADER(ctx)->OutputsWritten;
1016
1017 R300_STATECHANGE(r300, txe);
1018 R300_STATECHANGE(r300, tex.filter);
1019 R300_STATECHANGE(r300, tex.unknown1);
1020 R300_STATECHANGE(r300, tex.size);
1021 R300_STATECHANGE(r300, tex.format);
1022 R300_STATECHANGE(r300, tex.offset);
1023 R300_STATECHANGE(r300, tex.unknown4);
1024 R300_STATECHANGE(r300, tex.border_color);
1025
1026 r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
1027
1028 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1029 if (RADEON_DEBUG & DEBUG_STATE)
1030 fprintf(stderr, "mtu=%d\n", mtu);
1031
1032 if(mtu > R300_MAX_TEXTURE_UNITS) {
1033 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1034 mtu, R300_MAX_TEXTURE_UNITS);
1035 exit(-1);
1036 }
1037
1038 for(i=0; i < mtu; i++) {
1039 /*if( ((r300->state.render_inputs & (_TNL_BIT_TEX0<<i))!=0) != ((ctx->Texture.Unit[i].Enabled)!=0) ) {
1040 WARN_ONCE("Mismatch between render_inputs and ctx->Texture.Unit[i].Enabled value(%d vs %d).\n",
1041 ((r300->state.render_inputs & (_TNL_BIT_TEX0<<i))!=0), ((ctx->Texture.Unit[i].Enabled)!=0));
1042 }*/
1043
1044 if(TMU_ENABLED(ctx, i)) {
1045 t=r300->state.texture.unit[i].texobj;
1046 //fprintf(stderr, "format=%08x\n", r300->state.texture.unit[i].format);
1047
1048 if(t == NULL){
1049 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1050 exit(-1);
1051 t=&default_tex_obj;
1052 }
1053
1054 //fprintf(stderr, "t->format=%08x\n", t->format);
1055 if((t->format & 0xffffff00)==0xffffff00) {
1056 WARN_ONCE("unknown texture format (entry %x) encountered. Help me !\n", t->format & 0xff);
1057 //fprintf(stderr, "t->format=%08x\n", t->format);
1058 }
1059
1060 if (RADEON_DEBUG & DEBUG_STATE)
1061 fprintf(stderr, "Activating texture unit %d\n", i);
1062 max_texture_unit=i;
1063 r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1064
1065 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=gen_fixed_filter(t->filter) | (i << 28);
1066 //r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=0x0; /* move lod bias here? */
1067
1068 /* No idea why linear filtered textures shake when puting random data */
1069 /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1070 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1071 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1072 //fprintf(stderr, "t->format=%08x\n", t->format);
1073 r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=t->offset;
1074 r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1075 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0+i]=t->pp_border_color;
1076 }
1077 }
1078
1079 ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->packet0.count = max_texture_unit+1;
1080 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->packet0.count = max_texture_unit+1;
1081 ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->packet0.count = max_texture_unit+1;
1082 ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->packet0.count = max_texture_unit+1;
1083 ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->packet0.count = max_texture_unit+1;
1084 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->packet0.count = max_texture_unit+1;
1085 ((drm_r300_cmd_header_t*)r300->hw.tex.border_color.cmd)->packet0.count = max_texture_unit+1;
1086
1087 if (RADEON_DEBUG & DEBUG_STATE)
1088 fprintf(stderr, "TX_ENABLE: %08x max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1089 }
1090
1091 #if USE_ARB_F_P == 1
1092 void r300_setup_rs_unit(GLcontext *ctx)
1093 {
1094 r300ContextPtr r300 = R300_CONTEXT(ctx);
1095 /* I'm still unsure if these are needed */
1096 GLuint interp_magic[8] = {
1097 0x00,
1098 0x40,
1099 0x80,
1100 0xC0,
1101 0x00,
1102 0x00,
1103 0x00,
1104 0x00
1105 };
1106 GLuint OutputsWritten;
1107 GLuint InputsRead;
1108 int vp_reg, fp_reg, high_rr;
1109 int in_texcoords, col_interp_nr;
1110 int i;
1111
1112 if(hw_tcl_on)
1113 OutputsWritten = CURRENT_VERTEX_SHADER(ctx)->OutputsWritten;
1114 else
1115 OutputsWritten = r300->state.render_inputs;
1116
1117 if (ctx->FragmentProgram._Current)
1118 InputsRead = ctx->FragmentProgram._Current->InputsRead;
1119 else {
1120 fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
1121 return; /* This should only ever happen once.. */
1122 }
1123
1124 R300_STATECHANGE(r300, ri);
1125 R300_STATECHANGE(r300, rc);
1126 R300_STATECHANGE(r300, rr);
1127
1128 vp_reg = fp_reg = in_texcoords = col_interp_nr = high_rr = 0;
1129 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0;
1130 r300->hw.rr.cmd[R300_RR_ROUTE_1] = 0;
1131
1132 for (i=0;i<ctx->Const.MaxTextureUnits;i++) {
1133 if (OutputsWritten & (hw_tcl_on ? (1 << (VERT_RESULT_TEX0+i)) : (_TNL_BIT_TEX0<<i)))
1134 in_texcoords++;
1135
1136 r300->hw.ri.cmd[R300_RI_INTERP_0+i] = 0
1137 | R300_RS_INTERP_USED
1138 | (vp_reg << R300_RS_INTERP_SRC_SHIFT)
1139 | interp_magic[i];
1140
1141 if (InputsRead & (FRAG_BIT_TEX0<<i)) {
1142 //assert(r300->state.texture.tc_count != 0);
1143 r300->hw.rr.cmd[R300_RR_ROUTE_0 + fp_reg] = 0
1144 | R300_RS_ROUTE_ENABLE
1145 | i /* source INTERP */
1146 | (fp_reg << R300_RS_ROUTE_DEST_SHIFT);
1147 high_rr = fp_reg;
1148
1149 if (OutputsWritten & (hw_tcl_on ? (1 << (VERT_RESULT_TEX0+i)) : (_TNL_BIT_TEX0<<i))) {
1150 vp_reg++;
1151 } else {
1152 /* Unsure of how to handle this situation, for now print errors and
1153 * the program will just recieve bogus data
1154 */
1155 fprintf(stderr, "fragprog wants coords for tex%d, vp doesn't provide them!\n", i);
1156 }
1157 InputsRead &= ~(FRAG_BIT_TEX0<<i);
1158 fp_reg++;
1159 }
1160 }
1161
1162 if (InputsRead & FRAG_BIT_COL0) {
1163 if (!(OutputsWritten & (hw_tcl_on ? (1<<VERT_RESULT_COL0) : _TNL_BIT_COLOR0)))
1164 fprintf(stderr, "fragprog wants col0, vp doesn't provide it\n");
1165
1166 r300->hw.rr.cmd[R300_RR_ROUTE_0] |= 0
1167 | R300_RS_ROUTE_0_COLOR
1168 | (fp_reg++ << R300_RS_ROUTE_0_COLOR_DEST_SHIFT);
1169 InputsRead &= ~FRAG_BIT_COL0;
1170 col_interp_nr++;
1171 }
1172
1173 if (InputsRead & FRAG_BIT_COL1) {
1174 if (!(OutputsWritten & (hw_tcl_on ? (1<<VERT_RESULT_COL1) : _TNL_BIT_COLOR1)))
1175 fprintf(stderr, "fragprog wants col1, vp doesn't provide it\n");
1176
1177 r300->hw.rr.cmd[R300_RR_ROUTE_1] |= R300_RS_ROUTE_1_UNKNOWN11
1178 | R300_RS_ROUTE_1_COLOR1
1179 | (fp_reg++ << R300_RS_ROUTE_1_COLOR1_DEST_SHIFT);
1180 InputsRead &= ~FRAG_BIT_COL1;
1181 if (high_rr < 1) high_rr = 1;
1182 col_interp_nr++;
1183 }
1184
1185 r300->hw.rc.cmd[1] = 0
1186 | (in_texcoords << R300_RS_CNTL_TC_CNT_SHIFT)
1187 | (col_interp_nr << R300_RS_CNTL_CI_CNT_SHIFT)
1188 | R300_RS_CNTL_0_UNKNOWN_18;
1189
1190 assert(high_rr >= 0);
1191 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(R300_RS_ROUTE_0, high_rr+1);
1192 r300->hw.rc.cmd[2] = 0xC0 | high_rr;
1193
1194 if (InputsRead)
1195 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead);
1196 }
1197 #else
1198 void r300_setup_rs_unit(GLcontext *ctx)
1199 {
1200 r300ContextPtr r300 = R300_CONTEXT(ctx);
1201 int i, cur_reg;
1202 /* I'm still unsure if these are needed */
1203 GLuint interp_magic[8] = {
1204 0x00,
1205 0x40,
1206 0x80,
1207 0xC0,
1208 0x00,
1209 0x00,
1210 0x00,
1211 0x00
1212 };
1213 GLuint OutputsWritten;
1214
1215 if(hw_tcl_on)
1216 OutputsWritten = CURRENT_VERTEX_SHADER(ctx)->OutputsWritten;
1217
1218 /* This needs to be rewritten - it is a hack at best */
1219
1220 R300_STATECHANGE(r300, ri);
1221 R300_STATECHANGE(r300, rc);
1222 R300_STATECHANGE(r300, rr);
1223
1224 cur_reg = 0;
1225 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0;
1226
1227 for (i=0;i<ctx->Const.MaxTextureUnits;i++) {
1228 r300->hw.ri.cmd[R300_RI_INTERP_0+i] = 0
1229 | R300_RS_INTERP_USED
1230 | (cur_reg << R300_RS_INTERP_SRC_SHIFT)
1231 | interp_magic[i];
1232 // fprintf(stderr, "RS_INTERP[%d] = 0x%x\n", i, r300->hw.ri.cmd[R300_RI_INTERP_0+i]);
1233
1234 if (TMU_ENABLED(ctx, i)) {
1235 assert(r300->state.texture.tc_count != 0);
1236 r300->hw.rr.cmd[R300_RR_ROUTE_0 + cur_reg] = 0
1237 | R300_RS_ROUTE_ENABLE
1238 | i /* source INTERP */
1239 | (cur_reg << R300_RS_ROUTE_DEST_SHIFT);
1240 // fprintf(stderr, "RS_ROUTE[%d] = 0x%x\n", cur_reg, r300->hw.rr.cmd[R300_RR_ROUTE_0 + cur_reg]);
1241 cur_reg++;
1242 }
1243 }
1244 if (hw_tcl_on ? OutputsWritten & (1<<VERT_RESULT_COL0) : r300->state.render_inputs & _TNL_BIT_COLOR0)
1245 r300->hw.rr.cmd[R300_RR_ROUTE_0] |= 0
1246 | R300_RS_ROUTE_0_COLOR
1247 | (cur_reg << R300_RS_ROUTE_0_COLOR_DEST_SHIFT);
1248
1249 // fprintf(stderr, "ADJ_RR0 = 0x%x\n", r300->hw.rr.cmd[R300_RR_ROUTE_0]);
1250
1251 r300->hw.rc.cmd[1] = 0
1252 | (cur_reg /* count */ << R300_RS_CNTL_TC_CNT_SHIFT)
1253 | (1 << R300_RS_CNTL_CI_CNT_SHIFT)
1254 | R300_RS_CNTL_0_UNKNOWN_18;
1255
1256 if (r300->state.texture.tc_count > 0) {
1257 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(R300_RS_ROUTE_0, cur_reg);
1258 r300->hw.rc.cmd[2] = 0xC0 | (cur_reg-1); /* index of highest */
1259 } else {
1260 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(R300_RS_ROUTE_0, 1);
1261 r300->hw.rc.cmd[2] = 0x0;
1262 }
1263
1264
1265 // fprintf(stderr, "rendering with %d texture co-ordinate sets\n", cur_reg);
1266 }
1267 #endif // USE_ARB_F_P
1268
1269 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1270
1271 #define bump_vpu_count(ptr, new_count) do{\
1272 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1273 int _nc=(new_count)/4; \
1274 if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1275 }while(0)
1276
1277 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1278 {
1279 int i;
1280
1281 if(vsf->length==0)return;
1282
1283 if(vsf->length & 0x3){
1284 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1285 exit(-1);
1286 }
1287
1288 switch((dest>>8) & 0xf){
1289 case 0:
1290 R300_STATECHANGE(r300, vpi);
1291 for(i=0;i<vsf->length;i++)
1292 r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1293 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1294 break;
1295
1296 case 2:
1297 R300_STATECHANGE(r300, vpp);
1298 for(i=0;i<vsf->length;i++)
1299 r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1300 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1301 break;
1302 case 4:
1303 R300_STATECHANGE(r300, vps);
1304 for(i=0;i<vsf->length;i++)
1305 r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1306 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1307 break;
1308 default:
1309 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1310 exit(-1);
1311 }
1312 }
1313
1314 void r300SetupVertexProgram(r300ContextPtr rmesa);
1315
1316 /* just a skeleton for now.. */
1317
1318 /* Generate a vertex shader that simply transforms vertex and texture coordinates,
1319 while leaving colors intact. Nothing fancy (like lights)
1320
1321 If implementing lights make a copy first, so it is easy to switch between the two versions */
1322 static void r300GenerateSimpleVertexShader(r300ContextPtr r300)
1323 {
1324 int i;
1325 GLuint o_reg = 0;
1326
1327 /* Allocate parameters */
1328 r300->state.vap_param.transform_offset=0x0; /* transform matrix */
1329 r300->state.vertex_shader.param_offset=0x0;
1330 r300->state.vertex_shader.param_count=0x4; /* 4 vector values - 4x4 matrix */
1331
1332 r300->state.vertex_shader.program_start=0x0;
1333 r300->state.vertex_shader.unknown_ptr1=0x4; /* magic value ? */
1334 r300->state.vertex_shader.program_end=0x0;
1335
1336 r300->state.vertex_shader.unknown_ptr2=0x0; /* magic value */
1337 r300->state.vertex_shader.unknown_ptr3=0x4; /* magic value */
1338
1339 /* Initialize matrix and vector parameters.. these should really be restructured */
1340 /* TODO: fix vertex_shader structure */
1341 r300->state.vertex_shader.matrix[0].length=16;
1342 r300->state.vertex_shader.matrix[1].length=0;
1343 r300->state.vertex_shader.matrix[2].length=0;
1344 r300->state.vertex_shader.vector[0].length=0;
1345 r300->state.vertex_shader.vector[1].length=0;
1346 r300->state.vertex_shader.unknown1.length=0;
1347 r300->state.vertex_shader.unknown2.length=0;
1348
1349 #define WRITE_OP(oper,source1,source2,source3) {\
1350 r300->state.vertex_shader.program.body.i[r300->state.vertex_shader.program_end].op=(oper); \
1351 r300->state.vertex_shader.program.body.i[r300->state.vertex_shader.program_end].src1=(source1); \
1352 r300->state.vertex_shader.program.body.i[r300->state.vertex_shader.program_end].src2=(source2); \
1353 r300->state.vertex_shader.program.body.i[r300->state.vertex_shader.program_end].src3=(source3); \
1354 r300->state.vertex_shader.program_end++; \
1355 }
1356
1357 /* Multiply vertex coordinates with transform matrix */
1358
1359 WRITE_OP(
1360 EASY_VSF_OP(MUL, 0, ALL, TMP),
1361 VSF_PARAM(3),
1362 VSF_ATTR_W(0),
1363 EASY_VSF_SOURCE(0, W, W, W, W, NONE, NONE)
1364 )
1365
1366 WRITE_OP(
1367 EASY_VSF_OP(MUL, 1, ALL, RESULT),
1368 VSF_REG(1),
1369 VSF_ATTR_UNITY(1),
1370 VSF_UNITY(1)
1371 )
1372
1373 WRITE_OP(
1374 EASY_VSF_OP(MAD, 0, ALL, TMP),
1375 VSF_PARAM(2),
1376 VSF_ATTR_Z(0),
1377 VSF_TMP(0)
1378 )
1379
1380 WRITE_OP(
1381 EASY_VSF_OP(MAD, 0, ALL, TMP),
1382 VSF_PARAM(1),
1383 VSF_ATTR_Y(0),
1384 VSF_TMP(0)
1385 )
1386
1387 WRITE_OP(
1388 EASY_VSF_OP(MAD, 0, ALL, RESULT),
1389 VSF_PARAM(0),
1390 VSF_ATTR_X(0),
1391 VSF_TMP(0)
1392 )
1393 o_reg += 2;
1394
1395 if (r300->state.render_inputs & _TNL_BIT_COLOR1) {
1396 WRITE_OP(
1397 EASY_VSF_OP(MUL, o_reg++, ALL, RESULT),
1398 VSF_REG(r300->state.vap_reg.i_color[1]),
1399 VSF_ATTR_UNITY(r300->state.vap_reg.i_color[1]),
1400 VSF_UNITY(r300->state.vap_reg.i_color[1])
1401 )
1402 }
1403
1404 /* Pass through texture coordinates, if any */
1405 for(i=0;i < r300->radeon.glCtx->Const.MaxTextureUnits;i++)
1406 if(r300->state.render_inputs & (_TNL_BIT_TEX0<<i)){
1407 // fprintf(stderr, "i_tex[%d]=%d\n", i, r300->state.vap_reg.i_tex[i]);
1408 WRITE_OP(
1409 EASY_VSF_OP(MUL, o_reg++ /* 2+i */, ALL, RESULT),
1410 VSF_REG(r300->state.vap_reg.i_tex[i]),
1411 VSF_ATTR_UNITY(r300->state.vap_reg.i_tex[i]),
1412 VSF_UNITY(r300->state.vap_reg.i_tex[i])
1413 )
1414 }
1415
1416 r300->state.vertex_shader.program_end--; /* r300 wants program length to be one more - no idea why */
1417 r300->state.vertex_shader.program.length=(r300->state.vertex_shader.program_end+1)*4;
1418
1419 r300->state.vertex_shader.unknown_ptr1=r300->state.vertex_shader.program_end; /* magic value ? */
1420 r300->state.vertex_shader.unknown_ptr2=r300->state.vertex_shader.program_end; /* magic value ? */
1421 r300->state.vertex_shader.unknown_ptr3=r300->state.vertex_shader.program_end; /* magic value ? */
1422
1423 }
1424
1425
1426 void r300SetupVertexShader(r300ContextPtr rmesa)
1427 {
1428 GLcontext* ctx = rmesa->radeon.glCtx;
1429
1430 /* Reset state, in case we don't use something */
1431 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1432 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1433 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1434
1435 /* Not sure why this doesnt work...
1436 0x400 area might have something to do with pixel shaders as it appears right after pfs programming.
1437 0x406 is set to { 0.0, 0.0, 1.0, 0.0 } most of the time but should change with smooth points and in other rare cases. */
1438 //setup_vertex_shader_fragment(rmesa, 0x406, &unk4);
1439 if(hw_tcl_on && ((struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx))->translated){
1440 r300SetupVertexProgram(rmesa);
1441 return ;
1442 }
1443
1444 /* This needs to be replaced by vertex shader generation code */
1445
1446
1447 #if 0
1448 /* textures enabled ? */
1449 if(rmesa->state.texture.tc_count>0){
1450 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1451 } else {
1452 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1453 }
1454 #endif
1455
1456 r300GenerateSimpleVertexShader(rmesa);
1457
1458 rmesa->state.vertex_shader.matrix[0].length=16;
1459 memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1460
1461 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1462
1463 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1464 #if 0
1465 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1466 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1467
1468 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1469 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1470 #endif
1471
1472 #if 0
1473 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1474 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1475 #endif
1476
1477 R300_STATECHANGE(rmesa, pvs);
1478 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1479 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_POS_END_SHIFT)
1480 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1481 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1482 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1483 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1484 | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1485
1486 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1487 so I leave it as a reminder */
1488 #if 0
1489 reg_start(R300_VAP_PVS_WAITIDLE,0);
1490 e32(0x00000000);
1491 #endif
1492 }
1493
1494 void r300SetupVertexProgram(r300ContextPtr rmesa)
1495 {
1496 GLcontext* ctx = rmesa->radeon.glCtx;
1497 int inst_count;
1498 int param_count;
1499 struct r300_vertex_program *prog=(struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx);
1500
1501
1502 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1503 R300_STATECHANGE(rmesa, vpp);
1504 param_count = r300VertexProgUpdateParams(ctx, prog, (float *)&rmesa->hw.vpp.cmd[R300_VPP_PARAM_0]);
1505 bump_vpu_count(rmesa->hw.vpp.cmd, param_count);
1506 param_count /= 4;
1507
1508 /* Reset state, in case we don't use something */
1509 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1510 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1511
1512 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(prog->program));
1513
1514 #if 0
1515 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1516 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1517 #endif
1518
1519 inst_count=prog->program.length/4 - 1;
1520
1521 R300_STATECHANGE(rmesa, pvs);
1522 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(0 << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1523 | (inst_count/*pos_end*/ << R300_PVS_CNTL_1_POS_END_SHIFT)
1524 | (inst_count << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1525 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(0 << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1526 | (param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1527 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(0/*rmesa->state.vertex_shader.unknown_ptr2*/ << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1528 | (inst_count /*rmesa->state.vertex_shader.unknown_ptr3*/ << 0);
1529
1530 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1531 so I leave it as a reminder */
1532 #if 0
1533 reg_start(R300_VAP_PVS_WAITIDLE,0);
1534 e32(0x00000000);
1535 #endif
1536 }
1537
1538 extern void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx );
1539
1540 extern int future_hw_tcl_on;
1541 void r300UpdateShaders(r300ContextPtr rmesa)
1542 {
1543 GLcontext *ctx;
1544 struct r300_vertex_program *vp;
1545
1546 ctx = rmesa->radeon.glCtx;
1547
1548 if (rmesa->NewGLState && hw_tcl_on) {
1549 rmesa->NewGLState = 0;
1550 if (ctx->VertexProgram._Enabled == GL_FALSE)
1551 _tnl_UpdateFixedFunctionProgram(ctx);
1552
1553 vp = (struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx);
1554 if (vp->translated == GL_FALSE)
1555 translate_vertex_shader(vp);
1556 if (vp->translated == GL_FALSE) {
1557 fprintf(stderr, "Failing back to sw-tcl\n");
1558 debug_vp(ctx, &vp->mesa_program);
1559 hw_tcl_on = future_hw_tcl_on = 0;
1560 r300ResetHwState(rmesa);
1561
1562 return ;
1563 }
1564 }
1565
1566 }
1567
1568 void r300UpdateShaderStates(r300ContextPtr rmesa)
1569 {
1570 GLcontext *ctx;
1571 ctx = rmesa->radeon.glCtx;
1572
1573 #ifdef CB_DPATH
1574 r300UpdateTextureState(ctx);
1575 #endif
1576
1577 r300_setup_textures(ctx);
1578 r300_setup_rs_unit(ctx);
1579
1580 r300SetupVertexShader(rmesa);
1581 r300SetupPixelShader(rmesa);
1582 }
1583
1584 /* This is probably wrong for some values, I need to test this
1585 * some more. Range checking would be a good idea also..
1586 *
1587 * But it works for most things. I'll fix it later if someone
1588 * else with a better clue doesn't
1589 */
1590 static unsigned int r300PackFloat24(float f)
1591 {
1592 float mantissa;
1593 int exponent;
1594 unsigned int float24 = 0;
1595
1596 if (f == 0.0) return 0;
1597
1598 mantissa = frexpf(f, &exponent);
1599
1600 /* Handle -ve */
1601 if (mantissa < 0) {
1602 float24 |= (1<<23);
1603 mantissa = mantissa * -1.0;
1604 }
1605 /* Handle exponent, bias of 63 */
1606 exponent += 62;
1607 float24 |= (exponent << 16);
1608 /* Kill 7 LSB of mantissa */
1609 float24 |= (r300PackFloat32(mantissa) & 0x7FFFFF) >> 7;
1610
1611 return float24;
1612 }
1613
1614 #if USE_ARB_F_P == 1
1615 void r300SetupPixelShader(r300ContextPtr rmesa)
1616 {
1617 GLcontext *ctx = rmesa->radeon.glCtx;
1618 struct r300_fragment_program *rp =
1619 (struct r300_fragment_program *)ctx->FragmentProgram._Current;
1620 int i,k;
1621
1622 if (!rp) /* should only happenen once, just after context is created */
1623 return;
1624
1625 translate_fragment_shader(rp);
1626 if (!rp->translated) {
1627 fprintf(stderr, "%s: No valid fragment shader, exiting\n", __func__);
1628 exit(-1);
1629 }
1630
1631 R300_STATECHANGE(rmesa, fpt);
1632 for(i=0;i<rp->tex.length;i++)
1633 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rp->tex.inst[i];
1634 rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmdpacket0(R300_PFS_TEXI_0, rp->tex.length);
1635
1636 #define OUTPUT_FIELD(st, reg, field) \
1637 R300_STATECHANGE(rmesa, st); \
1638 for(i=0;i<=rp->alu_end;i++) \
1639 rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rp->alu.inst[i].field;\
1640 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmdpacket0(reg, rp->alu_end+1);
1641
1642 OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1643 OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1644 OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1645 OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1646 #undef OUTPUT_FIELD
1647
1648 R300_STATECHANGE(rmesa, fp);
1649 /* I just want to say, the way these nodes are stored.. weird.. */
1650 for (i=0,k=(4-(rp->cur_node+1));i<4;i++,k++) {
1651 if (i<(rp->cur_node+1)) {
1652 rmesa->hw.fp.cmd[R300_FP_NODE0+k]=
1653 (rp->node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1654 | (rp->node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
1655 | (rp->node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1656 | (rp->node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
1657 | ( (k==3) ? R300_PFS_NODE_LAST_NODE : 0);
1658 } else {
1659 rmesa->hw.fp.cmd[R300_FP_NODE0+(3-i)] = 0;
1660 }
1661 }
1662
1663 /* PFS_CNTL_0 */
1664 rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1665 rp->cur_node
1666 | (rp->first_node_has_tex<<3);
1667 /* PFS_CNTL_1 */
1668 rmesa->hw.fp.cmd[R300_FP_CNTL1]=rp->max_temp_idx;
1669 /* PFS_CNTL_2 */
1670 rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1671 (rp->alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1672 | (rp->alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1673 | (rp->tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1674 | (rp->tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1675
1676 R300_STATECHANGE(rmesa, fpp);
1677 for(i=0;i<rp->const_nr;i++){
1678 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat24(rp->constant[i][0]);
1679 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat24(rp->constant[i][1]);
1680 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat24(rp->constant[i][2]);
1681 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat24(rp->constant[i][3]);
1682 }
1683 rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmdpacket0(R300_PFS_PARAM_0_X, rp->const_nr*4);
1684 }
1685 #else
1686 /* just a skeleton for now.. */
1687 void r300GenerateTexturePixelShader(r300ContextPtr r300)
1688 {
1689 int i, mtu;
1690 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1691 GLenum envMode;
1692 GLuint OutputsWritten = CURRENT_VERTEX_SHADER(r300->radeon.glCtx)->OutputsWritten;
1693
1694 int tex_inst=0, alu_inst=0;
1695
1696 for(i=0;i<mtu;i++){
1697 /* No need to proliferate {} */
1698 if(!TMU_ENABLED(r300->radeon.glCtx, i))continue;
1699
1700 envMode = r300->radeon.glCtx->Texture.Unit[i].EnvMode;
1701 //fprintf(stderr, "envMode=%s\n", _mesa_lookup_enum_by_nr(envMode));
1702
1703 /* Fetch textured pixel */
1704
1705 r300->state.pixel_shader.program.tex.inst[tex_inst]=0x00018000;
1706 tex_inst++;
1707
1708 switch(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->ModeRGB){
1709 case GL_REPLACE:
1710 WARN_ONCE("ModeA==GL_REPLACE is possibly broken.\n");
1711 r300->state.pixel_shader.program.alu.inst[alu_inst].inst0=
1712 EASY_PFS_INSTR0(MAD, SRC0C_XYZ, ONE, ZERO);
1713
1714 r300->state.pixel_shader.program.alu.inst[alu_inst].inst1=
1715 EASY_PFS_INSTR1(0, 0, 0 | PFS_FLAG_CONST, 0 | PFS_FLAG_CONST, NONE, ALL);
1716 break;
1717 case GL_MODULATE:
1718 WARN_ONCE("ModeRGB==GL_MODULATE is possibly broken.\n");
1719 r300->state.pixel_shader.program.alu.inst[alu_inst].inst0=
1720 EASY_PFS_INSTR0(MAD, SRC0C_XYZ, SRC1C_XYZ, ZERO);
1721
1722 r300->state.pixel_shader.program.alu.inst[alu_inst].inst1=
1723 EASY_PFS_INSTR1(0, 0, 1, 0 | PFS_FLAG_CONST, NONE, ALL);
1724
1725 break;
1726 default:
1727 WARN_ONCE("ModeRGB=%s is not implemented yet !\n",
1728 _mesa_lookup_enum_by_nr(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->ModeRGB));
1729 /* PFS_NOP */
1730 r300->state.pixel_shader.program.alu.inst[alu_inst].inst0=
1731 EASY_PFS_INSTR0(MAD, SRC0C_XYZ, ONE, ZERO);
1732
1733 r300->state.pixel_shader.program.alu.inst[alu_inst].inst1=
1734 EASY_PFS_INSTR1(0, 0, 0 | PFS_FLAG_CONST, 0 | PFS_FLAG_CONST, NONE, ALL);
1735 }
1736 switch(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->ModeA){
1737 case GL_REPLACE:
1738 WARN_ONCE("ModeA==GL_REPLACE is possibly broken.\n");
1739 r300->state.pixel_shader.program.alu.inst[alu_inst].inst2=
1740 EASY_PFS_INSTR2(MAD, SRC0A, ONE, ZERO);
1741
1742 r300->state.pixel_shader.program.alu.inst[alu_inst].inst3=
1743 EASY_PFS_INSTR3(0, 0, 0| PFS_FLAG_CONST, 0 | PFS_FLAG_CONST, OUTPUT);
1744
1745 #if 0
1746 fprintf(stderr, "numArgsA=%d sourceA[0]=%s op=%d\n",
1747 r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->_NumArgsA,
1748 _mesa_lookup_enum_by_nr(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->SourceA[0]),
1749 r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->OperandA[0]-GL_SRC_ALPHA);
1750 #endif
1751 break;
1752 case GL_MODULATE:
1753 WARN_ONCE("ModeA==GL_MODULATE is possibly broken.\n");
1754
1755 r300->state.pixel_shader.program.alu.inst[alu_inst].inst2=
1756 EASY_PFS_INSTR2(MAD, SRC0A, SRC1A, ZERO);
1757
1758 r300->state.pixel_shader.program.alu.inst[alu_inst].inst3=
1759 EASY_PFS_INSTR3(0, 0, 1, 0 | PFS_FLAG_CONST, OUTPUT);
1760
1761 break;
1762 default:
1763 WARN_ONCE("ModeA=%s is not implemented yet !\n",
1764 _mesa_lookup_enum_by_nr(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->ModeA));
1765 /* PFS_NOP */
1766 r300->state.pixel_shader.program.alu.inst[alu_inst].inst2=
1767 EASY_PFS_INSTR2(MAD, SRC0A, ONE, ZERO);
1768
1769 r300->state.pixel_shader.program.alu.inst[alu_inst].inst3=
1770 EASY_PFS_INSTR3(0, 0, 0 | PFS_FLAG_CONST, 0 | PFS_FLAG_CONST, OUTPUT);
1771
1772 }
1773
1774 alu_inst++;
1775 }
1776
1777 r300->state.pixel_shader.program.tex.length=tex_inst;
1778 r300->state.pixel_shader.program.tex_offset=0;
1779 r300->state.pixel_shader.program.tex_end=tex_inst-1;
1780
1781 #if 0
1782 /* saturate last instruction, like i915 driver does */
1783 r300->state.pixel_shader.program.alu.inst[alu_inst-1].inst0|=R300_FPI0_OUTC_SAT;
1784 r300->state.pixel_shader.program.alu.inst[alu_inst-1].inst2|=R300_FPI2_OUTA_SAT;
1785 #endif
1786
1787 r300->state.pixel_shader.program.alu.length=alu_inst;
1788 r300->state.pixel_shader.program.alu_offset=0;
1789 r300->state.pixel_shader.program.alu_end=alu_inst-1;
1790 }
1791
1792 void r300SetupPixelShader(r300ContextPtr rmesa)
1793 {
1794 int i,k;
1795
1796 /* This needs to be replaced by pixel shader generation code */
1797
1798 /* textures enabled ? */
1799 if(rmesa->state.texture.tc_count>0){
1800 #if 1
1801 r300GenerateTextureFragmentShader(rmesa);
1802 #else
1803 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1804 r300GenerateTexturePixelShader(rmesa);
1805 #endif
1806 } else {
1807 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1808 }
1809
1810 R300_STATECHANGE(rmesa, fpt);
1811 for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1812 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1813 rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmdpacket0(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1814
1815 #define OUTPUT_FIELD(st, reg, field) \
1816 R300_STATECHANGE(rmesa, st); \
1817 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1818 rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1819 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmdpacket0(reg, rmesa->state.pixel_shader.program.alu.length);
1820
1821 OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1822 OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1823 OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1824 OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1825 #undef OUTPUT_FIELD
1826
1827 R300_STATECHANGE(rmesa, fp);
1828 for(i=0;i<4;i++){
1829 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1830 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1831 | (rmesa->state.pixel_shader.program.node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
1832 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1833 | (rmesa->state.pixel_shader.program.node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
1834 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1835 }
1836
1837 /* PFS_CNTL_0 */
1838 rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1839 (rmesa->state.pixel_shader.program.active_nodes-1)
1840 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1841 /* PFS_CNTL_1 */
1842 rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1843 /* PFS_CNTL_2 */
1844 rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1845 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1846 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1847 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1848 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1849
1850 R300_STATECHANGE(rmesa, fpp);
1851 for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1852 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1853 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1854 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1855 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1856 }
1857 rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmdpacket0(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1858
1859 }
1860 #endif
1861
1862 /**
1863 * Called by Mesa after an internal state update.
1864 */
1865 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1866 {
1867 r300ContextPtr r300 = R300_CONTEXT(ctx);
1868
1869 _swrast_InvalidateState(ctx, new_state);
1870 _swsetup_InvalidateState(ctx, new_state);
1871 _ac_InvalidateState(ctx, new_state);
1872 _tnl_InvalidateState(ctx, new_state);
1873 _ae_invalidate_state(ctx, new_state);
1874
1875 #ifndef CB_DPATH
1876 /* Go inefficiency! */
1877 r300ResetHwState(r300);
1878 #endif
1879 #ifdef HW_VBOS
1880 if(new_state & _NEW_ARRAY)
1881 r300->state.VB.lock_uptodate = GL_FALSE;
1882 #endif
1883 r300->NewGLState |= new_state;
1884 }
1885
1886 /**
1887 * Completely recalculates hardware state based on the Mesa state.
1888 */
1889 void r300ResetHwState(r300ContextPtr r300)
1890 {
1891 GLcontext* ctx = r300->radeon.glCtx;
1892
1893 if (RADEON_DEBUG & DEBUG_STATE)
1894 fprintf(stderr, "%s\n", __FUNCTION__);
1895
1896 /* This is a place to initialize registers which
1897 have bitfields accessed by different functions
1898 and not all bits are used */
1899 #if 0
1900 /* initialize similiar to r200 */
1901 r300->hw.zs.cmd[R300_ZS_CNTL_0] = 0;
1902 r300->hw.zs.cmd[R300_ZS_CNTL_1] =
1903 (R300_ZS_ALWAYS << R300_RB3D_ZS1_FRONT_FUNC_SHIFT) |
1904 (R300_ZS_KEEP << R300_RB3D_ZS1_FRONT_FAIL_OP_SHIFT) |
1905 (R300_ZS_KEEP << R300_RB3D_ZS1_FRONT_ZPASS_OP_SHIFT) |
1906 (R300_ZS_KEEP << R300_RB3D_ZS1_FRONT_ZFAIL_OP_SHIFT) |
1907 (R300_ZS_ALWAYS << R300_RB3D_ZS1_BACK_FUNC_SHIFT) |
1908 (R300_ZS_KEEP << R300_RB3D_ZS1_BACK_FAIL_OP_SHIFT) |
1909 (R300_ZS_KEEP << R300_RB3D_ZS1_BACK_ZPASS_OP_SHIFT) |
1910 (R300_ZS_KEEP << R300_RB3D_ZS1_BACK_ZFAIL_OP_SHIFT);
1911 r300->hw.zs.cmd[R300_ZS_CNTL_2] = 0x00ffff00;
1912 #endif
1913
1914 /* go and compute register values from GL state */
1915
1916 r300UpdateWindow(ctx);
1917
1918 r300ColorMask(ctx,
1919 ctx->Color.ColorMask[RCOMP],
1920 ctx->Color.ColorMask[GCOMP],
1921 ctx->Color.ColorMask[BCOMP],
1922 ctx->Color.ColorMask[ACOMP]);
1923
1924 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1925 r300DepthMask(ctx, ctx->Depth.Mask);
1926 r300DepthFunc(ctx, ctx->Depth.Func);
1927
1928 /* stencil */
1929 r300Enable(ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled);
1930 r300StencilMaskSeparate(ctx, 0, ctx->Stencil.WriteMask[0]);
1931 r300StencilFuncSeparate(ctx, 0, ctx->Stencil.Function[0], ctx->Stencil.Ref[0], ctx->Stencil.ValueMask[0]);
1932 r300StencilOpSeparate(ctx, 0, ctx->Stencil.FailFunc[0], ctx->Stencil.ZFailFunc[0], ctx->Stencil.ZPassFunc[0]);
1933
1934 r300UpdateCulling(ctx);
1935
1936 r300UpdateTextureState(ctx);
1937
1938 // r300_setup_routing(ctx, GL_TRUE);
1939 if(hw_tcl_on == GL_FALSE){
1940 r300EmitArrays(ctx, GL_TRUE); /* Just do the routing */
1941 r300_setup_textures(ctx);
1942 r300_setup_rs_unit(ctx);
1943
1944 r300SetupVertexShader(r300);
1945 r300SetupPixelShader(r300);
1946 }
1947
1948 r300_set_blend_state(ctx);
1949
1950 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1951 r300Enable(ctx, GL_ALPHA_TEST, ctx->Color.AlphaEnabled);
1952
1953 /* Initialize magic registers
1954 TODO : learn what they really do, or get rid of
1955 those we don't have to touch */
1956 r300->hw.unk2080.cmd[1] = 0x0030045A; /* Dangerous */
1957
1958 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1959 | R300_VPORT_X_OFFSET_ENA
1960 | R300_VPORT_Y_SCALE_ENA
1961 | R300_VPORT_Y_OFFSET_ENA
1962 | R300_VPORT_Z_SCALE_ENA
1963 | R300_VPORT_Z_OFFSET_ENA
1964 | R300_VTX_W0_FMT;
1965 r300->hw.vte.cmd[2] = 0x00000008;
1966
1967 r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1968 r300->hw.unk2134.cmd[2] = 0x00000000;
1969 #ifdef MESA_BIG_ENDIAN
1970 r300->hw.unk2140.cmd[1] = 0x00000002;
1971 #else
1972 r300->hw.unk2140.cmd[1] = 0x00000000;
1973 #endif
1974
1975 #if 0 /* Done in setup routing */
1976 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->packet0.count = 1;
1977 r300->hw.vir[0].cmd[1] = 0x21030003;
1978
1979 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->packet0.count = 1;
1980 r300->hw.vir[1].cmd[1] = 0xF688F688;
1981
1982 r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1983 r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1984 #endif
1985
1986 r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1987
1988 r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1989
1990 r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1991 r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1992 r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1993 r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1994
1995 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1996 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1997 else
1998 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1999
2000 #if 0
2001 r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
2002 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
2003 r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
2004
2005
2006 r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
2007 r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
2008 r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
2009 #endif
2010
2011 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
2012 | R300_GB_LINE_STUFF_ENABLE
2013 | R300_GB_TRIANGLE_STUFF_ENABLE /*| R300_GB_UNK30*/;
2014
2015 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
2016 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
2017 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
2018 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
2019 | R300_GB_TILE_PIPE_COUNT_R300
2020 | R300_GB_TILE_SIZE_16;
2021 else if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R420)
2022 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
2023 | R300_GB_TILE_PIPE_COUNT_R420
2024 | R300_GB_TILE_SIZE_16;
2025 else
2026 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
2027 | R300_GB_TILE_PIPE_COUNT_RV300
2028 | R300_GB_TILE_SIZE_16;
2029 r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
2030 r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
2031
2032 //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
2033
2034 r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
2035 r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
2036 r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
2037 r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
2038
2039 r300->hw.unk4214.cmd[1] = 0x00050005;
2040
2041 r300PointSize(ctx, 0.0);
2042 #if 0
2043 r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
2044 (6 << R300_POINTSIZE_Y_SHIFT);
2045 #endif
2046
2047 r300->hw.unk4230.cmd[1] = 0x01800000;//18000006;
2048 r300->hw.unk4230.cmd[2] = 0x00020006;
2049 r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
2050
2051 r300LineWidth(ctx, 0.0);
2052
2053 r300->hw.unk4260.cmd[1] = 0;
2054 r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
2055 r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
2056
2057 r300->hw.unk4274.cmd[1] = 0x00000002;
2058 r300ShadeModel(ctx, ctx->Light.ShadeModel);
2059 r300->hw.unk4274.cmd[3] = 0x00000000;
2060 r300->hw.unk4274.cmd[4] = 0x00000000;
2061
2062 r300PolygonMode(ctx, GL_FRONT, ctx->Polygon.FrontMode);
2063 r300PolygonMode(ctx, GL_BACK, ctx->Polygon.BackMode);
2064 r300->hw.unk4288.cmd[2] = 0x00000001;
2065 r300->hw.unk4288.cmd[3] = 0x00000000;
2066 r300->hw.unk4288.cmd[4] = 0x00000000;
2067 r300->hw.unk4288.cmd[5] = 0x00000000;
2068
2069 r300->hw.unk42A0.cmd[1] = 0x00000000;
2070
2071 r300PolygonOffset(ctx, ctx->Polygon.OffsetFactor, ctx->Polygon.OffsetUnits);
2072 r300Enable(ctx, GL_POLYGON_OFFSET_FILL, ctx->Polygon.OffsetFill);
2073
2074 r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
2075 r300->hw.unk42C0.cmd[2] = 0x00000000;
2076
2077
2078 r300->hw.unk43A4.cmd[1] = 0x0000001C;
2079 r300->hw.unk43A4.cmd[2] = 0x2DA49525;
2080
2081 r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
2082
2083 #if 0
2084 r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
2085 r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
2086 r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
2087 r300->hw.fp.cmd[R300_FP_NODE0] = 0;
2088 r300->hw.fp.cmd[R300_FP_NODE1] = 0;
2089 r300->hw.fp.cmd[R300_FP_NODE2] = 0;
2090 r300->hw.fp.cmd[R300_FP_NODE3] = 0;
2091 #endif
2092
2093 r300->hw.unk46A4.cmd[1] = 0x00001B01;
2094 r300->hw.unk46A4.cmd[2] = 0x00001B0F;
2095 r300->hw.unk46A4.cmd[3] = 0x00001B0F;
2096 r300->hw.unk46A4.cmd[4] = 0x00001B0F;
2097 r300->hw.unk46A4.cmd[5] = 0x00000001;
2098
2099 #if 0
2100 for(i = 1; i <= 64; ++i) {
2101 /* create NOP instructions */
2102 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
2103 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
2104 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
2105 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
2106 }
2107 #endif
2108
2109 r300->hw.unk4BC0.cmd[1] = 0;
2110
2111 r300->hw.unk4BC8.cmd[1] = 0;
2112 r300->hw.unk4BC8.cmd[2] = 0;
2113 r300->hw.unk4BC8.cmd[3] = 0;
2114
2115
2116 r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
2117 r300->hw.unk4BD8.cmd[1] = 0;
2118
2119 r300->hw.unk4E00.cmd[1] = 0;
2120
2121 #if 0
2122 r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
2123 r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
2124 #endif
2125
2126 r300BlendColor(ctx, ctx->Color.BlendColor);
2127 r300->hw.unk4E10.cmd[2] = 0;
2128 r300->hw.unk4E10.cmd[3] = 0;
2129
2130 /* Again, r300ClearBuffer uses this */
2131 r300->hw.cb.cmd[R300_CB_OFFSET] = r300->radeon.state.color.drawOffset +
2132 r300->radeon.radeonScreen->fbLocation;
2133 r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.state.color.drawPitch;
2134
2135 if (r300->radeon.radeonScreen->cpp == 4)
2136 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_FORMAT_ARGB8888;
2137 else
2138 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_FORMAT_RGB565;
2139
2140 if (r300->radeon.sarea->tiling_enabled)
2141 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_TILE_ENABLE;
2142
2143 r300->hw.unk4E50.cmd[1] = 0;
2144 r300->hw.unk4E50.cmd[2] = 0;
2145 r300->hw.unk4E50.cmd[3] = 0;
2146 r300->hw.unk4E50.cmd[4] = 0;
2147 r300->hw.unk4E50.cmd[5] = 0;
2148 r300->hw.unk4E50.cmd[6] = 0;
2149 r300->hw.unk4E50.cmd[7] = 0;
2150 r300->hw.unk4E50.cmd[8] = 0;
2151 r300->hw.unk4E50.cmd[9] = 0;
2152
2153 r300->hw.unk4E88.cmd[1] = 0;
2154
2155 r300->hw.unk4EA0.cmd[1] = 0x00000000;
2156 r300->hw.unk4EA0.cmd[2] = 0xffffffff;
2157
2158 switch (ctx->Visual.depthBits) {
2159 case 16:
2160 r300->hw.unk4F10.cmd[1] = R300_DEPTH_FORMAT_16BIT_INT_Z;
2161 break;
2162 case 24:
2163 r300->hw.unk4F10.cmd[1] = R300_DEPTH_FORMAT_24BIT_INT_Z;
2164 break;
2165 default:
2166 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
2167 ctx->Visual.depthBits);
2168 exit(-1);
2169
2170 }
2171 r300->hw.unk4F10.cmd[3] = 0x00000003;
2172 r300->hw.unk4F10.cmd[4] = 0x00000000;
2173
2174 r300->hw.zb.cmd[R300_ZB_OFFSET] =
2175 r300->radeon.radeonScreen->depthOffset +
2176 r300->radeon.radeonScreen->fbLocation;
2177 r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
2178
2179 if (r300->radeon.sarea->tiling_enabled) {
2180 /* Turn off when clearing buffers ? */
2181 r300->hw.zb.cmd[R300_ZB_PITCH] |= R300_DEPTH_TILE_ENABLE;
2182
2183 if (ctx->Visual.depthBits == 24)
2184 r300->hw.zb.cmd[R300_ZB_PITCH] |= R300_DEPTH_MICROTILE_ENABLE;
2185 }
2186
2187 r300->hw.unk4F28.cmd[1] = 0;
2188
2189 r300->hw.unk4F30.cmd[1] = 0;
2190 r300->hw.unk4F30.cmd[2] = 0;
2191
2192 r300->hw.unk4F44.cmd[1] = 0;
2193
2194 r300->hw.unk4F54.cmd[1] = 0;
2195
2196 #if 0
2197 ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
2198 for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
2199 /* MOV t0, t0 */
2200 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
2201 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
2202 r300->hw.vpi.cmd[i+2] = VP_ZERO();
2203 r300->hw.vpi.cmd[i+3] = VP_ZERO();
2204 }
2205
2206 ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
2207 for(i = 1; i < R300_VPP_CMDSIZE; ++i)
2208 r300->hw.vpp.cmd[i] = 0;
2209 #endif
2210
2211 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
2212 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
2213 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
2214 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
2215
2216 //END: TODO
2217 r300->hw.all_dirty = GL_TRUE;
2218 }
2219
2220
2221
2222 /**
2223 * Calculate initial hardware state and register state functions.
2224 * Assumes that the command buffer and state atoms have been
2225 * initialized already.
2226 */
2227 void r300InitState(r300ContextPtr r300)
2228 {
2229 GLcontext *ctx = r300->radeon.glCtx;
2230 GLuint depth_fmt;
2231
2232 radeonInitState(&r300->radeon);
2233
2234 switch (ctx->Visual.depthBits) {
2235 case 16:
2236 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
2237 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
2238 r300->state.stencil.clear = 0x00000000;
2239 break;
2240 case 24:
2241 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
2242 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
2243 r300->state.stencil.clear = 0x00ff0000;
2244 break;
2245 default:
2246 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
2247 ctx->Visual.depthBits);
2248 exit(-1);
2249 }
2250
2251 /* Only have hw stencil when depth buffer is 24 bits deep */
2252 r300->state.stencil.hw_stencil = (ctx->Visual.stencilBits > 0 &&
2253 ctx->Visual.depthBits == 24);
2254
2255 memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
2256
2257 r300ResetHwState(r300);
2258 }
2259
2260 static void r300RenderMode( GLcontext *ctx, GLenum mode )
2261 {
2262 r300ContextPtr rmesa = R300_CONTEXT(ctx);
2263 (void)rmesa;
2264 WARN_ONCE("TODO: fallback properly when rendering mode is not GL_RENDER\n"
2265 "\tThe way things are now neither selection nor feedback modes work\n")
2266 // FALLBACK( rmesa, R300_FALLBACK_RENDER_MODE, (mode != GL_RENDER) );
2267 }
2268
2269 /**
2270 * Initialize driver's state callback functions
2271 */
2272 void r300InitStateFuncs(struct dd_function_table* functions)
2273 {
2274 radeonInitStateFuncs(functions);
2275
2276 functions->UpdateState = r300InvalidateState;
2277 functions->AlphaFunc = r300AlphaFunc;
2278 functions->BlendColor = r300BlendColor;
2279 functions->BlendEquationSeparate = r300BlendEquationSeparate;
2280 functions->BlendFuncSeparate = r300BlendFuncSeparate;
2281 functions->Enable = r300Enable;
2282 functions->ColorMask = r300ColorMask;
2283 functions->DepthFunc = r300DepthFunc;
2284 functions->DepthMask = r300DepthMask;
2285 functions->CullFace = r300CullFace;
2286 functions->FrontFace = r300FrontFace;
2287 functions->ShadeModel = r300ShadeModel;
2288
2289 /* Stencil related */
2290 functions->ClearStencil = r300ClearStencil;
2291 functions->StencilFuncSeparate = r300StencilFuncSeparate;
2292 functions->StencilMaskSeparate = r300StencilMaskSeparate;
2293 functions->StencilOpSeparate = r300StencilOpSeparate;
2294
2295 /* Viewport related */
2296 functions->Viewport = r300Viewport;
2297 functions->DepthRange = r300DepthRange;
2298 functions->PointSize = r300PointSize;
2299 functions->LineWidth = r300LineWidth;
2300
2301 functions->PolygonOffset = r300PolygonOffset;
2302 functions->PolygonMode = r300PolygonMode;
2303
2304 functions->RenderMode = r300RenderMode;
2305 }
2306