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
, vap_flush
);
375 R300_STATECHANGE( rmesa
, vpucp
[p
] );
376 rmesa
->hw
.vpucp
[p
].cmd
[R300_VPUCP_X
] = ip
[0];
377 rmesa
->hw
.vpucp
[p
].cmd
[R300_VPUCP_Y
] = ip
[1];
378 rmesa
->hw
.vpucp
[p
].cmd
[R300_VPUCP_Z
] = ip
[2];
379 rmesa
->hw
.vpucp
[p
].cmd
[R300_VPUCP_W
] = ip
[3];
382 static void r300SetClipPlaneState(GLcontext
* ctx
, GLenum cap
, GLboolean state
)
384 r300ContextPtr r300
= R300_CONTEXT(ctx
);
387 /* no VAP UCP on non-TCL chipsets */
388 if (!r300
->options
.hw_tcl_enabled
)
391 p
= cap
- GL_CLIP_PLANE0
;
392 R300_STATECHANGE(r300
, vap_clip_cntl
);
394 r300
->hw
.vap_clip_cntl
.cmd
[1] |= (R300_VAP_UCP_ENABLE_0
<< p
);
395 r300ClipPlane(ctx
, cap
, NULL
);
397 r300
->hw
.vap_clip_cntl
.cmd
[1] &= ~(R300_VAP_UCP_ENABLE_0
<< p
);
402 * Update our tracked culling state based on Mesa's state.
404 static void r300UpdateCulling(GLcontext
* ctx
)
406 r300ContextPtr r300
= R300_CONTEXT(ctx
);
409 if (ctx
->Polygon
.CullFlag
) {
410 switch (ctx
->Polygon
.CullFaceMode
) {
412 val
= R300_CULL_FRONT
;
415 val
= R300_CULL_BACK
;
417 case GL_FRONT_AND_BACK
:
418 val
= R300_CULL_FRONT
| R300_CULL_BACK
;
425 switch (ctx
->Polygon
.FrontFace
) {
427 val
|= R300_FRONT_FACE_CW
;
430 val
|= R300_FRONT_FACE_CCW
;
436 /* Winding is inverted when rendering to FBO */
437 if (ctx
->DrawBuffer
&& ctx
->DrawBuffer
->Name
)
438 val
^= R300_FRONT_FACE_CW
;
440 R300_STATECHANGE(r300
, cul
);
441 r300
->hw
.cul
.cmd
[R300_CUL_CULL
] = val
;
444 static void r300SetPolygonOffsetState(GLcontext
* ctx
, GLboolean state
)
446 r300ContextPtr r300
= R300_CONTEXT(ctx
);
448 R300_STATECHANGE(r300
, occlusion_cntl
);
450 r300
->hw
.occlusion_cntl
.cmd
[1] |= (3 << 0);
452 r300
->hw
.occlusion_cntl
.cmd
[1] &= ~(3 << 0);
456 static GLboolean
current_fragment_program_writes_depth(GLcontext
* ctx
)
458 r300ContextPtr r300
= R300_CONTEXT(ctx
);
460 return ctx
->FragmentProgram
._Current
&& r300
->selected_fp
->code
.writes_depth
;
463 static void r300SetEarlyZState(GLcontext
* ctx
)
465 r300ContextPtr r300
= R300_CONTEXT(ctx
);
466 GLuint topZ
= R300_ZTOP_ENABLE
;
467 GLuint w_fmt
, fgdepthsrc
;
469 if (ctx
->Color
.AlphaEnabled
&& ctx
->Color
.AlphaFunc
!= GL_ALWAYS
)
470 topZ
= R300_ZTOP_DISABLE
;
471 else if (current_fragment_program_writes_depth(ctx
))
472 topZ
= R300_ZTOP_DISABLE
;
473 else if (ctx
->FragmentProgram
._Current
&& ctx
->FragmentProgram
._Current
->UsesKill
)
474 topZ
= R300_ZTOP_DISABLE
;
475 else if (r300
->radeon
.query
.current
)
476 topZ
= R300_ZTOP_DISABLE
;
478 if (topZ
!= r300
->hw
.zstencil_format
.cmd
[2]) {
479 /* Note: This completely reemits the stencil format.
480 * I have not tested whether this is strictly necessary,
481 * or if emitting a write to ZB_ZTOP is enough.
483 R300_STATECHANGE(r300
, zstencil_format
);
484 r300
->hw
.zstencil_format
.cmd
[2] = topZ
;
487 /* w_fmt value is set to get best performance
488 * see p.130 R5xx 3D acceleration guide v1.3 */
489 if (current_fragment_program_writes_depth(ctx
)) {
490 fgdepthsrc
= R300_FG_DEPTH_SRC_SHADER
;
491 w_fmt
= R300_W_FMT_W24
| R300_W_SRC_US
;
493 fgdepthsrc
= R300_FG_DEPTH_SRC_SCAN
;
494 w_fmt
= R300_W_FMT_W0
| R300_W_SRC_US
;
497 if (w_fmt
!= r300
->hw
.us_out_fmt
.cmd
[5]) {
498 R300_STATECHANGE(r300
, us_out_fmt
);
499 r300
->hw
.us_out_fmt
.cmd
[5] = w_fmt
;
502 if (fgdepthsrc
!= r300
->hw
.fg_depth_src
.cmd
[1]) {
503 R300_STATECHANGE(r300
, fg_depth_src
);
504 r300
->hw
.fg_depth_src
.cmd
[1] = fgdepthsrc
;
508 static void r300SetAlphaState(GLcontext
* ctx
)
510 r300ContextPtr r300
= R300_CONTEXT(ctx
);
512 uint32_t pp_misc
= 0x0;
513 GLboolean really_enabled
= ctx
->Color
.AlphaEnabled
;
515 CLAMPED_FLOAT_TO_UBYTE(refByte
, ctx
->Color
.AlphaRef
);
517 switch (ctx
->Color
.AlphaFunc
) {
519 pp_misc
|= R300_FG_ALPHA_FUNC_NEVER
;
522 pp_misc
|= R300_FG_ALPHA_FUNC_LESS
;
525 pp_misc
|= R300_FG_ALPHA_FUNC_EQUAL
;
528 pp_misc
|= R300_FG_ALPHA_FUNC_LE
;
531 pp_misc
|= R300_FG_ALPHA_FUNC_GREATER
;
534 pp_misc
|= R300_FG_ALPHA_FUNC_NOTEQUAL
;
537 pp_misc
|= R300_FG_ALPHA_FUNC_GE
;
540 /*pp_misc |= FG_ALPHA_FUNC_ALWAYS; */
541 really_enabled
= GL_FALSE
;
545 if (really_enabled
) {
546 pp_misc
|= R300_FG_ALPHA_FUNC_ENABLE
;
547 pp_misc
|= R500_FG_ALPHA_FUNC_8BIT
;
548 pp_misc
|= (refByte
& R300_FG_ALPHA_FUNC_VAL_MASK
);
553 R300_STATECHANGE(r300
, at
);
554 r300
->hw
.at
.cmd
[R300_AT_ALPHA_TEST
] = pp_misc
;
555 r300
->hw
.at
.cmd
[R300_AT_UNKNOWN
] = 0;
558 static void r300AlphaFunc(GLcontext
* ctx
, GLenum func
, GLfloat ref
)
562 r300SetAlphaState(ctx
);
565 static int translate_func(int func
)
569 return R300_ZS_NEVER
;
573 return R300_ZS_EQUAL
;
575 return R300_ZS_LEQUAL
;
577 return R300_ZS_GREATER
;
579 return R300_ZS_NOTEQUAL
;
581 return R300_ZS_GEQUAL
;
583 return R300_ZS_ALWAYS
;
588 static void r300SetDepthState(GLcontext
* ctx
)
590 r300ContextPtr r300
= R300_CONTEXT(ctx
);
592 R300_STATECHANGE(r300
, zs
);
593 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] &= R300_STENCIL_ENABLE
|R300_STENCIL_FRONT_BACK
;
594 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] &= ~(R300_ZS_MASK
<< R300_Z_FUNC_SHIFT
);
596 if (ctx
->Depth
.Test
) {
597 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] |= R300_Z_ENABLE
;
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
;
605 static void r300CatchStencilFallback(GLcontext
*ctx
)
607 const unsigned back
= ctx
->Stencil
._BackFace
;
609 if (ctx
->Stencil
._Enabled
&& (ctx
->Stencil
.Ref
[0] != ctx
->Stencil
.Ref
[back
]
610 || ctx
->Stencil
.ValueMask
[0] != ctx
->Stencil
.ValueMask
[back
]
611 || ctx
->Stencil
.WriteMask
[0] != ctx
->Stencil
.WriteMask
[back
])) {
612 r300SwitchFallback(ctx
, R300_FALLBACK_STENCIL_TWOSIDE
, GL_TRUE
);
614 r300SwitchFallback(ctx
, R300_FALLBACK_STENCIL_TWOSIDE
, GL_FALSE
);
618 static void r300SetStencilState(GLcontext
* ctx
, GLboolean state
)
620 r300ContextPtr r300
= R300_CONTEXT(ctx
);
621 GLboolean hw_stencil
= GL_FALSE
;
623 r300CatchStencilFallback(ctx
);
625 if (ctx
->DrawBuffer
) {
626 struct radeon_renderbuffer
*rrbStencil
627 = radeon_get_renderbuffer(ctx
->DrawBuffer
, BUFFER_STENCIL
);
628 hw_stencil
= (rrbStencil
&& rrbStencil
->bo
);
632 R300_STATECHANGE(r300
, zs
);
634 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] |=
637 r300
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] &=
638 ~R300_STENCIL_ENABLE
;
643 static void r300UpdatePolygonMode(GLcontext
* ctx
)
645 r300ContextPtr r300
= R300_CONTEXT(ctx
);
646 uint32_t hw_mode
= R300_GA_POLY_MODE_DISABLE
;
648 /* Only do something if a polygon mode is wanted, default is GL_FILL */
649 if (ctx
->Polygon
.FrontMode
!= GL_FILL
||
650 ctx
->Polygon
.BackMode
!= GL_FILL
) {
653 /* Handle GL_CW (clock wise and GL_CCW (counter clock wise)
654 * correctly by selecting the correct front and back face
656 if (ctx
->Polygon
.FrontFace
== GL_CCW
) {
657 f
= ctx
->Polygon
.FrontMode
;
658 b
= ctx
->Polygon
.BackMode
;
660 f
= ctx
->Polygon
.BackMode
;
661 b
= ctx
->Polygon
.FrontMode
;
664 /* Enable polygon mode */
665 hw_mode
|= R300_GA_POLY_MODE_DUAL
;
669 hw_mode
|= R300_GA_POLY_MODE_FRONT_PTYPE_LINE
;
672 hw_mode
|= R300_GA_POLY_MODE_FRONT_PTYPE_POINT
;
675 hw_mode
|= R300_GA_POLY_MODE_FRONT_PTYPE_TRI
;
681 hw_mode
|= R300_GA_POLY_MODE_BACK_PTYPE_LINE
;
684 hw_mode
|= R300_GA_POLY_MODE_BACK_PTYPE_POINT
;
687 hw_mode
|= R300_GA_POLY_MODE_BACK_PTYPE_TRI
;
692 if (r300
->hw
.polygon_mode
.cmd
[1] != hw_mode
) {
693 R300_STATECHANGE(r300
, polygon_mode
);
694 r300
->hw
.polygon_mode
.cmd
[1] = hw_mode
;
697 r300
->hw
.polygon_mode
.cmd
[2] = 0x00000001;
698 r300
->hw
.polygon_mode
.cmd
[3] = 0x00000000;
702 * Change the culling mode.
704 * \note Mesa already filters redundant calls to this function.
706 static void r300CullFace(GLcontext
* ctx
, GLenum mode
)
710 r300UpdateCulling(ctx
);
714 * Change the polygon orientation.
716 * \note Mesa already filters redundant calls to this function.
718 static void r300FrontFace(GLcontext
* ctx
, GLenum mode
)
722 r300UpdateCulling(ctx
);
723 r300UpdatePolygonMode(ctx
);
727 * Change the depth testing function.
729 * \note Mesa already filters redundant calls to this function.
731 static void r300DepthFunc(GLcontext
* ctx
, GLenum func
)
734 r300SetDepthState(ctx
);
738 * Enable/Disable depth writing.
740 * \note Mesa already filters redundant calls to this function.
742 static void r300DepthMask(GLcontext
* ctx
, GLboolean mask
)
745 r300SetDepthState(ctx
);
749 * Handle glColorMask()
751 static void r300ColorMask(GLcontext
* ctx
,
752 GLboolean r
, GLboolean g
, GLboolean b
, GLboolean a
)
754 r300ContextPtr r300
= R300_CONTEXT(ctx
);
755 int mask
= (r
? RB3D_COLOR_CHANNEL_MASK_RED_MASK0
: 0) |
756 (g
? RB3D_COLOR_CHANNEL_MASK_GREEN_MASK0
: 0) |
757 (b
? RB3D_COLOR_CHANNEL_MASK_BLUE_MASK0
: 0) |
758 (a
? RB3D_COLOR_CHANNEL_MASK_ALPHA_MASK0
: 0);
760 if (mask
!= r300
->hw
.cmk
.cmd
[R300_CMK_COLORMASK
]) {
761 R300_STATECHANGE(r300
, cmk
);
762 r300
->hw
.cmk
.cmd
[R300_CMK_COLORMASK
] = mask
;
766 /* =============================================================
769 static void r300PointSize(GLcontext
* ctx
, GLfloat size
)
771 r300ContextPtr r300
= R300_CONTEXT(ctx
);
773 /* We need to clamp to user defined range here, because
774 * the HW clamping happens only for per vertex point size. */
775 size
= CLAMP(size
, ctx
->Point
.MinSize
, ctx
->Point
.MaxSize
);
777 /* same size limits for AA, non-AA points */
778 size
= CLAMP(size
, ctx
->Const
.MinPointSize
, ctx
->Const
.MaxPointSize
);
780 R300_STATECHANGE(r300
, ps
);
781 r300
->hw
.ps
.cmd
[R300_PS_POINTSIZE
] =
782 ((int)(size
* 6) << R300_POINTSIZE_X_SHIFT
) |
783 ((int)(size
* 6) << R300_POINTSIZE_Y_SHIFT
);
786 static void r300PointParameter(GLcontext
* ctx
, GLenum pname
, const GLfloat
* param
)
788 r300ContextPtr r300
= R300_CONTEXT(ctx
);
791 case GL_POINT_SIZE_MIN
:
792 R300_STATECHANGE(r300
, ga_point_minmax
);
793 r300
->hw
.ga_point_minmax
.cmd
[1] &= ~R300_GA_POINT_MINMAX_MIN_MASK
;
794 r300
->hw
.ga_point_minmax
.cmd
[1] |= (GLuint
)(ctx
->Point
.MinSize
* 6.0);
796 case GL_POINT_SIZE_MAX
:
797 R300_STATECHANGE(r300
, ga_point_minmax
);
798 r300
->hw
.ga_point_minmax
.cmd
[1] &= ~R300_GA_POINT_MINMAX_MAX_MASK
;
799 r300
->hw
.ga_point_minmax
.cmd
[1] |= (GLuint
)(ctx
->Point
.MaxSize
* 6.0)
800 << R300_GA_POINT_MINMAX_MAX_SHIFT
;
802 case GL_POINT_DISTANCE_ATTENUATION
:
804 case GL_POINT_FADE_THRESHOLD_SIZE
:
811 /* =============================================================
814 static void r300LineWidth(GLcontext
* ctx
, GLfloat widthf
)
816 r300ContextPtr r300
= R300_CONTEXT(ctx
);
818 widthf
= CLAMP(widthf
,
819 ctx
->Const
.MinPointSize
,
820 ctx
->Const
.MaxPointSize
);
821 R300_STATECHANGE(r300
, lcntl
);
822 r300
->hw
.lcntl
.cmd
[1] =
823 R300_LINE_CNT_HO
| R300_LINE_CNT_VE
| (int)(widthf
* 6.0);
826 static void r300PolygonMode(GLcontext
* ctx
, GLenum face
, GLenum mode
)
831 r300UpdatePolygonMode(ctx
);
834 /* =============================================================
838 static int translate_stencil_op(int op
)
846 return R300_ZS_REPLACE
;
851 case GL_INCR_WRAP_EXT
:
852 return R300_ZS_INCR_WRAP
;
853 case GL_DECR_WRAP_EXT
:
854 return R300_ZS_DECR_WRAP
;
856 return R300_ZS_INVERT
;
858 WARN_ONCE("Do not know how to translate stencil op");
864 static void r300ShadeModel(GLcontext
* ctx
, GLenum mode
)
866 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
868 R300_STATECHANGE(rmesa
, shade
);
869 rmesa
->hw
.shade
.cmd
[1] = 0x00000002;
870 R300_STATECHANGE(rmesa
, shade2
);
873 rmesa
->hw
.shade2
.cmd
[1] = R300_RE_SHADE_MODEL_FLAT
;
876 rmesa
->hw
.shade2
.cmd
[1] = R300_RE_SHADE_MODEL_SMOOTH
;
881 rmesa
->hw
.shade2
.cmd
[2] = 0x00000000;
882 rmesa
->hw
.shade2
.cmd
[3] = 0x00000000;
885 static void r300StencilFuncSeparate(GLcontext
* ctx
, GLenum face
,
886 GLenum func
, GLint ref
, GLuint mask
)
888 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
891 const unsigned back
= ctx
->Stencil
._BackFace
;
893 r300CatchStencilFallback(ctx
);
895 refmask
= ((ctx
->Stencil
.Ref
[0] & 0xff) << R300_STENCILREF_SHIFT
)
896 | ((ctx
->Stencil
.ValueMask
[0] & 0xff) << R300_STENCILMASK_SHIFT
);
898 R300_STATECHANGE(rmesa
, zs
);
899 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_0
] |= R300_STENCIL_FRONT_BACK
;
900 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] &= ~((R300_ZS_MASK
<<
901 R300_S_FRONT_FUNC_SHIFT
)
903 R300_S_BACK_FUNC_SHIFT
));
905 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_2
] &=
906 ~((R300_STENCILREF_MASK
<< R300_STENCILREF_SHIFT
) |
907 (R300_STENCILREF_MASK
<< R300_STENCILMASK_SHIFT
));
909 flag
= translate_func(ctx
->Stencil
.Function
[0]);
910 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
911 (flag
<< R300_S_FRONT_FUNC_SHIFT
);
913 flag
= translate_func(ctx
->Stencil
.Function
[back
]);
915 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
916 (flag
<< R300_S_BACK_FUNC_SHIFT
);
917 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_2
] |= refmask
;
920 static void r300StencilMaskSeparate(GLcontext
* ctx
, GLenum face
, GLuint mask
)
922 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
924 r300CatchStencilFallback(ctx
);
926 R300_STATECHANGE(rmesa
, zs
);
927 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_2
] &=
928 ~(R300_STENCILREF_MASK
<<
929 R300_STENCILWRITEMASK_SHIFT
);
930 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_2
] |=
932 WriteMask
[0] & R300_STENCILREF_MASK
) <<
933 R300_STENCILWRITEMASK_SHIFT
;
936 static void r300StencilOpSeparate(GLcontext
* ctx
, GLenum face
,
937 GLenum fail
, GLenum zfail
, GLenum zpass
)
939 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
940 const unsigned back
= ctx
->Stencil
._BackFace
;
942 r300CatchStencilFallback(ctx
);
944 R300_STATECHANGE(rmesa
, zs
);
945 /* It is easier to mask what's left.. */
946 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] &=
947 (R300_ZS_MASK
<< R300_Z_FUNC_SHIFT
) |
948 (R300_ZS_MASK
<< R300_S_FRONT_FUNC_SHIFT
) |
949 (R300_ZS_MASK
<< R300_S_BACK_FUNC_SHIFT
);
951 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
952 (translate_stencil_op(ctx
->Stencil
.FailFunc
[0]) <<
953 R300_S_FRONT_SFAIL_OP_SHIFT
)
954 | (translate_stencil_op(ctx
->Stencil
.ZFailFunc
[0]) <<
955 R300_S_FRONT_ZFAIL_OP_SHIFT
)
956 | (translate_stencil_op(ctx
->Stencil
.ZPassFunc
[0]) <<
957 R300_S_FRONT_ZPASS_OP_SHIFT
);
959 rmesa
->hw
.zs
.cmd
[R300_ZS_CNTL_1
] |=
960 (translate_stencil_op(ctx
->Stencil
.FailFunc
[back
]) <<
961 R300_S_BACK_SFAIL_OP_SHIFT
)
962 | (translate_stencil_op(ctx
->Stencil
.ZFailFunc
[back
]) <<
963 R300_S_BACK_ZFAIL_OP_SHIFT
)
964 | (translate_stencil_op(ctx
->Stencil
.ZPassFunc
[back
]) <<
965 R300_S_BACK_ZPASS_OP_SHIFT
);
968 /* =============================================================
969 * Window position and viewport transformation
972 static void r300UpdateWindow(GLcontext
* ctx
)
974 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
975 __DRIdrawablePrivate
*dPriv
= radeon_get_drawable(&rmesa
->radeon
);
976 GLfloat xoffset
= dPriv
? (GLfloat
) dPriv
->x
: 0;
977 GLfloat yoffset
= dPriv
? (GLfloat
) dPriv
->y
+ dPriv
->h
: 0;
978 const GLfloat
*v
= ctx
->Viewport
._WindowMap
.m
;
979 const GLfloat depthScale
= 1.0F
/ ctx
->DrawBuffer
->_DepthMaxF
;
980 const GLboolean render_to_fbo
= (ctx
->DrawBuffer
->Name
!= 0);
981 GLfloat y_scale
, y_bias
;
991 GLfloat sx
= v
[MAT_SX
];
992 GLfloat tx
= v
[MAT_TX
] + xoffset
;
993 GLfloat sy
= v
[MAT_SY
] * y_scale
;
994 GLfloat ty
= (v
[MAT_TY
] * y_scale
) + y_bias
;
995 GLfloat sz
= v
[MAT_SZ
] * depthScale
;
996 GLfloat tz
= v
[MAT_TZ
] * depthScale
;
998 R300_STATECHANGE(rmesa
, vpt
);
1000 rmesa
->hw
.vpt
.cmd
[R300_VPT_XSCALE
] = r300PackFloat32(sx
);
1001 rmesa
->hw
.vpt
.cmd
[R300_VPT_XOFFSET
] = r300PackFloat32(tx
);
1002 rmesa
->hw
.vpt
.cmd
[R300_VPT_YSCALE
] = r300PackFloat32(sy
);
1003 rmesa
->hw
.vpt
.cmd
[R300_VPT_YOFFSET
] = r300PackFloat32(ty
);
1004 rmesa
->hw
.vpt
.cmd
[R300_VPT_ZSCALE
] = r300PackFloat32(sz
);
1005 rmesa
->hw
.vpt
.cmd
[R300_VPT_ZOFFSET
] = r300PackFloat32(tz
);
1008 static void r300Viewport(GLcontext
* ctx
, GLint x
, GLint y
,
1009 GLsizei width
, GLsizei height
)
1011 /* Don't pipeline viewport changes, conflict with window offset
1012 * setting below. Could apply deltas to rescue pipelined viewport
1013 * values, or keep the originals hanging around.
1015 r300UpdateWindow(ctx
);
1017 radeon_viewport(ctx
, x
, y
, width
, height
);
1020 static void r300DepthRange(GLcontext
* ctx
, GLclampd nearval
, GLclampd farval
)
1022 r300UpdateWindow(ctx
);
1025 void r300UpdateViewportOffset(GLcontext
* ctx
)
1027 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1028 __DRIdrawablePrivate
*dPriv
= radeon_get_drawable(&rmesa
->radeon
);
1029 GLfloat xoffset
= (GLfloat
) dPriv
->x
;
1030 GLfloat yoffset
= (GLfloat
) dPriv
->y
+ dPriv
->h
;
1031 const GLfloat
*v
= ctx
->Viewport
._WindowMap
.m
;
1033 GLfloat tx
= v
[MAT_TX
] + xoffset
;
1034 GLfloat ty
= (-v
[MAT_TY
]) + yoffset
;
1036 if (rmesa
->hw
.vpt
.cmd
[R300_VPT_XOFFSET
] != r300PackFloat32(tx
) ||
1037 rmesa
->hw
.vpt
.cmd
[R300_VPT_YOFFSET
] != r300PackFloat32(ty
)) {
1038 /* Note: this should also modify whatever data the context reset
1041 R300_STATECHANGE(rmesa
, vpt
);
1042 rmesa
->hw
.vpt
.cmd
[R300_VPT_XOFFSET
] = r300PackFloat32(tx
);
1043 rmesa
->hw
.vpt
.cmd
[R300_VPT_YOFFSET
] = r300PackFloat32(ty
);
1047 radeonUpdateScissor(ctx
);
1051 * Update R300's own internal state parameters.
1052 * For now just STATE_R300_WINDOW_DIMENSION
1054 static void r300UpdateStateParameters(GLcontext
* ctx
, GLuint new_state
)
1056 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1057 struct gl_program_parameter_list
*paramList
;
1059 if (!(new_state
& (_NEW_BUFFERS
| _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
)))
1062 if (!ctx
->FragmentProgram
._Current
|| !rmesa
->selected_fp
)
1065 paramList
= ctx
->FragmentProgram
._Current
->Base
.Parameters
;
1070 _mesa_load_state_parameters(ctx
, paramList
);
1073 /* =============================================================
1076 static void r300PolygonOffset(GLcontext
* ctx
, GLfloat factor
, GLfloat units
)
1078 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1079 GLfloat constant
= units
;
1081 switch (ctx
->Visual
.depthBits
) {
1092 /* fprintf(stderr, "%s f:%f u:%f\n", __FUNCTION__, factor, constant); */
1094 R300_STATECHANGE(rmesa
, zbs
);
1095 rmesa
->hw
.zbs
.cmd
[R300_ZBS_T_FACTOR
] = r300PackFloat32(factor
);
1096 rmesa
->hw
.zbs
.cmd
[R300_ZBS_T_CONSTANT
] = r300PackFloat32(constant
);
1097 rmesa
->hw
.zbs
.cmd
[R300_ZBS_W_FACTOR
] = r300PackFloat32(factor
);
1098 rmesa
->hw
.zbs
.cmd
[R300_ZBS_W_CONSTANT
] = r300PackFloat32(constant
);
1101 /* Routing and texture-related */
1103 /* r300 doesnt handle GL_CLAMP and GL_MIRROR_CLAMP_EXT correctly when filter is NEAREST.
1104 * Since texwrap produces same results for GL_CLAMP and GL_CLAMP_TO_EDGE we use them instead.
1105 * We need to recalculate wrap modes whenever filter mode is changed because someone might do:
1106 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1107 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1108 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1109 * Since r300 completely ignores R300_TX_CLAMP when either min or mag is nearest it cant handle
1110 * combinations where only one of them is nearest.
1112 static unsigned long gen_fixed_filter(unsigned long f
)
1114 unsigned long mag
, min
, needs_fixing
= 0;
1117 /* We ignore MIRROR bit so we dont have to do everything twice */
1118 if ((f
& ((7 - 1) << R300_TX_WRAP_S_SHIFT
)) ==
1119 (R300_TX_CLAMP
<< R300_TX_WRAP_S_SHIFT
)) {
1122 if ((f
& ((7 - 1) << R300_TX_WRAP_T_SHIFT
)) ==
1123 (R300_TX_CLAMP
<< R300_TX_WRAP_T_SHIFT
)) {
1126 if ((f
& ((7 - 1) << R300_TX_WRAP_R_SHIFT
)) ==
1127 (R300_TX_CLAMP
<< R300_TX_WRAP_R_SHIFT
)) {
1134 mag
= f
& R300_TX_MAG_FILTER_MASK
;
1135 min
= f
& (R300_TX_MIN_FILTER_MASK
|R300_TX_MIN_FILTER_MIP_MASK
);
1137 /* TODO: Check for anisto filters too */
1138 if ((mag
!= R300_TX_MAG_FILTER_NEAREST
)
1139 && (min
!= R300_TX_MIN_FILTER_NEAREST
))
1142 /* r300 cant handle these modes hence we force nearest to linear */
1143 if ((mag
== R300_TX_MAG_FILTER_NEAREST
)
1144 && (min
!= R300_TX_MIN_FILTER_NEAREST
)) {
1145 f
&= ~R300_TX_MAG_FILTER_NEAREST
;
1146 f
|= R300_TX_MAG_FILTER_LINEAR
;
1150 if ((min
== R300_TX_MIN_FILTER_NEAREST
)
1151 && (mag
!= R300_TX_MAG_FILTER_NEAREST
)) {
1152 f
&= ~R300_TX_MIN_FILTER_NEAREST
;
1153 f
|= R300_TX_MIN_FILTER_LINEAR
;
1157 /* Both are nearest */
1158 if (needs_fixing
& 1) {
1159 f
&= ~((7 - 1) << R300_TX_WRAP_S_SHIFT
);
1160 f
|= R300_TX_CLAMP_TO_EDGE
<< R300_TX_WRAP_S_SHIFT
;
1162 if (needs_fixing
& 2) {
1163 f
&= ~((7 - 1) << R300_TX_WRAP_T_SHIFT
);
1164 f
|= R300_TX_CLAMP_TO_EDGE
<< R300_TX_WRAP_T_SHIFT
;
1166 if (needs_fixing
& 4) {
1167 f
&= ~((7 - 1) << R300_TX_WRAP_R_SHIFT
);
1168 f
|= R300_TX_CLAMP_TO_EDGE
<< R300_TX_WRAP_R_SHIFT
;
1173 static void r300SetupFragmentShaderTextures(GLcontext
*ctx
, int *tmu_mappings
)
1175 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1177 struct r300_fragment_program_code
*code
= &r300
->selected_fp
->code
.code
.r300
;
1179 R300_STATECHANGE(r300
, fpt
);
1181 for (i
= 0; i
< code
->tex
.length
; i
++) {
1186 unit
= code
->tex
.inst
[i
] >> R300_TEX_ID_SHIFT
;
1189 val
= code
->tex
.inst
[i
];
1190 val
&= ~R300_TEX_ID_MASK
;
1193 (val
& R300_TEX_INST_MASK
) >> R300_TEX_INST_SHIFT
;
1194 if (opcode
== R300_TEX_OP_KIL
) {
1195 r300
->hw
.fpt
.cmd
[R300_FPT_INSTR_0
+ i
] = val
;
1197 if (tmu_mappings
[unit
] >= 0) {
1199 tmu_mappings
[unit
] <<
1201 r300
->hw
.fpt
.cmd
[R300_FPT_INSTR_0
+ i
] = val
;
1203 // We get here when the corresponding texture image is incomplete
1204 // (e.g. incomplete mipmaps etc.)
1205 r300
->hw
.fpt
.cmd
[R300_FPT_INSTR_0
+ i
] = val
;
1210 r300
->hw
.fpt
.cmd
[R300_FPT_CMD_0
] =
1211 cmdpacket0(r300
->radeon
.radeonScreen
,
1212 R300_US_TEX_INST_0
, code
->tex
.length
);
1215 static void r500SetupFragmentShaderTextures(GLcontext
*ctx
, int *tmu_mappings
)
1217 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1219 struct r500_fragment_program_code
*code
= &r300
->selected_fp
->code
.code
.r500
;
1221 /* find all the texture instructions and relocate the texture units */
1222 for (i
= 0; i
< code
->inst_end
+ 1; i
++) {
1223 if ((code
->inst
[i
].inst0
& 0x3) == R500_INST_TYPE_TEX
) {
1225 int unit
, opcode
, new_unit
;
1227 val
= code
->inst
[i
].inst1
;
1229 unit
= (val
>> 16) & 0xf;
1231 val
&= ~(0xf << 16);
1233 opcode
= val
& (0x7 << 22);
1234 if (opcode
== R500_TEX_INST_TEXKILL
) {
1237 if (tmu_mappings
[unit
] >= 0) {
1238 new_unit
= tmu_mappings
[unit
];
1243 val
|= R500_TEX_ID(new_unit
);
1244 code
->inst
[i
].inst1
= val
;
1249 static GLuint
translate_lod_bias(GLfloat bias
)
1251 GLint b
= (int)(bias
*32);
1254 else if (b
< -(1 << 9))
1256 return (((GLuint
)b
) << R300_LOD_BIAS_SHIFT
) & R300_LOD_BIAS_MASK
;
1260 static void r300SetupTextures(GLcontext
* ctx
)
1263 struct radeon_tex_obj
*t
;
1264 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1266 int last_hw_tmu
= -1; /* -1 translates into no setup costs for fields */
1267 int tmu_mappings
[R300_MAX_TEXTURE_UNITS
] = { -1, };
1269 R300_STATECHANGE(r300
, txe
);
1270 R300_STATECHANGE(r300
, tex
.filter
);
1271 R300_STATECHANGE(r300
, tex
.filter_1
);
1272 R300_STATECHANGE(r300
, tex
.size
);
1273 R300_STATECHANGE(r300
, tex
.format
);
1274 R300_STATECHANGE(r300
, tex
.pitch
);
1275 R300_STATECHANGE(r300
, tex
.offset
);
1276 R300_STATECHANGE(r300
, tex
.chroma_key
);
1277 R300_STATECHANGE(r300
, tex
.border_color
);
1279 r300
->hw
.txe
.cmd
[R300_TXE_ENABLE
] = 0x0;
1281 mtu
= r300
->radeon
.glCtx
->Const
.MaxTextureUnits
;
1282 if (RADEON_DEBUG
& RADEON_STATE
)
1283 fprintf(stderr
, "mtu=%d\n", mtu
);
1285 if (mtu
> R300_MAX_TEXTURE_UNITS
) {
1287 "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1288 mtu
, R300_MAX_TEXTURE_UNITS
);
1292 /* We cannot let disabled tmu offsets pass DRM */
1293 for (i
= 0; i
< mtu
; i
++) {
1294 if (ctx
->Texture
.Unit
[i
]._ReallyEnabled
) {
1295 tmu_mappings
[i
] = hw_tmu
;
1297 t
= radeon_tex_obj(ctx
->Texture
.Unit
[i
]._Current
);
1301 if ((t
->pp_txformat
& 0xffffff00) == 0xffffff00) {
1303 ("unknown texture format (entry %x) encountered. Help me !\n",
1304 t
->pp_txformat
& 0xff);
1307 if (RADEON_DEBUG
& RADEON_STATE
)
1309 "Activating texture unit %d\n", i
);
1311 r300
->hw
.txe
.cmd
[R300_TXE_ENABLE
] |= (1 << hw_tmu
);
1313 r300
->hw
.tex
.filter
.cmd
[R300_TEX_VALUE_0
+
1315 gen_fixed_filter(t
->pp_txfilter
) | (hw_tmu
<< 28);
1316 /* Note: There is a LOD bias per texture unit and a LOD bias
1317 * per texture object. We add them here to get the correct behaviour.
1318 * (The per-texture object LOD bias was introduced in OpenGL 1.4
1319 * and is not present in the EXT_texture_object extension).
1321 r300
->hw
.tex
.filter_1
.cmd
[R300_TEX_VALUE_0
+ hw_tmu
] =
1323 translate_lod_bias(ctx
->Texture
.Unit
[i
].LodBias
+ t
->base
.LodBias
);
1324 r300
->hw
.tex
.size
.cmd
[R300_TEX_VALUE_0
+ hw_tmu
] =
1326 r300
->hw
.tex
.format
.cmd
[R300_TEX_VALUE_0
+
1327 hw_tmu
] = t
->pp_txformat
;
1328 r300
->hw
.tex
.pitch
.cmd
[R300_TEX_VALUE_0
+ hw_tmu
] =
1330 r300
->hw
.textures
[hw_tmu
] = t
;
1332 if (t
->tile_bits
& R300_TXO_MACRO_TILE
) {
1333 WARN_ONCE("macro tiling enabled!\n");
1336 if (t
->tile_bits
& R300_TXO_MICRO_TILE
) {
1337 WARN_ONCE("micro tiling enabled!\n");
1340 r300
->hw
.tex
.chroma_key
.cmd
[R300_TEX_VALUE_0
+
1342 r300
->hw
.tex
.border_color
.cmd
[R300_TEX_VALUE_0
+
1346 last_hw_tmu
= hw_tmu
;
1352 /* R3xx and R4xx chips require that the texture unit corresponding to
1353 * KIL instructions is really enabled.
1355 * We do some fakery here and in the state atom emit logic to enable
1356 * the texture without tripping up the CS checker in the kernel.
1358 if (r300
->radeon
.radeonScreen
->chip_family
< CHIP_FAMILY_RV515
) {
1359 if (ctx
->FragmentProgram
._Current
->UsesKill
&& last_hw_tmu
< 0) {
1362 r300
->hw
.txe
.cmd
[R300_TXE_ENABLE
] |= 1;
1364 r300
->hw
.tex
.border_color
.cmd
[R300_TEX_VALUE_0
] = 0;
1365 r300
->hw
.tex
.chroma_key
.cmd
[R300_TEX_VALUE_0
] = 0;
1366 r300
->hw
.tex
.filter
.cmd
[R300_TEX_VALUE_0
] = 0;
1367 r300
->hw
.tex
.filter_1
.cmd
[R300_TEX_VALUE_0
] = 0;
1368 r300
->hw
.tex
.size
.cmd
[R300_TEX_VALUE_0
] = 0; /* 1x1 texture */
1369 r300
->hw
.tex
.format
.cmd
[R300_TEX_VALUE_0
] = 0; /* A8 format */
1370 r300
->hw
.tex
.pitch
.cmd
[R300_TEX_VALUE_0
] = 0;
1374 r300
->hw
.tex
.filter
.cmd
[R300_TEX_CMD_0
] =
1375 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_FILTER0_0
, last_hw_tmu
+ 1);
1376 r300
->hw
.tex
.filter_1
.cmd
[R300_TEX_CMD_0
] =
1377 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_FILTER1_0
, last_hw_tmu
+ 1);
1378 r300
->hw
.tex
.size
.cmd
[R300_TEX_CMD_0
] =
1379 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_SIZE_0
, last_hw_tmu
+ 1);
1380 r300
->hw
.tex
.format
.cmd
[R300_TEX_CMD_0
] =
1381 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_FORMAT_0
, last_hw_tmu
+ 1);
1382 r300
->hw
.tex
.pitch
.cmd
[R300_TEX_CMD_0
] =
1383 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_FORMAT2_0
, last_hw_tmu
+ 1);
1384 r300
->hw
.tex
.offset
.cmd
[R300_TEX_CMD_0
] =
1385 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_OFFSET_0
, last_hw_tmu
+ 1);
1386 r300
->hw
.tex
.chroma_key
.cmd
[R300_TEX_CMD_0
] =
1387 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_CHROMA_KEY_0
, last_hw_tmu
+ 1);
1388 r300
->hw
.tex
.border_color
.cmd
[R300_TEX_CMD_0
] =
1389 cmdpacket0(r300
->radeon
.radeonScreen
, R300_TX_BORDER_COLOR_0
, last_hw_tmu
+ 1);
1391 r300
->vtbl
.SetupFragmentShaderTextures(ctx
, tmu_mappings
);
1393 if (RADEON_DEBUG
& RADEON_STATE
)
1394 fprintf(stderr
, "TX_ENABLE: %08x last_hw_tmu=%d\n",
1395 r300
->hw
.txe
.cmd
[R300_TXE_ENABLE
], last_hw_tmu
);
1398 union r300_outputs_written
{
1399 GLuint vp_outputs
; /* hw_tcl_on */
1400 DECLARE_RENDERINPUTS(index_bitset
); /* !hw_tcl_on */
1403 #define R300_OUTPUTS_WRITTEN_TEST(ow, vp_result, tnl_attrib) \
1404 ((hw_tcl_on) ? (ow).vp_outputs & (1 << (vp_result)) : \
1405 RENDERINPUTS_TEST( (ow.index_bitset), (tnl_attrib) ))
1407 static void r300SetupRSUnit(GLcontext
* ctx
)
1409 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1410 union r300_outputs_written OutputsWritten
;
1412 int fp_reg
, high_rr
;
1414 int rs_tex_count
= 0;
1415 int i
, col_fmt
, hw_tcl_on
;
1417 hw_tcl_on
= r300
->options
.hw_tcl_enabled
;
1420 OutputsWritten
.vp_outputs
= r300
->selected_vp
->code
.OutputsWritten
;
1422 RENDERINPUTS_COPY(OutputsWritten
.index_bitset
, r300
->render_inputs_bitset
);
1424 InputsRead
= r300
->selected_fp
->InputsRead
;
1426 R300_STATECHANGE(r300
, ri
);
1427 R300_STATECHANGE(r300
, rc
);
1428 R300_STATECHANGE(r300
, rr
);
1430 fp_reg
= col_ip
= tex_ip
= col_fmt
= 0;
1432 r300
->hw
.rc
.cmd
[1] = 0;
1433 r300
->hw
.rc
.cmd
[2] = 0;
1434 for (i
=0; i
<R300_RR_CMDSIZE
-1; ++i
)
1435 r300
->hw
.rr
.cmd
[R300_RR_INST_0
+ i
] = 0;
1437 for (i
=0; i
<R300_RI_CMDSIZE
-1; ++i
)
1438 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
+ i
] = 0;
1441 if (InputsRead
& FRAG_BIT_COL0
) {
1442 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_COL0
, _TNL_ATTRIB_COLOR0
)) {
1443 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
);
1444 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
);
1445 InputsRead
&= ~FRAG_BIT_COL0
;
1449 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1453 if (InputsRead
& FRAG_BIT_COL1
) {
1454 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_COL1
, _TNL_ATTRIB_COLOR1
)) {
1455 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
);
1456 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
);
1457 InputsRead
&= ~FRAG_BIT_COL1
;
1461 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1465 /* We always route 4 texcoord components */
1466 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
1467 if (! ( InputsRead
& FRAG_BIT_TEX(i
) ) )
1470 if (!R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_TEX0
+ i
, _TNL_ATTRIB_TEX(i
))) {
1471 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i
);
1475 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
);
1476 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
);
1477 InputsRead
&= ~(FRAG_BIT_TEX0
<< i
);
1483 /* Setup default color if no color or tex was set */
1484 if (rs_tex_count
== 0 && col_ip
== 0) {
1485 r300
->hw
.rr
.cmd
[R300_RR_INST_0
] = R300_RS_INST_COL_ID(0) | R300_RS_INST_COL_ADDR(0);
1486 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
] = R300_RS_COL_PTR(0) | R300_RS_COL_FMT(R300_RS_COL_FMT_0001
);
1490 high_rr
= (col_ip
> tex_ip
) ? col_ip
: tex_ip
;
1491 r300
->hw
.rc
.cmd
[1] |= (rs_tex_count
<< R300_IT_COUNT_SHIFT
) | (col_ip
<< R300_IC_COUNT_SHIFT
) | R300_HIRES_EN
;
1492 r300
->hw
.rc
.cmd
[2] |= high_rr
- 1;
1494 r300
->hw
.rr
.cmd
[R300_RR_CMD_0
] = cmdpacket0(r300
->radeon
.radeonScreen
, R300_RS_INST_0
, high_rr
);
1495 r300
->hw
.ri
.cmd
[R300_RI_CMD_0
] = cmdpacket0(r300
->radeon
.radeonScreen
, R300_RS_IP_0
, high_rr
);
1498 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead
);
1501 static void r500SetupRSUnit(GLcontext
* ctx
)
1503 r300ContextPtr r300
= R300_CONTEXT(ctx
);
1504 union r300_outputs_written OutputsWritten
;
1506 int fp_reg
, high_rr
;
1508 int rs_tex_count
= 0;
1509 int i
, col_fmt
, hw_tcl_on
;
1511 hw_tcl_on
= r300
->options
.hw_tcl_enabled
;
1514 OutputsWritten
.vp_outputs
= r300
->selected_vp
->code
.OutputsWritten
;
1516 RENDERINPUTS_COPY(OutputsWritten
.index_bitset
, r300
->render_inputs_bitset
);
1518 InputsRead
= r300
->selected_fp
->InputsRead
;
1520 R300_STATECHANGE(r300
, ri
);
1521 R300_STATECHANGE(r300
, rc
);
1522 R300_STATECHANGE(r300
, rr
);
1524 fp_reg
= col_ip
= tex_ip
= col_fmt
= 0;
1526 r300
->hw
.rc
.cmd
[1] = 0;
1527 r300
->hw
.rc
.cmd
[2] = 0;
1528 for (i
=0; i
<R300_RR_CMDSIZE
-1; ++i
)
1529 r300
->hw
.rr
.cmd
[R300_RR_INST_0
+ i
] = 0;
1531 for (i
=0; i
<R500_RI_CMDSIZE
-1; ++i
)
1532 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
+ i
] = 0;
1535 if (InputsRead
& FRAG_BIT_COL0
) {
1536 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_COL0
, _TNL_ATTRIB_COLOR0
)) {
1537 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
);
1538 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
);
1539 InputsRead
&= ~FRAG_BIT_COL0
;
1543 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1547 if (InputsRead
& FRAG_BIT_COL1
) {
1548 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_COL1
, _TNL_ATTRIB_COLOR1
)) {
1549 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
);
1550 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
);
1551 InputsRead
&= ~FRAG_BIT_COL1
;
1555 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1559 /* We always route 4 texcoord components */
1560 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
1561 if (! ( InputsRead
& FRAG_BIT_TEX(i
) ) )
1564 if (!R300_OUTPUTS_WRITTEN_TEST(OutputsWritten
, VERT_RESULT_TEX0
+ i
, _TNL_ATTRIB_TEX(i
))) {
1565 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i
);
1569 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
+ tex_ip
] |= ((rs_tex_count
+ 0) << R500_RS_IP_TEX_PTR_S_SHIFT
) |
1570 ((rs_tex_count
+ 1) << R500_RS_IP_TEX_PTR_T_SHIFT
) |
1571 ((rs_tex_count
+ 2) << R500_RS_IP_TEX_PTR_R_SHIFT
) |
1572 ((rs_tex_count
+ 3) << R500_RS_IP_TEX_PTR_Q_SHIFT
);
1574 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
);
1575 InputsRead
&= ~(FRAG_BIT_TEX0
<< i
);
1581 /* Setup default color if no color or tex was set */
1582 if (rs_tex_count
== 0 && col_ip
== 0) {
1583 r300
->hw
.rr
.cmd
[R300_RR_INST_0
] = R500_RS_INST_COL_ID(0) | R500_RS_INST_COL_ADDR(0);
1584 r300
->hw
.ri
.cmd
[R300_RI_INTERP_0
] = R500_RS_COL_PTR(0) | R500_RS_COL_FMT(R300_RS_COL_FMT_0001
);
1588 high_rr
= (col_ip
> tex_ip
) ? col_ip
: tex_ip
;
1589 r300
->hw
.rc
.cmd
[1] = (rs_tex_count
<< R300_IT_COUNT_SHIFT
) | (col_ip
<< R300_IC_COUNT_SHIFT
) | R300_HIRES_EN
;
1590 r300
->hw
.rc
.cmd
[2] = 0xC0 | (high_rr
- 1);
1592 r300
->hw
.rr
.cmd
[R300_RR_CMD_0
] = cmdpacket0(r300
->radeon
.radeonScreen
, R500_RS_INST_0
, high_rr
);
1593 r300
->hw
.ri
.cmd
[R300_RI_CMD_0
] = cmdpacket0(r300
->radeon
.radeonScreen
, R500_RS_IP_0
, high_rr
);
1596 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead
);
1599 #define MIN3(a, b, c) ((a) < (b) ? MIN2(a, c) : MIN2(b, c))
1601 void r300VapCntl(r300ContextPtr rmesa
, GLuint input_count
,
1602 GLuint output_count
, GLuint temp_count
)
1608 /* Flush PVS engine before changing PVS_NUM_SLOTS, PVS_NUM_CNTRLS.
1609 * See r500 docs 6.5.2 - done in emit */
1611 /* avoid division by zero */
1612 if (input_count
== 0) input_count
= 1;
1613 if (output_count
== 0) output_count
= 1;
1614 if (temp_count
== 0) temp_count
= 1;
1616 if (rmesa
->radeon
.radeonScreen
->chip_family
>= CHIP_FAMILY_RV515
)
1621 pvs_num_slots
= MIN3(10, vtx_mem_size
/input_count
, vtx_mem_size
/output_count
);
1622 pvs_num_cntrls
= MIN2(6, vtx_mem_size
/temp_count
);
1624 R300_STATECHANGE(rmesa
, vap_cntl
);
1625 if (rmesa
->options
.hw_tcl_enabled
) {
1626 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] =
1627 (pvs_num_slots
<< R300_PVS_NUM_SLOTS_SHIFT
) |
1628 (pvs_num_cntrls
<< R300_PVS_NUM_CNTLRS_SHIFT
) |
1629 (12 << R300_VF_MAX_VTX_NUM_SHIFT
);
1630 if (rmesa
->radeon
.radeonScreen
->chip_family
>= CHIP_FAMILY_RV515
)
1631 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= R500_TCL_STATE_OPTIMIZATION
;
1633 /* not sure about non-tcl */
1634 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] = ((10 << R300_PVS_NUM_SLOTS_SHIFT
) |
1635 (5 << R300_PVS_NUM_CNTLRS_SHIFT
) |
1636 (5 << R300_VF_MAX_VTX_NUM_SHIFT
));
1638 if (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV515
)
1639 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (2 << R300_PVS_NUM_FPUS_SHIFT
);
1640 else if ((rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV530
) ||
1641 (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV560
) ||
1642 (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV570
))
1643 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (5 << R300_PVS_NUM_FPUS_SHIFT
);
1644 else if ((rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_RV410
) ||
1645 (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_R420
))
1646 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (6 << R300_PVS_NUM_FPUS_SHIFT
);
1647 else if ((rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_R520
) ||
1648 (rmesa
->radeon
.radeonScreen
->chip_family
== CHIP_FAMILY_R580
))
1649 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (8 << R300_PVS_NUM_FPUS_SHIFT
);
1651 rmesa
->hw
.vap_cntl
.cmd
[R300_VAP_CNTL_INSTR
] |= (4 << R300_PVS_NUM_FPUS_SHIFT
);
1656 * Enable/Disable states.
1658 * \note Mesa already filters redundant calls to this function.
1660 static void r300Enable(GLcontext
* ctx
, GLenum cap
, GLboolean state
)
1662 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1663 if (RADEON_DEBUG
& RADEON_STATE
)
1664 fprintf(stderr
, "%s( %s = %s )\n", __FUNCTION__
,
1665 _mesa_lookup_enum_by_nr(cap
),
1666 state
? "GL_TRUE" : "GL_FALSE");
1670 r300SetAlphaState(ctx
);
1672 case GL_COLOR_LOGIC_OP
:
1673 r300SetLogicOpState(ctx
);
1674 /* fall-through, because logic op overrides blending */
1676 r300SetBlendState(ctx
);
1678 case GL_CLIP_PLANE0
:
1679 case GL_CLIP_PLANE1
:
1680 case GL_CLIP_PLANE2
:
1681 case GL_CLIP_PLANE3
:
1682 case GL_CLIP_PLANE4
:
1683 case GL_CLIP_PLANE5
:
1684 r300SetClipPlaneState(ctx
, cap
, state
);
1687 r300UpdateCulling(ctx
);
1690 r300SetDepthState(ctx
);
1692 case GL_LINE_SMOOTH
:
1693 if (rmesa
->options
.conformance_mode
)
1694 r300SwitchFallback(ctx
, R300_FALLBACK_LINE_SMOOTH
, ctx
->Line
.SmoothFlag
);
1696 case GL_LINE_STIPPLE
:
1697 if (rmesa
->options
.conformance_mode
)
1698 r300SwitchFallback(ctx
, R300_FALLBACK_LINE_STIPPLE
, ctx
->Line
.StippleFlag
);
1700 case GL_POINT_SMOOTH
:
1701 if (rmesa
->options
.conformance_mode
)
1702 r300SwitchFallback(ctx
, R300_FALLBACK_POINT_SMOOTH
, ctx
->Point
.SmoothFlag
);
1704 case GL_POLYGON_SMOOTH
:
1705 if (rmesa
->options
.conformance_mode
)
1706 r300SwitchFallback(ctx
, R300_FALLBACK_POLYGON_SMOOTH
, ctx
->Polygon
.SmoothFlag
);
1708 case GL_POLYGON_STIPPLE
:
1709 if (rmesa
->options
.conformance_mode
)
1710 r300SwitchFallback(ctx
, R300_FALLBACK_POLYGON_STIPPLE
, ctx
->Polygon
.StippleFlag
);
1712 case GL_POLYGON_OFFSET_POINT
:
1713 case GL_POLYGON_OFFSET_LINE
:
1714 case GL_POLYGON_OFFSET_FILL
:
1715 r300SetPolygonOffsetState(ctx
, state
);
1717 case GL_SCISSOR_TEST
:
1718 radeon_firevertices(&rmesa
->radeon
);
1719 rmesa
->radeon
.state
.scissor
.enabled
= state
;
1720 radeonUpdateScissor( ctx
);
1722 case GL_STENCIL_TEST
:
1723 r300SetStencilState(ctx
, state
);
1731 * Completely recalculates hardware state based on the Mesa state.
1733 static void r300ResetHwState(r300ContextPtr r300
)
1735 GLcontext
*ctx
= r300
->radeon
.glCtx
;
1738 has_tcl
= r300
->options
.hw_tcl_enabled
;
1740 if (RADEON_DEBUG
& RADEON_STATE
)
1741 fprintf(stderr
, "%s\n", __FUNCTION__
);
1743 radeon_firevertices(&r300
->radeon
);
1746 ctx
->Color
.ColorMask
[RCOMP
],
1747 ctx
->Color
.ColorMask
[GCOMP
],
1748 ctx
->Color
.ColorMask
[BCOMP
], ctx
->Color
.ColorMask
[ACOMP
]);
1750 r300Enable(ctx
, GL_DEPTH_TEST
, ctx
->Depth
.Test
);
1751 r300DepthMask(ctx
, ctx
->Depth
.Mask
);
1752 r300DepthFunc(ctx
, ctx
->Depth
.Func
);
1755 r300Enable(ctx
, GL_STENCIL_TEST
, ctx
->Stencil
._Enabled
);
1756 r300StencilMaskSeparate(ctx
, 0, ctx
->Stencil
.WriteMask
[0]);
1757 r300StencilFuncSeparate(ctx
, 0, ctx
->Stencil
.Function
[0],
1758 ctx
->Stencil
.Ref
[0], ctx
->Stencil
.ValueMask
[0]);
1759 r300StencilOpSeparate(ctx
, 0, ctx
->Stencil
.FailFunc
[0],
1760 ctx
->Stencil
.ZFailFunc
[0],
1761 ctx
->Stencil
.ZPassFunc
[0]);
1763 r300UpdateCulling(ctx
);
1765 r300SetBlendState(ctx
);
1766 r300SetLogicOpState(ctx
);
1768 r300AlphaFunc(ctx
, ctx
->Color
.AlphaFunc
, ctx
->Color
.AlphaRef
);
1769 r300Enable(ctx
, GL_ALPHA_TEST
, ctx
->Color
.AlphaEnabled
);
1771 r300
->hw
.vte
.cmd
[1] = R300_VPORT_X_SCALE_ENA
1772 | R300_VPORT_X_OFFSET_ENA
1773 | R300_VPORT_Y_SCALE_ENA
1774 | R300_VPORT_Y_OFFSET_ENA
1775 | R300_VPORT_Z_SCALE_ENA
1776 | R300_VPORT_Z_OFFSET_ENA
| R300_VTX_W0_FMT
;
1777 r300
->hw
.vte
.cmd
[2] = 0x00000008;
1779 r300
->hw
.vap_vf_max_vtx_indx
.cmd
[1] = 0x00FFFFFF;
1780 r300
->hw
.vap_vf_max_vtx_indx
.cmd
[2] = 0x00000000;
1782 #ifdef MESA_LITTLE_ENDIAN
1783 r300
->hw
.vap_cntl_status
.cmd
[1] = R300_VC_NO_SWAP
;
1785 r300
->hw
.vap_cntl_status
.cmd
[1] = R300_VC_32BIT_SWAP
;
1788 /* disable VAP/TCL on non-TCL capable chips */
1790 r300
->hw
.vap_cntl_status
.cmd
[1] |= R300_VAP_TCL_BYPASS
;
1792 r300
->hw
.vap_psc_sgn_norm_cntl
.cmd
[1] = 0xAAAAAAAA;
1794 /* XXX: Other families? */
1796 r300
->hw
.vap_clip_cntl
.cmd
[1] = R300_PS_UCP_MODE_DIST_COP
;
1798 r300
->hw
.vap_clip
.cmd
[1] = r300PackFloat32(1.0); /* X */
1799 r300
->hw
.vap_clip
.cmd
[2] = r300PackFloat32(1.0); /* X */
1800 r300
->hw
.vap_clip
.cmd
[3] = r300PackFloat32(1.0); /* Y */
1801 r300
->hw
.vap_clip
.cmd
[4] = r300PackFloat32(1.0); /* Y */
1803 switch (r300
->radeon
.radeonScreen
->chip_family
) {
1804 case CHIP_FAMILY_R300
:
1805 r300
->hw
.vap_pvs_vtx_timeout_reg
.cmd
[1] = R300_2288_R300
;
1808 r300
->hw
.vap_pvs_vtx_timeout_reg
.cmd
[1] = R300_2288_RV350
;
1813 r300
->hw
.gb_enable
.cmd
[1] = R300_GB_POINT_STUFF_ENABLE
1814 | R300_GB_LINE_STUFF_ENABLE
1815 | R300_GB_TRIANGLE_STUFF_ENABLE
;
1817 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_MSPOS_0
] = 0x66666666;
1818 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_MSPOS_1
] = 0x06666666;
1820 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] =
1821 R300_GB_TILE_ENABLE
| R300_GB_TILE_SIZE_16
/*| R300_GB_SUBPIXEL_1_16*/;
1822 switch (r300
->radeon
.radeonScreen
->num_gb_pipes
) {
1825 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] |=
1826 R300_GB_TILE_PIPE_COUNT_RV300
;
1829 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] |=
1830 R300_GB_TILE_PIPE_COUNT_R300
;
1833 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] |=
1834 R300_GB_TILE_PIPE_COUNT_R420_3P
;
1837 r300
->hw
.gb_misc
.cmd
[R300_GB_MISC_TILE_CONFIG
] |=
1838 R300_GB_TILE_PIPE_COUNT_R420
;
1842 /* XXX: Enable anti-aliasing? */
1843 r300
->hw
.gb_misc2
.cmd
[R300_GB_MISC2_AA_CONFIG
] = GB_AA_CONFIG_AA_DISABLE
;
1844 r300
->hw
.gb_misc2
.cmd
[R300_GB_MISC2_SELECT
] = 0;
1846 r300
->hw
.ga_point_s0
.cmd
[1] = r300PackFloat32(0.0);
1847 r300
->hw
.ga_point_s0
.cmd
[2] = r300PackFloat32(0.0);
1848 r300
->hw
.ga_point_s0
.cmd
[3] = r300PackFloat32(1.0);
1849 r300
->hw
.ga_point_s0
.cmd
[4] = r300PackFloat32(1.0);
1851 r300
->hw
.ga_triangle_stipple
.cmd
[1] = 0x00050005;
1853 r300PointSize(ctx
, 1.0);
1855 r300
->hw
.ga_point_minmax
.cmd
[1] = 0x18000006;
1856 r300
->hw
.ga_point_minmax
.cmd
[2] = 0x00020006;
1857 r300
->hw
.ga_point_minmax
.cmd
[3] = r300PackFloat32(1.0 / 192.0);
1859 r300LineWidth(ctx
, 1.0);
1861 r300
->hw
.ga_line_stipple
.cmd
[1] = 0;
1862 r300
->hw
.ga_line_stipple
.cmd
[2] = r300PackFloat32(0.0);
1863 r300
->hw
.ga_line_stipple
.cmd
[3] = r300PackFloat32(1.0);
1865 r300ShadeModel(ctx
, ctx
->Light
.ShadeModel
);
1867 r300PolygonMode(ctx
, GL_FRONT
, ctx
->Polygon
.FrontMode
);
1868 r300PolygonMode(ctx
, GL_BACK
, ctx
->Polygon
.BackMode
);
1869 r300
->hw
.zbias_cntl
.cmd
[1] = 0x00000000;
1871 r300PolygonOffset(ctx
, ctx
->Polygon
.OffsetFactor
,
1872 ctx
->Polygon
.OffsetUnits
);
1873 r300Enable(ctx
, GL_POLYGON_OFFSET_POINT
, ctx
->Polygon
.OffsetPoint
);
1874 r300Enable(ctx
, GL_POLYGON_OFFSET_LINE
, ctx
->Polygon
.OffsetLine
);
1875 r300Enable(ctx
, GL_POLYGON_OFFSET_FILL
, ctx
->Polygon
.OffsetFill
);
1877 r300
->hw
.su_depth_scale
.cmd
[1] = 0x4B7FFFFF;
1878 r300
->hw
.su_depth_scale
.cmd
[2] = 0x00000000;
1880 r300
->hw
.sc_hyperz
.cmd
[1] = 0x0000001C;
1881 r300
->hw
.sc_hyperz
.cmd
[2] = 0x2DA49525;
1883 r300
->hw
.sc_screendoor
.cmd
[1] = 0x00FFFFFF;
1885 r300
->hw
.us_out_fmt
.cmd
[1] = R500_OUT_FMT_C4_8
|
1886 R500_C0_SEL_B
| R500_C1_SEL_G
| R500_C2_SEL_R
| R500_C3_SEL_A
;
1887 r300
->hw
.us_out_fmt
.cmd
[2] = R500_OUT_FMT_UNUSED
|
1888 R500_C0_SEL_B
| R500_C1_SEL_G
| R500_C2_SEL_R
| R500_C3_SEL_A
;
1889 r300
->hw
.us_out_fmt
.cmd
[3] = R500_OUT_FMT_UNUSED
|
1890 R500_C0_SEL_B
| R500_C1_SEL_G
| R500_C2_SEL_R
| R500_C3_SEL_A
;
1891 r300
->hw
.us_out_fmt
.cmd
[4] = R500_OUT_FMT_UNUSED
|
1892 R500_C0_SEL_B
| R500_C1_SEL_G
| R500_C2_SEL_R
| R500_C3_SEL_A
;
1893 r300
->hw
.us_out_fmt
.cmd
[5] = R300_W_FMT_W0
| R300_W_SRC_US
;
1895 /* disable fog unit */
1896 r300
->hw
.fogs
.cmd
[R300_FOGS_STATE
] = 0;
1897 r300
->hw
.fg_depth_src
.cmd
[1] = R300_FG_DEPTH_SRC_SCAN
;
1899 r300
->hw
.rb3d_cctl
.cmd
[1] = 0;
1901 r300BlendColor(ctx
, ctx
->Color
.BlendColor
);
1903 r300
->hw
.rb3d_dither_ctl
.cmd
[1] = 0;
1904 r300
->hw
.rb3d_dither_ctl
.cmd
[2] = 0;
1905 r300
->hw
.rb3d_dither_ctl
.cmd
[3] = 0;
1906 r300
->hw
.rb3d_dither_ctl
.cmd
[4] = 0;
1907 r300
->hw
.rb3d_dither_ctl
.cmd
[5] = 0;
1908 r300
->hw
.rb3d_dither_ctl
.cmd
[6] = 0;
1909 r300
->hw
.rb3d_dither_ctl
.cmd
[7] = 0;
1910 r300
->hw
.rb3d_dither_ctl
.cmd
[8] = 0;
1911 r300
->hw
.rb3d_dither_ctl
.cmd
[9] = 0;
1913 r300
->hw
.rb3d_aaresolve_ctl
.cmd
[1] = 0;
1915 r300
->hw
.rb3d_discard_src_pixel_lte_threshold
.cmd
[1] = 0x00000000;
1916 r300
->hw
.rb3d_discard_src_pixel_lte_threshold
.cmd
[2] = 0xffffffff;
1918 r300
->hw
.zb_depthclearvalue
.cmd
[1] = 0;
1920 r300
->hw
.zstencil_format
.cmd
[2] = R300_ZTOP_DISABLE
;
1921 r300
->hw
.zstencil_format
.cmd
[3] = 0x00000003;
1922 r300
->hw
.zstencil_format
.cmd
[4] = 0x00000000;
1923 r300SetEarlyZState(ctx
);
1925 r300
->hw
.zb_zmask
.cmd
[1] = 0;
1926 r300
->hw
.zb_zmask
.cmd
[2] = 0;
1928 r300
->hw
.zb_hiz_offset
.cmd
[1] = 0;
1930 r300
->hw
.zb_hiz_pitch
.cmd
[1] = 0;
1932 r300VapCntl(r300
, 0, 0, 0);
1934 r300
->hw
.vps
.cmd
[R300_VPS_ZERO_0
] = 0;
1935 r300
->hw
.vps
.cmd
[R300_VPS_ZERO_1
] = 0;
1936 r300
->hw
.vps
.cmd
[R300_VPS_POINTSIZE
] = r300PackFloat32(1.0);
1937 r300
->hw
.vps
.cmd
[R300_VPS_ZERO_3
] = 0;
1940 r300
->radeon
.hw
.all_dirty
= GL_TRUE
;
1943 void r300UpdateShaders(r300ContextPtr rmesa
)
1945 GLcontext
*ctx
= rmesa
->radeon
.glCtx
;
1947 /* should only happenen once, just after context is created */
1948 /* TODO: shouldn't we fallback to sw here? */
1949 if (!ctx
->FragmentProgram
._Current
) {
1950 _mesa_fprintf(stderr
, "No ctx->FragmentProgram._Current!!\n");
1955 struct r300_fragment_program
*fp
;
1957 fp
= r300SelectAndTranslateFragmentShader(ctx
);
1959 r300SwitchFallback(ctx
, R300_FALLBACK_FRAGMENT_PROGRAM
, fp
->error
);
1962 if (rmesa
->options
.hw_tcl_enabled
) {
1963 struct r300_vertex_program
*vp
;
1965 if (rmesa
->radeon
.NewGLState
) {
1967 for (i
= _TNL_FIRST_MAT
; i
<= _TNL_LAST_MAT
; i
++) {
1968 rmesa
->temp_attrib
[i
] =
1969 TNL_CONTEXT(ctx
)->vb
.AttribPtr
[i
];
1970 TNL_CONTEXT(ctx
)->vb
.AttribPtr
[i
] =
1971 &rmesa
->dummy_attrib
[i
];
1974 _tnl_UpdateFixedFunctionProgram(ctx
);
1976 for (i
= _TNL_FIRST_MAT
; i
<= _TNL_LAST_MAT
; i
++) {
1977 TNL_CONTEXT(ctx
)->vb
.AttribPtr
[i
] =
1978 rmesa
->temp_attrib
[i
];
1982 vp
= r300SelectAndTranslateVertexShader(ctx
);
1984 r300SwitchFallback(ctx
, R300_FALLBACK_VERTEX_PROGRAM
, vp
->error
);
1987 r300UpdateStateParameters(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
1988 rmesa
->radeon
.NewGLState
= 0;
1991 static const GLfloat
*get_fragmentprogram_constant(GLcontext
*ctx
, GLuint index
, GLfloat
* buffer
)
1993 static const GLfloat dummy
[4] = { 0, 0, 0, 0 };
1994 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
1995 struct rc_constant
* rcc
= &rmesa
->selected_fp
->code
.constants
.Constants
[index
];
1998 case RC_CONSTANT_EXTERNAL
:
1999 return ctx
->FragmentProgram
._Current
->Base
.Parameters
->ParameterValues
[rcc
->u
.External
];
2000 case RC_CONSTANT_IMMEDIATE
:
2001 return rcc
->u
.Immediate
;
2002 case RC_CONSTANT_STATE
:
2003 switch(rcc
->u
.State
[0]) {
2004 case RC_STATE_SHADOW_AMBIENT
: {
2005 const int unit
= (int) rcc
->u
.State
[1];
2006 const struct gl_texture_object
*texObj
= ctx
->Texture
.Unit
[unit
]._Current
;
2011 buffer
[3] = texObj
->CompareFailValue
;
2016 case RC_STATE_R300_WINDOW_DIMENSION
: {
2017 __DRIdrawablePrivate
* drawable
= radeon_get_drawable(&rmesa
->radeon
);
2018 buffer
[0] = drawable
->w
* 0.5f
; /* width*0.5 */
2019 buffer
[1] = drawable
->h
* 0.5f
; /* height*0.5 */
2020 buffer
[2] = 0.5F
; /* for moving range [-1 1] -> [0 1] */
2021 buffer
[3] = 1.0F
; /* not used */
2025 case RC_STATE_R300_TEXRECT_FACTOR
: {
2026 struct gl_texture_object
*t
=
2027 ctx
->Texture
.Unit
[rcc
->u
.State
[1]].CurrentTex
[TEXTURE_RECT_INDEX
];
2029 if (t
&& t
->Image
[0][t
->BaseLevel
]) {
2030 struct gl_texture_image
*image
=
2031 t
->Image
[0][t
->BaseLevel
];
2032 buffer
[0] = 1.0 / image
->Width2
;
2033 buffer
[1] = 1.0 / image
->Height2
;
2049 static void r300SetupPixelShader(GLcontext
*ctx
)
2051 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
2052 struct r300_fragment_program
*fp
= rmesa
->selected_fp
;
2053 struct r300_fragment_program_code
*code
;
2056 code
= &fp
->code
.code
.r300
;
2058 R300_STATECHANGE(rmesa
, fpi
[0]);
2059 R300_STATECHANGE(rmesa
, fpi
[1]);
2060 R300_STATECHANGE(rmesa
, fpi
[2]);
2061 R300_STATECHANGE(rmesa
, fpi
[3]);
2062 rmesa
->hw
.fpi
[0].cmd
[R300_FPI_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_US_ALU_RGB_INST_0
, code
->alu
.length
);
2063 rmesa
->hw
.fpi
[1].cmd
[R300_FPI_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_US_ALU_RGB_ADDR_0
, code
->alu
.length
);
2064 rmesa
->hw
.fpi
[2].cmd
[R300_FPI_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_US_ALU_ALPHA_INST_0
, code
->alu
.length
);
2065 rmesa
->hw
.fpi
[3].cmd
[R300_FPI_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_US_ALU_ALPHA_ADDR_0
, code
->alu
.length
);
2066 for (i
= 0; i
< code
->alu
.length
; i
++) {
2067 rmesa
->hw
.fpi
[0].cmd
[R300_FPI_INSTR_0
+ i
] = code
->alu
.inst
[i
].rgb_inst
;
2068 rmesa
->hw
.fpi
[1].cmd
[R300_FPI_INSTR_0
+ i
] = code
->alu
.inst
[i
].rgb_addr
;
2069 rmesa
->hw
.fpi
[2].cmd
[R300_FPI_INSTR_0
+ i
] = code
->alu
.inst
[i
].alpha_inst
;
2070 rmesa
->hw
.fpi
[3].cmd
[R300_FPI_INSTR_0
+ i
] = code
->alu
.inst
[i
].alpha_addr
;
2073 R300_STATECHANGE(rmesa
, fp
);
2074 rmesa
->hw
.fp
.cmd
[R300_FP_CNTL0
] = code
->config
;
2075 rmesa
->hw
.fp
.cmd
[R300_FP_CNTL1
] = code
->pixsize
;
2076 rmesa
->hw
.fp
.cmd
[R300_FP_CNTL2
] = code
->code_offset
;
2077 for (i
= 0; i
< 4; i
++)
2078 rmesa
->hw
.fp
.cmd
[R300_FP_NODE0
+ i
] = code
->code_addr
[i
];
2080 R300_STATECHANGE(rmesa
, fpp
);
2081 rmesa
->hw
.fpp
.cmd
[R300_FPP_CMD_0
] = cmdpacket0(rmesa
->radeon
.radeonScreen
, R300_PFS_PARAM_0_X
, fp
->code
.constants
.Count
* 4);
2082 for (i
= 0; i
< fp
->code
.constants
.Count
; i
++) {
2084 const GLfloat
*constant
= get_fragmentprogram_constant(ctx
, i
, buffer
);
2085 rmesa
->hw
.fpp
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 0] = r300PackFloat24(constant
[0]);
2086 rmesa
->hw
.fpp
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 1] = r300PackFloat24(constant
[1]);
2087 rmesa
->hw
.fpp
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 2] = r300PackFloat24(constant
[2]);
2088 rmesa
->hw
.fpp
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 3] = r300PackFloat24(constant
[3]);
2092 #define bump_r500fp_count(ptr, new_count) do{\
2093 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2094 int _nc=(new_count)/6; \
2095 assert(_nc < 256); \
2096 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2099 #define bump_r500fp_const_count(ptr, new_count) do{\
2100 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2101 int _nc=(new_count)/4; \
2102 assert(_nc < 256); \
2103 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2106 static void r500SetupPixelShader(GLcontext
*ctx
)
2108 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
2109 struct r300_fragment_program
*fp
= rmesa
->selected_fp
;
2111 struct r500_fragment_program_code
*code
;
2113 ((drm_r300_cmd_header_t
*) rmesa
->hw
.r500fp
.cmd
)->r500fp
.count
= 0;
2114 ((drm_r300_cmd_header_t
*) rmesa
->hw
.r500fp_const
.cmd
)->r500fp
.count
= 0;
2116 code
= &fp
->code
.code
.r500
;
2118 R300_STATECHANGE(rmesa
, fp
);
2119 rmesa
->hw
.fp
.cmd
[R500_FP_PIXSIZE
] = code
->max_temp_idx
;
2121 rmesa
->hw
.fp
.cmd
[R500_FP_CODE_ADDR
] =
2122 R500_US_CODE_START_ADDR(0) |
2123 R500_US_CODE_END_ADDR(code
->inst_end
);
2124 rmesa
->hw
.fp
.cmd
[R500_FP_CODE_RANGE
] =
2125 R500_US_CODE_RANGE_ADDR(0) |
2126 R500_US_CODE_RANGE_SIZE(code
->inst_end
);
2127 rmesa
->hw
.fp
.cmd
[R500_FP_CODE_OFFSET
] =
2128 R500_US_CODE_OFFSET_ADDR(0);
2130 R300_STATECHANGE(rmesa
, r500fp
);
2131 /* Emit our shader... */
2132 for (i
= 0; i
< code
->inst_end
+1; i
++) {
2133 rmesa
->hw
.r500fp
.cmd
[i
*6+1] = code
->inst
[i
].inst0
;
2134 rmesa
->hw
.r500fp
.cmd
[i
*6+2] = code
->inst
[i
].inst1
;
2135 rmesa
->hw
.r500fp
.cmd
[i
*6+3] = code
->inst
[i
].inst2
;
2136 rmesa
->hw
.r500fp
.cmd
[i
*6+4] = code
->inst
[i
].inst3
;
2137 rmesa
->hw
.r500fp
.cmd
[i
*6+5] = code
->inst
[i
].inst4
;
2138 rmesa
->hw
.r500fp
.cmd
[i
*6+6] = code
->inst
[i
].inst5
;
2141 bump_r500fp_count(rmesa
->hw
.r500fp
.cmd
, (code
->inst_end
+ 1) * 6);
2143 R300_STATECHANGE(rmesa
, r500fp_const
);
2144 for (i
= 0; i
< fp
->code
.constants
.Count
; i
++) {
2146 const GLfloat
*constant
= get_fragmentprogram_constant(ctx
, i
, buffer
);
2147 rmesa
->hw
.r500fp_const
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 0] = r300PackFloat32(constant
[0]);
2148 rmesa
->hw
.r500fp_const
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 1] = r300PackFloat32(constant
[1]);
2149 rmesa
->hw
.r500fp_const
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 2] = r300PackFloat32(constant
[2]);
2150 rmesa
->hw
.r500fp_const
.cmd
[R300_FPP_PARAM_0
+ 4 * i
+ 3] = r300PackFloat32(constant
[3]);
2152 bump_r500fp_const_count(rmesa
->hw
.r500fp_const
.cmd
, fp
->code
.constants
.Count
* 4);
2155 void r300SetupVAP(GLcontext
*ctx
, GLuint InputsRead
, GLuint OutputsWritten
)
2157 r300ContextPtr rmesa
= R300_CONTEXT( ctx
);
2158 struct vertex_attribute
*attrs
= rmesa
->vbuf
.attribs
;
2159 int i
, j
, reg_count
;
2160 uint32_t *vir0
= &rmesa
->hw
.vir
[0].cmd
[1];
2161 uint32_t *vir1
= &rmesa
->hw
.vir
[1].cmd
[1];
2163 for (i
= 0; i
< R300_VIR_CMDSIZE
-1; ++i
)
2164 vir0
[i
] = vir1
[i
] = 0;
2166 for (i
= 0, j
= 0; i
< rmesa
->vbuf
.num_attribs
; ++i
) {
2169 tmp
= attrs
[i
].data_type
| (attrs
[i
].dst_loc
<< R300_DST_VEC_LOC_SHIFT
);
2170 if (attrs
[i
]._signed
)
2172 if (attrs
[i
].normalize
)
2173 tmp
|= R300_NORMALIZE
;
2176 vir0
[j
] = tmp
<< R300_DATA_TYPE_0_SHIFT
;
2177 vir1
[j
] = attrs
[i
].swizzle
| (attrs
[i
].write_mask
<< R300_WRITE_ENA_SHIFT
);
2179 vir0
[j
] |= tmp
<< R300_DATA_TYPE_1_SHIFT
;
2180 vir1
[j
] |= (attrs
[i
].swizzle
| (attrs
[i
].write_mask
<< R300_WRITE_ENA_SHIFT
)) << R300_SWIZZLE1_SHIFT
;
2185 reg_count
= (rmesa
->vbuf
.num_attribs
+ 1) >> 1;
2186 if (rmesa
->vbuf
.num_attribs
% 2 != 0) {
2187 vir0
[reg_count
-1] |= R300_LAST_VEC
<< R300_DATA_TYPE_0_SHIFT
;
2189 vir0
[reg_count
-1] |= R300_LAST_VEC
<< R300_DATA_TYPE_1_SHIFT
;
2192 R300_STATECHANGE(rmesa
, vir
[0]);
2193 R300_STATECHANGE(rmesa
, vir
[1]);
2194 R300_STATECHANGE(rmesa
, vof
);
2195 R300_STATECHANGE(rmesa
, vic
);
2197 if (rmesa
->radeon
.radeonScreen
->kernel_mm
) {
2198 rmesa
->hw
.vir
[0].cmd
[0] &= 0xC000FFFF;
2199 rmesa
->hw
.vir
[1].cmd
[0] &= 0xC000FFFF;
2200 rmesa
->hw
.vir
[0].cmd
[0] |= (reg_count
& 0x3FFF) << 16;
2201 rmesa
->hw
.vir
[1].cmd
[0] |= (reg_count
& 0x3FFF) << 16;
2203 ((drm_r300_cmd_header_t
*) rmesa
->hw
.vir
[0].cmd
)->packet0
.count
= reg_count
;
2204 ((drm_r300_cmd_header_t
*) rmesa
->hw
.vir
[1].cmd
)->packet0
.count
= reg_count
;
2207 rmesa
->hw
.vic
.cmd
[R300_VIC_CNTL_0
] = r300VAPInputCntl0(ctx
, InputsRead
);
2208 rmesa
->hw
.vic
.cmd
[R300_VIC_CNTL_1
] = r300VAPInputCntl1(ctx
, InputsRead
);
2209 rmesa
->hw
.vof
.cmd
[R300_VOF_CNTL_0
] = r300VAPOutputCntl0(ctx
, OutputsWritten
);
2210 rmesa
->hw
.vof
.cmd
[R300_VOF_CNTL_1
] = r300VAPOutputCntl1(ctx
, OutputsWritten
);
2213 void r300UpdateShaderStates(r300ContextPtr rmesa
)
2216 ctx
= rmesa
->radeon
.glCtx
;
2218 /* should only happenen once, just after context is created */
2219 if (!ctx
->FragmentProgram
._Current
)
2222 r300SetEarlyZState(ctx
);
2224 r300SetupTextures(ctx
);
2226 rmesa
->vtbl
.SetupPixelShader(ctx
);
2228 rmesa
->vtbl
.SetupRSUnit(ctx
);
2230 if (rmesa
->options
.hw_tcl_enabled
) {
2231 r300SetupVertexProgram(rmesa
);
2236 * Called by Mesa after an internal state update.
2238 static void r300InvalidateState(GLcontext
* ctx
, GLuint new_state
)
2240 r300ContextPtr r300
= R300_CONTEXT(ctx
);
2242 _swrast_InvalidateState(ctx
, new_state
);
2243 _swsetup_InvalidateState(ctx
, new_state
);
2244 _vbo_InvalidateState(ctx
, new_state
);
2245 _tnl_InvalidateState(ctx
, new_state
);
2247 if (new_state
& _NEW_BUFFERS
) {
2248 _mesa_update_framebuffer(ctx
);
2249 /* this updates the DrawBuffer's Width/Height if it's a FBO */
2250 _mesa_update_draw_buffer_bounds(ctx
);
2252 R300_STATECHANGE(r300
, cb
);
2253 R300_STATECHANGE(r300
, zb
);
2256 if (new_state
& (_NEW_LIGHT
)) {
2257 R300_STATECHANGE(r300
, shade2
);
2258 if (ctx
->Light
.ProvokingVertex
== GL_LAST_VERTEX_CONVENTION
)
2259 r300
->hw
.shade2
.cmd
[1] |= R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_LAST
;
2261 r300
->hw
.shade2
.cmd
[1] &= ~R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_LAST
;
2264 r300
->radeon
.NewGLState
|= new_state
;
2268 * Calculate initial hardware state and register state functions.
2269 * Assumes that the command buffer and state atoms have been
2270 * initialized already.
2272 void r300InitState(r300ContextPtr r300
)
2274 r300ResetHwState(r300
);
2277 static void r300RenderMode(GLcontext
* ctx
, GLenum mode
)
2279 r300SwitchFallback(ctx
, R300_FALLBACK_RENDER_MODE
, ctx
->RenderMode
!= GL_RENDER
);
2283 * Initialize driver's state callback functions
2285 void r300InitStateFuncs(struct dd_function_table
*functions
)
2288 functions
->UpdateState
= r300InvalidateState
;
2289 functions
->AlphaFunc
= r300AlphaFunc
;
2290 functions
->BlendColor
= r300BlendColor
;
2291 functions
->BlendEquationSeparate
= r300BlendEquationSeparate
;
2292 functions
->BlendFuncSeparate
= r300BlendFuncSeparate
;
2293 functions
->Enable
= r300Enable
;
2294 functions
->ColorMask
= r300ColorMask
;
2295 functions
->DepthFunc
= r300DepthFunc
;
2296 functions
->DepthMask
= r300DepthMask
;
2297 functions
->CullFace
= r300CullFace
;
2298 functions
->FrontFace
= r300FrontFace
;
2299 functions
->ShadeModel
= r300ShadeModel
;
2300 functions
->LogicOpcode
= r300LogicOpcode
;
2302 /* ARB_point_parameters */
2303 functions
->PointParameterfv
= r300PointParameter
;
2305 /* Stencil related */
2306 functions
->StencilFuncSeparate
= r300StencilFuncSeparate
;
2307 functions
->StencilMaskSeparate
= r300StencilMaskSeparate
;
2308 functions
->StencilOpSeparate
= r300StencilOpSeparate
;
2310 /* Viewport related */
2311 functions
->Viewport
= r300Viewport
;
2312 functions
->DepthRange
= r300DepthRange
;
2313 functions
->PointSize
= r300PointSize
;
2314 functions
->LineWidth
= r300LineWidth
;
2316 functions
->PolygonOffset
= r300PolygonOffset
;
2317 functions
->PolygonMode
= r300PolygonMode
;
2319 functions
->RenderMode
= r300RenderMode
;
2321 functions
->ClipPlane
= r300ClipPlane
;
2322 functions
->Scissor
= radeonScissor
;
2324 functions
->DrawBuffer
= radeonDrawBuffer
;
2325 functions
->ReadBuffer
= radeonReadBuffer
;
2328 void r300InitShaderFunctions(r300ContextPtr r300
)
2330 if (r300
->radeon
.radeonScreen
->chip_family
>= CHIP_FAMILY_RV515
) {
2331 r300
->vtbl
.SetupRSUnit
= r500SetupRSUnit
;
2332 r300
->vtbl
.SetupPixelShader
= r500SetupPixelShader
;
2333 r300
->vtbl
.SetupFragmentShaderTextures
= r500SetupFragmentShaderTextures
;
2335 r300
->vtbl
.SetupRSUnit
= r300SetupRSUnit
;
2336 r300
->vtbl
.SetupPixelShader
= r300SetupPixelShader
;
2337 r300
->vtbl
.SetupFragmentShaderTextures
= r300SetupFragmentShaderTextures
;