projects / mesa.git / blob
? search:


9fb42108cb5165210a4c2c14706a137daf0ce691
[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
52 #include "radeon_ioctl.h"
53 #include "radeon_state.h"
54 #include "r300_context.h"
55 #include "r300_ioctl.h"
56 #include "r300_state.h"
57 #include "r300_reg.h"
58 #include "r300_program.h"
59 #include "r300_emit.h"
60 #include "r300_fixed_pipelines.h"
61
62 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
63 {
64 r300ContextPtr rmesa = R300_CONTEXT(ctx);
65 int pp_misc = rmesa->hw.at.cmd[R300_AT_ALPHA_TEST];
66 GLubyte refByte;
67
68 CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
69
70 R300_STATECHANGE(rmesa, at);
71
72 pp_misc &= ~(R300_ALPHA_TEST_OP_MASK | R300_REF_ALPHA_MASK);
73 pp_misc |= (refByte & R300_REF_ALPHA_MASK);
74
75 switch (func) {
76 case GL_NEVER:
77 pp_misc |= R300_ALPHA_TEST_FAIL;
78 break;
79 case GL_LESS:
80 pp_misc |= R300_ALPHA_TEST_LESS;
81 break;
82 case GL_EQUAL:
83 pp_misc |= R300_ALPHA_TEST_EQUAL;
84 break;
85 case GL_LEQUAL:
86 pp_misc |= R300_ALPHA_TEST_LEQUAL;
87 break;
88 case GL_GREATER:
89 pp_misc |= R300_ALPHA_TEST_GREATER;
90 break;
91 case GL_NOTEQUAL:
92 pp_misc |= R300_ALPHA_TEST_NEQUAL;
93 break;
94 case GL_GEQUAL:
95 pp_misc |= R300_ALPHA_TEST_GEQUAL;
96 break;
97 case GL_ALWAYS:
98 pp_misc |= R300_ALPHA_TEST_PASS;
99 break;
100 }
101
102 rmesa->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
103 }
104
105 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
106 {
107 GLubyte color[4];
108 r300ContextPtr rmesa = R300_CONTEXT(ctx);
109 fprintf(stderr, "%s:%s is not implemented yet. Fixme !\n", __FILE__, __FUNCTION__);
110 #if 0
111 R200_STATECHANGE(rmesa, ctx);
112 CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
113 CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
114 CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
115 CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
116 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor)
117 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCOLOR] =
118 radeonPackColor(4, color[0], color[1], color[2], color[3]);
119 #endif
120 }
121
122 /**
123 * Calculate the hardware blend factor setting. This same function is used
124 * for source and destination of both alpha and RGB.
125 *
126 * \returns
127 * The hardware register value for the specified blend factor. This value
128 * will need to be shifted into the correct position for either source or
129 * destination factor.
130 *
131 * \todo
132 * Since the two cases where source and destination are handled differently
133 * are essentially error cases, they should never happen. Determine if these
134 * cases can be removed.
135 */
136 static int blend_factor(GLenum factor, GLboolean is_src)
137 {
138 int func;
139
140 switch (factor) {
141 case GL_ZERO:
142 func = R200_BLEND_GL_ZERO;
143 break;
144 case GL_ONE:
145 func = R200_BLEND_GL_ONE;
146 break;
147 case GL_DST_COLOR:
148 func = R200_BLEND_GL_DST_COLOR;
149 break;
150 case GL_ONE_MINUS_DST_COLOR:
151 func = R200_BLEND_GL_ONE_MINUS_DST_COLOR;
152 break;
153 case GL_SRC_COLOR:
154 func = R200_BLEND_GL_SRC_COLOR;
155 break;
156 case GL_ONE_MINUS_SRC_COLOR:
157 func = R200_BLEND_GL_ONE_MINUS_SRC_COLOR;
158 break;
159 case GL_SRC_ALPHA:
160 func = R200_BLEND_GL_SRC_ALPHA;
161 break;
162 case GL_ONE_MINUS_SRC_ALPHA:
163 func = R200_BLEND_GL_ONE_MINUS_SRC_ALPHA;
164 break;
165 case GL_DST_ALPHA:
166 func = R200_BLEND_GL_DST_ALPHA;
167 break;
168 case GL_ONE_MINUS_DST_ALPHA:
169 func = R200_BLEND_GL_ONE_MINUS_DST_ALPHA;
170 break;
171 case GL_SRC_ALPHA_SATURATE:
172 func =
173 (is_src) ? R200_BLEND_GL_SRC_ALPHA_SATURATE :
174 R200_BLEND_GL_ZERO;
175 break;
176 case GL_CONSTANT_COLOR:
177 func = R200_BLEND_GL_CONST_COLOR;
178 break;
179 case GL_ONE_MINUS_CONSTANT_COLOR:
180 func = R200_BLEND_GL_ONE_MINUS_CONST_COLOR;
181 break;
182 case GL_CONSTANT_ALPHA:
183 func = R200_BLEND_GL_CONST_ALPHA;
184 break;
185 case GL_ONE_MINUS_CONSTANT_ALPHA:
186 func = R200_BLEND_GL_ONE_MINUS_CONST_ALPHA;
187 break;
188 default:
189 func = (is_src) ? R200_BLEND_GL_ONE : R200_BLEND_GL_ZERO;
190 }
191 return func;
192 }
193
194 /**
195 * Sets both the blend equation and the blend function.
196 * This is done in a single
197 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
198 * change the interpretation of the blend function.
199 * Also, make sure that blend function and blend equation are set to their default
200 * value if color blending is not enabled, since at least blend equations GL_MIN
201 * and GL_FUNC_REVERSE_SUBTRACT will cause wrong results otherwise for
202 * unknown reasons.
203 */
204 static void r300_set_blend_state(GLcontext * ctx)
205 {
206 r300ContextPtr rmesa = R300_CONTEXT(ctx);
207 #if 0
208 GLuint cntl = rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &
209 ~(R300_ROP_ENABLE | R300_ALPHA_BLEND_ENABLE |
210 R300_SEPARATE_ALPHA_ENABLE);
211 #endif
212
213 int func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
214 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
215 int eqn = R200_COMB_FCN_ADD_CLAMP;
216 int funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
217 (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
218 int eqnA = R200_COMB_FCN_ADD_CLAMP;
219
220 R300_STATECHANGE(rmesa, bld);
221
222 if (rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
223 if (ctx->Color._LogicOpEnabled) {
224 #if 0
225 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
226 cntl | R300_ROP_ENABLE;
227 #endif
228 rmesa->hw.bld.cmd[R300_BLD_ABLEND] = eqn | func;
229 rmesa->hw.bld.cmd[R300_BLD_CBLEND] = eqn | func;
230 return;
231 } else if (ctx->Color.BlendEnabled) {
232 #if 0
233 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
234 cntl | R300_ALPHA_BLEND_ENABLE |
235 R300_SEPARATE_ALPHA_ENABLE;
236 #endif
237 } else {
238 #if 0
239 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
240 #endif
241 rmesa->hw.bld.cmd[R300_BLD_ABLEND] = eqn | func;
242 rmesa->hw.bld.cmd[R300_BLD_CBLEND] = eqn | func;
243 return;
244 }
245 } else {
246 if (ctx->Color._LogicOpEnabled) {
247 #if 0
248 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
249 cntl | R300_ROP_ENABLE;
250 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
251 #endif
252 return;
253 } else if (ctx->Color.BlendEnabled) {
254 #if 0
255 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
256 cntl | R300_ALPHA_BLEND_ENABLE;
257 #endif
258 } else {
259 #if 0
260 rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
261 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
262 #endif
263 return;
264 }
265 }
266
267 func =
268 (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
269 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
270 GL_FALSE) <<
271 R200_DST_BLEND_SHIFT);
272
273 switch (ctx->Color.BlendEquationRGB) {
274 case GL_FUNC_ADD:
275 eqn = R300_COMB_FCN_ADD_CLAMP;
276 break;
277
278 case GL_FUNC_SUBTRACT:
279 eqn = R300_COMB_FCN_SUB_CLAMP;
280 break;
281
282 case GL_FUNC_REVERSE_SUBTRACT:
283 eqn = R200_COMB_FCN_RSUB_CLAMP;
284 break;
285
286 case GL_MIN:
287 eqn = R200_COMB_FCN_MIN;
288 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
289 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
290 break;
291
292 case GL_MAX:
293 eqn = R200_COMB_FCN_MAX;
294 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
295 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
296 break;
297
298 default:
299 fprintf(stderr,
300 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
301 __func__, __LINE__, ctx->Color.BlendEquationRGB);
302 return;
303 }
304
305 if (!rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
306 #if 0
307 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
308 #endif
309 return;
310 }
311
312 funcA =
313 (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
314 R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
315 GL_FALSE) <<
316 R200_DST_BLEND_SHIFT);
317
318 switch (ctx->Color.BlendEquationA) {
319 case GL_FUNC_ADD:
320 eqnA = R300_COMB_FCN_ADD_CLAMP;
321 break;
322
323 case GL_FUNC_SUBTRACT:
324 eqnA = R300_COMB_FCN_SUB_CLAMP;
325 break;
326
327 case GL_FUNC_REVERSE_SUBTRACT:
328 eqnA = R200_COMB_FCN_RSUB_CLAMP;
329 break;
330
331 case GL_MIN:
332 eqnA = R200_COMB_FCN_MIN;
333 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
334 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
335 break;
336
337 case GL_MAX:
338 eqnA = R200_COMB_FCN_MAX;
339 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
340 (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
341 break;
342
343 default:
344 fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n",
345 __func__, __LINE__, ctx->Color.BlendEquationA);
346 return;
347 }
348
349 rmesa->hw.bld.cmd[R300_BLD_ABLEND] = eqnA | funcA;
350 rmesa->hw.bld.cmd[R300_BLD_CBLEND] = eqn | func ;
351 if(rmesa->hw.bld.cmd[R300_BLD_ABLEND] == rmesa->hw.bld.cmd[R300_BLD_CBLEND]){
352 rmesa->hw.bld.cmd[R300_BLD_CBLEND] |= R300_BLEND_UNKNOWN | R300_BLEND_ENABLE | R300_BLEND_NO_SEPARATE;
353 } else {
354 rmesa->hw.bld.cmd[R300_BLD_CBLEND] |= R300_BLEND_UNKNOWN | R300_BLEND_ENABLE;
355 }
356
357 }
358
359 static void r300BlendEquationSeparate(GLcontext * ctx,
360 GLenum modeRGB, GLenum modeA)
361 {
362 r300_set_blend_state(ctx);
363 }
364
365 static void r300BlendFuncSeparate(GLcontext * ctx,
366 GLenum sfactorRGB, GLenum dfactorRGB,
367 GLenum sfactorA, GLenum dfactorA)
368 {
369 r300_set_blend_state(ctx);
370 }
371
372 /**
373 * Update our tracked culling state based on Mesa's state.
374 */
375 static void r300UpdateCulling(GLcontext* ctx)
376 {
377 r300ContextPtr r300 = R300_CONTEXT(ctx);
378 uint32_t val = 0;
379
380 R300_STATECHANGE(r300, cul);
381 if (ctx->Polygon.CullFlag) {
382 if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
383 val = R300_CULL_FRONT|R300_CULL_BACK;
384 else if (ctx->Polygon.CullFaceMode == GL_FRONT)
385 val = R300_CULL_FRONT;
386 else
387 val = R300_CULL_BACK;
388
389 if (ctx->Polygon.FrontFace == GL_CW)
390 val |= R300_FRONT_FACE_CW;
391 else
392 val |= R300_FRONT_FACE_CCW;
393 }
394
395 r300->hw.cul.cmd[R300_CUL_CULL] = val;
396 }
397
398
399 /**
400 * Handle glEnable()/glDisable().
401 *
402 * \note Mesa already filters redundant calls to glEnable/glDisable.
403 */
404 static void r300Enable(GLcontext* ctx, GLenum cap, GLboolean state)
405 {
406 r300ContextPtr r300 = R300_CONTEXT(ctx);
407 uint32_t newval;
408
409 if (RADEON_DEBUG & DEBUG_STATE)
410 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
411 _mesa_lookup_enum_by_nr(cap),
412 state ? "GL_TRUE" : "GL_FALSE");
413
414 switch (cap) {
415 case GL_DEPTH_TEST:
416 R300_STATECHANGE(r300, zc);
417
418 if (state) {
419 if (ctx->Depth.Mask)
420 newval = R300_RB3D_Z_TEST_AND_WRITE;
421 else
422 newval = R300_RB3D_Z_TEST;
423 } else
424 newval = 0;
425
426 r300->hw.zc.cmd[R300_ZC_CNTL_0] = newval;
427 break;
428
429 case GL_CULL_FACE:
430 r300UpdateCulling(ctx);
431 break;
432
433 default:
434 radeonEnable(ctx, cap, state);
435 return;
436 }
437 }
438
439
440 /**
441 * Change the culling mode.
442 *
443 * \note Mesa already filters redundant calls to this function.
444 */
445 static void r300CullFace(GLcontext* ctx, GLenum mode)
446 {
447 (void)mode;
448
449 r300UpdateCulling(ctx);
450 }
451
452
453 /**
454 * Change the polygon orientation.
455 *
456 * \note Mesa already filters redundant calls to this function.
457 */
458 static void r300FrontFace(GLcontext* ctx, GLenum mode)
459 {
460 (void)mode;
461
462 r300UpdateCulling(ctx);
463 }
464
465
466 /**
467 * Change the depth testing function.
468 *
469 * \note Mesa already filters redundant calls to this function.
470 */
471 static void r300DepthFunc(GLcontext* ctx, GLenum func)
472 {
473 r300ContextPtr r300 = R300_CONTEXT(ctx);
474
475 R300_STATECHANGE(r300, zc);
476
477 switch(func) {
478 case GL_NEVER:
479 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_NEVER;
480 break;
481 case GL_LESS:
482 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_LESS;
483 break;
484 case GL_EQUAL:
485 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_EQUAL;
486 break;
487 case GL_LEQUAL:
488 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_LEQUAL;
489 break;
490 case GL_GREATER:
491 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_GREATER;
492 break;
493 case GL_NOTEQUAL:
494 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_NEQUAL;
495 break;
496 case GL_GEQUAL:
497 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_GEQUAL;
498 break;
499 case GL_ALWAYS:
500 r300->hw.zc.cmd[R300_ZC_CNTL_1] = R300_Z_TEST_ALWAYS;
501 break;
502 }
503 }
504
505
506 /**
507 * Enable/Disable depth writing.
508 *
509 * \note Mesa already filters redundant calls to this function.
510 */
511 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
512 {
513 r300ContextPtr r300 = R300_CONTEXT(ctx);
514
515 if (!ctx->Depth.Test)
516 return;
517
518 R300_STATECHANGE(r300, zc);
519 r300->hw.zc.cmd[R300_ZC_CNTL_0] = mask
520 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
521 }
522
523
524 /**
525 * Handle glColorMask()
526 */
527 static void r300ColorMask(GLcontext* ctx,
528 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
529 {
530 r300ContextPtr r300 = R300_CONTEXT(ctx);
531 int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
532
533 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
534 R300_STATECHANGE(r300, cmk);
535 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
536 }
537 }
538
539 /* =============================================================
540 * Point state
541 */
542 static void r300PointSize(GLcontext * ctx, GLfloat size)
543 {
544 r300ContextPtr r300 = R300_CONTEXT(ctx);
545
546 /* This might need fixing later */
547 R300_STATECHANGE(r300, vps);
548 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
549 }
550
551 /* =============================================================
552 * Window position and viewport transformation
553 */
554
555 /*
556 * To correctly position primitives:
557 */
558 #define SUBPIXEL_X 0.125
559 #define SUBPIXEL_Y 0.125
560
561 void r300UpdateWindow(GLcontext * ctx)
562 {
563 r300ContextPtr rmesa = R300_CONTEXT(ctx);
564 __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
565 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
566 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
567 const GLfloat *v = ctx->Viewport._WindowMap.m;
568
569 GLfloat sx = v[MAT_SX];
570 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
571 GLfloat sy = -v[MAT_SY];
572 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
573 GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
574 GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
575
576 R300_FIREVERTICES(rmesa);
577 R300_STATECHANGE(rmesa, vpt);
578
579 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
580 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
581 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
582 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
583 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
584 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
585 }
586
587 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
588 GLsizei width, GLsizei height)
589 {
590 /* Don't pipeline viewport changes, conflict with window offset
591 * setting below. Could apply deltas to rescue pipelined viewport
592 * values, or keep the originals hanging around.
593 */
594 R200_FIREVERTICES(R200_CONTEXT(ctx));
595 r300UpdateWindow(ctx);
596 }
597
598 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
599 {
600 r300UpdateWindow(ctx);
601 }
602
603 /* Routing and texture-related */
604
605 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
606 {
607 int i, count=0,reg=0;
608 GLuint dw, mask;
609 TNLcontext *tnl = TNL_CONTEXT(ctx);
610 struct vertex_buffer *VB = &tnl->vb;
611 r300ContextPtr r300 = R300_CONTEXT(ctx);
612
613
614 /* Stage 1 - input to VAP */
615
616 /* Assign register number automatically, retaining it in rmesa->state.reg */
617
618 /* Note: immediate vertex data includes all coordinates.
619 To save bandwidth use either VBUF or state-based vertex generation */
620
621 #define CONFIGURE_AOS(v, o, r, f) \
622 {\
623 if(immediate){ \
624 r300->state.aos[count].element_size=4; \
625 r300->state.aos[count].stride=4; \
626 r300->state.aos[count].ncomponents=4; \
627 } else { \
628 r300->state.aos[count].element_size=v->size; \
629 r300->state.aos[count].stride=v->size; \
630 r300->state.aos[count].ncomponents=v->size; \
631 } \
632 r300->state.aos[count].offset=o; \
633 r300->state.aos[count].reg=reg; \
634 r300->state.aos[count].format=(f); \
635 r300->state.vap_reg.r=reg; \
636 count++; \
637 reg++; \
638 }
639
640 /* All offsets are 0 - for use by immediate mode.
641 Should change later to handle vertex buffers */
642 CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
643 CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
644 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
645 if(ctx->Texture.Unit[i].Enabled)
646 CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
647
648 r300->state.aos_count=count;
649
650 if (RADEON_DEBUG & DEBUG_STATE)
651 fprintf(stderr, "aos_count=%d\n", count);
652
653 if(count>R300_MAX_AOS_ARRAYS){
654 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
655 exit(-1);
656 }
657
658 /* Implement AOS */
659
660 /* setup INPUT_ROUTE */
661 R300_STATECHANGE(r300, vir[0]);
662 for(i=0;i+1<count;i+=2){
663 dw=(r300->state.aos[i].ncomponents-1)
664 | ((r300->state.aos[i].reg)<<8)
665 | (r300->state.aos[i].format<<14)
666 | (((r300->state.aos[i+1].ncomponents-1)
667 | ((r300->state.aos[i+1].reg)<<8)
668 | (r300->state.aos[i+1].format<<14))<<16);
669
670 if(i+2==count){
671 dw|=(1<<(13+16));
672 }
673 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
674 }
675 if(count & 1){
676 dw=(r300->state.aos[count-1].ncomponents-1)
677 | (r300->state.aos[count-1].format<<14)
678 | ((r300->state.aos[count-1].reg)<<8)
679 | (1<<13);
680 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
681 //fprintf(stderr, "vir0 dw=%08x\n", dw);
682 }
683 /* Set the rest of INPUT_ROUTE_0 to 0 */
684 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
685 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
686
687
688 /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
689 #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
690 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
691 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
692 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
693
694 #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
695 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
696 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
697 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
698
699 R300_STATECHANGE(r300, vir[1]);
700
701 for(i=0;i+1<count;i+=2){
702 /* do i first.. */
703 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
704 dw=(ALL_COMPONENTS & mask)
705 | (ALL_DEFAULT & ~mask)
706 | R300_INPUT_ROUTE_ENABLE;
707
708 /* i+1 */
709 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
710 dw|=(
711 (ALL_COMPONENTS & mask)
712 | (ALL_DEFAULT & ~mask)
713 | R300_INPUT_ROUTE_ENABLE
714 )<<16;
715
716 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
717 }
718 if(count & 1){
719 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
720 dw=(ALL_COMPONENTS & mask)
721 | (ALL_DEFAULT & ~mask)
722 | R300_INPUT_ROUTE_ENABLE;
723 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
724 //fprintf(stderr, "vir1 dw=%08x\n", dw);
725 }
726 /* Set the rest of INPUT_ROUTE_1 to 0 */
727 //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
728 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
729
730 /* Set up input_cntl */
731
732 R300_STATECHANGE(r300, vic);
733 r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555; /* Hard coded value, no idea what it means */
734
735 r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
736 | R300_INPUT_CNTL_COLOR;
737
738 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
739 if(ctx->Texture.Unit[i].Enabled)
740 r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
741
742 /* Stage 3: VAP output */
743 R300_STATECHANGE(r300, vof);
744 r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
745 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
746
747 r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
748 for(i=0;i < ctx->Const.MaxTextureUnits;i++)
749 if(ctx->Texture.Unit[i].Enabled)
750 r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
751
752 }
753
754 static r300TexObj default_tex_obj={
755 filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
756 pitch: 0x8000,
757 size: (0xff << R300_TX_WIDTHMASK_SHIFT)
758 | (0xff << R300_TX_HEIGHTMASK_SHIFT)
759 | (0x8 << R300_TX_SIZE_SHIFT),
760 format: 0x88a0c,
761 offset: 0x0,
762 unknown4: 0x0,
763 unknown5: 0x0
764 };
765
766 /* there is probably a system to these value, but, for now,
767 we just try by hand */
768
769 static int inline translate_src(int src)
770 {
771 switch (src) {
772 case GL_TEXTURE:
773 return 1;
774 break;
775 case GL_CONSTANT:
776 return 2;
777 break;
778 case GL_PRIMARY_COLOR:
779 return 3;
780 break;
781 case GL_PREVIOUS:
782 return 4;
783 break;
784 case GL_ZERO:
785 return 5;
786 break;
787 case GL_ONE:
788 return 6;
789 break;
790 default:
791 return 0;
792 }
793 }
794
795 /* I think 357 and 457 are prime numbers.. wiggle them if you get coincidences */
796 #define FORMAT_HASH(opRGB, srcRGB, modeRGB, opA, srcA, modeA, format, intFormat) ( \
797 (\
798 ((opRGB)<<30) | ((opA)<<28) | \
799 ((srcRGB)<< 25) | ((srcA)<<22) | \
800 ((modeRGB)) \
801 ) \
802 ^ ((modeA)*357) \
803 ^ (((format)) *457) \
804 ^ ((intFormat) * 7) \
805 )
806
807
808 static GLuint translate_texture_format(GLcontext *ctx, GLint tex_unit, GLuint format, GLint IntFormat)
809 {
810 const struct gl_texture_unit *texUnit= &ctx->Texture.Unit[tex_unit];
811 int i=0; /* number of alpha args .. */
812 GLuint fmt;
813
814 #if 0
815 fprintf(stderr, "_ReallyEnabled=%d EnvMode=%s\n",
816 texUnit->_ReallyEnabled,
817 _mesa_lookup_enum_by_nr(texUnit->EnvMode));
818 #endif
819
820 switch(IntFormat){
821 case 4:
822 case GL_RGBA:
823 case GL_RGBA8:
824 fmt=R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8);
825 break;
826 case 3:
827 case GL_RGB8:
828 fmt=R300_EASY_TX_FORMAT(Z, Y, X, ONE, W8Z8Y8X8);
829 break;
830 default:
831 return 0;
832 }
833 #if 0
834 //fmt &= 0x00fff;
835 //fmt |= ((format) & 0xff00)<<4;
836 fprintf(stderr, "NumArgsRGB=%d NumArgsA=%d\n",
837 texUnit->_CurrentCombine->_NumArgsRGB,
838 texUnit->_CurrentCombine->_NumArgsA);
839
840 fprintf(stderr, "fmt=%08x\n", fmt);
841 #endif
842 //return fmt;
843 /* Size field in format specific first */
844 switch(FORMAT_HASH(
845 texUnit->_CurrentCombine->OperandRGB[i] -GL_SRC_COLOR,
846 translate_src(texUnit->_CurrentCombine->SourceRGB[i]),
847 texUnit->_CurrentCombine->ModeRGB,
848 texUnit->_CurrentCombine->OperandA[i] -GL_SRC_ALPHA,
849 translate_src(texUnit->_CurrentCombine->SourceA[i]),
850 texUnit->_CurrentCombine->ModeA,
851 format,
852 IntFormat
853 )){
854 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA):
855 /* tested with:
856 kfiresaver.kss
857 */
858 return R300_EASY_TX_FORMAT(X, X, CUT_W, W, W8Z8Y8X8);
859 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008847, GL_RGBA8):
860 /* tested with:
861 Quake3demo
862 */
863 /* Quake3demo -small font on the bottom */
864 return fmt;
865 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, GL_RGBA8):
866 /* Quake3demo - mouse cursor*/
867 return fmt;
868 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, 4):
869 /* tested with:
870 kfiresaver.kss
871 */
872 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
873 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00005547, 4):
874 /* tested with:
875 kfiresaver.kss
876 kfountain.kss
877 */
878 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
879 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008847, 3):
880 /* tested with
881 lesson 06
882 lesson 07
883 */
884 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, 0x00000003):
885 /* Tested with NeHe lesson 08 */
886 //case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x0005547, 0):
887 /* Can't remember what I tested this with..
888 try putting return 0 of you see broken textures which
889 are not being complained about */
890 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00009947, GL_RGB8):
891 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00007747, GL_RGB8):
892 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00003347, GL_RGB8):
893 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, 3):
894 /* Tested with:
895 Quake3demo
896 */
897 return R300_EASY_TX_FORMAT(Y, Z, W, ONE, W8Z8Y8X8);
898 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007847, GL_RGBA8):
899 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006747, GL_RGBA8):
900 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00006647, GL_RGBA8):
901 case FORMAT_HASH(0, 1, 0x2100, 0, 4, 0x1e01, 0x00008947, GL_RGBA8):
902 /* Tested with:
903 Quake3demo
904 */
905 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
906 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x00007747, GL_RGBA8):
907 return R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) ;
908 case FORMAT_HASH(0, 1, 0x2100, 0, 1, 0x2100, 0x0008845, 0x00008056):
909 //return 0;
910 fprintf(stderr, "***\n");
911 return R300_EASY_TX_FORMAT(Y, Z, W, W, W8Z8Y8X8);
912 }
913
914
915 {
916 static int warn_once=1;
917 if(warn_once){
918 fprintf(stderr, "%s:%s Do not know how to translate texture format - help me !\n",
919 __FILE__, __FUNCTION__);
920 warn_once=0;
921 }
922 }
923 return 0;
924 }
925
926 void r300_setup_textures(GLcontext *ctx)
927 {
928 int i, mtu;
929 struct r300_tex_obj *t;
930 r300ContextPtr r300 = R300_CONTEXT(ctx);
931 int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
932 struct gl_texture_unit *texUnit;
933
934 R300_STATECHANGE(r300, txe);
935 R300_STATECHANGE(r300, tex.filter);
936 R300_STATECHANGE(r300, tex.unknown1);
937 R300_STATECHANGE(r300, tex.size);
938 R300_STATECHANGE(r300, tex.format);
939 R300_STATECHANGE(r300, tex.offset);
940 R300_STATECHANGE(r300, tex.unknown4);
941 R300_STATECHANGE(r300, tex.unknown5);
942
943 r300->state.texture.tc_count=0;
944
945 r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
946
947 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
948 if (RADEON_DEBUG & DEBUG_STATE)
949 fprintf(stderr, "mtu=%d\n", mtu);
950
951 if(mtu>R300_MAX_TEXTURE_UNITS){
952 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
953 mtu, R300_MAX_TEXTURE_UNITS);
954 exit(-1);
955 }
956 for(i=0;i<mtu;i++){
957 if(ctx->Texture.Unit[i].Enabled){
958 t=r300->state.texture.unit[i].texobj;
959 r300->state.texture.tc_count++;
960 if(t==NULL){
961 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
962 //exit(-1);
963 t=&default_tex_obj;
964 }
965 if (RADEON_DEBUG & DEBUG_STATE)
966 fprintf(stderr, "Activating texture unit %d\n", i);
967 max_texture_unit=i;
968 r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
969
970 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=t->filter;
971
972 /* Turn off rest of the bits that are wrong */
973 t->filter &= R300_TX_MIN_FILTER_MASK | R300_TX_MAG_FILTER_MASK;
974
975 /* No idea why linear filtered textures shake when puting random data */
976 /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
977 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
978 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
979 r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
980 r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
981 r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
982
983 /* We don't know how to set this yet */
984 //value from r300_lib.c for RGB24
985 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x88a0c;
986 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=translate_texture_format(ctx, i, t->format,
987 r300->state.texture.unit[i].texobj!=NULL?t->base.tObj->Image[0][0]->IntFormat:3);
988
989
990 #if 0
991 fprintf(stderr, "Format=%s IntFormat=%08x MesaFormat=%08x BaseFormat=%s IsCompressed=%d Target=%s\n",
992 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->Format),
993 t->base.tObj->Image[0][0]->IntFormat,
994 t->base.tObj->Image[0][0]->TexFormat->MesaFormat,
995 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->TexFormat->BaseFormat),
996 t->base.tObj->Image[0][0]->IsCompressed,
997 _mesa_lookup_enum_by_nr(t->base.tObj->Target));
998
999 fprintf(stderr, "pitch=%08x filter=%08x format=%08x\n", t->pitch, t->filter, r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]);
1000 fprintf(stderr, "unknown1=%08x size=%08x\n", r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i],
1001 r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]);
1002 #endif
1003 /* Use the code below to quickly find matching texture
1004 formats. Requires an app that displays the same texture
1005 repeatedly */
1006 #if 1
1007 if(r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]==0){
1008 static int fmt=0x0;
1009 static int k=0;
1010 k++;
1011 if(k>20){
1012 k=0;
1013 fmt++;
1014 texUnit = &ctx->Texture.Unit[i];
1015 fprintf(stderr, "Want to set FORMAT_HASH(%d, %d, 0x%04x, %d, %d, 0x%04x, 0x%08x, %s(%08x))\n",
1016 texUnit->_CurrentCombine->OperandRGB[0] -GL_SRC_COLOR,
1017 translate_src(texUnit->_CurrentCombine->SourceRGB[0]),
1018 texUnit->_CurrentCombine->ModeRGB,
1019 texUnit->_CurrentCombine->OperandA[0] -GL_SRC_ALPHA,
1020 translate_src(texUnit->_CurrentCombine->SourceA[0]),
1021 texUnit->_CurrentCombine->ModeA,
1022 t->format,
1023 _mesa_lookup_enum_by_nr(t->base.tObj->Image[0][0]->IntFormat),
1024 t->base.tObj->Image[0][0]->IntFormat
1025 );
1026 fprintf(stderr, "Also known: format_x=%08x border_color=%08x cubic_faces=%08x\n", t->format_x, t->pp_border_color, t->pp_cubic_faces);
1027 fprintf(stderr, "\t_ReallyEnabled=%08x EnvMode=%08x IntFormat=%08x\n", texUnit->_ReallyEnabled, texUnit->EnvMode, t->base.tObj->Image[0][0]->IntFormat);
1028 if(fmt>0xfff){
1029 fmt=0;
1030 }
1031 //sleep(1);
1032 fprintf(stderr, "Now trying format %08x\n",
1033 fmt);
1034 fprintf(stderr, "size=%08x\n", t->size);
1035 }
1036 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=known_formats[fmt];
1037 r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=
1038 R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8) | (fmt<<24);
1039 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x08a0c | (fmt<<16);
1040 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x58a00 | (fmt);
1041 //r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=0x53a0c | (fmt<<24);
1042 }
1043 #endif
1044
1045 }
1046
1047 }
1048 ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1049 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1050 ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1051 ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1052 ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1053 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1054 ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1055
1056 if (RADEON_DEBUG & DEBUG_STATE)
1057 fprintf(stderr, "TX_ENABLE: %08x max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1058 }
1059
1060 void r300_setup_rs_unit(GLcontext *ctx)
1061 {
1062 r300ContextPtr r300 = R300_CONTEXT(ctx);
1063 int i;
1064
1065 /* This needs to be rewritten - it is a hack at best */
1066
1067 R300_STATECHANGE(r300, ri);
1068 R300_STATECHANGE(r300, rc);
1069 R300_STATECHANGE(r300, rr);
1070
1071 for(i = 1; i <= 8; ++i)
1072 r300->hw.ri.cmd[i] = 0x00d10000;
1073 r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1074 r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1075 r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1076
1077 #if 1
1078 for(i = 2; i <= 8; ++i)
1079 r300->hw.ri.cmd[i] |= 4;
1080 #endif
1081
1082 for(i = 1; i <= 8; ++i)
1083 r300->hw.rr.cmd[i] = 0;
1084 /* textures enabled ? */
1085 if(r300->state.texture.tc_count>0){
1086
1087 /* This code only really works with one set of texture coordinates */
1088
1089 /* The second constant is needed to get glxgears display anything .. */
1090 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1091 | R300_RS_CNTL_0_UNKNOWN_18
1092 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1093 r300->hw.rc.cmd[2] = 0xc0;
1094
1095
1096 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1097 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1098
1099 } else {
1100
1101 /* The second constant is needed to get glxgears display anything .. */
1102 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1103 r300->hw.rc.cmd[2] = 0;
1104
1105 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1106 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1107
1108 }
1109 }
1110
1111 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1112
1113 #define bump_vpu_count(ptr, new_count) do{\
1114 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1115 int _nc=(new_count)/4; \
1116 if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1117 }while(0)
1118
1119 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1120 {
1121 int i;
1122
1123 if(vsf->length==0)return;
1124
1125 if(vsf->length & 0x3){
1126 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1127 exit(-1);
1128 }
1129
1130 switch((dest>>8) & 0xf){
1131 case 0:
1132 R300_STATECHANGE(r300, vpi);
1133 for(i=0;i<vsf->length;i++)
1134 r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1135 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1136 break;
1137
1138 case 2:
1139 R300_STATECHANGE(r300, vpp);
1140 for(i=0;i<vsf->length;i++)
1141 r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1142 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1143 break;
1144 case 4:
1145 R300_STATECHANGE(r300, vps);
1146 for(i=0;i<vsf->length;i++)
1147 r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1148 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1149 break;
1150 default:
1151 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1152 exit(-1);
1153 }
1154 }
1155
1156
1157 void r300SetupVertexShader(r300ContextPtr rmesa)
1158 {
1159 GLcontext* ctx = rmesa->radeon.glCtx;
1160
1161 /* Reset state, in case we don't use something */
1162 ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1163 ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1164 ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1165
1166
1167 /* This needs to be replaced by vertex shader generation code */
1168
1169
1170 /* textures enabled ? */
1171 if(rmesa->state.texture.tc_count>0){
1172 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1173 } else {
1174 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1175 }
1176
1177
1178 rmesa->state.vertex_shader.matrix[0].length=16;
1179 memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1180
1181 setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1182
1183 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1184 #if 0
1185 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1186 setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1187
1188 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1189 setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1190 #endif
1191
1192 #if 0
1193 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1194 setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1195 #endif
1196
1197 R300_STATECHANGE(rmesa, pvs);
1198 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1199 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1200 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1201 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1202 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1203 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1204 | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1205
1206 /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1207 so I leave it as a reminder */
1208 #if 0
1209 reg_start(R300_VAP_PVS_WAITIDLE,0);
1210 e32(0x00000000);
1211 #endif
1212 }
1213
1214 void r300SetupPixelShader(r300ContextPtr rmesa)
1215 {
1216 int i,k;
1217
1218 /* This needs to be replaced by pixel shader generation code */
1219
1220 /* textures enabled ? */
1221 if(rmesa->state.texture.tc_count>0){
1222 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1223 } else {
1224 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1225 }
1226
1227 R300_STATECHANGE(rmesa, fpt);
1228 for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1229 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1230 rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1231
1232 #define OUTPUT_FIELD(st, reg, field) \
1233 R300_STATECHANGE(rmesa, st); \
1234 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1235 rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1236 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1237
1238 OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1239 OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1240 OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1241 OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1242 #undef OUTPUT_FIELD
1243
1244 R300_STATECHANGE(rmesa, fp);
1245 for(i=0;i<4;i++){
1246 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1247 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1248 | (rmesa->state.pixel_shader.program.node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT)
1249 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1250 | (rmesa->state.pixel_shader.program.node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT)
1251 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1252 }
1253
1254 /* PFS_CNTL_0 */
1255 rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1256 (rmesa->state.pixel_shader.program.active_nodes-1)
1257 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1258 /* PFS_CNTL_1 */
1259 rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1260 /* PFS_CNTL_2 */
1261 rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1262 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1263 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1264 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1265 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1266
1267 R300_STATECHANGE(rmesa, fpp);
1268 for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1269 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1270 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1271 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1272 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1273 }
1274 rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1275
1276 }
1277
1278 /**
1279 * Called by Mesa after an internal state update.
1280 */
1281 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1282 {
1283 r300ContextPtr r300 = R300_CONTEXT(ctx);
1284
1285 _swrast_InvalidateState(ctx, new_state);
1286 _swsetup_InvalidateState(ctx, new_state);
1287 _ac_InvalidateState(ctx, new_state);
1288 _tnl_InvalidateState(ctx, new_state);
1289 _ae_invalidate_state(ctx, new_state);
1290
1291 /* Go inefficiency! */
1292 r300ResetHwState(r300);
1293 }
1294
1295
1296 /**
1297 * Completely recalculates hardware state based on the Mesa state.
1298 */
1299 void r300ResetHwState(r300ContextPtr r300)
1300 {
1301 GLcontext* ctx = r300->radeon.glCtx;
1302 int i;
1303
1304 if (RADEON_DEBUG & DEBUG_STATE)
1305 fprintf(stderr, "%s\n", __FUNCTION__);
1306
1307 r300UpdateWindow(ctx);
1308
1309 r300ColorMask(ctx,
1310 ctx->Color.ColorMask[RCOMP],
1311 ctx->Color.ColorMask[GCOMP],
1312 ctx->Color.ColorMask[BCOMP],
1313 ctx->Color.ColorMask[ACOMP]);
1314
1315 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1316 r300DepthMask(ctx, ctx->Depth.Mask);
1317 r300DepthFunc(ctx, ctx->Depth.Func);
1318
1319 r300UpdateCulling(ctx);
1320
1321 r300_setup_routing(ctx, GL_TRUE);
1322
1323 r300UpdateTextureState(ctx);
1324 r300_setup_textures(ctx);
1325 r300_setup_rs_unit(ctx);
1326
1327 r300SetupVertexShader(r300);
1328 r300SetupPixelShader(r300);
1329
1330 r300_set_blend_state(ctx);
1331 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1332
1333 //BEGIN: TODO
1334 r300->hw.unk2080.cmd[1] = 0x0030045A;
1335
1336 r300->hw.ovf.cmd[R300_OVF_FMT_0] = 0x00000003;
1337 r300->hw.ovf.cmd[R300_OVF_FMT_1] = 0x00000000;
1338
1339 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1340 | R300_VPORT_X_OFFSET_ENA
1341 | R300_VPORT_Y_SCALE_ENA
1342 | R300_VPORT_Y_OFFSET_ENA
1343 | R300_VPORT_Z_SCALE_ENA
1344 | R300_VPORT_Z_OFFSET_ENA
1345 | R300_VTX_W0_FMT;
1346 r300->hw.vte.cmd[2] = 0x00000008;
1347
1348 r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1349 r300->hw.unk2134.cmd[2] = 0x00000000;
1350
1351 r300->hw.unk2140.cmd[1] = 0x00000000;
1352
1353 #if 0 /* Done in setup routing */
1354 ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1355 r300->hw.vir[0].cmd[1] = 0x21030003;
1356
1357 ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1358 r300->hw.vir[1].cmd[1] = 0xF688F688;
1359
1360 r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1361 r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1362 #endif
1363
1364 r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1365
1366 r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1367
1368 r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1369 r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1370 r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1371 r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1372
1373 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1374 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1375 else
1376 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1377
1378 #if 0
1379 r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1380 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1381 r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1382
1383
1384 r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1385 r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1386 r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1387 #endif
1388
1389 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1390 | R300_GB_LINE_STUFF_ENABLE
1391 | R300_GB_TRIANGLE_STUFF_ENABLE;
1392
1393 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1394 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1395 if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1396 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1397 | R300_GB_TILE_PIPE_COUNT_R300
1398 | R300_GB_TILE_SIZE_16;
1399 else
1400 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1401 | R300_GB_TILE_PIPE_COUNT_RV300
1402 | R300_GB_TILE_SIZE_16;
1403 r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1404 r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1405
1406 //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1407
1408 r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1409 r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1410 r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1411 r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1412
1413 r300->hw.unk4214.cmd[1] = 0x00050005;
1414
1415 r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1416 (6 << R300_POINTSIZE_Y_SHIFT);
1417
1418 r300->hw.unk4230.cmd[1] = 0x01800000;
1419 r300->hw.unk4230.cmd[2] = 0x00020006;
1420 r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1421
1422 r300->hw.unk4260.cmd[1] = 0;
1423 r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1424 r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1425
1426 r300->hw.unk4274.cmd[1] = 0x00000002;
1427 r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1428 r300->hw.unk4274.cmd[3] = 0x00000000;
1429 r300->hw.unk4274.cmd[4] = 0x00000000;
1430
1431 r300->hw.unk4288.cmd[1] = 0x00000000;
1432 r300->hw.unk4288.cmd[2] = 0x00000001;
1433 r300->hw.unk4288.cmd[3] = 0x00000000;
1434 r300->hw.unk4288.cmd[4] = 0x00000000;
1435 r300->hw.unk4288.cmd[5] = 0x00000000;
1436
1437 r300->hw.unk42A0.cmd[1] = 0x00000000;
1438
1439 r300->hw.unk42B4.cmd[1] = 0x00000000;
1440
1441 r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1442 r300->hw.unk42C0.cmd[2] = 0x00000000;
1443
1444
1445 r300->hw.unk43A4.cmd[1] = 0x0000001C;
1446 r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1447
1448 r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1449
1450 #if 0
1451 r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1452 r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1453 r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1454 r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1455 r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1456 r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1457 r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1458 #endif
1459
1460 r300->hw.unk46A4.cmd[1] = 0x00001B01;
1461 r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1462 r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1463 r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1464 r300->hw.unk46A4.cmd[5] = 0x00000001;
1465
1466 #if 0
1467 for(i = 1; i <= 64; ++i) {
1468 /* create NOP instructions */
1469 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1470 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1471 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1472 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1473 }
1474 #endif
1475
1476 r300->hw.unk4BC0.cmd[1] = 0;
1477
1478 r300->hw.unk4BC8.cmd[1] = 0;
1479 r300->hw.unk4BC8.cmd[2] = 0;
1480 r300->hw.unk4BC8.cmd[3] = 0;
1481
1482 #if 0
1483 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1484 #endif
1485
1486 r300->hw.unk4BD8.cmd[1] = 0;
1487
1488 r300->hw.unk4E00.cmd[1] = 0;
1489
1490 #if 0
1491 r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1492 r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1493 #endif
1494
1495 r300->hw.unk4E10.cmd[1] = 0;
1496 r300->hw.unk4E10.cmd[2] = 0;
1497 r300->hw.unk4E10.cmd[3] = 0;
1498
1499 r300->hw.cb.cmd[R300_CB_OFFSET] =
1500 r300->radeon.radeonScreen->backOffset +
1501 r300->radeon.radeonScreen->fbLocation;
1502 r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1503 | R300_COLOR_UNKNOWN_22_23;
1504
1505 r300->hw.unk4E50.cmd[1] = 0;
1506 r300->hw.unk4E50.cmd[2] = 0;
1507 r300->hw.unk4E50.cmd[3] = 0;
1508 r300->hw.unk4E50.cmd[4] = 0;
1509 r300->hw.unk4E50.cmd[5] = 0;
1510 r300->hw.unk4E50.cmd[6] = 0;
1511 r300->hw.unk4E50.cmd[7] = 0;
1512 r300->hw.unk4E50.cmd[8] = 0;
1513 r300->hw.unk4E50.cmd[9] = 0;
1514
1515 r300->hw.unk4E88.cmd[1] = 0;
1516
1517 r300->hw.unk4EA0.cmd[1] = 0x00000000;
1518 r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1519
1520 r300->hw.unk4F08.cmd[1] = 0x00FFFF00;
1521
1522 r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1523 r300->hw.unk4F10.cmd[2] = 0x00000000;
1524 r300->hw.unk4F10.cmd[3] = 0x00000003;
1525 r300->hw.unk4F10.cmd[4] = 0x00000000;
1526
1527 r300->hw.zb.cmd[R300_ZB_OFFSET] =
1528 r300->radeon.radeonScreen->depthOffset +
1529 r300->radeon.radeonScreen->fbLocation;
1530 r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1531
1532 r300->hw.unk4F28.cmd[1] = 0;
1533
1534 r300->hw.unk4F30.cmd[1] = 0;
1535 r300->hw.unk4F30.cmd[2] = 0;
1536
1537 r300->hw.unk4F44.cmd[1] = 0;
1538
1539 r300->hw.unk4F54.cmd[1] = 0;
1540
1541 #if 0
1542 ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1543 for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1544 /* MOV t0, t0 */
1545 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1546 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1547 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1548 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1549 }
1550
1551 ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1552 for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1553 r300->hw.vpp.cmd[i] = 0;
1554 #endif
1555
1556 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1557 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1558 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1559 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1560
1561 //END: TODO
1562
1563 r300->hw.all_dirty = GL_TRUE;
1564 }
1565
1566
1567
1568 /**
1569 * Calculate initial hardware state and register state functions.
1570 * Assumes that the command buffer and state atoms have been
1571 * initialized already.
1572 */
1573 void r300InitState(r300ContextPtr r300)
1574 {
1575 GLcontext *ctx = r300->radeon.glCtx;
1576 GLuint depth_fmt;
1577
1578 radeonInitState(&r300->radeon);
1579
1580 switch (ctx->Visual.depthBits) {
1581 case 16:
1582 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1583 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1584 //r300->state.stencil.clear = 0x00000000;
1585 break;
1586 case 24:
1587 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1588 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1589 //r300->state.stencil.clear = 0xff000000;
1590 break;
1591 default:
1592 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1593 ctx->Visual.depthBits);
1594 exit(-1);
1595 }
1596
1597 memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1598
1599 r300ResetHwState(r300);
1600 }
1601
1602
1603
1604 /**
1605 * Initialize driver's state callback functions
1606 */
1607 void r300InitStateFuncs(struct dd_function_table* functions)
1608 {
1609 radeonInitStateFuncs(functions);
1610
1611 functions->UpdateState = r300InvalidateState;
1612 //functions->AlphaFunc = r300AlphaFunc;
1613 functions->BlendColor = r300BlendColor;
1614 functions->BlendEquationSeparate = r300BlendEquationSeparate;
1615 functions->BlendFuncSeparate = r300BlendFuncSeparate;
1616 functions->Enable = r300Enable;
1617 functions->ColorMask = r300ColorMask;
1618 functions->DepthFunc = r300DepthFunc;
1619 functions->DepthMask = r300DepthMask;
1620 functions->CullFace = r300CullFace;
1621 functions->FrontFace = r300FrontFace;
1622
1623 /* Viewport related */
1624 functions->Viewport = r300Viewport;
1625 functions->DepthRange = r300DepthRange;
1626 functions->PointSize = r300PointSize;
1627 }
1628