projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
r500: cleanup r500 RS setup
[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 * \file
34 *
35 * \author Nicolai Haehnle <prefect_@gmx.net>
36 */
37
38 #include "glheader.h"
39 #include "state.h"
40 #include "imports.h"
41 #include "enums.h"
42 #include "macros.h"
43 #include "context.h"
44 #include "dd.h"
45 #include "simple_list.h"
46
47 #include "api_arrayelt.h"
48 #include "swrast/swrast.h"
49 #include "swrast_setup/swrast_setup.h"
50 #include "shader/prog_parameter.h"
51 #include "shader/prog_statevars.h"
52 #include "vbo/vbo.h"
53 #include "tnl/tnl.h"
54 #include "texformat.h"
55
56 #include "radeon_ioctl.h"
57 #include "radeon_state.h"
58 #include "r300_context.h"
59 #include "r300_ioctl.h"
60 #include "r300_state.h"
61 #include "r300_reg.h"
62 #include "r300_emit.h"
63 #include "r300_fragprog.h"
64 #include "r300_tex.h"
65
66 #include "drirenderbuffer.h"
67
68 extern int future_hw_tcl_on;
69 extern void _tnl_UpdateFixedFunctionProgram(GLcontext * ctx);
70
71 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
72 {
73 GLubyte color[4];
74 r300ContextPtr rmesa = R300_CONTEXT(ctx);
75
76 R300_STATECHANGE(rmesa, blend_color);
77
78 CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
79 CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
80 CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
81 CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
82
83 rmesa->hw.blend_color.cmd[1] = PACK_COLOR_8888(color[3], color[0],
84 color[1], color[2]);
85 rmesa->hw.blend_color.cmd[2] = 0;
86 rmesa->hw.blend_color.cmd[3] = 0;
87 }
88
89 /**
90 * Calculate the hardware blend factor setting. This same function is used
91 * for source and destination of both alpha and RGB.
92 *
93 * \returns
94 * The hardware register value for the specified blend factor. This value
95 * will need to be shifted into the correct position for either source or
96 * destination factor.
97 *
98 * \todo
99 * Since the two cases where source and destination are handled differently
100 * are essentially error cases, they should never happen. Determine if these
101 * cases can be removed.
102 */
103 static int blend_factor(GLenum factor, GLboolean is_src)
104 {
105 switch (factor) {
106 case GL_ZERO:
107 return R300_BLEND_GL_ZERO;
108 break;
109 case GL_ONE:
110 return R300_BLEND_GL_ONE;
111 break;
112 case GL_DST_COLOR:
113 return R300_BLEND_GL_DST_COLOR;
114 break;
115 case GL_ONE_MINUS_DST_COLOR:
116 return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
117 break;
118 case GL_SRC_COLOR:
119 return R300_BLEND_GL_SRC_COLOR;
120 break;
121 case GL_ONE_MINUS_SRC_COLOR:
122 return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
123 break;
124 case GL_SRC_ALPHA:
125 return R300_BLEND_GL_SRC_ALPHA;
126 break;
127 case GL_ONE_MINUS_SRC_ALPHA:
128 return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
129 break;
130 case GL_DST_ALPHA:
131 return R300_BLEND_GL_DST_ALPHA;
132 break;
133 case GL_ONE_MINUS_DST_ALPHA:
134 return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
135 break;
136 case GL_SRC_ALPHA_SATURATE:
137 return (is_src) ? R300_BLEND_GL_SRC_ALPHA_SATURATE :
138 R300_BLEND_GL_ZERO;
139 break;
140 case GL_CONSTANT_COLOR:
141 return R300_BLEND_GL_CONST_COLOR;
142 break;
143 case GL_ONE_MINUS_CONSTANT_COLOR:
144 return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
145 break;
146 case GL_CONSTANT_ALPHA:
147 return R300_BLEND_GL_CONST_ALPHA;
148 break;
149 case GL_ONE_MINUS_CONSTANT_ALPHA:
150 return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
151 break;
152 default:
153 fprintf(stderr, "unknown blend factor %x\n", factor);
154 return (is_src) ? R300_BLEND_GL_ONE : R300_BLEND_GL_ZERO;
155 break;
156 }
157 }
158
159 /**
160 * Sets both the blend equation and the blend function.
161 * This is done in a single
162 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
163 * change the interpretation of the blend function.
164 * Also, make sure that blend function and blend equation are set to their
165 * default value if color blending is not enabled, since at least blend
166 * equations GL_MIN and GL_FUNC_REVERSE_SUBTRACT will cause wrong results
167 * otherwise for unknown reasons.
168 */
169
170 /* helper function */
171 static void r300SetBlendCntl(r300ContextPtr r300, int func, int eqn,
172 int cbits, int funcA, int eqnA)
173 {
174 GLuint new_ablend, new_cblend;
175
176 #if 0
177 fprintf(stderr,
178 "eqnA=%08x funcA=%08x eqn=%08x func=%08x cbits=%08x\n",
179 eqnA, funcA, eqn, func, cbits);
180 #endif
181 new_ablend = eqnA | funcA;
182 new_cblend = eqn | func;
183
184 /* Some blend factor combinations don't seem to work when the
185 * BLEND_NO_SEPARATE bit is set.
186 *
187 * Especially problematic candidates are the ONE_MINUS_* flags,
188 * but I can't see a real pattern.
189 */
190 #if 0
191 if (new_ablend == new_cblend) {
192 new_cblend |= R300_BLEND_NO_SEPARATE;
193 }
194 #endif
195 new_cblend |= cbits;
196
197 if ((new_ablend != r300->hw.bld.cmd[R300_BLD_ABLEND]) ||
198 (new_cblend != r300->hw.bld.cmd[R300_BLD_CBLEND])) {
199 R300_STATECHANGE(r300, bld);
200 r300->hw.bld.cmd[R300_BLD_ABLEND] = new_ablend;
201 r300->hw.bld.cmd[R300_BLD_CBLEND] = new_cblend;
202 }
203 }
204
205 static void r300SetBlendState(GLcontext * ctx)
206 {
207 r300ContextPtr r300 = R300_CONTEXT(ctx);
208 int func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
209 (R300_BLEND_GL_ZERO << R300_DST_BLEND_SHIFT);
210 int eqn = R300_COMB_FCN_ADD_CLAMP;
211 int funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
212 (R300_BLEND_GL_ZERO << R300_DST_BLEND_SHIFT);
213 int eqnA = R300_COMB_FCN_ADD_CLAMP;
214
215 if (RGBA_LOGICOP_ENABLED(ctx) || !ctx->Color.BlendEnabled) {
216 r300SetBlendCntl(r300, func, eqn, 0, func, eqn);
217 return;
218 }
219
220 func =
221 (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
222 R300_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
223 GL_FALSE) <<
224 R300_DST_BLEND_SHIFT);
225
226 switch (ctx->Color.BlendEquationRGB) {
227 case GL_FUNC_ADD:
228 eqn = R300_COMB_FCN_ADD_CLAMP;
229 break;
230
231 case GL_FUNC_SUBTRACT:
232 eqn = R300_COMB_FCN_SUB_CLAMP;
233 break;
234
235 case GL_FUNC_REVERSE_SUBTRACT:
236 eqn = R300_COMB_FCN_RSUB_CLAMP;
237 break;
238
239 case GL_MIN:
240 eqn = R300_COMB_FCN_MIN;
241 func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
242 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
243 break;
244
245 case GL_MAX:
246 eqn = R300_COMB_FCN_MAX;
247 func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
248 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
249 break;
250
251 default:
252 fprintf(stderr,
253 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
254 __FUNCTION__, __LINE__, ctx->Color.BlendEquationRGB);
255 return;
256 }
257
258 funcA =
259 (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
260 R300_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
261 GL_FALSE) <<
262 R300_DST_BLEND_SHIFT);
263
264 switch (ctx->Color.BlendEquationA) {
265 case GL_FUNC_ADD:
266 eqnA = R300_COMB_FCN_ADD_CLAMP;
267 break;
268
269 case GL_FUNC_SUBTRACT:
270 eqnA = R300_COMB_FCN_SUB_CLAMP;
271 break;
272
273 case GL_FUNC_REVERSE_SUBTRACT:
274 eqnA = R300_COMB_FCN_RSUB_CLAMP;
275 break;
276
277 case GL_MIN:
278 eqnA = R300_COMB_FCN_MIN;
279 funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
280 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
281 break;
282
283 case GL_MAX:
284 eqnA = R300_COMB_FCN_MAX;
285 funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
286 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
287 break;
288
289 default:
290 fprintf(stderr,
291 "[%s:%u] Invalid A blend equation (0x%04x).\n",
292 __FUNCTION__, __LINE__, ctx->Color.BlendEquationA);
293 return;
294 }
295
296 r300SetBlendCntl(r300,
297 func, eqn,
298 R300_BLEND_UNKNOWN | R300_BLEND_ENABLE, funcA, eqnA);
299 }
300
301 static void r300BlendEquationSeparate(GLcontext * ctx,
302 GLenum modeRGB, GLenum modeA)
303 {
304 r300SetBlendState(ctx);
305 }
306
307 static void r300BlendFuncSeparate(GLcontext * ctx,
308 GLenum sfactorRGB, GLenum dfactorRGB,
309 GLenum sfactorA, GLenum dfactorA)
310 {
311 r300SetBlendState(ctx);
312 }
313
314 static void r300ClipPlane( GLcontext *ctx, GLenum plane, const GLfloat *eq )
315 {
316 r300ContextPtr rmesa = R300_CONTEXT(ctx);
317 GLint p;
318 GLint *ip;
319
320 /* no VAP UCP on non-TCL chipsets */
321 if (!(rmesa->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL))
322 return;
323
324 p = (GLint) plane - (GLint) GL_CLIP_PLANE0;
325 ip = (GLint *)ctx->Transform._ClipUserPlane[p];
326
327 R300_STATECHANGE( rmesa, vpucp[p] );
328 rmesa->hw.vpucp[p].cmd[R300_VPUCP_X] = ip[0];
329 rmesa->hw.vpucp[p].cmd[R300_VPUCP_Y] = ip[1];
330 rmesa->hw.vpucp[p].cmd[R300_VPUCP_Z] = ip[2];
331 rmesa->hw.vpucp[p].cmd[R300_VPUCP_W] = ip[3];
332 }
333
334 static void r300SetClipPlaneState(GLcontext * ctx, GLenum cap, GLboolean state)
335 {
336 r300ContextPtr r300 = R300_CONTEXT(ctx);
337 GLuint p;
338
339 /* no VAP UCP on non-TCL chipsets */
340 if (!(r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL))
341 return;
342
343 p = cap - GL_CLIP_PLANE0;
344 R300_STATECHANGE(r300, vap_clip_cntl);
345 if (state) {
346 r300->hw.vap_clip_cntl.cmd[1] |= (R300_VAP_UCP_ENABLE_0 << p);
347 r300ClipPlane(ctx, cap, NULL);
348 } else {
349 r300->hw.vap_clip_cntl.cmd[1] &= ~(R300_VAP_UCP_ENABLE_0 << p);
350 }
351 }
352
353 /**
354 * Update our tracked culling state based on Mesa's state.
355 */
356 static void r300UpdateCulling(GLcontext * ctx)
357 {
358 r300ContextPtr r300 = R300_CONTEXT(ctx);
359 uint32_t val = 0;
360
361 if (ctx->Polygon.CullFlag) {
362 switch (ctx->Polygon.CullFaceMode) {
363 case GL_FRONT:
364 val = R300_CULL_FRONT;
365 break;
366 case GL_BACK:
367 val = R300_CULL_BACK;
368 break;
369 case GL_FRONT_AND_BACK:
370 val = R300_CULL_FRONT | R300_CULL_BACK;
371 break;
372 default:
373 break;
374 }
375 }
376
377 switch (ctx->Polygon.FrontFace) {
378 case GL_CW:
379 val |= R300_FRONT_FACE_CW;
380 break;
381 case GL_CCW:
382 val |= R300_FRONT_FACE_CCW;
383 break;
384 default:
385 break;
386 }
387
388 R300_STATECHANGE(r300, cul);
389 r300->hw.cul.cmd[R300_CUL_CULL] = val;
390 }
391
392 static void r300SetPolygonOffsetState(GLcontext * ctx, GLboolean state)
393 {
394 r300ContextPtr r300 = R300_CONTEXT(ctx);
395
396 R300_STATECHANGE(r300, occlusion_cntl);
397 if (state) {
398 r300->hw.occlusion_cntl.cmd[1] |= (3 << 0);
399 } else {
400 r300->hw.occlusion_cntl.cmd[1] &= ~(3 << 0);
401 }
402 }
403
404 static void r300SetEarlyZState(GLcontext * ctx)
405 {
406 /* updates register R300_RB3D_EARLY_Z (0x4F14)
407 if depth test is not enabled it should be R300_EARLY_Z_DISABLE
408 if depth is enabled and alpha not it should be R300_EARLY_Z_ENABLE
409 if depth and alpha is enabled it should be R300_EARLY_Z_DISABLE
410 */
411 r300ContextPtr r300 = R300_CONTEXT(ctx);
412
413 R300_STATECHANGE(r300, zstencil_format);
414 switch (ctx->Visual.depthBits) {
415 case 16:
416 r300->hw.zstencil_format.cmd[1] = ZB_FORMAR_DEPTHFORMAT_16BIT_INT_Z;
417 break;
418 case 24:
419 r300->hw.zstencil_format.cmd[1] = ZB_FORMAR_DEPTHFORMAT_24BIT_INT_Z;
420 break;
421 default:
422 fprintf(stderr, "Error: Unsupported depth %d... exiting\n", ctx->Visual.depthBits);
423 _mesa_exit(-1);
424 }
425
426 if (ctx->Color.AlphaEnabled && ctx->Color.AlphaFunc != GL_ALWAYS)
427 /* disable early Z */
428 r300->hw.zstencil_format.cmd[2] = R300_EARLY_Z_DISABLE;
429 else {
430 if (ctx->Depth.Test && ctx->Depth.Func != GL_NEVER)
431 /* enable early Z */
432 r300->hw.zstencil_format.cmd[2] = R300_EARLY_Z_ENABLE;
433 else
434 /* disable early Z */
435 r300->hw.zstencil_format.cmd[2] = R300_EARLY_Z_DISABLE;
436 }
437
438 r300->hw.zstencil_format.cmd[3] = 0x00000003;
439 r300->hw.zstencil_format.cmd[4] = 0x00000000;
440 }
441
442 static void r300SetAlphaState(GLcontext * ctx)
443 {
444 r300ContextPtr r300 = R300_CONTEXT(ctx);
445 GLubyte refByte;
446 uint32_t pp_misc = 0x0;
447 GLboolean really_enabled = ctx->Color.AlphaEnabled;
448
449 CLAMPED_FLOAT_TO_UBYTE(refByte, ctx->Color.AlphaRef);
450
451 switch (ctx->Color.AlphaFunc) {
452 case GL_NEVER:
453 pp_misc |= FG_ALPHA_FUNC_NEVER;
454 break;
455 case GL_LESS:
456 pp_misc |= FG_ALPHA_FUNC_LESS;
457 break;
458 case GL_EQUAL:
459 pp_misc |= FG_ALPHA_FUNC_EQUAL;
460 break;
461 case GL_LEQUAL:
462 pp_misc |= FG_ALPHA_FUNC_LE;
463 break;
464 case GL_GREATER:
465 pp_misc |= FG_ALPHA_FUNC_GREATER;
466 break;
467 case GL_NOTEQUAL:
468 pp_misc |= FG_ALPHA_FUNC_NOTEQUAL;
469 break;
470 case GL_GEQUAL:
471 pp_misc |= FG_ALPHA_FUNC_GE;
472 break;
473 case GL_ALWAYS:
474 /*pp_misc |= FG_ALPHA_FUNC_ALWAYS; */
475 really_enabled = GL_FALSE;
476 break;
477 }
478
479 if (really_enabled) {
480 pp_misc |= FG_ALPHA_FUNC_ENABLE;
481 pp_misc |= (refByte & R300_REF_ALPHA_MASK);
482 } else {
483 pp_misc = 0x0;
484 }
485
486 R300_STATECHANGE(r300, at);
487 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
488 r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
489
490 r300SetEarlyZState(ctx);
491 }
492
493 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
494 {
495 (void)func;
496 (void)ref;
497 r300SetAlphaState(ctx);
498 }
499
500 static int translate_func(int func)
501 {
502 switch (func) {
503 case GL_NEVER:
504 return R300_ZS_NEVER;
505 case GL_LESS:
506 return R300_ZS_LESS;
507 case GL_EQUAL:
508 return R300_ZS_EQUAL;
509 case GL_LEQUAL:
510 return R300_ZS_LEQUAL;
511 case GL_GREATER:
512 return R300_ZS_GREATER;
513 case GL_NOTEQUAL:
514 return R300_ZS_NOTEQUAL;
515 case GL_GEQUAL:
516 return R300_ZS_GEQUAL;
517 case GL_ALWAYS:
518 return R300_ZS_ALWAYS;
519 }
520 return 0;
521 }
522
523 static void r300SetDepthState(GLcontext * ctx)
524 {
525 r300ContextPtr r300 = R300_CONTEXT(ctx);
526
527 R300_STATECHANGE(r300, zs);
528 r300->hw.zs.cmd[R300_ZS_CNTL_0] &= R300_RB3D_STENCIL_ENABLE;
529 r300->hw.zs.cmd[R300_ZS_CNTL_1] &=
530 ~(R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
531
532 if (ctx->Depth.Test && ctx->Depth.Func != GL_NEVER) {
533 if (ctx->Depth.Mask)
534 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
535 R300_RB3D_Z_TEST_AND_WRITE;
536 else
537 r300->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_RB3D_Z_TEST;
538
539 r300->hw.zs.cmd[R300_ZS_CNTL_1] |=
540 translate_func(ctx->Depth.
541 Func) << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
542 } else {
543 r300->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_RB3D_Z_DISABLED_1;
544 r300->hw.zs.cmd[R300_ZS_CNTL_1] |=
545 translate_func(GL_NEVER) << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
546 }
547
548 r300SetEarlyZState(ctx);
549 }
550
551 static void r300SetStencilState(GLcontext * ctx, GLboolean state)
552 {
553 r300ContextPtr r300 = R300_CONTEXT(ctx);
554
555 if (r300->state.stencil.hw_stencil) {
556 R300_STATECHANGE(r300, zs);
557 if (state) {
558 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
559 R300_RB3D_STENCIL_ENABLE;
560 } else {
561 r300->hw.zs.cmd[R300_ZS_CNTL_0] &=
562 ~R300_RB3D_STENCIL_ENABLE;
563 }
564 } else {
565 #if R200_MERGED
566 FALLBACK(&r300->radeon, RADEON_FALLBACK_STENCIL, state);
567 #endif
568 }
569 }
570
571 static void r300UpdatePolygonMode(GLcontext * ctx)
572 {
573 r300ContextPtr r300 = R300_CONTEXT(ctx);
574 uint32_t hw_mode = GA_POLY_MODE_DISABLE;
575
576 /* Only do something if a polygon mode is wanted, default is GL_FILL */
577 if (ctx->Polygon.FrontMode != GL_FILL ||
578 ctx->Polygon.BackMode != GL_FILL) {
579 GLenum f, b;
580
581 /* Handle GL_CW (clock wise and GL_CCW (counter clock wise)
582 * correctly by selecting the correct front and back face
583 */
584 if (ctx->Polygon.FrontFace == GL_CCW) {
585 f = ctx->Polygon.FrontMode;
586 b = ctx->Polygon.BackMode;
587 } else {
588 f = ctx->Polygon.BackMode;
589 b = ctx->Polygon.FrontMode;
590 }
591
592 /* Enable polygon mode */
593 hw_mode |= GA_POLY_MODE_DUAL;
594
595 switch (f) {
596 case GL_LINE:
597 hw_mode |= GA_POLY_MODE_FRONT_PTYPE_LINE;
598 break;
599 case GL_POINT:
600 hw_mode |= GA_POLY_MODE_FRONT_PTYPE_POINT;
601 break;
602 case GL_FILL:
603 hw_mode |= GA_POLY_MODE_FRONT_PTYPE_TRI;
604 break;
605 }
606
607 switch (b) {
608 case GL_LINE:
609 hw_mode |= GA_POLY_MODE_BACK_PTYPE_LINE;
610 break;
611 case GL_POINT:
612 hw_mode |= GA_POLY_MODE_BACK_PTYPE_POINT;
613 break;
614 case GL_FILL:
615 hw_mode |= GA_POLY_MODE_BACK_PTYPE_TRI;
616 break;
617 }
618 }
619
620 if (r300->hw.polygon_mode.cmd[1] != hw_mode) {
621 R300_STATECHANGE(r300, polygon_mode);
622 r300->hw.polygon_mode.cmd[1] = hw_mode;
623 }
624
625 r300->hw.polygon_mode.cmd[2] = 0x00000001;
626 r300->hw.polygon_mode.cmd[3] = 0x00000000;
627 }
628
629 /**
630 * Change the culling mode.
631 *
632 * \note Mesa already filters redundant calls to this function.
633 */
634 static void r300CullFace(GLcontext * ctx, GLenum mode)
635 {
636 (void)mode;
637
638 r300UpdateCulling(ctx);
639 }
640
641 /**
642 * Change the polygon orientation.
643 *
644 * \note Mesa already filters redundant calls to this function.
645 */
646 static void r300FrontFace(GLcontext * ctx, GLenum mode)
647 {
648 (void)mode;
649
650 r300UpdateCulling(ctx);
651 r300UpdatePolygonMode(ctx);
652 }
653
654 /**
655 * Change the depth testing function.
656 *
657 * \note Mesa already filters redundant calls to this function.
658 */
659 static void r300DepthFunc(GLcontext * ctx, GLenum func)
660 {
661 (void)func;
662 r300SetDepthState(ctx);
663 }
664
665 /**
666 * Enable/Disable depth writing.
667 *
668 * \note Mesa already filters redundant calls to this function.
669 */
670 static void r300DepthMask(GLcontext * ctx, GLboolean mask)
671 {
672 (void)mask;
673 r300SetDepthState(ctx);
674 }
675
676 /**
677 * Handle glColorMask()
678 */
679 static void r300ColorMask(GLcontext * ctx,
680 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
681 {
682 r300ContextPtr r300 = R300_CONTEXT(ctx);
683 int mask = (r ? RB3D_COLOR_CHANNEL_MASK_RED_MASK0 : 0) |
684 (g ? RB3D_COLOR_CHANNEL_MASK_GREEN_MASK0 : 0) |
685 (b ? RB3D_COLOR_CHANNEL_MASK_BLUE_MASK0 : 0) |
686 (a ? RB3D_COLOR_CHANNEL_MASK_ALPHA_MASK0 : 0);
687
688 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
689 R300_STATECHANGE(r300, cmk);
690 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
691 }
692 }
693
694 /* =============================================================
695 * Fog
696 */
697 static void r300Fogfv(GLcontext * ctx, GLenum pname, const GLfloat * param)
698 {
699 r300ContextPtr r300 = R300_CONTEXT(ctx);
700 union {
701 int i;
702 float f;
703 } fogScale, fogStart;
704
705 (void)param;
706
707 fogScale.i = r300->hw.fogp.cmd[R300_FOGP_SCALE];
708 fogStart.i = r300->hw.fogp.cmd[R300_FOGP_START];
709
710 switch (pname) {
711 case GL_FOG_MODE:
712 if (!ctx->Fog.Enabled)
713 return;
714 switch (ctx->Fog.Mode) {
715 case GL_LINEAR:
716 R300_STATECHANGE(r300, fogs);
717 r300->hw.fogs.cmd[R300_FOGS_STATE] =
718 (r300->hw.fogs.
719 cmd[R300_FOGS_STATE] & ~FG_FOG_BLEND_FN_MASK) |
720 FG_FOG_BLEND_FN_LINEAR;
721
722 if (ctx->Fog.Start == ctx->Fog.End) {
723 fogScale.f = -1.0;
724 fogStart.f = 1.0;
725 } else {
726 fogScale.f =
727 1.0 / (ctx->Fog.End - ctx->Fog.Start);
728 fogStart.f =
729 -ctx->Fog.Start / (ctx->Fog.End -
730 ctx->Fog.Start);
731 }
732 break;
733 case GL_EXP:
734 R300_STATECHANGE(r300, fogs);
735 r300->hw.fogs.cmd[R300_FOGS_STATE] =
736 (r300->hw.fogs.
737 cmd[R300_FOGS_STATE] & ~FG_FOG_BLEND_FN_MASK) |
738 FG_FOG_BLEND_FN_EXP;
739 fogScale.f = 0.0933 * ctx->Fog.Density;
740 fogStart.f = 0.0;
741 break;
742 case GL_EXP2:
743 R300_STATECHANGE(r300, fogs);
744 r300->hw.fogs.cmd[R300_FOGS_STATE] =
745 (r300->hw.fogs.
746 cmd[R300_FOGS_STATE] & ~FG_FOG_BLEND_FN_MASK) |
747 FG_FOG_BLEND_FN_EXP2;
748 fogScale.f = 0.3 * ctx->Fog.Density;
749 fogStart.f = 0.0;
750 default:
751 return;
752 }
753 break;
754 case GL_FOG_DENSITY:
755 switch (ctx->Fog.Mode) {
756 case GL_EXP:
757 fogScale.f = 0.0933 * ctx->Fog.Density;
758 fogStart.f = 0.0;
759 break;
760 case GL_EXP2:
761 fogScale.f = 0.3 * ctx->Fog.Density;
762 fogStart.f = 0.0;
763 default:
764 break;
765 }
766 break;
767 case GL_FOG_START:
768 case GL_FOG_END:
769 if (ctx->Fog.Mode == GL_LINEAR) {
770 if (ctx->Fog.Start == ctx->Fog.End) {
771 fogScale.f = -1.0;
772 fogStart.f = 1.0;
773 } else {
774 fogScale.f =
775 1.0 / (ctx->Fog.End - ctx->Fog.Start);
776 fogStart.f =
777 -ctx->Fog.Start / (ctx->Fog.End -
778 ctx->Fog.Start);
779 }
780 }
781 break;
782 case GL_FOG_COLOR:
783 R300_STATECHANGE(r300, fogc);
784 r300->hw.fogc.cmd[R300_FOGC_R] =
785 (GLuint) (ctx->Fog.Color[0] * 1023.0F) & 0x3FF;
786 r300->hw.fogc.cmd[R300_FOGC_G] =
787 (GLuint) (ctx->Fog.Color[1] * 1023.0F) & 0x3FF;
788 r300->hw.fogc.cmd[R300_FOGC_B] =
789 (GLuint) (ctx->Fog.Color[2] * 1023.0F) & 0x3FF;
790 break;
791 case GL_FOG_COORD_SRC:
792 break;
793 default:
794 return;
795 }
796
797 if (fogScale.i != r300->hw.fogp.cmd[R300_FOGP_SCALE] ||
798 fogStart.i != r300->hw.fogp.cmd[R300_FOGP_START]) {
799 R300_STATECHANGE(r300, fogp);
800 r300->hw.fogp.cmd[R300_FOGP_SCALE] = fogScale.i;
801 r300->hw.fogp.cmd[R300_FOGP_START] = fogStart.i;
802 }
803 }
804
805 static void r300SetFogState(GLcontext * ctx, GLboolean state)
806 {
807 r300ContextPtr r300 = R300_CONTEXT(ctx);
808
809 R300_STATECHANGE(r300, fogs);
810 if (state) {
811 r300->hw.fogs.cmd[R300_FOGS_STATE] |= FG_FOG_BLEND_ENABLE;
812
813 r300Fogfv(ctx, GL_FOG_MODE, NULL);
814 r300Fogfv(ctx, GL_FOG_DENSITY, &ctx->Fog.Density);
815 r300Fogfv(ctx, GL_FOG_START, &ctx->Fog.Start);
816 r300Fogfv(ctx, GL_FOG_END, &ctx->Fog.End);
817 r300Fogfv(ctx, GL_FOG_COLOR, ctx->Fog.Color);
818 } else {
819 r300->hw.fogs.cmd[R300_FOGS_STATE] &= ~FG_FOG_BLEND_ENABLE;
820 }
821 }
822
823 /* =============================================================
824 * Point state
825 */
826 static void r300PointSize(GLcontext * ctx, GLfloat size)
827 {
828 r300ContextPtr r300 = R300_CONTEXT(ctx);
829 /* same size limits for AA, non-AA points */
830 size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize);
831
832 R300_STATECHANGE(r300, ps);
833 r300->hw.ps.cmd[R300_PS_POINTSIZE] =
834 ((int)(size * 6) << R300_POINTSIZE_X_SHIFT) |
835 ((int)(size * 6) << R300_POINTSIZE_Y_SHIFT);
836 }
837
838 /* =============================================================
839 * Line state
840 */
841 static void r300LineWidth(GLcontext * ctx, GLfloat widthf)
842 {
843 r300ContextPtr r300 = R300_CONTEXT(ctx);
844
845 widthf = CLAMP(widthf,
846 ctx->Const.MinPointSize,
847 ctx->Const.MaxPointSize);
848 R300_STATECHANGE(r300, lcntl);
849 r300->hw.lcntl.cmd[1] =
850 R300_LINE_CNT_HO | R300_LINE_CNT_VE | (int)(widthf * 6.0);
851 }
852
853 static void r300PolygonMode(GLcontext * ctx, GLenum face, GLenum mode)
854 {
855 (void)face;
856 (void)mode;
857
858 r300UpdatePolygonMode(ctx);
859 }
860
861 /* =============================================================
862 * Stencil
863 */
864
865 static int translate_stencil_op(int op)
866 {
867 switch (op) {
868 case GL_KEEP:
869 return R300_ZS_KEEP;
870 case GL_ZERO:
871 return R300_ZS_ZERO;
872 case GL_REPLACE:
873 return R300_ZS_REPLACE;
874 case GL_INCR:
875 return R300_ZS_INCR;
876 case GL_DECR:
877 return R300_ZS_DECR;
878 case GL_INCR_WRAP_EXT:
879 return R300_ZS_INCR_WRAP;
880 case GL_DECR_WRAP_EXT:
881 return R300_ZS_DECR_WRAP;
882 case GL_INVERT:
883 return R300_ZS_INVERT;
884 default:
885 WARN_ONCE("Do not know how to translate stencil op");
886 return R300_ZS_KEEP;
887 }
888 return 0;
889 }
890
891 static void r300ShadeModel(GLcontext * ctx, GLenum mode)
892 {
893 r300ContextPtr rmesa = R300_CONTEXT(ctx);
894
895 R300_STATECHANGE(rmesa, shade);
896 rmesa->hw.shade.cmd[1] = 0x00000002;
897 switch (mode) {
898 case GL_FLAT:
899 rmesa->hw.shade.cmd[2] = R300_RE_SHADE_MODEL_FLAT;
900 break;
901 case GL_SMOOTH:
902 rmesa->hw.shade.cmd[2] = R300_RE_SHADE_MODEL_SMOOTH;
903 break;
904 default:
905 return;
906 }
907 rmesa->hw.shade.cmd[3] = 0x00000000;
908 rmesa->hw.shade.cmd[4] = 0x00000000;
909 }
910
911 static void r300StencilFuncSeparate(GLcontext * ctx, GLenum face,
912 GLenum func, GLint ref, GLuint mask)
913 {
914 r300ContextPtr rmesa = R300_CONTEXT(ctx);
915 GLuint refmask =
916 (((ctx->Stencil.
917 Ref[0] & 0xff) << ZB_STENCILREFMASK_STENCILREF_SHIFT) | ((ctx->
918 Stencil.
919 ValueMask
920 [0] &
921 0xff)
922 <<
923 ZB_STENCILREFMASK_STENCILMASK_SHIFT));
924
925 GLuint flag;
926
927 R300_STATECHANGE(rmesa, zs);
928
929 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~((R300_ZS_MASK <<
930 R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
931 | (R300_ZS_MASK <<
932 R300_RB3D_ZS1_BACK_FUNC_SHIFT));
933
934 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &=
935 ~((ZB_STENCILREFMASK_STENCIL_MASK << ZB_STENCILREFMASK_STENCILREF_SHIFT) |
936 (ZB_STENCILREFMASK_STENCIL_MASK << ZB_STENCILREFMASK_STENCILMASK_SHIFT));
937
938 flag = translate_func(ctx->Stencil.Function[0]);
939 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
940 (flag << R300_RB3D_ZS1_FRONT_FUNC_SHIFT);
941
942 if (ctx->Stencil._TestTwoSide)
943 flag = translate_func(ctx->Stencil.Function[1]);
944
945 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
946 (flag << R300_RB3D_ZS1_BACK_FUNC_SHIFT);
947 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
948 }
949
950 static void r300StencilMaskSeparate(GLcontext * ctx, GLenum face, GLuint mask)
951 {
952 r300ContextPtr rmesa = R300_CONTEXT(ctx);
953
954 R300_STATECHANGE(rmesa, zs);
955 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &=
956 ~(ZB_STENCILREFMASK_STENCIL_MASK <<
957 ZB_STENCILREFMASK_STENCILWRITEMASK_SHIFT);
958 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |=
959 (ctx->Stencil.
960 WriteMask[0] & ZB_STENCILREFMASK_STENCIL_MASK) <<
961 ZB_STENCILREFMASK_STENCILWRITEMASK_SHIFT;
962 }
963
964 static void r300StencilOpSeparate(GLcontext * ctx, GLenum face,
965 GLenum fail, GLenum zfail, GLenum zpass)
966 {
967 r300ContextPtr rmesa = R300_CONTEXT(ctx);
968
969 R300_STATECHANGE(rmesa, zs);
970 /* It is easier to mask what's left.. */
971 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &=
972 (R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT) |
973 (R300_ZS_MASK << R300_RB3D_ZS1_FRONT_FUNC_SHIFT) |
974 (R300_ZS_MASK << R300_RB3D_ZS1_BACK_FUNC_SHIFT);
975
976 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
977 (translate_stencil_op(ctx->Stencil.FailFunc[0]) <<
978 R300_RB3D_ZS1_FRONT_FAIL_OP_SHIFT)
979 | (translate_stencil_op(ctx->Stencil.ZFailFunc[0]) <<
980 R300_RB3D_ZS1_FRONT_ZFAIL_OP_SHIFT)
981 | (translate_stencil_op(ctx->Stencil.ZPassFunc[0]) <<
982 R300_RB3D_ZS1_FRONT_ZPASS_OP_SHIFT);
983
984 if (ctx->Stencil._TestTwoSide) {
985 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
986 (translate_stencil_op(ctx->Stencil.FailFunc[1]) <<
987 R300_RB3D_ZS1_BACK_FAIL_OP_SHIFT)
988 | (translate_stencil_op(ctx->Stencil.ZFailFunc[1]) <<
989 R300_RB3D_ZS1_BACK_ZFAIL_OP_SHIFT)
990 | (translate_stencil_op(ctx->Stencil.ZPassFunc[1]) <<
991 R300_RB3D_ZS1_BACK_ZPASS_OP_SHIFT);
992 } else {
993 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
994 (translate_stencil_op(ctx->Stencil.FailFunc[0]) <<
995 R300_RB3D_ZS1_BACK_FAIL_OP_SHIFT)
996 | (translate_stencil_op(ctx->Stencil.ZFailFunc[0]) <<
997 R300_RB3D_ZS1_BACK_ZFAIL_OP_SHIFT)
998 | (translate_stencil_op(ctx->Stencil.ZPassFunc[0]) <<
999 R300_RB3D_ZS1_BACK_ZPASS_OP_SHIFT);
1000 }
1001 }
1002
1003 static void r300ClearStencil(GLcontext * ctx, GLint s)
1004 {
1005 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1006
1007 rmesa->state.stencil.clear =
1008 ((GLuint) (ctx->Stencil.Clear & ZB_STENCILREFMASK_STENCIL_MASK) |
1009 (ZB_STENCILREFMASK_STENCIL_MASK << ZB_STENCILREFMASK_STENCILMASK_SHIFT) |
1010 ((ctx->Stencil.WriteMask[0] & ZB_STENCILREFMASK_STENCIL_MASK) <<
1011 ZB_STENCILREFMASK_STENCILMASK_SHIFT));
1012 }
1013
1014 /* =============================================================
1015 * Window position and viewport transformation
1016 */
1017
1018 /*
1019 * To correctly position primitives:
1020 */
1021 #define SUBPIXEL_X 0.125
1022 #define SUBPIXEL_Y 0.125
1023
1024 static void r300UpdateWindow(GLcontext * ctx)
1025 {
1026 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1027 __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
1028 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
1029 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
1030 const GLfloat *v = ctx->Viewport._WindowMap.m;
1031
1032 GLfloat sx = v[MAT_SX];
1033 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
1034 GLfloat sy = -v[MAT_SY];
1035 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
1036 GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
1037 GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
1038
1039 R300_FIREVERTICES(rmesa);
1040 R300_STATECHANGE(rmesa, vpt);
1041
1042 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
1043 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
1044 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
1045 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
1046 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
1047 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
1048 }
1049
1050 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
1051 GLsizei width, GLsizei height)
1052 {
1053 /* Don't pipeline viewport changes, conflict with window offset
1054 * setting below. Could apply deltas to rescue pipelined viewport
1055 * values, or keep the originals hanging around.
1056 */
1057 r300UpdateWindow(ctx);
1058 }
1059
1060 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
1061 {
1062 r300UpdateWindow(ctx);
1063 }
1064
1065 void r300UpdateViewportOffset(GLcontext * ctx)
1066 {
1067 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1068 __DRIdrawablePrivate *dPriv = ((radeonContextPtr) rmesa)->dri.drawable;
1069 GLfloat xoffset = (GLfloat) dPriv->x;
1070 GLfloat yoffset = (GLfloat) dPriv->y + dPriv->h;
1071 const GLfloat *v = ctx->Viewport._WindowMap.m;
1072
1073 GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
1074 GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
1075
1076 if (rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] != r300PackFloat32(tx) ||
1077 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] != r300PackFloat32(ty)) {
1078 /* Note: this should also modify whatever data the context reset
1079 * code uses...
1080 */
1081 R300_STATECHANGE(rmesa, vpt);
1082 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
1083 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
1084
1085 }
1086
1087 radeonUpdateScissor(ctx);
1088 }
1089
1090 /**
1091 * Tell the card where to render (offset, pitch).
1092 * Effected by glDrawBuffer, etc
1093 */
1094 void r300UpdateDrawBuffer(GLcontext * ctx)
1095 {
1096 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1097 r300ContextPtr r300 = rmesa;
1098 struct gl_framebuffer *fb = ctx->DrawBuffer;
1099 driRenderbuffer *drb;
1100
1101 if (fb->_ColorDrawBufferIndexes[0] == BUFFER_FRONT_LEFT) {
1102 /* draw to front */
1103 drb =
1104 (driRenderbuffer *) fb->Attachment[BUFFER_FRONT_LEFT].
1105 Renderbuffer;
1106 } else if (fb->_ColorDrawBufferIndexes[0] == BUFFER_BACK_LEFT) {
1107 /* draw to back */
1108 drb =
1109 (driRenderbuffer *) fb->Attachment[BUFFER_BACK_LEFT].
1110 Renderbuffer;
1111 } else {
1112 /* drawing to multiple buffers, or none */
1113 return;
1114 }
1115
1116 assert(drb);
1117 assert(drb->flippedPitch);
1118
1119 R300_STATECHANGE(rmesa, cb);
1120
1121 r300->hw.cb.cmd[R300_CB_OFFSET] = drb->flippedOffset + //r300->radeon.state.color.drawOffset +
1122 r300->radeon.radeonScreen->fbLocation;
1123 r300->hw.cb.cmd[R300_CB_PITCH] = drb->flippedPitch; //r300->radeon.state.color.drawPitch;
1124
1125 if (r300->radeon.radeonScreen->cpp == 4)
1126 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_FORMAT_ARGB8888;
1127 else
1128 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_FORMAT_RGB565;
1129
1130 if (r300->radeon.sarea->tiling_enabled)
1131 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_TILE_ENABLE;
1132 #if 0
1133 R200_STATECHANGE(rmesa, ctx);
1134
1135 /* Note: we used the (possibly) page-flipped values */
1136 rmesa->hw.ctx.cmd[CTX_RB3D_COLOROFFSET]
1137 = ((drb->flippedOffset + rmesa->r200Screen->fbLocation)
1138 & R200_COLOROFFSET_MASK);
1139 rmesa->hw.ctx.cmd[CTX_RB3D_COLORPITCH] = drb->flippedPitch;
1140
1141 if (rmesa->sarea->tiling_enabled) {
1142 rmesa->hw.ctx.cmd[CTX_RB3D_COLORPITCH] |=
1143 R200_COLOR_TILE_ENABLE;
1144 }
1145 #endif
1146 }
1147
1148 static void
1149 r300FetchStateParameter(GLcontext * ctx,
1150 const gl_state_index state[STATE_LENGTH],
1151 GLfloat * value)
1152 {
1153 r300ContextPtr r300 = R300_CONTEXT(ctx);
1154
1155 switch (state[0]) {
1156 case STATE_INTERNAL:
1157 switch (state[1]) {
1158 case STATE_R300_WINDOW_DIMENSION:
1159 value[0] = r300->radeon.dri.drawable->w * 0.5f; /* width*0.5 */
1160 value[1] = r300->radeon.dri.drawable->h * 0.5f; /* height*0.5 */
1161 value[2] = 0.5F; /* for moving range [-1 1] -> [0 1] */
1162 value[3] = 1.0F; /* not used */
1163 break;
1164
1165 case STATE_R300_TEXRECT_FACTOR:{
1166 struct gl_texture_object *t =
1167 ctx->Texture.Unit[state[2]].CurrentRect;
1168
1169 if (t && t->Image[0][t->BaseLevel]) {
1170 struct gl_texture_image *image =
1171 t->Image[0][t->BaseLevel];
1172 value[0] = 1.0 / image->Width2;
1173 value[1] = 1.0 / image->Height2;
1174 } else {
1175 value[0] = 1.0;
1176 value[1] = 1.0;
1177 }
1178 value[2] = 1.0;
1179 value[3] = 1.0;
1180 break;
1181 }
1182
1183 default:
1184 break;
1185 }
1186 break;
1187
1188 default:
1189 break;
1190 }
1191 }
1192
1193 /**
1194 * Update R300's own internal state parameters.
1195 * For now just STATE_R300_WINDOW_DIMENSION
1196 */
1197 void r300UpdateStateParameters(GLcontext * ctx, GLuint new_state)
1198 {
1199 struct r300_fragment_program *fp;
1200 struct gl_program_parameter_list *paramList;
1201 GLuint i;
1202
1203 if (!(new_state & (_NEW_BUFFERS | _NEW_PROGRAM)))
1204 return;
1205
1206 fp = (struct r300_fragment_program *)ctx->FragmentProgram._Current;
1207 if (!fp)
1208 return;
1209
1210 paramList = fp->mesa_program.Base.Parameters;
1211
1212 if (!paramList)
1213 return;
1214
1215 for (i = 0; i < paramList->NumParameters; i++) {
1216 if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
1217 r300FetchStateParameter(ctx,
1218 paramList->Parameters[i].
1219 StateIndexes,
1220 paramList->ParameterValues[i]);
1221 }
1222 }
1223 }
1224
1225 /* =============================================================
1226 * Polygon state
1227 */
1228 static void r300PolygonOffset(GLcontext * ctx, GLfloat factor, GLfloat units)
1229 {
1230 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1231 GLfloat constant = units;
1232
1233 switch (ctx->Visual.depthBits) {
1234 case 16:
1235 constant *= 4.0;
1236 break;
1237 case 24:
1238 constant *= 2.0;
1239 break;
1240 }
1241
1242 factor *= 12.0;
1243
1244 /* fprintf(stderr, "%s f:%f u:%f\n", __FUNCTION__, factor, constant); */
1245
1246 R300_STATECHANGE(rmesa, zbs);
1247 rmesa->hw.zbs.cmd[R300_ZBS_T_FACTOR] = r300PackFloat32(factor);
1248 rmesa->hw.zbs.cmd[R300_ZBS_T_CONSTANT] = r300PackFloat32(constant);
1249 rmesa->hw.zbs.cmd[R300_ZBS_W_FACTOR] = r300PackFloat32(factor);
1250 rmesa->hw.zbs.cmd[R300_ZBS_W_CONSTANT] = r300PackFloat32(constant);
1251 }
1252
1253 /* Routing and texture-related */
1254
1255 /* r300 doesnt handle GL_CLAMP and GL_MIRROR_CLAMP_EXT correctly when filter is NEAREST.
1256 * Since texwrap produces same results for GL_CLAMP and GL_CLAMP_TO_EDGE we use them instead.
1257 * We need to recalculate wrap modes whenever filter mode is changed because someone might do:
1258 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1259 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1260 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1261 * Since r300 completely ignores R300_TX_CLAMP when either min or mag is nearest it cant handle
1262 * combinations where only one of them is nearest.
1263 */
1264 static unsigned long gen_fixed_filter(unsigned long f)
1265 {
1266 unsigned long mag, min, needs_fixing = 0;
1267 //return f;
1268
1269 /* We ignore MIRROR bit so we dont have to do everything twice */
1270 if ((f & ((7 - 1) << R300_TX_WRAP_S_SHIFT)) ==
1271 (R300_TX_CLAMP << R300_TX_WRAP_S_SHIFT)) {
1272 needs_fixing |= 1;
1273 }
1274 if ((f & ((7 - 1) << R300_TX_WRAP_T_SHIFT)) ==
1275 (R300_TX_CLAMP << R300_TX_WRAP_T_SHIFT)) {
1276 needs_fixing |= 2;
1277 }
1278 if ((f & ((7 - 1) << R300_TX_WRAP_Q_SHIFT)) ==
1279 (R300_TX_CLAMP << R300_TX_WRAP_Q_SHIFT)) {
1280 needs_fixing |= 4;
1281 }
1282
1283 if (!needs_fixing)
1284 return f;
1285
1286 mag = f & R300_TX_MAG_FILTER_MASK;
1287 min = f & R300_TX_MIN_FILTER_MASK;
1288
1289 /* TODO: Check for anisto filters too */
1290 if ((mag != R300_TX_MAG_FILTER_NEAREST)
1291 && (min != R300_TX_MIN_FILTER_NEAREST))
1292 return f;
1293
1294 /* r300 cant handle these modes hence we force nearest to linear */
1295 if ((mag == R300_TX_MAG_FILTER_NEAREST)
1296 && (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)
1303 && (mag != R300_TX_MAG_FILTER_NEAREST)) {
1304 f &= ~R300_TX_MIN_FILTER_NEAREST;
1305 f |= R300_TX_MIN_FILTER_LINEAR;
1306 return f;
1307 }
1308
1309 /* Both are nearest */
1310 if (needs_fixing & 1) {
1311 f &= ~((7 - 1) << R300_TX_WRAP_S_SHIFT);
1312 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_S_SHIFT;
1313 }
1314 if (needs_fixing & 2) {
1315 f &= ~((7 - 1) << R300_TX_WRAP_T_SHIFT);
1316 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_T_SHIFT;
1317 }
1318 if (needs_fixing & 4) {
1319 f &= ~((7 - 1) << R300_TX_WRAP_Q_SHIFT);
1320 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_Q_SHIFT;
1321 }
1322 return f;
1323 }
1324
1325 static void r300SetupTextures(GLcontext * ctx)
1326 {
1327 int i, mtu;
1328 struct r300_tex_obj *t;
1329 r300ContextPtr r300 = R300_CONTEXT(ctx);
1330 int hw_tmu = 0;
1331 int last_hw_tmu = -1; /* -1 translates into no setup costs for fields */
1332 int tmu_mappings[R300_MAX_TEXTURE_UNITS] = { -1, };
1333 struct r300_fragment_program *fp = (struct r300_fragment_program *)
1334 (char *)ctx->FragmentProgram._Current;
1335
1336 R300_STATECHANGE(r300, txe);
1337 R300_STATECHANGE(r300, tex.filter);
1338 R300_STATECHANGE(r300, tex.filter_1);
1339 R300_STATECHANGE(r300, tex.size);
1340 R300_STATECHANGE(r300, tex.format);
1341 R300_STATECHANGE(r300, tex.pitch);
1342 R300_STATECHANGE(r300, tex.offset);
1343 R300_STATECHANGE(r300, tex.chroma_key);
1344 R300_STATECHANGE(r300, tex.border_color);
1345
1346 r300->hw.txe.cmd[R300_TXE_ENABLE] = 0x0;
1347
1348 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1349 if (RADEON_DEBUG & DEBUG_STATE)
1350 fprintf(stderr, "mtu=%d\n", mtu);
1351
1352 if (mtu > R300_MAX_TEXTURE_UNITS) {
1353 fprintf(stderr,
1354 "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1355 mtu, R300_MAX_TEXTURE_UNITS);
1356 _mesa_exit(-1);
1357 }
1358
1359 /* We cannot let disabled tmu offsets pass DRM */
1360 for (i = 0; i < mtu; i++) {
1361 if (ctx->Texture.Unit[i]._ReallyEnabled) {
1362
1363 #if 0 /* Enables old behaviour */
1364 hw_tmu = i;
1365 #endif
1366 tmu_mappings[i] = hw_tmu;
1367
1368 t = r300->state.texture.unit[i].texobj;
1369 /* XXX questionable fix for bug 9170: */
1370 if (!t)
1371 continue;
1372
1373 if ((t->format & 0xffffff00) == 0xffffff00) {
1374 WARN_ONCE
1375 ("unknown texture format (entry %x) encountered. Help me !\n",
1376 t->format & 0xff);
1377 }
1378
1379 if (RADEON_DEBUG & DEBUG_STATE)
1380 fprintf(stderr,
1381 "Activating texture unit %d\n", i);
1382
1383 r300->hw.txe.cmd[R300_TXE_ENABLE] |= (1 << hw_tmu);
1384
1385 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0 +
1386 hw_tmu] =
1387 gen_fixed_filter(t->filter) | (hw_tmu << 28);
1388 /* Currently disabled! */
1389 r300->hw.tex.filter_1.cmd[R300_TEX_VALUE_0 + hw_tmu] = 0x0; //0x20501f80;
1390 r300->hw.tex.size.cmd[R300_TEX_VALUE_0 + hw_tmu] =
1391 t->size;
1392 r300->hw.tex.format.cmd[R300_TEX_VALUE_0 +
1393 hw_tmu] = t->format;
1394 r300->hw.tex.pitch.cmd[R300_TEX_VALUE_0 + hw_tmu] =
1395 t->pitch_reg;
1396 r300->hw.tex.offset.cmd[R300_TEX_VALUE_0 +
1397 hw_tmu] = t->offset;
1398
1399 if (t->offset & R300_TXO_MACRO_TILE) {
1400 WARN_ONCE("macro tiling enabled!\n");
1401 }
1402
1403 if (t->offset & R300_TXO_MICRO_TILE) {
1404 WARN_ONCE("micro tiling enabled!\n");
1405 }
1406
1407 r300->hw.tex.chroma_key.cmd[R300_TEX_VALUE_0 +
1408 hw_tmu] = 0x0;
1409 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0 +
1410 hw_tmu] =
1411 t->pp_border_color;
1412
1413 last_hw_tmu = hw_tmu;
1414
1415 hw_tmu++;
1416 }
1417 }
1418
1419 r300->hw.tex.filter.cmd[R300_TEX_CMD_0] =
1420 cmdpacket0(R300_TX_FILTER0_0, last_hw_tmu + 1);
1421 r300->hw.tex.filter_1.cmd[R300_TEX_CMD_0] =
1422 cmdpacket0(R300_TX_FILTER1_0, last_hw_tmu + 1);
1423 r300->hw.tex.size.cmd[R300_TEX_CMD_0] =
1424 cmdpacket0(R300_TX_SIZE_0, last_hw_tmu + 1);
1425 r300->hw.tex.format.cmd[R300_TEX_CMD_0] =
1426 cmdpacket0(R300_TX_FORMAT_0, last_hw_tmu + 1);
1427 r300->hw.tex.pitch.cmd[R300_TEX_CMD_0] =
1428 cmdpacket0(R300_TX_FORMAT2_0, last_hw_tmu + 1);
1429 r300->hw.tex.offset.cmd[R300_TEX_CMD_0] =
1430 cmdpacket0(R300_TX_OFFSET_0, last_hw_tmu + 1);
1431 r300->hw.tex.chroma_key.cmd[R300_TEX_CMD_0] =
1432 cmdpacket0(R300_TX_CHROMA_KEY_0, last_hw_tmu + 1);
1433 r300->hw.tex.border_color.cmd[R300_TEX_CMD_0] =
1434 cmdpacket0(R300_TX_BORDER_COLOR_0, last_hw_tmu + 1);
1435
1436 if (!fp) /* should only happenen once, just after context is created */
1437 return;
1438
1439
1440 if (r300->radeon.radeonScreen->chip_family < CHIP_FAMILY_RV515) {
1441 R300_STATECHANGE(r300, fpt);
1442
1443 for (i = 0; i < fp->tex.length; i++) {
1444 int unit;
1445 int opcode;
1446 unsigned long val;
1447
1448 unit = fp->tex.inst[i] >> R300_FPITX_IMAGE_SHIFT;
1449 unit &= 15;
1450
1451 val = fp->tex.inst[i];
1452 val &= ~R300_FPITX_IMAGE_MASK;
1453
1454 opcode =
1455 (val & R300_FPITX_OPCODE_MASK) >> R300_FPITX_OPCODE_SHIFT;
1456 if (opcode == R300_FPITX_OP_KIL) {
1457 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1458 } else {
1459 if (tmu_mappings[unit] >= 0) {
1460 val |=
1461 tmu_mappings[unit] <<
1462 R300_FPITX_IMAGE_SHIFT;
1463 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1464 } else {
1465 // We get here when the corresponding texture image is incomplete
1466 // (e.g. incomplete mipmaps etc.)
1467 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1468 }
1469 }
1470 }
1471
1472 r300->hw.fpt.cmd[R300_FPT_CMD_0] =
1473 cmdpacket0(R300_PFS_TEXI_0, fp->tex.length);
1474 }
1475
1476 if (RADEON_DEBUG & DEBUG_STATE)
1477 fprintf(stderr, "TX_ENABLE: %08x last_hw_tmu=%d\n",
1478 r300->hw.txe.cmd[R300_TXE_ENABLE], last_hw_tmu);
1479 }
1480
1481 union r300_outputs_written {
1482 GLuint vp_outputs; /* hw_tcl_on */
1483 DECLARE_RENDERINPUTS(index_bitset); /* !hw_tcl_on */
1484 };
1485
1486 #define R300_OUTPUTS_WRITTEN_TEST(ow, vp_result, tnl_attrib) \
1487 ((hw_tcl_on) ? (ow).vp_outputs & (1 << (vp_result)) : \
1488 RENDERINPUTS_TEST( (ow.index_bitset), (tnl_attrib) ))
1489
1490 static void r300SetupRSUnit(GLcontext * ctx)
1491 {
1492 r300ContextPtr r300 = R300_CONTEXT(ctx);
1493 /* I'm still unsure if these are needed */
1494 GLuint interp_col[8];
1495 TNLcontext *tnl = TNL_CONTEXT(ctx);
1496 struct vertex_buffer *VB = &tnl->vb;
1497 union r300_outputs_written OutputsWritten;
1498 GLuint InputsRead;
1499 int fp_reg, high_rr;
1500 int col_interp_nr;
1501 int rs_tex_count = 0, rs_col_count = 0;
1502 int i, count;
1503
1504 memset(interp_col, 0, sizeof(interp_col));
1505
1506 if (hw_tcl_on)
1507 OutputsWritten.vp_outputs = CURRENT_VERTEX_SHADER(ctx)->key.OutputsWritten;
1508 else
1509 RENDERINPUTS_COPY(OutputsWritten.index_bitset, r300->state.render_inputs_bitset);
1510
1511 if (ctx->FragmentProgram._Current)
1512 InputsRead = ctx->FragmentProgram._Current->Base.InputsRead;
1513 else {
1514 fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
1515 return; /* This should only ever happen once.. */
1516 }
1517
1518 R300_STATECHANGE(r300, ri);
1519 R300_STATECHANGE(r300, rc);
1520 R300_STATECHANGE(r300, rr);
1521
1522 fp_reg = col_interp_nr = high_rr = 0;
1523
1524 r300->hw.rr.cmd[R300_RR_INST_1] = 0;
1525
1526 if (InputsRead & FRAG_BIT_WPOS) {
1527 for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
1528 if (!(InputsRead & (FRAG_BIT_TEX0 << i)))
1529 break;
1530
1531 if (i == ctx->Const.MaxTextureUnits) {
1532 fprintf(stderr, "\tno free texcoord found...\n");
1533 _mesa_exit(-1);
1534 }
1535
1536 InputsRead |= (FRAG_BIT_TEX0 << i);
1537 InputsRead &= ~FRAG_BIT_WPOS;
1538 }
1539
1540 if (InputsRead & FRAG_BIT_COL0) {
1541 count = VB->AttribPtr[_TNL_ATTRIB_COLOR0]->size;
1542 interp_col[0] |= R300_RS_COL_PTR(rs_col_count);
1543 if (count == 3)
1544 interp_col[0] |= R300_RS_COL_FMT(R300_RS_COL_FMT_RGB1);
1545 rs_col_count += count;
1546 }
1547 else
1548 interp_col[0] = R300_RS_COL_FMT(R300_RS_COL_FMT_0001);
1549
1550 if (InputsRead & FRAG_BIT_COL1) {
1551 count = VB->AttribPtr[_TNL_ATTRIB_COLOR1]->size;
1552 if (count == 3)
1553 interp_col[1] |= R300_RS_COL_FMT(R300_RS_COL_FMT_RGB1);
1554 interp_col[1] |= R300_RS_COL_PTR(1);
1555 rs_col_count += count;
1556 }
1557
1558
1559 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
1560 int swiz;
1561
1562 /* with TCL we always seem to route 4 components */
1563 if (hw_tcl_on)
1564 count = 4;
1565 else
1566 count = VB->AttribPtr[_TNL_ATTRIB_TEX(i)]->size;
1567
1568 r300->hw.ri.cmd[R300_RI_INTERP_0 + i] = interp_col[i] | rs_tex_count;
1569 switch(count) {
1570 case 4:swiz = R300_RS_SEL_S(0) | R300_RS_SEL_T(1) | R300_RS_SEL_R(2) | R300_RS_SEL_Q(3); break;
1571 case 3: swiz = R300_RS_SEL_S(0) | R300_RS_SEL_T(1) | R300_RS_SEL_R(2) | R300_RS_SEL_Q(R300_RS_SEL_K1); break;
1572 default:
1573 case 1:
1574 case 2: swiz = R300_RS_SEL_S(0) | R300_RS_SEL_T(1) | R300_RS_SEL_R(R300_RS_SEL_K0) | R300_RS_SEL_Q(R300_RS_SEL_K1); break;
1575 };
1576
1577 r300->hw.ri.cmd[R300_RI_INTERP_0 + i] |= swiz;
1578
1579 r300->hw.rr.cmd[R300_RR_INST_0 + fp_reg] = 0;
1580 if (InputsRead & (FRAG_BIT_TEX0 << i)) {
1581
1582 rs_tex_count += count;
1583
1584 //assert(r300->state.texture.tc_count != 0);
1585 r300->hw.rr.cmd[R300_RR_INST_0 + fp_reg] |= R300_RS_INST_TEX_CN_WRITE | i /* source INTERP */
1586 | (fp_reg << R300_RS_INST_TEX_ADDR_SHIFT);
1587 high_rr = fp_reg;
1588
1589 /* Passing invalid data here can lock the GPU. */
1590 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_TEX0 + i, _TNL_ATTRIB_TEX(i))) {
1591 InputsRead &= ~(FRAG_BIT_TEX0 << i);
1592 fp_reg++;
1593 } else {
1594 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i);
1595 }
1596 }
1597 }
1598
1599 if (InputsRead & FRAG_BIT_COL0) {
1600 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL0, _TNL_ATTRIB_COLOR0)) {
1601 r300->hw.rr.cmd[R300_RR_INST_0] |= R300_RS_INST_COL_ID(0) | R300_RS_INST_COL_CN_WRITE | (fp_reg++ << R300_RS_INST_COL_ADDR_SHIFT);
1602 InputsRead &= ~FRAG_BIT_COL0;
1603 col_interp_nr++;
1604 } else {
1605 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1606 }
1607 }
1608
1609 if (InputsRead & FRAG_BIT_COL1) {
1610 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL1, _TNL_ATTRIB_COLOR1)) {
1611 r300->hw.rr.cmd[R300_RR_INST_1] |= R300_RS_INST_COL_ID(1) | R300_RS_INST_COL_CN_WRITE | (fp_reg++ << R300_RS_INST_COL_ADDR_SHIFT);
1612 InputsRead &= ~FRAG_BIT_COL1;
1613 if (high_rr < 1)
1614 high_rr = 1;
1615 col_interp_nr++;
1616 } else {
1617 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1618 }
1619 }
1620
1621 /* Need at least one. This might still lock as the values are undefined... */
1622 if (rs_tex_count == 0 && col_interp_nr == 0) {
1623 r300->hw.rr.cmd[R300_RR_INST_0] |= R300_RS_INST_COL_ID(0) | R300_RS_INST_COL_CN_WRITE | (fp_reg++ << R300_RS_INST_COL_ADDR_SHIFT);
1624 col_interp_nr++;
1625 }
1626
1627 r300->hw.rc.cmd[1] = 0 | (rs_tex_count << R300_IT_COUNT_SHIFT)
1628 | (col_interp_nr << R300_IC_COUNT_SHIFT)
1629 | R300_HIRES_EN;
1630
1631 assert(high_rr >= 0);
1632 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(R300_RS_INST_0, high_rr + 1);
1633 r300->hw.rc.cmd[2] = high_rr;
1634
1635 if (InputsRead)
1636 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead);
1637 }
1638
1639 static void r500SetupRSUnit(GLcontext * ctx)
1640 {
1641 r300ContextPtr r300 = R300_CONTEXT(ctx);
1642 /* I'm still unsure if these are needed */
1643 GLuint interp_col[8];
1644 union r300_outputs_written OutputsWritten;
1645 TNLcontext *tnl = TNL_CONTEXT(ctx);
1646 struct vertex_buffer *VB = &tnl->vb;
1647 GLuint InputsRead;
1648 int fp_reg, high_rr;
1649 int rs_tex_count = 0, rs_col_count = 0;
1650 int in_texcoords, col_interp_nr;
1651 int i, count;
1652
1653 memset(interp_col, 0, sizeof(interp_col));
1654 if (hw_tcl_on)
1655 OutputsWritten.vp_outputs = CURRENT_VERTEX_SHADER(ctx)->key.OutputsWritten;
1656 else
1657 RENDERINPUTS_COPY(OutputsWritten.index_bitset, r300->state.render_inputs_bitset);
1658
1659 if (ctx->FragmentProgram._Current)
1660 InputsRead = ctx->FragmentProgram._Current->Base.InputsRead;
1661 else {
1662 fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
1663 return; /* This should only ever happen once.. */
1664 }
1665
1666 R300_STATECHANGE(r300, ri);
1667 R300_STATECHANGE(r300, rc);
1668 R300_STATECHANGE(r300, rr);
1669
1670 fp_reg = col_interp_nr = high_rr = in_texcoords = 0;
1671
1672 r300->hw.rr.cmd[R300_RR_INST_1] = 0;
1673
1674 if (InputsRead & FRAG_BIT_WPOS) {
1675 for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
1676 if (!(InputsRead & (FRAG_BIT_TEX0 << i)))
1677 break;
1678
1679 if (i == ctx->Const.MaxTextureUnits) {
1680 fprintf(stderr, "\tno free texcoord found...\n");
1681 _mesa_exit(-1);
1682 }
1683
1684 InputsRead |= (FRAG_BIT_TEX0 << i);
1685 InputsRead &= ~FRAG_BIT_WPOS;
1686 }
1687
1688 if (InputsRead & FRAG_BIT_COL0) {
1689 count = VB->AttribPtr[_TNL_ATTRIB_COLOR0]->size;
1690 interp_col[0] |= R500_RS_COL_PTR(rs_col_count);
1691 if (count == 3)
1692 interp_col[0] |= R500_RS_COL_FMT(R300_RS_COL_FMT_RGB1);
1693 rs_col_count += count;
1694 }
1695 else
1696 interp_col[0] = R500_RS_COL_FMT(R300_RS_COL_FMT_0001);
1697
1698 if (InputsRead & FRAG_BIT_COL1) {
1699 count = VB->AttribPtr[_TNL_ATTRIB_COLOR1]->size;
1700 interp_col[1] |= R500_RS_COL_PTR(1);
1701 if (count == 3)
1702 interp_col[1] |= R500_RS_COL_FMT(R300_RS_COL_FMT_RGB1);
1703 rs_col_count += count;
1704 }
1705
1706 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
1707 GLuint swiz;
1708
1709 /* with TCL we always seem to route 4 components */
1710 if (InputsRead & (FRAG_BIT_TEX0 << i)) {
1711
1712 if (hw_tcl_on)
1713 count = 4;
1714 else
1715 count = VB->AttribPtr[_TNL_ATTRIB_TEX(i)]->size;
1716
1717 swiz = 0;
1718 if (count == 4)
1719 swiz |= in_texcoords++ << R500_RS_IP_TEX_PTR_Q_SHIFT;
1720 else
1721 swiz |= R500_RS_IP_PTR_K1 << R500_RS_IP_TEX_PTR_Q_SHIFT;
1722
1723 if (count >= 3)
1724 swiz |= in_texcoords++ << R500_RS_IP_TEX_PTR_R_SHIFT;
1725 else
1726 swiz |= R500_RS_IP_PTR_K0 << R500_RS_IP_TEX_PTR_R_SHIFT;
1727
1728 /* always have a least 2 tex coords */
1729 swiz |= in_texcoords++ << R500_RS_IP_TEX_PTR_T_SHIFT;
1730 swiz |= in_texcoords++ << R500_RS_IP_TEX_PTR_S_SHIFT;
1731 }
1732 r300->hw.ri.cmd[R300_RI_INTERP_0 + i] = interp_col[i] | rs_tex_count | swiz;
1733
1734 r300->hw.rr.cmd[R300_RR_INST_0 + fp_reg] = 0;
1735 if (InputsRead & (FRAG_BIT_TEX0 << i)) {
1736 //assert(r300->state.texture.tc_count != 0);
1737 r300->hw.rr.cmd[R300_RR_INST_0 + fp_reg] |= R500_RS_INST_TEX_CN_WRITE | i /* source INTERP */
1738 | (fp_reg << R500_RS_INST_TEX_ADDR_SHIFT);
1739 high_rr = fp_reg;
1740
1741 /* Passing invalid data here can lock the GPU. */
1742 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_TEX0 + i, _TNL_ATTRIB_TEX(i))) {
1743 InputsRead &= ~(FRAG_BIT_TEX0 << i);
1744 fp_reg++;
1745 } else {
1746 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i);
1747 }
1748 }
1749 }
1750
1751 if (InputsRead & FRAG_BIT_COL0) {
1752 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL0, _TNL_ATTRIB_COLOR0)) {
1753 r300->hw.rr.cmd[R300_RR_INST_0] |= R500_RS_INST_COL_CN_WRITE | (fp_reg++ << R500_RS_INST_COL_ADDR_SHIFT);
1754 InputsRead &= ~FRAG_BIT_COL0;
1755 col_interp_nr++;
1756 } else {
1757 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1758 }
1759 }
1760
1761 if (InputsRead & FRAG_BIT_COL1) {
1762 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL1, _TNL_ATTRIB_COLOR1)) {
1763 r300->hw.rr.cmd[R300_RR_INST_1] |= (1 << 12) | R500_RS_INST_COL_CN_WRITE | (fp_reg++ << R500_RS_INST_COL_ADDR_SHIFT);
1764 InputsRead &= ~FRAG_BIT_COL1;
1765 if (high_rr < 1)
1766 high_rr = 1;
1767 col_interp_nr++;
1768 } else {
1769 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1770 }
1771 }
1772
1773 /* Need at least one. This might still lock as the values are undefined... */
1774 if (in_texcoords == 0 && col_interp_nr == 0) {
1775 r300->hw.rr.cmd[R300_RR_INST_0] |= 0 | R500_RS_INST_COL_CN_WRITE | (fp_reg++ << R500_RS_INST_COL_ADDR_SHIFT);
1776 col_interp_nr++;
1777 }
1778
1779 r300->hw.rc.cmd[1] = 0 | (rs_tex_count << R300_IT_COUNT_SHIFT)
1780 | (col_interp_nr << R300_IC_COUNT_SHIFT)
1781 | R300_HIRES_EN;
1782
1783 assert(high_rr >= 0);
1784 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(R300_RS_INST_0, high_rr + 1);
1785 r300->hw.rc.cmd[2] = 0xC0 | high_rr;
1786
1787 if (InputsRead)
1788 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead);
1789 }
1790
1791
1792
1793
1794 #define bump_vpu_count(ptr, new_count) do{\
1795 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1796 int _nc=(new_count)/4; \
1797 assert(_nc < 256); \
1798 if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1799 }while(0)
1800
1801 static inline void r300SetupVertexProgramFragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1802 {
1803 int i;
1804
1805 if (vsf->length == 0)
1806 return;
1807
1808 if (vsf->length & 0x3) {
1809 fprintf(stderr, "VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1810 _mesa_exit(-1);
1811 }
1812
1813 switch ((dest >> 8) & 0xf) {
1814 case 0:
1815 R300_STATECHANGE(r300, vpi);
1816 for (i = 0; i < vsf->length; i++)
1817 r300->hw.vpi.cmd[R300_VPI_INSTR_0 + i + 4 * (dest & 0xff)] = (vsf->body.d[i]);
1818 bump_vpu_count(r300->hw.vpi.cmd, vsf->length + 4 * (dest & 0xff));
1819 break;
1820
1821 case 2:
1822 R300_STATECHANGE(r300, vpp);
1823 for (i = 0; i < vsf->length; i++)
1824 r300->hw.vpp.cmd[R300_VPP_PARAM_0 + i + 4 * (dest & 0xff)] = (vsf->body.d[i]);
1825 bump_vpu_count(r300->hw.vpp.cmd, vsf->length + 4 * (dest & 0xff));
1826 break;
1827 case 4:
1828 R300_STATECHANGE(r300, vps);
1829 for (i = 0; i < vsf->length; i++)
1830 r300->hw.vps.cmd[1 + i + 4 * (dest & 0xff)] = (vsf->body.d[i]);
1831 bump_vpu_count(r300->hw.vps.cmd, vsf->length + 4 * (dest & 0xff));
1832 break;
1833 default:
1834 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1835 _mesa_exit(-1);
1836 }
1837 }
1838
1839 #define MIN3(a,b,c) ((a)<(b) ? MIN2(a, c): MIN2(b, c))
1840
1841 static void r300VapCntl(r300ContextPtr rmesa, GLuint input_count, GLuint output_count, GLuint temp_count)
1842 {
1843 int vtx_mem_size;
1844 int cmd_reserved = 0;
1845 int cmd_written = 0;
1846 drm_radeon_cmd_header_t *cmd = NULL;
1847 int pvs_num_slots;
1848 int pvs_num_cntrls;
1849
1850 /* Flush PVS engine before changing PVS_NUM_SLOTS, PVS_NUM_CNTRLS.
1851 * See r500 docs 6.5.2 */
1852 reg_start(R300_VAP_PVS_WAITIDLE, 0);
1853 e32(0x00000000);
1854
1855 /* avoid division by zero */
1856 if (input_count == 0) input_count = 1;
1857 if (output_count == 0) output_count = 1;
1858 if (temp_count == 0) temp_count = 1;
1859
1860 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)
1861 vtx_mem_size = 128;
1862 else
1863 vtx_mem_size = 72;
1864
1865 pvs_num_slots = MIN3(10, vtx_mem_size/input_count, vtx_mem_size/output_count);
1866 pvs_num_cntrls = MIN2(6, vtx_mem_size/temp_count);
1867
1868 R300_STATECHANGE(rmesa, vap_cntl);
1869 if (rmesa->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL) {
1870 rmesa->hw.vap_cntl.cmd[1] =
1871 (pvs_num_slots << R300_PVS_NUM_SLOTS_SHIFT) |
1872 (pvs_num_cntrls << R300_PVS_NUM_CNTLRS_SHIFT) |
1873 (12 << R300_VF_MAX_VTX_NUM_SHIFT);
1874 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)
1875 rmesa->hw.vap_cntl.cmd[1] |= R500_TCL_STATE_OPTIMIZATION;
1876 } else
1877 /* not sure about non-tcl */
1878 rmesa->hw.vap_cntl.cmd[1] = ((10 << R300_PVS_NUM_SLOTS_SHIFT) |
1879 (5 << R300_PVS_NUM_CNTLRS_SHIFT) |
1880 (5 << R300_VF_MAX_VTX_NUM_SHIFT));
1881
1882 if (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV515)
1883 rmesa->hw.vap_cntl.cmd[1] |= (2 << R300_PVS_NUM_FPUS_SHIFT);
1884 else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV530) ||
1885 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV560))
1886 rmesa->hw.vap_cntl.cmd[1] |= (5 << R300_PVS_NUM_FPUS_SHIFT);
1887 else if (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R420)
1888 rmesa->hw.vap_cntl.cmd[1] |= (6 << R300_PVS_NUM_FPUS_SHIFT);
1889 else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R520) ||
1890 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R580) ||
1891 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV570))
1892 rmesa->hw.vap_cntl.cmd[1] |= (8 << R300_PVS_NUM_FPUS_SHIFT);
1893 else
1894 rmesa->hw.vap_cntl.cmd[1] |= (4 << R300_PVS_NUM_FPUS_SHIFT);
1895
1896 }
1897
1898 static void r300SetupDefaultVertexProgram(r300ContextPtr rmesa)
1899 {
1900 struct r300_vertex_shader_state *prog = &(rmesa->state.vertex_shader);
1901 GLuint o_reg = 0;
1902 GLuint i_reg = 0;
1903 int i;
1904 int inst_count = 0;
1905 int param_count = 0;
1906 int program_end = 0;
1907
1908 for (i = VERT_ATTRIB_POS; i < VERT_ATTRIB_MAX; i++) {
1909 if (rmesa->state.sw_tcl_inputs[i] != -1) {
1910 prog->program.body.i[program_end + 0] = PVS_OP_DST_OPERAND(VE_MULTIPLY, GL_FALSE, GL_FALSE, o_reg++, VSF_FLAG_ALL, PVS_DST_REG_OUT);
1911 prog->program.body.i[program_end + 1] = PVS_SRC_OPERAND(rmesa->state.sw_tcl_inputs[i], PVS_SRC_SELECT_X, PVS_SRC_SELECT_Y, PVS_SRC_SELECT_Z, PVS_SRC_SELECT_W, PVS_SRC_REG_INPUT, VSF_FLAG_NONE);
1912 prog->program.body.i[program_end + 2] = PVS_SRC_OPERAND(rmesa->state.sw_tcl_inputs[i], PVS_SRC_SELECT_FORCE_1, PVS_SRC_SELECT_FORCE_1, PVS_SRC_SELECT_FORCE_1, PVS_SRC_SELECT_FORCE_1, PVS_SRC_REG_INPUT, VSF_FLAG_NONE);
1913 prog->program.body.i[program_end + 3] = PVS_SRC_OPERAND(rmesa->state.sw_tcl_inputs[i], PVS_SRC_SELECT_FORCE_1, PVS_SRC_SELECT_FORCE_1, PVS_SRC_SELECT_FORCE_1, PVS_SRC_SELECT_FORCE_1, PVS_SRC_REG_INPUT, VSF_FLAG_NONE);
1914 program_end += 4;
1915 i_reg++;
1916 }
1917 }
1918
1919 prog->program.length = program_end;
1920
1921 r300SetupVertexProgramFragment(rmesa, R300_PVS_CODE_START,
1922 &(prog->program));
1923 inst_count = (prog->program.length / 4) - 1;
1924
1925 r300VapCntl(rmesa, i_reg, o_reg, 0);
1926
1927 R300_STATECHANGE(rmesa, pvs);
1928 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1] =
1929 (0 << R300_PVS_CNTL_1_PROGRAM_START_SHIFT) |
1930 (inst_count << R300_PVS_CNTL_1_POS_END_SHIFT) |
1931 (inst_count << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1932 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2] =
1933 (0 << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT) |
1934 (param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1935 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3] =
1936 (inst_count << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT) |
1937 (inst_count << R300_PVS_CNTL_3_PROGRAM_UNKNOWN2_SHIFT);
1938 }
1939
1940 static int bit_count (int x)
1941 {
1942 x = ((x & 0xaaaaaaaaU) >> 1) + (x & 0x55555555U);
1943 x = ((x & 0xccccccccU) >> 2) + (x & 0x33333333U);
1944 x = (x >> 16) + (x & 0xffff);
1945 x = ((x & 0xf0f0) >> 4) + (x & 0x0f0f);
1946 return (x >> 8) + (x & 0x00ff);
1947 }
1948
1949 static void r300SetupRealVertexProgram(r300ContextPtr rmesa)
1950 {
1951 GLcontext *ctx = rmesa->radeon.glCtx;
1952 struct r300_vertex_program *prog = (struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx);
1953 int inst_count = 0;
1954 int param_count = 0;
1955
1956 /* FIXME: r300SetupVertexProgramFragment */
1957 R300_STATECHANGE(rmesa, vpp);
1958 param_count =
1959 r300VertexProgUpdateParams(ctx,
1960 (struct r300_vertex_program_cont *)
1961 ctx->VertexProgram._Current,
1962 (float *)&rmesa->hw.vpp.
1963 cmd[R300_VPP_PARAM_0]);
1964 bump_vpu_count(rmesa->hw.vpp.cmd, param_count);
1965 param_count /= 4;
1966
1967 r300SetupVertexProgramFragment(rmesa, R300_PVS_CODE_START, &(prog->program));
1968 inst_count = (prog->program.length / 4) - 1;
1969
1970 r300VapCntl(rmesa, bit_count(prog->key.InputsRead),
1971 bit_count(prog->key.OutputsWritten), prog->num_temporaries);
1972
1973 R300_STATECHANGE(rmesa, pvs);
1974 rmesa->hw.pvs.cmd[R300_PVS_CNTL_1] =
1975 (0 << R300_PVS_CNTL_1_PROGRAM_START_SHIFT) |
1976 (inst_count << R300_PVS_CNTL_1_POS_END_SHIFT) |
1977 (inst_count << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1978 rmesa->hw.pvs.cmd[R300_PVS_CNTL_2] =
1979 (0 << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT) |
1980 (param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1981 rmesa->hw.pvs.cmd[R300_PVS_CNTL_3] =
1982 (inst_count << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT) |
1983 (inst_count << R300_PVS_CNTL_3_PROGRAM_UNKNOWN2_SHIFT);
1984 }
1985
1986 static void r300SetupVertexProgram(r300ContextPtr rmesa)
1987 {
1988 GLcontext *ctx = rmesa->radeon.glCtx;
1989
1990 /* Reset state, in case we don't use something */
1991 ((drm_r300_cmd_header_t *) rmesa->hw.vpp.cmd)->vpu.count = 0;
1992 ((drm_r300_cmd_header_t *) rmesa->hw.vpi.cmd)->vpu.count = 0;
1993 ((drm_r300_cmd_header_t *) rmesa->hw.vps.cmd)->vpu.count = 0;
1994
1995 /* Not sure why this doesnt work...
1996 0x400 area might have something to do with pixel shaders as it appears right after pfs programming.
1997 0x406 is set to { 0.0, 0.0, 1.0, 0.0 } most of the time but should change with smooth points and in other rare cases. */
1998 //setup_vertex_shader_fragment(rmesa, 0x406, &unk4);
1999 if (hw_tcl_on && ((struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx))->translated) {
2000 r300SetupRealVertexProgram(rmesa);
2001 } else {
2002 /* FIXME: This needs to be replaced by vertex shader generation code. */
2003 r300SetupDefaultVertexProgram(rmesa);
2004 }
2005
2006 }
2007
2008 /**
2009 * Enable/Disable states.
2010 *
2011 * \note Mesa already filters redundant calls to this function.
2012 */
2013 static void r300Enable(GLcontext * ctx, GLenum cap, GLboolean state)
2014 {
2015 if (RADEON_DEBUG & DEBUG_STATE)
2016 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
2017 _mesa_lookup_enum_by_nr(cap),
2018 state ? "GL_TRUE" : "GL_FALSE");
2019
2020 switch (cap) {
2021 case GL_TEXTURE_1D:
2022 case GL_TEXTURE_2D:
2023 case GL_TEXTURE_3D:
2024 /* empty */
2025 break;
2026 case GL_FOG:
2027 r300SetFogState(ctx, state);
2028 break;
2029 case GL_ALPHA_TEST:
2030 r300SetAlphaState(ctx);
2031 break;
2032 case GL_BLEND:
2033 case GL_COLOR_LOGIC_OP:
2034 r300SetBlendState(ctx);
2035 break;
2036 case GL_CLIP_PLANE0:
2037 case GL_CLIP_PLANE1:
2038 case GL_CLIP_PLANE2:
2039 case GL_CLIP_PLANE3:
2040 case GL_CLIP_PLANE4:
2041 case GL_CLIP_PLANE5:
2042 r300SetClipPlaneState(ctx, cap, state);
2043 break;
2044 case GL_DEPTH_TEST:
2045 r300SetDepthState(ctx);
2046 break;
2047 case GL_STENCIL_TEST:
2048 r300SetStencilState(ctx, state);
2049 break;
2050 case GL_CULL_FACE:
2051 r300UpdateCulling(ctx);
2052 break;
2053 case GL_POLYGON_OFFSET_POINT:
2054 case GL_POLYGON_OFFSET_LINE:
2055 case GL_POLYGON_OFFSET_FILL:
2056 r300SetPolygonOffsetState(ctx, state);
2057 break;
2058 default:
2059 radeonEnable(ctx, cap, state);
2060 break;
2061 }
2062 }
2063
2064 /**
2065 * Completely recalculates hardware state based on the Mesa state.
2066 */
2067 static void r300ResetHwState(r300ContextPtr r300)
2068 {
2069 GLcontext *ctx = r300->radeon.glCtx;
2070 int has_tcl = 1;
2071
2072 if (!(r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL))
2073 has_tcl = 0;
2074
2075 if (RADEON_DEBUG & DEBUG_STATE)
2076 fprintf(stderr, "%s\n", __FUNCTION__);
2077
2078 r300UpdateWindow(ctx);
2079
2080 r300ColorMask(ctx,
2081 ctx->Color.ColorMask[RCOMP],
2082 ctx->Color.ColorMask[GCOMP],
2083 ctx->Color.ColorMask[BCOMP], ctx->Color.ColorMask[ACOMP]);
2084
2085 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
2086 r300DepthMask(ctx, ctx->Depth.Mask);
2087 r300DepthFunc(ctx, ctx->Depth.Func);
2088
2089 /* stencil */
2090 r300Enable(ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled);
2091 r300StencilMaskSeparate(ctx, 0, ctx->Stencil.WriteMask[0]);
2092 r300StencilFuncSeparate(ctx, 0, ctx->Stencil.Function[0],
2093 ctx->Stencil.Ref[0], ctx->Stencil.ValueMask[0]);
2094 r300StencilOpSeparate(ctx, 0, ctx->Stencil.FailFunc[0],
2095 ctx->Stencil.ZFailFunc[0],
2096 ctx->Stencil.ZPassFunc[0]);
2097
2098 r300UpdateCulling(ctx);
2099
2100 r300UpdateTextureState(ctx);
2101
2102 r300SetBlendState(ctx);
2103
2104 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
2105 r300Enable(ctx, GL_ALPHA_TEST, ctx->Color.AlphaEnabled);
2106
2107 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
2108 | R300_VPORT_X_OFFSET_ENA
2109 | R300_VPORT_Y_SCALE_ENA
2110 | R300_VPORT_Y_OFFSET_ENA
2111 | R300_VPORT_Z_SCALE_ENA
2112 | R300_VPORT_Z_OFFSET_ENA | R300_VTX_W0_FMT;
2113 r300->hw.vte.cmd[2] = 0x00000008;
2114
2115 r300->hw.vap_vf_max_vtx_indx.cmd[1] = 0x00FFFFFF;
2116 r300->hw.vap_vf_max_vtx_indx.cmd[2] = 0x00000000;
2117
2118 #ifdef MESA_LITTLE_ENDIAN
2119 r300->hw.vap_cntl_status.cmd[1] = R300_VC_NO_SWAP;
2120 #else
2121 r300->hw.vap_cntl_status.cmd[1] = R300_VC_32BIT_SWAP;
2122 #endif
2123
2124 /* disable VAP/TCL on non-TCL capable chips */
2125 if (!has_tcl)
2126 r300->hw.vap_cntl_status.cmd[1] |= R300_VAP_TCL_BYPASS;
2127
2128 r300->hw.vap_psc_sgn_norm_cntl.cmd[1] = 0xAAAAAAAA;
2129
2130 /* XXX: Other families? */
2131 if (has_tcl) {
2132 r300->hw.vap_clip_cntl.cmd[1] = R300_PS_UCP_MODE_DIST_COP;
2133
2134 r300->hw.vap_clip.cmd[1] = r300PackFloat32(1.0); /* X */
2135 r300->hw.vap_clip.cmd[2] = r300PackFloat32(1.0); /* X */
2136 r300->hw.vap_clip.cmd[3] = r300PackFloat32(1.0); /* Y */
2137 r300->hw.vap_clip.cmd[4] = r300PackFloat32(1.0); /* Y */
2138
2139 switch (r300->radeon.radeonScreen->chip_family) {
2140 case CHIP_FAMILY_R300:
2141 r300->hw.vap_pvs_vtx_timeout_reg.cmd[1] = R300_2288_R300;
2142 break;
2143 default:
2144 r300->hw.vap_pvs_vtx_timeout_reg.cmd[1] = R300_2288_RV350;
2145 break;
2146 }
2147 }
2148
2149 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
2150 | R300_GB_LINE_STUFF_ENABLE
2151 | R300_GB_TRIANGLE_STUFF_ENABLE;
2152
2153 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
2154 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
2155
2156 /* num pipes needs to be read back from the GB_PIPE_SELECT register
2157 * on r4xx/r5xx/rs4xx/rs6xx
2158 * should move this to the drm
2159 */
2160 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] =
2161 R300_GB_TILE_ENABLE | R300_GB_TILE_SIZE_16 /*| R300_GB_SUBPIXEL_1_16*/;
2162 switch (r300->radeon.radeonScreen->chip_family) {
2163 case CHIP_FAMILY_R300:
2164 case CHIP_FAMILY_R350:
2165 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
2166 R300_GB_TILE_PIPE_COUNT_R300;
2167 break;
2168 case CHIP_FAMILY_RV350:
2169 case CHIP_FAMILY_RV515:
2170 case CHIP_FAMILY_RV530:
2171 case CHIP_FAMILY_RV410:
2172 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
2173 R300_GB_TILE_PIPE_COUNT_RV300;
2174 break;
2175 case CHIP_FAMILY_R420:
2176 case CHIP_FAMILY_R520:
2177 case CHIP_FAMILY_R580:
2178 case CHIP_FAMILY_RV560:
2179 case CHIP_FAMILY_RV570:
2180 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
2181 R300_GB_TILE_PIPE_COUNT_R420;
2182 break;
2183 default:
2184 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
2185 R300_GB_TILE_DISABLE; /* TODO: This disables tiling totally. I guess it happened accidentially. */
2186 break;
2187 }
2188
2189 /* XXX: set to 0 when fog is disabled? */
2190 r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = R300_GB_FOG_SELECT_1_1_W;
2191
2192 /* XXX: Enable anti-aliasing? */
2193 r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = GB_AA_CONFIG_AA_DISABLE;
2194
2195 r300->hw.ga_point_s0.cmd[1] = r300PackFloat32(0.0);
2196 r300->hw.ga_point_s0.cmd[2] = r300PackFloat32(0.0);
2197 r300->hw.ga_point_s0.cmd[3] = r300PackFloat32(1.0);
2198 r300->hw.ga_point_s0.cmd[4] = r300PackFloat32(1.0);
2199
2200 r300->hw.ga_triangle_stipple.cmd[1] = 0x00050005;
2201
2202 r300PointSize(ctx, 1.0);
2203
2204 r300->hw.ga_point_minmax.cmd[1] = 0x18000006;
2205 r300->hw.ga_point_minmax.cmd[2] = 0x00020006;
2206 r300->hw.ga_point_minmax.cmd[3] = r300PackFloat32(1.0 / 192.0);
2207
2208 r300LineWidth(ctx, 1.0);
2209
2210 r300->hw.ga_line_stipple.cmd[1] = 0;
2211 r300->hw.ga_line_stipple.cmd[2] = r300PackFloat32(0.0);
2212 r300->hw.ga_line_stipple.cmd[3] = r300PackFloat32(1.0);
2213
2214 r300ShadeModel(ctx, ctx->Light.ShadeModel);
2215
2216 r300PolygonMode(ctx, GL_FRONT, ctx->Polygon.FrontMode);
2217 r300PolygonMode(ctx, GL_BACK, ctx->Polygon.BackMode);
2218 r300->hw.zbias_cntl.cmd[1] = 0x00000000;
2219
2220 r300PolygonOffset(ctx, ctx->Polygon.OffsetFactor,
2221 ctx->Polygon.OffsetUnits);
2222 r300Enable(ctx, GL_POLYGON_OFFSET_POINT, ctx->Polygon.OffsetPoint);
2223 r300Enable(ctx, GL_POLYGON_OFFSET_LINE, ctx->Polygon.OffsetLine);
2224 r300Enable(ctx, GL_POLYGON_OFFSET_FILL, ctx->Polygon.OffsetFill);
2225
2226 r300->hw.su_depth_scale.cmd[1] = 0x4B7FFFFF;
2227 r300->hw.su_depth_scale.cmd[2] = 0x00000000;
2228
2229 r300->hw.sc_hyperz.cmd[1] = 0x0000001C;
2230 r300->hw.sc_hyperz.cmd[2] = 0x2DA49525;
2231
2232 r300->hw.sc_screendoor.cmd[1] = 0x00FFFFFF;
2233
2234 r300->hw.us_out_fmt.cmd[1] = 0x00001B01;
2235 r300->hw.us_out_fmt.cmd[2] = 0x00001B0F;
2236 r300->hw.us_out_fmt.cmd[3] = 0x00001B0F;
2237 r300->hw.us_out_fmt.cmd[4] = 0x00001B0F;
2238 r300->hw.us_out_fmt.cmd[5] = 0x00000001;
2239
2240 r300Enable(ctx, GL_FOG, ctx->Fog.Enabled);
2241 r300Fogfv(ctx, GL_FOG_MODE, NULL);
2242 r300Fogfv(ctx, GL_FOG_DENSITY, &ctx->Fog.Density);
2243 r300Fogfv(ctx, GL_FOG_START, &ctx->Fog.Start);
2244 r300Fogfv(ctx, GL_FOG_END, &ctx->Fog.End);
2245 r300Fogfv(ctx, GL_FOG_COLOR, ctx->Fog.Color);
2246 r300Fogfv(ctx, GL_FOG_COORDINATE_SOURCE_EXT, NULL);
2247
2248 r300->hw.fg_depth_src.cmd[1] = 0;
2249
2250 r300->hw.rb3d_cctl.cmd[1] = 0;
2251
2252 r300BlendColor(ctx, ctx->Color.BlendColor);
2253
2254 /* Again, r300ClearBuffer uses this */
2255 r300->hw.cb.cmd[R300_CB_OFFSET] =
2256 r300->radeon.state.color.drawOffset +
2257 r300->radeon.radeonScreen->fbLocation;
2258 r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.state.color.drawPitch;
2259
2260 if (r300->radeon.radeonScreen->cpp == 4)
2261 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_FORMAT_ARGB8888;
2262 else
2263 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_FORMAT_RGB565;
2264
2265 if (r300->radeon.sarea->tiling_enabled)
2266 r300->hw.cb.cmd[R300_CB_PITCH] |= R300_COLOR_TILE_ENABLE;
2267
2268 r300->hw.rb3d_dither_ctl.cmd[1] = 0;
2269 r300->hw.rb3d_dither_ctl.cmd[2] = 0;
2270 r300->hw.rb3d_dither_ctl.cmd[3] = 0;
2271 r300->hw.rb3d_dither_ctl.cmd[4] = 0;
2272 r300->hw.rb3d_dither_ctl.cmd[5] = 0;
2273 r300->hw.rb3d_dither_ctl.cmd[6] = 0;
2274 r300->hw.rb3d_dither_ctl.cmd[7] = 0;
2275 r300->hw.rb3d_dither_ctl.cmd[8] = 0;
2276 r300->hw.rb3d_dither_ctl.cmd[9] = 0;
2277
2278 r300->hw.rb3d_aaresolve_ctl.cmd[1] = 0;
2279
2280 r300->hw.rb3d_discard_src_pixel_lte_threshold.cmd[1] = 0x00000000;
2281 r300->hw.rb3d_discard_src_pixel_lte_threshold.cmd[2] = 0xffffffff;
2282
2283 r300->hw.zb.cmd[R300_ZB_OFFSET] =
2284 r300->radeon.radeonScreen->depthOffset +
2285 r300->radeon.radeonScreen->fbLocation;
2286 r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
2287
2288 if (r300->radeon.sarea->tiling_enabled) {
2289 /* XXX: Turn off when clearing buffers ? */
2290 r300->hw.zb.cmd[R300_ZB_PITCH] |= ZB_DEPTHPITCH_DEPTHMACROTILE_ENABLE;
2291
2292 if (ctx->Visual.depthBits == 24)
2293 r300->hw.zb.cmd[R300_ZB_PITCH] |=
2294 ZB_DEPTHPITCH_DEPTHMICROTILE_TILED;
2295 }
2296
2297 r300->hw.zb_depthclearvalue.cmd[1] = 0;
2298
2299 r300->hw.unk4F30.cmd[1] = 0;
2300 r300->hw.unk4F30.cmd[2] = 0;
2301
2302 r300->hw.zb_hiz_offset.cmd[1] = 0;
2303
2304 r300->hw.zb_hiz_pitch.cmd[1] = 0;
2305
2306 if (has_tcl) {
2307 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
2308 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
2309 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
2310 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
2311 }
2312
2313 r300->hw.all_dirty = GL_TRUE;
2314 }
2315
2316 void r300UpdateShaders(r300ContextPtr rmesa)
2317 {
2318 GLcontext *ctx;
2319 struct r300_vertex_program *vp;
2320 int i;
2321
2322 ctx = rmesa->radeon.glCtx;
2323
2324 if (rmesa->NewGLState && hw_tcl_on) {
2325 rmesa->NewGLState = 0;
2326
2327 for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) {
2328 rmesa->temp_attrib[i] =
2329 TNL_CONTEXT(ctx)->vb.AttribPtr[i];
2330 TNL_CONTEXT(ctx)->vb.AttribPtr[i] =
2331 &rmesa->dummy_attrib[i];
2332 }
2333
2334 _tnl_UpdateFixedFunctionProgram(ctx);
2335
2336 for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) {
2337 TNL_CONTEXT(ctx)->vb.AttribPtr[i] =
2338 rmesa->temp_attrib[i];
2339 }
2340
2341 r300SelectVertexShader(rmesa);
2342 vp = (struct r300_vertex_program *)
2343 CURRENT_VERTEX_SHADER(ctx);
2344 /*if (vp->translated == GL_FALSE)
2345 r300TranslateVertexShader(vp); */
2346 if (vp->translated == GL_FALSE) {
2347 fprintf(stderr, "Failing back to sw-tcl\n");
2348 hw_tcl_on = future_hw_tcl_on = 0;
2349 r300ResetHwState(rmesa);
2350
2351 r300UpdateStateParameters(ctx, _NEW_PROGRAM);
2352 return;
2353 }
2354 }
2355 r300UpdateStateParameters(ctx, _NEW_PROGRAM);
2356 }
2357
2358 static void r300SetupPixelShader(r300ContextPtr rmesa)
2359 {
2360 GLcontext *ctx = rmesa->radeon.glCtx;
2361 struct r300_fragment_program *fp = (struct r300_fragment_program *)
2362 (char *)ctx->FragmentProgram._Current;
2363 int i, k;
2364
2365 if (!fp) /* should only happenen once, just after context is created */
2366 return;
2367
2368 r300TranslateFragmentShader(rmesa, fp);
2369 if (!fp->translated) {
2370 fprintf(stderr, "%s: No valid fragment shader, exiting\n",
2371 __FUNCTION__);
2372 return;
2373 }
2374
2375 R300_STATECHANGE(rmesa, fpi[0]);
2376 rmesa->hw.fpi[0].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR0_0, fp->alu_end + 1);
2377 for (i = 0; i <= fp->alu_end; i++) {
2378 rmesa->hw.fpi[0].cmd[R300_FPI_INSTR_0 + i] = fp->alu.inst[i].inst0;
2379 }
2380
2381 R300_STATECHANGE(rmesa, fpi[1]);
2382 rmesa->hw.fpi[1].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR1_0, fp->alu_end + 1);
2383 for (i = 0; i <= fp->alu_end; i++) {
2384 rmesa->hw.fpi[1].cmd[R300_FPI_INSTR_0 + i] = fp->alu.inst[i].inst1;
2385 }
2386
2387 R300_STATECHANGE(rmesa, fpi[2]);
2388 rmesa->hw.fpi[2].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR2_0, fp->alu_end + 1);
2389 for (i = 0; i <= fp->alu_end; i++) {
2390 rmesa->hw.fpi[2].cmd[R300_FPI_INSTR_0 + i] = fp->alu.inst[i].inst2;
2391 }
2392
2393 R300_STATECHANGE(rmesa, fpi[3]);
2394 rmesa->hw.fpi[3].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR3_0, fp->alu_end + 1);
2395 for (i = 0; i <= fp->alu_end; i++) {
2396 rmesa->hw.fpi[3].cmd[R300_FPI_INSTR_0 + i] = fp->alu.inst[i].inst3;
2397 }
2398
2399 R300_STATECHANGE(rmesa, fp);
2400 rmesa->hw.fp.cmd[R300_FP_CNTL0] = fp->cur_node | (fp->first_node_has_tex << 3);
2401 rmesa->hw.fp.cmd[R300_FP_CNTL1] = fp->max_temp_idx;
2402 rmesa->hw.fp.cmd[R300_FP_CNTL2] =
2403 (fp->alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT) |
2404 (fp->alu_end << R300_PFS_CNTL_ALU_END_SHIFT) |
2405 (fp->tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT) |
2406 (fp->tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
2407 /* I just want to say, the way these nodes are stored.. weird.. */
2408 for (i = 0, k = (4 - (fp->cur_node + 1)); i < 4; i++, k++) {
2409 if (i < (fp->cur_node + 1)) {
2410 rmesa->hw.fp.cmd[R300_FP_NODE0 + k] =
2411 (fp->node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT) |
2412 (fp->node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT) |
2413 (fp->node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT) |
2414 (fp->node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT) |
2415 fp->node[i].flags;
2416 } else {
2417 rmesa->hw.fp.cmd[R300_FP_NODE0 + (3 - i)] = 0;
2418 }
2419 }
2420
2421 R300_STATECHANGE(rmesa, fpp);
2422 rmesa->hw.fpp.cmd[R300_FPP_CMD_0] = cmdpacket0(R300_PFS_PARAM_0_X, fp->const_nr * 4);
2423 for (i = 0; i < fp->const_nr; i++) {
2424 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 0] = r300PackFloat24(fp->constant[i][0]);
2425 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 1] = r300PackFloat24(fp->constant[i][1]);
2426 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 2] = r300PackFloat24(fp->constant[i][2]);
2427 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 3] = r300PackFloat24(fp->constant[i][3]);
2428 }
2429 }
2430
2431 #define bump_r500fp_count(ptr, new_count) do{\
2432 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2433 int _nc=(new_count)/6; \
2434 assert(_nc < 256); \
2435 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2436 } while(0)
2437
2438 #define bump_r500fp_const_count(ptr, new_count) do{\
2439 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2440 int _nc=(new_count)/4; \
2441 assert(_nc < 256); \
2442 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2443 } while(0)
2444
2445 static void r500SetupPixelShader(r300ContextPtr rmesa)
2446 {
2447 GLcontext *ctx = rmesa->radeon.glCtx;
2448 struct r500_fragment_program *fp = (struct r500_fragment_program *)
2449 (char *)ctx->FragmentProgram._Current;
2450 int i, k;
2451
2452 if (!fp) /* should only happenen once, just after context is created */
2453 return;
2454
2455 r500TranslateFragmentShader(rmesa, fp);
2456 if (!fp->translated) {
2457 fprintf(stderr, "%s: No valid fragment shader, exiting\n",
2458 __FUNCTION__);
2459 return;
2460 }
2461
2462 R300_STATECHANGE(rmesa, fp);
2463 rmesa->hw.fp.cmd[R500_FP_PIXSIZE] = fp->max_temp_idx;
2464
2465 R300_STATECHANGE(rmesa, r500fp);
2466 /* Emit our shader... */
2467 for (i = 0; i < fp->cs->nrslots; i++) {
2468 rmesa->hw.r500fp.cmd[i*6+1] = fp->inst[i].inst0;
2469 rmesa->hw.r500fp.cmd[i*6+2] = fp->inst[i].inst1;
2470 rmesa->hw.r500fp.cmd[i*6+3] = fp->inst[i].inst2;
2471 rmesa->hw.r500fp.cmd[i*6+4] = fp->inst[i].inst3;
2472 rmesa->hw.r500fp.cmd[i*6+5] = fp->inst[i].inst4;
2473 rmesa->hw.r500fp.cmd[i*6+6] = fp->inst[i].inst5;
2474 }
2475
2476 bump_r500fp_count(rmesa->hw.r500fp.cmd, fp->cs->nrslots * 6);
2477
2478
2479 R300_STATECHANGE(rmesa, r500fp_const);
2480 for (i = 0; i < fp->const_nr; i++) {
2481 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 0] = r300PackFloat32(fp->constant[i][0]);
2482 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 1] = r300PackFloat32(fp->constant[i][1]);
2483 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 2] = r300PackFloat32(fp->constant[i][2]);
2484 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 3] = r300PackFloat32(fp->constant[i][3]);
2485 }
2486 bump_r500fp_const_count(rmesa->hw.r500fp_const.cmd, fp->const_nr * 4);
2487
2488 }
2489
2490 void r300UpdateShaderStates(r300ContextPtr rmesa)
2491 {
2492 GLcontext *ctx;
2493 ctx = rmesa->radeon.glCtx;
2494
2495 r300UpdateTextureState(ctx);
2496
2497 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)
2498 r500SetupPixelShader(rmesa);
2499 else
2500 r300SetupPixelShader(rmesa);
2501 r300SetupTextures(ctx);
2502
2503 if ((rmesa->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL))
2504 r300SetupVertexProgram(rmesa);
2505
2506 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)
2507 r500SetupRSUnit(ctx);
2508 else
2509 r300SetupRSUnit(ctx);
2510 }
2511
2512 /**
2513 * Called by Mesa after an internal state update.
2514 */
2515 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
2516 {
2517 r300ContextPtr r300 = R300_CONTEXT(ctx);
2518
2519 _swrast_InvalidateState(ctx, new_state);
2520 _swsetup_InvalidateState(ctx, new_state);
2521 _vbo_InvalidateState(ctx, new_state);
2522 _tnl_InvalidateState(ctx, new_state);
2523 _ae_invalidate_state(ctx, new_state);
2524
2525 if (new_state & (_NEW_BUFFERS | _NEW_COLOR | _NEW_PIXEL)) {
2526 r300UpdateDrawBuffer(ctx);
2527 }
2528
2529 r300UpdateStateParameters(ctx, new_state);
2530
2531 r300->NewGLState |= new_state;
2532 }
2533
2534 /**
2535 * Calculate initial hardware state and register state functions.
2536 * Assumes that the command buffer and state atoms have been
2537 * initialized already.
2538 */
2539 void r300InitState(r300ContextPtr r300)
2540 {
2541 GLcontext *ctx = r300->radeon.glCtx;
2542 GLuint depth_fmt;
2543
2544 radeonInitState(&r300->radeon);
2545
2546 switch (ctx->Visual.depthBits) {
2547 case 16:
2548 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
2549 depth_fmt = ZB_FORMAR_DEPTHFORMAT_16BIT_INT_Z;
2550 r300->state.stencil.clear = 0x00000000;
2551 break;
2552 case 24:
2553 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
2554 depth_fmt = ZB_FORMAR_DEPTHFORMAT_24BIT_INT_Z;
2555 r300->state.stencil.clear = 0x00ff0000;
2556 break;
2557 default:
2558 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
2559 ctx->Visual.depthBits);
2560 _mesa_exit(-1);
2561 }
2562
2563 /* Only have hw stencil when depth buffer is 24 bits deep */
2564 r300->state.stencil.hw_stencil = (ctx->Visual.stencilBits > 0 &&
2565 ctx->Visual.depthBits == 24);
2566
2567 memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
2568
2569 r300ResetHwState(r300);
2570 }
2571
2572 static void r300RenderMode(GLcontext * ctx, GLenum mode)
2573 {
2574 r300ContextPtr rmesa = R300_CONTEXT(ctx);
2575 (void)rmesa;
2576 (void)mode;
2577 }
2578
2579 void r300UpdateClipPlanes( GLcontext *ctx )
2580 {
2581 r300ContextPtr rmesa = R300_CONTEXT(ctx);
2582 GLuint p;
2583
2584 for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
2585 if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
2586 GLint *ip = (GLint *)ctx->Transform._ClipUserPlane[p];
2587
2588 R300_STATECHANGE( rmesa, vpucp[p] );
2589 rmesa->hw.vpucp[p].cmd[R300_VPUCP_X] = ip[0];
2590 rmesa->hw.vpucp[p].cmd[R300_VPUCP_Y] = ip[1];
2591 rmesa->hw.vpucp[p].cmd[R300_VPUCP_Z] = ip[2];
2592 rmesa->hw.vpucp[p].cmd[R300_VPUCP_W] = ip[3];
2593 }
2594 }
2595 }
2596
2597 /**
2598 * Initialize driver's state callback functions
2599 */
2600 void r300InitStateFuncs(struct dd_function_table *functions)
2601 {
2602 radeonInitStateFuncs(functions);
2603
2604 functions->UpdateState = r300InvalidateState;
2605 functions->AlphaFunc = r300AlphaFunc;
2606 functions->BlendColor = r300BlendColor;
2607 functions->BlendEquationSeparate = r300BlendEquationSeparate;
2608 functions->BlendFuncSeparate = r300BlendFuncSeparate;
2609 functions->Enable = r300Enable;
2610 functions->ColorMask = r300ColorMask;
2611 functions->DepthFunc = r300DepthFunc;
2612 functions->DepthMask = r300DepthMask;
2613 functions->CullFace = r300CullFace;
2614 functions->Fogfv = r300Fogfv;
2615 functions->FrontFace = r300FrontFace;
2616 functions->ShadeModel = r300ShadeModel;
2617
2618 /* Stencil related */
2619 functions->ClearStencil = r300ClearStencil;
2620 functions->StencilFuncSeparate = r300StencilFuncSeparate;
2621 functions->StencilMaskSeparate = r300StencilMaskSeparate;
2622 functions->StencilOpSeparate = r300StencilOpSeparate;
2623
2624 /* Viewport related */
2625 functions->Viewport = r300Viewport;
2626 functions->DepthRange = r300DepthRange;
2627 functions->PointSize = r300PointSize;
2628 functions->LineWidth = r300LineWidth;
2629
2630 functions->PolygonOffset = r300PolygonOffset;
2631 functions->PolygonMode = r300PolygonMode;
2632
2633 functions->RenderMode = r300RenderMode;
2634
2635 functions->ClipPlane = r300ClipPlane;
2636 }