projects / mesa.git / blob
? search:


ba9980854d0883d5861dcd3bb608b819909d2bd9
[mesa.git] / src / mesa / state_tracker / st_program.c
1 /**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27 /*
28 * Authors:
29 * Keith Whitwell <keith@tungstengraphics.com>
30 * Brian Paul
31 */
32
33
34 #include "main/imports.h"
35 #include "main/hash.h"
36 #include "main/mfeatures.h"
37 #include "main/mtypes.h"
38 #include "program/prog_parameter.h"
39 #include "program/prog_print.h"
40 #include "program/programopt.h"
41
42 #include "pipe/p_context.h"
43 #include "pipe/p_defines.h"
44 #include "pipe/p_shader_tokens.h"
45 #include "draw/draw_context.h"
46 #include "tgsi/tgsi_dump.h"
47 #include "tgsi/tgsi_ureg.h"
48
49 #include "st_debug.h"
50 #include "st_cb_bitmap.h"
51 #include "st_cb_drawpixels.h"
52 #include "st_context.h"
53 #include "st_program.h"
54 #include "st_mesa_to_tgsi.h"
55 #include "cso_cache/cso_context.h"
56
57
58
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 /**
83 * Clean out any old compilations:
84 */
85 void
86 st_release_vp_variants( struct st_context *st,
87 struct st_vertex_program *stvp )
88 {
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);
94 vpv = next;
95 }
96
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;
165 }
166
167
168
169
170 /**
171 * Translate a Mesa vertex shader into a TGSI shader.
172 * \param outputMapping to map vertex program output registers (VERT_RESULT_x)
173 * to TGSI output slots
174 * \param tokensOut destination for TGSI tokens
175 * \return pointer to cached pipe_shader object.
176 */
177 void
178 st_prepare_vertex_program(struct gl_context *ctx,
179 struct st_vertex_program *stvp)
180 {
181 GLuint attr;
182
183 stvp->num_inputs = 0;
184 stvp->num_outputs = 0;
185
186 if (stvp->Base.IsPositionInvariant)
187 _mesa_insert_mvp_code(ctx, &stvp->Base);
188
189 if (!stvp->glsl_to_tgsi)
190 assert(stvp->Base.Base.NumInstructions > 1);
191
192 /*
193 * Determine number of inputs, the mappings between VERT_ATTRIB_x
194 * and TGSI generic input indexes, plus input attrib semantic info.
195 */
196 for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
197 if (stvp->Base.Base.InputsRead & (1 << attr)) {
198 stvp->input_to_index[attr] = stvp->num_inputs;
199 stvp->index_to_input[stvp->num_inputs] = attr;
200 stvp->num_inputs++;
201 }
202 }
203 /* bit of a hack, presetup potentially unused edgeflag input */
204 stvp->input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
205 stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
206
207 /* Compute mapping of vertex program outputs to slots.
208 */
209 for (attr = 0; attr < VERT_RESULT_MAX; attr++) {
210 if ((stvp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {
211 stvp->result_to_output[attr] = ~0;
212 }
213 else {
214 unsigned slot = stvp->num_outputs++;
215
216 stvp->result_to_output[attr] = slot;
217
218 switch (attr) {
219 case VERT_RESULT_HPOS:
220 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
221 stvp->output_semantic_index[slot] = 0;
222 break;
223 case VERT_RESULT_COL0:
224 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
225 stvp->output_semantic_index[slot] = 0;
226 break;
227 case VERT_RESULT_COL1:
228 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
229 stvp->output_semantic_index[slot] = 1;
230 break;
231 case VERT_RESULT_BFC0:
232 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
233 stvp->output_semantic_index[slot] = 0;
234 break;
235 case VERT_RESULT_BFC1:
236 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
237 stvp->output_semantic_index[slot] = 1;
238 break;
239 case VERT_RESULT_FOGC:
240 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
241 stvp->output_semantic_index[slot] = 0;
242 break;
243 case VERT_RESULT_PSIZ:
244 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
245 stvp->output_semantic_index[slot] = 0;
246 break;
247 case VERT_RESULT_EDGE:
248 assert(0);
249 break;
250
251 case VERT_RESULT_TEX0:
252 case VERT_RESULT_TEX1:
253 case VERT_RESULT_TEX2:
254 case VERT_RESULT_TEX3:
255 case VERT_RESULT_TEX4:
256 case VERT_RESULT_TEX5:
257 case VERT_RESULT_TEX6:
258 case VERT_RESULT_TEX7:
259 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
260 stvp->output_semantic_index[slot] = attr - VERT_RESULT_TEX0;
261 break;
262
263 case VERT_RESULT_VAR0:
264 default:
265 assert(attr < VERT_RESULT_MAX);
266 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
267 stvp->output_semantic_index[slot] = (FRAG_ATTRIB_VAR0 -
268 FRAG_ATTRIB_TEX0 +
269 attr -
270 VERT_RESULT_VAR0);
271 break;
272 }
273 }
274 }
275 /* similar hack to above, presetup potentially unused edgeflag output */
276 stvp->result_to_output[VERT_RESULT_EDGE] = stvp->num_outputs;
277 stvp->output_semantic_name[stvp->num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
278 stvp->output_semantic_index[stvp->num_outputs] = 0;
279 }
280
281
282 /**
283 * Translate a vertex program to create a new variant.
284 */
285 static struct st_vp_variant *
286 st_translate_vertex_program(struct st_context *st,
287 struct st_vertex_program *stvp,
288 const struct st_vp_variant_key *key)
289 {
290 struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
291 struct pipe_context *pipe = st->pipe;
292 struct ureg_program *ureg;
293 enum pipe_error error;
294 unsigned num_outputs;
295
296 st_prepare_vertex_program(st->ctx, stvp);
297
298 if (!stvp->glsl_to_tgsi)
299 {
300 _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
301 _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);
302 }
303
304 ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
305 if (ureg == NULL) {
306 FREE(vpv);
307 return NULL;
308 }
309
310 vpv->key = *key;
311
312 vpv->num_inputs = stvp->num_inputs;
313 num_outputs = stvp->num_outputs;
314 if (key->passthrough_edgeflags) {
315 vpv->num_inputs++;
316 num_outputs++;
317 }
318
319 if (ST_DEBUG & DEBUG_MESA) {
320 _mesa_print_program(&stvp->Base.Base);
321 _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
322 debug_printf("\n");
323 }
324
325 if (stvp->glsl_to_tgsi)
326 error = st_translate_program(st->ctx,
327 TGSI_PROCESSOR_VERTEX,
328 ureg,
329 stvp->glsl_to_tgsi,
330 &stvp->Base.Base,
331 /* inputs */
332 stvp->num_inputs,
333 stvp->input_to_index,
334 NULL, /* input semantic name */
335 NULL, /* input semantic index */
336 NULL, /* interp mode */
337 /* outputs */
338 stvp->num_outputs,
339 stvp->result_to_output,
340 stvp->output_semantic_name,
341 stvp->output_semantic_index,
342 key->passthrough_edgeflags );
343 else
344 error = st_translate_mesa_program(st->ctx,
345 TGSI_PROCESSOR_VERTEX,
346 ureg,
347 &stvp->Base.Base,
348 /* inputs */
349 vpv->num_inputs,
350 stvp->input_to_index,
351 NULL, /* input semantic name */
352 NULL, /* input semantic index */
353 NULL,
354 /* outputs */
355 num_outputs,
356 stvp->result_to_output,
357 stvp->output_semantic_name,
358 stvp->output_semantic_index,
359 key->passthrough_edgeflags );
360
361 if (error)
362 goto fail;
363
364 vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );
365 if (!vpv->tgsi.tokens)
366 goto fail;
367
368 ureg_destroy( ureg );
369
370 vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
371
372 if (ST_DEBUG & DEBUG_TGSI) {
373 tgsi_dump( vpv->tgsi.tokens, 0 );
374 debug_printf("\n");
375 }
376
377 return vpv;
378
379 fail:
380 debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);
381 _mesa_print_program(&stvp->Base.Base);
382 debug_assert(0);
383
384 ureg_destroy( ureg );
385 return NULL;
386 }
387
388
389 /**
390 * Find/create a vertex program variant.
391 */
392 struct st_vp_variant *
393 st_get_vp_variant(struct st_context *st,
394 struct st_vertex_program *stvp,
395 const struct st_vp_variant_key *key)
396 {
397 struct st_vp_variant *vpv;
398
399 /* Search for existing variant */
400 for (vpv = stvp->variants; vpv; vpv = vpv->next) {
401 if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
402 break;
403 }
404 }
405
406 if (!vpv) {
407 /* create now */
408 vpv = st_translate_vertex_program(st, stvp, key);
409 if (vpv) {
410 /* insert into list */
411 vpv->next = stvp->variants;
412 stvp->variants = vpv;
413 }
414 }
415
416 return vpv;
417 }
418
419
420 /**
421 * Translate a Mesa fragment shader into a TGSI shader using extra info in
422 * the key.
423 * \return new fragment program variant
424 */
425 static struct st_fp_variant *
426 st_translate_fragment_program(struct st_context *st,
427 struct st_fragment_program *stfp,
428 const struct st_fp_variant_key *key)
429 {
430 struct pipe_context *pipe = st->pipe;
431 struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
432 GLboolean deleteFP = GL_FALSE;
433
434 if (!variant)
435 return NULL;
436
437 assert(!(key->bitmap && key->drawpixels));
438
439 #if FEATURE_drawpix
440 if (key->bitmap) {
441 /* glBitmap drawing */
442 struct gl_fragment_program *fp; /* we free this temp program below */
443
444 st_make_bitmap_fragment_program(st, &stfp->Base,
445 &fp, &variant->bitmap_sampler);
446
447 variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
448 stfp = st_fragment_program(fp);
449 deleteFP = GL_TRUE;
450 }
451 else if (key->drawpixels) {
452 /* glDrawPixels drawing */
453 struct gl_fragment_program *fp; /* we free this temp program below */
454
455 if (key->drawpixels_z || key->drawpixels_stencil) {
456 fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,
457 key->drawpixels_stencil);
458 }
459 else {
460 /* RGBA */
461 st_make_drawpix_fragment_program(st, &stfp->Base, &fp);
462 variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
463 deleteFP = GL_TRUE;
464 }
465 stfp = st_fragment_program(fp);
466 }
467 #endif
468
469 if (!stfp->tgsi.tokens) {
470 /* need to translate Mesa instructions to TGSI now */
471 GLuint outputMapping[FRAG_RESULT_MAX];
472 GLuint inputMapping[FRAG_ATTRIB_MAX];
473 GLuint interpMode[PIPE_MAX_SHADER_INPUTS]; /* XXX size? */
474 GLuint attr;
475 const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
476 struct ureg_program *ureg;
477
478 GLboolean write_all = GL_FALSE;
479
480 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
481 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
482 uint fs_num_inputs = 0;
483
484 ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
485 ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
486 uint fs_num_outputs = 0;
487
488 if (!stfp->glsl_to_tgsi)
489 _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
490
491 /*
492 * Convert Mesa program inputs to TGSI input register semantics.
493 */
494 for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
495 if (inputsRead & (1 << attr)) {
496 const GLuint slot = fs_num_inputs++;
497
498 inputMapping[attr] = slot;
499
500 switch (attr) {
501 case FRAG_ATTRIB_WPOS:
502 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
503 input_semantic_index[slot] = 0;
504 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
505 break;
506 case FRAG_ATTRIB_COL0:
507 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
508 input_semantic_index[slot] = 0;
509 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
510 break;
511 case FRAG_ATTRIB_COL1:
512 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
513 input_semantic_index[slot] = 1;
514 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
515 break;
516 case FRAG_ATTRIB_FOGC:
517 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
518 input_semantic_index[slot] = 0;
519 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
520 break;
521 case FRAG_ATTRIB_FACE:
522 input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
523 input_semantic_index[slot] = 0;
524 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
525 break;
526 /* In most cases, there is nothing special about these
527 * inputs, so adopt a convention to use the generic
528 * semantic name and the mesa FRAG_ATTRIB_ number as the
529 * index.
530 *
531 * All that is required is that the vertex shader labels
532 * its own outputs similarly, and that the vertex shader
533 * generates at least every output required by the
534 * fragment shader plus fixed-function hardware (such as
535 * BFC).
536 *
537 * There is no requirement that semantic indexes start at
538 * zero or be restricted to a particular range -- nobody
539 * should be building tables based on semantic index.
540 */
541 case FRAG_ATTRIB_PNTC:
542 case FRAG_ATTRIB_TEX0:
543 case FRAG_ATTRIB_TEX1:
544 case FRAG_ATTRIB_TEX2:
545 case FRAG_ATTRIB_TEX3:
546 case FRAG_ATTRIB_TEX4:
547 case FRAG_ATTRIB_TEX5:
548 case FRAG_ATTRIB_TEX6:
549 case FRAG_ATTRIB_TEX7:
550 case FRAG_ATTRIB_VAR0:
551 default:
552 /* Actually, let's try and zero-base this just for
553 * readability of the generated TGSI.
554 */
555 assert(attr >= FRAG_ATTRIB_TEX0);
556 input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
557 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
558 if (attr == FRAG_ATTRIB_PNTC)
559 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
560 else
561 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
562 break;
563 }
564 }
565 else {
566 inputMapping[attr] = -1;
567 }
568 }
569
570 /*
571 * Semantics and mapping for outputs
572 */
573 {
574 uint numColors = 0;
575 GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
576
577 /* if z is written, emit that first */
578 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
579 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
580 fs_output_semantic_index[fs_num_outputs] = 0;
581 outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
582 fs_num_outputs++;
583 outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
584 }
585
586 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
587 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
588 fs_output_semantic_index[fs_num_outputs] = 0;
589 outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
590 fs_num_outputs++;
591 outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
592 }
593
594 /* handle remaning outputs (color) */
595 for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
596 if (outputsWritten & BITFIELD64_BIT(attr)) {
597 switch (attr) {
598 case FRAG_RESULT_DEPTH:
599 case FRAG_RESULT_STENCIL:
600 /* handled above */
601 assert(0);
602 break;
603 case FRAG_RESULT_COLOR:
604 write_all = GL_TRUE; /* fallthrough */
605 default:
606 assert(attr == FRAG_RESULT_COLOR ||
607 (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
608 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
609 fs_output_semantic_index[fs_num_outputs] = numColors;
610 outputMapping[attr] = fs_num_outputs;
611 numColors++;
612 break;
613 }
614
615 fs_num_outputs++;
616 }
617 }
618 }
619
620 ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
621 if (ureg == NULL)
622 return NULL;
623
624 if (ST_DEBUG & DEBUG_MESA) {
625 _mesa_print_program(&stfp->Base.Base);
626 _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
627 debug_printf("\n");
628 }
629 if (write_all == GL_TRUE)
630 ureg_property_fs_color0_writes_all_cbufs(ureg, 1);
631
632 if (stfp->glsl_to_tgsi)
633 st_translate_program(st->ctx,
634 TGSI_PROCESSOR_FRAGMENT,
635 ureg,
636 stfp->glsl_to_tgsi,
637 &stfp->Base.Base,
638 /* inputs */
639 fs_num_inputs,
640 inputMapping,
641 input_semantic_name,
642 input_semantic_index,
643 interpMode,
644 /* outputs */
645 fs_num_outputs,
646 outputMapping,
647 fs_output_semantic_name,
648 fs_output_semantic_index, FALSE );
649 else
650 st_translate_mesa_program(st->ctx,
651 TGSI_PROCESSOR_FRAGMENT,
652 ureg,
653 &stfp->Base.Base,
654 /* inputs */
655 fs_num_inputs,
656 inputMapping,
657 input_semantic_name,
658 input_semantic_index,
659 interpMode,
660 /* outputs */
661 fs_num_outputs,
662 outputMapping,
663 fs_output_semantic_name,
664 fs_output_semantic_index, FALSE );
665
666 stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
667 ureg_destroy( ureg );
668 }
669
670 /* fill in variant */
671 variant->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
672 variant->key = *key;
673
674 if (ST_DEBUG & DEBUG_TGSI) {
675 tgsi_dump( stfp->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
676 debug_printf("\n");
677 }
678
679 if (deleteFP) {
680 /* Free the temporary program made above */
681 struct gl_fragment_program *fp = &stfp->Base;
682 _mesa_reference_fragprog(st->ctx, &fp, NULL);
683 }
684
685 return variant;
686 }
687
688
689 /**
690 * Translate fragment program if needed.
691 */
692 struct st_fp_variant *
693 st_get_fp_variant(struct st_context *st,
694 struct st_fragment_program *stfp,
695 const struct st_fp_variant_key *key)
696 {
697 struct st_fp_variant *fpv;
698
699 /* Search for existing variant */
700 for (fpv = stfp->variants; fpv; fpv = fpv->next) {
701 if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
702 break;
703 }
704 }
705
706 if (!fpv) {
707 /* create new */
708 fpv = st_translate_fragment_program(st, stfp, key);
709 if (fpv) {
710 /* insert into list */
711 fpv->next = stfp->variants;
712 stfp->variants = fpv;
713 }
714 }
715
716 return fpv;
717 }
718
719
720 /**
721 * Translate a geometry program to create a new variant.
722 */
723 static struct st_gp_variant *
724 st_translate_geometry_program(struct st_context *st,
725 struct st_geometry_program *stgp,
726 const struct st_gp_variant_key *key)
727 {
728 GLuint inputMapping[GEOM_ATTRIB_MAX];
729 GLuint outputMapping[GEOM_RESULT_MAX];
730 struct pipe_context *pipe = st->pipe;
731 GLuint attr;
732 const GLbitfield inputsRead = stgp->Base.Base.InputsRead;
733 GLuint vslot = 0;
734 GLuint num_generic = 0;
735
736 uint gs_num_inputs = 0;
737 uint gs_builtin_inputs = 0;
738 uint gs_array_offset = 0;
739
740 ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
741 ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
742 uint gs_num_outputs = 0;
743
744 GLint i;
745 GLuint maxSlot = 0;
746 struct ureg_program *ureg;
747
748 struct st_gp_variant *gpv;
749
750 gpv = CALLOC_STRUCT(st_gp_variant);
751 if (!gpv)
752 return NULL;
753
754 _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);
755 _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_VARYING);
756
757 ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
758 if (ureg == NULL) {
759 FREE(gpv);
760 return NULL;
761 }
762
763 /* which vertex output goes to the first geometry input */
764 vslot = 0;
765
766 memset(inputMapping, 0, sizeof(inputMapping));
767 memset(outputMapping, 0, sizeof(outputMapping));
768
769 /*
770 * Convert Mesa program inputs to TGSI input register semantics.
771 */
772 for (attr = 0; attr < GEOM_ATTRIB_MAX; attr++) {
773 if (inputsRead & (1 << attr)) {
774 const GLuint slot = gs_num_inputs;
775
776 gs_num_inputs++;
777
778 inputMapping[attr] = slot;
779
780 stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs;
781 stgp->input_to_index[attr] = vslot;
782 stgp->index_to_input[vslot] = attr;
783 ++vslot;
784
785 if (attr != GEOM_ATTRIB_PRIMITIVE_ID) {
786 gs_array_offset += 2;
787 } else
788 ++gs_builtin_inputs;
789
790 #if 0
791 debug_printf("input map at %d = %d\n",
792 slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
793 #endif
794
795 switch (attr) {
796 case GEOM_ATTRIB_PRIMITIVE_ID:
797 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
798 stgp->input_semantic_index[slot] = 0;
799 break;
800 case GEOM_ATTRIB_POSITION:
801 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
802 stgp->input_semantic_index[slot] = 0;
803 break;
804 case GEOM_ATTRIB_COLOR0:
805 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
806 stgp->input_semantic_index[slot] = 0;
807 break;
808 case GEOM_ATTRIB_COLOR1:
809 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
810 stgp->input_semantic_index[slot] = 1;
811 break;
812 case GEOM_ATTRIB_FOG_FRAG_COORD:
813 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
814 stgp->input_semantic_index[slot] = 0;
815 break;
816 case GEOM_ATTRIB_TEX_COORD:
817 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
818 stgp->input_semantic_index[slot] = num_generic++;
819 break;
820 case GEOM_ATTRIB_VAR0:
821 /* fall-through */
822 default:
823 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
824 stgp->input_semantic_index[slot] = num_generic++;
825 }
826 }
827 }
828
829 /* initialize output semantics to defaults */
830 for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
831 gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
832 gs_output_semantic_index[i] = 0;
833 }
834
835 num_generic = 0;
836 /*
837 * Determine number of outputs, the (default) output register
838 * mapping and the semantic information for each output.
839 */
840 for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
841 if (stgp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) {
842 GLuint slot;
843
844 slot = gs_num_outputs;
845 gs_num_outputs++;
846 outputMapping[attr] = slot;
847
848 switch (attr) {
849 case GEOM_RESULT_POS:
850 assert(slot == 0);
851 gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
852 gs_output_semantic_index[slot] = 0;
853 break;
854 case GEOM_RESULT_COL0:
855 gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
856 gs_output_semantic_index[slot] = 0;
857 break;
858 case GEOM_RESULT_COL1:
859 gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
860 gs_output_semantic_index[slot] = 1;
861 break;
862 case GEOM_RESULT_SCOL0:
863 gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
864 gs_output_semantic_index[slot] = 0;
865 break;
866 case GEOM_RESULT_SCOL1:
867 gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
868 gs_output_semantic_index[slot] = 1;
869 break;
870 case GEOM_RESULT_FOGC:
871 gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
872 gs_output_semantic_index[slot] = 0;
873 break;
874 case GEOM_RESULT_PSIZ:
875 gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
876 gs_output_semantic_index[slot] = 0;
877 break;
878 case GEOM_RESULT_TEX0:
879 case GEOM_RESULT_TEX1:
880 case GEOM_RESULT_TEX2:
881 case GEOM_RESULT_TEX3:
882 case GEOM_RESULT_TEX4:
883 case GEOM_RESULT_TEX5:
884 case GEOM_RESULT_TEX6:
885 case GEOM_RESULT_TEX7:
886 /* fall-through */
887 case GEOM_RESULT_VAR0:
888 /* fall-through */
889 default:
890 assert(slot < Elements(gs_output_semantic_name));
891 /* use default semantic info */
892 gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
893 gs_output_semantic_index[slot] = num_generic++;
894 }
895 }
896 }
897
898 assert(gs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);
899
900 /* find max output slot referenced to compute gs_num_outputs */
901 for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
902 if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)
903 maxSlot = outputMapping[attr];
904 }
905 gs_num_outputs = maxSlot + 1;
906
907 #if 0 /* debug */
908 {
909 GLuint i;
910 printf("outputMapping? %d\n", outputMapping ? 1 : 0);
911 if (outputMapping) {
912 printf("attr -> slot\n");
913 for (i = 0; i < 16; i++) {
914 printf(" %2d %3d\n", i, outputMapping[i]);
915 }
916 }
917 printf("slot sem_name sem_index\n");
918 for (i = 0; i < gs_num_outputs; i++) {
919 printf(" %2d %d %d\n",
920 i,
921 gs_output_semantic_name[i],
922 gs_output_semantic_index[i]);
923 }
924 }
925 #endif
926
927 /* free old shader state, if any */
928 if (stgp->tgsi.tokens) {
929 st_free_tokens(stgp->tgsi.tokens);
930 stgp->tgsi.tokens = NULL;
931 }
932
933 ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
934 ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
935 ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
936
937 st_translate_mesa_program(st->ctx,
938 TGSI_PROCESSOR_GEOMETRY,
939 ureg,
940 &stgp->Base.Base,
941 /* inputs */
942 gs_num_inputs,
943 inputMapping,
944 stgp->input_semantic_name,
945 stgp->input_semantic_index,
946 NULL,
947 /* outputs */
948 gs_num_outputs,
949 outputMapping,
950 gs_output_semantic_name,
951 gs_output_semantic_index,
952 FALSE);
953
954 stgp->num_inputs = gs_num_inputs;
955 stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
956 ureg_destroy( ureg );
957
958 /* fill in new variant */
959 gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
960 gpv->key = *key;
961
962 if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
963 _mesa_print_program(&stgp->Base.Base);
964 debug_printf("\n");
965 }
966
967 if (ST_DEBUG & DEBUG_TGSI) {
968 tgsi_dump(stgp->tgsi.tokens, 0);
969 debug_printf("\n");
970 }
971
972 return gpv;
973 }
974
975
976 /**
977 * Get/create geometry program variant.
978 */
979 struct st_gp_variant *
980 st_get_gp_variant(struct st_context *st,
981 struct st_geometry_program *stgp,
982 const struct st_gp_variant_key *key)
983 {
984 struct st_gp_variant *gpv;
985
986 /* Search for existing variant */
987 for (gpv = stgp->variants; gpv; gpv = gpv->next) {
988 if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
989 break;
990 }
991 }
992
993 if (!gpv) {
994 /* create new */
995 gpv = st_translate_geometry_program(st, stgp, key);
996 if (gpv) {
997 /* insert into list */
998 gpv->next = stgp->variants;
999 stgp->variants = gpv;
1000 }
1001 }
1002
1003 return gpv;
1004 }
1005
1006
1007
1008
1009 /**
1010 * Debug- print current shader text
1011 */
1012 void
1013 st_print_shaders(struct gl_context *ctx)
1014 {
1015 struct gl_shader_program *shProg[3] = {
1016 ctx->Shader.CurrentVertexProgram,
1017 ctx->Shader.CurrentGeometryProgram,
1018 ctx->Shader.CurrentFragmentProgram,
1019 };
1020 unsigned j;
1021
1022 for (j = 0; j < 3; j++) {
1023 unsigned i;
1024
1025 if (shProg[j] == NULL)
1026 continue;
1027
1028 for (i = 0; i < shProg[j]->NumShaders; i++) {
1029 struct gl_shader *sh;
1030
1031 switch (shProg[j]->Shaders[i]->Type) {
1032 case GL_VERTEX_SHADER:
1033 sh = (i != 0) ? NULL : shProg[j]->Shaders[i];
1034 break;
1035 case GL_GEOMETRY_SHADER_ARB:
1036 sh = (i != 1) ? NULL : shProg[j]->Shaders[i];
1037 break;
1038 case GL_FRAGMENT_SHADER:
1039 sh = (i != 2) ? NULL : shProg[j]->Shaders[i];
1040 break;
1041 default:
1042 assert(0);
1043 sh = NULL;
1044 break;
1045 }
1046
1047 if (sh != NULL) {
1048 printf("GLSL shader %u of %u:\n", i, shProg[j]->NumShaders);
1049 printf("%s\n", sh->Source);
1050 }
1051 }
1052 }
1053 }
1054
1055
1056 /**
1057 * Vert/Geom/Frag programs have per-context variants. Free all the
1058 * variants attached to the given program which match the given context.
1059 */
1060 static void
1061 destroy_program_variants(struct st_context *st, struct gl_program *program)
1062 {
1063 if (!program)
1064 return;
1065
1066 switch (program->Target) {
1067 case GL_VERTEX_PROGRAM_ARB:
1068 {
1069 struct st_vertex_program *stvp = (struct st_vertex_program *) program;
1070 struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1071
1072 for (vpv = stvp->variants; vpv; ) {
1073 struct st_vp_variant *next = vpv->next;
1074 if (vpv->key.st == st) {
1075 /* unlink from list */
1076 *prevPtr = next;
1077 /* destroy this variant */
1078 delete_vp_variant(st, vpv);
1079 }
1080 else {
1081 prevPtr = &vpv->next;
1082 }
1083 vpv = next;
1084 }
1085 }
1086 break;
1087 case GL_FRAGMENT_PROGRAM_ARB:
1088 {
1089 struct st_fragment_program *stfp =
1090 (struct st_fragment_program *) program;
1091 struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1092
1093 for (fpv = stfp->variants; fpv; ) {
1094 struct st_fp_variant *next = fpv->next;
1095 if (fpv->key.st == st) {
1096 /* unlink from list */
1097 *prevPtr = next;
1098 /* destroy this variant */
1099 delete_fp_variant(st, fpv);
1100 }
1101 else {
1102 prevPtr = &fpv->next;
1103 }
1104 fpv = next;
1105 }
1106 }
1107 break;
1108 case MESA_GEOMETRY_PROGRAM:
1109 {
1110 struct st_geometry_program *stgp =
1111 (struct st_geometry_program *) program;
1112 struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
1113
1114 for (gpv = stgp->variants; gpv; ) {
1115 struct st_gp_variant *next = gpv->next;
1116 if (gpv->key.st == st) {
1117 /* unlink from list */
1118 *prevPtr = next;
1119 /* destroy this variant */
1120 delete_gp_variant(st, gpv);
1121 }
1122 else {
1123 prevPtr = &gpv->next;
1124 }
1125 gpv = next;
1126 }
1127 }
1128 break;
1129 default:
1130 _mesa_problem(NULL, "Unexpected program target 0x%x in "
1131 "destroy_program_variants_cb()", program->Target);
1132 }
1133 }
1134
1135
1136 /**
1137 * Callback for _mesa_HashWalk. Free all the shader's program variants
1138 * which match the given context.
1139 */
1140 static void
1141 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1142 {
1143 struct st_context *st = (struct st_context *) userData;
1144 struct gl_shader *shader = (struct gl_shader *) data;
1145
1146 switch (shader->Type) {
1147 case GL_SHADER_PROGRAM_MESA:
1148 {
1149 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1150 GLuint i;
1151
1152 for (i = 0; i < shProg->NumShaders; i++) {
1153 destroy_program_variants(st, shProg->Shaders[i]->Program);
1154 }
1155
1156 destroy_program_variants(st,
1157 shProg->_LinkedShaders[MESA_SHADER_VERTEX]->Program);
1158 destroy_program_variants(st, (struct gl_program *)
1159 shProg->FragmentProgram);
1160 destroy_program_variants(st,
1161 shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program);
1162 }
1163 break;
1164 case GL_VERTEX_SHADER:
1165 case GL_FRAGMENT_SHADER:
1166 case GL_GEOMETRY_SHADER:
1167 {
1168 destroy_program_variants(st, shader->Program);
1169 }
1170 break;
1171 default:
1172 assert(0);
1173 }
1174 }
1175
1176
1177 /**
1178 * Callback for _mesa_HashWalk. Free all the program variants which match
1179 * the given context.
1180 */
1181 static void
1182 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1183 {
1184 struct st_context *st = (struct st_context *) userData;
1185 struct gl_program *program = (struct gl_program *) data;
1186 destroy_program_variants(st, program);
1187 }
1188
1189
1190 /**
1191 * Walk over all shaders and programs to delete any variants which
1192 * belong to the given context.
1193 * This is called during context tear-down.
1194 */
1195 void
1196 st_destroy_program_variants(struct st_context *st)
1197 {
1198 /* ARB vert/frag program */
1199 _mesa_HashWalk(st->ctx->Shared->Programs,
1200 destroy_program_variants_cb, st);
1201
1202 /* GLSL vert/frag/geom shaders */
1203 _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1204 destroy_shader_program_variants_cb, st);
1205 }