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