projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Removing some regs that are wrong and adding some comments to r300_reg.h .
[mesa.git] / src / mesa / drivers / dri / r300 / r300_state.c
1 /*
2 Copyright (C) The Weather Channel, Inc. 2002.
3 Copyright (C) 2004 Nicolai Haehnle.
4 All Rights Reserved.
5
6 The Weather Channel (TM) funded Tungsten Graphics to develop the
7 initial release of the Radeon 8500 driver under the XFree86 license.
8 This notice must be preserved.
9
10 Permission is hereby granted, free of charge, to any person obtaining
11 a copy of this software and associated documentation files (the
12 "Software"), to deal in the Software without restriction, including
13 without limitation the rights to use, copy, modify, merge, publish,
14 distribute, sublicense, and/or sell copies of the Software, and to
15 permit persons to whom the Software is furnished to do so, subject to
16 the following conditions:
17
18 The above copyright notice and this permission notice (including the
19 next paragraph) shall be included in all copies or substantial
20 portions of the Software.
21
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
26 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29
30 **************************************************************************/
31
32 /*
33 * Authors:
34 * Nicolai Haehnle <prefect_@gmx.net>
35 */
36
37 #include "glheader.h"
38 #include "state.h"
39 #include "imports.h"
40 #include "enums.h"
41 #include "macros.h"
42 #include "context.h"
43 #include "dd.h"
44 #include "simple_list.h"
45
46 #include "api_arrayelt.h"
47 #include "swrast/swrast.h"
48 #include "swrast_setup/swrast_setup.h"
49 #include "array_cache/acache.h"
50 #include "tnl/tnl.h"
51 #include "texformat.h"
52
53 #include "radeon_ioctl.h"
54 #include "radeon_state.h"
55 #include "r300_context.h"
56 #include "r300_ioctl.h"
57 #include "r300_state.h"
58 #include "r300_reg.h"
59 #include "r300_program.h"
60 #include "r300_emit.h"
61 #include "r300_fixed_pipelines.h"
62
63
64 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
65 {
66 r300ContextPtr rmesa = R300_CONTEXT(ctx);
67 int pp_misc = rmesa->hw.at.cmd[R300_AT_ALPHA_TEST];
68 GLubyte refByte;
69
70 CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
71
72 R300_STATECHANGE(rmesa, at);
73
74 pp_misc &= ~(R300_ALPHA_TEST_OP_MASK | R300_REF_ALPHA_MASK);
75 pp_misc |= (refByte & R300_REF_ALPHA_MASK);
76
77 switch (func) {
78 case GL_NEVER:
79 pp_misc |= R300_ALPHA_TEST_FAIL;
80 break;
81 case GL_LESS:
82 pp_misc |= R300_ALPHA_TEST_LESS;
83 break;
84 case GL_EQUAL:
85 pp_misc |= R300_ALPHA_TEST_EQUAL;
86 break;
87 case GL_LEQUAL:
88 pp_misc |= R300_ALPHA_TEST_LEQUAL;
89 break;
90 case GL_GREATER:
91 pp_misc |= R300_ALPHA_TEST_GREATER;
92 break;
93 case GL_NOTEQUAL:
94 pp_misc |= R300_ALPHA_TEST_NEQUAL;
95 break;
96 case GL_GEQUAL:
97 pp_misc |= R300_ALPHA_TEST_GEQUAL;
98 break;
99 case GL_ALWAYS:
100 pp_misc |= R300_ALPHA_TEST_PASS;
101 break;
102 }
103
104 rmesa->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
105 }
106
107 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
108 {
109 GLubyte color[4];
110 r300ContextPtr rmesa = R300_CONTEXT(ctx);
111 fprintf(stderr, "%s:%s is not implemented yet. Fixme !\n", __FILE__, __FUNCTION__);
112 #if 0
113 R200_STATECHANGE(rmesa, ctx);
114 CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
115 CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
116 CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
117 CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
118 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor)
119 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCOLOR] =
120 radeonPackColor(4, color[0], color[1], color[2], color[3]);
121 #endif
122 }
123
124 /**
125 * Calculate the hardware blend factor setting. This same function is used
126 * for source and destination of both alpha and RGB.
127 *
128 * \returns
129 * The hardware register value for the specified blend factor. This value
130 * will need to be shifted into the correct position for either source or
131 * destination factor.
132 *
133 * \todo
134 * Since the two cases where source and destination are handled differently
135 * are essentially error cases, they should never happen. Determine if these
136 * cases can be removed.
137 */
138 static int blend_factor(GLenum factor, GLboolean is_src)
139 {
140 int func;
141
142 switch (factor) {
143 case GL_ZERO:
144 func = R200_BLEND_GL_ZERO;
145 break;
146 case GL_ONE:
147 func = R200_BLEND_GL_ONE;
148 break;
149 case GL_DST_COLOR:
150 func = R200_BLEND_GL_DST_COLOR;
151 break;
152 case GL_ONE_MINUS_DST_COLOR:
153 func = R200_BLEND_GL_ONE_MINUS_DST_COLOR;
154 break;
155 case GL_SRC_COLOR:
156 func = R200_BLEND_GL_SRC_COLOR;
157 break;
158 case GL_ONE_MINUS_SRC_COLOR:
159 func = R200_BLEND_GL_ONE_MINUS_SRC_COLOR;
160 break;
161 case GL_SRC_ALPHA:
162 func = R200_BLEND_GL_SRC_ALPHA;
163 break;
164 case GL_ONE_MINUS_SRC_ALPHA:
165 func = R200_BLEND_GL_ONE_MINUS_SRC_ALPHA;
166 break;
167 case GL_DST_ALPHA:
168 func = R200_BLEND_GL_DST_ALPHA;
169 break;
170 case GL_ONE_MINUS_DST_ALPHA:
171 func = R200_BLEND_GL_ONE_MINUS_DST_ALPHA;
172 break;
173 case GL_SRC_ALPHA_SATURATE:
174 func =
175 (is_src) ? R200_BLEND_GL_SRC_ALPHA_SATURATE :
176 R200_BLEND_GL_ZERO;
177 break;
178 case GL_CONSTANT_COLOR:
179 func = R200_BLEND_GL_CONST_COLOR;
180 break;
181 case GL_ONE_MINUS_CONSTANT_COLOR:
182 func = R200_BLEND_GL_ONE_MINUS_CONST_COLOR;
183 break;
184 case GL_CONSTANT_ALPHA:
185 func = R200_BLEND_GL_CONST_ALPHA;
186 break;
187 case GL_ONE_MINUS_CONSTANT_ALPHA:
188 func = R200_BLEND_GL_ONE_MINUS_CONST_ALPHA;
189 break;
190 default:
191 func = (is_src) ? R200_BLEND_GL_ONE : R200_BLEND_GL_ZERO;
192 }
193 return func;
194 }
195
196 /**
197 * Sets both the blend equation and the blend function.
198 * This is done in a single
199 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
200 * change the interpretation of the blend function.
201 * Also, make sure that blend function and blend equation are set to their default
202 * value if color blending is not enabled, since at least blend equations GL_MIN
203 * and GL_FUNC_REVERSE_SUBTRACT will cause wrong results otherwise for
204 * unknown reasons.
205 */
206
207 /* helper function */
208 static void r300_set_blend_cntl(r300ContextPtr rmesa, int func, int eqn, int cbits, int funcA, int eqnA)
209 {
210 GLuint new_ablend, new_cblend;
211
212 #if 0
213 fprintf(stderr, "eqnA=%08x funcA=%08x eqn=%08x func=%08x cbits=%08x\n", eqnA, funcA, eqn, func, cbits);
214 #endif
215 new_ablend = eqnA | funcA;
216 new_cblend = eqn | func;
217 if(funcA == func){
218 new_cblend |= R300_BLEND_NO_SEPARATE;
219 }
220 new_cblend |= cbits;
221
222 if((new_ablend != rmesa->hw.bld.cmd[R300_BLD_ABLEND])
223 || (new_cblend != rmesa->hw.bld.cmd[R300_BLD_CBLEND])){
224 R300_STATECHANGE(rmesa, bld);
225 rmesa->hw.bld.cmd[R300_BLD_ABLEND]=new_ablend;
226 rmesa->hw.bld.cmd[R300_BLD_CBLEND]=new_cblend;
227 }
228 }
229
230 static void r300_set_blend_state(GLcontext * ctx)
231 {
232 r300ContextPtr rmesa = R300_CONTEXT(ctx);
233 #if 0
234 GLuint cntl = rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &
235 ~(R300_ROP_ENABLE | R300_ALPHA_BLEND_ENABLE |
236 R300_SEPARATE_ALPHA_ENABLE);
237 #endif
238
239 int func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
240 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
241 int eqn = R200_COMB_FCN_ADD_CLAMP;
242 int funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
243 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
244 int eqnA = R200_COMB_FCN_ADD_CLAMP;
245
246
247 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
248 if (ctx->Color._LogicOpEnabled) {
249 #if 0
250 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
251 cntl | R300_ROP_ENABLE;
252 #endif
253 r300_set_blend_cntl(rmesa,
254 func, eqn, 0,
255 func, eqn);
256 return;
257 } else if (ctx->Color.BlendEnabled) {
258 #if 0
259 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
260 cntl | R300_ALPHA_BLEND_ENABLE |
261 R300_SEPARATE_ALPHA_ENABLE;
262 #endif
263 } else {
264 #if 0
265 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
266 #endif
267 r300_set_blend_cntl(rmesa,
268 func, eqn, 0,
269 func, eqn);
270 return;
271 }
272 } else {
273 if (ctx->Color._LogicOpEnabled) {
274 #if 0
275 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
276 cntl | R300_ROP_ENABLE;
277 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
278 #endif
279 return;
280 } else if (ctx->Color.BlendEnabled) {
281 #if 0
282 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
283 cntl | R300_ALPHA_BLEND_ENABLE;
284 #endif
285 } else {
286 #if 0
287 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
288 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
289 #endif
290 r300_set_blend_cntl(rmesa,
291 func, eqn, 0,
292 func, eqn);
293 return;
294 }
295 }
296
297 func =
298 (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
299 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
300 GL_FALSE) <<
301 R200_DST_BLEND_SHIFT);
302
303 switch (ctx->Color.BlendEquationRGB) {
304 case GL_FUNC_ADD:
305 eqn = R300_COMB_FCN_ADD_CLAMP;
306 break;
307
308 case GL_FUNC_SUBTRACT:
309 eqn = R300_COMB_FCN_SUB_CLAMP;
310 break;
311
312 case GL_FUNC_REVERSE_SUBTRACT:
313 eqn = R200_COMB_FCN_RSUB_CLAMP;
314 break;
315
316 case GL_MIN:
317 eqn = R200_COMB_FCN_MIN;
318 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
319 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
320 break;
321
322 case GL_MAX:
323 eqn = R200_COMB_FCN_MAX;
324 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
325 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
326 break;
327
328 default:
329 fprintf(stderr,
330 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
331 __func__, __LINE__, ctx->Color.BlendEquationRGB);
332 return;
333 }
334
335 if (!rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
336 #if 0
337 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
338 #endif
339 return;
340 }
341
342 funcA =
343 (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
344 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
345 GL_FALSE) <<
346 R200_DST_BLEND_SHIFT);
347
348 switch (ctx->Color.BlendEquationA) {
349 case GL_FUNC_ADD:
350 eqnA = R300_COMB_FCN_ADD_CLAMP;
351 break;
352
353 case GL_FUNC_SUBTRACT:
354 eqnA = R300_COMB_FCN_SUB_CLAMP;
355 break;
356
357 case GL_FUNC_REVERSE_SUBTRACT:
358 eqnA = R200_COMB_FCN_RSUB_CLAMP;
359 break;
360
361 case GL_MIN:
362 eqnA = R200_COMB_FCN_MIN;
363 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
364 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
365 break;
366
367 case GL_MAX:
368 eqnA = R200_COMB_FCN_MAX;
369 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
370 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
371 break;
372
373 default:
374 fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n",
375 __func__, __LINE__, ctx->Color.BlendEquationA);
376 return;
377 }
378
379 r300_set_blend_cntl(rmesa,
380 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
381 funcA, eqnA);
382 r300_set_blend_cntl(rmesa,
383 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
384 funcA, eqnA);
385 }
386
387 static void r300BlendEquationSeparate(GLcontext * ctx,
388 GLenum modeRGB, GLenum modeA)
389 {
390 r300_set_blend_state(ctx);
391 }
392
393 static void r300BlendFuncSeparate(GLcontext * ctx,
394 GLenum sfactorRGB, GLenum dfactorRGB,
395 GLenum sfactorA, GLenum dfactorA)
396 {
397 r300_set_blend_state(ctx);
398 }
399
400 /**
401 * Update our tracked culling state based on Mesa's state.
402 */
403 static void r300UpdateCulling(GLcontext* ctx)
404 {
405 r300ContextPtr r300 = R300_CONTEXT(ctx);
406 uint32_t val = 0;
407
408 R300_STATECHANGE(r300, cul);
409 if (ctx->Polygon.CullFlag) {
410 if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
411 val = R300_CULL_FRONT|R300_CULL_BACK;
412 else if (ctx->Polygon.CullFaceMode == GL_FRONT)
413 val = R300_CULL_FRONT;
414 else
415 val = R300_CULL_BACK;
416
417 if (ctx->Polygon.FrontFace == GL_CW)
418 val |= R300_FRONT_FACE_CW;
419 else
420 val |= R300_FRONT_FACE_CCW;
421 }
422 r300->hw.cul.cmd[R300_CUL_CULL] = val;
423 }
424
425
426 /**
427 * Handle glEnable()/glDisable().
428 *
429 * \note Mesa already filters redundant calls to glEnable/glDisable.
430 */
431 static void r300Enable(GLcontext* ctx, GLenum cap, GLboolean state)
432 {
433 r300ContextPtr r300 = R300_CONTEXT(ctx);
434 uint32_t newval;
435
436 if (RADEON_DEBUG & DEBUG_STATE)
437 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
438 _mesa_lookup_enum_by_nr(cap),
439 state ? "GL_TRUE" : "GL_FALSE");
440
441 switch (cap) {
442 /* Fast track this one...
443 */
444 case GL_TEXTURE_1D:
445 case GL_TEXTURE_2D:
446 case GL_TEXTURE_3D:
447 break;
448
449 case GL_ALPHA_TEST:
450 R200_STATECHANGE(r300, at);
451 if (state) {
452 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
453 R300_ALPHA_TEST_ENABLE;
454 } else {
455 r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
456 ~R300_ALPHA_TEST_ENABLE;
457 }
458 break;
459
460 case GL_BLEND:
461 case GL_COLOR_LOGIC_OP:
462 r300_set_blend_state(ctx);
463 break;
464
465 case GL_DEPTH_TEST:
466 R300_STATECHANGE(r300, zs);
467
468 if (state) {
469 if (ctx->Depth.Mask)
470 newval = R300_RB3D_Z_TEST_AND_WRITE;
471 else
472 newval = R300_RB3D_Z_TEST;
473 } else
474 newval = 0;
475
476 r300->hw.zs.cmd[R300_ZS_CNTL_0] = newval;
477 break;
478
479 case GL_STENCIL_TEST:
480
481 WARN_ONCE("Do not know how to enable stencil. Help me !\n");
482
483 if (r300->state.hw_stencil) {
484 //fprintf(stderr, "Stencil %s\n", state ? "enabled" : "disabled");
485 R300_STATECHANGE(r300, zs);
486 if (state) {
487 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
488 R300_RB3D_STENCIL_ENABLE;
489 } else {
490 r300->hw.zs.cmd[R300_ZS_CNTL_0] &=
491 ~R300_RB3D_STENCIL_ENABLE;
492 }
493 } else {
494 FALLBACK(&r300->radeon, RADEON_FALLBACK_STENCIL, state);
495 }
496 break;
497
498 case GL_CULL_FACE:
499 r300UpdateCulling(ctx);
500 break;
501
502 case GL_POLYGON_OFFSET_POINT:
503 case GL_POLYGON_OFFSET_LINE:
504 WARN_ONCE("Don't know how to enable polygon offset point/line. Help me !\n");
505
506 /* Something is apparently blocking these from working */
507 R300_STATECHANGE(r300, unk42B4);
508 if(state){
509 r300->hw.unk42B4.cmd[1] |= ~(3<<0);
510 } else {
511 r300->hw.unk42B4.cmd[1] &= (3<<0);
512 }
513 break;
514
515 case GL_POLYGON_OFFSET_FILL:
516 R300_STATECHANGE(r300, unk42B4);
517 if(state){
518 r300->hw.unk42B4.cmd[1] |= (3<<0);
519 } else {
520 r300->hw.unk42B4.cmd[1] &= ~(3<<0);
521 }
522 break;
523
524 case GL_VERTEX_PROGRAM_ARB:
525 //TCL_FALLBACK(rmesa->glCtx, R200_TCL_FALLBACK_TCL_DISABLE, state);
526 break;
527
528 default:
529 radeonEnable(ctx, cap, state);
530 return;
531 }
532 }
533
534
535 /**
536 * Change the culling mode.
537 *
538 * \note Mesa already filters redundant calls to this function.
539 */
540 static void r300CullFace(GLcontext* ctx, GLenum mode)
541 {
542 (void)mode;
543
544 r300UpdateCulling(ctx);
545 }
546
547
548 /**
549 * Change the polygon orientation.
550 *
551 * \note Mesa already filters redundant calls to this function.
552 */
553 static void r300FrontFace(GLcontext* ctx, GLenum mode)
554 {
555 (void)mode;
556
557 r300UpdateCulling(ctx);
558 }
559
560
561 /**
562 * Change the depth testing function.
563 *
564 * \note Mesa already filters redundant calls to this function.
565 */
566 static void r300DepthFunc(GLcontext* ctx, GLenum func)
567 {
568 r300ContextPtr r300 = R300_CONTEXT(ctx);
569
570 R300_STATECHANGE(r300, zs);
571
572 r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
573
574 switch(func) {
575 case GL_NEVER:
576 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NEVER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
577 break;
578 case GL_LESS:
579 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LESS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
580 break;
581 case GL_EQUAL:
582 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_EQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
583 break;
584 case GL_LEQUAL:
585 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
586 break;
587 case GL_GREATER:
588 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GREATER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
589 break;
590 case GL_NOTEQUAL:
591 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NOTEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
592 break;
593 case GL_GEQUAL:
594 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
595 break;
596 case GL_ALWAYS:
597 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_ALWAYS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
598 break;
599 }
600
601 }
602
603
604 /**
605 * Enable/Disable depth writing.
606 *
607 * \note Mesa already filters redundant calls to this function.
608 */
609 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
610 {
611 r300ContextPtr r300 = R300_CONTEXT(ctx);
612
613 if (!ctx->Depth.Test)
614 return;
615
616 R300_STATECHANGE(r300, zs);
617 r300->hw.zs.cmd[R300_ZS_CNTL_0] = mask
618 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
619 }
620
621
622 /**
623 * Handle glColorMask()
624 */
625 static void r300ColorMask(GLcontext* ctx,
626 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
627 {
628 r300ContextPtr r300 = R300_CONTEXT(ctx);
629 int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
630
631 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
632 R300_STATECHANGE(r300, cmk);
633 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
634 }
635 }
636
637 /* =============================================================
638 * Point state
639 */
640 static void r300PointSize(GLcontext * ctx, GLfloat size)
641 {
642 r300ContextPtr r300 = R300_CONTEXT(ctx);
643
644 /* TODO: Validate point size */
645 R300_STATECHANGE(r300, ps);
646 r300->hw.ps.cmd[R300_PS_POINTSIZE] =
647 ((int)(size * 6) << R300_POINTSIZE_X_SHIFT) |
648 ((int)(size * 6) << R300_POINTSIZE_Y_SHIFT);
649
650 #if 0 /* r200 reg? */
651 /* This might need fixing later */
652 R300_STATECHANGE(r300, vps);
653 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
654 #endif
655 }
656
657 /* =============================================================
658 * Line state
659 */
660 static void r300LineWidth(GLcontext *ctx, GLfloat widthf)
661 {
662 r300ContextPtr r300 = R300_CONTEXT(ctx);
663 /* IMHO mesa isnt clamping line widths according to ctx->Const.*LineWidth
664 before calling this from the dd function table.
665 Since r300ResetHwState calls these with clamped values,
666 they must be set properly. */
667
668 R300_STATECHANGE(r300, lcntl);
669 r300->hw.lcntl.cmd[1] = (int)(widthf * 6.0);
670 /* Doesnt look very good without this... */
671 r300->hw.lcntl.cmd[1] |= R300_LINE_CNT_UNK1;
672 }
673
674 /*
675
676 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); : 00000091 ( 1001 0001)
677 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); : 00000001 ( 1)
678
679 glPolygonMode(GL_FRONT, GL_LINE); : 00000111 (1 0001 0001)
680 glPolygonMode(GL_FRONT, GL_POINT); : 00000101 (1 0000 0001)
681
682 glPolygonMode(GL_BACK, GL_LINE); : 000000a1 ( 1010 0001)
683 glPolygonMode(GL_BACK, GL_POINT); : 00000021 ( 10 0001)
684
685 */
686
687 /* exclusive */
688 #define PM_NOT_BACK (1<<8)
689 #define PM_NOT_FRONT (1<<5)
690
691 #define PM_FRONT_LINE (1<<4)
692 #define PM_BACK_LINE (1<<7)
693
694 static void r300PolygonMode(GLcontext *ctx, GLenum face, GLenum mode)
695 {
696 r300ContextPtr r300 = R300_CONTEXT(ctx);
697 unsigned long hw_mode=0;
698
699 hw_mode=r300->hw.unk4288.cmd[1];
700 hw_mode |= 1; /* enables point mode by default */
701
702 switch (face) {
703 case GL_FRONT:
704 //fprintf(stderr, "front\n");
705 hw_mode &= ~PM_NOT_FRONT;
706 switch (mode) {
707 case GL_LINE:
708 hw_mode |= PM_FRONT_LINE;
709 break;
710 case GL_POINT:
711 hw_mode &= ~PM_FRONT_LINE;
712 break;
713 case GL_FILL: /* No idea */
714 hw_mode = 0;
715 break;
716 }
717 break;
718
719 case GL_BACK:
720 //fprintf(stderr, "back\n");
721 hw_mode &= ~PM_NOT_BACK;
722 switch (mode) {
723 case GL_LINE:
724 hw_mode |= PM_BACK_LINE;
725 break;
726 case GL_POINT:
727 hw_mode &= ~PM_BACK_LINE;
728 break;
729 case GL_FILL: /* No idea */
730 hw_mode = 0;
731 break;
732 }
733 break;
734
735 case GL_FRONT_AND_BACK:
736 //fprintf(stderr, "front and back\n");
737 hw_mode &= ~PM_NOT_FRONT;
738 hw_mode &= ~PM_NOT_BACK;
739 switch (mode) {
740 case GL_LINE:
741 hw_mode |= PM_FRONT_LINE;
742 hw_mode |= PM_BACK_LINE;
743 break;
744 case GL_POINT:
745 hw_mode &= ~PM_FRONT_LINE;
746 hw_mode &= ~PM_BACK_LINE;
747 break;
748 case GL_FILL:
749 hw_mode = 0;
750 break;
751 }
752 break;
753 }
754
755 //if( front and back fill) hw_mode=0;
756
757 if(r300->hw.unk4288.cmd[1] != hw_mode){
758 R300_STATECHANGE(r300, unk4288);
759 r300->hw.unk4288.cmd[1] = hw_mode;
760 }
761 }
762
763 /* =============================================================
764 * Stencil
765 */
766
767 static int translate_stencil_func(int func)
768 {
769 switch (func) {
770 case GL_NEVER:
771 return R300_ZS_NEVER;
772 break;
773 case GL_LESS:
774 return R300_ZS_LESS;
775 break;
776 case GL_EQUAL:
777 return R300_ZS_EQUAL;
778 break;
779 case GL_LEQUAL:
780 return R300_ZS_LEQUAL;
781 break;
782 case GL_GREATER:
783 return R300_ZS_GREATER;
784 break;
785 case GL_NOTEQUAL:
786 return R300_ZS_NOTEQUAL;
787 break;
788 case GL_GEQUAL:
789 return R300_ZS_GEQUAL;
790 break;
791 case GL_ALWAYS:
792 return R300_ZS_ALWAYS;
793 break;
794 }
795 return 0;
796 }
797
798 static int translate_stencil_op(int op)
799 {
800 switch (op) {
801 case GL_KEEP:
802 return R300_ZS_KEEP;
803 case GL_ZERO:
804 return R300_ZS_ZERO;
805 case GL_REPLACE:
806 return R300_ZS_REPLACE;
807 case GL_INCR:
808 return R300_ZS_INCR;
809 case GL_DECR:
810 return R300_ZS_DECR;
811 case GL_INCR_WRAP_EXT:
812 return R300_ZS_INCR_WRAP;
813 case GL_DECR_WRAP_EXT:
814 return R300_ZS_DECR_WRAP;
815 case GL_INVERT:
816 return R300_ZS_INVERT;
817 default:
818 WARN_ONCE("Do not know how to translate stencil op");
819 return R300_ZS_KEEP;
820 }
821 }
822
823 static void r300StencilFunc(GLcontext * ctx, GLenum func,
824 GLint ref, GLuint mask)
825 {
826 r300ContextPtr rmesa = R300_CONTEXT(ctx);
827 GLuint refmask = ((ctx->Stencil.Ref[0] << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
828 (ctx->Stencil.
829 ValueMask[0] << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
830 GLuint flag;
831
832 R300_STATECHANGE(rmesa, zs);
833
834 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(
835 (R300_ZS_MASK << R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
836 | (R300_ZS_MASK << R300_RB3D_ZS1_BACK_FUNC_SHIFT));
837 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &= ~((R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
838 (R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
839
840 flag = translate_stencil_func(ctx->Stencil.Function[0]);
841
842 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |= (flag << R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
843 | (flag << R300_RB3D_ZS1_BACK_FUNC_SHIFT);
844 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
845 }
846
847 static void r300StencilMask(GLcontext * ctx, GLuint mask)
848 {
849 r300ContextPtr rmesa = R300_CONTEXT(ctx);
850
851 R300_STATECHANGE(rmesa, zs);
852 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &= ~(R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT);
853 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= ctx->Stencil.WriteMask[0] << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT;
854 }
855
856
857 static void r300StencilOp(GLcontext * ctx, GLenum fail,
858 GLenum zfail, GLenum zpass)
859 {
860 r300ContextPtr rmesa = R300_CONTEXT(ctx);
861
862 R300_STATECHANGE(rmesa, zs);
863 /* It is easier to mask what's left.. */
864 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= (R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
865
866 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
867 (translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_FRONT_FAIL_OP_SHIFT)
868 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_FRONT_ZFAIL_OP_SHIFT)
869 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_FRONT_ZPASS_OP_SHIFT)
870 |(translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_BACK_FAIL_OP_SHIFT)
871 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_BACK_ZFAIL_OP_SHIFT)
872 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_BACK_ZPASS_OP_SHIFT);
873
874 }
875
876 static void r300ClearStencil(GLcontext * ctx, GLint s)
877 {
878 r300ContextPtr rmesa = R300_CONTEXT(ctx);
879
880 /* Not sure whether this is correct.. */
881 R300_STATECHANGE(rmesa, zs);
882 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] =
883 ((GLuint) ctx->Stencil.Clear |
884 (0xff << R200_STENCIL_MASK_SHIFT) |
885 (ctx->Stencil.WriteMask[0] << R200_STENCIL_WRITEMASK_SHIFT));
886 }
887
888 /* =============================================================
889 * Window position and viewport transformation
890 */
891
892 /*
893 * To correctly position primitives:
894 */
895 #define SUBPIXEL_X 0.125
896 #define SUBPIXEL_Y 0.125
897
898 void r300UpdateWindow(GLcontext * ctx)
899 {
900 r300ContextPtr rmesa = R300_CONTEXT(ctx);
901 __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
902 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
903 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
904 const GLfloat *v = ctx->Viewport._WindowMap.m;
905
906 GLfloat sx = v[MAT_SX];
907 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
908 GLfloat sy = -v[MAT_SY];
909 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
910 GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
911 GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
912
913 R300_FIREVERTICES(rmesa);
914 R300_STATECHANGE(rmesa, vpt);
915
916 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
917 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
918 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
919 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
920 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
921 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
922 }
923
924 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
925 GLsizei width, GLsizei height)
926 {
927 /* Don't pipeline viewport changes, conflict with window offset
928 * setting below. Could apply deltas to rescue pipelined viewport
929 * values, or keep the originals hanging around.
930 */
931 R300_FIREVERTICES(R300_CONTEXT(ctx));
932 r300UpdateWindow(ctx);
933 }
934
935 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
936 {
937 r300UpdateWindow(ctx);
938 }
939
940 /* =============================================================
941 * Polygon state
942 */
943 static void r300PolygonOffset(GLcontext * ctx, GLfloat factor, GLfloat units)
944 {
945 r300ContextPtr rmesa = R300_CONTEXT(ctx);
946 GLfloat constant = units * /*rmesa->state.depth.scale*/4;
947
948 factor *= 12;
949
950 /* fprintf(stderr, "%s f:%f u:%f\n", __FUNCTION__, factor, constant); */
951
952 R300_STATECHANGE(rmesa, zbs);
953 rmesa->hw.zbs.cmd[R300_ZBS_T_FACTOR] = r300PackFloat32(factor);
954 rmesa->hw.zbs.cmd[R300_ZBS_T_CONSTANT] = r300PackFloat32(constant);
955 rmesa->hw.zbs.cmd[R300_ZBS_W_FACTOR] = r300PackFloat32(factor);
956 rmesa->hw.zbs.cmd[R300_ZBS_W_CONSTANT] = r300PackFloat32(constant);
957 }
958
959 /* Routing and texture-related */
960
961 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
962 {
963 int i, count=0,reg=0;
964 GLuint dw, mask;
965 TNLcontext *tnl = TNL_CONTEXT(ctx);
966 struct vertex_buffer *VB = &tnl->vb;
967 r300ContextPtr r300 = R300_CONTEXT(ctx);
968
969
970 /* Stage 1 - input to VAP */
971
972 /* Assign register number automatically, retaining it in rmesa->state.reg */
973
974 /* Note: immediate vertex data includes all coordinates.
975 To save bandwidth use either VBUF or state-based vertex generation */
976
977 #define CONFIGURE_AOS(v, o, r, f) \
978 {\
979 if (RADEON_DEBUG & DEBUG_STATE)fprintf(stderr, "Enabling "#r "\n"); \
980 if(immediate){ \
981 r300->state.aos[count].element_size=4; \
982 r300->state.aos[count].stride=4; \
983 r300->state.aos[count].ncomponents=4; \
984 } else { \
985 r300->state.aos[count].element_size=v->size; \
986 r300->state.aos[count].stride=v->size; \
987 r300->state.aos[count].ncomponents=v->size; \
988 } \
989 r300->state.aos[count].offset=o; \
990 r300->state.aos[count].reg=reg; \
991 r300->state.aos[count].format=(f); \
992 r300->state.vap_reg.r=reg; \
993 count++; \
994 reg++; \
995 }
996
997 /* All offsets are 0 - for use by immediate mode.
998 Should change later to handle vertex buffers */
999 if(r300->current_vp!=NULL){
1000
1001 /* VERT_ATTRIB_WEIGHT, VERT_ATTRIB_SIX, VERT_ATTRIB_SEVEN, VERT_ATTRIB_GENERIC0,
1002 VERT_ATTRIB_GENERIC1, VERT_ATTRIB_GENERIC2, VERT_ATTRIB_GENERIC3 */
1003 r300->state.render_inputs = 0;
1004
1005 if(r300->current_vp->inputs[VERT_ATTRIB_POS] != -1){
1006 reg=r300->current_vp->inputs[VERT_ATTRIB_POS];
1007 CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
1008 r300->state.render_inputs |= _TNL_BIT_POS;
1009 }
1010 if(r300->current_vp->inputs[VERT_ATTRIB_NORMAL] != -1){
1011 reg=r300->current_vp->inputs[VERT_ATTRIB_NORMAL];
1012 CONFIGURE_AOS(VB->NormalPtr, 0, i_normal, AOS_FORMAT_FLOAT);
1013 r300->state.render_inputs |= _TNL_BIT_NORMAL;
1014 }
1015 if(r300->current_vp->inputs[VERT_ATTRIB_COLOR0] != -1){
1016 reg=r300->current_vp->inputs[VERT_ATTRIB_COLOR0];
1017 CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
1018 r300->state.render_inputs |= _TNL_BIT_COLOR0;
1019 }
1020 if(r300->current_vp->inputs[VERT_ATTRIB_COLOR1] != -1){
1021 reg=r300->current_vp->inputs[VERT_ATTRIB_COLOR1];
1022 CONFIGURE_AOS(VB->SecondaryColorPtr[0], 0, i_color[1], AOS_FORMAT_FLOAT_COLOR);
1023 r300->state.render_inputs |= _TNL_BIT_COLOR1;
1024 }
1025 if(r300->current_vp->inputs[VERT_ATTRIB_FOG] != -1){
1026 reg=r300->current_vp->inputs[VERT_ATTRIB_FOG];
1027 CONFIGURE_AOS(VB->FogCoordPtr, 0, i_fog, AOS_FORMAT_FLOAT);
1028 r300->state.render_inputs |= _TNL_BIT_FOG;
1029 }
1030 for(i=0;i < ctx->Const.MaxTextureUnits;i++) // tex 7 is last
1031 if(r300->current_vp->inputs[VERT_ATTRIB_TEX0+i] != -1){
1032 reg=r300->current_vp->inputs[VERT_ATTRIB_TEX0+i];
1033 CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
1034 r300->state.render_inputs |= _TNL_BIT_TEX0<<i;
1035 }
1036 #if 0
1037 if((tnl->render_inputs & _TNL_BIT_INDEX))
1038 CONFIGURE_AOS(VB->IndexPtr[0], 0, i_index, AOS_FORMAT_FLOAT);
1039
1040 if((tnl->render_inputs & _TNL_BIT_POINTSIZE))
1041 CONFIGURE_AOS(VB->PointSizePtr, 0, i_pointsize, AOS_FORMAT_FLOAT);
1042 #endif
1043 }else{
1044
1045 r300->state.render_inputs = tnl->render_inputs;
1046
1047 if(tnl->render_inputs & _TNL_BIT_POS)
1048 CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
1049 if(tnl->render_inputs & _TNL_BIT_NORMAL)
1050 CONFIGURE_AOS(VB->NormalPtr, 0, i_normal, AOS_FORMAT_FLOAT);
1051
1052 if(tnl->render_inputs & _TNL_BIT_COLOR0)
1053 CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
1054 if(tnl->render_inputs & _TNL_BIT_COLOR1)
1055 CONFIGURE_AOS(VB->SecondaryColorPtr[0], 0, i_color[1], AOS_FORMAT_FLOAT_COLOR);
1056
1057 /*if(tnl->render_inputs & _TNL_BIT_FOG) // Causes lock ups when immediate mode is on
1058 CONFIGURE_AOS(VB->FogCoordPtr, 0, i_fog, AOS_FORMAT_FLOAT);*/
1059
1060 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
1061 if(tnl->render_inputs & (_TNL_BIT_TEX0<<i))
1062 CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
1063
1064 if(tnl->render_inputs & _TNL_BIT_INDEX)
1065 CONFIGURE_AOS(VB->IndexPtr[0], 0, i_index, AOS_FORMAT_FLOAT);
1066 if(tnl->render_inputs & _TNL_BIT_POINTSIZE)
1067 CONFIGURE_AOS(VB->PointSizePtr, 0, i_pointsize, AOS_FORMAT_FLOAT);
1068 }
1069
1070 r300->state.aos_count=count;
1071
1072 if (RADEON_DEBUG & DEBUG_STATE)
1073 fprintf(stderr, "aos_count=%d render_inputs=%08x\n", count, r300->state.render_inputs);
1074
1075
1076 if(count>R300_MAX_AOS_ARRAYS){
1077 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
1078 exit(-1);
1079 }
1080
1081 /* Implement AOS */
1082
1083 /* setup INPUT_ROUTE */
1084 R300_STATECHANGE(r300, vir[0]);
1085 for(i=0;i+1<count;i+=2){
1086 dw=(r300->state.aos[i].ncomponents-1)
1087 | ((r300->state.aos[i].reg)<<8)
1088 | (r300->state.aos[i].format<<14)
1089 | (((r300->state.aos[i+1].ncomponents-1)
1090 | ((r300->state.aos[i+1].reg)<<8)
1091 | (r300->state.aos[i+1].format<<14))<<16);
1092
1093 if(i+2==count){
1094 dw|=(1<<(13+16));
1095 }
1096 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
1097 }
1098 if(count & 1){
1099 dw=(r300->state.aos[count-1].ncomponents-1)
1100 | (r300->state.aos[count-1].format<<14)
1101 | ((r300->state.aos[count-1].reg)<<8)
1102 | (1<<13);
1103 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
1104 //fprintf(stderr, "vir0 dw=%08x\n", dw);
1105 }
1106 /* Set the rest of INPUT_ROUTE_0 to 0 */
1107 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
1108 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
1109
1110
1111 /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
1112 #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
1113 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
1114 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
1115 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
1116
1117 #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
1118 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
1119 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
1120 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
1121
1122 R300_STATECHANGE(r300, vir[1]);
1123
1124 for(i=0;i+1<count;i+=2){
1125 /* do i first.. */
1126 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
1127 dw=(ALL_COMPONENTS & mask)
1128 | (ALL_DEFAULT & ~mask)
1129 | R300_INPUT_ROUTE_ENABLE;
1130
1131 /* i+1 */
1132 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
1133 dw|=(
1134 (ALL_COMPONENTS & mask)
1135 | (ALL_DEFAULT & ~mask)
1136 | R300_INPUT_ROUTE_ENABLE
1137 )<<16;
1138
1139 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
1140 }
1141 if(count & 1){
1142 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
1143 dw=(ALL_COMPONENTS & mask)
1144 | (ALL_DEFAULT & ~mask)
1145 | R300_INPUT_ROUTE_ENABLE;
1146 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
1147 //fprintf(stderr, "vir1 dw=%08x\n", dw);
1148 }
1149 /* Set the rest of INPUT_ROUTE_1 to 0 */
1150 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
1151 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
1152
1153 /* Set up input_cntl */
1154
1155 R300_STATECHANGE(r300, vic);
1156 r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555; /* Hard coded value, no idea what it means */
1157
1158 r300->hw.vic.cmd[R300_VIC_CNTL_1]=0;
1159
1160 if(r300->state.render_inputs & _TNL_BIT_POS)
1161 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_POS;
1162
1163 if(r300->state.render_inputs & _TNL_BIT_NORMAL)
1164 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_NORMAL;
1165
1166 if(r300->state.render_inputs & _TNL_BIT_COLOR0)
1167 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_COLOR;
1168
1169 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
1170 if(r300->state.render_inputs & (_TNL_BIT_TEX0<<i))
1171 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
1172
1173 /* Stage 3: VAP output */
1174 R300_STATECHANGE(r300, vof);
1175 r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1176 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1177
1178 r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
1179 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
1180 if(r300->state.render_inputs & (_TNL_BIT_TEX0<<i))
1181 r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
1182
1183 }
1184
1185 static r300TexObj default_tex_obj={
1186 filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
1187 pitch: 0x8000,
1188 size: (0xff << R300_TX_WIDTHMASK_SHIFT)
1189 | (0xff << R300_TX_HEIGHTMASK_SHIFT)
1190 | (0x8 << R300_TX_SIZE_SHIFT),
1191 format: 0x88a0c,
1192 offset: 0x0,
1193 unknown4: 0x0,
1194 unknown5: 0x0
1195 };
1196
1197 /* there is probably a system to these value, but, for now,
1198 we just try by hand */
1199
1200 static int inline translate_src(int src)
1201 {
1202 switch (src) {
1203 case GL_TEXTURE:
1204 return 1;
1205 break;
1206 case GL_CONSTANT:
1207 return 2;
1208 break;
1209 case GL_PRIMARY_COLOR:
1210 return 3;
1211 break;
1212 case GL_PREVIOUS:
1213 return 4;
1214 break;
1215 case GL_ZERO:
1216 return 5;
1217 break;
1218 case GL_ONE:
1219 return 6;
1220 break;
1221 default:
1222 return 0;
1223 }
1224 }
1225
1226 /* r300 doesnt handle GL_CLAMP and GL_MIRROR_CLAMP_EXT correctly when filter is NEAREST.
1227 * Since texwrap produces same results for GL_CLAMP and GL_CLAMP_TO_EDGE we use them instead.
1228 * We need to recalculate wrap modes whenever filter mode is changed because someone might do:
1229 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1230 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1231 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1232 * Since r300 completely ignores R300_TX_CLAMP when either min or mag is nearest it cant handle
1233 * combinations where only one of them is nearest.
1234 */
1235 static unsigned long gen_fixed_filter(unsigned long f)
1236 {
1237 unsigned long mag, min, needs_fixing=0;
1238 //return f;
1239
1240 /* We ignore MIRROR bit so we dont have to do everything twice */
1241 if((f & ((7-1) << R300_TX_WRAP_S_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_S_SHIFT)){
1242 needs_fixing |= 1;
1243 }
1244 if((f & ((7-1) << R300_TX_WRAP_T_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_T_SHIFT)){
1245 needs_fixing |= 2;
1246 }
1247 if((f & ((7-1) << R300_TX_WRAP_Q_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_Q_SHIFT)){
1248 needs_fixing |= 4;
1249 }
1250
1251 if(!needs_fixing)
1252 return f;
1253
1254 mag=f & R300_TX_MAG_FILTER_MASK;
1255 min=f & R300_TX_MIN_FILTER_MASK;
1256
1257 /* TODO: Check for anisto filters too */
1258 if((mag != R300_TX_MAG_FILTER_NEAREST) && (min != R300_TX_MIN_FILTER_NEAREST))
1259 return f;
1260
1261 /* r300 cant handle these modes hence we force nearest to linear */
1262 if((mag == R300_TX_MAG_FILTER_NEAREST) && (min != R300_TX_MIN_FILTER_NEAREST)){
1263 f &= ~R300_TX_MAG_FILTER_NEAREST;
1264 f |= R300_TX_MAG_FILTER_LINEAR;
1265 return f;
1266 }
1267
1268 if((min == R300_TX_MIN_FILTER_NEAREST) && (mag != R300_TX_MAG_FILTER_NEAREST)){
1269 f &= ~R300_TX_MIN_FILTER_NEAREST;
1270 f |= R300_TX_MIN_FILTER_LINEAR;
1271 return f;
1272 }
1273
1274 /* Both are nearest */
1275 if(needs_fixing & 1){
1276 f &= ~((7-1) << R300_TX_WRAP_S_SHIFT);
1277 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_S_SHIFT;
1278 }
1279 if(needs_fixing & 2){
1280 f &= ~((7-1) << R300_TX_WRAP_T_SHIFT);
1281 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_T_SHIFT;
1282 }
1283 if(needs_fixing & 4){
1284 f &= ~((7-1) << R300_TX_WRAP_Q_SHIFT);
1285 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_Q_SHIFT;
1286 }
1287 return f;
1288 }
1289
1290 void r300_setup_textures(GLcontext *ctx)
1291 {
1292 int i, mtu;
1293 struct r300_tex_obj *t;
1294 r300ContextPtr r300 = R300_CONTEXT(ctx);
1295 int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
1296 struct gl_texture_unit *texUnit;
1297
1298 R300_STATECHANGE(r300, txe);
1299 R300_STATECHANGE(r300, tex.filter);
1300 R300_STATECHANGE(r300, tex.unknown1);
1301 R300_STATECHANGE(r300, tex.size);
1302 R300_STATECHANGE(r300, tex.format);
1303 R300_STATECHANGE(r300, tex.offset);
1304 R300_STATECHANGE(r300, tex.unknown4);
1305 R300_STATECHANGE(r300, tex.border_color);
1306
1307 r300->state.texture.tc_count=0;
1308
1309 r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
1310
1311 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1312 if (RADEON_DEBUG & DEBUG_STATE)
1313 fprintf(stderr, "mtu=%d\n", mtu);
1314
1315 if(mtu>R300_MAX_TEXTURE_UNITS){
1316 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1317 mtu, R300_MAX_TEXTURE_UNITS);
1318 exit(-1);
1319 }
1320 for(i=0;i<mtu;i++){
1321 if( ((r300->state.render_inputs & (_TNL_BIT_TEX0<<i))!=0) != ((ctx->Texture.Unit[i].Enabled)!=0) ) {
1322 WARN_ONCE("Mismatch between render_inputs and ctx->Texture.Unit[i].Enabled value.\n");
1323 }
1324 if(r300->state.render_inputs & (_TNL_BIT_TEX0<<i)){
1325 t=r300->state.texture.unit[i].texobj;
1326 //fprintf(stderr, "format=%08x\n", r300->state.texture.unit[i].format);
1327 r300->state.texture.tc_count++;
1328 if(t==NULL){
1329 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1330 //exit(-1);
1331 t=&default_tex_obj;
1332 }
1333 //fprintf(stderr, "t->format=%08x\n", t->format);
1334 if((t->format & 0xffffff00)==0xffffff00){
1335 WARN_ONCE("unknown texture format (entry %x) encountered. Help me !\n", t->format & 0xff);
1336 //fprintf(stderr, "t->format=%08x\n", t->format);
1337 }
1338 if (RADEON_DEBUG & DEBUG_STATE)
1339 fprintf(stderr, "Activating texture unit %d\n", i);
1340 max_texture_unit=i;
1341 r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1342
1343 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=gen_fixed_filter(t->filter);
1344 /* No idea why linear filtered textures shake when puting random data */
1345 /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1346 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1347 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1348 //fprintf(stderr, "t->format=%08x\n", t->format);
1349 r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
1350 r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1351 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0+i]=t->pp_border_color;
1352 }
1353 }
1354 ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1355 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1356 ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1357 ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1358 ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1359 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1360 ((drm_r300_cmd_header_t*)r300->hw.tex.border_color.cmd)->unchecked_state.count = max_texture_unit+1;
1361
1362 if (RADEON_DEBUG & DEBUG_STATE)
1363 fprintf(stderr, "TX_ENABLE: %08x max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1364 }
1365
1366 void r300_setup_rs_unit(GLcontext *ctx)
1367 {
1368 r300ContextPtr r300 = R300_CONTEXT(ctx);
1369 int i;
1370
1371 /* This needs to be rewritten - it is a hack at best */
1372
1373 R300_STATECHANGE(r300, ri);
1374 R300_STATECHANGE(r300, rc);
1375 R300_STATECHANGE(r300, rr);
1376
1377 for(i = 1; i <= 8; ++i)
1378 r300->hw.ri.cmd[i] = 0x00d10000;
1379 r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1380 r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1381 r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1382
1383 #if 1
1384 for(i = 2; i <= 8; ++i)
1385 r300->hw.ri.cmd[i] |= 4;
1386 #endif
1387
1388 for(i = 1; i <= 8; ++i)
1389 r300->hw.rr.cmd[i] = 0;
1390 /* textures enabled ? */
1391 if(r300->state.texture.tc_count>0){
1392
1393 /* This code only really works with one set of texture coordinates */
1394
1395 /* The second constant is needed to get glxgears display anything .. */
1396 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1397 | R300_RS_CNTL_0_UNKNOWN_18
1398 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1399 r300->hw.rc.cmd[2] = 0xc0;
1400
1401
1402 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1403 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1404
1405 } else {
1406
1407 /* The second constant is needed to get glxgears display anything .. */
1408 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1409 r300->hw.rc.cmd[2] = 0;
1410
1411 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1412 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1413
1414 }
1415 }
1416
1417 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1418
1419 #define bump_vpu_count(ptr, new_count) do{\
1420 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1421 int _nc=(new_count)/4; \
1422 if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1423 }while(0)
1424
1425 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1426 {
1427 int i;
1428
1429 if(vsf->length==0)return;
1430
1431 if(vsf->length & 0x3){
1432 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1433 exit(-1);
1434 }
1435
1436 switch((dest>>8) & 0xf){
1437 case 0:
1438 R300_STATECHANGE(r300, vpi);
1439 for(i=0;i<vsf->length;i++)
1440 r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1441 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1442 break;
1443
1444 case 2:
1445 R300_STATECHANGE(r300, vpp);
1446 for(i=0;i<vsf->length;i++)
1447 r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1448 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1449 break;
1450 case 4:
1451 R300_STATECHANGE(r300, vps);
1452 for(i=0;i<vsf->length;i++)
1453 r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1454 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1455 break;
1456 default:
1457 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1458 exit(-1);
1459 }
1460 }
1461
1462 void r300SetupVertexProgram(r300ContextPtr rmesa);
1463
1464 void r300SetupVertexShader(r300ContextPtr rmesa)
1465 {
1466 GLcontext* ctx = rmesa->radeon.glCtx;
1467
1468 if(rmesa->current_vp != NULL){
1469 r300SetupVertexProgram(rmesa);
1470 return ;
1471 }
1472
1473 /* Reset state, in case we don't use something */
1474 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1475 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1476 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1477
1478
1479 /* This needs to be replaced by vertex shader generation code */
1480
1481
1482 /* textures enabled ? */
1483 if(rmesa->state.texture.tc_count>0){
1484 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1485 } else {
1486 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1487 }
1488
1489
1490 rmesa->state.vertex_shader.matrix[0].length=16;
1491 memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1492
1493 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1494
1495 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1496 #if 0
1497 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1498 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1499
1500 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1501 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1502 #endif
1503
1504 #if 0
1505 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1506 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1507 #endif
1508
1509 R300_STATECHANGE(rmesa, pvs);
1510 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1511 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1512 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1513 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1514 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1515 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1516 | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1517
1518 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1519 so I leave it as a reminder */
1520 #if 0
1521 reg_start(R300_VAP_PVS_WAITIDLE,0);
1522 e32(0x00000000);
1523 #endif
1524 }
1525
1526 void r300SetupVertexProgram(r300ContextPtr rmesa)
1527 {
1528 GLcontext* ctx = rmesa->radeon.glCtx;
1529 int inst_count;
1530 int param_count;
1531
1532 /* Reset state, in case we don't use something */
1533 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1534 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1535 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1536
1537 r300VertexProgUpdateParams(ctx, rmesa->current_vp);
1538
1539 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->current_vp->program));
1540
1541 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->current_vp->params));
1542
1543 #if 0
1544 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1545 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1546 #endif
1547
1548 inst_count=rmesa->current_vp->program.length/4 - 1;
1549 param_count=rmesa->current_vp->params.length/4;
1550
1551 R300_STATECHANGE(rmesa, pvs);
1552 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(0 << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1553 | (inst_count/*0*/ << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1554 | (inst_count << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1555 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(0 << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1556 | (param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1557 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(0/*rmesa->state.vertex_shader.unknown_ptr2*/ << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1558 | ((inst_count-rmesa->current_vp->t2rs) /*rmesa->state.vertex_shader.unknown_ptr3*/ << 0);
1559
1560 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1561 so I leave it as a reminder */
1562 #if 0
1563 reg_start(R300_VAP_PVS_WAITIDLE,0);
1564 e32(0x00000000);
1565 #endif
1566 }
1567
1568
1569 /* just a skeleton for now.. */
1570 void r300GenerateTexturePixelShader(r300ContextPtr r300)
1571 {
1572 int i, mtu;
1573 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1574 GLenum envMode;
1575
1576 int tex_inst=0, alu_inst=0;
1577
1578 for(i=0;i<mtu;i++){
1579 /* No need to proliferate {} */
1580 if(! (r300->state.render_inputs & (_TNL_BIT_TEX0<<i)))continue;
1581
1582 envMode = r300->radeon.glCtx->Texture.Unit[i].EnvMode;
1583 //fprintf(stderr, "envMode=%s\n", _mesa_lookup_enum_by_nr(envMode));
1584
1585 /* Fetch textured pixel */
1586
1587 r300->state.pixel_shader.program.tex.inst[tex_inst]=0x00018000;
1588 tex_inst++;
1589
1590 switch(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->ModeRGB){
1591 case GL_REPLACE:
1592 WARN_ONCE("ModeA==GL_REPLACE is possibly broken.\n");
1593 r300->state.pixel_shader.program.alu.inst[alu_inst].inst0=
1594 EASY_PFS_INSTR0(MAD, SRC0C_XYZ, ONE, ZERO);
1595
1596 r300->state.pixel_shader.program.alu.inst[alu_inst].inst1=
1597 EASY_PFS_INSTR1(0, 0, 0 | PFS_FLAG_CONST, 0 | PFS_FLAG_CONST, NONE, ALL);
1598 break;
1599 case GL_MODULATE:
1600 WARN_ONCE("ModeRGB==GL_MODULATE is possibly broken.\n");
1601 r300->state.pixel_shader.program.alu.inst[alu_inst].inst0=
1602 EASY_PFS_INSTR0(MAD, SRC0C_XYZ, SRC1C_XYZ, ZERO);
1603
1604 r300->state.pixel_shader.program.alu.inst[alu_inst].inst1=
1605 EASY_PFS_INSTR1(0, 0, 1, 0 | PFS_FLAG_CONST, NONE, ALL);
1606
1607 break;
1608 default:
1609 fprintf(stderr, "ModeRGB=%s is not implemented yet !\n",
1610 _mesa_lookup_enum_by_nr(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->ModeRGB));
1611 /* PFS_NOP */
1612 r300->state.pixel_shader.program.alu.inst[alu_inst].inst0=
1613 EASY_PFS_INSTR0(MAD, SRC0C_XYZ, ONE, ZERO);
1614
1615 r300->state.pixel_shader.program.alu.inst[alu_inst].inst1=
1616 EASY_PFS_INSTR1(0, 0, 0 | PFS_FLAG_CONST, 0 | PFS_FLAG_CONST, NONE, ALL);
1617 }
1618 switch(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->ModeA){
1619 case GL_REPLACE:
1620 WARN_ONCE("ModeA==GL_REPLACE is possibly broken.\n");
1621 r300->state.pixel_shader.program.alu.inst[alu_inst].inst2=
1622 EASY_PFS_INSTR2(MAD, SRC0A, ONE, ZERO);
1623
1624 r300->state.pixel_shader.program.alu.inst[alu_inst].inst3=
1625 EASY_PFS_INSTR3(0, 0, 0| PFS_FLAG_CONST, 0 | PFS_FLAG_CONST, OUTPUT);
1626
1627 #if 0
1628 fprintf(stderr, "numArgsA=%d sourceA[0]=%s op=%d\n",
1629 r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->_NumArgsA,
1630 _mesa_lookup_enum_by_nr(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->SourceA[0]),
1631 r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->OperandA[0]-GL_SRC_ALPHA);
1632 #endif
1633 break;
1634 case GL_MODULATE:
1635 WARN_ONCE("ModeA==GL_MODULATE is possibly broken.\n");
1636
1637 r300->state.pixel_shader.program.alu.inst[alu_inst].inst2=
1638 EASY_PFS_INSTR2(MAD, SRC0A, SRC1A, ZERO);
1639
1640 r300->state.pixel_shader.program.alu.inst[alu_inst].inst3=
1641 EASY_PFS_INSTR3(0, 0, 1, 0 | PFS_FLAG_CONST, OUTPUT);
1642
1643 break;
1644 default:
1645 fprintf(stderr, "ModeA=%s is not implemented yet !\n",
1646 _mesa_lookup_enum_by_nr(r300->radeon.glCtx->Texture.Unit[i]._CurrentCombine->ModeA));
1647 /* PFS_NOP */
1648 r300->state.pixel_shader.program.alu.inst[alu_inst].inst2=
1649 EASY_PFS_INSTR2(MAD, SRC0A, ONE, ZERO);
1650
1651 r300->state.pixel_shader.program.alu.inst[alu_inst].inst3=
1652 EASY_PFS_INSTR3(0, 0, 0 | PFS_FLAG_CONST, 0 | PFS_FLAG_CONST, OUTPUT);
1653
1654 }
1655
1656 alu_inst++;
1657 }
1658
1659 r300->state.pixel_shader.program.tex.length=tex_inst;
1660 r300->state.pixel_shader.program.tex_offset=0;
1661 r300->state.pixel_shader.program.tex_end=tex_inst-1;
1662
1663 #if 0
1664 /* saturate last instruction, like i915 driver does */
1665 r300->state.pixel_shader.program.alu.inst[alu_inst-1].inst0|=R300_FPI0_OUTC_SAT;
1666 r300->state.pixel_shader.program.alu.inst[alu_inst-1].inst2|=R300_FPI2_OUTA_SAT;
1667 #endif
1668
1669 r300->state.pixel_shader.program.alu.length=alu_inst;
1670 r300->state.pixel_shader.program.alu_offset=0;
1671 r300->state.pixel_shader.program.alu_end=alu_inst-1;
1672 }
1673
1674 void r300SetupPixelShader(r300ContextPtr rmesa)
1675 {
1676 int i,k;
1677
1678 /* This needs to be replaced by pixel shader generation code */
1679
1680 /* textures enabled ? */
1681 if(rmesa->state.texture.tc_count>0){
1682 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1683 r300GenerateTexturePixelShader(rmesa);
1684 } else {
1685 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1686 }
1687
1688 R300_STATECHANGE(rmesa, fpt);
1689 for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1690 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1691 rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1692
1693 #define OUTPUT_FIELD(st, reg, field) \
1694 R300_STATECHANGE(rmesa, st); \
1695 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1696 rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1697 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1698
1699 OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1700 OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1701 OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1702 OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1703 #undef OUTPUT_FIELD
1704
1705 R300_STATECHANGE(rmesa, fp);
1706 for(i=0;i<4;i++){
1707 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1708 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1709 | (rmesa->state.pixel_shader.program.node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
1710 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1711 | (rmesa->state.pixel_shader.program.node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
1712 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1713 }
1714
1715 /* PFS_CNTL_0 */
1716 rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1717 (rmesa->state.pixel_shader.program.active_nodes-1)
1718 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1719 /* PFS_CNTL_1 */
1720 rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1721 /* PFS_CNTL_2 */
1722 rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1723 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1724 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1725 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1726 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1727
1728 R300_STATECHANGE(rmesa, fpp);
1729 for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1730 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1731 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1732 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1733 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1734 }
1735 rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1736
1737 }
1738
1739 /**
1740 * Called by Mesa after an internal state update.
1741 */
1742 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1743 {
1744 r300ContextPtr r300 = R300_CONTEXT(ctx);
1745
1746 _swrast_InvalidateState(ctx, new_state);
1747 _swsetup_InvalidateState(ctx, new_state);
1748 _ac_InvalidateState(ctx, new_state);
1749 _tnl_InvalidateState(ctx, new_state);
1750 _ae_invalidate_state(ctx, new_state);
1751
1752 /* Go inefficiency! */
1753 r300ResetHwState(r300);
1754 }
1755
1756 void update_zbias(GLcontext * ctx, int prim);
1757
1758 /**
1759 * Completely recalculates hardware state based on the Mesa state.
1760 */
1761 void r300ResetHwState(r300ContextPtr r300)
1762 {
1763 GLcontext* ctx = r300->radeon.glCtx;
1764 int i;
1765
1766 if (RADEON_DEBUG & DEBUG_STATE)
1767 fprintf(stderr, "%s\n", __FUNCTION__);
1768
1769 /* This is a place to initialize registers which
1770 have bitfields accessed by different functions
1771 and not all bits are used */
1772 #if 0
1773 r300->hw.zs.cmd[R300_ZS_CNTL_0] = 0;
1774 r300->hw.zs.cmd[R300_ZS_CNTL_1] = 0;
1775 r300->hw.zs.cmd[R300_ZS_CNTL_2] = 0xffff00;
1776 #endif
1777
1778 /* go and compute register values from GL state */
1779
1780 r300UpdateWindow(ctx);
1781
1782 r300ColorMask(ctx,
1783 ctx->Color.ColorMask[RCOMP],
1784 ctx->Color.ColorMask[GCOMP],
1785 ctx->Color.ColorMask[BCOMP],
1786 ctx->Color.ColorMask[ACOMP]);
1787
1788 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1789 r300DepthMask(ctx, ctx->Depth.Mask);
1790 r300DepthFunc(ctx, ctx->Depth.Func);
1791
1792 r300UpdateCulling(ctx);
1793
1794 r300UpdateTextureState(ctx);
1795
1796 r300_setup_routing(ctx, GL_TRUE);
1797 r300_setup_textures(ctx);
1798 r300_setup_rs_unit(ctx);
1799
1800 r300SetupVertexShader(r300);
1801 r300SetupPixelShader(r300);
1802
1803 r300_set_blend_state(ctx);
1804 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1805
1806 /* Initialize magic registers
1807 TODO : learn what they really do, or get rid of
1808 those we don't have to touch */
1809 r300->hw.unk2080.cmd[1] = 0x0030045A;
1810
1811 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1812 | R300_VPORT_X_OFFSET_ENA
1813 | R300_VPORT_Y_SCALE_ENA
1814 | R300_VPORT_Y_OFFSET_ENA
1815 | R300_VPORT_Z_SCALE_ENA
1816 | R300_VPORT_Z_OFFSET_ENA
1817 | R300_VTX_W0_FMT;
1818 r300->hw.vte.cmd[2] = 0x00000008;
1819
1820 r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1821 r300->hw.unk2134.cmd[2] = 0x00000000;
1822 #ifdef MESA_BIG_ENDIAN
1823 r300->hw.unk2140.cmd[1] = 0x00000002;
1824 #else
1825 r300->hw.unk2140.cmd[1] = 0x00000000;
1826 #endif
1827
1828 #if 0 /* Done in setup routing */
1829 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1830 r300->hw.vir[0].cmd[1] = 0x21030003;
1831
1832 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1833 r300->hw.vir[1].cmd[1] = 0xF688F688;
1834
1835 r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1836 r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1837 #endif
1838
1839 r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1840
1841 r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1842
1843 r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1844 r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1845 r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1846 r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1847
1848 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1849 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1850 else
1851 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1852
1853 #if 0
1854 r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1855 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1856 r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1857
1858
1859 r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1860 r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1861 r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1862 #endif
1863
1864 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1865 | R300_GB_LINE_STUFF_ENABLE
1866 | R300_GB_TRIANGLE_STUFF_ENABLE;
1867
1868 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1869 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1870 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1871 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1872 | R300_GB_TILE_PIPE_COUNT_R300
1873 | R300_GB_TILE_SIZE_16;
1874 else
1875 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1876 | R300_GB_TILE_PIPE_COUNT_RV300
1877 | R300_GB_TILE_SIZE_16;
1878 r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1879 r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1880
1881 //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1882
1883 r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1884 r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1885 r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1886 r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1887
1888 r300->hw.unk4214.cmd[1] = 0x00050005;
1889
1890 r300PointSize(ctx, ctx->Point._Size);
1891 #if 0
1892 r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1893 (6 << R300_POINTSIZE_Y_SHIFT);
1894 #endif
1895
1896 r300->hw.unk4230.cmd[1] = 0x01800000;
1897 r300->hw.unk4230.cmd[2] = 0x00020006;
1898 r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1899
1900 r300LineWidth(ctx, ctx->Line._Width);
1901
1902 #ifdef EXP_C
1903 static int foobar=0;
1904 r300->hw.lsf.cmd[1] = foobar++; //0x3a088889;
1905 #endif
1906 r300->hw.unk4260.cmd[1] = 0;
1907 r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1908 r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1909
1910 r300->hw.unk4274.cmd[1] = 0x00000002;
1911 r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1912 r300->hw.unk4274.cmd[3] = 0x00000000;
1913 r300->hw.unk4274.cmd[4] = 0x00000000;
1914
1915 r300PolygonMode(ctx, GL_FRONT, ctx->Polygon.FrontMode);
1916 r300PolygonMode(ctx, GL_BACK, ctx->Polygon.BackMode);
1917 #if 0
1918 r300->hw.unk4288.cmd[1] = 0x00000000;
1919 #endif
1920 r300->hw.unk4288.cmd[2] = 0x00000001;
1921 r300->hw.unk4288.cmd[3] = 0x00000000;
1922 r300->hw.unk4288.cmd[4] = 0x00000000;
1923 r300->hw.unk4288.cmd[5] = 0x00000000;
1924
1925 r300->hw.unk42A0.cmd[1] = 0x00000000;
1926
1927 update_zbias(ctx, GL_TRIANGLES);/* FIXME */
1928 #if 0
1929 r300->hw.unk42B4.cmd[1] = 0x00000000;
1930 #endif
1931 r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1932 r300->hw.unk42C0.cmd[2] = 0x00000000;
1933
1934
1935 r300->hw.unk43A4.cmd[1] = 0x0000001C;
1936 r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1937
1938 r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1939
1940 #if 0
1941 r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1942 r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1943 r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1944 r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1945 r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1946 r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1947 r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1948 #endif
1949
1950 r300->hw.unk46A4.cmd[1] = 0x00001B01;
1951 r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1952 r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1953 r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1954 r300->hw.unk46A4.cmd[5] = 0x00000001;
1955
1956 #if 0
1957 for(i = 1; i <= 64; ++i) {
1958 /* create NOP instructions */
1959 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1960 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1961 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1962 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1963 }
1964 #endif
1965
1966 r300->hw.unk4BC0.cmd[1] = 0;
1967
1968 r300->hw.unk4BC8.cmd[1] = 0;
1969 r300->hw.unk4BC8.cmd[2] = 0;
1970 r300->hw.unk4BC8.cmd[3] = 0;
1971
1972 #if 0
1973 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1974 #endif
1975
1976 r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
1977 r300->hw.unk4BD8.cmd[1] = 0;
1978
1979 r300->hw.unk4E00.cmd[1] = 0;
1980
1981 #if 0
1982 r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1983 r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1984 #endif
1985
1986 r300->hw.unk4E10.cmd[1] = 0;
1987 r300->hw.unk4E10.cmd[2] = 0;
1988 r300->hw.unk4E10.cmd[3] = 0;
1989
1990 r300->hw.cb.cmd[R300_CB_OFFSET] =
1991 r300->radeon.radeonScreen->backOffset +
1992 r300->radeon.radeonScreen->fbLocation;
1993 r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1994 | R300_COLOR_UNKNOWN_22_23;
1995
1996 r300->hw.unk4E50.cmd[1] = 0;
1997 r300->hw.unk4E50.cmd[2] = 0;
1998 r300->hw.unk4E50.cmd[3] = 0;
1999 r300->hw.unk4E50.cmd[4] = 0;
2000 r300->hw.unk4E50.cmd[5] = 0;
2001 r300->hw.unk4E50.cmd[6] = 0;
2002 r300->hw.unk4E50.cmd[7] = 0;
2003 r300->hw.unk4E50.cmd[8] = 0;
2004 r300->hw.unk4E50.cmd[9] = 0;
2005
2006 r300->hw.unk4E88.cmd[1] = 0;
2007
2008 r300->hw.unk4EA0.cmd[1] = 0x00000000;
2009 r300->hw.unk4EA0.cmd[2] = 0xffffffff;
2010
2011 r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
2012 r300->hw.unk4F10.cmd[2] = 0x00000000;
2013 r300->hw.unk4F10.cmd[3] = 0x00000003;
2014 r300->hw.unk4F10.cmd[4] = 0x00000000;
2015
2016 /* experiment a bit */
2017 r300->hw.unk4F10.cmd[2] = 0x00000001; // depthbuffer format?
2018
2019 r300->hw.zb.cmd[R300_ZB_OFFSET] =
2020 r300->radeon.radeonScreen->depthOffset +
2021 r300->radeon.radeonScreen->fbLocation;
2022 r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
2023
2024 r300->hw.unk4F28.cmd[1] = 0;
2025
2026 r300->hw.unk4F30.cmd[1] = 0;
2027 r300->hw.unk4F30.cmd[2] = 0;
2028
2029 r300->hw.unk4F44.cmd[1] = 0;
2030
2031 r300->hw.unk4F54.cmd[1] = 0;
2032
2033 #if 0
2034 ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
2035 for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
2036 /* MOV t0, t0 */
2037 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
2038 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
2039 r300->hw.vpi.cmd[i+2] = VP_ZERO();
2040 r300->hw.vpi.cmd[i+3] = VP_ZERO();
2041 }
2042
2043 ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
2044 for(i = 1; i < R300_VPP_CMDSIZE; ++i)
2045 r300->hw.vpp.cmd[i] = 0;
2046 #endif
2047
2048 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
2049 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
2050 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
2051 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
2052
2053 //END: TODO
2054
2055 r300->hw.all_dirty = GL_TRUE;
2056 }
2057
2058
2059
2060 /**
2061 * Calculate initial hardware state and register state functions.
2062 * Assumes that the command buffer and state atoms have been
2063 * initialized already.
2064 */
2065 void r300InitState(r300ContextPtr r300)
2066 {
2067 GLcontext *ctx = r300->radeon.glCtx;
2068 GLuint depth_fmt;
2069
2070 radeonInitState(&r300->radeon);
2071
2072 switch (ctx->Visual.depthBits) {
2073 case 16:
2074 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
2075 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
2076 //r300->state.stencil.clear = 0x00000000;
2077 break;
2078 case 24:
2079 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
2080 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
2081 //r300->state.stencil.clear = 0xff000000;
2082 break;
2083 default:
2084 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
2085 ctx->Visual.depthBits);
2086 exit(-1);
2087 }
2088
2089 /* Only have hw stencil when depth buffer is 24 bits deep */
2090 r300->state.hw_stencil = (ctx->Visual.stencilBits > 0 &&
2091 ctx->Visual.depthBits == 24);
2092
2093 memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
2094
2095 r300ResetHwState(r300);
2096 }
2097
2098
2099 /**
2100 * Initialize driver's state callback functions
2101 */
2102 void r300InitStateFuncs(struct dd_function_table* functions)
2103 {
2104 radeonInitStateFuncs(functions);
2105
2106 functions->UpdateState = r300InvalidateState;
2107 functions->AlphaFunc = r300AlphaFunc;
2108 functions->BlendColor = r300BlendColor;
2109 functions->BlendEquationSeparate = r300BlendEquationSeparate;
2110 functions->BlendFuncSeparate = r300BlendFuncSeparate;
2111 functions->Enable = r300Enable;
2112 functions->ColorMask = r300ColorMask;
2113 functions->DepthFunc = r300DepthFunc;
2114 functions->DepthMask = r300DepthMask;
2115 functions->CullFace = r300CullFace;
2116 functions->FrontFace = r300FrontFace;
2117
2118 /* Stencil related */
2119 functions->ClearStencil = r300ClearStencil;
2120 functions->StencilFunc = r300StencilFunc;
2121 functions->StencilMask = r300StencilMask;
2122 functions->StencilOp = r300StencilOp;
2123
2124 /* Viewport related */
2125 functions->Viewport = r300Viewport;
2126 functions->DepthRange = r300DepthRange;
2127 functions->PointSize = r300PointSize;
2128 functions->LineWidth = r300LineWidth;
2129
2130 functions->PolygonOffset = r300PolygonOffset;
2131 functions->PolygonMode = r300PolygonMode;
2132 }