1 /**************************************************************************
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
29 * \brief Quad depth testing
32 #include "pipe/p_defines.h"
33 #include "util/u_format.h"
34 #include "util/u_memory.h"
35 #include "tgsi/tgsi_scan.h"
36 #include "sp_context.h"
38 #include "sp_quad_pipe.h"
39 #include "sp_tile_cache.h"
40 #include "sp_state.h" /* for sp_fragment_shader */
44 struct pipe_surface
*ps
;
45 enum pipe_format format
;
46 unsigned bzzzz
[QUAD_SIZE
]; /**< Z values fetched from depth buffer */
47 unsigned qzzzz
[QUAD_SIZE
]; /**< Z values from the quad */
48 ubyte stencilVals
[QUAD_SIZE
];
49 struct softpipe_cached_tile
*tile
;
55 get_depth_stencil_values( struct depth_data
*data
,
56 const struct quad_header
*quad
)
59 const struct softpipe_cached_tile
*tile
= data
->tile
;
61 switch (data
->format
) {
62 case PIPE_FORMAT_Z16_UNORM
:
63 for (j
= 0; j
< QUAD_SIZE
; j
++) {
64 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
65 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
66 data
->bzzzz
[j
] = tile
->data
.depth16
[y
][x
];
69 case PIPE_FORMAT_Z32_UNORM
:
70 for (j
= 0; j
< QUAD_SIZE
; j
++) {
71 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
72 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
73 data
->bzzzz
[j
] = tile
->data
.depth32
[y
][x
];
76 case PIPE_FORMAT_Z24X8_UNORM
:
77 case PIPE_FORMAT_Z24S8_UNORM
:
78 for (j
= 0; j
< QUAD_SIZE
; j
++) {
79 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
80 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
81 data
->bzzzz
[j
] = tile
->data
.depth32
[y
][x
] & 0xffffff;
82 data
->stencilVals
[j
] = tile
->data
.depth32
[y
][x
] >> 24;
85 case PIPE_FORMAT_X8Z24_UNORM
:
86 case PIPE_FORMAT_S8Z24_UNORM
:
87 for (j
= 0; j
< QUAD_SIZE
; j
++) {
88 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
89 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
90 data
->bzzzz
[j
] = tile
->data
.depth32
[y
][x
] >> 8;
91 data
->stencilVals
[j
] = tile
->data
.depth32
[y
][x
] & 0xff;
99 /* If the shader has not been run, interpolate the depth values
103 interpolate_quad_depth( struct quad_header
*quad
)
105 const float fx
= (float) quad
->input
.x0
;
106 const float fy
= (float) quad
->input
.y0
;
107 const float dzdx
= quad
->posCoef
->dadx
[2];
108 const float dzdy
= quad
->posCoef
->dady
[2];
109 const float z0
= quad
->posCoef
->a0
[2] + dzdx
* fx
+ dzdy
* fy
;
111 quad
->output
.depth
[0] = z0
;
112 quad
->output
.depth
[1] = z0
+ dzdx
;
113 quad
->output
.depth
[2] = z0
+ dzdy
;
114 quad
->output
.depth
[3] = z0
+ dzdx
+ dzdy
;
119 convert_quad_depth( struct depth_data
*data
,
120 const struct quad_header
*quad
)
124 /* Convert quad's float depth values to int depth values (qzzzz).
125 * If the Z buffer stores integer values, we _have_ to do the depth
126 * compares with integers (not floats). Otherwise, the float->int->float
127 * conversion of Z values (which isn't an identity function) will cause
130 switch (data
->format
) {
131 case PIPE_FORMAT_Z16_UNORM
:
133 float scale
= 65535.0;
135 for (j
= 0; j
< QUAD_SIZE
; j
++) {
136 data
->qzzzz
[j
] = (unsigned) (quad
->output
.depth
[j
] * scale
);
140 case PIPE_FORMAT_Z32_UNORM
:
142 double scale
= (double) (uint
) ~0UL;
144 for (j
= 0; j
< QUAD_SIZE
; j
++) {
145 data
->qzzzz
[j
] = (unsigned) (quad
->output
.depth
[j
] * scale
);
149 case PIPE_FORMAT_Z24X8_UNORM
:
150 case PIPE_FORMAT_Z24S8_UNORM
:
152 float scale
= (float) ((1 << 24) - 1);
154 for (j
= 0; j
< QUAD_SIZE
; j
++) {
155 data
->qzzzz
[j
] = (unsigned) (quad
->output
.depth
[j
] * scale
);
159 case PIPE_FORMAT_X8Z24_UNORM
:
160 case PIPE_FORMAT_S8Z24_UNORM
:
162 float scale
= (float) ((1 << 24) - 1);
164 for (j
= 0; j
< QUAD_SIZE
; j
++) {
165 data
->qzzzz
[j
] = (unsigned) (quad
->output
.depth
[j
] * scale
);
177 write_depth_stencil_values( struct depth_data
*data
,
178 struct quad_header
*quad
)
180 struct softpipe_cached_tile
*tile
= data
->tile
;
183 /* put updated Z values back into cached tile */
184 switch (data
->format
) {
185 case PIPE_FORMAT_Z16_UNORM
:
186 for (j
= 0; j
< QUAD_SIZE
; j
++) {
187 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
188 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
189 tile
->data
.depth16
[y
][x
] = (ushort
) data
->bzzzz
[j
];
192 case PIPE_FORMAT_Z24X8_UNORM
:
193 case PIPE_FORMAT_Z32_UNORM
:
194 for (j
= 0; j
< QUAD_SIZE
; j
++) {
195 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
196 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
197 tile
->data
.depth32
[y
][x
] = data
->bzzzz
[j
];
200 case PIPE_FORMAT_Z24S8_UNORM
:
201 for (j
= 0; j
< QUAD_SIZE
; j
++) {
202 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
203 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
204 tile
->data
.depth32
[y
][x
] = (data
->stencilVals
[j
] << 24) | data
->bzzzz
[j
];
207 case PIPE_FORMAT_S8Z24_UNORM
:
208 for (j
= 0; j
< QUAD_SIZE
; j
++) {
209 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
210 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
211 tile
->data
.depth32
[y
][x
] = (data
->bzzzz
[j
] << 8) | data
->stencilVals
[j
];
214 case PIPE_FORMAT_X8Z24_UNORM
:
215 for (j
= 0; j
< QUAD_SIZE
; j
++) {
216 int x
= quad
->input
.x0
% TILE_SIZE
+ (j
& 1);
217 int y
= quad
->input
.y0
% TILE_SIZE
+ (j
>> 1);
218 tile
->data
.depth32
[y
][x
] = data
->bzzzz
[j
] << 8;
229 /** Only 8-bit stencil supported */
230 #define STENCIL_MAX 0xff
234 * Do the basic stencil test (compare stencil buffer values against the
237 * \param data->stencilVals the stencil values from the stencil buffer
238 * \param func the stencil func (PIPE_FUNC_x)
239 * \param ref the stencil reference value
240 * \param valMask the stencil value mask indicating which bits of the stencil
241 * values and ref value are to be used.
242 * \return mask indicating which pixels passed the stencil test
245 do_stencil_test(struct depth_data
*data
,
247 unsigned ref
, unsigned valMask
)
249 unsigned passMask
= 0x0;
255 case PIPE_FUNC_NEVER
:
259 for (j
= 0; j
< QUAD_SIZE
; j
++) {
260 if (ref
< (data
->stencilVals
[j
] & valMask
)) {
261 passMask
|= (1 << j
);
265 case PIPE_FUNC_EQUAL
:
266 for (j
= 0; j
< QUAD_SIZE
; j
++) {
267 if (ref
== (data
->stencilVals
[j
] & valMask
)) {
268 passMask
|= (1 << j
);
272 case PIPE_FUNC_LEQUAL
:
273 for (j
= 0; j
< QUAD_SIZE
; j
++) {
274 if (ref
<= (data
->stencilVals
[j
] & valMask
)) {
275 passMask
|= (1 << j
);
279 case PIPE_FUNC_GREATER
:
280 for (j
= 0; j
< QUAD_SIZE
; j
++) {
281 if (ref
> (data
->stencilVals
[j
] & valMask
)) {
282 passMask
|= (1 << j
);
286 case PIPE_FUNC_NOTEQUAL
:
287 for (j
= 0; j
< QUAD_SIZE
; j
++) {
288 if (ref
!= (data
->stencilVals
[j
] & valMask
)) {
289 passMask
|= (1 << j
);
293 case PIPE_FUNC_GEQUAL
:
294 for (j
= 0; j
< QUAD_SIZE
; j
++) {
295 if (ref
>= (data
->stencilVals
[j
] & valMask
)) {
296 passMask
|= (1 << j
);
300 case PIPE_FUNC_ALWAYS
:
312 * Apply the stencil operator to stencil values.
314 * \param data->stencilVals the stencil buffer values (read and written)
315 * \param mask indicates which pixels to update
316 * \param op the stencil operator (PIPE_STENCIL_OP_x)
317 * \param ref the stencil reference value
318 * \param wrtMask writemask controlling which bits are changed in the
322 apply_stencil_op(struct depth_data
*data
,
323 unsigned mask
, unsigned op
, ubyte ref
, ubyte wrtMask
)
326 ubyte newstencil
[QUAD_SIZE
];
328 for (j
= 0; j
< QUAD_SIZE
; j
++) {
329 newstencil
[j
] = data
->stencilVals
[j
];
333 case PIPE_STENCIL_OP_KEEP
:
336 case PIPE_STENCIL_OP_ZERO
:
337 for (j
= 0; j
< QUAD_SIZE
; j
++) {
338 if (mask
& (1 << j
)) {
343 case PIPE_STENCIL_OP_REPLACE
:
344 for (j
= 0; j
< QUAD_SIZE
; j
++) {
345 if (mask
& (1 << j
)) {
350 case PIPE_STENCIL_OP_INCR
:
351 for (j
= 0; j
< QUAD_SIZE
; j
++) {
352 if (mask
& (1 << j
)) {
353 if (data
->stencilVals
[j
] < STENCIL_MAX
) {
354 newstencil
[j
] = data
->stencilVals
[j
] + 1;
359 case PIPE_STENCIL_OP_DECR
:
360 for (j
= 0; j
< QUAD_SIZE
; j
++) {
361 if (mask
& (1 << j
)) {
362 if (data
->stencilVals
[j
] > 0) {
363 newstencil
[j
] = data
->stencilVals
[j
] - 1;
368 case PIPE_STENCIL_OP_INCR_WRAP
:
369 for (j
= 0; j
< QUAD_SIZE
; j
++) {
370 if (mask
& (1 << j
)) {
371 newstencil
[j
] = data
->stencilVals
[j
] + 1;
375 case PIPE_STENCIL_OP_DECR_WRAP
:
376 for (j
= 0; j
< QUAD_SIZE
; j
++) {
377 if (mask
& (1 << j
)) {
378 newstencil
[j
] = data
->stencilVals
[j
] - 1;
382 case PIPE_STENCIL_OP_INVERT
:
383 for (j
= 0; j
< QUAD_SIZE
; j
++) {
384 if (mask
& (1 << j
)) {
385 newstencil
[j
] = ~data
->stencilVals
[j
];
394 * update the stencil values
396 if (wrtMask
!= STENCIL_MAX
) {
397 /* apply bit-wise stencil buffer writemask */
398 for (j
= 0; j
< QUAD_SIZE
; j
++) {
399 data
->stencilVals
[j
] = (wrtMask
& newstencil
[j
]) | (~wrtMask
& data
->stencilVals
[j
]);
403 for (j
= 0; j
< QUAD_SIZE
; j
++) {
404 data
->stencilVals
[j
] = newstencil
[j
];
412 * To increase efficiency, we should probably have multiple versions
413 * of this function that are specifically for Z16, Z32 and FP Z buffers.
414 * Try to effectively do that with codegen...
418 depth_test_quad(struct quad_stage
*qs
,
419 struct depth_data
*data
,
420 struct quad_header
*quad
)
422 struct softpipe_context
*softpipe
= qs
->softpipe
;
426 switch (softpipe
->depth_stencil
->depth
.func
) {
427 case PIPE_FUNC_NEVER
:
431 /* Note this is pretty much a single sse or cell instruction.
432 * Like this: quad->mask &= (quad->outputs.depth < zzzz);
434 for (j
= 0; j
< QUAD_SIZE
; j
++) {
435 if (data
->qzzzz
[j
] < data
->bzzzz
[j
])
439 case PIPE_FUNC_EQUAL
:
440 for (j
= 0; j
< QUAD_SIZE
; j
++) {
441 if (data
->qzzzz
[j
] == data
->bzzzz
[j
])
445 case PIPE_FUNC_LEQUAL
:
446 for (j
= 0; j
< QUAD_SIZE
; j
++) {
447 if (data
->qzzzz
[j
] <= data
->bzzzz
[j
])
451 case PIPE_FUNC_GREATER
:
452 for (j
= 0; j
< QUAD_SIZE
; j
++) {
453 if (data
->qzzzz
[j
] > data
->bzzzz
[j
])
457 case PIPE_FUNC_NOTEQUAL
:
458 for (j
= 0; j
< QUAD_SIZE
; j
++) {
459 if (data
->qzzzz
[j
] != data
->bzzzz
[j
])
463 case PIPE_FUNC_GEQUAL
:
464 for (j
= 0; j
< QUAD_SIZE
; j
++) {
465 if (data
->qzzzz
[j
] >= data
->bzzzz
[j
])
469 case PIPE_FUNC_ALWAYS
:
476 quad
->inout
.mask
&= zmask
;
477 if (quad
->inout
.mask
== 0)
480 /* Update our internal copy only if writemask set. Even if
481 * depth.writemask is FALSE, may still need to write out buffer
482 * data due to stencil changes.
484 if (softpipe
->depth_stencil
->depth
.writemask
) {
485 for (j
= 0; j
< QUAD_SIZE
; j
++) {
486 if (quad
->inout
.mask
& (1 << j
)) {
487 data
->bzzzz
[j
] = data
->qzzzz
[j
];
498 * Do stencil (and depth) testing. Stenciling depends on the outcome of
502 depth_stencil_test_quad(struct quad_stage
*qs
,
503 struct depth_data
*data
,
504 struct quad_header
*quad
)
506 struct softpipe_context
*softpipe
= qs
->softpipe
;
507 unsigned func
, zFailOp
, zPassOp
, failOp
;
508 ubyte ref
, wrtMask
, valMask
;
509 uint face
= quad
->input
.facing
;
511 if (!softpipe
->depth_stencil
->stencil
[1].enabled
) {
512 /* single-sided stencil test, use front (face=0) state */
516 /* choose front or back face function, operator, etc */
517 /* XXX we could do these initializations once per primitive */
518 func
= softpipe
->depth_stencil
->stencil
[face
].func
;
519 failOp
= softpipe
->depth_stencil
->stencil
[face
].fail_op
;
520 zFailOp
= softpipe
->depth_stencil
->stencil
[face
].zfail_op
;
521 zPassOp
= softpipe
->depth_stencil
->stencil
[face
].zpass_op
;
522 ref
= softpipe
->stencil_ref
.ref_value
[face
];
523 wrtMask
= softpipe
->depth_stencil
->stencil
[face
].writemask
;
524 valMask
= softpipe
->depth_stencil
->stencil
[face
].valuemask
;
527 /* do the stencil test first */
529 unsigned passMask
, failMask
;
530 passMask
= do_stencil_test(data
, func
, ref
, valMask
);
531 failMask
= quad
->inout
.mask
& ~passMask
;
532 quad
->inout
.mask
&= passMask
;
534 if (failOp
!= PIPE_STENCIL_OP_KEEP
) {
535 apply_stencil_op(data
, failMask
, failOp
, ref
, wrtMask
);
539 if (quad
->inout
.mask
) {
540 /* now the pixels that passed the stencil test are depth tested */
541 if (softpipe
->depth_stencil
->depth
.enabled
) {
542 const unsigned origMask
= quad
->inout
.mask
;
544 depth_test_quad(qs
, data
, quad
); /* quad->mask is updated */
546 /* update stencil buffer values according to z pass/fail result */
547 if (zFailOp
!= PIPE_STENCIL_OP_KEEP
) {
548 const unsigned zFailMask
= origMask
& ~quad
->inout
.mask
;
549 apply_stencil_op(data
, zFailMask
, zFailOp
, ref
, wrtMask
);
552 if (zPassOp
!= PIPE_STENCIL_OP_KEEP
) {
553 const unsigned zPassMask
= origMask
& quad
->inout
.mask
;
554 apply_stencil_op(data
, zPassMask
, zPassOp
, ref
, wrtMask
);
558 /* no depth test, apply Zpass operator to stencil buffer values */
559 apply_stencil_op(data
, quad
->inout
.mask
, zPassOp
, ref
, wrtMask
);
565 #define ALPHATEST( FUNC, COMP ) \
567 alpha_test_quads_##FUNC( struct quad_stage *qs, \
568 struct quad_header *quads[], \
571 const float ref = qs->softpipe->depth_stencil->alpha.ref_value; \
572 const uint cbuf = 0; /* only output[0].alpha is tested */ \
573 unsigned pass_nr = 0; \
576 for (i = 0; i < nr; i++) { \
577 const float *aaaa = quads[i]->output.color[cbuf][3]; \
578 unsigned passMask = 0; \
580 if (aaaa[0] COMP ref) passMask |= (1 << 0); \
581 if (aaaa[1] COMP ref) passMask |= (1 << 1); \
582 if (aaaa[2] COMP ref) passMask |= (1 << 2); \
583 if (aaaa[3] COMP ref) passMask |= (1 << 3); \
585 quads[i]->inout.mask &= passMask; \
587 if (quads[i]->inout.mask) \
588 quads[pass_nr++] = quads[i]; \
596 ALPHATEST( EQUAL
, == )
597 ALPHATEST( LEQUAL
, <= )
598 ALPHATEST( GREATER
, > )
599 ALPHATEST( NOTEQUAL
, != )
600 ALPHATEST( GEQUAL
, >= )
603 /* XXX: Incorporate into shader using KILP.
606 alpha_test_quads(struct quad_stage
*qs
,
607 struct quad_header
*quads
[],
610 switch (qs
->softpipe
->depth_stencil
->alpha
.func
) {
612 return alpha_test_quads_LESS( qs
, quads
, nr
);
613 case PIPE_FUNC_EQUAL
:
614 return alpha_test_quads_EQUAL( qs
, quads
, nr
);
616 case PIPE_FUNC_LEQUAL
:
617 return alpha_test_quads_LEQUAL( qs
, quads
, nr
);
618 case PIPE_FUNC_GREATER
:
619 return alpha_test_quads_GREATER( qs
, quads
, nr
);
620 case PIPE_FUNC_NOTEQUAL
:
621 return alpha_test_quads_NOTEQUAL( qs
, quads
, nr
);
622 case PIPE_FUNC_GEQUAL
:
623 return alpha_test_quads_GEQUAL( qs
, quads
, nr
);
624 case PIPE_FUNC_ALWAYS
:
626 case PIPE_FUNC_NEVER
:
632 static unsigned mask_count
[16] =
654 /** helper to get number of Z buffer bits */
656 get_depth_bits(struct quad_stage
*qs
)
658 struct pipe_surface
*zsurf
= qs
->softpipe
->framebuffer
.zsbuf
;
660 return util_format_get_component_bits(zsurf
->format
,
661 UTIL_FORMAT_COLORSPACE_ZS
, 0);
669 depth_test_quads_fallback(struct quad_stage
*qs
,
670 struct quad_header
*quads
[],
673 unsigned i
, pass
= 0;
674 const struct sp_fragment_shader
*fs
= qs
->softpipe
->fs
;
675 boolean interp_depth
= !fs
->info
.writes_z
;
676 struct depth_data data
;
679 if (qs
->softpipe
->depth_stencil
->alpha
.enabled
) {
680 nr
= alpha_test_quads(qs
, quads
, nr
);
683 if (get_depth_bits(qs
) > 0 &&
684 (qs
->softpipe
->depth_stencil
->depth
.enabled
||
685 qs
->softpipe
->depth_stencil
->stencil
[0].enabled
)) {
687 data
.ps
= qs
->softpipe
->framebuffer
.zsbuf
;
688 data
.format
= data
.ps
->format
;
689 data
.tile
= sp_get_cached_tile(qs
->softpipe
->zsbuf_cache
,
693 for (i
= 0; i
< nr
; i
++) {
694 get_depth_stencil_values(&data
, quads
[i
]);
696 if (qs
->softpipe
->depth_stencil
->depth
.enabled
) {
698 interpolate_quad_depth(quads
[i
]);
700 convert_quad_depth(&data
, quads
[i
]);
703 if (qs
->softpipe
->depth_stencil
->stencil
[0].enabled
) {
704 depth_stencil_test_quad(qs
, &data
, quads
[i
]);
705 write_depth_stencil_values(&data
, quads
[i
]);
708 if (!depth_test_quad(qs
, &data
, quads
[i
]))
711 if (qs
->softpipe
->depth_stencil
->depth
.writemask
)
712 write_depth_stencil_values(&data
, quads
[i
]);
716 quads
[pass
++] = quads
[i
];
722 if (qs
->softpipe
->active_query_count
) {
723 for (i
= 0; i
< nr
; i
++)
724 qs
->softpipe
->occlusion_count
+= mask_count
[quads
[i
]->inout
.mask
];
728 qs
->next
->run(qs
->next
, quads
, nr
);
733 * Special-case Z testing for 16-bit Zbuffer and Z buffer writes enabled.
736 #define NAME depth_interp_z16_less_write
738 #include "sp_quad_depth_test_tmp.h"
740 #define NAME depth_interp_z16_equal_write
742 #include "sp_quad_depth_test_tmp.h"
744 #define NAME depth_interp_z16_lequal_write
746 #include "sp_quad_depth_test_tmp.h"
748 #define NAME depth_interp_z16_greater_write
750 #include "sp_quad_depth_test_tmp.h"
752 #define NAME depth_interp_z16_notequal_write
754 #include "sp_quad_depth_test_tmp.h"
756 #define NAME depth_interp_z16_gequal_write
758 #include "sp_quad_depth_test_tmp.h"
760 #define NAME depth_interp_z16_always_write
762 #include "sp_quad_depth_test_tmp.h"
767 depth_noop(struct quad_stage
*qs
,
768 struct quad_header
*quads
[],
771 qs
->next
->run(qs
->next
, quads
, nr
);
777 choose_depth_test(struct quad_stage
*qs
,
778 struct quad_header
*quads
[],
781 boolean interp_depth
= !qs
->softpipe
->fs
->info
.writes_z
;
783 boolean alpha
= qs
->softpipe
->depth_stencil
->alpha
.enabled
;
785 boolean depth
= (get_depth_bits(qs
) > 0 &&
786 qs
->softpipe
->depth_stencil
->depth
.enabled
);
788 unsigned depthfunc
= qs
->softpipe
->depth_stencil
->depth
.func
;
790 boolean stencil
= qs
->softpipe
->depth_stencil
->stencil
[0].enabled
;
792 boolean depthwrite
= qs
->softpipe
->depth_stencil
->depth
.writemask
;
794 boolean occlusion
= qs
->softpipe
->active_query_count
;
797 qs
->run
= depth_test_quads_fallback
;
799 /* look for special cases */
803 qs
->run
= depth_noop
;
812 if (qs
->softpipe
->framebuffer
.zsbuf
->format
== PIPE_FORMAT_Z16_UNORM
) {
814 case PIPE_FUNC_NEVER
:
815 qs
->run
= depth_test_quads_fallback
;
818 qs
->run
= depth_interp_z16_less_write
;
820 case PIPE_FUNC_EQUAL
:
821 qs
->run
= depth_interp_z16_equal_write
;
823 case PIPE_FUNC_LEQUAL
:
824 qs
->run
= depth_interp_z16_lequal_write
;
826 case PIPE_FUNC_GREATER
:
827 qs
->run
= depth_interp_z16_greater_write
;
829 case PIPE_FUNC_NOTEQUAL
:
830 qs
->run
= depth_interp_z16_notequal_write
;
832 case PIPE_FUNC_GEQUAL
:
833 qs
->run
= depth_interp_z16_gequal_write
;
835 case PIPE_FUNC_ALWAYS
:
836 qs
->run
= depth_interp_z16_always_write
;
839 qs
->run
= depth_test_quads_fallback
;
845 /* next quad/fragment stage */
846 qs
->run( qs
, quads
, nr
);
853 static void depth_test_begin(struct quad_stage
*qs
)
855 qs
->run
= choose_depth_test
;
856 qs
->next
->begin(qs
->next
);
860 static void depth_test_destroy(struct quad_stage
*qs
)
866 struct quad_stage
*sp_quad_depth_test_stage( struct softpipe_context
*softpipe
)
868 struct quad_stage
*stage
= CALLOC_STRUCT(quad_stage
);
870 stage
->softpipe
= softpipe
;
871 stage
->begin
= depth_test_begin
;
872 stage
->run
= choose_depth_test
;
873 stage
->destroy
= depth_test_destroy
;