2 Copyright (C) The Weather Channel, Inc. 2002.
3 Copyright (C) 2004 Nicolai Haehnle.
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.
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:
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.
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.
30 **************************************************************************/
35 * \author Nicolai Haehnle <prefect_@gmx.net>
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"
45 #include "main/framebuffer.h"
46 #include "main/simple_list.h"
47 #include "main/api_arrayelt.h"
48 #include "main/texformat.h"
50 #include "swrast/swrast.h"
51 #include "swrast_setup/swrast_setup.h"
52 #include "shader/prog_parameter.h"
53 #include "shader/prog_statevars.h"
56 #include "tnl/t_vp_build.h"
58 #include "r300_context.h"
59 #include "r300_ioctl.h"
60 #include "r300_state.h"
62 #include "r300_emit.h"
64 #include "r300_fragprog_common.h"
65 #include "r300_render.h"
66 #include "r300_vertprog.h"
68 #include "drirenderbuffer.h"
70 static void r300BlendColor(GLcontext
* ctx
, const GLfloat cf
[4])
72 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
74 R300_STATECHANGE(rmesa
, blend_color
);
76 if (rmesa
->radeon
.radeonScreen
->chip_family
>= CHIP_FAMILY_RV515
) {
77 GLuint r
= IROUND(cf
[0]*1023.0f
);
78 GLuint g
= IROUND(cf
[1]*1023.0f
);
79 GLuint b
= IROUND(cf
[2]*1023.0f
);
80 GLuint a
= IROUND(cf
[3]*1023.0f
);
82 rmesa
->hw
.blend_color
.cmd
[1] = r
| (a
<< 16);
83 rmesa
->hw
.blend_color
.cmd
[2] = b
| (g
<< 16);
86 CLAMPED_FLOAT_TO_UBYTE(color
[0], cf
[0]);
87 CLAMPED_FLOAT_TO_UBYTE(color
[1], cf
[1]);
88 CLAMPED_FLOAT_TO_UBYTE(color
[2], cf
[2]);
89 CLAMPED_FLOAT_TO_UBYTE(color
[3], cf
[3]);
91 rmesa
->hw
.blend_color
.cmd
[1] = PACK_COLOR_8888(color
[3], color
[0],
97 * Calculate the hardware blend factor setting. This same function is used
98 * for source and destination of both alpha and RGB.
101 * The hardware register value for the specified blend factor. This value
102 * will need to be shifted into the correct position for either source or
103 * destination factor.
106 * Since the two cases where source and destination are handled differently
107 * are essentially error cases, they should never happen. Determine if these
108 * cases can be removed.
110 static int blend_factor(GLenum factor
, GLboolean is_src
)
114 return R300_BLEND_GL_ZERO
;
117 return R300_BLEND_GL_ONE
;
120 return R300_BLEND_GL_DST_COLOR
;
122 case GL_ONE_MINUS_DST_COLOR
:
123 return R300_BLEND_GL_ONE_MINUS_DST_COLOR
;
126 return R300_BLEND_GL_SRC_COLOR
;
128 case GL_ONE_MINUS_SRC_COLOR
:
129 return R300_BLEND_GL_ONE_MINUS_SRC_COLOR
;
132 return R300_BLEND_GL_SRC_ALPHA
;
134 case GL_ONE_MINUS_SRC_ALPHA
:
135 return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA
;
138 return R300_BLEND_GL_DST_ALPHA
;
140 case GL_ONE_MINUS_DST_ALPHA
:
141 return R300_BLEND_GL_ONE_MINUS_DST_ALPHA
;
143 case GL_SRC_ALPHA_SATURATE
:
144 return (is_src
) ? R300_BLEND_GL_SRC_ALPHA_SATURATE
:
147 case GL_CONSTANT_COLOR
:
148 return R300_BLEND_GL_CONST_COLOR
;
150 case GL_ONE_MINUS_CONSTANT_COLOR
:
151 return R300_BLEND_GL_ONE_MINUS_CONST_COLOR
;
153 case GL_CONSTANT_ALPHA
:
154 return R300_BLEND_GL_CONST_ALPHA
;
156 case GL_ONE_MINUS_CONSTANT_ALPHA
:
157 return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA
;
160 fprintf(stderr
, "unknown blend factor %x\n", factor
);
161 return (is_src
) ? R300_BLEND_GL_ONE
: R300_BLEND_GL_ZERO
;
167 * Sets both the blend equation and the blend function.
168 * This is done in a single
169 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
170 * change the interpretation of the blend function.
171 * Also, make sure that blend function and blend equation are set to their
172 * default value if color blending is not enabled, since at least blend
173 * equations GL_MIN and GL_FUNC_REVERSE_SUBTRACT will cause wrong results
174 * otherwise for unknown reasons.
177 /* helper function */
178 static void r300SetBlendCntl(r300ContextPtr r300
, int func
, int eqn
,
179 int cbits
, int funcA
, int eqnA
)
181 GLuint new_ablend
, new_cblend
;
185 "eqnA=%08x funcA=%08x eqn=%08x func=%08x cbits=%08x\n",
186 eqnA
, funcA
, eqn
, func
, cbits
);
188 new_ablend
= eqnA
| funcA
;
189 new_cblend
= eqn
| func
;
191 /* Some blend factor combinations don't seem to work when the
192 * BLEND_NO_SEPARATE bit is set.
194 * Especially problematic candidates are the ONE_MINUS_* flags,
195 * but I can't see a real pattern.
198 if (new_ablend
== new_cblend
) {
199 new_cblend
|= R300_DISCARD_SRC_PIXELS_SRC_ALPHA_0
;
204 if ((new_ablend
!= r300
->hw
.bld
.cmd
[R300_BLD_ABLEND
]) ||
205 (new_cblend
!= r300
->hw
.bld
.cmd
[R300_BLD_CBLEND
])) {
206 R300_STATECHANGE(r300
, bld
);
207 r300
->hw
.bld
.cmd
[R300_BLD_ABLEND
] = new_ablend
;
208 r300
->hw
.bld
.cmd
[R300_BLD_CBLEND
] = new_cblend
;
212 static void r300SetBlendState(GLcontext
* ctx
)
214 r300ContextPtr r300
= R300_CONTEXT(ctx
);
215 int func
= (R300_BLEND_GL_ONE
<< R300_SRC_BLEND_SHIFT
) |
216 (R300_BLEND_GL_ZERO
<< R300_DST_BLEND_SHIFT
);
217 int eqn
= R300_COMB_FCN_ADD_CLAMP
;
218 int funcA
= (R300_BLEND_GL_ONE
<< R300_SRC_BLEND_SHIFT
) |
219 (R300_BLEND_GL_ZERO
<< R300_DST_BLEND_SHIFT
);
220 int eqnA
= R300_COMB_FCN_ADD_CLAMP
;
222 if (RGBA_LOGICOP_ENABLED(ctx
) || !ctx
->Color
.BlendEnabled
) {
223 r300SetBlendCntl(r300
, func
, eqn
, 0, func
, eqn
);
228 (blend_factor(ctx
->Color
.BlendSrcRGB
, GL_TRUE
) <<
229 R300_SRC_BLEND_SHIFT
) | (blend_factor(ctx
->Color
.BlendDstRGB
,
231 R300_DST_BLEND_SHIFT
);
233 switch (ctx
->Color
.BlendEquationRGB
) {
235 eqn
= R300_COMB_FCN_ADD_CLAMP
;
238 case GL_FUNC_SUBTRACT
:
239 eqn
= R300_COMB_FCN_SUB_CLAMP
;
242 case GL_FUNC_REVERSE_SUBTRACT
:
243 eqn
= R300_COMB_FCN_RSUB_CLAMP
;
247 eqn
= R300_COMB_FCN_MIN
;
248 func
= (R300_BLEND_GL_ONE
<< R300_SRC_BLEND_SHIFT
) |
249 (R300_BLEND_GL_ONE
<< R300_DST_BLEND_SHIFT
);
253 eqn
= R300_COMB_FCN_MAX
;
254 func
= (R300_BLEND_GL_ONE
<< R300_SRC_BLEND_SHIFT
) |
255 (R300_BLEND_GL_ONE
<< R300_DST_BLEND_SHIFT
);
260 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
261 __FUNCTION__
, __LINE__
, ctx
->Color
.BlendEquationRGB
);
266 (blend_factor(ctx
->Color
.BlendSrcA
, GL_TRUE
) <<
267 R300_SRC_BLEND_SHIFT
) | (blend_factor(ctx
->Color
.BlendDstA
,
269 R300_DST_BLEND_SHIFT
);
271 switch (ctx
->Color
.BlendEquationA
) {
273 eqnA
= R300_COMB_FCN_ADD_CLAMP
;
276 case GL_FUNC_SUBTRACT
:
277 eqnA
= R300_COMB_FCN_SUB_CLAMP
;
280 case GL_FUNC_REVERSE_SUBTRACT
:
281 eqnA
= R300_COMB_FCN_RSUB_CLAMP
;
285 eqnA
= R300_COMB_FCN_MIN
;
286 funcA
= (R300_BLEND_GL_ONE
<< R300_SRC_BLEND_SHIFT
) |
287 (R300_BLEND_GL_ONE
<< R300_DST_BLEND_SHIFT
);
291 eqnA
= R300_COMB_FCN_MAX
;
292 funcA
= (R300_BLEND_GL_ONE
<< R300_SRC_BLEND_SHIFT
) |
293 (R300_BLEND_GL_ONE
<< R300_DST_BLEND_SHIFT
);
298 "[%s:%u] Invalid A blend equation (0x%04x).\n",
299 __FUNCTION__
, __LINE__
, ctx
->Color
.BlendEquationA
);
303 r300SetBlendCntl(r300
,
305 (R300_SEPARATE_ALPHA_ENABLE
|
307 R300_ALPHA_BLEND_ENABLE
), funcA
, eqnA
);
310 static void r300BlendEquationSeparate(GLcontext
* ctx
,
311 GLenum modeRGB
, GLenum modeA
)
313 r300SetBlendState(ctx
);
316 static void r300BlendFuncSeparate(GLcontext
* ctx
,
317 GLenum sfactorRGB
, GLenum dfactorRGB
,
318 GLenum sfactorA
, GLenum dfactorA
)
320 r300SetBlendState(ctx
);
324 * Translate LogicOp enums into hardware representation.
325 * Both use a very logical bit-wise layout, but unfortunately the order
326 * of bits is reversed.
328 static GLuint
translate_logicop(GLenum logicop
)
330 GLuint bits
= logicop
- GL_CLEAR
;
331 bits
= ((bits
& 1) << 3) | ((bits
& 2) << 1) | ((bits
& 4) >> 1) | ((bits
& 8) >> 3);
332 return bits
<< R300_RB3D_ROPCNTL_ROP_SHIFT
;
336 * Used internally to update the r300->hw hardware state to match the
337 * current OpenGL state.
339 static void r300SetLogicOpState(GLcontext
*ctx
)
341 r300ContextPtr r300
= R300_CONTEXT(ctx
);
342 R300_STATECHANGE(r300
, rop
);
343 if (RGBA_LOGICOP_ENABLED(ctx
)) {
344 r300
->hw
.rop
.cmd
[1] = R300_RB3D_ROPCNTL_ROP_ENABLE
|
345 translate_logicop(ctx
->Color
.LogicOp
);
347 r300
->hw
.rop
.cmd
[1] = 0;
352 * Called by Mesa when an application program changes the LogicOp state
355 static void r300LogicOpcode(GLcontext
*ctx
, GLenum logicop
)
357 if (RGBA_LOGICOP_ENABLED(ctx
))
358 r300SetLogicOpState(ctx
);
361 static void r300ClipPlane( GLcontext
*ctx
, GLenum plane
, const GLfloat
*eq
)
363 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
367 /* no VAP UCP on non-TCL chipsets */
368 if (!rmesa
->options
.hw_tcl_enabled
)
371 p
= (GLint
) plane
- (GLint
) GL_CLIP_PLANE0
;
372 ip
= (GLint
*)ctx
->Transform
._ClipUserPlane
[p
];
374 R300_STATECHANGE( rmesa
, vpucp
[p
] );
375 rmesa
->hw
.vpucp
[p
].cmd
[R300_VPUCP_X
] = ip
[0];
376 rmesa
->hw
.vpucp
[p
].cmd
[R300_VPUCP_Y
] = ip
[1];
377 rmesa
->hw
.vpucp
[p
].cmd
[R300_VPUCP_Z
] = ip
[2];
378 rmesa
->hw
.vpucp
[p
].cmd
[R300_VPUCP_W
] = ip
[3];
381 static void r300SetClipPlaneState(GLcontext
* ctx
, GLenum cap
, GLboolean state
)
383 r300ContextPtr r300
= R300_CONTEXT(ctx
);
386 /* no VAP UCP on non-TCL chipsets */
387 if (!r300
->options
.hw_tcl_enabled
)
390 p
= cap
- GL_CLIP_PLANE0
;
391 R300_STATECHANGE(r300
, vap_clip_cntl
);
393 r300
->hw
.vap_clip_cntl
.cmd
[1] |= (R300_VAP_UCP_ENABLE_0
<< p
);
394 r300ClipPlane(ctx
, cap
, NULL
);
396 r300
->hw
.vap_clip_cntl
.cmd
[1] &= ~(R300_VAP_UCP_ENABLE_0
<< p
);
401 * Update our tracked culling state based on Mesa's state.
403 static void r300UpdateCulling(GLcontext
* ctx
)
405 r300ContextPtr r300
= R300_CONTEXT(ctx
);
408 if (ctx
->Polygon
.CullFlag
) {
409 switch (ctx
->Polygon
.CullFaceMode
) {
411 val
= R300_CULL_FRONT
;
414 val
= R300_CULL_BACK
;
416 case GL_FRONT_AND_BACK
:
417 val
= R300_CULL_FRONT
| R300_CULL_BACK
;
424 switch (ctx
->Polygon
.FrontFace
) {
426 val
|= R300_FRONT_FACE_CW
;
429 val
|= R300_FRONT_FACE_CCW
;
435 /* Winding is inverted when rendering to FBO */
436 if (ctx
->DrawBuffer
&& ctx
->DrawBuffer
->Name
)
437 val
^= R300_FRONT_FACE_CW
;
439 R300_STATECHANGE(r300
, cul
);
440 r300
->hw
.cul
.cmd
[R300_CUL_CULL
] = val
;
443 static void r300SetPolygonOffsetState(GLcontext
* ctx
, GLboolean state
)
445 r300ContextPtr r300
= R300_CONTEXT(ctx
);
447 R300_STATECHANGE(r300
, occlusion_cntl
);
449 r300
->hw
.occlusion_cntl
.cmd
[1] |= (3 << 0);
451 r300
->hw
.occlusion_cntl
.cmd
[1] &= ~(3 << 0);
455 static GLboolean
current_fragment_program_writes_depth(GLcontext
* ctx
)
457 r300ContextPtr r300
= R300_CONTEXT(ctx
);
459 return ctx
->FragmentProgram
._Current
&& r300
->selected_fp
->code
.writes_depth
;
462 static void r300SetEarlyZState(GLcontext
* ctx
)
464 r300ContextPtr r300
= R300_CONTEXT(ctx
);
465 GLuint topZ
= R300_ZTOP_ENABLE
;
466 GLuint w_fmt
, fgdepthsrc
;
468 if (ctx
->Color
.AlphaEnabled
&& ctx
->Color
.AlphaFunc
!= GL_ALWAYS
)
469 topZ
= R300_ZTOP_DISABLE
;
470 else if (current_fragment_program_writes_depth(ctx
))
471 topZ
= R300_ZTOP_DISABLE
;
472 else if (ctx
->FragmentProgram
._Current
&& ctx
->FragmentProgram
._Current
->UsesKill
)
473 topZ
= R300_ZTOP_DISABLE
;
474 else if (r300
->radeon
.query
.current
)
475 topZ
= R300_ZTOP_DISABLE
;
477 if (topZ
!= r300
->hw
.zstencil_format
.cmd
[2]) {
478 /* Note: This completely reemits the stencil format.
479 * I have not tested whether this is strictly necessary,
480 * or if emitting a write to ZB_ZTOP is enough.
482 R300_STATECHANGE(r300
, zstencil_format
);
483 r300
->hw
.zstencil_format
.cmd
[2] = topZ
;
486 /* w_fmt value is set to get best performance
487 * see p.130 R5xx 3D acceleration guide v1.3 */
488 if (current_fragment_program_writes_depth(ctx
)) {
489 fgdepthsrc
= R300_FG_DEPTH_SRC_SHADER
;
490 w_fmt
= R300_W_FMT_W24
| R300_W_SRC_US
;
492 fgdepthsrc
= R300_FG_DEPTH_SRC_SCAN
;
493 w_fmt
= R300_W_FMT_W0
| R300_W_SRC_US
;
496 if (w_fmt
!= r300
->hw
.us_out_fmt
.cmd
[5]) {
497 R300_STATECHANGE(r300
, us_out_fmt
);
498 r300
->hw
.us_out_fmt
.cmd
[5] = w_fmt
;
501 if (fgdepthsrc
!= r300
->hw
.fg_depth_src
.cmd
[1]) {
502 R300_STATECHANGE(r300
, fg_depth_src
);
503 r300
->hw
.fg_depth_src
.cmd
[1] = fgdepthsrc
;
507 static void r300SetAlphaState(GLcontext
* ctx
)
509 r300ContextPtr r300
= R300_CONTEXT(ctx
);
511 uint32_t pp_misc
= 0x0;
512 GLboolean really_enabled
= ctx
->Color
.AlphaEnabled
;
514 CLAMPED_FLOAT_TO_UBYTE(refByte
, ctx
->Color
.AlphaRef
);
516 switch (ctx
->Color
.AlphaFunc
) {
518 pp_misc
|= R300_FG_ALPHA_FUNC_NEVER
;
521 pp_misc
|= R300_FG_ALPHA_FUNC_LESS
;
524 pp_misc
|= R300_FG_ALPHA_FUNC_EQUAL
;
527 pp_misc
|= R300_FG_ALPHA_FUNC_LE
;
530 pp_misc
|= R300_FG_ALPHA_FUNC_GREATER
;
533 pp_misc
|= R300_FG_ALPHA_FUNC_NOTEQUAL
;
536 pp_misc
|= R300_FG_ALPHA_FUNC_GE
;
539 /*pp_misc |= FG_ALPHA_FUNC_ALWAYS; */
540 really_enabled
= GL_FALSE
;
544 if (really_enabled
) {
545 pp_misc
|= R300_FG_ALPHA_FUNC_ENABLE
;
546 pp_misc
|= R500_FG_ALPHA_FUNC_8BIT
;
547 pp_misc
|= (refByte
& R300_FG_ALPHA_FUNC_VAL_MASK
);
552 R300_STATECHANGE(r300
, at
);
553 r300
->hw
.at
.cmd
[R300_AT_ALPHA_TEST
] = pp_misc
;
554 r300
->hw
.at
.cmd
[R300_AT_UNKNOWN
] = 0;
557 static void r300AlphaFunc(GLcontext
* ctx
, GLenum func
, GLfloat ref
)
561 r300SetAlphaState(ctx
);
564 static int translate_func(int func
)
568 return R300_ZS_NEVER
;
572 return R300_ZS_EQUAL
;
574 return R300_ZS_LEQUAL
;
576 return R300_ZS_GREATER
;
578 return R300_ZS_NOTEQUAL
;
580 return R300_ZS_GEQUAL
;
582 return R300_ZS_ALWAYS
;
587 static void r300SetDepthState(GLcontext
* ctx
)
589 r300ContextPtr r300
= R300_CONTEXT(ctx
);
591 R300_STATECHANGE(r300
, zs
);
592 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] &= R300_STENCIL_ENABLE
|R300_STENCIL_FRONT_BACK
;
593 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] &= ~(R300_ZS_MASK
<< R300_Z_FUNC_SHIFT
);
595 if (ctx
->Depth
.Test
) {
596 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] |= R300_Z_ENABLE
;
598 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] |= R300_Z_WRITE_ENABLE
;
599 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
600 translate_func(ctx
->Depth
.Func
) << R300_Z_FUNC_SHIFT
;
604 static void r300CatchStencilFallback(GLcontext
*ctx
)
606 const unsigned back
= ctx
->Stencil
._BackFace
;
608 if (ctx
->Stencil
._Enabled
&& (ctx
->Stencil
.Ref
[0] != ctx
->Stencil
.Ref
[back
]
609 || ctx
->Stencil
.ValueMask
[0] != ctx
->Stencil
.ValueMask
[back
]
610 || ctx
->Stencil
.WriteMask
[0] != ctx
->Stencil
.WriteMask
[back
])) {
611 r300SwitchFallback(ctx
, R300_FALLBACK_STENCIL_TWOSIDE
, GL_TRUE
);
613 r300SwitchFallback(ctx
, R300_FALLBACK_STENCIL_TWOSIDE
, GL_FALSE
);
617 static void r300SetStencilState(GLcontext
* ctx
, GLboolean state
)
619 r300ContextPtr r300
= R300_CONTEXT(ctx
);
620 GLboolean hw_stencil
= GL_FALSE
;
622 r300CatchStencilFallback(ctx
);
624 if (ctx
->DrawBuffer
) {
625 struct radeon_renderbuffer
*rrbStencil
626 = radeon_get_renderbuffer(ctx
->DrawBuffer
, BUFFER_STENCIL
);
627 hw_stencil
= (rrbStencil
&& rrbStencil
->bo
);
631 R300_STATECHANGE(r300
, zs
);
633 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] |=
636 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] &=
637 ~R300_STENCIL_ENABLE
;
642 static void r300UpdatePolygonMode(GLcontext
* ctx
)
644 r300ContextPtr r300
= R300_CONTEXT(ctx
);
645 uint32_t hw_mode
= R300_GA_POLY_MODE_DISABLE
;
647 /* Only do something if a polygon mode is wanted, default is GL_FILL */
648 if (ctx
->Polygon
.FrontMode
!= GL_FILL
||
649 ctx
->Polygon
.BackMode
!= GL_FILL
) {
652 /* Handle GL_CW (clock wise and GL_CCW (counter clock wise)
653 * correctly by selecting the correct front and back face
655 if (ctx
->Polygon
.FrontFace
== GL_CCW
) {
656 f
= ctx
->Polygon
.FrontMode
;
657 b
= ctx
->Polygon
.BackMode
;
659 f
= ctx
->Polygon
.BackMode
;
660 b
= ctx
->Polygon
.FrontMode
;
663 /* Enable polygon mode */
664 hw_mode
|= R300_GA_POLY_MODE_DUAL
;
668 hw_mode
|= R300_GA_POLY_MODE_FRONT_PTYPE_LINE
;
671 hw_mode
|= R300_GA_POLY_MODE_FRONT_PTYPE_POINT
;
674 hw_mode
|= R300_GA_POLY_MODE_FRONT_PTYPE_TRI
;
680 hw_mode
|= R300_GA_POLY_MODE_BACK_PTYPE_LINE
;
683 hw_mode
|= R300_GA_POLY_MODE_BACK_PTYPE_POINT
;
686 hw_mode
|= R300_GA_POLY_MODE_BACK_PTYPE_TRI
;
691 if (r300
->hw
.polygon_mode
.cmd
[1] != hw_mode
) {
692 R300_STATECHANGE(r300
, polygon_mode
);
693 r300
->hw
.polygon_mode
.cmd
[1] = hw_mode
;
696 r300
->hw
.polygon_mode
.cmd
[2] = 0x00000001;
697 r300
->hw
.polygon_mode
.cmd
[3] = 0x00000000;
701 * Change the culling mode.
703 * \note Mesa already filters redundant calls to this function.
705 static void r300CullFace(GLcontext
* ctx
, GLenum mode
)
709 r300UpdateCulling(ctx
);
713 * Change the polygon orientation.
715 * \note Mesa already filters redundant calls to this function.
717 static void r300FrontFace(GLcontext
* ctx
, GLenum mode
)
721 r300UpdateCulling(ctx
);
722 r300UpdatePolygonMode(ctx
);
726 * Change the depth testing function.
728 * \note Mesa already filters redundant calls to this function.
730 static void r300DepthFunc(GLcontext
* ctx
, GLenum func
)
733 r300SetDepthState(ctx
);
737 * Enable/Disable depth writing.
739 * \note Mesa already filters redundant calls to this function.
741 static void r300DepthMask(GLcontext
* ctx
, GLboolean mask
)
744 r300SetDepthState(ctx
);
748 * Handle glColorMask()
750 static void r300ColorMask(GLcontext
* ctx
,
751 GLboolean r
, GLboolean g
, GLboolean b
, GLboolean a
)
753 r300ContextPtr r300
= R300_CONTEXT(ctx
);
754 int mask
= (r
? RB3D_COLOR_CHANNEL_MASK_RED_MASK0
: 0) |
755 (g
? RB3D_COLOR_CHANNEL_MASK_GREEN_MASK0
: 0) |
756 (b
? RB3D_COLOR_CHANNEL_MASK_BLUE_MASK0
: 0) |
757 (a
? RB3D_COLOR_CHANNEL_MASK_ALPHA_MASK0
: 0);
759 if (mask
!= r300
->hw
.cmk
.cmd
[R300_CMK_COLORMASK
]) {
760 R300_STATECHANGE(r300
, cmk
);
761 r300
->hw
.cmk
.cmd
[R300_CMK_COLORMASK
] = mask
;
765 /* =============================================================
768 static void r300PointSize(GLcontext
* ctx
, GLfloat size
)
770 r300ContextPtr r300
= R300_CONTEXT(ctx
);
772 /* We need to clamp to user defined range here, because
773 * the HW clamping happens only for per vertex point size. */
774 size
= CLAMP(size
, ctx
->Point
.MinSize
, ctx
->Point
.MaxSize
);
776 /* same size limits for AA, non-AA points */
777 size
= CLAMP(size
, ctx
->Const
.MinPointSize
, ctx
->Const
.MaxPointSize
);
779 R300_STATECHANGE(r300
, ps
);
780 r300
->hw
.ps
.cmd
[R300_PS_POINTSIZE
] =
781 ((int)(size
* 6) << R300_POINTSIZE_X_SHIFT
) |
782 ((int)(size
* 6) << R300_POINTSIZE_Y_SHIFT
);
785 static void r300PointParameter(GLcontext
* ctx
, GLenum pname
, const GLfloat
* param
)
787 r300ContextPtr r300
= R300_CONTEXT(ctx
);
790 case GL_POINT_SIZE_MIN
:
791 R300_STATECHANGE(r300
, ga_point_minmax
);
792 r300
->hw
.ga_point_minmax
.cmd
[1] &= ~R300_GA_POINT_MINMAX_MIN_MASK
;
793 r300
->hw
.ga_point_minmax
.cmd
[1] |= (GLuint
)(ctx
->Point
.MinSize
* 6.0);
795 case GL_POINT_SIZE_MAX
:
796 R300_STATECHANGE(r300
, ga_point_minmax
);
797 r300
->hw
.ga_point_minmax
.cmd
[1] &= ~R300_GA_POINT_MINMAX_MAX_MASK
;
798 r300
->hw
.ga_point_minmax
.cmd
[1] |= (GLuint
)(ctx
->Point
.MaxSize
* 6.0)
799 << R300_GA_POINT_MINMAX_MAX_SHIFT
;
801 case GL_POINT_DISTANCE_ATTENUATION
:
803 case GL_POINT_FADE_THRESHOLD_SIZE
:
810 /* =============================================================
813 static void r300LineWidth(GLcontext
* ctx
, GLfloat widthf
)
815 r300ContextPtr r300
= R300_CONTEXT(ctx
);
817 widthf
= CLAMP(widthf
,
818 ctx
->Const
.MinPointSize
,
819 ctx
->Const
.MaxPointSize
);
820 R300_STATECHANGE(r300
, lcntl
);
821 r300
->hw
.lcntl
.cmd
[1] =
822 R300_LINE_CNT_HO
| R300_LINE_CNT_VE
| (int)(widthf
* 6.0);
825 static void r300PolygonMode(GLcontext
* ctx
, GLenum face
, GLenum mode
)
830 r300UpdatePolygonMode(ctx
);
833 /* =============================================================
837 static int translate_stencil_op(int op
)
845 return R300_ZS_REPLACE
;
850 case GL_INCR_WRAP_EXT
:
851 return R300_ZS_INCR_WRAP
;
852 case GL_DECR_WRAP_EXT
:
853 return R300_ZS_DECR_WRAP
;
855 return R300_ZS_INVERT
;
857 WARN_ONCE("Do not know how to translate stencil op");
863 static void r300ShadeModel(GLcontext
* ctx
, GLenum mode
)
865 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
867 R300_STATECHANGE(rmesa
, shade
);
868 rmesa
->hw
.shade
.cmd
[1] = 0x00000002;
869 R300_STATECHANGE(rmesa
, shade2
);
872 rmesa
->hw
.shade2
.cmd
[1] = R300_RE_SHADE_MODEL_FLAT
;
875 rmesa
->hw
.shade2
.cmd
[1] = R300_RE_SHADE_MODEL_SMOOTH
;
880 rmesa
->hw
.shade2
.cmd
[2] = 0x00000000;
881 rmesa
->hw
.shade2
.cmd
[3] = 0x00000000;
884 static void r300StencilFuncSeparate(GLcontext
* ctx
, GLenum face
,
885 GLenum func
, GLint ref
, GLuint mask
)
887 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
890 const unsigned back
= ctx
->Stencil
._BackFace
;
892 r300CatchStencilFallback(ctx
);
894 refmask
= ((ctx
->Stencil
.Ref
[0] & 0xff) << R300_STENCILREF_SHIFT
)
895 | ((ctx
->Stencil
.ValueMask
[0] & 0xff) << R300_STENCILMASK_SHIFT
);
897 R300_STATECHANGE(rmesa
, zs
);
898 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] |= R300_STENCIL_FRONT_BACK
;
899 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] &= ~((R300_ZS_MASK
<<
900 R300_S_FRONT_FUNC_SHIFT
)
902 R300_S_BACK_FUNC_SHIFT
));
904 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_2
] &=
905 ~((R300_STENCILREF_MASK
<< R300_STENCILREF_SHIFT
) |
906 (R300_STENCILREF_MASK
<< R300_STENCILMASK_SHIFT
));
908 flag
= translate_func(ctx
->Stencil
.Function
[0]);
909 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
910 (flag
<< R300_S_FRONT_FUNC_SHIFT
);
912 flag
= translate_func(ctx
->Stencil
.Function
[back
]);
914 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
915 (flag
<< R300_S_BACK_FUNC_SHIFT
);
916 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_2
] |= refmask
;
919 static void r300StencilMaskSeparate(GLcontext
* ctx
, GLenum face
, GLuint mask
)
921 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
923 r300CatchStencilFallback(ctx
);
925 R300_STATECHANGE(rmesa
, zs
);
926 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_2
] &=
927 ~(R300_STENCILREF_MASK
<<
928 R300_STENCILWRITEMASK_SHIFT
);
929 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_2
] |=
931 WriteMask
[0] & R300_STENCILREF_MASK
) <<
932 R300_STENCILWRITEMASK_SHIFT
;
935 static void r300StencilOpSeparate(GLcontext
* ctx
, GLenum face
,
936 GLenum fail
, GLenum zfail
, GLenum zpass
)
938 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
939 const unsigned back
= ctx
->Stencil
._BackFace
;
941 r300CatchStencilFallback(ctx
);
943 R300_STATECHANGE(rmesa
, zs
);
944 /* It is easier to mask what's left.. */
945 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] &=
946 (R300_ZS_MASK
<< R300_Z_FUNC_SHIFT
) |
947 (R300_ZS_MASK
<< R300_S_FRONT_FUNC_SHIFT
) |
948 (R300_ZS_MASK
<< R300_S_BACK_FUNC_SHIFT
);
950 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
951 (translate_stencil_op(ctx
->Stencil
.FailFunc
[0]) <<
952 R300_S_FRONT_SFAIL_OP_SHIFT
)
953 | (translate_stencil_op(ctx
->Stencil
.ZFailFunc
[0]) <<
954 R300_S_FRONT_ZFAIL_OP_SHIFT
)
955 | (translate_stencil_op(ctx
->Stencil
.ZPassFunc
[0]) <<
956 R300_S_FRONT_ZPASS_OP_SHIFT
);
958 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
959 (translate_stencil_op(ctx
->Stencil
.FailFunc
[back
]) <<
960 R300_S_BACK_SFAIL_OP_SHIFT
)
961 | (translate_stencil_op(ctx
->Stencil
.ZFailFunc
[back
]) <<
962 R300_S_BACK_ZFAIL_OP_SHIFT
)
963 | (translate_stencil_op(ctx
->Stencil
.ZPassFunc
[back
]) <<
964 R300_S_BACK_ZPASS_OP_SHIFT
);
967 /* =============================================================
968 * Window position and viewport transformation
971 static void r300UpdateWindow(GLcontext
* ctx
)
973 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
974 __DRIdrawablePrivate
*dPriv
= radeon_get_drawable(&rmesa
->radeon
);
975 GLfloat xoffset
= dPriv
? (GLfloat
) dPriv
->x
: 0;
976 GLfloat yoffset
= dPriv
? (GLfloat
) dPriv
->y
+ dPriv
->h
: 0;
977 const GLfloat
*v
= ctx
->Viewport
._WindowMap
.m
;
978 const GLfloat depthScale
= 1.0F
/ ctx
->DrawBuffer
->_DepthMaxF
;
979 const GLboolean render_to_fbo
= (ctx
->DrawBuffer
->Name
!= 0);
980 GLfloat y_scale
, y_bias
;
990 GLfloat sx
= v
[MAT_SX
];
991 GLfloat tx
= v
[MAT_TX
] + xoffset
;
992 GLfloat sy
= v
[MAT_SY
] * y_scale
;
993 GLfloat ty
= (v
[MAT_TY
] * y_scale
) + y_bias
;
994 GLfloat sz
= v
[MAT_SZ
] * depthScale
;
995 GLfloat tz
= v
[MAT_TZ
] * depthScale
;
997 R300_STATECHANGE(rmesa
, vpt
);
999 rmesa
->hw
.vpt
.cmd
[R300_VPT_XSCALE
] = r300PackFloat32(sx
);
1000 rmesa
->hw
.vpt
.cmd
[R300_VPT_XOFFSET
] = r300PackFloat32(tx
);
1001 rmesa
->hw
.vpt
.cmd
[R300_VPT_YSCALE
] = r300PackFloat32(sy
);
1002 rmesa
->hw
.vpt
.cmd
[R300_VPT_YOFFSET
] = r300PackFloat32(ty
);
1003 rmesa
->hw
.vpt
.cmd
[R300_VPT_ZSCALE
] = r300PackFloat32(sz
);
1004 rmesa
->hw
.vpt
.cmd
[R300_VPT_ZOFFSET
] = r300PackFloat32(tz
);
1007 static void r300Viewport(GLcontext
* ctx
, GLint x
, GLint y
,
1008 GLsizei width
, GLsizei height
)
1010 /* Don't pipeline viewport changes, conflict with window offset
1011 * setting below. Could apply deltas to rescue pipelined viewport
1012 * values, or keep the originals hanging around.
1014 r300UpdateWindow(ctx
);
1016 radeon_viewport(ctx
, x
, y
, width
, height
);
1019 static void r300DepthRange(GLcontext
* ctx
, GLclampd nearval
, GLclampd farval
)
1021 r300UpdateWindow(ctx
);
1024 void r300UpdateViewportOffset(GLcontext
* ctx
)
1026 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1027 __DRIdrawablePrivate
*dPriv
= radeon_get_drawable(&rmesa
->radeon
);
1028 GLfloat xoffset
= (GLfloat
) dPriv
->x
;
1029 GLfloat yoffset
= (GLfloat
) dPriv
->y
+ dPriv
->h
;
1030 const GLfloat
*v
= ctx
->Viewport
._WindowMap
.m
;
1032 GLfloat tx
= v
[MAT_TX
] + xoffset
;
1033 GLfloat ty
= (-v
[MAT_TY
]) + yoffset
;
1035 if (rmesa
->hw
.vpt
.cmd
[R300_VPT_XOFFSET
] != r300PackFloat32(tx
) ||
1036 rmesa
->hw
.vpt
.cmd
[R300_VPT_YOFFSET
] != r300PackFloat32(ty
)) {
1037 /* Note: this should also modify whatever data the context reset
1040 R300_STATECHANGE(rmesa
, vpt
);
1041 rmesa
->hw
.vpt
.cmd
[R300_VPT_XOFFSET
] = r300PackFloat32(tx
);
1042 rmesa
->hw
.vpt
.cmd
[R300_VPT_YOFFSET
] = r300PackFloat32(ty
);
1046 radeonUpdateScissor(ctx
);
1050 * Update R300's own internal state parameters.
1051 * For now just STATE_R300_WINDOW_DIMENSION
1053 static void r300UpdateStateParameters(GLcontext
* ctx
, GLuint new_state
)
1055 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1056 struct gl_program_parameter_list
*paramList
;
1058 if (!(new_state
& (_NEW_BUFFERS
| _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
)))
1061 if (!ctx
->FragmentProgram
._Current
|| !rmesa
->selected_fp
)
1064 paramList
= ctx
->FragmentProgram
._Current
->Base
.Parameters
;
1069 _mesa_load_state_parameters(ctx
, paramList
);
1072 /* =============================================================
1075 static void r300PolygonOffset(GLcontext
* ctx
, GLfloat factor
, GLfloat units
)
1077 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1078 GLfloat constant
= units
;
1080 switch (ctx
->Visual
.depthBits
) {
1091 /* fprintf(stderr, "%s f:%f u:%f\n", __FUNCTION__, factor, constant); */
1093 R300_STATECHANGE(rmesa
, zbs
);
1094 rmesa
->hw
.zbs
.cmd
[R300_ZBS_T_FACTOR
] = r300PackFloat32(factor
);
1095 rmesa
->hw
.zbs
.cmd
[R300_ZBS_T_CONSTANT
] = r300PackFloat32(constant
);
1096 rmesa
->hw
.zbs
.cmd
[R300_ZBS_W_FACTOR
] = r300PackFloat32(factor
);
1097 rmesa
->hw
.zbs
.cmd
[R300_ZBS_W_CONSTANT
] = r300PackFloat32(constant
);
1100 /* Routing and texture-related */
1102 /* r300 doesnt handle GL_CLAMP and GL_MIRROR_CLAMP_EXT correctly when filter is NEAREST.
1103 * Since texwrap produces same results for GL_CLAMP and GL_CLAMP_TO_EDGE we use them instead.
1104 * We need to recalculate wrap modes whenever filter mode is changed because someone might do:
1105 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1106 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1107 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1108 * Since r300 completely ignores R300_TX_CLAMP when either min or mag is nearest it cant handle
1109 * combinations where only one of them is nearest.
1111 static unsigned long gen_fixed_filter(unsigned long f
)
1113 unsigned long mag
, min
, needs_fixing
= 0;
1116 /* We ignore MIRROR bit so we dont have to do everything twice */
1117 if ((f
& ((7 - 1) << R300_TX_WRAP_S_SHIFT
)) ==
1118 (R300_TX_CLAMP
<< R300_TX_WRAP_S_SHIFT
)) {
1121 if ((f
& ((7 - 1) << R300_TX_WRAP_T_SHIFT
)) ==
1122 (R300_TX_CLAMP
<< R300_TX_WRAP_T_SHIFT
)) {
1125 if ((f
& ((7 - 1) << R300_TX_WRAP_R_SHIFT
)) ==
1126 (R300_TX_CLAMP
<< R300_TX_WRAP_R_SHIFT
)) {
1133 mag
= f
& R300_TX_MAG_FILTER_MASK
;
1134 min
= f
& (R300_TX_MIN_FILTER_MASK
|R300_TX_MIN_FILTER_MIP_MASK
);
1136 /* TODO: Check for anisto filters too */
1137 if ((mag
!= R300_TX_MAG_FILTER_NEAREST
)
1138 && (min
!= R300_TX_MIN_FILTER_NEAREST
))
1141 /* r300 cant handle these modes hence we force nearest to linear */
1142 if ((mag
== R300_TX_MAG_FILTER_NEAREST
)
1143 && (min
!= R300_TX_MIN_FILTER_NEAREST
)) {
1144 f
&= ~R300_TX_MAG_FILTER_NEAREST
;
1145 f
|= R300_TX_MAG_FILTER_LINEAR
;
1149 if ((min
== R300_TX_MIN_FILTER_NEAREST
)
1150 && (mag
!= R300_TX_MAG_FILTER_NEAREST
)) {
1151 f
&= ~R300_TX_MIN_FILTER_NEAREST
;
1152 f
|= R300_TX_MIN_FILTER_LINEAR
;
1156 /* Both are nearest */
1157 if (needs_fixing
& 1) {
1158 f
&= ~((7 - 1) << R300_TX_WRAP_S_SHIFT
);
1159 f
|= R300_TX_CLAMP_TO_EDGE
<< R300_TX_WRAP_S_SHIFT
;
1161 if (needs_fixing
& 2) {
1162 f
&= ~((7 - 1) << R300_TX_WRAP_T_SHIFT
);
1163 f
|= R300_TX_CLAMP_TO_EDGE
<< R300_TX_WRAP_T_SHIFT
;
1165 if (needs_fixing
& 4) {
1166 f
&= ~((7 - 1) << R300_TX_WRAP_R_SHIFT
);
1167 f
|= R300_TX_CLAMP_TO_EDGE
<< R300_TX_WRAP_R_SHIFT
;
1172 static void r300SetupFragmentShaderTextures(GLcontext
*ctx
, int *tmu_mappings
)
1174 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1176 struct r300_fragment_program_code
*code
= &r300
->selected_fp
->code
.code
.r300
;
1178 R300_STATECHANGE(r300
, fpt
);
1180 for (i
= 0; i
< code
->tex
.length
; i
++) {
1185 unit
= code
->tex
.inst
[i
] >> R300_TEX_ID_SHIFT
;
1188 val
= code
->tex
.inst
[i
];
1189 val
&= ~R300_TEX_ID_MASK
;
1192 (val
& R300_TEX_INST_MASK
) >> R300_TEX_INST_SHIFT
;
1193 if (opcode
== R300_TEX_OP_KIL
) {
1194 r300
->hw
.fpt
.cmd
[R300_FPT_INSTR_0
+ i
] = val
;
1196 if (tmu_mappings
[unit
] >= 0) {
1198 tmu_mappings
[unit
] <<
1200 r300
->hw
.fpt
.cmd
[R300_FPT_INSTR_0
+ i
] = val
;
1202 // We get here when the corresponding texture image is incomplete
1203 // (e.g. incomplete mipmaps etc.)
1204 r300
->hw
.fpt
.cmd
[R300_FPT_INSTR_0
+ i
] = val
;
1209 r300
->hw
.fpt
.cmd
[R300_FPT_CMD_0
] =
1210 cmdpacket0(r300
->radeon
.radeonScreen
,
1211 R300_US_TEX_INST_0
, code
->tex
.length
);
1214 static void r500SetupFragmentShaderTextures(GLcontext
*ctx
, int *tmu_mappings
)
1216 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1218 struct r500_fragment_program_code
*code
= &r300
->selected_fp
->code
.code
.r500
;
1220 /* find all the texture instructions and relocate the texture units */
1221 for (i
= 0; i
< code
->inst_end
+ 1; i
++) {
1222 if ((code
->inst
[i
].inst0
& 0x3) == R500_INST_TYPE_TEX
) {
1224 int unit
, opcode
, new_unit
;
1226 val
= code
->inst
[i
].inst1
;
1228 unit
= (val
>> 16) & 0xf;
1230 val
&= ~(0xf << 16);
1232 opcode
= val
& (0x7 << 22);
1233 if (opcode
== R500_TEX_INST_TEXKILL
) {
1236 if (tmu_mappings
[unit
] >= 0) {
1237 new_unit
= tmu_mappings
[unit
];
1242 val
|= R500_TEX_ID(new_unit
);
1243 code
->inst
[i
].inst1
= val
;
1248 static GLuint
translate_lod_bias(GLfloat bias
)
1250 GLint b
= (int)(bias
*32);
1253 else if (b
< -(1 << 9))
1255 return (((GLuint
)b
) << R300_LOD_BIAS_SHIFT
) & R300_LOD_BIAS_MASK
;
1259 static void r300SetupTextures(GLcontext
* ctx
)
1262 struct radeon_tex_obj
*t
;
1263 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1265 int last_hw_tmu
= -1; /* -1 translates into no setup costs for fields */
1266 int tmu_mappings
[R300_MAX_TEXTURE_UNITS
] = { -1, };
1268 R300_STATECHANGE(r300
, txe
);
1269 R300_STATECHANGE(r300
, tex
.filter
);
1270 R300_STATECHANGE(r300
, tex
.filter_1
);
1271 R300_STATECHANGE(r300
, tex
.size
);
1272 R300_STATECHANGE(r300
, tex
.format
);
1273 R300_STATECHANGE(r300
, tex
.pitch
);
1274 R300_STATECHANGE(r300
, tex
.offset
);
1275 R300_STATECHANGE(r300
, tex
.chroma_key
);
1276 R300_STATECHANGE(r300
, tex
.border_color
);
1278 r300
->hw
.txe
.cmd
[R300_TXE_ENABLE
] = 0x0;
1280 mtu
= r300
->radeon
.glCtx
->Const
.MaxTextureUnits
;
1281 if (RADEON_DEBUG
& DEBUG_STATE
)
1282 fprintf(stderr
, "mtu=%d\n", mtu
);
1284 if (mtu
> R300_MAX_TEXTURE_UNITS
) {
1286 "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1287 mtu
, R300_MAX_TEXTURE_UNITS
);
1291 /* We cannot let disabled tmu offsets pass DRM */
1292 for (i
= 0; i
< mtu
; i
++) {
1293 if (ctx
->Texture
.Unit
[i
]._ReallyEnabled
) {
1294 tmu_mappings
[i
] = hw_tmu
;
1296 t
= radeon_tex_obj(ctx
->Texture
.Unit
[i
]._Current
);
1300 if ((t
->pp_txformat
& 0xffffff00) == 0xffffff00) {
1302 ("unknown texture format (entry %x) encountered. Help me !\n",
1303 t
->pp_txformat
& 0xff);
1306 if (RADEON_DEBUG
& DEBUG_STATE
)
1308 "Activating texture unit %d\n", i
);
1310 r300
->hw
.txe
.cmd
[R300_TXE_ENABLE
] |= (1 << hw_tmu
);
1312 r300
->hw
.tex
.filter
.cmd
[R300_TEX_VALUE_0
+
1314 gen_fixed_filter(t
->pp_txfilter
) | (hw_tmu
<< 28);
1315 /* Note: There is a LOD bias per texture unit and a LOD bias
1316 * per texture object. We add them here to get the correct behaviour.
1317 * (The per-texture object LOD bias was introduced in OpenGL 1.4
1318 * and is not present in the EXT_texture_object extension).
1320 r300
->hw
.tex
.filter_1
.cmd
[R300_TEX_VALUE_0
+ hw_tmu
] =
1322 translate_lod_bias(ctx
->Texture
.Unit
[i
].LodBias
+ t
->base
.LodBias
);
1323 r300
->hw
.tex
.size
.cmd
[R300_TEX_VALUE_0
+ hw_tmu
] =
1325 r300
->hw
.tex
.format
.cmd
[R300_TEX_VALUE_0
+
1326 hw_tmu
] = t
->pp_txformat
;
1327 r300
->hw
.tex
.pitch
.cmd
[R300_TEX_VALUE_0
+ hw_tmu
] =
1329 r300
->hw
.textures
[hw_tmu
] = t
;
1331 if (t
->tile_bits
& R300_TXO_MACRO_TILE
) {
1332 WARN_ONCE("macro tiling enabled!\n");
1335 if (t
->tile_bits
& R300_TXO_MICRO_TILE
) {
1336 WARN_ONCE("micro tiling enabled!\n");
1339 r300
->hw
.tex
.chroma_key
.cmd
[R300_TEX_VALUE_0
+
1341 r300
->hw
.tex
.border_color
.cmd
[R300_TEX_VALUE_0
+
1345 last_hw_tmu
= hw_tmu
;
1351 /* R3xx and R4xx chips require that the texture unit corresponding to
1352 * KIL instructions is really enabled.
1354 * We do some fakery here and in the state atom emit logic to enable
1355 * the texture without tripping up the CS checker in the kernel.
1357 if (r300
->radeon
.radeonScreen
->chip_family
< CHIP_FAMILY_RV515
) {
1358 if (ctx
->FragmentProgram
._Current
->UsesKill
&& last_hw_tmu
< 0) {
1361 r300
->hw
.txe
.cmd
[R300_TXE_ENABLE
] |= 1;
1363 r300
->hw
.tex
.border_color
.cmd
[R300_TEX_VALUE_0
] = 0;
1364 r300
->hw
.tex
.chroma_key
.cmd
[R300_TEX_VALUE_0
] = 0;
1365 r300
->hw
.tex
.filter
.cmd
[R300_TEX_VALUE_0
] = 0;
1366 r300
->hw
.tex
.filter_1
.cmd
[R300_TEX_VALUE_0
] = 0;
1367 r300
->hw
.tex
.size
.cmd
[R300_TEX_VALUE_0
] = 0; /* 1x1 texture */
1368 r300
->hw
.tex
.format
.cmd
[R300_TEX_VALUE_0
] = 0; /* A8 format */
1369 r300
->hw
.tex
.pitch
.cmd
[R300_TEX_VALUE_0
] = 0;
1373 r300
->hw
.tex
.filter
.cmd
[R300_TEX_CMD_0
] =
1374 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_FILTER0_0
, last_hw_tmu
+ 1);
1375 r300
->hw
.tex
.filter_1
.cmd
[R300_TEX_CMD_0
] =
1376 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_FILTER1_0
, last_hw_tmu
+ 1);
1377 r300
->hw
.tex
.size
.cmd
[R300_TEX_CMD_0
] =
1378 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_SIZE_0
, last_hw_tmu
+ 1);
1379 r300
->hw
.tex
.format
.cmd
[R300_TEX_CMD_0
] =
1380 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_FORMAT_0
, last_hw_tmu
+ 1);
1381 r300
->hw
.tex
.pitch
.cmd
[R300_TEX_CMD_0
] =
1382 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_FORMAT2_0
, last_hw_tmu
+ 1);
1383 r300
->hw
.tex
.offset
.cmd
[R300_TEX_CMD_0
] =
1384 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_OFFSET_0
, last_hw_tmu
+ 1);
1385 r300
->hw
.tex
.chroma_key
.cmd
[R300_TEX_CMD_0
] =
1386 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_CHROMA_KEY_0
, last_hw_tmu
+ 1);
1387 r300
->hw
.tex
.border_color
.cmd
[R300_TEX_CMD_0
] =
1388 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_BORDER_COLOR_0
, last_hw_tmu
+ 1);
1390 r300
->vtbl
.SetupFragmentShaderTextures(ctx
, tmu_mappings
);
1392 if (RADEON_DEBUG
& DEBUG_STATE
)
1393 fprintf(stderr
, "TX_ENABLE: %08x last_hw_tmu=%d\n",
1394 r300
->hw
.txe
.cmd
[R300_TXE_ENABLE
], last_hw_tmu
);
1397 union r300_outputs_written
{
1398 GLuint vp_outputs
; /* hw_tcl_on */
1399 DECLARE_RENDERINPUTS(index_bitset
); /* !hw_tcl_on */
1402 #define R300_OUTPUTS_WRITTEN_TEST(ow, vp_result, tnl_attrib) \
1403 ((hw_tcl_on) ? (ow).vp_outputs & (1 << (vp_result)) : \
1404 RENDERINPUTS_TEST( (ow.index_bitset), (tnl_attrib) ))
1406 static void r300SetupRSUnit(GLcontext
* ctx
)
1408 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1409 union r300_outputs_written OutputsWritten
;
1411 int fp_reg
, high_rr
;
1413 int rs_tex_count
= 0;
1414 int i
, col_fmt
, hw_tcl_on
;
1416 hw_tcl_on
= r300
->options
.hw_tcl_enabled
;
1419 OutputsWritten
.vp_outputs
= r300
->selected_vp
->code
.OutputsWritten
;
1421 RENDERINPUTS_COPY(OutputsWritten
.index_bitset
, r300
->render_inputs_bitset
);
1423 InputsRead
= r300
->selected_fp
->InputsRead
;
1425 R300_STATECHANGE(r300
, ri
);
1426 R300_STATECHANGE(r300
, rc
);
1427 R300_STATECHANGE(r300
, rr
);
1429 fp_reg
= col_ip
= tex_ip
= col_fmt
= 0;
1431 r300
->hw
.rc
.cmd
[1] = 0;
1432 r300
->hw
.rc
.cmd
[2] = 0;
1433 for (i
=0; i
<R300_RR_CMDSIZE
-1; ++i
)
1434 r300
->hw
.rr
.cmd
[R300_RR_INST_0
+ i
] = 0;
1436 for (i
=0; i
<R300_RI_CMDSIZE
-1; ++i
)
1437 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
+ i
] = 0;
1440 if (InputsRead
& FRAG_BIT_COL0
) {
1441 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_COL0
, _TNL_ATTRIB_COLOR0
)) {
1442 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
);
1443 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
);
1444 InputsRead
&= ~FRAG_BIT_COL0
;
1448 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1452 if (InputsRead
& FRAG_BIT_COL1
) {
1453 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_COL1
, _TNL_ATTRIB_COLOR1
)) {
1454 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
);
1455 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
);
1456 InputsRead
&= ~FRAG_BIT_COL1
;
1460 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1464 /* We always route 4 texcoord components */
1465 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
1466 if (! ( InputsRead
& FRAG_BIT_TEX(i
) ) )
1469 if (!R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_TEX0
+ i
, _TNL_ATTRIB_TEX(i
))) {
1470 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i
);
1474 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
);
1475 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
);
1476 InputsRead
&= ~(FRAG_BIT_TEX0
<< i
);
1482 /* Setup default color if no color or tex was set */
1483 if (rs_tex_count
== 0 && col_ip
== 0) {
1484 r300
->hw
.rr
.cmd
[R300_RR_INST_0
] = R300_RS_INST_COL_ID(0) | R300_RS_INST_COL_ADDR(0);
1485 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
] = R300_RS_COL_PTR(0) | R300_RS_COL_FMT(R300_RS_COL_FMT_0001
);
1489 high_rr
= (col_ip
> tex_ip
) ? col_ip
: tex_ip
;
1490 r300
->hw
.rc
.cmd
[1] |= (rs_tex_count
<< R300_IT_COUNT_SHIFT
) | (col_ip
<< R300_IC_COUNT_SHIFT
) | R300_HIRES_EN
;
1491 r300
->hw
.rc
.cmd
[2] |= high_rr
- 1;
1493 r300
->hw
.rr
.cmd
[R300_RR_CMD_0
] = cmdpacket0(r300
->radeon
.radeonScreen
, R300_RS_INST_0
, high_rr
);
1494 r300
->hw
.ri
.cmd
[R300_RI_CMD_0
] = cmdpacket0(r300
->radeon
.radeonScreen
, R300_RS_IP_0
, high_rr
);
1497 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead
);
1500 static void r500SetupRSUnit(GLcontext
* ctx
)
1502 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1503 union r300_outputs_written OutputsWritten
;
1505 int fp_reg
, high_rr
;
1507 int rs_tex_count
= 0;
1508 int i
, col_fmt
, hw_tcl_on
;
1510 hw_tcl_on
= r300
->options
.hw_tcl_enabled
;
1513 OutputsWritten
.vp_outputs
= r300
->selected_vp
->code
.OutputsWritten
;
1515 RENDERINPUTS_COPY(OutputsWritten
.index_bitset
, r300
->render_inputs_bitset
);
1517 InputsRead
= r300
->selected_fp
->InputsRead
;
1519 R300_STATECHANGE(r300
, ri
);
1520 R300_STATECHANGE(r300
, rc
);
1521 R300_STATECHANGE(r300
, rr
);
1523 fp_reg
= col_ip
= tex_ip
= col_fmt
= 0;
1525 r300
->hw
.rc
.cmd
[1] = 0;
1526 r300
->hw
.rc
.cmd
[2] = 0;
1527 for (i
=0; i
<R300_RR_CMDSIZE
-1; ++i
)
1528 r300
->hw
.rr
.cmd
[R300_RR_INST_0
+ i
] = 0;
1530 for (i
=0; i
<R500_RI_CMDSIZE
-1; ++i
)
1531 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
+ i
] = 0;
1534 if (InputsRead
& FRAG_BIT_COL0
) {
1535 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_COL0
, _TNL_ATTRIB_COLOR0
)) {
1536 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
);
1537 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
);
1538 InputsRead
&= ~FRAG_BIT_COL0
;
1542 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1546 if (InputsRead
& FRAG_BIT_COL1
) {
1547 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_COL1
, _TNL_ATTRIB_COLOR1
)) {
1548 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
);
1549 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
);
1550 InputsRead
&= ~FRAG_BIT_COL1
;
1554 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1558 /* We always route 4 texcoord components */
1559 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
1560 if (! ( InputsRead
& FRAG_BIT_TEX(i
) ) )
1563 if (!R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_TEX0
+ i
, _TNL_ATTRIB_TEX(i
))) {
1564 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i
);
1568 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
+ tex_ip
] |= ((rs_tex_count
+ 0) << R500_RS_IP_TEX_PTR_S_SHIFT
) |
1569 ((rs_tex_count
+ 1) << R500_RS_IP_TEX_PTR_T_SHIFT
) |
1570 ((rs_tex_count
+ 2) << R500_RS_IP_TEX_PTR_R_SHIFT
) |
1571 ((rs_tex_count
+ 3) << R500_RS_IP_TEX_PTR_Q_SHIFT
);
1573 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
);
1574 InputsRead
&= ~(FRAG_BIT_TEX0
<< i
);
1580 /* Setup default color if no color or tex was set */
1581 if (rs_tex_count
== 0 && col_ip
== 0) {
1582 r300
->hw
.rr
.cmd
[R300_RR_INST_0
] = R500_RS_INST_COL_ID(0) | R500_RS_INST_COL_ADDR(0);
1583 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
] = R500_RS_COL_PTR(0) | R500_RS_COL_FMT(R300_RS_COL_FMT_0001
);
1587 high_rr
= (col_ip
> tex_ip
) ? col_ip
: tex_ip
;
1588 r300
->hw
.rc
.cmd
[1] = (rs_tex_count
<< R300_IT_COUNT_SHIFT
) | (col_ip
<< R300_IC_COUNT_SHIFT
) | R300_HIRES_EN
;
1589 r300
->hw
.rc
.cmd
[2] = 0xC0 | (high_rr
- 1);
1591 r300
->hw
.rr
.cmd
[R300_RR_CMD_0
] = cmdpacket0(r300
->radeon
.radeonScreen
, R500_RS_INST_0
, high_rr
);
1592 r300
->hw
.ri
.cmd
[R300_RI_CMD_0
] = cmdpacket0(r300
->radeon
.radeonScreen
, R500_RS_IP_0
, high_rr
);
1595 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead
);
1598 #define MIN3(a, b, c) ((a) < (b) ? MIN2(a, c) : MIN2(b, c))
1600 void r300VapCntl(r300ContextPtr rmesa
, GLuint input_count
,
1601 GLuint output_count
, GLuint temp_count
)
1607 /* Flush PVS engine before changing PVS_NUM_SLOTS, PVS_NUM_CNTRLS.
1608 * See r500 docs 6.5.2 - done in emit */
1610 /* avoid division by zero */
1611 if (input_count
== 0) input_count
= 1;
1612 if (output_count
== 0) output_count
= 1;
1613 if (temp_count
== 0) temp_count
= 1;
1615 if (rmesa
->radeon
.radeonScreen
->chip_family
>= CHIP_FAMILY_RV515
)
1620 pvs_num_slots
= MIN3(10, vtx_mem_size
/input_count
, vtx_mem_size
/output_count
);
1621 pvs_num_cntrls
= MIN2(6, vtx_mem_size
/temp_count
);
1623 R300_STATECHANGE(rmesa
, vap_cntl
);
1624 if (rmesa
->options
.hw_tcl_enabled
) {
1625 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] =
1626 (pvs_num_slots
<< R300_PVS_NUM_SLOTS_SHIFT
) |
1627 (pvs_num_cntrls
<< R300_PVS_NUM_CNTLRS_SHIFT
) |
1628 (12 << R300_VF_MAX_VTX_NUM_SHIFT
);
1629 if (rmesa
->radeon
.radeonScreen
->chip_family
>= CHIP_FAMILY_RV515
)
1630 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= R500_TCL_STATE_OPTIMIZATION
;
1632 /* not sure about non-tcl */
1633 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] = ((10 << R300_PVS_NUM_SLOTS_SHIFT
) |
1634 (5 << R300_PVS_NUM_CNTLRS_SHIFT
) |
1635 (5 << R300_VF_MAX_VTX_NUM_SHIFT
));
1637 if (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV515
)
1638 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (2 << R300_PVS_NUM_FPUS_SHIFT
);
1639 else if ((rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV530
) ||
1640 (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV560
) ||
1641 (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV570
))
1642 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (5 << R300_PVS_NUM_FPUS_SHIFT
);
1643 else if ((rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV410
) ||
1644 (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_R420
))
1645 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (6 << R300_PVS_NUM_FPUS_SHIFT
);
1646 else if ((rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_R520
) ||
1647 (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_R580
))
1648 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (8 << R300_PVS_NUM_FPUS_SHIFT
);
1650 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (4 << R300_PVS_NUM_FPUS_SHIFT
);
1655 * Enable/Disable states.
1657 * \note Mesa already filters redundant calls to this function.
1659 static void r300Enable(GLcontext
* ctx
, GLenum cap
, GLboolean state
)
1661 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1662 if (RADEON_DEBUG
& DEBUG_STATE
)
1663 fprintf(stderr
, "%s( %s = %s )\n", __FUNCTION__
,
1664 _mesa_lookup_enum_by_nr(cap
),
1665 state
? "GL_TRUE" : "GL_FALSE");
1669 r300SetAlphaState(ctx
);
1671 case GL_COLOR_LOGIC_OP
:
1672 r300SetLogicOpState(ctx
);
1673 /* fall-through, because logic op overrides blending */
1675 r300SetBlendState(ctx
);
1677 case GL_CLIP_PLANE0
:
1678 case GL_CLIP_PLANE1
:
1679 case GL_CLIP_PLANE2
:
1680 case GL_CLIP_PLANE3
:
1681 case GL_CLIP_PLANE4
:
1682 case GL_CLIP_PLANE5
:
1683 r300SetClipPlaneState(ctx
, cap
, state
);
1686 r300UpdateCulling(ctx
);
1689 r300SetDepthState(ctx
);
1691 case GL_LINE_SMOOTH
:
1692 if (rmesa
->options
.conformance_mode
)
1693 r300SwitchFallback(ctx
, R300_FALLBACK_LINE_SMOOTH
, ctx
->Line
.SmoothFlag
);
1695 case GL_LINE_STIPPLE
:
1696 if (rmesa
->options
.conformance_mode
)
1697 r300SwitchFallback(ctx
, R300_FALLBACK_LINE_STIPPLE
, ctx
->Line
.StippleFlag
);
1699 case GL_POINT_SMOOTH
:
1700 if (rmesa
->options
.conformance_mode
)
1701 r300SwitchFallback(ctx
, R300_FALLBACK_POINT_SMOOTH
, ctx
->Point
.SmoothFlag
);
1703 case GL_POLYGON_SMOOTH
:
1704 if (rmesa
->options
.conformance_mode
)
1705 r300SwitchFallback(ctx
, R300_FALLBACK_POLYGON_SMOOTH
, ctx
->Polygon
.SmoothFlag
);
1707 case GL_POLYGON_STIPPLE
:
1708 if (rmesa
->options
.conformance_mode
)
1709 r300SwitchFallback(ctx
, R300_FALLBACK_POLYGON_STIPPLE
, ctx
->Polygon
.StippleFlag
);
1711 case GL_POLYGON_OFFSET_POINT
:
1712 case GL_POLYGON_OFFSET_LINE
:
1713 case GL_POLYGON_OFFSET_FILL
:
1714 r300SetPolygonOffsetState(ctx
, state
);
1716 case GL_SCISSOR_TEST
:
1717 radeon_firevertices(&rmesa
->radeon
);
1718 rmesa
->radeon
.state
.scissor
.enabled
= state
;
1719 radeonUpdateScissor( ctx
);
1721 case GL_STENCIL_TEST
:
1722 r300SetStencilState(ctx
, state
);
1730 * Completely recalculates hardware state based on the Mesa state.
1732 static void r300ResetHwState(r300ContextPtr r300
)
1734 GLcontext
*ctx
= r300
->radeon
.glCtx
;
1737 has_tcl
= r300
->options
.hw_tcl_enabled
;
1739 if (RADEON_DEBUG
& DEBUG_STATE
)
1740 fprintf(stderr
, "%s\n", __FUNCTION__
);
1742 radeon_firevertices(&r300
->radeon
);
1745 ctx
->Color
.ColorMask
[RCOMP
],
1746 ctx
->Color
.ColorMask
[GCOMP
],
1747 ctx
->Color
.ColorMask
[BCOMP
], ctx
->Color
.ColorMask
[ACOMP
]);
1749 r300Enable(ctx
, GL_DEPTH_TEST
, ctx
->Depth
.Test
);
1750 r300DepthMask(ctx
, ctx
->Depth
.Mask
);
1751 r300DepthFunc(ctx
, ctx
->Depth
.Func
);
1754 r300Enable(ctx
, GL_STENCIL_TEST
, ctx
->Stencil
._Enabled
);
1755 r300StencilMaskSeparate(ctx
, 0, ctx
->Stencil
.WriteMask
[0]);
1756 r300StencilFuncSeparate(ctx
, 0, ctx
->Stencil
.Function
[0],
1757 ctx
->Stencil
.Ref
[0], ctx
->Stencil
.ValueMask
[0]);
1758 r300StencilOpSeparate(ctx
, 0, ctx
->Stencil
.FailFunc
[0],
1759 ctx
->Stencil
.ZFailFunc
[0],
1760 ctx
->Stencil
.ZPassFunc
[0]);
1762 r300UpdateCulling(ctx
);
1764 r300SetBlendState(ctx
);
1765 r300SetLogicOpState(ctx
);
1767 r300AlphaFunc(ctx
, ctx
->Color
.AlphaFunc
, ctx
->Color
.AlphaRef
);
1768 r300Enable(ctx
, GL_ALPHA_TEST
, ctx
->Color
.AlphaEnabled
);
1770 r300
->hw
.vte
.cmd
[1] = R300_VPORT_X_SCALE_ENA
1771 | R300_VPORT_X_OFFSET_ENA
1772 | R300_VPORT_Y_SCALE_ENA
1773 | R300_VPORT_Y_OFFSET_ENA
1774 | R300_VPORT_Z_SCALE_ENA
1775 | R300_VPORT_Z_OFFSET_ENA
| R300_VTX_W0_FMT
;
1776 r300
->hw
.vte
.cmd
[2] = 0x00000008;
1778 r300
->hw
.vap_vf_max_vtx_indx
.cmd
[1] = 0x00FFFFFF;
1779 r300
->hw
.vap_vf_max_vtx_indx
.cmd
[2] = 0x00000000;
1781 #ifdef MESA_LITTLE_ENDIAN
1782 r300
->hw
.vap_cntl_status
.cmd
[1] = R300_VC_NO_SWAP
;
1784 r300
->hw
.vap_cntl_status
.cmd
[1] = R300_VC_32BIT_SWAP
;
1787 /* disable VAP/TCL on non-TCL capable chips */
1789 r300
->hw
.vap_cntl_status
.cmd
[1] |= R300_VAP_TCL_BYPASS
;
1791 r300
->hw
.vap_psc_sgn_norm_cntl
.cmd
[1] = 0xAAAAAAAA;
1793 /* XXX: Other families? */
1795 r300
->hw
.vap_clip_cntl
.cmd
[1] = R300_PS_UCP_MODE_DIST_COP
;
1797 r300
->hw
.vap_clip
.cmd
[1] = r300PackFloat32(1.0); /* X */
1798 r300
->hw
.vap_clip
.cmd
[2] = r300PackFloat32(1.0); /* X */
1799 r300
->hw
.vap_clip
.cmd
[3] = r300PackFloat32(1.0); /* Y */
1800 r300
->hw
.vap_clip
.cmd
[4] = r300PackFloat32(1.0); /* Y */
1802 switch (r300
->radeon
.radeonScreen
->chip_family
) {
1803 case CHIP_FAMILY_R300
:
1804 r300
->hw
.vap_pvs_vtx_timeout_reg
.cmd
[1] = R300_2288_R300
;
1807 r300
->hw
.vap_pvs_vtx_timeout_reg
.cmd
[1] = R300_2288_RV350
;
1812 r300
->hw
.gb_enable
.cmd
[1] = R300_GB_POINT_STUFF_ENABLE
1813 | R300_GB_LINE_STUFF_ENABLE
1814 | R300_GB_TRIANGLE_STUFF_ENABLE
;
1816 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_MSPOS_0
] = 0x66666666;
1817 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_MSPOS_1
] = 0x06666666;
1819 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] =
1820 R300_GB_TILE_ENABLE
| R300_GB_TILE_SIZE_16
/*| R300_GB_SUBPIXEL_1_16*/;
1821 switch (r300
->radeon
.radeonScreen
->num_gb_pipes
) {
1824 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] |=
1825 R300_GB_TILE_PIPE_COUNT_RV300
;
1828 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] |=
1829 R300_GB_TILE_PIPE_COUNT_R300
;
1832 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] |=
1833 R300_GB_TILE_PIPE_COUNT_R420_3P
;
1836 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] |=
1837 R300_GB_TILE_PIPE_COUNT_R420
;
1841 /* XXX: Enable anti-aliasing? */
1842 r300
->hw
.gb_misc2
.cmd
[R300_GB_MISC2_AA_CONFIG
] = GB_AA_CONFIG_AA_DISABLE
;
1843 r300
->hw
.gb_misc2
.cmd
[R300_GB_MISC2_SELECT
] = 0;
1845 r300
->hw
.ga_point_s0
.cmd
[1] = r300PackFloat32(0.0);
1846 r300
->hw
.ga_point_s0
.cmd
[2] = r300PackFloat32(0.0);
1847 r300
->hw
.ga_point_s0
.cmd
[3] = r300PackFloat32(1.0);
1848 r300
->hw
.ga_point_s0
.cmd
[4] = r300PackFloat32(1.0);
1850 r300
->hw
.ga_triangle_stipple
.cmd
[1] = 0x00050005;
1852 r300PointSize(ctx
, 1.0);
1854 r300
->hw
.ga_point_minmax
.cmd
[1] = 0x18000006;
1855 r300
->hw
.ga_point_minmax
.cmd
[2] = 0x00020006;
1856 r300
->hw
.ga_point_minmax
.cmd
[3] = r300PackFloat32(1.0 / 192.0);
1858 r300LineWidth(ctx
, 1.0);
1860 r300
->hw
.ga_line_stipple
.cmd
[1] = 0;
1861 r300
->hw
.ga_line_stipple
.cmd
[2] = r300PackFloat32(0.0);
1862 r300
->hw
.ga_line_stipple
.cmd
[3] = r300PackFloat32(1.0);
1864 r300ShadeModel(ctx
, ctx
->Light
.ShadeModel
);
1866 r300PolygonMode(ctx
, GL_FRONT
, ctx
->Polygon
.FrontMode
);
1867 r300PolygonMode(ctx
, GL_BACK
, ctx
->Polygon
.BackMode
);
1868 r300
->hw
.zbias_cntl
.cmd
[1] = 0x00000000;
1870 r300PolygonOffset(ctx
, ctx
->Polygon
.OffsetFactor
,
1871 ctx
->Polygon
.OffsetUnits
);
1872 r300Enable(ctx
, GL_POLYGON_OFFSET_POINT
, ctx
->Polygon
.OffsetPoint
);
1873 r300Enable(ctx
, GL_POLYGON_OFFSET_LINE
, ctx
->Polygon
.OffsetLine
);
1874 r300Enable(ctx
, GL_POLYGON_OFFSET_FILL
, ctx
->Polygon
.OffsetFill
);
1876 r300
->hw
.su_depth_scale
.cmd
[1] = 0x4B7FFFFF;
1877 r300
->hw
.su_depth_scale
.cmd
[2] = 0x00000000;
1879 r300
->hw
.sc_hyperz
.cmd
[1] = 0x0000001C;
1880 r300
->hw
.sc_hyperz
.cmd
[2] = 0x2DA49525;
1882 r300
->hw
.sc_screendoor
.cmd
[1] = 0x00FFFFFF;
1884 r300
->hw
.us_out_fmt
.cmd
[1] = R500_OUT_FMT_C4_8
|
1885 R500_C0_SEL_B
| R500_C1_SEL_G
| R500_C2_SEL_R
| R500_C3_SEL_A
;
1886 r300
->hw
.us_out_fmt
.cmd
[2] = R500_OUT_FMT_UNUSED
|
1887 R500_C0_SEL_B
| R500_C1_SEL_G
| R500_C2_SEL_R
| R500_C3_SEL_A
;
1888 r300
->hw
.us_out_fmt
.cmd
[3] = R500_OUT_FMT_UNUSED
|
1889 R500_C0_SEL_B
| R500_C1_SEL_G
| R500_C2_SEL_R
| R500_C3_SEL_A
;
1890 r300
->hw
.us_out_fmt
.cmd
[4] = R500_OUT_FMT_UNUSED
|
1891 R500_C0_SEL_B
| R500_C1_SEL_G
| R500_C2_SEL_R
| R500_C3_SEL_A
;
1892 r300
->hw
.us_out_fmt
.cmd
[5] = R300_W_FMT_W0
| R300_W_SRC_US
;
1894 /* disable fog unit */
1895 r300
->hw
.fogs
.cmd
[R300_FOGS_STATE
] = 0;
1896 r300
->hw
.fg_depth_src
.cmd
[1] = R300_FG_DEPTH_SRC_SCAN
;
1898 r300
->hw
.rb3d_cctl
.cmd
[1] = 0;
1900 r300BlendColor(ctx
, ctx
->Color
.BlendColor
);
1902 r300
->hw
.rb3d_dither_ctl
.cmd
[1] = 0;
1903 r300
->hw
.rb3d_dither_ctl
.cmd
[2] = 0;
1904 r300
->hw
.rb3d_dither_ctl
.cmd
[3] = 0;
1905 r300
->hw
.rb3d_dither_ctl
.cmd
[4] = 0;
1906 r300
->hw
.rb3d_dither_ctl
.cmd
[5] = 0;
1907 r300
->hw
.rb3d_dither_ctl
.cmd
[6] = 0;
1908 r300
->hw
.rb3d_dither_ctl
.cmd
[7] = 0;
1909 r300
->hw
.rb3d_dither_ctl
.cmd
[8] = 0;
1910 r300
->hw
.rb3d_dither_ctl
.cmd
[9] = 0;
1912 r300
->hw
.rb3d_aaresolve_ctl
.cmd
[1] = 0;
1914 r300
->hw
.rb3d_discard_src_pixel_lte_threshold
.cmd
[1] = 0x00000000;
1915 r300
->hw
.rb3d_discard_src_pixel_lte_threshold
.cmd
[2] = 0xffffffff;
1917 r300
->hw
.zb_depthclearvalue
.cmd
[1] = 0;
1919 r300
->hw
.zstencil_format
.cmd
[2] = R300_ZTOP_DISABLE
;
1920 r300
->hw
.zstencil_format
.cmd
[3] = 0x00000003;
1921 r300
->hw
.zstencil_format
.cmd
[4] = 0x00000000;
1922 r300SetEarlyZState(ctx
);
1924 r300
->hw
.zb_zmask
.cmd
[1] = 0;
1925 r300
->hw
.zb_zmask
.cmd
[2] = 0;
1927 r300
->hw
.zb_hiz_offset
.cmd
[1] = 0;
1929 r300
->hw
.zb_hiz_pitch
.cmd
[1] = 0;
1931 r300VapCntl(r300
, 0, 0, 0);
1933 r300
->hw
.vps
.cmd
[R300_VPS_ZERO_0
] = 0;
1934 r300
->hw
.vps
.cmd
[R300_VPS_ZERO_1
] = 0;
1935 r300
->hw
.vps
.cmd
[R300_VPS_POINTSIZE
] = r300PackFloat32(1.0);
1936 r300
->hw
.vps
.cmd
[R300_VPS_ZERO_3
] = 0;
1939 r300
->radeon
.hw
.all_dirty
= GL_TRUE
;
1942 void r300UpdateShaders(r300ContextPtr rmesa
)
1944 GLcontext
*ctx
= rmesa
->radeon
.glCtx
;
1946 /* should only happenen once, just after context is created */
1947 /* TODO: shouldn't we fallback to sw here? */
1948 if (!ctx
->FragmentProgram
._Current
) {
1949 _mesa_fprintf(stderr
, "No ctx->FragmentProgram._Current!!\n");
1954 struct r300_fragment_program
*fp
;
1956 fp
= r300SelectAndTranslateFragmentShader(ctx
);
1958 r300SwitchFallback(ctx
, R300_FALLBACK_FRAGMENT_PROGRAM
, fp
->error
);
1961 if (rmesa
->options
.hw_tcl_enabled
) {
1962 struct r300_vertex_program
*vp
;
1964 if (rmesa
->radeon
.NewGLState
) {
1966 for (i
= _TNL_FIRST_MAT
; i
<= _TNL_LAST_MAT
; i
++) {
1967 rmesa
->temp_attrib
[i
] =
1968 TNL_CONTEXT(ctx
)->vb
.AttribPtr
[i
];
1969 TNL_CONTEXT(ctx
)->vb
.AttribPtr
[i
] =
1970 &rmesa
->dummy_attrib
[i
];
1973 _tnl_UpdateFixedFunctionProgram(ctx
);
1975 for (i
= _TNL_FIRST_MAT
; i
<= _TNL_LAST_MAT
; i
++) {
1976 TNL_CONTEXT(ctx
)->vb
.AttribPtr
[i
] =
1977 rmesa
->temp_attrib
[i
];
1981 vp
= r300SelectAndTranslateVertexShader(ctx
);
1983 r300SwitchFallback(ctx
, R300_FALLBACK_VERTEX_PROGRAM
, vp
->error
);
1986 r300UpdateStateParameters(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
1987 rmesa
->radeon
.NewGLState
= 0;
1990 static const GLfloat
*get_fragmentprogram_constant(GLcontext
*ctx
, GLuint index
, GLfloat
* buffer
)
1992 static const GLfloat dummy
[4] = { 0, 0, 0, 0 };
1993 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1994 struct rc_constant
* rcc
= &rmesa
->selected_fp
->code
.constants
.Constants
[index
];
1997 case RC_CONSTANT_EXTERNAL
:
1998 return ctx
->FragmentProgram
._Current
->Base
.Parameters
->ParameterValues
[rcc
->u
.External
];
1999 case RC_CONSTANT_IMMEDIATE
:
2000 return rcc
->u
.Immediate
;
2001 case RC_CONSTANT_STATE
:
2002 switch(rcc
->u
.State
[0]) {
2003 case RC_STATE_SHADOW_AMBIENT
: {
2004 const int unit
= (int) rcc
->u
.State
[1];
2005 const struct gl_texture_object
*texObj
= ctx
->Texture
.Unit
[unit
]._Current
;
2010 buffer
[3] = texObj
->CompareFailValue
;
2015 case RC_STATE_R300_WINDOW_DIMENSION
: {
2016 __DRIdrawablePrivate
* drawable
= radeon_get_drawable(&rmesa
->radeon
);
2017 buffer
[0] = drawable
->w
* 0.5f
; /* width*0.5 */
2018 buffer
[1] = drawable
->h
* 0.5f
; /* height*0.5 */
2019 buffer
[2] = 0.5F
; /* for moving range [-1 1] -> [0 1] */
2020 buffer
[3] = 1.0F
; /* not used */
2024 case RC_STATE_R300_TEXRECT_FACTOR
: {
2025 struct gl_texture_object
*t
=
2026 ctx
->Texture
.Unit
[rcc
->u
.State
[1]].CurrentTex
[TEXTURE_RECT_INDEX
];
2028 if (t
&& t
->Image
[0][t
->BaseLevel
]) {
2029 struct gl_texture_image
*image
=
2030 t
->Image
[0][t
->BaseLevel
];
2031 buffer
[0] = 1.0 / image
->Width2
;
2032 buffer
[1] = 1.0 / image
->Height2
;
2048 static void r300SetupPixelShader(GLcontext
*ctx
)
2050 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
2051 struct r300_fragment_program
*fp
= rmesa
->selected_fp
;
2052 struct r300_fragment_program_code
*code
;
2055 code
= &fp
->code
.code
.r300
;
2057 R300_STATECHANGE(rmesa
, fpi
[0]);
2058 R300_STATECHANGE(rmesa
, fpi
[1]);
2059 R300_STATECHANGE(rmesa
, fpi
[2]);
2060 R300_STATECHANGE(rmesa
, fpi
[3]);
2061 rmesa
->hw
.fpi
[0].cmd
[R300_FPI_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_US_ALU_RGB_INST_0
, code
->alu
.length
);
2062 rmesa
->hw
.fpi
[1].cmd
[R300_FPI_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_US_ALU_RGB_ADDR_0
, code
->alu
.length
);
2063 rmesa
->hw
.fpi
[2].cmd
[R300_FPI_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_US_ALU_ALPHA_INST_0
, code
->alu
.length
);
2064 rmesa
->hw
.fpi
[3].cmd
[R300_FPI_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_US_ALU_ALPHA_ADDR_0
, code
->alu
.length
);
2065 for (i
= 0; i
< code
->alu
.length
; i
++) {
2066 rmesa
->hw
.fpi
[0].cmd
[R300_FPI_INSTR_0
+ i
] = code
->alu
.inst
[i
].rgb_inst
;
2067 rmesa
->hw
.fpi
[1].cmd
[R300_FPI_INSTR_0
+ i
] = code
->alu
.inst
[i
].rgb_addr
;
2068 rmesa
->hw
.fpi
[2].cmd
[R300_FPI_INSTR_0
+ i
] = code
->alu
.inst
[i
].alpha_inst
;
2069 rmesa
->hw
.fpi
[3].cmd
[R300_FPI_INSTR_0
+ i
] = code
->alu
.inst
[i
].alpha_addr
;
2072 R300_STATECHANGE(rmesa
, fp
);
2073 rmesa
->hw
.fp
.cmd
[R300_FP_CNTL0
] = code
->config
;
2074 rmesa
->hw
.fp
.cmd
[R300_FP_CNTL1
] = code
->pixsize
;
2075 rmesa
->hw
.fp
.cmd
[R300_FP_CNTL2
] = code
->code_offset
;
2076 for (i
= 0; i
< 4; i
++)
2077 rmesa
->hw
.fp
.cmd
[R300_FP_NODE0
+ i
] = code
->code_addr
[i
];
2079 R300_STATECHANGE(rmesa
, fpp
);
2080 rmesa
->hw
.fpp
.cmd
[R300_FPP_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_PFS_PARAM_0_X
, fp
->code
.constants
.Count
* 4);
2081 for (i
= 0; i
< fp
->code
.constants
.Count
; i
++) {
2083 const GLfloat
*constant
= get_fragmentprogram_constant(ctx
, i
, buffer
);
2084 rmesa
->hw
.fpp
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 0] = r300PackFloat24(constant
[0]);
2085 rmesa
->hw
.fpp
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 1] = r300PackFloat24(constant
[1]);
2086 rmesa
->hw
.fpp
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 2] = r300PackFloat24(constant
[2]);
2087 rmesa
->hw
.fpp
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 3] = r300PackFloat24(constant
[3]);
2091 #define bump_r500fp_count(ptr, new_count) do{\
2092 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2093 int _nc=(new_count)/6; \
2094 assert(_nc < 256); \
2095 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2098 #define bump_r500fp_const_count(ptr, new_count) do{\
2099 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2100 int _nc=(new_count)/4; \
2101 assert(_nc < 256); \
2102 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2105 static void r500SetupPixelShader(GLcontext
*ctx
)
2107 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
2108 struct r300_fragment_program
*fp
= rmesa
->selected_fp
;
2110 struct r500_fragment_program_code
*code
;
2112 ((drm_r300_cmd_header_t
*) rmesa
->hw
.r500fp
.cmd
)->r500fp
.count
= 0;
2113 ((drm_r300_cmd_header_t
*) rmesa
->hw
.r500fp_const
.cmd
)->r500fp
.count
= 0;
2115 code
= &fp
->code
.code
.r500
;
2117 R300_STATECHANGE(rmesa
, fp
);
2118 rmesa
->hw
.fp
.cmd
[R500_FP_PIXSIZE
] = code
->max_temp_idx
;
2120 rmesa
->hw
.fp
.cmd
[R500_FP_CODE_ADDR
] =
2121 R500_US_CODE_START_ADDR(0) |
2122 R500_US_CODE_END_ADDR(code
->inst_end
);
2123 rmesa
->hw
.fp
.cmd
[R500_FP_CODE_RANGE
] =
2124 R500_US_CODE_RANGE_ADDR(0) |
2125 R500_US_CODE_RANGE_SIZE(code
->inst_end
);
2126 rmesa
->hw
.fp
.cmd
[R500_FP_CODE_OFFSET
] =
2127 R500_US_CODE_OFFSET_ADDR(0);
2129 R300_STATECHANGE(rmesa
, r500fp
);
2130 /* Emit our shader... */
2131 for (i
= 0; i
< code
->inst_end
+1; i
++) {
2132 rmesa
->hw
.r500fp
.cmd
[i
*6+1] = code
->inst
[i
].inst0
;
2133 rmesa
->hw
.r500fp
.cmd
[i
*6+2] = code
->inst
[i
].inst1
;
2134 rmesa
->hw
.r500fp
.cmd
[i
*6+3] = code
->inst
[i
].inst2
;
2135 rmesa
->hw
.r500fp
.cmd
[i
*6+4] = code
->inst
[i
].inst3
;
2136 rmesa
->hw
.r500fp
.cmd
[i
*6+5] = code
->inst
[i
].inst4
;
2137 rmesa
->hw
.r500fp
.cmd
[i
*6+6] = code
->inst
[i
].inst5
;
2140 bump_r500fp_count(rmesa
->hw
.r500fp
.cmd
, (code
->inst_end
+ 1) * 6);
2142 R300_STATECHANGE(rmesa
, r500fp_const
);
2143 for (i
= 0; i
< fp
->code
.constants
.Count
; i
++) {
2145 const GLfloat
*constant
= get_fragmentprogram_constant(ctx
, i
, buffer
);
2146 rmesa
->hw
.r500fp_const
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 0] = r300PackFloat32(constant
[0]);
2147 rmesa
->hw
.r500fp_const
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 1] = r300PackFloat32(constant
[1]);
2148 rmesa
->hw
.r500fp_const
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 2] = r300PackFloat32(constant
[2]);
2149 rmesa
->hw
.r500fp_const
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 3] = r300PackFloat32(constant
[3]);
2151 bump_r500fp_const_count(rmesa
->hw
.r500fp_const
.cmd
, fp
->code
.constants
.Count
* 4);
2154 void r300SetupVAP(GLcontext
*ctx
, GLuint InputsRead
, GLuint OutputsWritten
)
2156 r300ContextPtr rmesa
= R300_CONTEXT( ctx
);
2157 struct vertex_attribute
*attrs
= rmesa
->vbuf
.attribs
;
2158 int i
, j
, reg_count
;
2159 uint32_t *vir0
= &rmesa
->hw
.vir
[0].cmd
[1];
2160 uint32_t *vir1
= &rmesa
->hw
.vir
[1].cmd
[1];
2162 for (i
= 0; i
< R300_VIR_CMDSIZE
-1; ++i
)
2163 vir0
[i
] = vir1
[i
] = 0;
2165 for (i
= 0, j
= 0; i
< rmesa
->vbuf
.num_attribs
; ++i
) {
2168 tmp
= attrs
[i
].data_type
| (attrs
[i
].dst_loc
<< R300_DST_VEC_LOC_SHIFT
);
2169 if (attrs
[i
]._signed
)
2171 if (attrs
[i
].normalize
)
2172 tmp
|= R300_NORMALIZE
;
2175 vir0
[j
] = tmp
<< R300_DATA_TYPE_0_SHIFT
;
2176 vir1
[j
] = attrs
[i
].swizzle
| (attrs
[i
].write_mask
<< R300_WRITE_ENA_SHIFT
);
2178 vir0
[j
] |= tmp
<< R300_DATA_TYPE_1_SHIFT
;
2179 vir1
[j
] |= (attrs
[i
].swizzle
| (attrs
[i
].write_mask
<< R300_WRITE_ENA_SHIFT
)) << R300_SWIZZLE1_SHIFT
;
2184 reg_count
= (rmesa
->vbuf
.num_attribs
+ 1) >> 1;
2185 if (rmesa
->vbuf
.num_attribs
% 2 != 0) {
2186 vir0
[reg_count
-1] |= R300_LAST_VEC
<< R300_DATA_TYPE_0_SHIFT
;
2188 vir0
[reg_count
-1] |= R300_LAST_VEC
<< R300_DATA_TYPE_1_SHIFT
;
2191 R300_STATECHANGE(rmesa
, vir
[0]);
2192 R300_STATECHANGE(rmesa
, vir
[1]);
2193 R300_STATECHANGE(rmesa
, vof
);
2194 R300_STATECHANGE(rmesa
, vic
);
2196 if (rmesa
->radeon
.radeonScreen
->kernel_mm
) {
2197 rmesa
->hw
.vir
[0].cmd
[0] &= 0xC000FFFF;
2198 rmesa
->hw
.vir
[1].cmd
[0] &= 0xC000FFFF;
2199 rmesa
->hw
.vir
[0].cmd
[0] |= (reg_count
& 0x3FFF) << 16;
2200 rmesa
->hw
.vir
[1].cmd
[0] |= (reg_count
& 0x3FFF) << 16;
2202 ((drm_r300_cmd_header_t
*) rmesa
->hw
.vir
[0].cmd
)->packet0
.count
= reg_count
;
2203 ((drm_r300_cmd_header_t
*) rmesa
->hw
.vir
[1].cmd
)->packet0
.count
= reg_count
;
2206 rmesa
->hw
.vic
.cmd
[R300_VIC_CNTL_0
] = r300VAPInputCntl0(ctx
, InputsRead
);
2207 rmesa
->hw
.vic
.cmd
[R300_VIC_CNTL_1
] = r300VAPInputCntl1(ctx
, InputsRead
);
2208 rmesa
->hw
.vof
.cmd
[R300_VOF_CNTL_0
] = r300VAPOutputCntl0(ctx
, OutputsWritten
);
2209 rmesa
->hw
.vof
.cmd
[R300_VOF_CNTL_1
] = r300VAPOutputCntl1(ctx
, OutputsWritten
);
2212 void r300UpdateShaderStates(r300ContextPtr rmesa
)
2215 ctx
= rmesa
->radeon
.glCtx
;
2217 /* should only happenen once, just after context is created */
2218 if (!ctx
->FragmentProgram
._Current
)
2221 r300SetEarlyZState(ctx
);
2223 r300SetupTextures(ctx
);
2225 rmesa
->vtbl
.SetupPixelShader(ctx
);
2227 rmesa
->vtbl
.SetupRSUnit(ctx
);
2229 if (rmesa
->options
.hw_tcl_enabled
) {
2230 r300SetupVertexProgram(rmesa
);
2235 * Called by Mesa after an internal state update.
2237 static void r300InvalidateState(GLcontext
* ctx
, GLuint new_state
)
2239 r300ContextPtr r300
= R300_CONTEXT(ctx
);
2241 _swrast_InvalidateState(ctx
, new_state
);
2242 _swsetup_InvalidateState(ctx
, new_state
);
2243 _vbo_InvalidateState(ctx
, new_state
);
2244 _tnl_InvalidateState(ctx
, new_state
);
2246 if (new_state
& _NEW_BUFFERS
) {
2247 _mesa_update_framebuffer(ctx
);
2248 /* this updates the DrawBuffer's Width/Height if it's a FBO */
2249 _mesa_update_draw_buffer_bounds(ctx
);
2251 R300_STATECHANGE(r300
, cb
);
2252 R300_STATECHANGE(r300
, zb
);
2255 r300
->radeon
.NewGLState
|= new_state
;
2259 * Calculate initial hardware state and register state functions.
2260 * Assumes that the command buffer and state atoms have been
2261 * initialized already.
2263 void r300InitState(r300ContextPtr r300
)
2265 r300ResetHwState(r300
);
2268 static void r300RenderMode(GLcontext
* ctx
, GLenum mode
)
2270 r300SwitchFallback(ctx
, R300_FALLBACK_RENDER_MODE
, ctx
->RenderMode
!= GL_RENDER
);
2274 * Initialize driver's state callback functions
2276 void r300InitStateFuncs(struct dd_function_table
*functions
)
2279 functions
->UpdateState
= r300InvalidateState
;
2280 functions
->AlphaFunc
= r300AlphaFunc
;
2281 functions
->BlendColor
= r300BlendColor
;
2282 functions
->BlendEquationSeparate
= r300BlendEquationSeparate
;
2283 functions
->BlendFuncSeparate
= r300BlendFuncSeparate
;
2284 functions
->Enable
= r300Enable
;
2285 functions
->ColorMask
= r300ColorMask
;
2286 functions
->DepthFunc
= r300DepthFunc
;
2287 functions
->DepthMask
= r300DepthMask
;
2288 functions
->CullFace
= r300CullFace
;
2289 functions
->FrontFace
= r300FrontFace
;
2290 functions
->ShadeModel
= r300ShadeModel
;
2291 functions
->LogicOpcode
= r300LogicOpcode
;
2293 /* ARB_point_parameters */
2294 functions
->PointParameterfv
= r300PointParameter
;
2296 /* Stencil related */
2297 functions
->StencilFuncSeparate
= r300StencilFuncSeparate
;
2298 functions
->StencilMaskSeparate
= r300StencilMaskSeparate
;
2299 functions
->StencilOpSeparate
= r300StencilOpSeparate
;
2301 /* Viewport related */
2302 functions
->Viewport
= r300Viewport
;
2303 functions
->DepthRange
= r300DepthRange
;
2304 functions
->PointSize
= r300PointSize
;
2305 functions
->LineWidth
= r300LineWidth
;
2307 functions
->PolygonOffset
= r300PolygonOffset
;
2308 functions
->PolygonMode
= r300PolygonMode
;
2310 functions
->RenderMode
= r300RenderMode
;
2312 functions
->ClipPlane
= r300ClipPlane
;
2313 functions
->Scissor
= radeonScissor
;
2315 functions
->DrawBuffer
= radeonDrawBuffer
;
2316 functions
->ReadBuffer
= radeonReadBuffer
;
2319 void r300InitShaderFunctions(r300ContextPtr r300
)
2321 if (r300
->radeon
.radeonScreen
->chip_family
>= CHIP_FAMILY_RV515
) {
2322 r300
->vtbl
.SetupRSUnit
= r500SetupRSUnit
;
2323 r300
->vtbl
.SetupPixelShader
= r500SetupPixelShader
;
2324 r300
->vtbl
.SetupFragmentShaderTextures
= r500SetupFragmentShaderTextures
;
2326 r300
->vtbl
.SetupRSUnit
= r300SetupRSUnit
;
2327 r300
->vtbl
.SetupPixelShader
= r300SetupPixelShader
;
2328 r300
->vtbl
.SetupFragmentShaderTextures
= r300SetupFragmentShaderTextures
;