+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-/**
- * \brief Quad depth testing
- */
-
-#include "pipe/p_defines.h"
-#include "util/u_memory.h"
-#include "tgsi/tgsi_scan.h"
-#include "lp_context.h"
-#include "lp_quad.h"
-#include "lp_surface.h"
-#include "lp_quad_pipe.h"
-#include "lp_tile_cache.h"
-#include "lp_state.h" /* for lp_fragment_shader */
-
-
-struct depth_data {
- struct pipe_surface *ps;
- enum pipe_format format;
- unsigned bzzzz[QUAD_SIZE]; /**< Z values fetched from depth buffer */
- unsigned qzzzz[QUAD_SIZE]; /**< Z values from the quad */
- ubyte stencilVals[QUAD_SIZE];
- struct llvmpipe_cached_tile *tile;
-};
-
-
-
-static void
-get_depth_stencil_values( struct depth_data *data,
- const struct quad_header *quad )
-{
- unsigned j;
- const struct llvmpipe_cached_tile *tile = data->tile;
-
- switch (data->format) {
- case PIPE_FORMAT_Z16_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- data->bzzzz[j] = tile->data.depth16[y][x];
- }
- break;
- case PIPE_FORMAT_Z32_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- data->bzzzz[j] = tile->data.depth32[y][x];
- }
- break;
- case PIPE_FORMAT_X8Z24_UNORM:
- case PIPE_FORMAT_S8Z24_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- data->bzzzz[j] = tile->data.depth32[y][x] & 0xffffff;
- data->stencilVals[j] = tile->data.depth32[y][x] >> 24;
- }
- break;
- case PIPE_FORMAT_Z24X8_UNORM:
- case PIPE_FORMAT_Z24S8_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- data->bzzzz[j] = tile->data.depth32[y][x] >> 8;
- data->stencilVals[j] = tile->data.depth32[y][x] & 0xff;
- }
- break;
- default:
- assert(0);
- }
-}
-
-/* If the shader has not been run, interpolate the depth values
- * ourselves.
- */
-static void
-interpolate_quad_depth( struct quad_header *quad )
-{
- const float fx = (float) quad->input.x0;
- const float fy = (float) quad->input.y0;
- const float dzdx = quad->coef->dadx[0][2];
- const float dzdy = quad->coef->dady[0][2];
- const float z0 = quad->coef->a0[0][2] + dzdx * fx + dzdy * fy;
-
- quad->output.depth[0] = z0;
- quad->output.depth[1] = z0 + dzdx;
- quad->output.depth[2] = z0 + dzdy;
- quad->output.depth[3] = z0 + dzdx + dzdy;
-}
-
-
-static void
-convert_quad_depth( struct depth_data *data,
- const struct quad_header *quad )
-{
- unsigned j;
-
- /* Convert quad's float depth values to int depth values (qzzzz).
- * If the Z buffer stores integer values, we _have_ to do the depth
- * compares with integers (not floats). Otherwise, the float->int->float
- * conversion of Z values (which isn't an identity function) will cause
- * Z-fighting errors.
- */
- switch (data->format) {
- case PIPE_FORMAT_Z16_UNORM:
- {
- float scale = 65535.0;
-
- for (j = 0; j < QUAD_SIZE; j++) {
- data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
- }
- }
- break;
- case PIPE_FORMAT_Z32_UNORM:
- {
- double scale = (double) (uint) ~0UL;
-
- for (j = 0; j < QUAD_SIZE; j++) {
- data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
- }
- }
- break;
- case PIPE_FORMAT_X8Z24_UNORM:
- case PIPE_FORMAT_S8Z24_UNORM:
- {
- float scale = (float) ((1 << 24) - 1);
-
- for (j = 0; j < QUAD_SIZE; j++) {
- data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
- }
- }
- break;
- case PIPE_FORMAT_Z24X8_UNORM:
- case PIPE_FORMAT_Z24S8_UNORM:
- {
- float scale = (float) ((1 << 24) - 1);
-
- for (j = 0; j < QUAD_SIZE; j++) {
- data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
- }
- }
- break;
- default:
- assert(0);
- }
-}
-
-
-
-static void
-write_depth_stencil_values( struct depth_data *data,
- struct quad_header *quad )
-{
- struct llvmpipe_cached_tile *tile = data->tile;
- unsigned j;
-
- /* put updated Z values back into cached tile */
- switch (data->format) {
- case PIPE_FORMAT_Z16_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- tile->data.depth16[y][x] = (ushort) data->bzzzz[j];
- }
- break;
- case PIPE_FORMAT_X8Z24_UNORM:
- case PIPE_FORMAT_Z32_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- tile->data.depth32[y][x] = data->bzzzz[j];
- }
- break;
- case PIPE_FORMAT_S8Z24_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- tile->data.depth32[y][x] = (data->stencilVals[j] << 24) | data->bzzzz[j];
- }
- break;
- case PIPE_FORMAT_Z24S8_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- tile->data.depth32[y][x] = (data->bzzzz[j] << 8) | data->stencilVals[j];
- }
- break;
- case PIPE_FORMAT_Z24X8_UNORM:
- for (j = 0; j < QUAD_SIZE; j++) {
- int x = quad->input.x0 % TILE_SIZE + (j & 1);
- int y = quad->input.y0 % TILE_SIZE + (j >> 1);
- tile->data.depth32[y][x] = data->bzzzz[j] << 8;
- }
- break;
- default:
- assert(0);
- }
-}
-
-
-
-
-/** Only 8-bit stencil supported */
-#define STENCIL_MAX 0xff
-
-
-/**
- * Do the basic stencil test (compare stencil buffer values against the
- * reference value.
- *
- * \param data->stencilVals the stencil values from the stencil buffer
- * \param func the stencil func (PIPE_FUNC_x)
- * \param ref the stencil reference value
- * \param valMask the stencil value mask indicating which bits of the stencil
- * values and ref value are to be used.
- * \return mask indicating which pixels passed the stencil test
- */
-static unsigned
-do_stencil_test(struct depth_data *data,
- unsigned func,
- unsigned ref, unsigned valMask)
-{
- unsigned passMask = 0x0;
- unsigned j;
-
- ref &= valMask;
-
- switch (func) {
- case PIPE_FUNC_NEVER:
- /* passMask = 0x0 */
- break;
- case PIPE_FUNC_LESS:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (ref < (data->stencilVals[j] & valMask)) {
- passMask |= (1 << j);
- }
- }
- break;
- case PIPE_FUNC_EQUAL:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (ref == (data->stencilVals[j] & valMask)) {
- passMask |= (1 << j);
- }
- }
- break;
- case PIPE_FUNC_LEQUAL:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (ref <= (data->stencilVals[j] & valMask)) {
- passMask |= (1 << j);
- }
- }
- break;
- case PIPE_FUNC_GREATER:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (ref > (data->stencilVals[j] & valMask)) {
- passMask |= (1 << j);
- }
- }
- break;
- case PIPE_FUNC_NOTEQUAL:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (ref != (data->stencilVals[j] & valMask)) {
- passMask |= (1 << j);
- }
- }
- break;
- case PIPE_FUNC_GEQUAL:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (ref >= (data->stencilVals[j] & valMask)) {
- passMask |= (1 << j);
- }
- }
- break;
- case PIPE_FUNC_ALWAYS:
- passMask = MASK_ALL;
- break;
- default:
- assert(0);
- }
-
- return passMask;
-}
-
-
-/**
- * Apply the stencil operator to stencil values.
- *
- * \param data->stencilVals the stencil buffer values (read and written)
- * \param mask indicates which pixels to update
- * \param op the stencil operator (PIPE_STENCIL_OP_x)
- * \param ref the stencil reference value
- * \param wrtMask writemask controlling which bits are changed in the
- * stencil values
- */
-static void
-apply_stencil_op(struct depth_data *data,
- unsigned mask, unsigned op, ubyte ref, ubyte wrtMask)
-{
- unsigned j;
- ubyte newstencil[QUAD_SIZE];
-
- for (j = 0; j < QUAD_SIZE; j++) {
- newstencil[j] = data->stencilVals[j];
- }
-
- switch (op) {
- case PIPE_STENCIL_OP_KEEP:
- /* no-op */
- break;
- case PIPE_STENCIL_OP_ZERO:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (mask & (1 << j)) {
- newstencil[j] = 0;
- }
- }
- break;
- case PIPE_STENCIL_OP_REPLACE:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (mask & (1 << j)) {
- newstencil[j] = ref;
- }
- }
- break;
- case PIPE_STENCIL_OP_INCR:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (mask & (1 << j)) {
- if (data->stencilVals[j] < STENCIL_MAX) {
- newstencil[j] = data->stencilVals[j] + 1;
- }
- }
- }
- break;
- case PIPE_STENCIL_OP_DECR:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (mask & (1 << j)) {
- if (data->stencilVals[j] > 0) {
- newstencil[j] = data->stencilVals[j] - 1;
- }
- }
- }
- break;
- case PIPE_STENCIL_OP_INCR_WRAP:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (mask & (1 << j)) {
- newstencil[j] = data->stencilVals[j] + 1;
- }
- }
- break;
- case PIPE_STENCIL_OP_DECR_WRAP:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (mask & (1 << j)) {
- newstencil[j] = data->stencilVals[j] - 1;
- }
- }
- break;
- case PIPE_STENCIL_OP_INVERT:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (mask & (1 << j)) {
- newstencil[j] = ~data->stencilVals[j];
- }
- }
- break;
- default:
- assert(0);
- }
-
- /*
- * update the stencil values
- */
- if (wrtMask != STENCIL_MAX) {
- /* apply bit-wise stencil buffer writemask */
- for (j = 0; j < QUAD_SIZE; j++) {
- data->stencilVals[j] = (wrtMask & newstencil[j]) | (~wrtMask & data->stencilVals[j]);
- }
- }
- else {
- for (j = 0; j < QUAD_SIZE; j++) {
- data->stencilVals[j] = newstencil[j];
- }
- }
-}
-
-
-
-/*
- * To increase efficiency, we should probably have multiple versions
- * of this function that are specifically for Z16, Z32 and FP Z buffers.
- * Try to effectively do that with codegen...
- */
-
-static boolean
-depth_test_quad(struct quad_stage *qs,
- struct depth_data *data,
- struct quad_header *quad)
-{
- struct llvmpipe_context *llvmpipe = qs->llvmpipe;
- unsigned zmask = 0;
- unsigned j;
-
- switch (llvmpipe->depth_stencil->depth.func) {
- case PIPE_FUNC_NEVER:
- /* zmask = 0 */
- break;
- case PIPE_FUNC_LESS:
- /* Note this is pretty much a single sse or cell instruction.
- * Like this: quad->mask &= (quad->outputs.depth < zzzz);
- */
- for (j = 0; j < QUAD_SIZE; j++) {
- if (data->qzzzz[j] < data->bzzzz[j])
- zmask |= 1 << j;
- }
- break;
- case PIPE_FUNC_EQUAL:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (data->qzzzz[j] == data->bzzzz[j])
- zmask |= 1 << j;
- }
- break;
- case PIPE_FUNC_LEQUAL:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (data->qzzzz[j] <= data->bzzzz[j])
- zmask |= (1 << j);
- }
- break;
- case PIPE_FUNC_GREATER:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (data->qzzzz[j] > data->bzzzz[j])
- zmask |= (1 << j);
- }
- break;
- case PIPE_FUNC_NOTEQUAL:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (data->qzzzz[j] != data->bzzzz[j])
- zmask |= (1 << j);
- }
- break;
- case PIPE_FUNC_GEQUAL:
- for (j = 0; j < QUAD_SIZE; j++) {
- if (data->qzzzz[j] >= data->bzzzz[j])
- zmask |= (1 << j);
- }
- break;
- case PIPE_FUNC_ALWAYS:
- zmask = MASK_ALL;
- break;
- default:
- assert(0);
- }
-
- quad->inout.mask &= zmask;
- if (quad->inout.mask == 0)
- return FALSE;
-
- /* Update our internal copy only if writemask set. Even if
- * depth.writemask is FALSE, may still need to write out buffer
- * data due to stencil changes.
- */
- if (llvmpipe->depth_stencil->depth.writemask) {
- for (j = 0; j < QUAD_SIZE; j++) {
- if (quad->inout.mask & (1 << j)) {
- data->bzzzz[j] = data->qzzzz[j];
- }
- }
- }
-
- return TRUE;
-}
-
-
-
-/**
- * Do stencil (and depth) testing. Stenciling depends on the outcome of
- * depth testing.
- */
-static boolean
-depth_stencil_test_quad(struct quad_stage *qs,
- struct depth_data *data,
- struct quad_header *quad)
-{
- struct llvmpipe_context *llvmpipe = qs->llvmpipe;
- unsigned func, zFailOp, zPassOp, failOp;
- ubyte ref, wrtMask, valMask;
- uint face = quad->input.facing;
-
- if (!llvmpipe->depth_stencil->stencil[1].enabled) {
- /* single-sided stencil test, use front (face=0) state */
- face = 0;
- }
-
- /* choose front or back face function, operator, etc */
- /* XXX we could do these initializations once per primitive */
- func = llvmpipe->depth_stencil->stencil[face].func;
- failOp = llvmpipe->depth_stencil->stencil[face].fail_op;
- zFailOp = llvmpipe->depth_stencil->stencil[face].zfail_op;
- zPassOp = llvmpipe->depth_stencil->stencil[face].zpass_op;
- ref = llvmpipe->depth_stencil->stencil[face].ref_value;
- wrtMask = llvmpipe->depth_stencil->stencil[face].writemask;
- valMask = llvmpipe->depth_stencil->stencil[face].valuemask;
-
-
- /* do the stencil test first */
- {
- unsigned passMask, failMask;
- passMask = do_stencil_test(data, func, ref, valMask);
- failMask = quad->inout.mask & ~passMask;
- quad->inout.mask &= passMask;
-
- if (failOp != PIPE_STENCIL_OP_KEEP) {
- apply_stencil_op(data, failMask, failOp, ref, wrtMask);
- }
- }
-
- if (quad->inout.mask) {
- /* now the pixels that passed the stencil test are depth tested */
- if (llvmpipe->depth_stencil->depth.enabled) {
- const unsigned origMask = quad->inout.mask;
-
- depth_test_quad(qs, data, quad); /* quad->mask is updated */
-
- /* update stencil buffer values according to z pass/fail result */
- if (zFailOp != PIPE_STENCIL_OP_KEEP) {
- const unsigned failMask = origMask & ~quad->inout.mask;
- apply_stencil_op(data, failMask, zFailOp, ref, wrtMask);
- }
-
- if (zPassOp != PIPE_STENCIL_OP_KEEP) {
- const unsigned passMask = origMask & quad->inout.mask;
- apply_stencil_op(data, passMask, zPassOp, ref, wrtMask);
- }
- }
- else {
- /* no depth test, apply Zpass operator to stencil buffer values */
- apply_stencil_op(data, quad->inout.mask, zPassOp, ref, wrtMask);
- }
- }
-
- return quad->inout.mask != 0;
-}
-
-
-
-static unsigned mask_count[0x8] =
-{
- 0, /* 0x0 */
- 1, /* 0x1 */
- 1, /* 0x2 */
- 2, /* 0x3 */
- 1, /* 0x4 */
- 2, /* 0x5 */
- 2, /* 0x6 */
- 3, /* 0x7 */
-};
-
-
-
-static void
-depth_test_quads_fallback(struct quad_stage *qs,
- struct quad_header *quads[],
- unsigned nr)
-{
- unsigned i, pass = 0;
- const struct lp_fragment_shader *fs = qs->llvmpipe->fs;
- boolean interp_depth = !fs->info.writes_z;
- struct depth_data data;
-
-
- if (qs->llvmpipe->framebuffer.zsbuf &&
- (qs->llvmpipe->depth_stencil->depth.enabled ||
- qs->llvmpipe->depth_stencil->stencil[0].enabled)) {
-
- data.ps = qs->llvmpipe->framebuffer.zsbuf;
- data.format = data.ps->format;
- data.tile = lp_get_cached_tile(qs->llvmpipe->zsbuf_cache,
- quads[0]->input.x0,
- quads[0]->input.y0);
-
- for (i = 0; i < nr; i++) {
- if(!quads[i]->inout.mask)
- continue;
-
- get_depth_stencil_values(&data, quads[i]);
-
- if (qs->llvmpipe->depth_stencil->depth.enabled) {
- if (interp_depth)
- interpolate_quad_depth(quads[i]);
-
- convert_quad_depth(&data, quads[i]);
- }
-
- if (qs->llvmpipe->depth_stencil->stencil[0].enabled) {
- if (!depth_stencil_test_quad(qs, &data, quads[i]))
- continue;
- }
- else {
- if (!depth_test_quad(qs, &data, quads[i]))
- continue;
- }
-
- if (qs->llvmpipe->depth_stencil->stencil[0].enabled ||
- qs->llvmpipe->depth_stencil->depth.writemask)
- write_depth_stencil_values(&data, quads[i]);
-
- qs->llvmpipe->occlusion_count += mask_count[quads[i]->inout.mask];
- ++pass;
- }
- }
-
- if (pass)
- qs->next->run(qs->next, quads, nr);
-}
-
-/* XXX: this function assumes setup function actually emits linear
- * spans of quads. It seems a lot more natural to do (early)
- * depth-testing on spans rather than quads.
- */
-static void
-depth_interp_z16_less_write(struct quad_stage *qs,
- struct quad_header *quads[],
- unsigned nr)
-{
- unsigned i, pass = 0;
- const unsigned ix = quads[0]->input.x0;
- const unsigned iy = quads[0]->input.y0;
- const float fx = (float) ix;
- const float fy = (float) iy;
- const float dzdx = quads[0]->coef->dadx[0][2];
- const float dzdy = quads[0]->coef->dady[0][2];
- const float z0 = quads[0]->coef->a0[0][2] + dzdx * fx + dzdy * fy;
- struct llvmpipe_cached_tile *tile;
- ushort (*depth16)[TILE_SIZE];
- ushort idepth[4], depth_step;
- const float scale = 65535.0;
-
- idepth[0] = (ushort)((z0) * scale);
- idepth[1] = (ushort)((z0 + dzdx) * scale);
- idepth[2] = (ushort)((z0 + dzdy) * scale);
- idepth[3] = (ushort)((z0 + dzdx + dzdy) * scale);
-
- depth_step = (ushort)(dzdx * 2 * scale);
-
- tile = lp_get_cached_tile(qs->llvmpipe->zsbuf_cache, ix, iy);
-
- depth16 = (ushort (*)[TILE_SIZE])
- &tile->data.depth16[iy % TILE_SIZE][ix % TILE_SIZE];
-
- for (i = 0; i < nr; i++) {
- unsigned outmask = quads[i]->inout.mask;
- unsigned mask = 0;
-
- if ((outmask & 1) && idepth[0] < depth16[0][0]) {
- depth16[0][0] = idepth[0];
- mask |= (1 << 0);
- }
-
- if ((outmask & 2) && idepth[1] < depth16[0][1]) {
- depth16[0][1] = idepth[1];
- mask |= (1 << 1);
- }
-
- if ((outmask & 4) && idepth[2] < depth16[1][0]) {
- depth16[1][0] = idepth[2];
- mask |= (1 << 2);
- }
-
- if ((outmask & 8) && idepth[3] < depth16[1][1]) {
- depth16[1][1] = idepth[3];
- mask |= (1 << 3);
- }
-
- idepth[0] += depth_step;
- idepth[1] += depth_step;
- idepth[2] += depth_step;
- idepth[3] += depth_step;
-
- depth16 = (ushort (*)[TILE_SIZE]) &depth16[0][2];
-
- quads[i]->inout.mask = mask;
- if (quads[i]->inout.mask)
- ++pass;
- }
-
- if (pass)
- qs->next->run(qs->next, quads, nr);
-
-}
-
-
-static void
-depth_noop(struct quad_stage *qs,
- struct quad_header *quads[],
- unsigned nr)
-{
- qs->next->run(qs->next, quads, nr);
-}
-
-
-
-static void
-choose_depth_test(struct quad_stage *qs,
- struct quad_header *quads[],
- unsigned nr)
-{
- boolean interp_depth = !qs->llvmpipe->fs->info.writes_z;
-
- boolean depth = (qs->llvmpipe->framebuffer.zsbuf &&
- qs->llvmpipe->depth_stencil->depth.enabled);
-
- unsigned depthfunc = qs->llvmpipe->depth_stencil->depth.func;
-
- boolean stencil = qs->llvmpipe->depth_stencil->stencil[0].enabled;
-
- boolean depthwrite = qs->llvmpipe->depth_stencil->depth.writemask;
-
-
- qs->run = depth_test_quads_fallback;
-
- if (!depth &&
- !stencil) {
- qs->run = depth_noop;
- }
- else if (interp_depth &&
- depth &&
- depthfunc == PIPE_FUNC_LESS &&
- depthwrite &&
- !stencil)
- {
- switch (qs->llvmpipe->framebuffer.zsbuf->format) {
- case PIPE_FORMAT_Z16_UNORM:
- qs->run = depth_interp_z16_less_write;
- break;
- default:
- break;
- }
- }
-
- qs->run( qs, quads, nr );
-}
-
-
-
-
-
-static void depth_test_begin(struct quad_stage *qs)
-{
- qs->run = choose_depth_test;
- qs->next->begin(qs->next);
-}
-
-
-static void depth_test_destroy(struct quad_stage *qs)
-{
- FREE( qs );
-}
-
-
-struct quad_stage *lp_quad_depth_test_stage( struct llvmpipe_context *llvmpipe )
-{
- struct quad_stage *stage = CALLOC_STRUCT(quad_stage);
-
- stage->llvmpipe = llvmpipe;
- stage->begin = depth_test_begin;
- stage->run = choose_depth_test;
- stage->destroy = depth_test_destroy;
-
- return stage;
-}
#include "pipe/p_defines.h"
#include "util/u_memory.h"
+#include "util/u_format.h"
#include "util/u_debug_dump.h"
#include "pipe/internal/p_winsys_screen.h"
#include "pipe/p_shader_tokens.h"
#include "tgsi/tgsi_scan.h"
#include "tgsi/tgsi_parse.h"
#include "lp_bld_type.h"
+#include "lp_bld_conv.h"
+#include "lp_bld_depth.h"
#include "lp_bld_tgsi.h"
#include "lp_bld_alpha.h"
#include "lp_bld_swizzle.h"
}
+static void
+depth_test_generate(struct llvmpipe_context *lp,
+ LLVMBuilderRef builder,
+ const struct pipe_depth_state *state,
+ union lp_type src_type,
+ LLVMValueRef *mask,
+ LLVMValueRef src,
+ LLVMValueRef dst_ptr)
+{
+ const struct util_format_description *format_desc;
+ union lp_type dst_type;
+
+ if(!lp->framebuffer.zsbuf)
+ return;
+
+ format_desc = util_format_description(lp->framebuffer.zsbuf->format);
+ assert(format_desc);
+
+ dst_type = lp_depth_type(format_desc, src_type.width*src_type.length);
+
+ assert(dst_type.width == src_type.width);
+ assert(dst_type.length == src_type.length);
+
+#if 1
+ src = lp_build_clamped_float_to_unsigned_norm(builder,
+ src_type,
+ dst_type.width,
+ src);
+#else
+ lp_build_conv(builder, src_type, dst_type, &src, 1, &src, 1);
+#endif
+
+ lp_build_depth_test(builder,
+ state,
+ dst_type,
+ format_desc,
+ mask,
+ src,
+ dst_ptr);
+}
+
+
static struct lp_fragment_shader_variant *
-shader_generate(struct llvmpipe_screen *screen,
+shader_generate(struct llvmpipe_context *lp,
struct lp_fragment_shader *shader,
- const struct pipe_alpha_state *alpha)
+ const struct lp_fragment_shader_variant_key *key)
{
+ struct llvmpipe_screen *screen = llvmpipe_screen(lp->pipe.screen);
struct lp_fragment_shader_variant *variant;
const struct tgsi_token *tokens = shader->base.tokens;
union lp_type type;
#ifdef DEBUG
tgsi_dump(shader->base.tokens, 0);
- debug_printf("alpha.enabled = %u\n", alpha->enabled);
- debug_printf("alpha.func = %s\n", debug_dump_func(alpha->func, TRUE));
- debug_printf("alpha.ref_value = %f\n", alpha->ref_value);
+ debug_printf("depth.enabled = %u\n", key->depth.enabled);
+ debug_printf("depth.func = %s\n", debug_dump_func(key->depth.func, TRUE));
+ debug_printf("depth.writemask = %u\n", key->depth.writemask);
+ debug_printf("depth.occlusion_count = %u\n", key->depth.occlusion_count);
+ debug_printf("alpha.enabled = %u\n", key->alpha.enabled);
+ debug_printf("alpha.func = %s\n", debug_dump_func(key->alpha.func, TRUE));
+ debug_printf("alpha.ref_value = %f\n", key->alpha.ref_value);
#endif
variant = CALLOC_STRUCT(lp_fragment_shader_variant);
return NULL;
variant->shader = shader;
- memcpy(&variant->alpha, alpha, sizeof *alpha);
+ memcpy(&variant->key, key, sizeof *key);
type.value = 0;
type.floating = TRUE; /* floating point values */
arg_types[5] = LLVMPointerType(elem_type, 0); /* consts */
arg_types[6] = LLVMPointerType(int_vec_type, 0); /* mask */
arg_types[7] = LLVMPointerType(vec_type, 0); /* color */
- arg_types[8] = LLVMPointerType(vec_type, 0); /* depth */
+ arg_types[8] = LLVMPointerType(int_vec_type, 0); /* depth */
arg_types[9] = LLVMPointerType(LLVMInt8Type(), 0); /* samplers */
func_type = LLVMFunctionType(LLVMVoidType(), arg_types, Elements(arg_types), 0);
mask = LLVMBuildLoad(builder, mask_ptr, "");
+ /* FIXME:
+ early_depth_test =
+ lp->depth_stencil->depth.enabled &&
+ lp->framebuffer.zsbuf &&
+ !lp->depth_stencil->alpha.enabled &&
+ !lp->fs->info.uses_kill &&
+ !lp->fs->info.writes_z;
+ */
+
memset(outputs, 0, sizeof outputs);
lp_build_tgsi_soa(builder, tokens, type, &mask,
}
case TGSI_SEMANTIC_POSITION:
- if(chan == 3)
- LLVMBuildStore(builder, outputs[attrib][chan], depth_ptr);
+ if(chan == 2)
+ pos[2] = outputs[attrib][chan];
break;
}
}
}
}
+ depth_test_generate(lp, builder, &key->depth,
+ type, &mask,
+ pos[2], depth_ptr);
+
if(mask)
LLVMBuildStore(builder, mask, mask_ptr);
llvmpipe_create_fs_state(struct pipe_context *pipe,
const struct pipe_shader_state *templ)
{
- struct llvmpipe_screen *screen = llvmpipe_screen(pipe->screen);
struct lp_fragment_shader *shader;
shader = CALLOC_STRUCT(lp_fragment_shader);
/* we need to keep a local copy of the tokens */
shader->base.tokens = tgsi_dup_tokens(templ->tokens);
- shader->screen = screen;
-
return shader;
}
void
llvmpipe_delete_fs_state(struct pipe_context *pipe, void *fs)
{
+ struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
+ struct llvmpipe_screen *screen = llvmpipe_screen(pipe->screen);
struct lp_fragment_shader *shader = fs;
struct lp_fragment_shader_variant *variant;
- struct llvmpipe_screen *screen = shader->screen;
- assert(fs != llvmpipe_context(pipe)->fs);
+ assert(fs != llvmpipe->fs);
variant = shader->variants;
while(variant) {
void llvmpipe_update_fs(struct llvmpipe_context *lp)
{
struct lp_fragment_shader *shader = lp->fs;
- const struct pipe_alpha_state *alpha = &lp->depth_stencil->alpha;
+ struct lp_fragment_shader_variant_key key;
struct lp_fragment_shader_variant *variant;
+ memset(&key, 0, sizeof key);
+ memcpy(&key.depth, &lp->depth_stencil->depth, sizeof &key.depth);
+ memcpy(&key.alpha, &lp->depth_stencil->alpha, sizeof &key.alpha);
+
variant = shader->variants;
while(variant) {
- if(memcmp(&variant->alpha, alpha, sizeof *alpha) == 0)
+ if(memcmp(&variant->key, &key, sizeof key) == 0)
break;
variant = variant->next;
}
if(!variant)
- variant = shader_generate(shader->screen, shader, alpha);
+ variant = shader_generate(lp, shader, &key);
shader->current = variant;
}
projects / mesa.git / commitdiff