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