← Back to branch summary

~ubuntu-branches/ubuntu/raring/mesa/raring-proposed

« back to all changes in this revision

Viewing changes to src/mesa/state_tracker/st_program.c

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2011-06-19 21:26:00 UTC
  • mfrom: (1.6.1 upstream) (3.3.18 sid)
  • mto: (3.3.20 sid)
  • mto: This revision was merged to the branch mainline in revision 145.
  • Revision ID: james.westby@ubuntu.com-20110619212600-rleaapdmnbtstekb
Tags: 7.11~0-2
Thank you sbuild for giving a green light when that's not actually the
case. Fix missing Pre-Depends for the libegl1-mesa-drivers package
(multiarch-support).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/state_tracker/st_program.c
32
32
 
33
33
 
34
34
#include "main/imports.h"
 
35
#include "main/hash.h"
 
36
#include "main/mfeatures.h"
35
37
#include "main/mtypes.h"
 
38
#include "program/prog_parameter.h"
36
39
#include "program/prog_print.h"
37
40
#include "program/programopt.h"
38
41
 
44
47
#include "tgsi/tgsi_ureg.h"
45
48
 
46
49
#include "st_debug.h"
 
50
#include "st_cb_bitmap.h"
 
51
#include "st_cb_drawpixels.h"
47
52
#include "st_context.h"
48
53
#include "st_program.h"
49
54
#include "st_mesa_to_tgsi.h"
52
57
 
53
58
 
54
59
/**
 
60
 * Delete a vertex program variant.  Note the caller must unlink
 
61
 * the variant from the linked list.
 
62
 */
 
63
static void
 
64
delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
 
65
{
 
66
   if (vpv->driver_shader) 
 
67
      cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
 
68
      
 
69
#if FEATURE_feedback || FEATURE_rastpos
 
70
   if (vpv->draw_shader)
 
71
      draw_delete_vertex_shader( st->draw, vpv->draw_shader );
 
72
#endif
 
73
      
 
74
   if (vpv->tgsi.tokens)
 
75
      st_free_tokens(vpv->tgsi.tokens);
 
76
      
 
77
   FREE( vpv );
 
78
}
 
79
 
 
80
 
 
81
 
 
82
/**
55
83
 * Clean out any old compilations:
56
84
 */
57
85
void
58
 
st_vp_release_varients( struct st_context *st,
 
86
st_release_vp_variants( struct st_context *st,
59
87
                        struct st_vertex_program *stvp )
60
88
{
61
 
   struct st_vp_varient *vpv;
62
 
 
63
 
   for (vpv = stvp->varients; vpv; ) {
64
 
      struct st_vp_varient *next = vpv->next;
65
 
 
66
 
      if (vpv->driver_shader) 
67
 
         cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
68
 
      
69
 
#if FEATURE_feedback || FEATURE_rastpos
70
 
      if (vpv->draw_shader)
71
 
         draw_delete_vertex_shader( st->draw, vpv->draw_shader );
72
 
#endif
73
 
      
74
 
      if (vpv->tgsi.tokens)
75
 
         st_free_tokens(vpv->tgsi.tokens);
76
 
      
77
 
      FREE( vpv );
78
 
 
 
89
   struct st_vp_variant *vpv;
 
90
 
 
91
   for (vpv = stvp->variants; vpv; ) {
 
92
      struct st_vp_variant *next = vpv->next;
 
93
      delete_vp_variant(st, vpv);
79
94
      vpv = next;
80
95
   }
81
96
 
82
 
   stvp->varients = NULL;
 
97
   stvp->variants = NULL;
 
98
}
 
99
 
 
100
 
 
101
 
 
102
/**
 
103
 * Delete a fragment program variant.  Note the caller must unlink
 
104
 * the variant from the linked list.
 
105
 */
 
106
static void
 
107
delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)
 
108
{
 
109
   if (fpv->driver_shader) 
 
110
      cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
 
111
   if (fpv->parameters)
 
112
      _mesa_free_parameter_list(fpv->parameters);
 
113
      
 
114
   FREE(fpv);
 
115
}
 
116
 
 
117
 
 
118
/**
 
119
 * Free all variants of a fragment program.
 
120
 */
 
121
void
 
122
st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)
 
123
{
 
124
   struct st_fp_variant *fpv;
 
125
 
 
126
   for (fpv = stfp->variants; fpv; ) {
 
127
      struct st_fp_variant *next = fpv->next;
 
128
      delete_fp_variant(st, fpv);
 
129
      fpv = next;
 
130
   }
 
131
 
 
132
   stfp->variants = NULL;
 
133
}
 
134
 
 
135
 
 
136
/**
 
137
 * Delete a geometry program variant.  Note the caller must unlink
 
138
 * the variant from the linked list.
 
139
 */
 
140
static void
 
141
delete_gp_variant(struct st_context *st, struct st_gp_variant *gpv)
 
142
{
 
143
   if (gpv->driver_shader) 
 
144
      cso_delete_geometry_shader(st->cso_context, gpv->driver_shader);
 
145
      
 
146
   FREE(gpv);
 
147
}
 
148
 
 
149
 
 
150
/**
 
151
 * Free all variants of a geometry program.
 
152
 */
 
153
void
 
154
st_release_gp_variants(struct st_context *st, struct st_geometry_program *stgp)
 
155
{
 
156
   struct st_gp_variant *gpv;
 
157
 
 
158
   for (gpv = stgp->variants; gpv; ) {
 
159
      struct st_gp_variant *next = gpv->next;
 
160
      delete_gp_variant(st, gpv);
 
161
      gpv = next;
 
162
   }
 
163
 
 
164
   stgp->variants = NULL;
83
165
}
84
166
 
85
167
 
92
174
 * \param tokensOut  destination for TGSI tokens
93
175
 * \return  pointer to cached pipe_shader object.
94
176
 */
95
 
void
 
177
static void
96
178
st_prepare_vertex_program(struct st_context *st,
97
179
                            struct st_vertex_program *stvp)
98
180
{
196
278
}
197
279
 
198
280
 
199
 
struct st_vp_varient *
 
281
/**
 
282
 * Translate a vertex program to create a new variant.
 
283
 */
 
284
static struct st_vp_variant *
200
285
st_translate_vertex_program(struct st_context *st,
201
286
                            struct st_vertex_program *stvp,
202
 
                            const struct st_vp_varient_key *key)
 
287
                            const struct st_vp_variant_key *key)
203
288
{
204
 
   struct st_vp_varient *vpv = CALLOC_STRUCT(st_vp_varient);
 
289
   struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
205
290
   struct pipe_context *pipe = st->pipe;
206
291
   struct ureg_program *ureg;
207
292
   enum pipe_error error;
208
293
   unsigned num_outputs;
209
294
 
 
295
   st_prepare_vertex_program( st, stvp );
 
296
 
210
297
   _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
211
298
   _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);
212
299
 
231
318
      debug_printf("\n");
232
319
   }
233
320
 
234
 
   error = 
235
 
      st_translate_mesa_program(st->ctx,
236
 
                                TGSI_PROCESSOR_VERTEX,
237
 
                                ureg,
238
 
                                &stvp->Base.Base,
239
 
                                /* inputs */
240
 
                                vpv->num_inputs,
241
 
                                stvp->input_to_index,
242
 
                                NULL, /* input semantic name */
243
 
                                NULL, /* input semantic index */
244
 
                                NULL,
245
 
                                /* outputs */
246
 
                                num_outputs,
247
 
                                stvp->result_to_output,
248
 
                                stvp->output_semantic_name,
249
 
                                stvp->output_semantic_index,
250
 
                                key->passthrough_edgeflags );
 
321
   error = st_translate_mesa_program(st->ctx,
 
322
                                     TGSI_PROCESSOR_VERTEX,
 
323
                                     ureg,
 
324
                                     &stvp->Base.Base,
 
325
                                     /* inputs */
 
326
                                     vpv->num_inputs,
 
327
                                     stvp->input_to_index,
 
328
                                     NULL, /* input semantic name */
 
329
                                     NULL, /* input semantic index */
 
330
                                     NULL,
 
331
                                     /* outputs */
 
332
                                     num_outputs,
 
333
                                     stvp->result_to_output,
 
334
                                     stvp->output_semantic_name,
 
335
                                     stvp->output_semantic_index,
 
336
                                     key->passthrough_edgeflags );
251
337
 
252
338
   if (error)
253
339
      goto fail;
277
363
}
278
364
 
279
365
 
280
 
 
281
 
/**
282
 
 * Translate a Mesa fragment shader into a TGSI shader.
283
 
 * \return  pointer to cached pipe_shader object.
284
 
 */
285
 
void
 
366
/**
 
367
 * Find/create a vertex program variant.
 
368
 */
 
369
struct st_vp_variant *
 
370
st_get_vp_variant(struct st_context *st,
 
371
                  struct st_vertex_program *stvp,
 
372
                  const struct st_vp_variant_key *key)
 
373
{
 
374
   struct st_vp_variant *vpv;
 
375
 
 
376
   /* Search for existing variant */
 
377
   for (vpv = stvp->variants; vpv; vpv = vpv->next) {
 
378
      if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
 
379
         break;
 
380
      }
 
381
   }
 
382
 
 
383
   if (!vpv) {
 
384
      /* create now */
 
385
      vpv = st_translate_vertex_program(st, stvp, key);
 
386
      if (vpv) {
 
387
         /* insert into list */
 
388
         vpv->next = stvp->variants;
 
389
         stvp->variants = vpv;
 
390
      }
 
391
   }
 
392
 
 
393
   return vpv;
 
394
}
 
395
 
 
396
 
 
397
/**
 
398
 * Translate a Mesa fragment shader into a TGSI shader using extra info in
 
399
 * the key.
 
400
 * \return  new fragment program variant
 
401
 */
 
402
static struct st_fp_variant *
286
403
st_translate_fragment_program(struct st_context *st,
287
 
                              struct st_fragment_program *stfp )
 
404
                              struct st_fragment_program *stfp,
 
405
                              const struct st_fp_variant_key *key)
288
406
{
289
407
   struct pipe_context *pipe = st->pipe;
290
 
   GLuint outputMapping[FRAG_RESULT_MAX];
291
 
   GLuint inputMapping[FRAG_ATTRIB_MAX];
292
 
   GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
293
 
   GLuint attr;
294
 
   enum pipe_error error;
295
 
   const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
296
 
   struct ureg_program *ureg;
297
 
 
298
 
   ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
299
 
   ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
300
 
   uint fs_num_inputs = 0;
301
 
 
302
 
   ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
303
 
   ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
304
 
   uint fs_num_outputs = 0;
305
 
 
306
 
   _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
307
 
 
308
 
   /*
309
 
    * Convert Mesa program inputs to TGSI input register semantics.
310
 
    */
311
 
   for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
312
 
      if (inputsRead & (1 << attr)) {
313
 
         const GLuint slot = fs_num_inputs++;
314
 
 
315
 
         inputMapping[attr] = slot;
316
 
 
317
 
         switch (attr) {
318
 
         case FRAG_ATTRIB_WPOS:
319
 
            input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
320
 
            input_semantic_index[slot] = 0;
321
 
            interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
322
 
            break;
323
 
         case FRAG_ATTRIB_COL0:
324
 
            input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
325
 
            input_semantic_index[slot] = 0;
326
 
            interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
327
 
            break;
328
 
         case FRAG_ATTRIB_COL1:
329
 
            input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
330
 
            input_semantic_index[slot] = 1;
331
 
            interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
332
 
            break;
333
 
         case FRAG_ATTRIB_FOGC:
334
 
            input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
335
 
            input_semantic_index[slot] = 0;
336
 
            interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
337
 
            break;
338
 
         case FRAG_ATTRIB_FACE:
339
 
            input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
340
 
            input_semantic_index[slot] = 0;
341
 
            interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
342
 
            break;
343
 
            /* In most cases, there is nothing special about these
344
 
             * inputs, so adopt a convention to use the generic
345
 
             * semantic name and the mesa FRAG_ATTRIB_ number as the
346
 
             * index. 
347
 
             * 
348
 
             * All that is required is that the vertex shader labels
349
 
             * its own outputs similarly, and that the vertex shader
350
 
             * generates at least every output required by the
351
 
             * fragment shader plus fixed-function hardware (such as
352
 
             * BFC).
353
 
             * 
354
 
             * There is no requirement that semantic indexes start at
355
 
             * zero or be restricted to a particular range -- nobody
356
 
             * should be building tables based on semantic index.
357
 
             */
358
 
         case FRAG_ATTRIB_PNTC:
359
 
         case FRAG_ATTRIB_TEX0:
360
 
         case FRAG_ATTRIB_TEX1:
361
 
         case FRAG_ATTRIB_TEX2:
362
 
         case FRAG_ATTRIB_TEX3:
363
 
         case FRAG_ATTRIB_TEX4:
364
 
         case FRAG_ATTRIB_TEX5:
365
 
         case FRAG_ATTRIB_TEX6:
366
 
         case FRAG_ATTRIB_TEX7:
367
 
         case FRAG_ATTRIB_VAR0:
368
 
         default:
369
 
            /* Actually, let's try and zero-base this just for
370
 
             * readability of the generated TGSI.
371
 
             */
372
 
            assert(attr >= FRAG_ATTRIB_TEX0);
373
 
            input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
374
 
            input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
375
 
            if (attr == FRAG_ATTRIB_PNTC)
376
 
               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
377
 
            else
 
408
   struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
 
409
   GLboolean deleteFP = GL_FALSE;
 
410
 
 
411
   if (!variant)
 
412
      return NULL;
 
413
 
 
414
   assert(!(key->bitmap && key->drawpixels));
 
415
 
 
416
#if FEATURE_drawpix
 
417
   if (key->bitmap) {
 
418
      /* glBitmap drawing */
 
419
      struct gl_fragment_program *fp; /* we free this temp program below */
 
420
 
 
421
      st_make_bitmap_fragment_program(st, &stfp->Base,
 
422
                                      &fp, &variant->bitmap_sampler);
 
423
 
 
424
      variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
 
425
      stfp = st_fragment_program(fp);
 
426
      deleteFP = GL_TRUE;
 
427
   }
 
428
   else if (key->drawpixels) {
 
429
      /* glDrawPixels drawing */
 
430
      struct gl_fragment_program *fp; /* we free this temp program below */
 
431
 
 
432
      if (key->drawpixels_z || key->drawpixels_stencil) {
 
433
         fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,
 
434
                                                key->drawpixels_stencil);
 
435
      }
 
436
      else {
 
437
         /* RGBA */
 
438
         st_make_drawpix_fragment_program(st, &stfp->Base, &fp);
 
439
         variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
 
440
         deleteFP = GL_TRUE;
 
441
      }
 
442
      stfp = st_fragment_program(fp);
 
443
   }
 
444
#endif
 
445
 
 
446
   if (!stfp->tgsi.tokens) {
 
447
      /* need to translate Mesa instructions to TGSI now */
 
448
      GLuint outputMapping[FRAG_RESULT_MAX];
 
449
      GLuint inputMapping[FRAG_ATTRIB_MAX];
 
450
      GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
 
451
      GLuint attr;
 
452
      enum pipe_error error;
 
453
      const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
 
454
      struct ureg_program *ureg;
 
455
      GLboolean write_all = GL_FALSE;
 
456
 
 
457
      ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
 
458
      ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
 
459
      uint fs_num_inputs = 0;
 
460
 
 
461
      ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
 
462
      ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
 
463
      uint fs_num_outputs = 0;
 
464
 
 
465
 
 
466
      _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
 
467
 
 
468
      /*
 
469
       * Convert Mesa program inputs to TGSI input register semantics.
 
470
       */
 
471
      for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
 
472
         if (inputsRead & (1 << attr)) {
 
473
            const GLuint slot = fs_num_inputs++;
 
474
 
 
475
            inputMapping[attr] = slot;
 
476
 
 
477
            switch (attr) {
 
478
            case FRAG_ATTRIB_WPOS:
 
479
               input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 
480
               input_semantic_index[slot] = 0;
 
481
               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 
482
               break;
 
483
            case FRAG_ATTRIB_COL0:
 
484
               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 
485
               input_semantic_index[slot] = 0;
 
486
               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 
487
               break;
 
488
            case FRAG_ATTRIB_COL1:
 
489
               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 
490
               input_semantic_index[slot] = 1;
 
491
               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 
492
               break;
 
493
            case FRAG_ATTRIB_FOGC:
 
494
               input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 
495
               input_semantic_index[slot] = 0;
378
496
               interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
379
 
            break;
380
 
         }
381
 
      }
382
 
      else {
383
 
         inputMapping[attr] = -1;
384
 
      }
385
 
   }
386
 
 
387
 
   /*
388
 
    * Semantics and mapping for outputs
389
 
    */
390
 
   {
391
 
      uint numColors = 0;
392
 
      GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
393
 
 
394
 
      /* if z is written, emit that first */
395
 
      if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
396
 
         fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
397
 
         fs_output_semantic_index[fs_num_outputs] = 0;
398
 
         outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
399
 
         fs_num_outputs++;
400
 
         outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
401
 
      }
402
 
 
403
 
      if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
404
 
         fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
405
 
         fs_output_semantic_index[fs_num_outputs] = 0;
406
 
         outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
407
 
         fs_num_outputs++;
408
 
         outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
409
 
      }
410
 
 
411
 
      /* handle remaning outputs (color) */
412
 
      for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
413
 
         if (outputsWritten & BITFIELD64_BIT(attr)) {
414
 
            switch (attr) {
415
 
            case FRAG_RESULT_DEPTH:
416
 
            case FRAG_RESULT_STENCIL:
417
 
               /* handled above */
418
 
               assert(0);
419
 
               break;
 
497
               break;
 
498
            case FRAG_ATTRIB_FACE:
 
499
               input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
 
500
               input_semantic_index[slot] = 0;
 
501
               interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 
502
               break;
 
503
               /* In most cases, there is nothing special about these
 
504
                * inputs, so adopt a convention to use the generic
 
505
                * semantic name and the mesa FRAG_ATTRIB_ number as the
 
506
                * index. 
 
507
                * 
 
508
                * All that is required is that the vertex shader labels
 
509
                * its own outputs similarly, and that the vertex shader
 
510
                * generates at least every output required by the
 
511
                * fragment shader plus fixed-function hardware (such as
 
512
                * BFC).
 
513
                * 
 
514
                * There is no requirement that semantic indexes start at
 
515
                * zero or be restricted to a particular range -- nobody
 
516
                * should be building tables based on semantic index.
 
517
                */
 
518
            case FRAG_ATTRIB_PNTC:
 
519
            case FRAG_ATTRIB_TEX0:
 
520
            case FRAG_ATTRIB_TEX1:
 
521
            case FRAG_ATTRIB_TEX2:
 
522
            case FRAG_ATTRIB_TEX3:
 
523
            case FRAG_ATTRIB_TEX4:
 
524
            case FRAG_ATTRIB_TEX5:
 
525
            case FRAG_ATTRIB_TEX6:
 
526
            case FRAG_ATTRIB_TEX7:
 
527
            case FRAG_ATTRIB_VAR0:
420
528
            default:
421
 
               assert(attr == FRAG_RESULT_COLOR ||
422
 
                      (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
423
 
               fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
424
 
               fs_output_semantic_index[fs_num_outputs] = numColors;
425
 
               outputMapping[attr] = fs_num_outputs;
426
 
               numColors++;
 
529
               /* Actually, let's try and zero-base this just for
 
530
                * readability of the generated TGSI.
 
531
                */
 
532
               assert(attr >= FRAG_ATTRIB_TEX0);
 
533
               input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
 
534
               input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 
535
               if (attr == FRAG_ATTRIB_PNTC)
 
536
                  interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 
537
               else
 
538
                  interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
427
539
               break;
428
540
            }
429
 
 
430
 
            fs_num_outputs++;
431
 
         }
432
 
      }
433
 
   }
434
 
 
435
 
   ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
436
 
   if (ureg == NULL)
437
 
      return;
438
 
 
439
 
   if (ST_DEBUG & DEBUG_MESA) {
440
 
      _mesa_print_program(&stfp->Base.Base);
441
 
      _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
442
 
      debug_printf("\n");
443
 
   }
444
 
 
445
 
   error = 
446
 
      st_translate_mesa_program(st->ctx,
447
 
                                TGSI_PROCESSOR_FRAGMENT,
448
 
                                ureg,
449
 
                                &stfp->Base.Base,
450
 
                                /* inputs */
451
 
                                fs_num_inputs,
452
 
                                inputMapping,
453
 
                                input_semantic_name,
454
 
                                input_semantic_index,
455
 
                                interpMode,
456
 
                                /* outputs */
457
 
                                fs_num_outputs,
458
 
                                outputMapping,
459
 
                                fs_output_semantic_name,
460
 
                                fs_output_semantic_index, FALSE );
461
 
 
462
 
   stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
463
 
   ureg_destroy( ureg );
464
 
   stfp->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
 
541
         }
 
542
         else {
 
543
            inputMapping[attr] = -1;
 
544
         }
 
545
      }
 
546
 
 
547
      /*
 
548
       * Semantics and mapping for outputs
 
549
       */
 
550
      {
 
551
         uint numColors = 0;
 
552
         GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
 
553
 
 
554
         /* if z is written, emit that first */
 
555
         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
 
556
            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
 
557
            fs_output_semantic_index[fs_num_outputs] = 0;
 
558
            outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
 
559
            fs_num_outputs++;
 
560
            outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
 
561
         }
 
562
 
 
563
         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
 
564
            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
 
565
            fs_output_semantic_index[fs_num_outputs] = 0;
 
566
            outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
 
567
            fs_num_outputs++;
 
568
            outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
 
569
         }
 
570
 
 
571
         /* handle remaning outputs (color) */
 
572
         for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
 
573
            if (outputsWritten & BITFIELD64_BIT(attr)) {
 
574
               switch (attr) {
 
575
               case FRAG_RESULT_DEPTH:
 
576
               case FRAG_RESULT_STENCIL:
 
577
                  /* handled above */
 
578
                  assert(0);
 
579
                  break;
 
580
               case FRAG_RESULT_COLOR:
 
581
                  write_all = GL_TRUE; /* fallthrough */
 
582
               default:
 
583
                  assert(attr == FRAG_RESULT_COLOR ||
 
584
                         (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
 
585
                  fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
 
586
                  fs_output_semantic_index[fs_num_outputs] = numColors;
 
587
                  outputMapping[attr] = fs_num_outputs;
 
588
                  numColors++;
 
589
                  break;
 
590
               }
 
591
 
 
592
               fs_num_outputs++;
 
593
            }
 
594
         }
 
595
      }
 
596
 
 
597
      ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
 
598
      if (ureg == NULL)
 
599
         return NULL;
 
600
 
 
601
      if (ST_DEBUG & DEBUG_MESA) {
 
602
         _mesa_print_program(&stfp->Base.Base);
 
603
         _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
 
604
         debug_printf("\n");
 
605
      }
 
606
      if (write_all == GL_TRUE)
 
607
         ureg_property_fs_color0_writes_all_cbufs(ureg, 1);
 
608
 
 
609
      error = st_translate_mesa_program(st->ctx,
 
610
                                        TGSI_PROCESSOR_FRAGMENT,
 
611
                                        ureg,
 
612
                                        &stfp->Base.Base,
 
613
                                        /* inputs */
 
614
                                        fs_num_inputs,
 
615
                                        inputMapping,
 
616
                                        input_semantic_name,
 
617
                                        input_semantic_index,
 
618
                                        interpMode,
 
619
                                        /* outputs */
 
620
                                        fs_num_outputs,
 
621
                                        outputMapping,
 
622
                                        fs_output_semantic_name,
 
623
                                        fs_output_semantic_index, FALSE );
 
624
 
 
625
      stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
 
626
      ureg_destroy( ureg );
 
627
   }
 
628
 
 
629
   /* fill in variant */
 
630
   variant->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
 
631
   variant->key = *key;
465
632
 
466
633
   if (ST_DEBUG & DEBUG_TGSI) {
467
634
      tgsi_dump( stfp->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
468
635
      debug_printf("\n");
469
636
   }
470
 
}
471
 
 
472
 
void
 
637
 
 
638
   if (deleteFP) {
 
639
      /* Free the temporary program made above */
 
640
      struct gl_fragment_program *fp = &stfp->Base;
 
641
      _mesa_reference_fragprog(st->ctx, &fp, NULL);
 
642
   }
 
643
 
 
644
   return variant;
 
645
}
 
646
 
 
647
 
 
648
/**
 
649
 * Translate fragment program if needed.
 
650
 */
 
651
struct st_fp_variant *
 
652
st_get_fp_variant(struct st_context *st,
 
653
                  struct st_fragment_program *stfp,
 
654
                  const struct st_fp_variant_key *key)
 
655
{
 
656
   struct st_fp_variant *fpv;
 
657
 
 
658
   /* Search for existing variant */
 
659
   for (fpv = stfp->variants; fpv; fpv = fpv->next) {
 
660
      if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
 
661
         break;
 
662
      }
 
663
   }
 
664
 
 
665
   if (!fpv) {
 
666
      /* create new */
 
667
      fpv = st_translate_fragment_program(st, stfp, key);
 
668
      if (fpv) {
 
669
         /* insert into list */
 
670
         fpv->next = stfp->variants;
 
671
         stfp->variants = fpv;
 
672
      }
 
673
   }
 
674
 
 
675
   return fpv;
 
676
}
 
677
 
 
678
 
 
679
/**
 
680
 * Translate a geometry program to create a new variant.
 
681
 */
 
682
static struct st_gp_variant *
473
683
st_translate_geometry_program(struct st_context *st,
474
 
                              struct st_geometry_program *stgp)
 
684
                              struct st_geometry_program *stgp,
 
685
                              const struct st_gp_variant_key *key)
475
686
{
476
687
   GLuint inputMapping[GEOM_ATTRIB_MAX];
477
688
   GLuint outputMapping[GEOM_RESULT_MAX];
494
705
   GLuint maxSlot = 0;
495
706
   struct ureg_program *ureg;
496
707
 
 
708
   struct st_gp_variant *gpv;
 
709
 
 
710
   gpv = CALLOC_STRUCT(st_gp_variant);
 
711
   if (!gpv)
 
712
      return NULL;
 
713
 
497
714
   _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);
498
715
   _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_VARYING);
499
716
 
500
717
   ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
501
718
   if (ureg == NULL) {
502
 
      return;
 
719
      FREE(gpv);
 
720
      return NULL;
503
721
   }
504
722
 
505
723
   /* which vertex output goes to the first geometry input */
529
747
         } else
530
748
            ++gs_builtin_inputs;
531
749
 
532
 
#if 1
 
750
#if 0
533
751
         debug_printf("input map at %d = %d\n",
534
752
                      slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
535
753
#endif
580
798
    * mapping and the semantic information for each output.
581
799
    */
582
800
   for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
583
 
      if (stgp->Base.Base.OutputsWritten & (1 << attr)) {
 
801
      if (stgp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) {
584
802
         GLuint slot;
585
803
 
586
804
         slot = gs_num_outputs;
671
889
      st_free_tokens(stgp->tgsi.tokens);
672
890
      stgp->tgsi.tokens = NULL;
673
891
   }
674
 
   if (stgp->driver_shader) {
675
 
      cso_delete_geometry_shader(st->cso_context, stgp->driver_shader);
676
 
      stgp->driver_shader = NULL;
677
 
   }
678
892
 
679
893
   ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
680
894
   ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
681
895
   ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
682
896
 
683
 
   error  = st_translate_mesa_program(st->ctx,
684
 
                                      TGSI_PROCESSOR_GEOMETRY,
685
 
                                      ureg,
686
 
                                      &stgp->Base.Base,
687
 
                                      /* inputs */
688
 
                                      gs_num_inputs,
689
 
                                      inputMapping,
690
 
                                      stgp->input_semantic_name,
691
 
                                      stgp->input_semantic_index,
692
 
                                      NULL,
693
 
                                      /* outputs */
694
 
                                      gs_num_outputs,
695
 
                                      outputMapping,
696
 
                                      gs_output_semantic_name,
697
 
                                      gs_output_semantic_index,
698
 
                                      FALSE);
699
 
 
 
897
   error = st_translate_mesa_program(st->ctx,
 
898
                                     TGSI_PROCESSOR_GEOMETRY,
 
899
                                     ureg,
 
900
                                     &stgp->Base.Base,
 
901
                                     /* inputs */
 
902
                                     gs_num_inputs,
 
903
                                     inputMapping,
 
904
                                     stgp->input_semantic_name,
 
905
                                     stgp->input_semantic_index,
 
906
                                     NULL,
 
907
                                     /* outputs */
 
908
                                     gs_num_outputs,
 
909
                                     outputMapping,
 
910
                                     gs_output_semantic_name,
 
911
                                     gs_output_semantic_index,
 
912
                                     FALSE);
700
913
 
701
914
   stgp->num_inputs = gs_num_inputs;
702
915
   stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
703
916
   ureg_destroy( ureg );
704
 
   stgp->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
 
917
 
 
918
   /* fill in new variant */
 
919
   gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
 
920
   gpv->key = *key;
705
921
 
706
922
   if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
707
923
      _mesa_print_program(&stgp->Base.Base);
712
928
      tgsi_dump(stgp->tgsi.tokens, 0);
713
929
      debug_printf("\n");
714
930
   }
715
 
}
 
931
 
 
932
   return gpv;
 
933
}
 
934
 
 
935
 
 
936
/**
 
937
 * Get/create geometry program variant.
 
938
 */
 
939
struct st_gp_variant *
 
940
st_get_gp_variant(struct st_context *st,
 
941
                  struct st_geometry_program *stgp,
 
942
                  const struct st_gp_variant_key *key)
 
943
{
 
944
   struct st_gp_variant *gpv;
 
945
 
 
946
   /* Search for existing variant */
 
947
   for (gpv = stgp->variants; gpv; gpv = gpv->next) {
 
948
      if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
 
949
         break;
 
950
      }
 
951
   }
 
952
 
 
953
   if (!gpv) {
 
954
      /* create new */
 
955
      gpv = st_translate_geometry_program(st, stgp, key);
 
956
      if (gpv) {
 
957
         /* insert into list */
 
958
         gpv->next = stgp->variants;
 
959
         stgp->variants = gpv;
 
960
      }
 
961
   }
 
962
 
 
963
   return gpv;
 
964
}
 
965
 
 
966
 
 
967
 
716
968
 
717
969
/**
718
970
 * Debug- print current shader text
759
1011
      }
760
1012
   }
761
1013
}
 
1014
 
 
1015
 
 
1016
/**
 
1017
 * Vert/Geom/Frag programs have per-context variants.  Free all the
 
1018
 * variants attached to the given program which match the given context.
 
1019
 */
 
1020
static void
 
1021
destroy_program_variants(struct st_context *st, struct gl_program *program)
 
1022
{
 
1023
   if (!program)
 
1024
      return;
 
1025
 
 
1026
   switch (program->Target) {
 
1027
   case GL_VERTEX_PROGRAM_ARB:
 
1028
      {
 
1029
         struct st_vertex_program *stvp = (struct st_vertex_program *) program;
 
1030
         struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
 
1031
 
 
1032
         for (vpv = stvp->variants; vpv; ) {
 
1033
            struct st_vp_variant *next = vpv->next;
 
1034
            if (vpv->key.st == st) {
 
1035
               /* unlink from list */
 
1036
               *prevPtr = next;
 
1037
               /* destroy this variant */
 
1038
               delete_vp_variant(st, vpv);
 
1039
            }
 
1040
            else {
 
1041
               prevPtr = &vpv->next;
 
1042
            }
 
1043
            vpv = next;
 
1044
         }
 
1045
      }
 
1046
      break;
 
1047
   case GL_FRAGMENT_PROGRAM_ARB:
 
1048
      {
 
1049
         struct st_fragment_program *stfp =
 
1050
            (struct st_fragment_program *) program;
 
1051
         struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
 
1052
 
 
1053
         for (fpv = stfp->variants; fpv; ) {
 
1054
            struct st_fp_variant *next = fpv->next;
 
1055
            if (fpv->key.st == st) {
 
1056
               /* unlink from list */
 
1057
               *prevPtr = next;
 
1058
               /* destroy this variant */
 
1059
               delete_fp_variant(st, fpv);
 
1060
            }
 
1061
            else {
 
1062
               prevPtr = &fpv->next;
 
1063
            }
 
1064
            fpv = next;
 
1065
         }
 
1066
      }
 
1067
      break;
 
1068
   case MESA_GEOMETRY_PROGRAM:
 
1069
      {
 
1070
         struct st_geometry_program *stgp =
 
1071
            (struct st_geometry_program *) program;
 
1072
         struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
 
1073
 
 
1074
         for (gpv = stgp->variants; gpv; ) {
 
1075
            struct st_gp_variant *next = gpv->next;
 
1076
            if (gpv->key.st == st) {
 
1077
               /* unlink from list */
 
1078
               *prevPtr = next;
 
1079
               /* destroy this variant */
 
1080
               delete_gp_variant(st, gpv);
 
1081
            }
 
1082
            else {
 
1083
               prevPtr = &gpv->next;
 
1084
            }
 
1085
            gpv = next;
 
1086
         }
 
1087
      }
 
1088
      break;
 
1089
   default:
 
1090
      _mesa_problem(NULL, "Unexpected program target 0x%x in "
 
1091
                    "destroy_program_variants_cb()", program->Target);
 
1092
   }
 
1093
}
 
1094
 
 
1095
 
 
1096
/**
 
1097
 * Callback for _mesa_HashWalk.  Free all the shader's program variants
 
1098
 * which match the given context.
 
1099
 */
 
1100
static void
 
1101
destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
 
1102
{
 
1103
   struct st_context *st = (struct st_context *) userData;
 
1104
   struct gl_shader *shader = (struct gl_shader *) data;
 
1105
 
 
1106
   switch (shader->Type) {
 
1107
   case GL_SHADER_PROGRAM_MESA:
 
1108
      {
 
1109
         struct gl_shader_program *shProg = (struct gl_shader_program *) data;
 
1110
         GLuint i;
 
1111
 
 
1112
         for (i = 0; i < shProg->NumShaders; i++) {
 
1113
            destroy_program_variants(st, shProg->Shaders[i]->Program);
 
1114
         }
 
1115
 
 
1116
         destroy_program_variants(st, (struct gl_program *)
 
1117
                                  shProg->VertexProgram);
 
1118
         destroy_program_variants(st, (struct gl_program *)
 
1119
                                  shProg->FragmentProgram);
 
1120
         destroy_program_variants(st, (struct gl_program *)
 
1121
                                  shProg->GeometryProgram);
 
1122
      }
 
1123
      break;
 
1124
   case GL_VERTEX_SHADER:
 
1125
   case GL_FRAGMENT_SHADER:
 
1126
   case GL_GEOMETRY_SHADER:
 
1127
      {
 
1128
         destroy_program_variants(st, shader->Program);
 
1129
      }
 
1130
      break;
 
1131
   default:
 
1132
      assert(0);
 
1133
   }
 
1134
}
 
1135
 
 
1136
 
 
1137
/**
 
1138
 * Callback for _mesa_HashWalk.  Free all the program variants which match
 
1139
 * the given context.
 
1140
 */
 
1141
static void
 
1142
destroy_program_variants_cb(GLuint key, void *data, void *userData)
 
1143
{
 
1144
   struct st_context *st = (struct st_context *) userData;
 
1145
   struct gl_program *program = (struct gl_program *) data;
 
1146
   destroy_program_variants(st, program);
 
1147
}
 
1148
 
 
1149
 
 
1150
/**
 
1151
 * Walk over all shaders and programs to delete any variants which
 
1152
 * belong to the given context.
 
1153
 * This is called during context tear-down.
 
1154
 */
 
1155
void
 
1156
st_destroy_program_variants(struct st_context *st)
 
1157
{
 
1158
   /* ARB vert/frag program */
 
1159
   _mesa_HashWalk(st->ctx->Shared->Programs,
 
1160
                  destroy_program_variants_cb, st);
 
1161
 
 
1162
   /* GLSL vert/frag/geom shaders */
 
1163
   _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
 
1164
                  destroy_shader_program_variants_cb, st);
 
1165
}