Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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. }
  1008.