projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: Add "shader/" path to #include statements in shader parser/lexer sources
[mesa.git] / src / gallium / drivers / softpipe / sp_quad_depth_test.c
1 /**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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.
25 *
26 **************************************************************************/
27
28 /**
29 * \brief Quad depth testing
30 */
31
32 #include "pipe/p_defines.h"
33 #include "util/u_memory.h"
34 #include "tgsi/tgsi_scan.h"
35 #include "sp_context.h"
36 #include "sp_quad.h"
37 #include "sp_surface.h"
38 #include "sp_quad_pipe.h"
39 #include "sp_tile_cache.h"
40 #include "sp_state.h" /* for sp_fragment_shader */
41
42
43 struct depth_data {
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;
50 };
51
52
53
54 static void
55 get_depth_stencil_values( struct depth_data *data,
56 const struct quad_header *quad )
57 {
58 unsigned j;
59 const struct softpipe_cached_tile *tile = data->tile;
60
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];
67 }
68 break;
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];
74 }
75 break;
76 case PIPE_FORMAT_X8Z24_UNORM:
77 case PIPE_FORMAT_S8Z24_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;
83 }
84 break;
85 case PIPE_FORMAT_Z24X8_UNORM:
86 case PIPE_FORMAT_Z24S8_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;
92 }
93 break;
94 default:
95 assert(0);
96 }
97 }
98
99 /* If the shader has not been run, interpolate the depth values
100 * ourselves.
101 */
102 static void
103 interpolate_quad_depth( struct quad_header *quad )
104 {
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;
110
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;
115 }
116
117
118 static void
119 convert_quad_depth( struct depth_data *data,
120 const struct quad_header *quad )
121 {
122 unsigned j;
123
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
128 * Z-fighting errors.
129 */
130 switch (data->format) {
131 case PIPE_FORMAT_Z16_UNORM:
132 {
133 float scale = 65535.0;
134
135 for (j = 0; j < QUAD_SIZE; j++) {
136 data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
137 }
138 }
139 break;
140 case PIPE_FORMAT_Z32_UNORM:
141 {
142 double scale = (double) (uint) ~0UL;
143
144 for (j = 0; j < QUAD_SIZE; j++) {
145 data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
146 }
147 }
148 break;
149 case PIPE_FORMAT_X8Z24_UNORM:
150 case PIPE_FORMAT_S8Z24_UNORM:
151 {
152 float scale = (float) ((1 << 24) - 1);
153
154 for (j = 0; j < QUAD_SIZE; j++) {
155 data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
156 }
157 }
158 break;
159 case PIPE_FORMAT_Z24X8_UNORM:
160 case PIPE_FORMAT_Z24S8_UNORM:
161 {
162 float scale = (float) ((1 << 24) - 1);
163
164 for (j = 0; j < QUAD_SIZE; j++) {
165 data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
166 }
167 }
168 break;
169 default:
170 assert(0);
171 }
172 }
173
174
175
176 static void
177 write_depth_stencil_values( struct depth_data *data,
178 struct quad_header *quad )
179 {
180 struct softpipe_cached_tile *tile = data->tile;
181 unsigned j;
182
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];
190 }
191 break;
192 case PIPE_FORMAT_X8Z24_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];
198 }
199 break;
200 case PIPE_FORMAT_S8Z24_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];
205 }
206 break;
207 case PIPE_FORMAT_Z24S8_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];
212 }
213 break;
214 case PIPE_FORMAT_Z24X8_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;
219 }
220 break;
221 default:
222 assert(0);
223 }
224 }
225
226
227
228
229 /** Only 8-bit stencil supported */
230 #define STENCIL_MAX 0xff
231
232
233 /**
234 * Do the basic stencil test (compare stencil buffer values against the
235 * reference value.
236 *
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
243 */
244 static unsigned
245 do_stencil_test(struct depth_data *data,
246 unsigned func,
247 unsigned ref, unsigned valMask)
248 {
249 unsigned passMask = 0x0;
250 unsigned j;
251
252 ref &= valMask;
253
254 switch (func) {
255 case PIPE_FUNC_NEVER:
256 /* passMask = 0x0 */
257 break;
258 case PIPE_FUNC_LESS:
259 for (j = 0; j < QUAD_SIZE; j++) {
260 if (ref < (data->stencilVals[j] & valMask)) {
261 passMask |= (1 << j);
262 }
263 }
264 break;
265 case PIPE_FUNC_EQUAL:
266 for (j = 0; j < QUAD_SIZE; j++) {
267 if (ref == (data->stencilVals[j] & valMask)) {
268 passMask |= (1 << j);
269 }
270 }
271 break;
272 case PIPE_FUNC_LEQUAL:
273 for (j = 0; j < QUAD_SIZE; j++) {
274 if (ref <= (data->stencilVals[j] & valMask)) {
275 passMask |= (1 << j);
276 }
277 }
278 break;
279 case PIPE_FUNC_GREATER:
280 for (j = 0; j < QUAD_SIZE; j++) {
281 if (ref > (data->stencilVals[j] & valMask)) {
282 passMask |= (1 << j);
283 }
284 }
285 break;
286 case PIPE_FUNC_NOTEQUAL:
287 for (j = 0; j < QUAD_SIZE; j++) {
288 if (ref != (data->stencilVals[j] & valMask)) {
289 passMask |= (1 << j);
290 }
291 }
292 break;
293 case PIPE_FUNC_GEQUAL:
294 for (j = 0; j < QUAD_SIZE; j++) {
295 if (ref >= (data->stencilVals[j] & valMask)) {
296 passMask |= (1 << j);
297 }
298 }
299 break;
300 case PIPE_FUNC_ALWAYS:
301 passMask = MASK_ALL;
302 break;
303 default:
304 assert(0);
305 }
306
307 return passMask;
308 }
309
310
311 /**
312 * Apply the stencil operator to stencil values.
313 *
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
319 * stencil values
320 */
321 static void
322 apply_stencil_op(struct depth_data *data,
323 unsigned mask, unsigned op, ubyte ref, ubyte wrtMask)
324 {
325 unsigned j;
326 ubyte newstencil[QUAD_SIZE];
327
328 for (j = 0; j < QUAD_SIZE; j++) {
329 newstencil[j] = data->stencilVals[j];
330 }
331
332 switch (op) {
333 case PIPE_STENCIL_OP_KEEP:
334 /* no-op */
335 break;
336 case PIPE_STENCIL_OP_ZERO:
337 for (j = 0; j < QUAD_SIZE; j++) {
338 if (mask & (1 << j)) {
339 newstencil[j] = 0;
340 }
341 }
342 break;
343 case PIPE_STENCIL_OP_REPLACE:
344 for (j = 0; j < QUAD_SIZE; j++) {
345 if (mask & (1 << j)) {
346 newstencil[j] = ref;
347 }
348 }
349 break;
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;
355 }
356 }
357 }
358 break;
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;
364 }
365 }
366 }
367 break;
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;
372 }
373 }
374 break;
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;
379 }
380 }
381 break;
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];
386 }
387 }
388 break;
389 default:
390 assert(0);
391 }
392
393 /*
394 * update the stencil values
395 */
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]);
400 }
401 }
402 else {
403 for (j = 0; j < QUAD_SIZE; j++) {
404 data->stencilVals[j] = newstencil[j];
405 }
406 }
407 }
408
409
410
411 /*
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...
415 */
416
417 static boolean
418 depth_test_quad(struct quad_stage *qs,
419 struct depth_data *data,
420 struct quad_header *quad)
421 {
422 struct softpipe_context *softpipe = qs->softpipe;
423 unsigned zmask = 0;
424 unsigned j;
425
426 switch (softpipe->depth_stencil->depth.func) {
427 case PIPE_FUNC_NEVER:
428 /* zmask = 0 */
429 break;
430 case PIPE_FUNC_LESS:
431 /* Note this is pretty much a single sse or cell instruction.
432 * Like this: quad->mask &= (quad->outputs.depth < zzzz);
433 */
434 for (j = 0; j < QUAD_SIZE; j++) {
435 if (data->qzzzz[j] < data->bzzzz[j])
436 zmask |= 1 << j;
437 }
438 break;
439 case PIPE_FUNC_EQUAL:
440 for (j = 0; j < QUAD_SIZE; j++) {
441 if (data->qzzzz[j] == data->bzzzz[j])
442 zmask |= 1 << j;
443 }
444 break;
445 case PIPE_FUNC_LEQUAL:
446 for (j = 0; j < QUAD_SIZE; j++) {
447 if (data->qzzzz[j] <= data->bzzzz[j])
448 zmask |= (1 << j);
449 }
450 break;
451 case PIPE_FUNC_GREATER:
452 for (j = 0; j < QUAD_SIZE; j++) {
453 if (data->qzzzz[j] > data->bzzzz[j])
454 zmask |= (1 << j);
455 }
456 break;
457 case PIPE_FUNC_NOTEQUAL:
458 for (j = 0; j < QUAD_SIZE; j++) {
459 if (data->qzzzz[j] != data->bzzzz[j])
460 zmask |= (1 << j);
461 }
462 break;
463 case PIPE_FUNC_GEQUAL:
464 for (j = 0; j < QUAD_SIZE; j++) {
465 if (data->qzzzz[j] >= data->bzzzz[j])
466 zmask |= (1 << j);
467 }
468 break;
469 case PIPE_FUNC_ALWAYS:
470 zmask = MASK_ALL;
471 break;
472 default:
473 assert(0);
474 }
475
476 quad->inout.mask &= zmask;
477 if (quad->inout.mask == 0)
478 return FALSE;
479
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.
483 */
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];
488 }
489 }
490 }
491
492 return TRUE;
493 }
494
495
496
497 /**
498 * Do stencil (and depth) testing. Stenciling depends on the outcome of
499 * depth testing.
500 */
501 static void
502 depth_stencil_test_quad(struct quad_stage *qs,
503 struct depth_data *data,
504 struct quad_header *quad)
505 {
506 struct softpipe_context *softpipe = qs->softpipe;
507 unsigned func, zFailOp, zPassOp, failOp;
508 ubyte ref, wrtMask, valMask;
509 uint face = quad->input.facing;
510
511 if (!softpipe->depth_stencil->stencil[1].enabled) {
512 /* single-sided stencil test, use front (face=0) state */
513 face = 0;
514 }
515
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->depth_stencil->stencil[face].ref_value;
523 wrtMask = softpipe->depth_stencil->stencil[face].writemask;
524 valMask = softpipe->depth_stencil->stencil[face].valuemask;
525
526
527 /* do the stencil test first */
528 {
529 unsigned passMask, failMask;
530 passMask = do_stencil_test(data, func, ref, valMask);
531 failMask = quad->inout.mask & ~passMask;
532 quad->inout.mask &= passMask;
533
534 if (failOp != PIPE_STENCIL_OP_KEEP) {
535 apply_stencil_op(data, failMask, failOp, ref, wrtMask);
536 }
537 }
538
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;
543
544 depth_test_quad(qs, data, quad); /* quad->mask is updated */
545
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);
550 }
551
552 if (zPassOp != PIPE_STENCIL_OP_KEEP) {
553 const unsigned zPassMask = origMask & quad->inout.mask;
554 apply_stencil_op(data, zPassMask, zPassOp, ref, wrtMask);
555 }
556 }
557 else {
558 /* no depth test, apply Zpass operator to stencil buffer values */
559 apply_stencil_op(data, quad->inout.mask, zPassOp, ref, wrtMask);
560 }
561 }
562 }
563
564
565 #define ALPHATEST( FUNC, COMP ) \
566 static int \
567 alpha_test_quads_##FUNC( struct quad_stage *qs, \
568 struct quad_header *quads[], \
569 unsigned nr ) \
570 { \
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; \
574 unsigned i; \
575 \
576 for (i = 0; i < nr; i++) { \
577 const float *aaaa = quads[i]->output.color[cbuf][3]; \
578 unsigned passMask = 0; \
579 \
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); \
584 \
585 quads[i]->inout.mask &= passMask; \
586 \
587 if (quads[i]->inout.mask) \
588 quads[pass_nr++] = quads[i]; \
589 } \
590 \
591 return pass_nr; \
592 }
593
594
595 ALPHATEST( LESS, < )
596 ALPHATEST( EQUAL, == )
597 ALPHATEST( LEQUAL, <= )
598 ALPHATEST( GREATER, > )
599 ALPHATEST( NOTEQUAL, != )
600 ALPHATEST( GEQUAL, >= )
601
602
603 /* XXX: Incorporate into shader using KILP.
604 */
605 static int
606 alpha_test_quads(struct quad_stage *qs,
607 struct quad_header *quads[],
608 unsigned nr)
609 {
610 switch (qs->softpipe->depth_stencil->alpha.func) {
611 case PIPE_FUNC_LESS:
612 return alpha_test_quads_LESS( qs, quads, nr );
613 case PIPE_FUNC_EQUAL:
614 return alpha_test_quads_EQUAL( qs, quads, nr );
615 break;
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:
625 return nr;
626 case PIPE_FUNC_NEVER:
627 default:
628 return 0;
629 }
630 }
631
632 static unsigned mask_count[16] =
633 {
634 0, /* 0x0 */
635 1, /* 0x1 */
636 1, /* 0x2 */
637 2, /* 0x3 */
638 1, /* 0x4 */
639 2, /* 0x5 */
640 2, /* 0x6 */
641 3, /* 0x7 */
642 1, /* 0x8 */
643 2, /* 0x9 */
644 2, /* 0xa */
645 3, /* 0xb */
646 2, /* 0xc */
647 3, /* 0xd */
648 3, /* 0xe */
649 4, /* 0xf */
650 };
651
652
653
654 static void
655 depth_test_quads_fallback(struct quad_stage *qs,
656 struct quad_header *quads[],
657 unsigned nr)
658 {
659 unsigned i, pass = 0;
660 const struct sp_fragment_shader *fs = qs->softpipe->fs;
661 boolean interp_depth = !fs->info.writes_z;
662 struct depth_data data;
663
664
665 if (qs->softpipe->depth_stencil->alpha.enabled) {
666 nr = alpha_test_quads(qs, quads, nr);
667 }
668
669 if (qs->softpipe->framebuffer.zsbuf &&
670 (qs->softpipe->depth_stencil->depth.enabled ||
671 qs->softpipe->depth_stencil->stencil[0].enabled)) {
672
673 data.ps = qs->softpipe->framebuffer.zsbuf;
674 data.format = data.ps->format;
675 data.tile = sp_get_cached_tile(qs->softpipe->zsbuf_cache,
676 quads[0]->input.x0,
677 quads[0]->input.y0);
678
679 for (i = 0; i < nr; i++) {
680 get_depth_stencil_values(&data, quads[i]);
681
682 if (qs->softpipe->depth_stencil->depth.enabled) {
683 if (interp_depth)
684 interpolate_quad_depth(quads[i]);
685
686 convert_quad_depth(&data, quads[i]);
687 }
688
689 if (qs->softpipe->depth_stencil->stencil[0].enabled) {
690 depth_stencil_test_quad(qs, &data, quads[i]);
691 write_depth_stencil_values(&data, quads[i]);
692 }
693 else {
694 if (!depth_test_quad(qs, &data, quads[i]))
695 continue;
696
697 if (qs->softpipe->depth_stencil->depth.writemask)
698 write_depth_stencil_values(&data, quads[i]);
699 }
700
701
702 quads[pass++] = quads[i];
703 }
704
705 nr = pass;
706 }
707
708 if (qs->softpipe->active_query_count) {
709 for (i = 0; i < nr; i++)
710 qs->softpipe->occlusion_count += mask_count[quads[i]->inout.mask];
711 }
712
713 if (nr)
714 qs->next->run(qs->next, quads, nr);
715 }
716
717 /* XXX: this function assumes setup function actually emits linear
718 * spans of quads. It seems a lot more natural to do (early)
719 * depth-testing on spans rather than quads.
720 */
721 static void
722 depth_interp_z16_less_write(struct quad_stage *qs,
723 struct quad_header *quads[],
724 unsigned nr)
725 {
726 unsigned i, pass = 0;
727 const unsigned ix = quads[0]->input.x0;
728 const unsigned iy = quads[0]->input.y0;
729 const float fx = (float) ix;
730 const float fy = (float) iy;
731 const float dzdx = quads[0]->posCoef->dadx[2];
732 const float dzdy = quads[0]->posCoef->dady[2];
733 const float z0 = quads[0]->posCoef->a0[2] + dzdx * fx + dzdy * fy;
734 struct softpipe_cached_tile *tile;
735 ushort (*depth16)[TILE_SIZE];
736 ushort idepth[4], depth_step;
737 const float scale = 65535.0;
738
739 idepth[0] = (ushort)((z0) * scale);
740 idepth[1] = (ushort)((z0 + dzdx) * scale);
741 idepth[2] = (ushort)((z0 + dzdy) * scale);
742 idepth[3] = (ushort)((z0 + dzdx + dzdy) * scale);
743
744 depth_step = (ushort)(dzdx * 2 * scale);
745
746 tile = sp_get_cached_tile(qs->softpipe->zsbuf_cache, ix, iy);
747
748 depth16 = (ushort (*)[TILE_SIZE])
749 &tile->data.depth16[iy % TILE_SIZE][ix % TILE_SIZE];
750
751 for (i = 0; i < nr; i++) {
752 unsigned outmask = quads[i]->inout.mask;
753 unsigned mask = 0;
754
755 if ((outmask & 1) && idepth[0] < depth16[0][0]) {
756 depth16[0][0] = idepth[0];
757 mask |= (1 << 0);
758 }
759
760 if ((outmask & 2) && idepth[1] < depth16[0][1]) {
761 depth16[0][1] = idepth[1];
762 mask |= (1 << 1);
763 }
764
765 if ((outmask & 4) && idepth[2] < depth16[1][0]) {
766 depth16[1][0] = idepth[2];
767 mask |= (1 << 2);
768 }
769
770 if ((outmask & 8) && idepth[3] < depth16[1][1]) {
771 depth16[1][1] = idepth[3];
772 mask |= (1 << 3);
773 }
774
775 idepth[0] += depth_step;
776 idepth[1] += depth_step;
777 idepth[2] += depth_step;
778 idepth[3] += depth_step;
779
780 depth16 = (ushort (*)[TILE_SIZE]) &depth16[0][2];
781
782 quads[i]->inout.mask = mask;
783 if (quads[i]->inout.mask)
784 quads[pass++] = quads[i];
785 }
786
787 if (pass)
788 qs->next->run(qs->next, quads, pass);
789
790 }
791
792
793 static void
794 depth_interp_z16_lequal_write(struct quad_stage *qs,
795 struct quad_header *quads[],
796 unsigned nr)
797 {
798 unsigned i, pass = 0;
799 const unsigned ix = quads[0]->input.x0;
800 const unsigned iy = quads[0]->input.y0;
801 const float fx = (float) ix;
802 const float fy = (float) iy;
803 const float dzdx = quads[0]->posCoef->dadx[2];
804 const float dzdy = quads[0]->posCoef->dady[2];
805 const float z0 = quads[0]->posCoef->a0[2] + dzdx * fx + dzdy * fy;
806 struct softpipe_cached_tile *tile;
807 ushort (*depth16)[TILE_SIZE];
808 ushort idepth[4], depth_step;
809 const float scale = 65535.0;
810
811 idepth[0] = (ushort)((z0) * scale);
812 idepth[1] = (ushort)((z0 + dzdx) * scale);
813 idepth[2] = (ushort)((z0 + dzdy) * scale);
814 idepth[3] = (ushort)((z0 + dzdx + dzdy) * scale);
815
816 depth_step = (ushort)(dzdx * 2 * scale);
817
818 tile = sp_get_cached_tile(qs->softpipe->zsbuf_cache, ix, iy);
819
820 depth16 = (ushort (*)[TILE_SIZE])
821 &tile->data.depth16[iy % TILE_SIZE][ix % TILE_SIZE];
822
823 for (i = 0; i < nr; i++) {
824 unsigned outmask = quads[i]->inout.mask;
825 unsigned mask = 0;
826
827 if ((outmask & 1) && idepth[0] <= depth16[0][0]) {
828 depth16[0][0] = idepth[0];
829 mask |= (1 << 0);
830 }
831
832 if ((outmask & 2) && idepth[1] <= depth16[0][1]) {
833 depth16[0][1] = idepth[1];
834 mask |= (1 << 1);
835 }
836
837 if ((outmask & 4) && idepth[2] <= depth16[1][0]) {
838 depth16[1][0] = idepth[2];
839 mask |= (1 << 2);
840 }
841
842 if ((outmask & 8) && idepth[3] <= depth16[1][1]) {
843 depth16[1][1] = idepth[3];
844 mask |= (1 << 3);
845 }
846
847 idepth[0] += depth_step;
848 idepth[1] += depth_step;
849 idepth[2] += depth_step;
850 idepth[3] += depth_step;
851
852 depth16 = (ushort (*)[TILE_SIZE]) &depth16[0][2];
853
854 quads[i]->inout.mask = mask;
855 if (quads[i]->inout.mask)
856 quads[pass++] = quads[i];
857 }
858
859 if (pass)
860 qs->next->run(qs->next, quads, pass);
861
862 }
863
864
865
866
867
868 static void
869 depth_noop(struct quad_stage *qs,
870 struct quad_header *quads[],
871 unsigned nr)
872 {
873 qs->next->run(qs->next, quads, nr);
874 }
875
876
877
878 static void
879 choose_depth_test(struct quad_stage *qs,
880 struct quad_header *quads[],
881 unsigned nr)
882 {
883 boolean interp_depth = !qs->softpipe->fs->info.writes_z;
884
885 boolean alpha = qs->softpipe->depth_stencil->alpha.enabled;
886
887 boolean depth = (qs->softpipe->framebuffer.zsbuf &&
888 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
899 if (!alpha &&
900 !depth &&
901 !stencil) {
902 qs->run = depth_noop;
903 }
904 else if (!alpha &&
905 interp_depth &&
906 depth &&
907 depthwrite &&
908 !occlusion &&
909 !stencil)
910 {
911 switch (depthfunc) {
912 case PIPE_FUNC_LESS:
913 switch (qs->softpipe->framebuffer.zsbuf->format) {
914 case PIPE_FORMAT_Z16_UNORM:
915 qs->run = depth_interp_z16_less_write;
916 break;
917 default:
918 qs->run = depth_test_quads_fallback;
919 break;
920 }
921 break;
922 case PIPE_FUNC_LEQUAL:
923 switch (qs->softpipe->framebuffer.zsbuf->format) {
924 case PIPE_FORMAT_Z16_UNORM:
925 qs->run = depth_interp_z16_lequal_write;
926 break;
927 default:
928 qs->run = depth_test_quads_fallback;
929 break;
930 }
931 break;
932 default:
933 qs->run = depth_test_quads_fallback;
934 }
935 }
936 else {
937 qs->run = depth_test_quads_fallback;
938 }
939
940
941 qs->run( qs, quads, nr );
942 }
943
944
945
946
947
948 static void depth_test_begin(struct quad_stage *qs)
949 {
950 qs->run = choose_depth_test;
951 qs->next->begin(qs->next);
952 }
953
954
955 static void depth_test_destroy(struct quad_stage *qs)
956 {
957 FREE( qs );
958 }
959
960
961 struct quad_stage *sp_quad_depth_test_stage( struct softpipe_context *softpipe )
962 {
963 struct quad_stage *stage = CALLOC_STRUCT(quad_stage);
964
965 stage->softpipe = softpipe;
966 stage->begin = depth_test_begin;
967 stage->run = choose_depth_test;
968 stage->destroy = depth_test_destroy;
969
970 return stage;
971 }