projects / mesa.git / blob
? search:


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