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