projects / mesa.git / blob
? search:


4d504d14e36cda7d2636cf1e8232560aee9b8408
[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 "main/glheader.h"
39 #include "main/state.h"
40 #include "main/imports.h"
41 #include "main/enums.h"
42 #include "main/macros.h"
43 #include "main/context.h"
44 #include "main/dd.h"
45 #include "main/framebuffer.h"
46 #include "main/simple_list.h"
47 #include "main/api_arrayelt.h"
48 #include "main/texformat.h"
49
50 #include "swrast/swrast.h"
51 #include "swrast_setup/swrast_setup.h"
52 #include "shader/prog_parameter.h"
53 #include "shader/prog_statevars.h"
54 #include "vbo/vbo.h"
55 #include "tnl/tnl.h"
56 #include "tnl/t_vp_build.h"
57
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_tex.h"
64 #include "r300_fragprog_common.h"
65 #include "r300_fragprog.h"
66 #include "r500_fragprog.h"
67 #include "r300_render.h"
68 #include "r300_vertprog.h"
69
70 #include "drirenderbuffer.h"
71
72 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
73 {
74 r300ContextPtr rmesa = R300_CONTEXT(ctx);
75
76 R300_STATECHANGE(rmesa, blend_color);
77
78 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
79 GLuint r = IROUND(cf[0]*1023.0f);
80 GLuint g = IROUND(cf[1]*1023.0f);
81 GLuint b = IROUND(cf[2]*1023.0f);
82 GLuint a = IROUND(cf[3]*1023.0f);
83
84 rmesa->hw.blend_color.cmd[1] = r | (a << 16);
85 rmesa->hw.blend_color.cmd[2] = b | (g << 16);
86 } else {
87 GLubyte color[4];
88 CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
89 CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
90 CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
91 CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
92
93 rmesa->hw.blend_color.cmd[1] = PACK_COLOR_8888(color[3], color[0],
94 color[1], color[2]);
95 }
96 }
97
98 /**
99 * Calculate the hardware blend factor setting. This same function is used
100 * for source and destination of both alpha and RGB.
101 *
102 * \returns
103 * The hardware register value for the specified blend factor. This value
104 * will need to be shifted into the correct position for either source or
105 * destination factor.
106 *
107 * \todo
108 * Since the two cases where source and destination are handled differently
109 * are essentially error cases, they should never happen. Determine if these
110 * cases can be removed.
111 */
112 static int blend_factor(GLenum factor, GLboolean is_src)
113 {
114 switch (factor) {
115 case GL_ZERO:
116 return R300_BLEND_GL_ZERO;
117 break;
118 case GL_ONE:
119 return R300_BLEND_GL_ONE;
120 break;
121 case GL_DST_COLOR:
122 return R300_BLEND_GL_DST_COLOR;
123 break;
124 case GL_ONE_MINUS_DST_COLOR:
125 return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
126 break;
127 case GL_SRC_COLOR:
128 return R300_BLEND_GL_SRC_COLOR;
129 break;
130 case GL_ONE_MINUS_SRC_COLOR:
131 return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
132 break;
133 case GL_SRC_ALPHA:
134 return R300_BLEND_GL_SRC_ALPHA;
135 break;
136 case GL_ONE_MINUS_SRC_ALPHA:
137 return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
138 break;
139 case GL_DST_ALPHA:
140 return R300_BLEND_GL_DST_ALPHA;
141 break;
142 case GL_ONE_MINUS_DST_ALPHA:
143 return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
144 break;
145 case GL_SRC_ALPHA_SATURATE:
146 return (is_src) ? R300_BLEND_GL_SRC_ALPHA_SATURATE :
147 R300_BLEND_GL_ZERO;
148 break;
149 case GL_CONSTANT_COLOR:
150 return R300_BLEND_GL_CONST_COLOR;
151 break;
152 case GL_ONE_MINUS_CONSTANT_COLOR:
153 return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
154 break;
155 case GL_CONSTANT_ALPHA:
156 return R300_BLEND_GL_CONST_ALPHA;
157 break;
158 case GL_ONE_MINUS_CONSTANT_ALPHA:
159 return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
160 break;
161 default:
162 fprintf(stderr, "unknown blend factor %x\n", factor);
163 return (is_src) ? R300_BLEND_GL_ONE : R300_BLEND_GL_ZERO;
164 break;
165 }
166 }
167
168 /**
169 * Sets both the blend equation and the blend function.
170 * This is done in a single
171 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
172 * change the interpretation of the blend function.
173 * Also, make sure that blend function and blend equation are set to their
174 * default value if color blending is not enabled, since at least blend
175 * equations GL_MIN and GL_FUNC_REVERSE_SUBTRACT will cause wrong results
176 * otherwise for unknown reasons.
177 */
178
179 /* helper function */
180 static void r300SetBlendCntl(r300ContextPtr r300, int func, int eqn,
181 int cbits, int funcA, int eqnA)
182 {
183 GLuint new_ablend, new_cblend;
184
185 #if 0
186 fprintf(stderr,
187 "eqnA=%08x funcA=%08x eqn=%08x func=%08x cbits=%08x\n",
188 eqnA, funcA, eqn, func, cbits);
189 #endif
190 new_ablend = eqnA | funcA;
191 new_cblend = eqn | func;
192
193 /* Some blend factor combinations don't seem to work when the
194 * BLEND_NO_SEPARATE bit is set.
195 *
196 * Especially problematic candidates are the ONE_MINUS_* flags,
197 * but I can't see a real pattern.
198 */
199 #if 0
200 if (new_ablend == new_cblend) {
201 new_cblend |= R300_DISCARD_SRC_PIXELS_SRC_ALPHA_0;
202 }
203 #endif
204 new_cblend |= cbits;
205
206 if ((new_ablend != r300->hw.bld.cmd[R300_BLD_ABLEND]) ||
207 (new_cblend != r300->hw.bld.cmd[R300_BLD_CBLEND])) {
208 R300_STATECHANGE(r300, bld);
209 r300->hw.bld.cmd[R300_BLD_ABLEND] = new_ablend;
210 r300->hw.bld.cmd[R300_BLD_CBLEND] = new_cblend;
211 }
212 }
213
214 static void r300SetBlendState(GLcontext * ctx)
215 {
216 r300ContextPtr r300 = R300_CONTEXT(ctx);
217 int func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
218 (R300_BLEND_GL_ZERO << R300_DST_BLEND_SHIFT);
219 int eqn = R300_COMB_FCN_ADD_CLAMP;
220 int funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
221 (R300_BLEND_GL_ZERO << R300_DST_BLEND_SHIFT);
222 int eqnA = R300_COMB_FCN_ADD_CLAMP;
223
224 if (RGBA_LOGICOP_ENABLED(ctx) || !ctx->Color.BlendEnabled) {
225 r300SetBlendCntl(r300, func, eqn, 0, func, eqn);
226 return;
227 }
228
229 func =
230 (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
231 R300_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
232 GL_FALSE) <<
233 R300_DST_BLEND_SHIFT);
234
235 switch (ctx->Color.BlendEquationRGB) {
236 case GL_FUNC_ADD:
237 eqn = R300_COMB_FCN_ADD_CLAMP;
238 break;
239
240 case GL_FUNC_SUBTRACT:
241 eqn = R300_COMB_FCN_SUB_CLAMP;
242 break;
243
244 case GL_FUNC_REVERSE_SUBTRACT:
245 eqn = R300_COMB_FCN_RSUB_CLAMP;
246 break;
247
248 case GL_MIN:
249 eqn = R300_COMB_FCN_MIN;
250 func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
251 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
252 break;
253
254 case GL_MAX:
255 eqn = R300_COMB_FCN_MAX;
256 func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
257 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
258 break;
259
260 default:
261 fprintf(stderr,
262 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
263 __FUNCTION__, __LINE__, ctx->Color.BlendEquationRGB);
264 return;
265 }
266
267 funcA =
268 (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
269 R300_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
270 GL_FALSE) <<
271 R300_DST_BLEND_SHIFT);
272
273 switch (ctx->Color.BlendEquationA) {
274 case GL_FUNC_ADD:
275 eqnA = R300_COMB_FCN_ADD_CLAMP;
276 break;
277
278 case GL_FUNC_SUBTRACT:
279 eqnA = R300_COMB_FCN_SUB_CLAMP;
280 break;
281
282 case GL_FUNC_REVERSE_SUBTRACT:
283 eqnA = R300_COMB_FCN_RSUB_CLAMP;
284 break;
285
286 case GL_MIN:
287 eqnA = R300_COMB_FCN_MIN;
288 funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
289 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
290 break;
291
292 case GL_MAX:
293 eqnA = R300_COMB_FCN_MAX;
294 funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
295 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
296 break;
297
298 default:
299 fprintf(stderr,
300 "[%s:%u] Invalid A blend equation (0x%04x).\n",
301 __FUNCTION__, __LINE__, ctx->Color.BlendEquationA);
302 return;
303 }
304
305 r300SetBlendCntl(r300,
306 func, eqn,
307 (R300_SEPARATE_ALPHA_ENABLE |
308 R300_READ_ENABLE |
309 R300_ALPHA_BLEND_ENABLE), funcA, eqnA);
310 }
311
312 static void r300BlendEquationSeparate(GLcontext * ctx,
313 GLenum modeRGB, GLenum modeA)
314 {
315 r300SetBlendState(ctx);
316 }
317
318 static void r300BlendFuncSeparate(GLcontext * ctx,
319 GLenum sfactorRGB, GLenum dfactorRGB,
320 GLenum sfactorA, GLenum dfactorA)
321 {
322 r300SetBlendState(ctx);
323 }
324
325 /**
326 * Translate LogicOp enums into hardware representation.
327 * Both use a very logical bit-wise layout, but unfortunately the order
328 * of bits is reversed.
329 */
330 static GLuint translate_logicop(GLenum logicop)
331 {
332 GLuint bits = logicop - GL_CLEAR;
333 bits = ((bits & 1) << 3) | ((bits & 2) << 1) | ((bits & 4) >> 1) | ((bits & 8) >> 3);
334 return bits << R300_RB3D_ROPCNTL_ROP_SHIFT;
335 }
336
337 /**
338 * Used internally to update the r300->hw hardware state to match the
339 * current OpenGL state.
340 */
341 static void r300SetLogicOpState(GLcontext *ctx)
342 {
343 r300ContextPtr r300 = R300_CONTEXT(ctx);
344 R300_STATECHANGE(r300, rop);
345 if (RGBA_LOGICOP_ENABLED(ctx)) {
346 r300->hw.rop.cmd[1] = R300_RB3D_ROPCNTL_ROP_ENABLE |
347 translate_logicop(ctx->Color.LogicOp);
348 } else {
349 r300->hw.rop.cmd[1] = 0;
350 }
351 }
352
353 /**
354 * Called by Mesa when an application program changes the LogicOp state
355 * via glLogicOp.
356 */
357 static void r300LogicOpcode(GLcontext *ctx, GLenum logicop)
358 {
359 if (RGBA_LOGICOP_ENABLED(ctx))
360 r300SetLogicOpState(ctx);
361 }
362
363 static void r300ClipPlane( GLcontext *ctx, GLenum plane, const GLfloat *eq )
364 {
365 r300ContextPtr rmesa = R300_CONTEXT(ctx);
366 GLint p;
367 GLint *ip;
368
369 /* no VAP UCP on non-TCL chipsets */
370 if (!rmesa->options.hw_tcl_enabled)
371 return;
372
373 p = (GLint) plane - (GLint) GL_CLIP_PLANE0;
374 ip = (GLint *)ctx->Transform._ClipUserPlane[p];
375
376 R300_STATECHANGE( rmesa, vpucp[p] );
377 rmesa->hw.vpucp[p].cmd[R300_VPUCP_X] = ip[0];
378 rmesa->hw.vpucp[p].cmd[R300_VPUCP_Y] = ip[1];
379 rmesa->hw.vpucp[p].cmd[R300_VPUCP_Z] = ip[2];
380 rmesa->hw.vpucp[p].cmd[R300_VPUCP_W] = ip[3];
381 }
382
383 static void r300SetClipPlaneState(GLcontext * ctx, GLenum cap, GLboolean state)
384 {
385 r300ContextPtr r300 = R300_CONTEXT(ctx);
386 GLuint p;
387
388 /* no VAP UCP on non-TCL chipsets */
389 if (!r300->options.hw_tcl_enabled)
390 return;
391
392 p = cap - GL_CLIP_PLANE0;
393 R300_STATECHANGE(r300, vap_clip_cntl);
394 if (state) {
395 r300->hw.vap_clip_cntl.cmd[1] |= (R300_VAP_UCP_ENABLE_0 << p);
396 r300ClipPlane(ctx, cap, NULL);
397 } else {
398 r300->hw.vap_clip_cntl.cmd[1] &= ~(R300_VAP_UCP_ENABLE_0 << p);
399 }
400 }
401
402 /**
403 * Update our tracked culling state based on Mesa's state.
404 */
405 static void r300UpdateCulling(GLcontext * ctx)
406 {
407 r300ContextPtr r300 = R300_CONTEXT(ctx);
408 uint32_t val = 0;
409
410 if (ctx->Polygon.CullFlag) {
411 switch (ctx->Polygon.CullFaceMode) {
412 case GL_FRONT:
413 val = R300_CULL_FRONT;
414 break;
415 case GL_BACK:
416 val = R300_CULL_BACK;
417 break;
418 case GL_FRONT_AND_BACK:
419 val = R300_CULL_FRONT | R300_CULL_BACK;
420 break;
421 default:
422 break;
423 }
424 }
425
426 switch (ctx->Polygon.FrontFace) {
427 case GL_CW:
428 val |= R300_FRONT_FACE_CW;
429 break;
430 case GL_CCW:
431 val |= R300_FRONT_FACE_CCW;
432 break;
433 default:
434 break;
435 }
436
437 R300_STATECHANGE(r300, cul);
438 r300->hw.cul.cmd[R300_CUL_CULL] = val;
439 }
440
441 static void r300SetPolygonOffsetState(GLcontext * ctx, GLboolean state)
442 {
443 r300ContextPtr r300 = R300_CONTEXT(ctx);
444
445 R300_STATECHANGE(r300, occlusion_cntl);
446 if (state) {
447 r300->hw.occlusion_cntl.cmd[1] |= (3 << 0);
448 } else {
449 r300->hw.occlusion_cntl.cmd[1] &= ~(3 << 0);
450 }
451 }
452
453 static GLboolean current_fragment_program_writes_depth(GLcontext* ctx)
454 {
455 r300ContextPtr r300 = R300_CONTEXT(ctx);
456
457 return ctx->FragmentProgram._Current && r300->selected_fp->writes_depth;
458 }
459
460 static void r300SetEarlyZState(GLcontext * ctx)
461 {
462 r300ContextPtr r300 = R300_CONTEXT(ctx);
463 GLuint topZ = R300_ZTOP_ENABLE;
464 GLuint w_fmt, fgdepthsrc;
465
466 if (ctx->Color.AlphaEnabled && ctx->Color.AlphaFunc != GL_ALWAYS)
467 topZ = R300_ZTOP_DISABLE;
468 else if (current_fragment_program_writes_depth(ctx))
469 topZ = R300_ZTOP_DISABLE;
470 else if (ctx->FragmentProgram._Current && ctx->FragmentProgram._Current->UsesKill)
471 topZ = R300_ZTOP_DISABLE;
472
473 if (topZ != r300->hw.zstencil_format.cmd[2]) {
474 /* Note: This completely reemits the stencil format.
475 * I have not tested whether this is strictly necessary,
476 * or if emitting a write to ZB_ZTOP is enough.
477 */
478 R300_STATECHANGE(r300, zstencil_format);
479 r300->hw.zstencil_format.cmd[2] = topZ;
480 }
481
482 /* w_fmt value is set to get best performance
483 * see p.130 R5xx 3D acceleration guide v1.3 */
484 if (current_fragment_program_writes_depth(ctx)) {
485 fgdepthsrc = R300_FG_DEPTH_SRC_SHADER;
486 w_fmt = R300_W_FMT_W24 | R300_W_SRC_US;
487 } else {
488 fgdepthsrc = R300_FG_DEPTH_SRC_SCAN;
489 w_fmt = R300_W_FMT_W0 | R300_W_SRC_US;
490 }
491
492 if (w_fmt != r300->hw.us_out_fmt.cmd[5]) {
493 R300_STATECHANGE(r300, us_out_fmt);
494 r300->hw.us_out_fmt.cmd[5] = w_fmt;
495 }
496
497 if (fgdepthsrc != r300->hw.fg_depth_src.cmd[1]) {
498 R300_STATECHANGE(r300, fg_depth_src);
499 r300->hw.fg_depth_src.cmd[1] = fgdepthsrc;
500 }
501 }
502
503 static void r300SetAlphaState(GLcontext * ctx)
504 {
505 r300ContextPtr r300 = R300_CONTEXT(ctx);
506 GLubyte refByte;
507 uint32_t pp_misc = 0x0;
508 GLboolean really_enabled = ctx->Color.AlphaEnabled;
509
510 CLAMPED_FLOAT_TO_UBYTE(refByte, ctx->Color.AlphaRef);
511
512 switch (ctx->Color.AlphaFunc) {
513 case GL_NEVER:
514 pp_misc |= R300_FG_ALPHA_FUNC_NEVER;
515 break;
516 case GL_LESS:
517 pp_misc |= R300_FG_ALPHA_FUNC_LESS;
518 break;
519 case GL_EQUAL:
520 pp_misc |= R300_FG_ALPHA_FUNC_EQUAL;
521 break;
522 case GL_LEQUAL:
523 pp_misc |= R300_FG_ALPHA_FUNC_LE;
524 break;
525 case GL_GREATER:
526 pp_misc |= R300_FG_ALPHA_FUNC_GREATER;
527 break;
528 case GL_NOTEQUAL:
529 pp_misc |= R300_FG_ALPHA_FUNC_NOTEQUAL;
530 break;
531 case GL_GEQUAL:
532 pp_misc |= R300_FG_ALPHA_FUNC_GE;
533 break;
534 case GL_ALWAYS:
535 /*pp_misc |= FG_ALPHA_FUNC_ALWAYS; */
536 really_enabled = GL_FALSE;
537 break;
538 }
539
540 if (really_enabled) {
541 pp_misc |= R300_FG_ALPHA_FUNC_ENABLE;
542 pp_misc |= R500_FG_ALPHA_FUNC_8BIT;
543 pp_misc |= (refByte & R300_FG_ALPHA_FUNC_VAL_MASK);
544 } else {
545 pp_misc = 0x0;
546 }
547
548 R300_STATECHANGE(r300, at);
549 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
550 r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
551 }
552
553 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
554 {
555 (void)func;
556 (void)ref;
557 r300SetAlphaState(ctx);
558 }
559
560 static int translate_func(int func)
561 {
562 switch (func) {
563 case GL_NEVER:
564 return R300_ZS_NEVER;
565 case GL_LESS:
566 return R300_ZS_LESS;
567 case GL_EQUAL:
568 return R300_ZS_EQUAL;
569 case GL_LEQUAL:
570 return R300_ZS_LEQUAL;
571 case GL_GREATER:
572 return R300_ZS_GREATER;
573 case GL_NOTEQUAL:
574 return R300_ZS_NOTEQUAL;
575 case GL_GEQUAL:
576 return R300_ZS_GEQUAL;
577 case GL_ALWAYS:
578 return R300_ZS_ALWAYS;
579 }
580 return 0;
581 }
582
583 static void r300SetDepthState(GLcontext * ctx)
584 {
585 r300ContextPtr r300 = R300_CONTEXT(ctx);
586
587 R300_STATECHANGE(r300, zs);
588 r300->hw.zs.cmd[R300_ZS_CNTL_0] &= R300_STENCIL_ENABLE|R300_STENCIL_FRONT_BACK;
589 r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_Z_FUNC_SHIFT);
590
591 if (ctx->Depth.Test) {
592 r300->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_Z_ENABLE;
593 if (ctx->Depth.Mask)
594 r300->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_Z_WRITE_ENABLE;
595 r300->hw.zs.cmd[R300_ZS_CNTL_1] |=
596 translate_func(ctx->Depth.Func) << R300_Z_FUNC_SHIFT;
597 }
598 }
599
600 static void r300CatchStencilFallback(GLcontext *ctx)
601 {
602 const unsigned back = ctx->Stencil._BackFace;
603
604 if (ctx->Stencil._Enabled && (ctx->Stencil.Ref[0] != ctx->Stencil.Ref[back]
605 || ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[back]
606 || ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[back])) {
607 r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_TRUE);
608 } else {
609 r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_FALSE);
610 }
611 }
612
613 static void r300SetStencilState(GLcontext * ctx, GLboolean state)
614 {
615 r300ContextPtr r300 = R300_CONTEXT(ctx);
616 GLboolean hw_stencil = GL_FALSE;
617
618 r300CatchStencilFallback(ctx);
619
620 if (ctx->DrawBuffer) {
621 struct radeon_renderbuffer *rrbStencil
622 = radeon_get_renderbuffer(ctx->DrawBuffer, BUFFER_STENCIL);
623 hw_stencil = (rrbStencil && rrbStencil->bo);
624 }
625
626 if (hw_stencil) {
627 R300_STATECHANGE(r300, zs);
628 if (state) {
629 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
630 R300_STENCIL_ENABLE;
631 } else {
632 r300->hw.zs.cmd[R300_ZS_CNTL_0] &=
633 ~R300_STENCIL_ENABLE;
634 }
635 }
636 }
637
638 static void r300UpdatePolygonMode(GLcontext * ctx)
639 {
640 r300ContextPtr r300 = R300_CONTEXT(ctx);
641 uint32_t hw_mode = R300_GA_POLY_MODE_DISABLE;
642
643 /* Only do something if a polygon mode is wanted, default is GL_FILL */
644 if (ctx->Polygon.FrontMode != GL_FILL ||
645 ctx->Polygon.BackMode != GL_FILL) {
646 GLenum f, b;
647
648 /* Handle GL_CW (clock wise and GL_CCW (counter clock wise)
649 * correctly by selecting the correct front and back face
650 */
651 if (ctx->Polygon.FrontFace == GL_CCW) {
652 f = ctx->Polygon.FrontMode;
653 b = ctx->Polygon.BackMode;
654 } else {
655 f = ctx->Polygon.BackMode;
656 b = ctx->Polygon.FrontMode;
657 }
658
659 /* Enable polygon mode */
660 hw_mode |= R300_GA_POLY_MODE_DUAL;
661
662 switch (f) {
663 case GL_LINE:
664 hw_mode |= R300_GA_POLY_MODE_FRONT_PTYPE_LINE;
665 break;
666 case GL_POINT:
667 hw_mode |= R300_GA_POLY_MODE_FRONT_PTYPE_POINT;
668 break;
669 case GL_FILL:
670 hw_mode |= R300_GA_POLY_MODE_FRONT_PTYPE_TRI;
671 break;
672 }
673
674 switch (b) {
675 case GL_LINE:
676 hw_mode |= R300_GA_POLY_MODE_BACK_PTYPE_LINE;
677 break;
678 case GL_POINT:
679 hw_mode |= R300_GA_POLY_MODE_BACK_PTYPE_POINT;
680 break;
681 case GL_FILL:
682 hw_mode |= R300_GA_POLY_MODE_BACK_PTYPE_TRI;
683 break;
684 }
685 }
686
687 if (r300->hw.polygon_mode.cmd[1] != hw_mode) {
688 R300_STATECHANGE(r300, polygon_mode);
689 r300->hw.polygon_mode.cmd[1] = hw_mode;
690 }
691
692 r300->hw.polygon_mode.cmd[2] = 0x00000001;
693 r300->hw.polygon_mode.cmd[3] = 0x00000000;
694 }
695
696 /**
697 * Change the culling mode.
698 *
699 * \note Mesa already filters redundant calls to this function.
700 */
701 static void r300CullFace(GLcontext * ctx, GLenum mode)
702 {
703 (void)mode;
704
705 r300UpdateCulling(ctx);
706 }
707
708 /**
709 * Change the polygon orientation.
710 *
711 * \note Mesa already filters redundant calls to this function.
712 */
713 static void r300FrontFace(GLcontext * ctx, GLenum mode)
714 {
715 (void)mode;
716
717 r300UpdateCulling(ctx);
718 r300UpdatePolygonMode(ctx);
719 }
720
721 /**
722 * Change the depth testing function.
723 *
724 * \note Mesa already filters redundant calls to this function.
725 */
726 static void r300DepthFunc(GLcontext * ctx, GLenum func)
727 {
728 (void)func;
729 r300SetDepthState(ctx);
730 }
731
732 /**
733 * Enable/Disable depth writing.
734 *
735 * \note Mesa already filters redundant calls to this function.
736 */
737 static void r300DepthMask(GLcontext * ctx, GLboolean mask)
738 {
739 (void)mask;
740 r300SetDepthState(ctx);
741 }
742
743 /**
744 * Handle glColorMask()
745 */
746 static void r300ColorMask(GLcontext * ctx,
747 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
748 {
749 r300ContextPtr r300 = R300_CONTEXT(ctx);
750 int mask = (r ? RB3D_COLOR_CHANNEL_MASK_RED_MASK0 : 0) |
751 (g ? RB3D_COLOR_CHANNEL_MASK_GREEN_MASK0 : 0) |
752 (b ? RB3D_COLOR_CHANNEL_MASK_BLUE_MASK0 : 0) |
753 (a ? RB3D_COLOR_CHANNEL_MASK_ALPHA_MASK0 : 0);
754
755 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
756 R300_STATECHANGE(r300, cmk);
757 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
758 }
759 }
760
761 /* =============================================================
762 * Point state
763 */
764 static void r300PointSize(GLcontext * ctx, GLfloat size)
765 {
766 r300ContextPtr r300 = R300_CONTEXT(ctx);
767
768 /* We need to clamp to user defined range here, because
769 * the HW clamping happens only for per vertex point size. */
770 size = CLAMP(size, ctx->Point.MinSize, ctx->Point.MaxSize);
771
772 /* same size limits for AA, non-AA points */
773 size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize);
774
775 R300_STATECHANGE(r300, ps);
776 r300->hw.ps.cmd[R300_PS_POINTSIZE] =
777 ((int)(size * 6) << R300_POINTSIZE_X_SHIFT) |
778 ((int)(size * 6) << R300_POINTSIZE_Y_SHIFT);
779 }
780
781 static void r300PointParameter(GLcontext * ctx, GLenum pname, const GLfloat * param)
782 {
783 r300ContextPtr r300 = R300_CONTEXT(ctx);
784
785 switch (pname) {
786 case GL_POINT_SIZE_MIN:
787 R300_STATECHANGE(r300, ga_point_minmax);
788 r300->hw.ga_point_minmax.cmd[1] &= ~R300_GA_POINT_MINMAX_MIN_MASK;
789 r300->hw.ga_point_minmax.cmd[1] |= (GLuint)(ctx->Point.MinSize * 6.0);
790 break;
791 case GL_POINT_SIZE_MAX:
792 R300_STATECHANGE(r300, ga_point_minmax);
793 r300->hw.ga_point_minmax.cmd[1] &= ~R300_GA_POINT_MINMAX_MAX_MASK;
794 r300->hw.ga_point_minmax.cmd[1] |= (GLuint)(ctx->Point.MaxSize * 6.0)
795 << R300_GA_POINT_MINMAX_MAX_SHIFT;
796 break;
797 case GL_POINT_DISTANCE_ATTENUATION:
798 break;
799 case GL_POINT_FADE_THRESHOLD_SIZE:
800 break;
801 default:
802 break;
803 }
804 }
805
806 /* =============================================================
807 * Line state
808 */
809 static void r300LineWidth(GLcontext * ctx, GLfloat widthf)
810 {
811 r300ContextPtr r300 = R300_CONTEXT(ctx);
812
813 widthf = CLAMP(widthf,
814 ctx->Const.MinPointSize,
815 ctx->Const.MaxPointSize);
816 R300_STATECHANGE(r300, lcntl);
817 r300->hw.lcntl.cmd[1] =
818 R300_LINE_CNT_HO | R300_LINE_CNT_VE | (int)(widthf * 6.0);
819 }
820
821 static void r300PolygonMode(GLcontext * ctx, GLenum face, GLenum mode)
822 {
823 (void)face;
824 (void)mode;
825
826 r300UpdatePolygonMode(ctx);
827 }
828
829 /* =============================================================
830 * Stencil
831 */
832
833 static int translate_stencil_op(int op)
834 {
835 switch (op) {
836 case GL_KEEP:
837 return R300_ZS_KEEP;
838 case GL_ZERO:
839 return R300_ZS_ZERO;
840 case GL_REPLACE:
841 return R300_ZS_REPLACE;
842 case GL_INCR:
843 return R300_ZS_INCR;
844 case GL_DECR:
845 return R300_ZS_DECR;
846 case GL_INCR_WRAP_EXT:
847 return R300_ZS_INCR_WRAP;
848 case GL_DECR_WRAP_EXT:
849 return R300_ZS_DECR_WRAP;
850 case GL_INVERT:
851 return R300_ZS_INVERT;
852 default:
853 WARN_ONCE("Do not know how to translate stencil op");
854 return R300_ZS_KEEP;
855 }
856 return 0;
857 }
858
859 static void r300ShadeModel(GLcontext * ctx, GLenum mode)
860 {
861 r300ContextPtr rmesa = R300_CONTEXT(ctx);
862
863 R300_STATECHANGE(rmesa, shade);
864 rmesa->hw.shade.cmd[1] = 0x00000002;
865 R300_STATECHANGE(rmesa, shade2);
866 switch (mode) {
867 case GL_FLAT:
868 rmesa->hw.shade2.cmd[1] = R300_RE_SHADE_MODEL_FLAT;
869 break;
870 case GL_SMOOTH:
871 rmesa->hw.shade2.cmd[1] = R300_RE_SHADE_MODEL_SMOOTH;
872 break;
873 default:
874 return;
875 }
876 rmesa->hw.shade2.cmd[2] = 0x00000000;
877 rmesa->hw.shade2.cmd[3] = 0x00000000;
878 }
879
880 static void r300StencilFuncSeparate(GLcontext * ctx, GLenum face,
881 GLenum func, GLint ref, GLuint mask)
882 {
883 r300ContextPtr rmesa = R300_CONTEXT(ctx);
884 GLuint refmask;
885 GLuint flag;
886 const unsigned back = ctx->Stencil._BackFace;
887
888 r300CatchStencilFallback(ctx);
889
890 refmask = ((ctx->Stencil.Ref[0] & 0xff) << R300_STENCILREF_SHIFT)
891 | ((ctx->Stencil.ValueMask[0] & 0xff) << R300_STENCILMASK_SHIFT);
892
893 R300_STATECHANGE(rmesa, zs);
894 rmesa->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_STENCIL_FRONT_BACK;
895 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~((R300_ZS_MASK <<
896 R300_S_FRONT_FUNC_SHIFT)
897 | (R300_ZS_MASK <<
898 R300_S_BACK_FUNC_SHIFT));
899
900 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &=
901 ~((R300_STENCILREF_MASK << R300_STENCILREF_SHIFT) |
902 (R300_STENCILREF_MASK << R300_STENCILMASK_SHIFT));
903
904 flag = translate_func(ctx->Stencil.Function[0]);
905 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
906 (flag << R300_S_FRONT_FUNC_SHIFT);
907
908 flag = translate_func(ctx->Stencil.Function[back]);
909
910 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
911 (flag << R300_S_BACK_FUNC_SHIFT);
912 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
913 }
914
915 static void r300StencilMaskSeparate(GLcontext * ctx, GLenum face, GLuint mask)
916 {
917 r300ContextPtr rmesa = R300_CONTEXT(ctx);
918
919 r300CatchStencilFallback(ctx);
920
921 R300_STATECHANGE(rmesa, zs);
922 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &=
923 ~(R300_STENCILREF_MASK <<
924 R300_STENCILWRITEMASK_SHIFT);
925 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |=
926 (ctx->Stencil.
927 WriteMask[0] & R300_STENCILREF_MASK) <<
928 R300_STENCILWRITEMASK_SHIFT;
929 }
930
931 static void r300StencilOpSeparate(GLcontext * ctx, GLenum face,
932 GLenum fail, GLenum zfail, GLenum zpass)
933 {
934 r300ContextPtr rmesa = R300_CONTEXT(ctx);
935 const unsigned back = ctx->Stencil._BackFace;
936
937 r300CatchStencilFallback(ctx);
938
939 R300_STATECHANGE(rmesa, zs);
940 /* It is easier to mask what's left.. */
941 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &=
942 (R300_ZS_MASK << R300_Z_FUNC_SHIFT) |
943 (R300_ZS_MASK << R300_S_FRONT_FUNC_SHIFT) |
944 (R300_ZS_MASK << R300_S_BACK_FUNC_SHIFT);
945
946 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
947 (translate_stencil_op(ctx->Stencil.FailFunc[0]) <<
948 R300_S_FRONT_SFAIL_OP_SHIFT)
949 | (translate_stencil_op(ctx->Stencil.ZFailFunc[0]) <<
950 R300_S_FRONT_ZFAIL_OP_SHIFT)
951 | (translate_stencil_op(ctx->Stencil.ZPassFunc[0]) <<
952 R300_S_FRONT_ZPASS_OP_SHIFT);
953
954 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
955 (translate_stencil_op(ctx->Stencil.FailFunc[back]) <<
956 R300_S_BACK_SFAIL_OP_SHIFT)
957 | (translate_stencil_op(ctx->Stencil.ZFailFunc[back]) <<
958 R300_S_BACK_ZFAIL_OP_SHIFT)
959 | (translate_stencil_op(ctx->Stencil.ZPassFunc[back]) <<
960 R300_S_BACK_ZPASS_OP_SHIFT);
961 }
962
963 /* =============================================================
964 * Window position and viewport transformation
965 */
966
967 static void r300UpdateWindow(GLcontext * ctx)
968 {
969 r300ContextPtr rmesa = R300_CONTEXT(ctx);
970 __DRIdrawablePrivate *dPriv = radeon_get_drawable(&rmesa->radeon);
971 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
972 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
973 const GLfloat *v = ctx->Viewport._WindowMap.m;
974 const GLfloat depthScale = 1.0F / ctx->DrawBuffer->_DepthMaxF;
975 const GLboolean render_to_fbo = (ctx->DrawBuffer->Name != 0);
976 GLfloat y_scale, y_bias;
977
978 if (render_to_fbo) {
979 y_scale = 1.0;
980 y_bias = 0;
981 } else {
982 y_scale = -1.0;
983 y_bias = yoffset;
984 }
985
986 GLfloat sx = v[MAT_SX];
987 GLfloat tx = v[MAT_TX] + xoffset;
988 GLfloat sy = v[MAT_SY] * y_scale;
989 GLfloat ty = (v[MAT_TY] * y_scale) + y_bias;
990 GLfloat sz = v[MAT_SZ] * depthScale;
991 GLfloat tz = v[MAT_TZ] * depthScale;
992
993 R300_STATECHANGE(rmesa, vpt);
994
995 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
996 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
997 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
998 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
999 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
1000 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
1001 }
1002
1003 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
1004 GLsizei width, GLsizei height)
1005 {
1006 /* Don't pipeline viewport changes, conflict with window offset
1007 * setting below. Could apply deltas to rescue pipelined viewport
1008 * values, or keep the originals hanging around.
1009 */
1010 r300UpdateWindow(ctx);
1011
1012 radeon_viewport(ctx, x, y, width, height);
1013 }
1014
1015 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
1016 {
1017 r300UpdateWindow(ctx);
1018 }
1019
1020 void r300UpdateViewportOffset(GLcontext * ctx)
1021 {
1022 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1023 __DRIdrawablePrivate *dPriv = radeon_get_drawable(&rmesa->radeon);
1024 GLfloat xoffset = (GLfloat) dPriv->x;
1025 GLfloat yoffset = (GLfloat) dPriv->y + dPriv->h;
1026 const GLfloat *v = ctx->Viewport._WindowMap.m;
1027
1028 GLfloat tx = v[MAT_TX] + xoffset;
1029 GLfloat ty = (-v[MAT_TY]) + yoffset;
1030
1031 if (rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] != r300PackFloat32(tx) ||
1032 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] != r300PackFloat32(ty)) {
1033 /* Note: this should also modify whatever data the context reset
1034 * code uses...
1035 */
1036 R300_STATECHANGE(rmesa, vpt);
1037 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
1038 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
1039
1040 }
1041
1042 radeonUpdateScissor(ctx);
1043 }
1044
1045 static void
1046 r300FetchStateParameter(GLcontext * ctx,
1047 const gl_state_index state[STATE_LENGTH],
1048 GLfloat * value)
1049 {
1050 r300ContextPtr r300 = R300_CONTEXT(ctx);
1051
1052 switch (state[0]) {
1053 case STATE_INTERNAL:
1054 switch (state[1]) {
1055 case STATE_R300_WINDOW_DIMENSION: {
1056 __DRIdrawablePrivate * drawable = radeon_get_drawable(&r300->radeon);
1057 value[0] = drawable->w * 0.5f; /* width*0.5 */
1058 value[1] = drawable->h * 0.5f; /* height*0.5 */
1059 value[2] = 0.5F; /* for moving range [-1 1] -> [0 1] */
1060 value[3] = 1.0F; /* not used */
1061 break;
1062 }
1063
1064 case STATE_R300_TEXRECT_FACTOR:{
1065 struct gl_texture_object *t =
1066 ctx->Texture.Unit[state[2]].CurrentTex[TEXTURE_RECT_INDEX];
1067
1068 if (t && t->Image[0][t->BaseLevel]) {
1069 struct gl_texture_image *image =
1070 t->Image[0][t->BaseLevel];
1071 value[0] = 1.0 / image->Width2;
1072 value[1] = 1.0 / image->Height2;
1073 } else {
1074 value[0] = 1.0;
1075 value[1] = 1.0;
1076 }
1077 value[2] = 1.0;
1078 value[3] = 1.0;
1079 break;
1080 }
1081
1082 default:
1083 break;
1084 }
1085 break;
1086
1087 default:
1088 break;
1089 }
1090 }
1091
1092 /**
1093 * Update R300's own internal state parameters.
1094 * For now just STATE_R300_WINDOW_DIMENSION
1095 */
1096 static void r300UpdateStateParameters(GLcontext * ctx, GLuint new_state)
1097 {
1098 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1099 struct gl_program_parameter_list *paramList;
1100 GLuint i;
1101
1102 if (!(new_state & (_NEW_BUFFERS | _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS)))
1103 return;
1104
1105 if (!ctx->FragmentProgram._Current || !rmesa->selected_fp)
1106 return;
1107
1108 paramList = rmesa->selected_fp->Base->Parameters;
1109
1110 if (!paramList)
1111 return;
1112
1113 _mesa_load_state_parameters(ctx, paramList);
1114
1115 for (i = 0; i < paramList->NumParameters; i++) {
1116 if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
1117 r300FetchStateParameter(ctx,
1118 paramList->Parameters[i].
1119 StateIndexes,
1120 paramList->ParameterValues[i]);
1121 }
1122 }
1123 }
1124
1125 /* =============================================================
1126 * Polygon state
1127 */
1128 static void r300PolygonOffset(GLcontext * ctx, GLfloat factor, GLfloat units)
1129 {
1130 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1131 GLfloat constant = units;
1132
1133 switch (ctx->Visual.depthBits) {
1134 case 16:
1135 constant *= 4.0;
1136 break;
1137 case 24:
1138 constant *= 2.0;
1139 break;
1140 }
1141
1142 factor *= 12.0;
1143
1144 /* fprintf(stderr, "%s f:%f u:%f\n", __FUNCTION__, factor, constant); */
1145
1146 R300_STATECHANGE(rmesa, zbs);
1147 rmesa->hw.zbs.cmd[R300_ZBS_T_FACTOR] = r300PackFloat32(factor);
1148 rmesa->hw.zbs.cmd[R300_ZBS_T_CONSTANT] = r300PackFloat32(constant);
1149 rmesa->hw.zbs.cmd[R300_ZBS_W_FACTOR] = r300PackFloat32(factor);
1150 rmesa->hw.zbs.cmd[R300_ZBS_W_CONSTANT] = r300PackFloat32(constant);
1151 }
1152
1153 /* Routing and texture-related */
1154
1155 /* r300 doesnt handle GL_CLAMP and GL_MIRROR_CLAMP_EXT correctly when filter is NEAREST.
1156 * Since texwrap produces same results for GL_CLAMP and GL_CLAMP_TO_EDGE we use them instead.
1157 * We need to recalculate wrap modes whenever filter mode is changed because someone might do:
1158 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1159 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1160 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1161 * Since r300 completely ignores R300_TX_CLAMP when either min or mag is nearest it cant handle
1162 * combinations where only one of them is nearest.
1163 */
1164 static unsigned long gen_fixed_filter(unsigned long f)
1165 {
1166 unsigned long mag, min, needs_fixing = 0;
1167 //return f;
1168
1169 /* We ignore MIRROR bit so we dont have to do everything twice */
1170 if ((f & ((7 - 1) << R300_TX_WRAP_S_SHIFT)) ==
1171 (R300_TX_CLAMP << R300_TX_WRAP_S_SHIFT)) {
1172 needs_fixing |= 1;
1173 }
1174 if ((f & ((7 - 1) << R300_TX_WRAP_T_SHIFT)) ==
1175 (R300_TX_CLAMP << R300_TX_WRAP_T_SHIFT)) {
1176 needs_fixing |= 2;
1177 }
1178 if ((f & ((7 - 1) << R300_TX_WRAP_R_SHIFT)) ==
1179 (R300_TX_CLAMP << R300_TX_WRAP_R_SHIFT)) {
1180 needs_fixing |= 4;
1181 }
1182
1183 if (!needs_fixing)
1184 return f;
1185
1186 mag = f & R300_TX_MAG_FILTER_MASK;
1187 min = f & (R300_TX_MIN_FILTER_MASK|R300_TX_MIN_FILTER_MIP_MASK);
1188
1189 /* TODO: Check for anisto filters too */
1190 if ((mag != R300_TX_MAG_FILTER_NEAREST)
1191 && (min != R300_TX_MIN_FILTER_NEAREST))
1192 return f;
1193
1194 /* r300 cant handle these modes hence we force nearest to linear */
1195 if ((mag == R300_TX_MAG_FILTER_NEAREST)
1196 && (min != R300_TX_MIN_FILTER_NEAREST)) {
1197 f &= ~R300_TX_MAG_FILTER_NEAREST;
1198 f |= R300_TX_MAG_FILTER_LINEAR;
1199 return f;
1200 }
1201
1202 if ((min == R300_TX_MIN_FILTER_NEAREST)
1203 && (mag != R300_TX_MAG_FILTER_NEAREST)) {
1204 f &= ~R300_TX_MIN_FILTER_NEAREST;
1205 f |= R300_TX_MIN_FILTER_LINEAR;
1206 return f;
1207 }
1208
1209 /* Both are nearest */
1210 if (needs_fixing & 1) {
1211 f &= ~((7 - 1) << R300_TX_WRAP_S_SHIFT);
1212 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_S_SHIFT;
1213 }
1214 if (needs_fixing & 2) {
1215 f &= ~((7 - 1) << R300_TX_WRAP_T_SHIFT);
1216 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_T_SHIFT;
1217 }
1218 if (needs_fixing & 4) {
1219 f &= ~((7 - 1) << R300_TX_WRAP_R_SHIFT);
1220 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_R_SHIFT;
1221 }
1222 return f;
1223 }
1224
1225 static void r300SetupFragmentShaderTextures(GLcontext *ctx, int *tmu_mappings)
1226 {
1227 r300ContextPtr r300 = R300_CONTEXT(ctx);
1228 int i;
1229 struct r300_fragment_program_code *code = &r300->selected_fp->code.r300;
1230
1231 R300_STATECHANGE(r300, fpt);
1232
1233 for (i = 0; i < code->tex.length; i++) {
1234 int unit;
1235 int opcode;
1236 unsigned long val;
1237
1238 unit = code->tex.inst[i] >> R300_TEX_ID_SHIFT;
1239 unit &= 15;
1240
1241 val = code->tex.inst[i];
1242 val &= ~R300_TEX_ID_MASK;
1243
1244 opcode =
1245 (val & R300_TEX_INST_MASK) >> R300_TEX_INST_SHIFT;
1246 if (opcode == R300_TEX_OP_KIL) {
1247 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1248 } else {
1249 if (tmu_mappings[unit] >= 0) {
1250 val |=
1251 tmu_mappings[unit] <<
1252 R300_TEX_ID_SHIFT;
1253 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1254 } else {
1255 // We get here when the corresponding texture image is incomplete
1256 // (e.g. incomplete mipmaps etc.)
1257 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1258 }
1259 }
1260 }
1261
1262 r300->hw.fpt.cmd[R300_FPT_CMD_0] =
1263 cmdpacket0(r300->radeon.radeonScreen,
1264 R300_US_TEX_INST_0, code->tex.length);
1265 }
1266
1267 static void r500SetupFragmentShaderTextures(GLcontext *ctx, int *tmu_mappings)
1268 {
1269 r300ContextPtr r300 = R300_CONTEXT(ctx);
1270 int i;
1271 struct r500_fragment_program_code *code = &r300->selected_fp->code.r500;
1272
1273 /* find all the texture instructions and relocate the texture units */
1274 for (i = 0; i < code->inst_end + 1; i++) {
1275 if ((code->inst[i].inst0 & 0x3) == R500_INST_TYPE_TEX) {
1276 uint32_t val;
1277 int unit, opcode, new_unit;
1278
1279 val = code->inst[i].inst1;
1280
1281 unit = (val >> 16) & 0xf;
1282
1283 val &= ~(0xf << 16);
1284
1285 opcode = val & (0x7 << 22);
1286 if (opcode == R500_TEX_INST_TEXKILL) {
1287 new_unit = 0;
1288 } else {
1289 if (tmu_mappings[unit] >= 0) {
1290 new_unit = tmu_mappings[unit];
1291 } else {
1292 new_unit = 0;
1293 }
1294 }
1295 val |= R500_TEX_ID(new_unit);
1296 code->inst[i].inst1 = val;
1297 }
1298 }
1299 }
1300
1301 static GLuint translate_lod_bias(GLfloat bias)
1302 {
1303 GLint b = (int)(bias*32);
1304 if (b >= (1 << 9))
1305 b = (1 << 9)-1;
1306 else if (b < -(1 << 9))
1307 b = -(1 << 9);
1308 return (((GLuint)b) << R300_LOD_BIAS_SHIFT) & R300_LOD_BIAS_MASK;
1309 }
1310
1311 static void r300SetupTextures(GLcontext * ctx)
1312 {
1313 int i, mtu;
1314 struct radeon_tex_obj *t;
1315 r300ContextPtr r300 = R300_CONTEXT(ctx);
1316 int hw_tmu = 0;
1317 int last_hw_tmu = -1; /* -1 translates into no setup costs for fields */
1318 int tmu_mappings[R300_MAX_TEXTURE_UNITS] = { -1, };
1319
1320 R300_STATECHANGE(r300, txe);
1321 R300_STATECHANGE(r300, tex.filter);
1322 R300_STATECHANGE(r300, tex.filter_1);
1323 R300_STATECHANGE(r300, tex.size);
1324 R300_STATECHANGE(r300, tex.format);
1325 R300_STATECHANGE(r300, tex.pitch);
1326 R300_STATECHANGE(r300, tex.offset);
1327 R300_STATECHANGE(r300, tex.chroma_key);
1328 R300_STATECHANGE(r300, tex.border_color);
1329
1330 r300->hw.txe.cmd[R300_TXE_ENABLE] = 0x0;
1331
1332 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1333 if (RADEON_DEBUG & DEBUG_STATE)
1334 fprintf(stderr, "mtu=%d\n", mtu);
1335
1336 if (mtu > R300_MAX_TEXTURE_UNITS) {
1337 fprintf(stderr,
1338 "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1339 mtu, R300_MAX_TEXTURE_UNITS);
1340 _mesa_exit(-1);
1341 }
1342
1343 /* We cannot let disabled tmu offsets pass DRM */
1344 for (i = 0; i < mtu; i++) {
1345 if (ctx->Texture.Unit[i]._ReallyEnabled) {
1346 tmu_mappings[i] = hw_tmu;
1347
1348 t = radeon_tex_obj(ctx->Texture.Unit[i]._Current);
1349 if (!t)
1350 continue;
1351
1352 if ((t->pp_txformat & 0xffffff00) == 0xffffff00) {
1353 WARN_ONCE
1354 ("unknown texture format (entry %x) encountered. Help me !\n",
1355 t->pp_txformat & 0xff);
1356 }
1357
1358 if (RADEON_DEBUG & DEBUG_STATE)
1359 fprintf(stderr,
1360 "Activating texture unit %d\n", i);
1361
1362 r300->hw.txe.cmd[R300_TXE_ENABLE] |= (1 << hw_tmu);
1363
1364 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0 +
1365 hw_tmu] =
1366 gen_fixed_filter(t->pp_txfilter) | (hw_tmu << 28);
1367 /* Note: There is a LOD bias per texture unit and a LOD bias
1368 * per texture object. We add them here to get the correct behaviour.
1369 * (The per-texture object LOD bias was introduced in OpenGL 1.4
1370 * and is not present in the EXT_texture_object extension).
1371 */
1372 r300->hw.tex.filter_1.cmd[R300_TEX_VALUE_0 + hw_tmu] =
1373 t->pp_txfilter_1 |
1374 translate_lod_bias(ctx->Texture.Unit[i].LodBias + t->base.LodBias);
1375 r300->hw.tex.size.cmd[R300_TEX_VALUE_0 + hw_tmu] =
1376 t->pp_txsize;
1377 r300->hw.tex.format.cmd[R300_TEX_VALUE_0 +
1378 hw_tmu] = t->pp_txformat;
1379 r300->hw.tex.pitch.cmd[R300_TEX_VALUE_0 + hw_tmu] =
1380 t->pp_txpitch;
1381 r300->hw.textures[hw_tmu] = t;
1382
1383 if (t->tile_bits & R300_TXO_MACRO_TILE) {
1384 WARN_ONCE("macro tiling enabled!\n");
1385 }
1386
1387 if (t->tile_bits & R300_TXO_MICRO_TILE) {
1388 WARN_ONCE("micro tiling enabled!\n");
1389 }
1390
1391 r300->hw.tex.chroma_key.cmd[R300_TEX_VALUE_0 +
1392 hw_tmu] = 0x0;
1393 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0 +
1394 hw_tmu] =
1395 t->pp_border_color;
1396
1397 last_hw_tmu = hw_tmu;
1398
1399 hw_tmu++;
1400 }
1401 }
1402
1403 r300->hw.tex.filter.cmd[R300_TEX_CMD_0] =
1404 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FILTER0_0, last_hw_tmu + 1);
1405 r300->hw.tex.filter_1.cmd[R300_TEX_CMD_0] =
1406 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FILTER1_0, last_hw_tmu + 1);
1407 r300->hw.tex.size.cmd[R300_TEX_CMD_0] =
1408 cmdpacket0(r300->radeon.radeonScreen, R300_TX_SIZE_0, last_hw_tmu + 1);
1409 r300->hw.tex.format.cmd[R300_TEX_CMD_0] =
1410 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FORMAT_0, last_hw_tmu + 1);
1411 r300->hw.tex.pitch.cmd[R300_TEX_CMD_0] =
1412 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FORMAT2_0, last_hw_tmu + 1);
1413 r300->hw.tex.offset.cmd[R300_TEX_CMD_0] =
1414 cmdpacket0(r300->radeon.radeonScreen, R300_TX_OFFSET_0, last_hw_tmu + 1);
1415 r300->hw.tex.chroma_key.cmd[R300_TEX_CMD_0] =
1416 cmdpacket0(r300->radeon.radeonScreen, R300_TX_CHROMA_KEY_0, last_hw_tmu + 1);
1417 r300->hw.tex.border_color.cmd[R300_TEX_CMD_0] =
1418 cmdpacket0(r300->radeon.radeonScreen, R300_TX_BORDER_COLOR_0, last_hw_tmu + 1);
1419
1420 if (r300->radeon.radeonScreen->chip_family < CHIP_FAMILY_RV515) {
1421 if (ctx->FragmentProgram._Current->UsesKill && last_hw_tmu < 0) {
1422 // The KILL operation requires the first texture unit
1423 // to be enabled.
1424 r300->hw.txe.cmd[R300_TXE_ENABLE] |= 1;
1425 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0] = 0;
1426 r300->hw.tex.filter.cmd[R300_TEX_CMD_0] =
1427 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FILTER0_0, 1);
1428 }
1429 }
1430 r300->vtbl.SetupFragmentShaderTextures(ctx, tmu_mappings);
1431
1432 if (RADEON_DEBUG & DEBUG_STATE)
1433 fprintf(stderr, "TX_ENABLE: %08x last_hw_tmu=%d\n",
1434 r300->hw.txe.cmd[R300_TXE_ENABLE], last_hw_tmu);
1435 }
1436
1437 union r300_outputs_written {
1438 GLuint vp_outputs; /* hw_tcl_on */
1439 DECLARE_RENDERINPUTS(index_bitset); /* !hw_tcl_on */
1440 };
1441
1442 #define R300_OUTPUTS_WRITTEN_TEST(ow, vp_result, tnl_attrib) \
1443 ((hw_tcl_on) ? (ow).vp_outputs & (1 << (vp_result)) : \
1444 RENDERINPUTS_TEST( (ow.index_bitset), (tnl_attrib) ))
1445
1446 static void r300SetupRSUnit(GLcontext * ctx)
1447 {
1448 r300ContextPtr r300 = R300_CONTEXT(ctx);
1449 union r300_outputs_written OutputsWritten;
1450 GLuint InputsRead;
1451 int fp_reg, high_rr;
1452 int col_ip, tex_ip;
1453 int rs_tex_count = 0;
1454 int i, col_fmt, hw_tcl_on;
1455
1456 hw_tcl_on = r300->options.hw_tcl_enabled;
1457
1458 if (hw_tcl_on)
1459 OutputsWritten.vp_outputs = r300->selected_vp->Base->Base.OutputsWritten;
1460 else
1461 RENDERINPUTS_COPY(OutputsWritten.index_bitset, r300->render_inputs_bitset);
1462
1463 InputsRead = r300->selected_fp->Base->InputsRead;
1464
1465 R300_STATECHANGE(r300, ri);
1466 R300_STATECHANGE(r300, rc);
1467 R300_STATECHANGE(r300, rr);
1468
1469 fp_reg = col_ip = tex_ip = col_fmt = 0;
1470
1471 r300->hw.rc.cmd[1] = 0;
1472 r300->hw.rc.cmd[2] = 0;
1473 for (i=0; i<R300_RR_CMDSIZE-1; ++i)
1474 r300->hw.rr.cmd[R300_RR_INST_0 + i] = 0;
1475
1476 for (i=0; i<R300_RI_CMDSIZE-1; ++i)
1477 r300->hw.ri.cmd[R300_RI_INTERP_0 + i] = 0;
1478
1479
1480 if (InputsRead & FRAG_BIT_COL0) {
1481 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL0, _TNL_ATTRIB_COLOR0)) {
1482 r300->hw.ri.cmd[R300_RI_INTERP_0 + col_ip] = R300_RS_COL_PTR(col_ip) | R300_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
1483 r300->hw.rr.cmd[R300_RR_INST_0 + col_ip] = R300_RS_INST_COL_ID(col_ip) | R300_RS_INST_COL_CN_WRITE | R300_RS_INST_COL_ADDR(fp_reg);
1484 InputsRead &= ~FRAG_BIT_COL0;
1485 ++col_ip;
1486 ++fp_reg;
1487 } else {
1488 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1489 }
1490 }
1491
1492 if (InputsRead & FRAG_BIT_COL1) {
1493 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL1, _TNL_ATTRIB_COLOR1)) {
1494 r300->hw.ri.cmd[R300_RI_INTERP_0 + col_ip] = R300_RS_COL_PTR(col_ip) | R300_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
1495 r300->hw.rr.cmd[R300_RR_INST_0 + col_ip] = R300_RS_INST_COL_ID(col_ip) | R300_RS_INST_COL_CN_WRITE | R300_RS_INST_COL_ADDR(fp_reg);
1496 InputsRead &= ~FRAG_BIT_COL1;
1497 ++col_ip;
1498 ++fp_reg;
1499 } else {
1500 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1501 }
1502 }
1503
1504 /* We always route 4 texcoord components */
1505 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
1506 if (! ( InputsRead & FRAG_BIT_TEX(i) ) )
1507 continue;
1508
1509 if (!R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_TEX0 + i, _TNL_ATTRIB_TEX(i))) {
1510 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i);
1511 continue;
1512 }
1513
1514 r300->hw.ri.cmd[R300_RI_INTERP_0 + tex_ip] |= R300_RS_SEL_S(0) | R300_RS_SEL_T(1) | R300_RS_SEL_R(2) | R300_RS_SEL_Q(3) | R300_RS_TEX_PTR(rs_tex_count);
1515 r300->hw.rr.cmd[R300_RR_INST_0 + tex_ip] |= R300_RS_INST_TEX_ID(tex_ip) | R300_RS_INST_TEX_CN_WRITE | R300_RS_INST_TEX_ADDR(fp_reg);
1516 InputsRead &= ~(FRAG_BIT_TEX0 << i);
1517 rs_tex_count += 4;
1518 ++tex_ip;
1519 ++fp_reg;
1520 }
1521
1522 /* Setup default color if no color or tex was set */
1523 if (rs_tex_count == 0 && col_ip == 0) {
1524 r300->hw.rr.cmd[R300_RR_INST_0] = R300_RS_INST_COL_ID(0) | R300_RS_INST_COL_ADDR(0);
1525 r300->hw.ri.cmd[R300_RI_INTERP_0] = R300_RS_COL_PTR(0) | R300_RS_COL_FMT(R300_RS_COL_FMT_0001);
1526 ++col_ip;
1527 }
1528
1529 high_rr = (col_ip > tex_ip) ? col_ip : tex_ip;
1530 r300->hw.rc.cmd[1] |= (rs_tex_count << R300_IT_COUNT_SHIFT) | (col_ip << R300_IC_COUNT_SHIFT) | R300_HIRES_EN;
1531 r300->hw.rc.cmd[2] |= high_rr - 1;
1532
1533 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(r300->radeon.radeonScreen, R300_RS_INST_0, high_rr);
1534 r300->hw.ri.cmd[R300_RI_CMD_0] = cmdpacket0(r300->radeon.radeonScreen, R300_RS_IP_0, high_rr);
1535
1536 if (InputsRead)
1537 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead);
1538 }
1539
1540 static void r500SetupRSUnit(GLcontext * ctx)
1541 {
1542 r300ContextPtr r300 = R300_CONTEXT(ctx);
1543 union r300_outputs_written OutputsWritten;
1544 GLuint InputsRead;
1545 int fp_reg, high_rr;
1546 int col_ip, tex_ip;
1547 int rs_tex_count = 0;
1548 int i, col_fmt, hw_tcl_on;
1549
1550 hw_tcl_on = r300->options.hw_tcl_enabled;
1551
1552 if (hw_tcl_on)
1553 OutputsWritten.vp_outputs = r300->selected_vp->Base->Base.OutputsWritten;
1554 else
1555 RENDERINPUTS_COPY(OutputsWritten.index_bitset, r300->render_inputs_bitset);
1556
1557 InputsRead = r300->selected_fp->Base->InputsRead;
1558
1559 R300_STATECHANGE(r300, ri);
1560 R300_STATECHANGE(r300, rc);
1561 R300_STATECHANGE(r300, rr);
1562
1563 fp_reg = col_ip = tex_ip = col_fmt = 0;
1564
1565 r300->hw.rc.cmd[1] = 0;
1566 r300->hw.rc.cmd[2] = 0;
1567 for (i=0; i<R300_RR_CMDSIZE-1; ++i)
1568 r300->hw.rr.cmd[R300_RR_INST_0 + i] = 0;
1569
1570 for (i=0; i<R500_RI_CMDSIZE-1; ++i)
1571 r300->hw.ri.cmd[R300_RI_INTERP_0 + i] = 0;
1572
1573
1574 if (InputsRead & FRAG_BIT_COL0) {
1575 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL0, _TNL_ATTRIB_COLOR0)) {
1576 r300->hw.ri.cmd[R300_RI_INTERP_0 + col_ip] = R500_RS_COL_PTR(col_ip) | R500_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
1577 r300->hw.rr.cmd[R300_RR_INST_0 + col_ip] = R500_RS_INST_COL_ID(col_ip) | R500_RS_INST_COL_CN_WRITE | R500_RS_INST_COL_ADDR(fp_reg);
1578 InputsRead &= ~FRAG_BIT_COL0;
1579 ++col_ip;
1580 ++fp_reg;
1581 } else {
1582 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1583 }
1584 }
1585
1586 if (InputsRead & FRAG_BIT_COL1) {
1587 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL1, _TNL_ATTRIB_COLOR1)) {
1588 r300->hw.ri.cmd[R300_RI_INTERP_0 + col_ip] = R500_RS_COL_PTR(col_ip) | R500_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
1589 r300->hw.rr.cmd[R300_RR_INST_0 + col_ip] = R500_RS_INST_COL_ID(col_ip) | R500_RS_INST_COL_CN_WRITE | R500_RS_INST_COL_ADDR(fp_reg);
1590 InputsRead &= ~FRAG_BIT_COL1;
1591 ++col_ip;
1592 ++fp_reg;
1593 } else {
1594 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1595 }
1596 }
1597
1598 /* We always route 4 texcoord components */
1599 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
1600 if (! ( InputsRead & FRAG_BIT_TEX(i) ) )
1601 continue;
1602
1603 if (!R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_TEX0 + i, _TNL_ATTRIB_TEX(i))) {
1604 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i);
1605 continue;
1606 }
1607
1608 r300->hw.ri.cmd[R300_RI_INTERP_0 + tex_ip] |= ((rs_tex_count + 0) << R500_RS_IP_TEX_PTR_S_SHIFT) |
1609 ((rs_tex_count + 1) << R500_RS_IP_TEX_PTR_T_SHIFT) |
1610 ((rs_tex_count + 2) << R500_RS_IP_TEX_PTR_R_SHIFT) |
1611 ((rs_tex_count + 3) << R500_RS_IP_TEX_PTR_Q_SHIFT);
1612
1613 r300->hw.rr.cmd[R300_RR_INST_0 + tex_ip] |= R500_RS_INST_TEX_ID(tex_ip) | R500_RS_INST_TEX_CN_WRITE | R500_RS_INST_TEX_ADDR(fp_reg);
1614 InputsRead &= ~(FRAG_BIT_TEX0 << i);
1615 rs_tex_count += 4;
1616 ++tex_ip;
1617 ++fp_reg;
1618 }
1619
1620 /* Setup default color if no color or tex was set */
1621 if (rs_tex_count == 0 && col_ip == 0) {
1622 r300->hw.rr.cmd[R300_RR_INST_0] = R500_RS_INST_COL_ID(0) | R500_RS_INST_COL_ADDR(0);
1623 r300->hw.ri.cmd[R300_RI_INTERP_0] = R500_RS_COL_PTR(0) | R500_RS_COL_FMT(R300_RS_COL_FMT_0001);
1624 ++col_ip;
1625 }
1626
1627 high_rr = (col_ip > tex_ip) ? col_ip : tex_ip;
1628 r300->hw.rc.cmd[1] = (rs_tex_count << R300_IT_COUNT_SHIFT) | (col_ip << R300_IC_COUNT_SHIFT) | R300_HIRES_EN;
1629 r300->hw.rc.cmd[2] = 0xC0 | (high_rr - 1);
1630
1631 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(r300->radeon.radeonScreen, R500_RS_INST_0, high_rr);
1632 r300->hw.ri.cmd[R300_RI_CMD_0] = cmdpacket0(r300->radeon.radeonScreen, R500_RS_IP_0, high_rr);
1633
1634 if (InputsRead)
1635 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead);
1636 }
1637
1638 #define MIN3(a, b, c) ((a) < (b) ? MIN2(a, c) : MIN2(b, c))
1639
1640 void r300VapCntl(r300ContextPtr rmesa, GLuint input_count,
1641 GLuint output_count, GLuint temp_count)
1642 {
1643 int vtx_mem_size;
1644 int pvs_num_slots;
1645 int pvs_num_cntrls;
1646
1647 /* Flush PVS engine before changing PVS_NUM_SLOTS, PVS_NUM_CNTRLS.
1648 * See r500 docs 6.5.2 - done in emit */
1649
1650 /* avoid division by zero */
1651 if (input_count == 0) input_count = 1;
1652 if (output_count == 0) output_count = 1;
1653 if (temp_count == 0) temp_count = 1;
1654
1655 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)
1656 vtx_mem_size = 128;
1657 else
1658 vtx_mem_size = 72;
1659
1660 pvs_num_slots = MIN3(10, vtx_mem_size/input_count, vtx_mem_size/output_count);
1661 pvs_num_cntrls = MIN2(6, vtx_mem_size/temp_count);
1662
1663 R300_STATECHANGE(rmesa, vap_cntl);
1664 if (rmesa->options.hw_tcl_enabled) {
1665 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] =
1666 (pvs_num_slots << R300_PVS_NUM_SLOTS_SHIFT) |
1667 (pvs_num_cntrls << R300_PVS_NUM_CNTLRS_SHIFT) |
1668 (12 << R300_VF_MAX_VTX_NUM_SHIFT);
1669 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)
1670 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= R500_TCL_STATE_OPTIMIZATION;
1671 } else
1672 /* not sure about non-tcl */
1673 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] = ((10 << R300_PVS_NUM_SLOTS_SHIFT) |
1674 (5 << R300_PVS_NUM_CNTLRS_SHIFT) |
1675 (5 << R300_VF_MAX_VTX_NUM_SHIFT));
1676
1677 if (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV515)
1678 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (2 << R300_PVS_NUM_FPUS_SHIFT);
1679 else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV530) ||
1680 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV560) ||
1681 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV570))
1682 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (5 << R300_PVS_NUM_FPUS_SHIFT);
1683 else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV410) ||
1684 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R420))
1685 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (6 << R300_PVS_NUM_FPUS_SHIFT);
1686 else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R520) ||
1687 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R580))
1688 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (8 << R300_PVS_NUM_FPUS_SHIFT);
1689 else
1690 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (4 << R300_PVS_NUM_FPUS_SHIFT);
1691
1692 }
1693
1694 /**
1695 * Enable/Disable states.
1696 *
1697 * \note Mesa already filters redundant calls to this function.
1698 */
1699 static void r300Enable(GLcontext * ctx, GLenum cap, GLboolean state)
1700 {
1701 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1702 if (RADEON_DEBUG & DEBUG_STATE)
1703 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
1704 _mesa_lookup_enum_by_nr(cap),
1705 state ? "GL_TRUE" : "GL_FALSE");
1706
1707 switch (cap) {
1708 case GL_ALPHA_TEST:
1709 r300SetAlphaState(ctx);
1710 break;
1711 case GL_COLOR_LOGIC_OP:
1712 r300SetLogicOpState(ctx);
1713 /* fall-through, because logic op overrides blending */
1714 case GL_BLEND:
1715 r300SetBlendState(ctx);
1716 break;
1717 case GL_CLIP_PLANE0:
1718 case GL_CLIP_PLANE1:
1719 case GL_CLIP_PLANE2:
1720 case GL_CLIP_PLANE3:
1721 case GL_CLIP_PLANE4:
1722 case GL_CLIP_PLANE5:
1723 r300SetClipPlaneState(ctx, cap, state);
1724 break;
1725 case GL_CULL_FACE:
1726 r300UpdateCulling(ctx);
1727 break;
1728 case GL_DEPTH_TEST:
1729 r300SetDepthState(ctx);
1730 break;
1731 case GL_LINE_SMOOTH:
1732 if (rmesa->options.conformance_mode)
1733 r300SwitchFallback(ctx, R300_FALLBACK_LINE_SMOOTH, ctx->Line.SmoothFlag);
1734 break;
1735 case GL_LINE_STIPPLE:
1736 if (rmesa->options.conformance_mode)
1737 r300SwitchFallback(ctx, R300_FALLBACK_LINE_STIPPLE, ctx->Line.StippleFlag);
1738 break;
1739 case GL_POINT_SMOOTH:
1740 if (rmesa->options.conformance_mode)
1741 r300SwitchFallback(ctx, R300_FALLBACK_POINT_SMOOTH, ctx->Point.SmoothFlag);
1742 break;
1743 case GL_POLYGON_SMOOTH:
1744 if (rmesa->options.conformance_mode)
1745 r300SwitchFallback(ctx, R300_FALLBACK_POLYGON_SMOOTH, ctx->Polygon.SmoothFlag);
1746 break;
1747 case GL_POLYGON_STIPPLE:
1748 if (rmesa->options.conformance_mode)
1749 r300SwitchFallback(ctx, R300_FALLBACK_POLYGON_STIPPLE, ctx->Polygon.StippleFlag);
1750 break;
1751 case GL_POLYGON_OFFSET_POINT:
1752 case GL_POLYGON_OFFSET_LINE:
1753 case GL_POLYGON_OFFSET_FILL:
1754 r300SetPolygonOffsetState(ctx, state);
1755 break;
1756 case GL_SCISSOR_TEST:
1757 radeon_firevertices(&rmesa->radeon);
1758 rmesa->radeon.state.scissor.enabled = state;
1759 radeonUpdateScissor( ctx );
1760 break;
1761 case GL_STENCIL_TEST:
1762 r300SetStencilState(ctx, state);
1763 break;
1764 default:
1765 break;
1766 }
1767 }
1768
1769 /**
1770 * Completely recalculates hardware state based on the Mesa state.
1771 */
1772 static void r300ResetHwState(r300ContextPtr r300)
1773 {
1774 GLcontext *ctx = r300->radeon.glCtx;
1775 int has_tcl;
1776
1777 has_tcl = r300->options.hw_tcl_enabled;
1778
1779 if (RADEON_DEBUG & DEBUG_STATE)
1780 fprintf(stderr, "%s\n", __FUNCTION__);
1781
1782 radeon_firevertices(&r300->radeon);
1783
1784 r300ColorMask(ctx,
1785 ctx->Color.ColorMask[RCOMP],
1786 ctx->Color.ColorMask[GCOMP],
1787 ctx->Color.ColorMask[BCOMP], ctx->Color.ColorMask[ACOMP]);
1788
1789 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1790 r300DepthMask(ctx, ctx->Depth.Mask);
1791 r300DepthFunc(ctx, ctx->Depth.Func);
1792
1793 /* stencil */
1794 r300Enable(ctx, GL_STENCIL_TEST, ctx->Stencil._Enabled);
1795 r300StencilMaskSeparate(ctx, 0, ctx->Stencil.WriteMask[0]);
1796 r300StencilFuncSeparate(ctx, 0, ctx->Stencil.Function[0],
1797 ctx->Stencil.Ref[0], ctx->Stencil.ValueMask[0]);
1798 r300StencilOpSeparate(ctx, 0, ctx->Stencil.FailFunc[0],
1799 ctx->Stencil.ZFailFunc[0],
1800 ctx->Stencil.ZPassFunc[0]);
1801
1802 r300UpdateCulling(ctx);
1803
1804 r300SetBlendState(ctx);
1805 r300SetLogicOpState(ctx);
1806
1807 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1808 r300Enable(ctx, GL_ALPHA_TEST, ctx->Color.AlphaEnabled);
1809
1810 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1811 | R300_VPORT_X_OFFSET_ENA
1812 | R300_VPORT_Y_SCALE_ENA
1813 | R300_VPORT_Y_OFFSET_ENA
1814 | R300_VPORT_Z_SCALE_ENA
1815 | R300_VPORT_Z_OFFSET_ENA | R300_VTX_W0_FMT;
1816 r300->hw.vte.cmd[2] = 0x00000008;
1817
1818 r300->hw.vap_vf_max_vtx_indx.cmd[1] = 0x00FFFFFF;
1819 r300->hw.vap_vf_max_vtx_indx.cmd[2] = 0x00000000;
1820
1821 #ifdef MESA_LITTLE_ENDIAN
1822 r300->hw.vap_cntl_status.cmd[1] = R300_VC_NO_SWAP;
1823 #else
1824 r300->hw.vap_cntl_status.cmd[1] = R300_VC_32BIT_SWAP;
1825 #endif
1826
1827 /* disable VAP/TCL on non-TCL capable chips */
1828 if (!has_tcl)
1829 r300->hw.vap_cntl_status.cmd[1] |= R300_VAP_TCL_BYPASS;
1830
1831 r300->hw.vap_psc_sgn_norm_cntl.cmd[1] = 0xAAAAAAAA;
1832
1833 /* XXX: Other families? */
1834 if (has_tcl) {
1835 r300->hw.vap_clip_cntl.cmd[1] = R300_PS_UCP_MODE_DIST_COP;
1836
1837 r300->hw.vap_clip.cmd[1] = r300PackFloat32(1.0); /* X */
1838 r300->hw.vap_clip.cmd[2] = r300PackFloat32(1.0); /* X */
1839 r300->hw.vap_clip.cmd[3] = r300PackFloat32(1.0); /* Y */
1840 r300->hw.vap_clip.cmd[4] = r300PackFloat32(1.0); /* Y */
1841
1842 switch (r300->radeon.radeonScreen->chip_family) {
1843 case CHIP_FAMILY_R300:
1844 r300->hw.vap_pvs_vtx_timeout_reg.cmd[1] = R300_2288_R300;
1845 break;
1846 default:
1847 r300->hw.vap_pvs_vtx_timeout_reg.cmd[1] = R300_2288_RV350;
1848 break;
1849 }
1850 }
1851
1852 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1853 | R300_GB_LINE_STUFF_ENABLE
1854 | R300_GB_TRIANGLE_STUFF_ENABLE;
1855
1856 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1857 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1858
1859 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] =
1860 R300_GB_TILE_ENABLE | R300_GB_TILE_SIZE_16 /*| R300_GB_SUBPIXEL_1_16*/;
1861 switch (r300->radeon.radeonScreen->num_gb_pipes) {
1862 case 1:
1863 default:
1864 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
1865 R300_GB_TILE_PIPE_COUNT_RV300;
1866 break;
1867 case 2:
1868 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
1869 R300_GB_TILE_PIPE_COUNT_R300;
1870 break;
1871 case 3:
1872 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
1873 R300_GB_TILE_PIPE_COUNT_R420_3P;
1874 break;
1875 case 4:
1876 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
1877 R300_GB_TILE_PIPE_COUNT_R420;
1878 break;
1879 }
1880
1881 /* XXX: Enable anti-aliasing? */
1882 r300->hw.gb_misc2.cmd[R300_GB_MISC2_AA_CONFIG] = GB_AA_CONFIG_AA_DISABLE;
1883 r300->hw.gb_misc2.cmd[R300_GB_MISC2_SELECT] = 0;
1884
1885 r300->hw.ga_point_s0.cmd[1] = r300PackFloat32(0.0);
1886 r300->hw.ga_point_s0.cmd[2] = r300PackFloat32(0.0);
1887 r300->hw.ga_point_s0.cmd[3] = r300PackFloat32(1.0);
1888 r300->hw.ga_point_s0.cmd[4] = r300PackFloat32(1.0);
1889
1890 r300->hw.ga_triangle_stipple.cmd[1] = 0x00050005;
1891
1892 r300PointSize(ctx, 1.0);
1893
1894 r300->hw.ga_point_minmax.cmd[1] = 0x18000006;
1895 r300->hw.ga_point_minmax.cmd[2] = 0x00020006;
1896 r300->hw.ga_point_minmax.cmd[3] = r300PackFloat32(1.0 / 192.0);
1897
1898 r300LineWidth(ctx, 1.0);
1899
1900 r300->hw.ga_line_stipple.cmd[1] = 0;
1901 r300->hw.ga_line_stipple.cmd[2] = r300PackFloat32(0.0);
1902 r300->hw.ga_line_stipple.cmd[3] = r300PackFloat32(1.0);
1903
1904 r300ShadeModel(ctx, ctx->Light.ShadeModel);
1905
1906 r300PolygonMode(ctx, GL_FRONT, ctx->Polygon.FrontMode);
1907 r300PolygonMode(ctx, GL_BACK, ctx->Polygon.BackMode);
1908 r300->hw.zbias_cntl.cmd[1] = 0x00000000;
1909
1910 r300PolygonOffset(ctx, ctx->Polygon.OffsetFactor,
1911 ctx->Polygon.OffsetUnits);
1912 r300Enable(ctx, GL_POLYGON_OFFSET_POINT, ctx->Polygon.OffsetPoint);
1913 r300Enable(ctx, GL_POLYGON_OFFSET_LINE, ctx->Polygon.OffsetLine);
1914 r300Enable(ctx, GL_POLYGON_OFFSET_FILL, ctx->Polygon.OffsetFill);
1915
1916 r300->hw.su_depth_scale.cmd[1] = 0x4B7FFFFF;
1917 r300->hw.su_depth_scale.cmd[2] = 0x00000000;
1918
1919 r300->hw.sc_hyperz.cmd[1] = 0x0000001C;
1920 r300->hw.sc_hyperz.cmd[2] = 0x2DA49525;
1921
1922 r300->hw.sc_screendoor.cmd[1] = 0x00FFFFFF;
1923
1924 r300->hw.us_out_fmt.cmd[1] = R500_OUT_FMT_C4_8 |
1925 R500_C0_SEL_B | R500_C1_SEL_G | R500_C2_SEL_R | R500_C3_SEL_A;
1926 r300->hw.us_out_fmt.cmd[2] = R500_OUT_FMT_UNUSED |
1927 R500_C0_SEL_B | R500_C1_SEL_G | R500_C2_SEL_R | R500_C3_SEL_A;
1928 r300->hw.us_out_fmt.cmd[3] = R500_OUT_FMT_UNUSED |
1929 R500_C0_SEL_B | R500_C1_SEL_G | R500_C2_SEL_R | R500_C3_SEL_A;
1930 r300->hw.us_out_fmt.cmd[4] = R500_OUT_FMT_UNUSED |
1931 R500_C0_SEL_B | R500_C1_SEL_G | R500_C2_SEL_R | R500_C3_SEL_A;
1932 r300->hw.us_out_fmt.cmd[5] = R300_W_FMT_W0 | R300_W_SRC_US;
1933
1934 /* disable fog unit */
1935 r300->hw.fogs.cmd[R300_FOGS_STATE] = 0;
1936 r300->hw.fg_depth_src.cmd[1] = R300_FG_DEPTH_SRC_SCAN;
1937
1938 r300->hw.rb3d_cctl.cmd[1] = 0;
1939
1940 r300BlendColor(ctx, ctx->Color.BlendColor);
1941
1942 r300->hw.rb3d_dither_ctl.cmd[1] = 0;
1943 r300->hw.rb3d_dither_ctl.cmd[2] = 0;
1944 r300->hw.rb3d_dither_ctl.cmd[3] = 0;
1945 r300->hw.rb3d_dither_ctl.cmd[4] = 0;
1946 r300->hw.rb3d_dither_ctl.cmd[5] = 0;
1947 r300->hw.rb3d_dither_ctl.cmd[6] = 0;
1948 r300->hw.rb3d_dither_ctl.cmd[7] = 0;
1949 r300->hw.rb3d_dither_ctl.cmd[8] = 0;
1950 r300->hw.rb3d_dither_ctl.cmd[9] = 0;
1951
1952 r300->hw.rb3d_aaresolve_ctl.cmd[1] = 0;
1953
1954 r300->hw.rb3d_discard_src_pixel_lte_threshold.cmd[1] = 0x00000000;
1955 r300->hw.rb3d_discard_src_pixel_lte_threshold.cmd[2] = 0xffffffff;
1956
1957 r300->hw.zb_depthclearvalue.cmd[1] = 0;
1958
1959 r300->hw.zstencil_format.cmd[2] = R300_ZTOP_DISABLE;
1960 r300->hw.zstencil_format.cmd[3] = 0x00000003;
1961 r300->hw.zstencil_format.cmd[4] = 0x00000000;
1962 r300SetEarlyZState(ctx);
1963
1964 r300->hw.zb_zmask.cmd[1] = 0;
1965 r300->hw.zb_zmask.cmd[2] = 0;
1966
1967 r300->hw.zb_hiz_offset.cmd[1] = 0;
1968
1969 r300->hw.zb_hiz_pitch.cmd[1] = 0;
1970
1971 r300VapCntl(r300, 0, 0, 0);
1972 if (has_tcl) {
1973 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1974 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1975 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1976 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1977 }
1978
1979 r300->radeon.hw.all_dirty = GL_TRUE;
1980 }
1981
1982 void r300UpdateShaders(r300ContextPtr rmesa)
1983 {
1984 GLcontext *ctx = rmesa->radeon.glCtx;
1985
1986 /* should only happenen once, just after context is created */
1987 /* TODO: shouldn't we fallback to sw here? */
1988 if (!ctx->FragmentProgram._Current) {
1989 _mesa_fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
1990 return;
1991 }
1992
1993 {
1994 struct r300_fragment_program *fp;
1995
1996 fp = r300SelectFragmentShader(ctx);
1997 if (!fp->translated)
1998 r300TranslateFragmentShader(ctx, fp);
1999
2000 r300SwitchFallback(ctx, R300_FALLBACK_FRAGMENT_PROGRAM, fp->error);
2001 }
2002
2003 if (rmesa->options.hw_tcl_enabled) {
2004 struct r300_vertex_program *vp;
2005
2006 if (rmesa->radeon.NewGLState) {
2007 int i;
2008 for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) {
2009 rmesa->temp_attrib[i] =
2010 TNL_CONTEXT(ctx)->vb.AttribPtr[i];
2011 TNL_CONTEXT(ctx)->vb.AttribPtr[i] =
2012 &rmesa->dummy_attrib[i];
2013 }
2014
2015 _tnl_UpdateFixedFunctionProgram(ctx);
2016
2017 for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) {
2018 TNL_CONTEXT(ctx)->vb.AttribPtr[i] =
2019 rmesa->temp_attrib[i];
2020 }
2021 }
2022
2023 vp = r300SelectVertexShader(ctx);
2024 if (!vp->translated)
2025 r300TranslateVertexShader(vp);
2026
2027 r300SwitchFallback(ctx, R300_FALLBACK_VERTEX_PROGRAM, vp->error);
2028 }
2029
2030 r300UpdateStateParameters(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
2031 rmesa->radeon.NewGLState = 0;
2032 }
2033
2034 static const GLfloat *get_fragmentprogram_constant(GLcontext *ctx,
2035 struct gl_program *program, struct prog_src_register srcreg)
2036 {
2037 static const GLfloat dummy[4] = { 0, 0, 0, 0 };
2038
2039 switch(srcreg.File) {
2040 case PROGRAM_LOCAL_PARAM:
2041 return program->LocalParams[srcreg.Index];
2042 case PROGRAM_ENV_PARAM:
2043 return ctx->FragmentProgram.Parameters[srcreg.Index];
2044 case PROGRAM_STATE_VAR:
2045 case PROGRAM_NAMED_PARAM:
2046 case PROGRAM_CONSTANT:
2047 return program->Parameters->ParameterValues[srcreg.Index];
2048 default:
2049 _mesa_problem(ctx, "get_fragmentprogram_constant: Unknown\n");
2050 return dummy;
2051 }
2052 }
2053
2054
2055 static void r300SetupPixelShader(GLcontext *ctx)
2056 {
2057 r300ContextPtr rmesa = R300_CONTEXT(ctx);
2058 struct r300_fragment_program *fp = rmesa->selected_fp;
2059 struct r300_fragment_program_code *code;
2060 int i, k;
2061
2062 code = &fp->code.r300;
2063
2064 R300_STATECHANGE(rmesa, fpi[0]);
2065 R300_STATECHANGE(rmesa, fpi[1]);
2066 R300_STATECHANGE(rmesa, fpi[2]);
2067 R300_STATECHANGE(rmesa, fpi[3]);
2068 rmesa->hw.fpi[0].cmd[R300_FPI_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_US_ALU_RGB_INST_0, code->alu.length);
2069 rmesa->hw.fpi[1].cmd[R300_FPI_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_US_ALU_RGB_ADDR_0, code->alu.length);
2070 rmesa->hw.fpi[2].cmd[R300_FPI_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_US_ALU_ALPHA_INST_0, code->alu.length);
2071 rmesa->hw.fpi[3].cmd[R300_FPI_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_US_ALU_ALPHA_ADDR_0, code->alu.length);
2072 for (i = 0; i < code->alu.length; i++) {
2073 rmesa->hw.fpi[0].cmd[R300_FPI_INSTR_0 + i] = code->alu.inst[i].inst0;
2074 rmesa->hw.fpi[1].cmd[R300_FPI_INSTR_0 + i] = code->alu.inst[i].inst1;
2075 rmesa->hw.fpi[2].cmd[R300_FPI_INSTR_0 + i] = code->alu.inst[i].inst2;
2076 rmesa->hw.fpi[3].cmd[R300_FPI_INSTR_0 + i] = code->alu.inst[i].inst3;
2077 }
2078
2079 R300_STATECHANGE(rmesa, fp);
2080 rmesa->hw.fp.cmd[R300_FP_CNTL0] = code->cur_node | (code->first_node_has_tex << 3);
2081 rmesa->hw.fp.cmd[R300_FP_CNTL1] = code->max_temp_idx;
2082 rmesa->hw.fp.cmd[R300_FP_CNTL2] =
2083 (0 << R300_PFS_CNTL_ALU_OFFSET_SHIFT) |
2084 ((code->alu.length-1) << R300_PFS_CNTL_ALU_END_SHIFT) |
2085 (0 << R300_PFS_CNTL_TEX_OFFSET_SHIFT) |
2086 ((code->tex.length ? code->tex.length-1 : 0) << R300_PFS_CNTL_TEX_END_SHIFT);
2087 /* I just want to say, the way these nodes are stored.. weird.. */
2088 for (i = 0, k = (4 - (code->cur_node + 1)); i < 4; i++, k++) {
2089 if (i < (code->cur_node + 1)) {
2090 rmesa->hw.fp.cmd[R300_FP_NODE0 + k] =
2091 (code->node[i].alu_offset << R300_ALU_START_SHIFT) |
2092 (code->node[i].alu_end << R300_ALU_SIZE_SHIFT) |
2093 (code->node[i].tex_offset << R300_TEX_START_SHIFT) |
2094 (code->node[i].tex_end << R300_TEX_SIZE_SHIFT) |
2095 code->node[i].flags;
2096 } else {
2097 rmesa->hw.fp.cmd[R300_FP_NODE0 + (3 - i)] = 0;
2098 }
2099 }
2100
2101 R300_STATECHANGE(rmesa, fpp);
2102 rmesa->hw.fpp.cmd[R300_FPP_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_PFS_PARAM_0_X, code->const_nr * 4);
2103 for (i = 0; i < code->const_nr; i++) {
2104 const GLfloat *constant = get_fragmentprogram_constant(ctx, fp->Base, code->constant[i]);
2105 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 0] = r300PackFloat24(constant[0]);
2106 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 1] = r300PackFloat24(constant[1]);
2107 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 2] = r300PackFloat24(constant[2]);
2108 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 3] = r300PackFloat24(constant[3]);
2109 }
2110 }
2111
2112 #define bump_r500fp_count(ptr, new_count) do{\
2113 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2114 int _nc=(new_count)/6; \
2115 assert(_nc < 256); \
2116 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2117 } while(0)
2118
2119 #define bump_r500fp_const_count(ptr, new_count) do{\
2120 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2121 int _nc=(new_count)/4; \
2122 assert(_nc < 256); \
2123 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2124 } while(0)
2125
2126 static void r500SetupPixelShader(GLcontext *ctx)
2127 {
2128 r300ContextPtr rmesa = R300_CONTEXT(ctx);
2129 struct r300_fragment_program *fp = rmesa->selected_fp;
2130 int i;
2131 struct r500_fragment_program_code *code;
2132
2133 ((drm_r300_cmd_header_t *) rmesa->hw.r500fp.cmd)->r500fp.count = 0;
2134 ((drm_r300_cmd_header_t *) rmesa->hw.r500fp_const.cmd)->r500fp.count = 0;
2135
2136 code = &fp->code.r500;
2137
2138 R300_STATECHANGE(rmesa, fp);
2139 rmesa->hw.fp.cmd[R500_FP_PIXSIZE] = code->max_temp_idx;
2140
2141 rmesa->hw.fp.cmd[R500_FP_CODE_ADDR] =
2142 R500_US_CODE_START_ADDR(code->inst_offset) |
2143 R500_US_CODE_END_ADDR(code->inst_end);
2144 rmesa->hw.fp.cmd[R500_FP_CODE_RANGE] =
2145 R500_US_CODE_RANGE_ADDR(code->inst_offset) |
2146 R500_US_CODE_RANGE_SIZE(code->inst_end);
2147 rmesa->hw.fp.cmd[R500_FP_CODE_OFFSET] =
2148 R500_US_CODE_OFFSET_ADDR(0); /* FIXME when we add flow control */
2149
2150 R300_STATECHANGE(rmesa, r500fp);
2151 /* Emit our shader... */
2152 for (i = 0; i < code->inst_end+1; i++) {
2153 rmesa->hw.r500fp.cmd[i*6+1] = code->inst[i].inst0;
2154 rmesa->hw.r500fp.cmd[i*6+2] = code->inst[i].inst1;
2155 rmesa->hw.r500fp.cmd[i*6+3] = code->inst[i].inst2;
2156 rmesa->hw.r500fp.cmd[i*6+4] = code->inst[i].inst3;
2157 rmesa->hw.r500fp.cmd[i*6+5] = code->inst[i].inst4;
2158 rmesa->hw.r500fp.cmd[i*6+6] = code->inst[i].inst5;
2159 }
2160
2161 bump_r500fp_count(rmesa->hw.r500fp.cmd, (code->inst_end + 1) * 6);
2162
2163 R300_STATECHANGE(rmesa, r500fp_const);
2164 for (i = 0; i < code->const_nr; i++) {
2165 const GLfloat *constant = get_fragmentprogram_constant(ctx, fp->Base, code->constant[i]);
2166 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 0] = r300PackFloat32(constant[0]);
2167 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 1] = r300PackFloat32(constant[1]);
2168 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 2] = r300PackFloat32(constant[2]);
2169 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 3] = r300PackFloat32(constant[3]);
2170 }
2171 bump_r500fp_const_count(rmesa->hw.r500fp_const.cmd, code->const_nr * 4);
2172 }
2173
2174 void r300SetupVAP(GLcontext *ctx, GLuint InputsRead, GLuint OutputsWritten)
2175 {
2176 r300ContextPtr rmesa = R300_CONTEXT( ctx );
2177 struct vertex_attribute *attrs = rmesa->vbuf.attribs;
2178 int i, j, reg_count;
2179 uint32_t *vir0 = &rmesa->hw.vir[0].cmd[1];
2180 uint32_t *vir1 = &rmesa->hw.vir[1].cmd[1];
2181
2182 for (i = 0; i < R300_VIR_CMDSIZE-1; ++i)
2183 vir0[i] = vir1[i] = 0;
2184
2185 for (i = 0, j = 0; i < rmesa->vbuf.num_attribs; ++i) {
2186 int tmp;
2187
2188 tmp = attrs[i].data_type | (attrs[i].dst_loc << R300_DST_VEC_LOC_SHIFT);
2189 if (attrs[i]._signed)
2190 tmp |= R300_SIGNED;
2191 if (attrs[i].normalize)
2192 tmp |= R300_NORMALIZE;
2193
2194 if (i % 2 == 0) {
2195 vir0[j] = tmp << R300_DATA_TYPE_0_SHIFT;
2196 vir1[j] = attrs[i].swizzle | (attrs[i].write_mask << R300_WRITE_ENA_SHIFT);
2197 } else {
2198 vir0[j] |= tmp << R300_DATA_TYPE_1_SHIFT;
2199 vir1[j] |= (attrs[i].swizzle | (attrs[i].write_mask << R300_WRITE_ENA_SHIFT)) << R300_SWIZZLE1_SHIFT;
2200 ++j;
2201 }
2202 }
2203
2204 reg_count = (rmesa->vbuf.num_attribs + 1) >> 1;
2205 if (rmesa->vbuf.num_attribs % 2 != 0) {
2206 vir0[reg_count-1] |= R300_LAST_VEC << R300_DATA_TYPE_0_SHIFT;
2207 } else {
2208 vir0[reg_count-1] |= R300_LAST_VEC << R300_DATA_TYPE_1_SHIFT;
2209 }
2210
2211 R300_STATECHANGE(rmesa, vir[0]);
2212 R300_STATECHANGE(rmesa, vir[1]);
2213 R300_STATECHANGE(rmesa, vof);
2214 R300_STATECHANGE(rmesa, vic);
2215
2216 if (rmesa->radeon.radeonScreen->kernel_mm) {
2217 rmesa->hw.vir[0].cmd[0] &= 0xC000FFFF;
2218 rmesa->hw.vir[1].cmd[0] &= 0xC000FFFF;
2219 rmesa->hw.vir[0].cmd[0] |= (reg_count & 0x3FFF) << 16;
2220 rmesa->hw.vir[1].cmd[0] |= (reg_count & 0x3FFF) << 16;
2221 } else {
2222 ((drm_r300_cmd_header_t *) rmesa->hw.vir[0].cmd)->packet0.count = reg_count;
2223 ((drm_r300_cmd_header_t *) rmesa->hw.vir[1].cmd)->packet0.count = reg_count;
2224 }
2225
2226 rmesa->hw.vic.cmd[R300_VIC_CNTL_0] = r300VAPInputCntl0(ctx, InputsRead);
2227 rmesa->hw.vic.cmd[R300_VIC_CNTL_1] = r300VAPInputCntl1(ctx, InputsRead);
2228 rmesa->hw.vof.cmd[R300_VOF_CNTL_0] = r300VAPOutputCntl0(ctx, OutputsWritten);
2229 rmesa->hw.vof.cmd[R300_VOF_CNTL_1] = r300VAPOutputCntl1(ctx, OutputsWritten);
2230 }
2231
2232 void r300UpdateShaderStates(r300ContextPtr rmesa)
2233 {
2234 GLcontext *ctx;
2235 ctx = rmesa->radeon.glCtx;
2236
2237 /* should only happenen once, just after context is created */
2238 if (!ctx->FragmentProgram._Current)
2239 return;
2240
2241 r300SetEarlyZState(ctx);
2242
2243 r300SetupTextures(ctx);
2244
2245 rmesa->vtbl.SetupPixelShader(ctx);
2246
2247 rmesa->vtbl.SetupRSUnit(ctx);
2248
2249 if (rmesa->options.hw_tcl_enabled) {
2250 r300SetupVertexProgram(rmesa);
2251 }
2252 }
2253
2254 /**
2255 * Called by Mesa after an internal state update.
2256 */
2257 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
2258 {
2259 r300ContextPtr r300 = R300_CONTEXT(ctx);
2260
2261 _swrast_InvalidateState(ctx, new_state);
2262 _swsetup_InvalidateState(ctx, new_state);
2263 _vbo_InvalidateState(ctx, new_state);
2264 _tnl_InvalidateState(ctx, new_state);
2265
2266 if (new_state & _NEW_BUFFERS) {
2267 _mesa_update_framebuffer(ctx);
2268 /* this updates the DrawBuffer's Width/Height if it's a FBO */
2269 _mesa_update_draw_buffer_bounds(ctx);
2270
2271 R300_STATECHANGE(r300, cb);
2272 }
2273
2274 r300->radeon.NewGLState |= new_state;
2275 }
2276
2277 /**
2278 * Calculate initial hardware state and register state functions.
2279 * Assumes that the command buffer and state atoms have been
2280 * initialized already.
2281 */
2282 void r300InitState(r300ContextPtr r300)
2283 {
2284 r300ResetHwState(r300);
2285 }
2286
2287 static void r300RenderMode(GLcontext * ctx, GLenum mode)
2288 {
2289 r300SwitchFallback(ctx, R300_FALLBACK_RENDER_MODE, ctx->RenderMode != GL_RENDER);
2290 }
2291
2292 /**
2293 * Initialize driver's state callback functions
2294 */
2295 void r300InitStateFuncs(struct dd_function_table *functions)
2296 {
2297
2298 functions->UpdateState = r300InvalidateState;
2299 functions->AlphaFunc = r300AlphaFunc;
2300 functions->BlendColor = r300BlendColor;
2301 functions->BlendEquationSeparate = r300BlendEquationSeparate;
2302 functions->BlendFuncSeparate = r300BlendFuncSeparate;
2303 functions->Enable = r300Enable;
2304 functions->ColorMask = r300ColorMask;
2305 functions->DepthFunc = r300DepthFunc;
2306 functions->DepthMask = r300DepthMask;
2307 functions->CullFace = r300CullFace;
2308 functions->FrontFace = r300FrontFace;
2309 functions->ShadeModel = r300ShadeModel;
2310 functions->LogicOpcode = r300LogicOpcode;
2311
2312 /* ARB_point_parameters */
2313 functions->PointParameterfv = r300PointParameter;
2314
2315 /* Stencil related */
2316 functions->StencilFuncSeparate = r300StencilFuncSeparate;
2317 functions->StencilMaskSeparate = r300StencilMaskSeparate;
2318 functions->StencilOpSeparate = r300StencilOpSeparate;
2319
2320 /* Viewport related */
2321 functions->Viewport = r300Viewport;
2322 functions->DepthRange = r300DepthRange;
2323 functions->PointSize = r300PointSize;
2324 functions->LineWidth = r300LineWidth;
2325
2326 functions->PolygonOffset = r300PolygonOffset;
2327 functions->PolygonMode = r300PolygonMode;
2328
2329 functions->RenderMode = r300RenderMode;
2330
2331 functions->ClipPlane = r300ClipPlane;
2332 functions->Scissor = radeonScissor;
2333
2334 functions->DrawBuffer = radeonDrawBuffer;
2335 functions->ReadBuffer = radeonReadBuffer;
2336 }
2337
2338 void r300InitShaderFunctions(r300ContextPtr r300)
2339 {
2340 if (r300->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
2341 r300->vtbl.SetupRSUnit = r500SetupRSUnit;
2342 r300->vtbl.SetupPixelShader = r500SetupPixelShader;
2343 r300->vtbl.SetupFragmentShaderTextures = r500SetupFragmentShaderTextures;
2344 r300->vtbl.BuildFragmentProgramHwCode = r500BuildFragmentProgramHwCode;
2345 r300->vtbl.FragmentProgramDump = r500FragmentProgramDump;
2346 } else {
2347 r300->vtbl.SetupRSUnit = r300SetupRSUnit;
2348 r300->vtbl.SetupPixelShader = r300SetupPixelShader;
2349 r300->vtbl.SetupFragmentShaderTextures = r300SetupFragmentShaderTextures;
2350 r300->vtbl.BuildFragmentProgramHwCode = r300BuildFragmentProgramHwCode;
2351 r300->vtbl.FragmentProgramDump = r300FragmentProgramDump;
2352 }
2353 }