← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mesa/state_tracker/st_program.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/mesa/state_tracker/st_program.c
174
174
 * \param tokensOut  destination for TGSI tokens
175
175
 * \return  pointer to cached pipe_shader object.
176
176
 */
177
 
static void
178
 
st_prepare_vertex_program(struct st_context *st,
 
177
void
 
178
st_prepare_vertex_program(struct gl_context *ctx,
179
179
                            struct st_vertex_program *stvp)
180
180
{
181
181
   GLuint attr;
184
184
   stvp->num_outputs = 0;
185
185
 
186
186
   if (stvp->Base.IsPositionInvariant)
187
 
      _mesa_insert_mvp_code(st->ctx, &stvp->Base);
 
187
      _mesa_insert_mvp_code(ctx, &stvp->Base);
188
188
 
189
 
   assert(stvp->Base.Base.NumInstructions > 1);
 
189
   if (!stvp->glsl_to_tgsi)
 
190
      assert(stvp->Base.Base.NumInstructions > 1);
190
191
 
191
192
   /*
192
193
    * Determine number of inputs, the mappings between VERT_ATTRIB_x
193
194
    * and TGSI generic input indexes, plus input attrib semantic info.
194
195
    */
195
196
   for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
196
 
      if (stvp->Base.Base.InputsRead & (1 << attr)) {
 
197
      if ((stvp->Base.Base.InputsRead & BITFIELD64_BIT(attr)) != 0) {
197
198
         stvp->input_to_index[attr] = stvp->num_inputs;
198
199
         stvp->index_to_input[stvp->num_inputs] = attr;
199
200
         stvp->num_inputs++;
243
244
            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
244
245
            stvp->output_semantic_index[slot] = 0;
245
246
            break;
 
247
         case VERT_RESULT_CLIP_DIST0:
 
248
            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 
249
            stvp->output_semantic_index[slot] = 0;
 
250
            break;
 
251
         case VERT_RESULT_CLIP_DIST1:
 
252
            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 
253
            stvp->output_semantic_index[slot] = 1;
 
254
            break;
246
255
         case VERT_RESULT_EDGE:
247
256
            assert(0);
248
257
            break;
 
258
         case VERT_RESULT_CLIP_VERTEX:
 
259
            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
 
260
            stvp->output_semantic_index[slot] = 0;
 
261
            break;
249
262
 
250
263
         case VERT_RESULT_TEX0:
251
264
         case VERT_RESULT_TEX1:
292
305
   enum pipe_error error;
293
306
   unsigned num_outputs;
294
307
 
295
 
   st_prepare_vertex_program( st, stvp );
 
308
   st_prepare_vertex_program(st->ctx, stvp);
296
309
 
297
 
   _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
298
 
   _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);
 
310
   if (!stvp->glsl_to_tgsi)
 
311
   {
 
312
      _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
 
313
      _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);
 
314
   }
299
315
 
300
316
   ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
301
317
   if (ureg == NULL) {
318
334
      debug_printf("\n");
319
335
   }
320
336
 
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 );
 
337
   if (stvp->glsl_to_tgsi)
 
338
      error = st_translate_program(st->ctx,
 
339
                                   TGSI_PROCESSOR_VERTEX,
 
340
                                   ureg,
 
341
                                   stvp->glsl_to_tgsi,
 
342
                                   &stvp->Base.Base,
 
343
                                   /* inputs */
 
344
                                   stvp->num_inputs,
 
345
                                   stvp->input_to_index,
 
346
                                   NULL, /* input semantic name */
 
347
                                   NULL, /* input semantic index */
 
348
                                   NULL, /* interp mode */
 
349
                                   /* outputs */
 
350
                                   stvp->num_outputs,
 
351
                                   stvp->result_to_output,
 
352
                                   stvp->output_semantic_name,
 
353
                                   stvp->output_semantic_index,
 
354
                                   key->passthrough_edgeflags );
 
355
   else
 
356
      error = st_translate_mesa_program(st->ctx,
 
357
                                        TGSI_PROCESSOR_VERTEX,
 
358
                                        ureg,
 
359
                                        &stvp->Base.Base,
 
360
                                        /* inputs */
 
361
                                        vpv->num_inputs,
 
362
                                        stvp->input_to_index,
 
363
                                        NULL, /* input semantic name */
 
364
                                        NULL, /* input semantic index */
 
365
                                        NULL,
 
366
                                        /* outputs */
 
367
                                        num_outputs,
 
368
                                        stvp->result_to_output,
 
369
                                        stvp->output_semantic_name,
 
370
                                        stvp->output_semantic_index,
 
371
                                        key->passthrough_edgeflags );
337
372
 
338
373
   if (error)
339
374
      goto fail;
344
379
 
345
380
   ureg_destroy( ureg );
346
381
 
 
382
   if (stvp->glsl_to_tgsi) {
 
383
      st_translate_stream_output_info(stvp->glsl_to_tgsi,
 
384
                                      stvp->result_to_output,
 
385
                                      &vpv->tgsi.stream_output);
 
386
   }
 
387
 
347
388
   vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
348
389
 
349
390
   if (ST_DEBUG & DEBUG_TGSI) {
394
435
}
395
436
 
396
437
 
 
438
static unsigned
 
439
st_translate_interp(enum glsl_interp_qualifier glsl_qual, bool is_color)
 
440
{
 
441
   switch (glsl_qual) {
 
442
   case INTERP_QUALIFIER_NONE:
 
443
      if (is_color)
 
444
         return TGSI_INTERPOLATE_COLOR;
 
445
      return TGSI_INTERPOLATE_PERSPECTIVE;
 
446
   case INTERP_QUALIFIER_SMOOTH:
 
447
      return TGSI_INTERPOLATE_PERSPECTIVE;
 
448
   case INTERP_QUALIFIER_FLAT:
 
449
      return TGSI_INTERPOLATE_CONSTANT;
 
450
   case INTERP_QUALIFIER_NOPERSPECTIVE:
 
451
      return TGSI_INTERPOLATE_LINEAR;
 
452
   default:
 
453
      assert(0 && "unexpected interp mode in st_translate_interp()");
 
454
      return TGSI_INTERPOLATE_PERSPECTIVE;
 
455
   }
 
456
}
 
457
 
 
458
 
397
459
/**
398
460
 * Translate a Mesa fragment shader into a TGSI shader using extra info in
399
461
 * the key.
449
511
      GLuint inputMapping[FRAG_ATTRIB_MAX];
450
512
      GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
451
513
      GLuint attr;
452
 
      enum pipe_error error;
453
 
      const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
 
514
      const GLbitfield64 inputsRead = stfp->Base.Base.InputsRead;
454
515
      struct ureg_program *ureg;
 
516
 
455
517
      GLboolean write_all = GL_FALSE;
456
518
 
457
519
      ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
461
523
      ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
462
524
      ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
463
525
      uint fs_num_outputs = 0;
464
 
 
465
 
 
466
 
      _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
 
526
      
 
527
      if (!stfp->glsl_to_tgsi)
 
528
         _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
467
529
 
468
530
      /*
469
531
       * Convert Mesa program inputs to TGSI input register semantics.
470
532
       */
471
533
      for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
472
 
         if (inputsRead & (1 << attr)) {
 
534
         if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
473
535
            const GLuint slot = fs_num_inputs++;
474
536
 
475
537
            inputMapping[attr] = slot;
483
545
            case FRAG_ATTRIB_COL0:
484
546
               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
485
547
               input_semantic_index[slot] = 0;
486
 
               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 
548
               interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 
549
                                                      TRUE);
487
550
               break;
488
551
            case FRAG_ATTRIB_COL1:
489
552
               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
490
553
               input_semantic_index[slot] = 1;
491
 
               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 
554
               interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 
555
                                                      TRUE);
492
556
               break;
493
557
            case FRAG_ATTRIB_FOGC:
494
558
               input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
500
564
               input_semantic_index[slot] = 0;
501
565
               interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
502
566
               break;
 
567
            case FRAG_ATTRIB_CLIP_DIST0:
 
568
               input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 
569
               input_semantic_index[slot] = 0;
 
570
               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 
571
               break;
 
572
            case FRAG_ATTRIB_CLIP_DIST1:
 
573
               input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 
574
               input_semantic_index[slot] = 1;
 
575
               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 
576
               break;
503
577
               /* In most cases, there is nothing special about these
504
578
                * inputs, so adopt a convention to use the generic
505
579
                * semantic name and the mesa FRAG_ATTRIB_ number as the
535
609
               if (attr == FRAG_ATTRIB_PNTC)
536
610
                  interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
537
611
               else
538
 
                  interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 
612
                  interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 
613
                                                         FALSE);
539
614
               break;
540
615
            }
541
616
         }
595
670
      }
596
671
 
597
672
      ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
598
 
      if (ureg == NULL)
 
673
      if (ureg == NULL) {
 
674
         FREE(variant);
599
675
         return NULL;
 
676
      }
600
677
 
601
678
      if (ST_DEBUG & DEBUG_MESA) {
602
679
         _mesa_print_program(&stfp->Base.Base);
606
683
      if (write_all == GL_TRUE)
607
684
         ureg_property_fs_color0_writes_all_cbufs(ureg, 1);
608
685
 
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 );
 
686
      if (stfp->Base.FragDepthLayout != FRAG_DEPTH_LAYOUT_NONE) {
 
687
         switch (stfp->Base.FragDepthLayout) {
 
688
         case FRAG_DEPTH_LAYOUT_ANY:
 
689
            ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_ANY);
 
690
            break;
 
691
         case FRAG_DEPTH_LAYOUT_GREATER:
 
692
            ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_GREATER);
 
693
            break;
 
694
         case FRAG_DEPTH_LAYOUT_LESS:
 
695
            ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_LESS);
 
696
            break;
 
697
         case FRAG_DEPTH_LAYOUT_UNCHANGED:
 
698
            ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
 
699
            break;
 
700
         default:
 
701
            assert(0);
 
702
         }
 
703
      }
 
704
 
 
705
      if (stfp->glsl_to_tgsi)
 
706
         st_translate_program(st->ctx,
 
707
                              TGSI_PROCESSOR_FRAGMENT,
 
708
                              ureg,
 
709
                              stfp->glsl_to_tgsi,
 
710
                              &stfp->Base.Base,
 
711
                              /* inputs */
 
712
                              fs_num_inputs,
 
713
                              inputMapping,
 
714
                              input_semantic_name,
 
715
                              input_semantic_index,
 
716
                              interpMode,
 
717
                              /* outputs */
 
718
                              fs_num_outputs,
 
719
                              outputMapping,
 
720
                              fs_output_semantic_name,
 
721
                              fs_output_semantic_index, FALSE );
 
722
      else
 
723
         st_translate_mesa_program(st->ctx,
 
724
                                   TGSI_PROCESSOR_FRAGMENT,
 
725
                                   ureg,
 
726
                                   &stfp->Base.Base,
 
727
                                   /* inputs */
 
728
                                   fs_num_inputs,
 
729
                                   inputMapping,
 
730
                                   input_semantic_name,
 
731
                                   input_semantic_index,
 
732
                                   interpMode,
 
733
                                   /* outputs */
 
734
                                   fs_num_outputs,
 
735
                                   outputMapping,
 
736
                                   fs_output_semantic_name,
 
737
                                   fs_output_semantic_index, FALSE );
624
738
 
625
739
      stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
626
740
      ureg_destroy( ureg );
687
801
   GLuint inputMapping[GEOM_ATTRIB_MAX];
688
802
   GLuint outputMapping[GEOM_RESULT_MAX];
689
803
   struct pipe_context *pipe = st->pipe;
690
 
   enum pipe_error error;
691
804
   GLuint attr;
692
 
   const GLbitfield inputsRead = stgp->Base.Base.InputsRead;
 
805
   const GLbitfield64 inputsRead = stgp->Base.Base.InputsRead;
693
806
   GLuint vslot = 0;
694
807
   GLuint num_generic = 0;
695
808
 
730
843
    * Convert Mesa program inputs to TGSI input register semantics.
731
844
    */
732
845
   for (attr = 0; attr < GEOM_ATTRIB_MAX; attr++) {
733
 
      if (inputsRead & (1 << attr)) {
 
846
      if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
734
847
         const GLuint slot = gs_num_inputs;
735
848
 
736
849
         gs_num_inputs++;
894
1007
   ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
895
1008
   ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
896
1009
 
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);
 
1010
   st_translate_mesa_program(st->ctx,
 
1011
                             TGSI_PROCESSOR_GEOMETRY,
 
1012
                             ureg,
 
1013
                             &stgp->Base.Base,
 
1014
                             /* inputs */
 
1015
                             gs_num_inputs,
 
1016
                             inputMapping,
 
1017
                             stgp->input_semantic_name,
 
1018
                             stgp->input_semantic_index,
 
1019
                             NULL,
 
1020
                             /* outputs */
 
1021
                             gs_num_outputs,
 
1022
                             outputMapping,
 
1023
                             gs_output_semantic_name,
 
1024
                             gs_output_semantic_index,
 
1025
                             FALSE);
913
1026
 
914
1027
   stgp->num_inputs = gs_num_inputs;
915
1028
   stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
916
1029
   ureg_destroy( ureg );
917
1030
 
 
1031
   if (stgp->glsl_to_tgsi) {
 
1032
      st_translate_stream_output_info(stgp->glsl_to_tgsi,
 
1033
                                      outputMapping,
 
1034
                                      &stgp->tgsi.stream_output);
 
1035
   }
 
1036
 
918
1037
   /* fill in new variant */
919
1038
   gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
920
1039
   gpv->key = *key;
1113
1232
            destroy_program_variants(st, shProg->Shaders[i]->Program);
1114
1233
         }
1115
1234
 
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);
 
1235
         for (i = 0; i < Elements(shProg->_LinkedShaders); i++) {
 
1236
            if (shProg->_LinkedShaders[i])
 
1237
               destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
 
1238
         }
1122
1239
      }
1123
1240
      break;
1124
1241
   case GL_VERTEX_SHADER: