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