← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/gallium/drivers/softpipe/sp_quad_depth_test.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/softpipe/sp_quad_depth_test.c
32
32
 
33
33
#include "pipe/p_defines.h"
34
34
#include "util/u_format.h"
 
35
#include "util/u_math.h"
35
36
#include "util/u_memory.h"
36
37
#include "tgsi/tgsi_scan.h"
37
38
#include "sp_context.h"
77
78
      }
78
79
      break;
79
80
   case PIPE_FORMAT_Z24X8_UNORM:
80
 
   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 
81
   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
81
82
      for (j = 0; j < QUAD_SIZE; j++) {
82
83
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
83
84
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
86
87
      }
87
88
      break;
88
89
   case PIPE_FORMAT_X8Z24_UNORM:
89
 
   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 
90
   case PIPE_FORMAT_S8_UINT_Z24_UNORM:
90
91
      for (j = 0; j < QUAD_SIZE; j++) {
91
92
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
92
93
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
94
95
         data->stencilVals[j] = tile->data.depth32[y][x] & 0xff;
95
96
      }
96
97
      break;
97
 
   case PIPE_FORMAT_S8_USCALED:
 
98
   case PIPE_FORMAT_S8_UINT:
98
99
      for (j = 0; j < QUAD_SIZE; j++) {
99
100
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
100
101
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
102
103
         data->stencilVals[j] = tile->data.stencil8[y][x];
103
104
      }
104
105
      break;
 
106
   case PIPE_FORMAT_Z32_FLOAT:
 
107
      for (j = 0; j < QUAD_SIZE; j++) {
 
108
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
 
109
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
 
110
         data->bzzzz[j] = tile->data.depth32[y][x];
 
111
      }
 
112
      break;
 
113
   case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
 
114
      for (j = 0; j < QUAD_SIZE; j++) {
 
115
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
 
116
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
 
117
         data->bzzzz[j] = tile->data.depth64[y][x] & 0xffffffff;
 
118
         data->stencilVals[j] = (tile->data.depth64[y][x] >> 32) & 0xff;
 
119
      }
 
120
      break;
105
121
   default:
106
122
      assert(0);
107
123
   }
163
179
      }
164
180
      break;
165
181
   case PIPE_FORMAT_Z24X8_UNORM:
166
 
   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 
182
   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
167
183
      {
168
184
         float scale = (float) ((1 << 24) - 1);
169
185
 
173
189
      }
174
190
      break;
175
191
   case PIPE_FORMAT_X8Z24_UNORM:
176
 
   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 
192
   case PIPE_FORMAT_S8_UINT_Z24_UNORM:
177
193
      {
178
194
         float scale = (float) ((1 << 24) - 1);
179
195
 
182
198
         }
183
199
      }
184
200
      break;
 
201
   case PIPE_FORMAT_Z32_FLOAT:
 
202
   case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
 
203
      {
 
204
         union fi fui;
 
205
 
 
206
         for (j = 0; j < QUAD_SIZE; j++) {
 
207
            fui.f = quad->output.depth[j];
 
208
            data->qzzzz[j] = fui.ui;
 
209
         }
 
210
      }
 
211
      break;
185
212
   default:
186
213
      assert(0);
187
214
   }
189
216
 
190
217
 
191
218
/**
192
 
 * Compute the depth_data::shader_stencil_refs[] values from the float fragment stencil values.
 
219
 * Compute the depth_data::shader_stencil_refs[] values from the float
 
220
 * fragment stencil values.
193
221
 */
194
222
static void
195
223
convert_quad_stencil( struct depth_data *data, 
202
230
    */
203
231
   switch (data->format) {
204
232
   case PIPE_FORMAT_Z24X8_UNORM:
205
 
   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 
233
   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
206
234
   case PIPE_FORMAT_X8Z24_UNORM:
207
 
   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
208
 
      {
209
 
         for (j = 0; j < QUAD_SIZE; j++) {
210
 
            data->shader_stencil_refs[j] = ((unsigned)(quad->output.stencil[j]));
211
 
         }
 
235
   case PIPE_FORMAT_S8_UINT_Z24_UNORM:
 
236
   case PIPE_FORMAT_S8_UINT:
 
237
   case PIPE_FORMAT_Z32_FLOAT:
 
238
   case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
 
239
      for (j = 0; j < QUAD_SIZE; j++) {
 
240
         data->shader_stencil_refs[j] = ((unsigned)(quad->output.stencil[j]));
212
241
      }
213
242
      break;
214
243
   default:
216
245
   }
217
246
}
218
247
 
 
248
 
219
249
/**
220
250
 * Write data->bzzzz[] values and data->stencilVals into the Z/stencil buffer.
221
251
 */
243
273
         tile->data.depth32[y][x] = data->bzzzz[j];
244
274
      }
245
275
      break;
246
 
   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 
276
   case PIPE_FORMAT_Z24_UNORM_S8_UINT:
247
277
      for (j = 0; j < QUAD_SIZE; j++) {
248
278
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
249
279
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
250
280
         tile->data.depth32[y][x] = (data->stencilVals[j] << 24) | data->bzzzz[j];
251
281
      }
252
282
      break;
253
 
   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 
283
   case PIPE_FORMAT_S8_UINT_Z24_UNORM:
254
284
      for (j = 0; j < QUAD_SIZE; j++) {
255
285
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
256
286
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
264
294
         tile->data.depth32[y][x] = data->bzzzz[j] << 8;
265
295
      }
266
296
      break;
267
 
   case PIPE_FORMAT_S8_USCALED:
 
297
   case PIPE_FORMAT_S8_UINT:
268
298
      for (j = 0; j < QUAD_SIZE; j++) {
269
299
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
270
300
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
271
301
         tile->data.stencil8[y][x] = data->stencilVals[j];
272
302
      }
273
303
      break;
274
 
 
 
304
   case PIPE_FORMAT_Z32_FLOAT:
 
305
      for (j = 0; j < QUAD_SIZE; j++) {
 
306
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
 
307
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
 
308
         tile->data.depth32[y][x] = data->bzzzz[j];
 
309
      }
 
310
      break;
 
311
   case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
 
312
      for (j = 0; j < QUAD_SIZE; j++) {
 
313
         int x = quad->input.x0 % TILE_SIZE + (j & 1);
 
314
         int y = quad->input.y0 % TILE_SIZE + (j >> 1);
 
315
         tile->data.depth64[y][x] = (uint64_t)data->bzzzz[j] | ((uint64_t)data->stencilVals[j] << 32);
 
316
      }
 
317
      break;
275
318
   default:
276
319
      assert(0);
277
320
   }
628
671
 
629
672
 
630
673
#define ALPHATEST( FUNC, COMP )                                         \
631
 
   static int                                                           \
 
674
   static unsigned                                                      \
632
675
   alpha_test_quads_##FUNC( struct quad_stage *qs,                      \
633
676
                           struct quad_header *quads[],                 \
634
677
                           unsigned nr )                                \
667
710
 
668
711
/* XXX: Incorporate into shader using KILP.
669
712
 */
670
 
static int
 
713
static unsigned
671
714
alpha_test_quads(struct quad_stage *qs, 
672
715
                 struct quad_header *quads[], 
673
716
                 unsigned nr)
677
720
      return alpha_test_quads_LESS( qs, quads, nr );
678
721
   case PIPE_FUNC_EQUAL:
679
722
      return alpha_test_quads_EQUAL( qs, quads, nr );
680
 
      break;
681
723
   case PIPE_FUNC_LEQUAL:
682
724
      return alpha_test_quads_LEQUAL( qs, quads, nr );
683
725
   case PIPE_FUNC_GREATER:
726
768
                          unsigned nr)
727
769
{
728
770
   unsigned i, pass = 0;
729
 
   const struct sp_fragment_shader *fs = qs->softpipe->fs;
730
 
   boolean interp_depth = !fs->info.writes_z;
731
 
   boolean shader_stencil_ref = fs->info.writes_stencil;
 
771
   const struct tgsi_shader_info *fsInfo = &qs->softpipe->fs_variant->info;
 
772
   boolean interp_depth = !fsInfo->writes_z;
 
773
   boolean shader_stencil_ref = fsInfo->writes_stencil;
732
774
   struct depth_data data;
733
775
 
734
776
   data.use_shader_stencil_refs = FALSE;
837
879
                  struct quad_header *quads[],
838
880
                  unsigned nr)
839
881
{
840
 
   boolean interp_depth = !qs->softpipe->fs->info.writes_z;
 
882
   const struct tgsi_shader_info *fsInfo = &qs->softpipe->fs_variant->info;
 
883
 
 
884
   boolean interp_depth = !fsInfo->writes_z;
841
885
 
842
886
   boolean alpha = qs->softpipe->depth_stencil->alpha.enabled;
843
887