projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
softpipe: remove the 32bits limitation on depth(-stencil) formats
[mesa.git] / src / gallium / drivers / softpipe / sp_quad_depth_test.c
1 /**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * Copyright 2010 VMware, Inc.
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the
9 * "Software"), to deal in the Software without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sub license, and/or sell copies of the Software, and to
12 * permit persons to whom the Software is furnished to do so, subject to
13 * the following conditions:
14 *
15 * The above copyright notice and this permission notice (including the
16 * next paragraph) shall be included in all copies or substantial portions
17 * of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
22 * IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
24 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
25 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 *
27 **************************************************************************/
28
29 /**
30 * \brief Quad depth / stencil testing
31 */
32
33 #include "pipe/p_defines.h"
34 #include "util/u_format.h"
35 #include "util/u_math.h"
36 #include "util/u_memory.h"
37 #include "tgsi/tgsi_scan.h"
38 #include "sp_context.h"
39 #include "sp_quad.h"
40 #include "sp_quad_pipe.h"
41 #include "sp_tile_cache.h"
42 #include "sp_state.h" /* for sp_fragment_shader */
43
44
45 struct depth_data {
46 struct pipe_surface *ps;
47 enum pipe_format format;
48 unsigned bzzzz[QUAD_SIZE]; /**< Z values fetched from depth buffer */
49 unsigned qzzzz[QUAD_SIZE]; /**< Z values from the quad */
50 ubyte stencilVals[QUAD_SIZE];
51 boolean use_shader_stencil_refs;
52 ubyte shader_stencil_refs[QUAD_SIZE];
53 struct softpipe_cached_tile *tile;
54 };
55
56
57
58 static void
59 get_depth_stencil_values( struct depth_data *data,
60 const struct quad_header *quad )
61 {
62 unsigned j;
63 const struct softpipe_cached_tile *tile = data->tile;
64
65 switch (data->format) {
66 case PIPE_FORMAT_Z16_UNORM:
67 for (j = 0; j < QUAD_SIZE; j++) {
68 int x = quad->input.x0 % TILE_SIZE + (j & 1);
69 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
70 data->bzzzz[j] = tile->data.depth16[y][x];
71 }
72 break;
73 case PIPE_FORMAT_Z32_UNORM:
74 for (j = 0; j < QUAD_SIZE; j++) {
75 int x = quad->input.x0 % TILE_SIZE + (j & 1);
76 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
77 data->bzzzz[j] = tile->data.depth32[y][x];
78 }
79 break;
80 case PIPE_FORMAT_Z24X8_UNORM:
81 case PIPE_FORMAT_Z24_UNORM_S8_UINT:
82 for (j = 0; j < QUAD_SIZE; j++) {
83 int x = quad->input.x0 % TILE_SIZE + (j & 1);
84 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
85 data->bzzzz[j] = tile->data.depth32[y][x] & 0xffffff;
86 data->stencilVals[j] = tile->data.depth32[y][x] >> 24;
87 }
88 break;
89 case PIPE_FORMAT_X8Z24_UNORM:
90 case PIPE_FORMAT_S8_UINT_Z24_UNORM:
91 for (j = 0; j < QUAD_SIZE; j++) {
92 int x = quad->input.x0 % TILE_SIZE + (j & 1);
93 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
94 data->bzzzz[j] = tile->data.depth32[y][x] >> 8;
95 data->stencilVals[j] = tile->data.depth32[y][x] & 0xff;
96 }
97 break;
98 case PIPE_FORMAT_S8_UINT:
99 for (j = 0; j < QUAD_SIZE; j++) {
100 int x = quad->input.x0 % TILE_SIZE + (j & 1);
101 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
102 data->bzzzz[j] = 0;
103 data->stencilVals[j] = tile->data.stencil8[y][x];
104 }
105 break;
106 case PIPE_FORMAT_Z32_FLOAT:
107 for (j = 0; j < QUAD_SIZE; j++) {
108 int x = quad->input.x0 % TILE_SIZE + (j & 1);
109 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
110 data->bzzzz[j] = tile->data.depth32[y][x];
111 }
112 break;
113 case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
114 for (j = 0; j < QUAD_SIZE; j++) {
115 int x = quad->input.x0 % TILE_SIZE + (j & 1);
116 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
117 data->bzzzz[j] = tile->data.depth64[y][x] & 0xffffffff;
118 data->stencilVals[j] = (tile->data.depth64[y][x] >> 32) & 0xff;
119 }
120 break;
121 default:
122 assert(0);
123 }
124 }
125
126
127 /**
128 * If the shader has not been run, interpolate the depth values
129 * ourselves.
130 */
131 static void
132 interpolate_quad_depth( struct quad_header *quad )
133 {
134 const float fx = (float) quad->input.x0;
135 const float fy = (float) quad->input.y0;
136 const float dzdx = quad->posCoef->dadx[2];
137 const float dzdy = quad->posCoef->dady[2];
138 const float z0 = quad->posCoef->a0[2] + dzdx * fx + dzdy * fy;
139
140 quad->output.depth[0] = z0;
141 quad->output.depth[1] = z0 + dzdx;
142 quad->output.depth[2] = z0 + dzdy;
143 quad->output.depth[3] = z0 + dzdx + dzdy;
144 }
145
146
147 /**
148 * Compute the depth_data::qzzzz[] values from the float fragment Z values.
149 */
150 static void
151 convert_quad_depth( struct depth_data *data,
152 const struct quad_header *quad )
153 {
154 unsigned j;
155
156 /* Convert quad's float depth values to int depth values (qzzzz).
157 * If the Z buffer stores integer values, we _have_ to do the depth
158 * compares with integers (not floats). Otherwise, the float->int->float
159 * conversion of Z values (which isn't an identity function) will cause
160 * Z-fighting errors.
161 */
162 switch (data->format) {
163 case PIPE_FORMAT_Z16_UNORM:
164 {
165 float scale = 65535.0;
166
167 for (j = 0; j < QUAD_SIZE; j++) {
168 data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
169 }
170 }
171 break;
172 case PIPE_FORMAT_Z32_UNORM:
173 {
174 double scale = (double) (uint) ~0UL;
175
176 for (j = 0; j < QUAD_SIZE; j++) {
177 data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
178 }
179 }
180 break;
181 case PIPE_FORMAT_Z24X8_UNORM:
182 case PIPE_FORMAT_Z24_UNORM_S8_UINT:
183 {
184 float scale = (float) ((1 << 24) - 1);
185
186 for (j = 0; j < QUAD_SIZE; j++) {
187 data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
188 }
189 }
190 break;
191 case PIPE_FORMAT_X8Z24_UNORM:
192 case PIPE_FORMAT_S8_UINT_Z24_UNORM:
193 {
194 float scale = (float) ((1 << 24) - 1);
195
196 for (j = 0; j < QUAD_SIZE; j++) {
197 data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
198 }
199 }
200 break;
201 case PIPE_FORMAT_Z32_FLOAT:
202 case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
203 {
204 union fi fui;
205
206 for (j = 0; j < QUAD_SIZE; j++) {
207 fui.f = quad->output.depth[j];
208 data->qzzzz[j] = fui.ui;
209 }
210 }
211 break;
212 default:
213 assert(0);
214 }
215 }
216
217
218 /**
219 * Compute the depth_data::shader_stencil_refs[] values from the float
220 * fragment stencil values.
221 */
222 static void
223 convert_quad_stencil( struct depth_data *data,
224 const struct quad_header *quad )
225 {
226 unsigned j;
227
228 data->use_shader_stencil_refs = TRUE;
229 /* Copy quads stencil values
230 */
231 switch (data->format) {
232 case PIPE_FORMAT_Z24X8_UNORM:
233 case PIPE_FORMAT_Z24_UNORM_S8_UINT:
234 case PIPE_FORMAT_X8Z24_UNORM:
235 case PIPE_FORMAT_S8_UINT_Z24_UNORM:
236 case PIPE_FORMAT_S8_UINT:
237 case PIPE_FORMAT_Z32_FLOAT:
238 case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
239 for (j = 0; j < QUAD_SIZE; j++) {
240 data->shader_stencil_refs[j] = ((unsigned)(quad->output.stencil[j]));
241 }
242 break;
243 default:
244 assert(0);
245 }
246 }
247
248
249 /**
250 * Write data->bzzzz[] values and data->stencilVals into the Z/stencil buffer.
251 */
252 static void
253 write_depth_stencil_values( struct depth_data *data,
254 struct quad_header *quad )
255 {
256 struct softpipe_cached_tile *tile = data->tile;
257 unsigned j;
258
259 /* put updated Z values back into cached tile */
260 switch (data->format) {
261 case PIPE_FORMAT_Z16_UNORM:
262 for (j = 0; j < QUAD_SIZE; j++) {
263 int x = quad->input.x0 % TILE_SIZE + (j & 1);
264 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
265 tile->data.depth16[y][x] = (ushort) data->bzzzz[j];
266 }
267 break;
268 case PIPE_FORMAT_Z24X8_UNORM:
269 case PIPE_FORMAT_Z32_UNORM:
270 for (j = 0; j < QUAD_SIZE; j++) {
271 int x = quad->input.x0 % TILE_SIZE + (j & 1);
272 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
273 tile->data.depth32[y][x] = data->bzzzz[j];
274 }
275 break;
276 case PIPE_FORMAT_Z24_UNORM_S8_UINT:
277 for (j = 0; j < QUAD_SIZE; j++) {
278 int x = quad->input.x0 % TILE_SIZE + (j & 1);
279 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
280 tile->data.depth32[y][x] = (data->stencilVals[j] << 24) | data->bzzzz[j];
281 }
282 break;
283 case PIPE_FORMAT_S8_UINT_Z24_UNORM:
284 for (j = 0; j < QUAD_SIZE; j++) {
285 int x = quad->input.x0 % TILE_SIZE + (j & 1);
286 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
287 tile->data.depth32[y][x] = (data->bzzzz[j] << 8) | data->stencilVals[j];
288 }
289 break;
290 case PIPE_FORMAT_X8Z24_UNORM:
291 for (j = 0; j < QUAD_SIZE; j++) {
292 int x = quad->input.x0 % TILE_SIZE + (j & 1);
293 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
294 tile->data.depth32[y][x] = data->bzzzz[j] << 8;
295 }
296 break;
297 case PIPE_FORMAT_S8_UINT:
298 for (j = 0; j < QUAD_SIZE; j++) {
299 int x = quad->input.x0 % TILE_SIZE + (j & 1);
300 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
301 tile->data.stencil8[y][x] = data->stencilVals[j];
302 }
303 break;
304 case PIPE_FORMAT_Z32_FLOAT:
305 for (j = 0; j < QUAD_SIZE; j++) {
306 int x = quad->input.x0 % TILE_SIZE + (j & 1);
307 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
308 tile->data.depth32[y][x] = data->bzzzz[j];
309 }
310 break;
311 case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
312 for (j = 0; j < QUAD_SIZE; j++) {
313 int x = quad->input.x0 % TILE_SIZE + (j & 1);
314 int y = quad->input.y0 % TILE_SIZE + (j >> 1);
315 tile->data.depth64[y][x] = (uint64_t)data->bzzzz[j] | ((uint64_t)data->stencilVals[j] << 32);
316 }
317 break;
318 default:
319 assert(0);
320 }
321 }
322
323
324
325 /** Only 8-bit stencil supported */
326 #define STENCIL_MAX 0xff
327
328
329 /**
330 * Do the basic stencil test (compare stencil buffer values against the
331 * reference value.
332 *
333 * \param data->stencilVals the stencil values from the stencil buffer
334 * \param func the stencil func (PIPE_FUNC_x)
335 * \param ref the stencil reference value
336 * \param valMask the stencil value mask indicating which bits of the stencil
337 * values and ref value are to be used.
338 * \return mask indicating which pixels passed the stencil test
339 */
340 static unsigned
341 do_stencil_test(struct depth_data *data,
342 unsigned func,
343 unsigned ref, unsigned valMask)
344 {
345 unsigned passMask = 0x0;
346 unsigned j;
347 ubyte refs[QUAD_SIZE];
348
349 for (j = 0; j < QUAD_SIZE; j++) {
350 if (data->use_shader_stencil_refs)
351 refs[j] = data->shader_stencil_refs[j] & valMask;
352 else
353 refs[j] = ref & valMask;
354 }
355
356 switch (func) {
357 case PIPE_FUNC_NEVER:
358 /* passMask = 0x0 */
359 break;
360 case PIPE_FUNC_LESS:
361 for (j = 0; j < QUAD_SIZE; j++) {
362 if (refs[j] < (data->stencilVals[j] & valMask)) {
363 passMask |= (1 << j);
364 }
365 }
366 break;
367 case PIPE_FUNC_EQUAL:
368 for (j = 0; j < QUAD_SIZE; j++) {
369 if (refs[j] == (data->stencilVals[j] & valMask)) {
370 passMask |= (1 << j);
371 }
372 }
373 break;
374 case PIPE_FUNC_LEQUAL:
375 for (j = 0; j < QUAD_SIZE; j++) {
376 if (refs[j] <= (data->stencilVals[j] & valMask)) {
377 passMask |= (1 << j);
378 }
379 }
380 break;
381 case PIPE_FUNC_GREATER:
382 for (j = 0; j < QUAD_SIZE; j++) {
383 if (refs[j] > (data->stencilVals[j] & valMask)) {
384 passMask |= (1 << j);
385 }
386 }
387 break;
388 case PIPE_FUNC_NOTEQUAL:
389 for (j = 0; j < QUAD_SIZE; j++) {
390 if (refs[j] != (data->stencilVals[j] & valMask)) {
391 passMask |= (1 << j);
392 }
393 }
394 break;
395 case PIPE_FUNC_GEQUAL:
396 for (j = 0; j < QUAD_SIZE; j++) {
397 if (refs[j] >= (data->stencilVals[j] & valMask)) {
398 passMask |= (1 << j);
399 }
400 }
401 break;
402 case PIPE_FUNC_ALWAYS:
403 passMask = MASK_ALL;
404 break;
405 default:
406 assert(0);
407 }
408
409 return passMask;
410 }
411
412
413 /**
414 * Apply the stencil operator to stencil values.
415 *
416 * \param data->stencilVals the stencil buffer values (read and written)
417 * \param mask indicates which pixels to update
418 * \param op the stencil operator (PIPE_STENCIL_OP_x)
419 * \param ref the stencil reference value
420 * \param wrtMask writemask controlling which bits are changed in the
421 * stencil values
422 */
423 static void
424 apply_stencil_op(struct depth_data *data,
425 unsigned mask, unsigned op, ubyte ref, ubyte wrtMask)
426 {
427 unsigned j;
428 ubyte newstencil[QUAD_SIZE];
429 ubyte refs[QUAD_SIZE];
430
431 for (j = 0; j < QUAD_SIZE; j++) {
432 newstencil[j] = data->stencilVals[j];
433 if (data->use_shader_stencil_refs)
434 refs[j] = data->shader_stencil_refs[j];
435 else
436 refs[j] = ref;
437 }
438
439 switch (op) {
440 case PIPE_STENCIL_OP_KEEP:
441 /* no-op */
442 break;
443 case PIPE_STENCIL_OP_ZERO:
444 for (j = 0; j < QUAD_SIZE; j++) {
445 if (mask & (1 << j)) {
446 newstencil[j] = 0;
447 }
448 }
449 break;
450 case PIPE_STENCIL_OP_REPLACE:
451 for (j = 0; j < QUAD_SIZE; j++) {
452 if (mask & (1 << j)) {
453 newstencil[j] = refs[j];
454 }
455 }
456 break;
457 case PIPE_STENCIL_OP_INCR:
458 for (j = 0; j < QUAD_SIZE; j++) {
459 if (mask & (1 << j)) {
460 if (data->stencilVals[j] < STENCIL_MAX) {
461 newstencil[j] = data->stencilVals[j] + 1;
462 }
463 }
464 }
465 break;
466 case PIPE_STENCIL_OP_DECR:
467 for (j = 0; j < QUAD_SIZE; j++) {
468 if (mask & (1 << j)) {
469 if (data->stencilVals[j] > 0) {
470 newstencil[j] = data->stencilVals[j] - 1;
471 }
472 }
473 }
474 break;
475 case PIPE_STENCIL_OP_INCR_WRAP:
476 for (j = 0; j < QUAD_SIZE; j++) {
477 if (mask & (1 << j)) {
478 newstencil[j] = data->stencilVals[j] + 1;
479 }
480 }
481 break;
482 case PIPE_STENCIL_OP_DECR_WRAP:
483 for (j = 0; j < QUAD_SIZE; j++) {
484 if (mask & (1 << j)) {
485 newstencil[j] = data->stencilVals[j] - 1;
486 }
487 }
488 break;
489 case PIPE_STENCIL_OP_INVERT:
490 for (j = 0; j < QUAD_SIZE; j++) {
491 if (mask & (1 << j)) {
492 newstencil[j] = ~data->stencilVals[j];
493 }
494 }
495 break;
496 default:
497 assert(0);
498 }
499
500 /*
501 * update the stencil values
502 */
503 if (wrtMask != STENCIL_MAX) {
504 /* apply bit-wise stencil buffer writemask */
505 for (j = 0; j < QUAD_SIZE; j++) {
506 data->stencilVals[j] = (wrtMask & newstencil[j]) | (~wrtMask & data->stencilVals[j]);
507 }
508 }
509 else {
510 for (j = 0; j < QUAD_SIZE; j++) {
511 data->stencilVals[j] = newstencil[j];
512 }
513 }
514 }
515
516
517
518 /**
519 * To increase efficiency, we should probably have multiple versions
520 * of this function that are specifically for Z16, Z32 and FP Z buffers.
521 * Try to effectively do that with codegen...
522 */
523 static boolean
524 depth_test_quad(struct quad_stage *qs,
525 struct depth_data *data,
526 struct quad_header *quad)
527 {
528 struct softpipe_context *softpipe = qs->softpipe;
529 unsigned zmask = 0;
530 unsigned j;
531
532 switch (softpipe->depth_stencil->depth.func) {
533 case PIPE_FUNC_NEVER:
534 /* zmask = 0 */
535 break;
536 case PIPE_FUNC_LESS:
537 /* Note this is pretty much a single sse or cell instruction.
538 * Like this: quad->mask &= (quad->outputs.depth < zzzz);
539 */
540 for (j = 0; j < QUAD_SIZE; j++) {
541 if (data->qzzzz[j] < data->bzzzz[j])
542 zmask |= 1 << j;
543 }
544 break;
545 case PIPE_FUNC_EQUAL:
546 for (j = 0; j < QUAD_SIZE; j++) {
547 if (data->qzzzz[j] == data->bzzzz[j])
548 zmask |= 1 << j;
549 }
550 break;
551 case PIPE_FUNC_LEQUAL:
552 for (j = 0; j < QUAD_SIZE; j++) {
553 if (data->qzzzz[j] <= data->bzzzz[j])
554 zmask |= (1 << j);
555 }
556 break;
557 case PIPE_FUNC_GREATER:
558 for (j = 0; j < QUAD_SIZE; j++) {
559 if (data->qzzzz[j] > data->bzzzz[j])
560 zmask |= (1 << j);
561 }
562 break;
563 case PIPE_FUNC_NOTEQUAL:
564 for (j = 0; j < QUAD_SIZE; j++) {
565 if (data->qzzzz[j] != data->bzzzz[j])
566 zmask |= (1 << j);
567 }
568 break;
569 case PIPE_FUNC_GEQUAL:
570 for (j = 0; j < QUAD_SIZE; j++) {
571 if (data->qzzzz[j] >= data->bzzzz[j])
572 zmask |= (1 << j);
573 }
574 break;
575 case PIPE_FUNC_ALWAYS:
576 zmask = MASK_ALL;
577 break;
578 default:
579 assert(0);
580 }
581
582 quad->inout.mask &= zmask;
583 if (quad->inout.mask == 0)
584 return FALSE;
585
586 /* Update our internal copy only if writemask set. Even if
587 * depth.writemask is FALSE, may still need to write out buffer
588 * data due to stencil changes.
589 */
590 if (softpipe->depth_stencil->depth.writemask) {
591 for (j = 0; j < QUAD_SIZE; j++) {
592 if (quad->inout.mask & (1 << j)) {
593 data->bzzzz[j] = data->qzzzz[j];
594 }
595 }
596 }
597
598 return TRUE;
599 }
600
601
602
603 /**
604 * Do stencil (and depth) testing. Stenciling depends on the outcome of
605 * depth testing.
606 */
607 static void
608 depth_stencil_test_quad(struct quad_stage *qs,
609 struct depth_data *data,
610 struct quad_header *quad)
611 {
612 struct softpipe_context *softpipe = qs->softpipe;
613 unsigned func, zFailOp, zPassOp, failOp;
614 ubyte ref, wrtMask, valMask;
615 uint face = quad->input.facing;
616
617 if (!softpipe->depth_stencil->stencil[1].enabled) {
618 /* single-sided stencil test, use front (face=0) state */
619 face = 0;
620 }
621
622 /* 0 = front-face, 1 = back-face */
623 assert(face == 0 || face == 1);
624
625 /* choose front or back face function, operator, etc */
626 /* XXX we could do these initializations once per primitive */
627 func = softpipe->depth_stencil->stencil[face].func;
628 failOp = softpipe->depth_stencil->stencil[face].fail_op;
629 zFailOp = softpipe->depth_stencil->stencil[face].zfail_op;
630 zPassOp = softpipe->depth_stencil->stencil[face].zpass_op;
631 ref = softpipe->stencil_ref.ref_value[face];
632 wrtMask = softpipe->depth_stencil->stencil[face].writemask;
633 valMask = softpipe->depth_stencil->stencil[face].valuemask;
634
635 /* do the stencil test first */
636 {
637 unsigned passMask, failMask;
638 passMask = do_stencil_test(data, func, ref, valMask);
639 failMask = quad->inout.mask & ~passMask;
640 quad->inout.mask &= passMask;
641
642 if (failOp != PIPE_STENCIL_OP_KEEP) {
643 apply_stencil_op(data, failMask, failOp, ref, wrtMask);
644 }
645 }
646
647 if (quad->inout.mask) {
648 /* now the pixels that passed the stencil test are depth tested */
649 if (softpipe->depth_stencil->depth.enabled) {
650 const unsigned origMask = quad->inout.mask;
651
652 depth_test_quad(qs, data, quad); /* quad->mask is updated */
653
654 /* update stencil buffer values according to z pass/fail result */
655 if (zFailOp != PIPE_STENCIL_OP_KEEP) {
656 const unsigned zFailMask = origMask & ~quad->inout.mask;
657 apply_stencil_op(data, zFailMask, zFailOp, ref, wrtMask);
658 }
659
660 if (zPassOp != PIPE_STENCIL_OP_KEEP) {
661 const unsigned zPassMask = origMask & quad->inout.mask;
662 apply_stencil_op(data, zPassMask, zPassOp, ref, wrtMask);
663 }
664 }
665 else {
666 /* no depth test, apply Zpass operator to stencil buffer values */
667 apply_stencil_op(data, quad->inout.mask, zPassOp, ref, wrtMask);
668 }
669 }
670 }
671
672
673 #define ALPHATEST( FUNC, COMP ) \
674 static unsigned \
675 alpha_test_quads_##FUNC( struct quad_stage *qs, \
676 struct quad_header *quads[], \
677 unsigned nr ) \
678 { \
679 const float ref = qs->softpipe->depth_stencil->alpha.ref_value; \
680 const uint cbuf = 0; /* only output[0].alpha is tested */ \
681 unsigned pass_nr = 0; \
682 unsigned i; \
683 \
684 for (i = 0; i < nr; i++) { \
685 const float *aaaa = quads[i]->output.color[cbuf][3]; \
686 unsigned passMask = 0; \
687 \
688 if (aaaa[0] COMP ref) passMask |= (1 << 0); \
689 if (aaaa[1] COMP ref) passMask |= (1 << 1); \
690 if (aaaa[2] COMP ref) passMask |= (1 << 2); \
691 if (aaaa[3] COMP ref) passMask |= (1 << 3); \
692 \
693 quads[i]->inout.mask &= passMask; \
694 \
695 if (quads[i]->inout.mask) \
696 quads[pass_nr++] = quads[i]; \
697 } \
698 \
699 return pass_nr; \
700 }
701
702
703 ALPHATEST( LESS, < )
704 ALPHATEST( EQUAL, == )
705 ALPHATEST( LEQUAL, <= )
706 ALPHATEST( GREATER, > )
707 ALPHATEST( NOTEQUAL, != )
708 ALPHATEST( GEQUAL, >= )
709
710
711 /* XXX: Incorporate into shader using KILP.
712 */
713 static unsigned
714 alpha_test_quads(struct quad_stage *qs,
715 struct quad_header *quads[],
716 unsigned nr)
717 {
718 switch (qs->softpipe->depth_stencil->alpha.func) {
719 case PIPE_FUNC_LESS:
720 return alpha_test_quads_LESS( qs, quads, nr );
721 case PIPE_FUNC_EQUAL:
722 return alpha_test_quads_EQUAL( qs, quads, nr );
723 case PIPE_FUNC_LEQUAL:
724 return alpha_test_quads_LEQUAL( qs, quads, nr );
725 case PIPE_FUNC_GREATER:
726 return alpha_test_quads_GREATER( qs, quads, nr );
727 case PIPE_FUNC_NOTEQUAL:
728 return alpha_test_quads_NOTEQUAL( qs, quads, nr );
729 case PIPE_FUNC_GEQUAL:
730 return alpha_test_quads_GEQUAL( qs, quads, nr );
731 case PIPE_FUNC_ALWAYS:
732 return nr;
733 case PIPE_FUNC_NEVER:
734 default:
735 return 0;
736 }
737 }
738
739
740 static unsigned mask_count[16] =
741 {
742 0, /* 0x0 */
743 1, /* 0x1 */
744 1, /* 0x2 */
745 2, /* 0x3 */
746 1, /* 0x4 */
747 2, /* 0x5 */
748 2, /* 0x6 */
749 3, /* 0x7 */
750 1, /* 0x8 */
751 2, /* 0x9 */
752 2, /* 0xa */
753 3, /* 0xb */
754 2, /* 0xc */
755 3, /* 0xd */
756 3, /* 0xe */
757 4, /* 0xf */
758 };
759
760
761
762 /**
763 * General depth/stencil test function. Used when there's no fast-path.
764 */
765 static void
766 depth_test_quads_fallback(struct quad_stage *qs,
767 struct quad_header *quads[],
768 unsigned nr)
769 {
770 unsigned i, pass = 0;
771 const struct tgsi_shader_info *fsInfo = &qs->softpipe->fs_variant->info;
772 boolean interp_depth = !fsInfo->writes_z;
773 boolean shader_stencil_ref = fsInfo->writes_stencil;
774 struct depth_data data;
775
776 data.use_shader_stencil_refs = FALSE;
777
778 if (qs->softpipe->depth_stencil->alpha.enabled) {
779 nr = alpha_test_quads(qs, quads, nr);
780 }
781
782 if (qs->softpipe->framebuffer.zsbuf &&
783 (qs->softpipe->depth_stencil->depth.enabled ||
784 qs->softpipe->depth_stencil->stencil[0].enabled)) {
785
786 data.ps = qs->softpipe->framebuffer.zsbuf;
787 data.format = data.ps->format;
788 data.tile = sp_get_cached_tile(qs->softpipe->zsbuf_cache,
789 quads[0]->input.x0,
790 quads[0]->input.y0);
791
792 for (i = 0; i < nr; i++) {
793 get_depth_stencil_values(&data, quads[i]);
794
795 if (qs->softpipe->depth_stencil->depth.enabled) {
796 if (interp_depth)
797 interpolate_quad_depth(quads[i]);
798
799 convert_quad_depth(&data, quads[i]);
800 }
801
802 if (qs->softpipe->depth_stencil->stencil[0].enabled) {
803 if (shader_stencil_ref)
804 convert_quad_stencil(&data, quads[i]);
805
806 depth_stencil_test_quad(qs, &data, quads[i]);
807 write_depth_stencil_values(&data, quads[i]);
808 }
809 else {
810 if (!depth_test_quad(qs, &data, quads[i]))
811 continue;
812
813 if (qs->softpipe->depth_stencil->depth.writemask)
814 write_depth_stencil_values(&data, quads[i]);
815 }
816
817 quads[pass++] = quads[i];
818 }
819
820 nr = pass;
821 }
822
823 if (qs->softpipe->active_query_count) {
824 for (i = 0; i < nr; i++)
825 qs->softpipe->occlusion_count += mask_count[quads[i]->inout.mask];
826 }
827
828 if (nr)
829 qs->next->run(qs->next, quads, nr);
830 }
831
832
833 /**
834 * Special-case Z testing for 16-bit Zbuffer and Z buffer writes enabled.
835 */
836
837 #define NAME depth_interp_z16_less_write
838 #define OPERATOR <
839 #include "sp_quad_depth_test_tmp.h"
840
841 #define NAME depth_interp_z16_equal_write
842 #define OPERATOR ==
843 #include "sp_quad_depth_test_tmp.h"
844
845 #define NAME depth_interp_z16_lequal_write
846 #define OPERATOR <=
847 #include "sp_quad_depth_test_tmp.h"
848
849 #define NAME depth_interp_z16_greater_write
850 #define OPERATOR >
851 #include "sp_quad_depth_test_tmp.h"
852
853 #define NAME depth_interp_z16_notequal_write
854 #define OPERATOR !=
855 #include "sp_quad_depth_test_tmp.h"
856
857 #define NAME depth_interp_z16_gequal_write
858 #define OPERATOR >=
859 #include "sp_quad_depth_test_tmp.h"
860
861 #define NAME depth_interp_z16_always_write
862 #define ALWAYS 1
863 #include "sp_quad_depth_test_tmp.h"
864
865
866
867 static void
868 depth_noop(struct quad_stage *qs,
869 struct quad_header *quads[],
870 unsigned nr)
871 {
872 qs->next->run(qs->next, quads, nr);
873 }
874
875
876
877 static void
878 choose_depth_test(struct quad_stage *qs,
879 struct quad_header *quads[],
880 unsigned nr)
881 {
882 const struct tgsi_shader_info *fsInfo = &qs->softpipe->fs_variant->info;
883
884 boolean interp_depth = !fsInfo->writes_z;
885
886 boolean alpha = qs->softpipe->depth_stencil->alpha.enabled;
887
888 boolean depth = qs->softpipe->depth_stencil->depth.enabled;
889
890 unsigned depthfunc = qs->softpipe->depth_stencil->depth.func;
891
892 boolean stencil = qs->softpipe->depth_stencil->stencil[0].enabled;
893
894 boolean depthwrite = qs->softpipe->depth_stencil->depth.writemask;
895
896 boolean occlusion = qs->softpipe->active_query_count;
897
898 if(!qs->softpipe->framebuffer.zsbuf)
899 depth = depthwrite = stencil = FALSE;
900
901 /* default */
902 qs->run = depth_test_quads_fallback;
903
904 /* look for special cases */
905 if (!alpha &&
906 !depth &&
907 !occlusion &&
908 !stencil) {
909 qs->run = depth_noop;
910 }
911 else if (!alpha &&
912 interp_depth &&
913 depth &&
914 depthwrite &&
915 !occlusion &&
916 !stencil)
917 {
918 if (qs->softpipe->framebuffer.zsbuf->format == PIPE_FORMAT_Z16_UNORM) {
919 switch (depthfunc) {
920 case PIPE_FUNC_NEVER:
921 qs->run = depth_test_quads_fallback;
922 break;
923 case PIPE_FUNC_LESS:
924 qs->run = depth_interp_z16_less_write;
925 break;
926 case PIPE_FUNC_EQUAL:
927 qs->run = depth_interp_z16_equal_write;
928 break;
929 case PIPE_FUNC_LEQUAL:
930 qs->run = depth_interp_z16_lequal_write;
931 break;
932 case PIPE_FUNC_GREATER:
933 qs->run = depth_interp_z16_greater_write;
934 break;
935 case PIPE_FUNC_NOTEQUAL:
936 qs->run = depth_interp_z16_notequal_write;
937 break;
938 case PIPE_FUNC_GEQUAL:
939 qs->run = depth_interp_z16_gequal_write;
940 break;
941 case PIPE_FUNC_ALWAYS:
942 qs->run = depth_interp_z16_always_write;
943 break;
944 default:
945 qs->run = depth_test_quads_fallback;
946 break;
947 }
948 }
949 }
950
951 /* next quad/fragment stage */
952 qs->run( qs, quads, nr );
953 }
954
955
956
957 static void
958 depth_test_begin(struct quad_stage *qs)
959 {
960 qs->run = choose_depth_test;
961 qs->next->begin(qs->next);
962 }
963
964
965 static void
966 depth_test_destroy(struct quad_stage *qs)
967 {
968 FREE( qs );
969 }
970
971
972 struct quad_stage *
973 sp_quad_depth_test_stage(struct softpipe_context *softpipe)
974 {
975 struct quad_stage *stage = CALLOC_STRUCT(quad_stage);
976
977 stage->softpipe = softpipe;
978 stage->begin = depth_test_begin;
979 stage->run = choose_depth_test;
980 stage->destroy = depth_test_destroy;
981
982 return stage;
983 }