projects / mesa.git / blob
? search:


aceaaf8c552be4a48f1a23e08e751bf5a2a5c3bd
[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 & BITFIELD64_BIT(attr)) != 0) {
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_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;
255 case VERT_RESULT_EDGE:
256 assert(0);
257 break;
258
259 case VERT_RESULT_TEX0:
260 case VERT_RESULT_TEX1:
261 case VERT_RESULT_TEX2:
262 case VERT_RESULT_TEX3:
263 case VERT_RESULT_TEX4:
264 case VERT_RESULT_TEX5:
265 case VERT_RESULT_TEX6:
266 case VERT_RESULT_TEX7:
267 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
268 stvp->output_semantic_index[slot] = attr - VERT_RESULT_TEX0;
269 break;
270
271 case VERT_RESULT_VAR0:
272 default:
273 assert(attr < VERT_RESULT_MAX);
274 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
275 stvp->output_semantic_index[slot] = (FRAG_ATTRIB_VAR0 -
276 FRAG_ATTRIB_TEX0 +
277 attr -
278 VERT_RESULT_VAR0);
279 break;
280 }
281 }
282 }
283 /* similar hack to above, presetup potentially unused edgeflag output */
284 stvp->result_to_output[VERT_RESULT_EDGE] = stvp->num_outputs;
285 stvp->output_semantic_name[stvp->num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
286 stvp->output_semantic_index[stvp->num_outputs] = 0;
287 }
288
289
290 /**
291 * Translate a vertex program to create a new variant.
292 */
293 static struct st_vp_variant *
294 st_translate_vertex_program(struct st_context *st,
295 struct st_vertex_program *stvp,
296 const struct st_vp_variant_key *key)
297 {
298 struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
299 struct pipe_context *pipe = st->pipe;
300 struct ureg_program *ureg;
301 enum pipe_error error;
302 unsigned num_outputs;
303
304 st_prepare_vertex_program(st->ctx, stvp);
305
306 if (!stvp->glsl_to_tgsi)
307 {
308 _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
309 _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);
310 }
311
312 ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
313 if (ureg == NULL) {
314 FREE(vpv);
315 return NULL;
316 }
317
318 vpv->key = *key;
319
320 vpv->num_inputs = stvp->num_inputs;
321 num_outputs = stvp->num_outputs;
322 if (key->passthrough_edgeflags) {
323 vpv->num_inputs++;
324 num_outputs++;
325 }
326
327 if (ST_DEBUG & DEBUG_MESA) {
328 _mesa_print_program(&stvp->Base.Base);
329 _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
330 debug_printf("\n");
331 }
332
333 if (stvp->glsl_to_tgsi)
334 error = st_translate_program(st->ctx,
335 TGSI_PROCESSOR_VERTEX,
336 ureg,
337 stvp->glsl_to_tgsi,
338 &stvp->Base.Base,
339 /* inputs */
340 stvp->num_inputs,
341 stvp->input_to_index,
342 NULL, /* input semantic name */
343 NULL, /* input semantic index */
344 NULL, /* interp mode */
345 /* outputs */
346 stvp->num_outputs,
347 stvp->result_to_output,
348 stvp->output_semantic_name,
349 stvp->output_semantic_index,
350 key->passthrough_edgeflags );
351 else
352 error = st_translate_mesa_program(st->ctx,
353 TGSI_PROCESSOR_VERTEX,
354 ureg,
355 &stvp->Base.Base,
356 /* inputs */
357 vpv->num_inputs,
358 stvp->input_to_index,
359 NULL, /* input semantic name */
360 NULL, /* input semantic index */
361 NULL,
362 /* outputs */
363 num_outputs,
364 stvp->result_to_output,
365 stvp->output_semantic_name,
366 stvp->output_semantic_index,
367 key->passthrough_edgeflags );
368
369 if (error)
370 goto fail;
371
372 vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );
373 if (!vpv->tgsi.tokens)
374 goto fail;
375
376 ureg_destroy( ureg );
377
378 if (stvp->glsl_to_tgsi) {
379 st_translate_stream_output_info(stvp->glsl_to_tgsi,
380 stvp->result_to_output,
381 &vpv->tgsi.stream_output);
382 }
383
384 vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
385
386 if (ST_DEBUG & DEBUG_TGSI) {
387 tgsi_dump( vpv->tgsi.tokens, 0 );
388 debug_printf("\n");
389 }
390
391 return vpv;
392
393 fail:
394 debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);
395 _mesa_print_program(&stvp->Base.Base);
396 debug_assert(0);
397
398 ureg_destroy( ureg );
399 return NULL;
400 }
401
402
403 /**
404 * Find/create a vertex program variant.
405 */
406 struct st_vp_variant *
407 st_get_vp_variant(struct st_context *st,
408 struct st_vertex_program *stvp,
409 const struct st_vp_variant_key *key)
410 {
411 struct st_vp_variant *vpv;
412
413 /* Search for existing variant */
414 for (vpv = stvp->variants; vpv; vpv = vpv->next) {
415 if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
416 break;
417 }
418 }
419
420 if (!vpv) {
421 /* create now */
422 vpv = st_translate_vertex_program(st, stvp, key);
423 if (vpv) {
424 /* insert into list */
425 vpv->next = stvp->variants;
426 stvp->variants = vpv;
427 }
428 }
429
430 return vpv;
431 }
432
433
434 static unsigned
435 st_translate_interp(enum glsl_interp_qualifier glsl_qual)
436 {
437 switch (glsl_qual) {
438 case INTERP_QUALIFIER_NONE:
439 case INTERP_QUALIFIER_SMOOTH:
440 return TGSI_INTERPOLATE_PERSPECTIVE;
441 case INTERP_QUALIFIER_FLAT:
442 return TGSI_INTERPOLATE_CONSTANT;
443 case INTERP_QUALIFIER_NOPERSPECTIVE:
444 return TGSI_INTERPOLATE_LINEAR;
445 default:
446 assert(0 && "unexpected interp mode in st_translate_interp()");
447 return TGSI_INTERPOLATE_PERSPECTIVE;
448 }
449 }
450
451
452 /**
453 * Translate a Mesa fragment shader into a TGSI shader using extra info in
454 * the key.
455 * \return new fragment program variant
456 */
457 static struct st_fp_variant *
458 st_translate_fragment_program(struct st_context *st,
459 struct st_fragment_program *stfp,
460 const struct st_fp_variant_key *key)
461 {
462 struct pipe_context *pipe = st->pipe;
463 struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
464 GLboolean deleteFP = GL_FALSE;
465
466 if (!variant)
467 return NULL;
468
469 assert(!(key->bitmap && key->drawpixels));
470
471 #if FEATURE_drawpix
472 if (key->bitmap) {
473 /* glBitmap drawing */
474 struct gl_fragment_program *fp; /* we free this temp program below */
475
476 st_make_bitmap_fragment_program(st, &stfp->Base,
477 &fp, &variant->bitmap_sampler);
478
479 variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
480 stfp = st_fragment_program(fp);
481 deleteFP = GL_TRUE;
482 }
483 else if (key->drawpixels) {
484 /* glDrawPixels drawing */
485 struct gl_fragment_program *fp; /* we free this temp program below */
486
487 if (key->drawpixels_z || key->drawpixels_stencil) {
488 fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,
489 key->drawpixels_stencil);
490 }
491 else {
492 /* RGBA */
493 st_make_drawpix_fragment_program(st, &stfp->Base, &fp);
494 variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
495 deleteFP = GL_TRUE;
496 }
497 stfp = st_fragment_program(fp);
498 }
499 #endif
500
501 if (!stfp->tgsi.tokens) {
502 /* need to translate Mesa instructions to TGSI now */
503 GLuint outputMapping[FRAG_RESULT_MAX];
504 GLuint inputMapping[FRAG_ATTRIB_MAX];
505 GLuint interpMode[PIPE_MAX_SHADER_INPUTS]; /* XXX size? */
506 GLuint attr;
507 const GLbitfield64 inputsRead = stfp->Base.Base.InputsRead;
508 struct ureg_program *ureg;
509
510 GLboolean write_all = GL_FALSE;
511
512 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
513 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
514 uint fs_num_inputs = 0;
515
516 ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
517 ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
518 uint fs_num_outputs = 0;
519
520 if (!stfp->glsl_to_tgsi)
521 _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
522
523 /*
524 * Convert Mesa program inputs to TGSI input register semantics.
525 */
526 for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
527 if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
528 const GLuint slot = fs_num_inputs++;
529
530 inputMapping[attr] = slot;
531
532 switch (attr) {
533 case FRAG_ATTRIB_WPOS:
534 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
535 input_semantic_index[slot] = 0;
536 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
537 break;
538 case FRAG_ATTRIB_COL0:
539 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
540 input_semantic_index[slot] = 0;
541 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr]);
542 break;
543 case FRAG_ATTRIB_COL1:
544 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
545 input_semantic_index[slot] = 1;
546 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr]);
547 break;
548 case FRAG_ATTRIB_FOGC:
549 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
550 input_semantic_index[slot] = 0;
551 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
552 break;
553 case FRAG_ATTRIB_FACE:
554 input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
555 input_semantic_index[slot] = 0;
556 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
557 break;
558 case FRAG_ATTRIB_CLIP_DIST0:
559 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
560 input_semantic_index[slot] = 0;
561 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
562 break;
563 case FRAG_ATTRIB_CLIP_DIST1:
564 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
565 input_semantic_index[slot] = 1;
566 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
567 break;
568 /* In most cases, there is nothing special about these
569 * inputs, so adopt a convention to use the generic
570 * semantic name and the mesa FRAG_ATTRIB_ number as the
571 * index.
572 *
573 * All that is required is that the vertex shader labels
574 * its own outputs similarly, and that the vertex shader
575 * generates at least every output required by the
576 * fragment shader plus fixed-function hardware (such as
577 * BFC).
578 *
579 * There is no requirement that semantic indexes start at
580 * zero or be restricted to a particular range -- nobody
581 * should be building tables based on semantic index.
582 */
583 case FRAG_ATTRIB_PNTC:
584 case FRAG_ATTRIB_TEX0:
585 case FRAG_ATTRIB_TEX1:
586 case FRAG_ATTRIB_TEX2:
587 case FRAG_ATTRIB_TEX3:
588 case FRAG_ATTRIB_TEX4:
589 case FRAG_ATTRIB_TEX5:
590 case FRAG_ATTRIB_TEX6:
591 case FRAG_ATTRIB_TEX7:
592 case FRAG_ATTRIB_VAR0:
593 default:
594 /* Actually, let's try and zero-base this just for
595 * readability of the generated TGSI.
596 */
597 assert(attr >= FRAG_ATTRIB_TEX0);
598 input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
599 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
600 if (attr == FRAG_ATTRIB_PNTC)
601 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
602 else
603 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr]);
604 break;
605 }
606 }
607 else {
608 inputMapping[attr] = -1;
609 }
610 }
611
612 /*
613 * Semantics and mapping for outputs
614 */
615 {
616 uint numColors = 0;
617 GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
618
619 /* if z is written, emit that first */
620 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
621 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
622 fs_output_semantic_index[fs_num_outputs] = 0;
623 outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
624 fs_num_outputs++;
625 outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
626 }
627
628 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
629 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
630 fs_output_semantic_index[fs_num_outputs] = 0;
631 outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
632 fs_num_outputs++;
633 outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
634 }
635
636 /* handle remaning outputs (color) */
637 for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
638 if (outputsWritten & BITFIELD64_BIT(attr)) {
639 switch (attr) {
640 case FRAG_RESULT_DEPTH:
641 case FRAG_RESULT_STENCIL:
642 /* handled above */
643 assert(0);
644 break;
645 case FRAG_RESULT_COLOR:
646 write_all = GL_TRUE; /* fallthrough */
647 default:
648 assert(attr == FRAG_RESULT_COLOR ||
649 (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
650 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
651 fs_output_semantic_index[fs_num_outputs] = numColors;
652 outputMapping[attr] = fs_num_outputs;
653 numColors++;
654 break;
655 }
656
657 fs_num_outputs++;
658 }
659 }
660 }
661
662 ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
663 if (ureg == NULL) {
664 FREE(variant);
665 return NULL;
666 }
667
668 if (ST_DEBUG & DEBUG_MESA) {
669 _mesa_print_program(&stfp->Base.Base);
670 _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
671 debug_printf("\n");
672 }
673 if (write_all == GL_TRUE)
674 ureg_property_fs_color0_writes_all_cbufs(ureg, 1);
675
676 if (stfp->Base.FragDepthLayout != FRAG_DEPTH_LAYOUT_NONE) {
677 switch (stfp->Base.FragDepthLayout) {
678 case FRAG_DEPTH_LAYOUT_ANY:
679 ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_ANY);
680 break;
681 case FRAG_DEPTH_LAYOUT_GREATER:
682 ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_GREATER);
683 break;
684 case FRAG_DEPTH_LAYOUT_LESS:
685 ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_LESS);
686 break;
687 case FRAG_DEPTH_LAYOUT_UNCHANGED:
688 ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
689 break;
690 default:
691 assert(0);
692 }
693 }
694
695 if (stfp->glsl_to_tgsi)
696 st_translate_program(st->ctx,
697 TGSI_PROCESSOR_FRAGMENT,
698 ureg,
699 stfp->glsl_to_tgsi,
700 &stfp->Base.Base,
701 /* inputs */
702 fs_num_inputs,
703 inputMapping,
704 input_semantic_name,
705 input_semantic_index,
706 interpMode,
707 /* outputs */
708 fs_num_outputs,
709 outputMapping,
710 fs_output_semantic_name,
711 fs_output_semantic_index, FALSE );
712 else
713 st_translate_mesa_program(st->ctx,
714 TGSI_PROCESSOR_FRAGMENT,
715 ureg,
716 &stfp->Base.Base,
717 /* inputs */
718 fs_num_inputs,
719 inputMapping,
720 input_semantic_name,
721 input_semantic_index,
722 interpMode,
723 /* outputs */
724 fs_num_outputs,
725 outputMapping,
726 fs_output_semantic_name,
727 fs_output_semantic_index, FALSE );
728
729 stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
730 ureg_destroy( ureg );
731 }
732
733 /* fill in variant */
734 variant->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
735 variant->key = *key;
736
737 if (ST_DEBUG & DEBUG_TGSI) {
738 tgsi_dump( stfp->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
739 debug_printf("\n");
740 }
741
742 if (deleteFP) {
743 /* Free the temporary program made above */
744 struct gl_fragment_program *fp = &stfp->Base;
745 _mesa_reference_fragprog(st->ctx, &fp, NULL);
746 }
747
748 return variant;
749 }
750
751
752 /**
753 * Translate fragment program if needed.
754 */
755 struct st_fp_variant *
756 st_get_fp_variant(struct st_context *st,
757 struct st_fragment_program *stfp,
758 const struct st_fp_variant_key *key)
759 {
760 struct st_fp_variant *fpv;
761
762 /* Search for existing variant */
763 for (fpv = stfp->variants; fpv; fpv = fpv->next) {
764 if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
765 break;
766 }
767 }
768
769 if (!fpv) {
770 /* create new */
771 fpv = st_translate_fragment_program(st, stfp, key);
772 if (fpv) {
773 /* insert into list */
774 fpv->next = stfp->variants;
775 stfp->variants = fpv;
776 }
777 }
778
779 return fpv;
780 }
781
782
783 /**
784 * Translate a geometry program to create a new variant.
785 */
786 static struct st_gp_variant *
787 st_translate_geometry_program(struct st_context *st,
788 struct st_geometry_program *stgp,
789 const struct st_gp_variant_key *key)
790 {
791 GLuint inputMapping[GEOM_ATTRIB_MAX];
792 GLuint outputMapping[GEOM_RESULT_MAX];
793 struct pipe_context *pipe = st->pipe;
794 GLuint attr;
795 const GLbitfield64 inputsRead = stgp->Base.Base.InputsRead;
796 GLuint vslot = 0;
797 GLuint num_generic = 0;
798
799 uint gs_num_inputs = 0;
800 uint gs_builtin_inputs = 0;
801 uint gs_array_offset = 0;
802
803 ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
804 ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
805 uint gs_num_outputs = 0;
806
807 GLint i;
808 GLuint maxSlot = 0;
809 struct ureg_program *ureg;
810
811 struct st_gp_variant *gpv;
812
813 gpv = CALLOC_STRUCT(st_gp_variant);
814 if (!gpv)
815 return NULL;
816
817 _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);
818 _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_VARYING);
819
820 ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
821 if (ureg == NULL) {
822 FREE(gpv);
823 return NULL;
824 }
825
826 /* which vertex output goes to the first geometry input */
827 vslot = 0;
828
829 memset(inputMapping, 0, sizeof(inputMapping));
830 memset(outputMapping, 0, sizeof(outputMapping));
831
832 /*
833 * Convert Mesa program inputs to TGSI input register semantics.
834 */
835 for (attr = 0; attr < GEOM_ATTRIB_MAX; attr++) {
836 if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
837 const GLuint slot = gs_num_inputs;
838
839 gs_num_inputs++;
840
841 inputMapping[attr] = slot;
842
843 stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs;
844 stgp->input_to_index[attr] = vslot;
845 stgp->index_to_input[vslot] = attr;
846 ++vslot;
847
848 if (attr != GEOM_ATTRIB_PRIMITIVE_ID) {
849 gs_array_offset += 2;
850 } else
851 ++gs_builtin_inputs;
852
853 #if 0
854 debug_printf("input map at %d = %d\n",
855 slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
856 #endif
857
858 switch (attr) {
859 case GEOM_ATTRIB_PRIMITIVE_ID:
860 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
861 stgp->input_semantic_index[slot] = 0;
862 break;
863 case GEOM_ATTRIB_POSITION:
864 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
865 stgp->input_semantic_index[slot] = 0;
866 break;
867 case GEOM_ATTRIB_COLOR0:
868 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
869 stgp->input_semantic_index[slot] = 0;
870 break;
871 case GEOM_ATTRIB_COLOR1:
872 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
873 stgp->input_semantic_index[slot] = 1;
874 break;
875 case GEOM_ATTRIB_FOG_FRAG_COORD:
876 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
877 stgp->input_semantic_index[slot] = 0;
878 break;
879 case GEOM_ATTRIB_TEX_COORD:
880 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
881 stgp->input_semantic_index[slot] = num_generic++;
882 break;
883 case GEOM_ATTRIB_VAR0:
884 /* fall-through */
885 default:
886 stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
887 stgp->input_semantic_index[slot] = num_generic++;
888 }
889 }
890 }
891
892 /* initialize output semantics to defaults */
893 for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
894 gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
895 gs_output_semantic_index[i] = 0;
896 }
897
898 num_generic = 0;
899 /*
900 * Determine number of outputs, the (default) output register
901 * mapping and the semantic information for each output.
902 */
903 for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
904 if (stgp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) {
905 GLuint slot;
906
907 slot = gs_num_outputs;
908 gs_num_outputs++;
909 outputMapping[attr] = slot;
910
911 switch (attr) {
912 case GEOM_RESULT_POS:
913 assert(slot == 0);
914 gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
915 gs_output_semantic_index[slot] = 0;
916 break;
917 case GEOM_RESULT_COL0:
918 gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
919 gs_output_semantic_index[slot] = 0;
920 break;
921 case GEOM_RESULT_COL1:
922 gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
923 gs_output_semantic_index[slot] = 1;
924 break;
925 case GEOM_RESULT_SCOL0:
926 gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
927 gs_output_semantic_index[slot] = 0;
928 break;
929 case GEOM_RESULT_SCOL1:
930 gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
931 gs_output_semantic_index[slot] = 1;
932 break;
933 case GEOM_RESULT_FOGC:
934 gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
935 gs_output_semantic_index[slot] = 0;
936 break;
937 case GEOM_RESULT_PSIZ:
938 gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
939 gs_output_semantic_index[slot] = 0;
940 break;
941 case GEOM_RESULT_TEX0:
942 case GEOM_RESULT_TEX1:
943 case GEOM_RESULT_TEX2:
944 case GEOM_RESULT_TEX3:
945 case GEOM_RESULT_TEX4:
946 case GEOM_RESULT_TEX5:
947 case GEOM_RESULT_TEX6:
948 case GEOM_RESULT_TEX7:
949 /* fall-through */
950 case GEOM_RESULT_VAR0:
951 /* fall-through */
952 default:
953 assert(slot < Elements(gs_output_semantic_name));
954 /* use default semantic info */
955 gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
956 gs_output_semantic_index[slot] = num_generic++;
957 }
958 }
959 }
960
961 assert(gs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);
962
963 /* find max output slot referenced to compute gs_num_outputs */
964 for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
965 if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)
966 maxSlot = outputMapping[attr];
967 }
968 gs_num_outputs = maxSlot + 1;
969
970 #if 0 /* debug */
971 {
972 GLuint i;
973 printf("outputMapping? %d\n", outputMapping ? 1 : 0);
974 if (outputMapping) {
975 printf("attr -> slot\n");
976 for (i = 0; i < 16; i++) {
977 printf(" %2d %3d\n", i, outputMapping[i]);
978 }
979 }
980 printf("slot sem_name sem_index\n");
981 for (i = 0; i < gs_num_outputs; i++) {
982 printf(" %2d %d %d\n",
983 i,
984 gs_output_semantic_name[i],
985 gs_output_semantic_index[i]);
986 }
987 }
988 #endif
989
990 /* free old shader state, if any */
991 if (stgp->tgsi.tokens) {
992 st_free_tokens(stgp->tgsi.tokens);
993 stgp->tgsi.tokens = NULL;
994 }
995
996 ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
997 ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
998 ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
999
1000 st_translate_mesa_program(st->ctx,
1001 TGSI_PROCESSOR_GEOMETRY,
1002 ureg,
1003 &stgp->Base.Base,
1004 /* inputs */
1005 gs_num_inputs,
1006 inputMapping,
1007 stgp->input_semantic_name,
1008 stgp->input_semantic_index,
1009 NULL,
1010 /* outputs */
1011 gs_num_outputs,
1012 outputMapping,
1013 gs_output_semantic_name,
1014 gs_output_semantic_index,
1015 FALSE);
1016
1017 stgp->num_inputs = gs_num_inputs;
1018 stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
1019 ureg_destroy( ureg );
1020
1021 if (stgp->glsl_to_tgsi) {
1022 st_translate_stream_output_info(stgp->glsl_to_tgsi,
1023 outputMapping,
1024 &stgp->tgsi.stream_output);
1025 }
1026
1027 /* fill in new variant */
1028 gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
1029 gpv->key = *key;
1030
1031 if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1032 _mesa_print_program(&stgp->Base.Base);
1033 debug_printf("\n");
1034 }
1035
1036 if (ST_DEBUG & DEBUG_TGSI) {
1037 tgsi_dump(stgp->tgsi.tokens, 0);
1038 debug_printf("\n");
1039 }
1040
1041 return gpv;
1042 }
1043
1044
1045 /**
1046 * Get/create geometry program variant.
1047 */
1048 struct st_gp_variant *
1049 st_get_gp_variant(struct st_context *st,
1050 struct st_geometry_program *stgp,
1051 const struct st_gp_variant_key *key)
1052 {
1053 struct st_gp_variant *gpv;
1054
1055 /* Search for existing variant */
1056 for (gpv = stgp->variants; gpv; gpv = gpv->next) {
1057 if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
1058 break;
1059 }
1060 }
1061
1062 if (!gpv) {
1063 /* create new */
1064 gpv = st_translate_geometry_program(st, stgp, key);
1065 if (gpv) {
1066 /* insert into list */
1067 gpv->next = stgp->variants;
1068 stgp->variants = gpv;
1069 }
1070 }
1071
1072 return gpv;
1073 }
1074
1075
1076
1077
1078 /**
1079 * Debug- print current shader text
1080 */
1081 void
1082 st_print_shaders(struct gl_context *ctx)
1083 {
1084 struct gl_shader_program *shProg[3] = {
1085 ctx->Shader.CurrentVertexProgram,
1086 ctx->Shader.CurrentGeometryProgram,
1087 ctx->Shader.CurrentFragmentProgram,
1088 };
1089 unsigned j;
1090
1091 for (j = 0; j < 3; j++) {
1092 unsigned i;
1093
1094 if (shProg[j] == NULL)
1095 continue;
1096
1097 for (i = 0; i < shProg[j]->NumShaders; i++) {
1098 struct gl_shader *sh;
1099
1100 switch (shProg[j]->Shaders[i]->Type) {
1101 case GL_VERTEX_SHADER:
1102 sh = (i != 0) ? NULL : shProg[j]->Shaders[i];
1103 break;
1104 case GL_GEOMETRY_SHADER_ARB:
1105 sh = (i != 1) ? NULL : shProg[j]->Shaders[i];
1106 break;
1107 case GL_FRAGMENT_SHADER:
1108 sh = (i != 2) ? NULL : shProg[j]->Shaders[i];
1109 break;
1110 default:
1111 assert(0);
1112 sh = NULL;
1113 break;
1114 }
1115
1116 if (sh != NULL) {
1117 printf("GLSL shader %u of %u:\n", i, shProg[j]->NumShaders);
1118 printf("%s\n", sh->Source);
1119 }
1120 }
1121 }
1122 }
1123
1124
1125 /**
1126 * Vert/Geom/Frag programs have per-context variants. Free all the
1127 * variants attached to the given program which match the given context.
1128 */
1129 static void
1130 destroy_program_variants(struct st_context *st, struct gl_program *program)
1131 {
1132 if (!program)
1133 return;
1134
1135 switch (program->Target) {
1136 case GL_VERTEX_PROGRAM_ARB:
1137 {
1138 struct st_vertex_program *stvp = (struct st_vertex_program *) program;
1139 struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1140
1141 for (vpv = stvp->variants; vpv; ) {
1142 struct st_vp_variant *next = vpv->next;
1143 if (vpv->key.st == st) {
1144 /* unlink from list */
1145 *prevPtr = next;
1146 /* destroy this variant */
1147 delete_vp_variant(st, vpv);
1148 }
1149 else {
1150 prevPtr = &vpv->next;
1151 }
1152 vpv = next;
1153 }
1154 }
1155 break;
1156 case GL_FRAGMENT_PROGRAM_ARB:
1157 {
1158 struct st_fragment_program *stfp =
1159 (struct st_fragment_program *) program;
1160 struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1161
1162 for (fpv = stfp->variants; fpv; ) {
1163 struct st_fp_variant *next = fpv->next;
1164 if (fpv->key.st == st) {
1165 /* unlink from list */
1166 *prevPtr = next;
1167 /* destroy this variant */
1168 delete_fp_variant(st, fpv);
1169 }
1170 else {
1171 prevPtr = &fpv->next;
1172 }
1173 fpv = next;
1174 }
1175 }
1176 break;
1177 case MESA_GEOMETRY_PROGRAM:
1178 {
1179 struct st_geometry_program *stgp =
1180 (struct st_geometry_program *) program;
1181 struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
1182
1183 for (gpv = stgp->variants; gpv; ) {
1184 struct st_gp_variant *next = gpv->next;
1185 if (gpv->key.st == st) {
1186 /* unlink from list */
1187 *prevPtr = next;
1188 /* destroy this variant */
1189 delete_gp_variant(st, gpv);
1190 }
1191 else {
1192 prevPtr = &gpv->next;
1193 }
1194 gpv = next;
1195 }
1196 }
1197 break;
1198 default:
1199 _mesa_problem(NULL, "Unexpected program target 0x%x in "
1200 "destroy_program_variants_cb()", program->Target);
1201 }
1202 }
1203
1204
1205 /**
1206 * Callback for _mesa_HashWalk. Free all the shader's program variants
1207 * which match the given context.
1208 */
1209 static void
1210 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1211 {
1212 struct st_context *st = (struct st_context *) userData;
1213 struct gl_shader *shader = (struct gl_shader *) data;
1214
1215 switch (shader->Type) {
1216 case GL_SHADER_PROGRAM_MESA:
1217 {
1218 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1219 GLuint i;
1220
1221 for (i = 0; i < shProg->NumShaders; i++) {
1222 destroy_program_variants(st, shProg->Shaders[i]->Program);
1223 }
1224
1225 for (i = 0; i < Elements(shProg->_LinkedShaders); i++) {
1226 if (shProg->_LinkedShaders[i])
1227 destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1228 }
1229 }
1230 break;
1231 case GL_VERTEX_SHADER:
1232 case GL_FRAGMENT_SHADER:
1233 case GL_GEOMETRY_SHADER:
1234 {
1235 destroy_program_variants(st, shader->Program);
1236 }
1237 break;
1238 default:
1239 assert(0);
1240 }
1241 }
1242
1243
1244 /**
1245 * Callback for _mesa_HashWalk. Free all the program variants which match
1246 * the given context.
1247 */
1248 static void
1249 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1250 {
1251 struct st_context *st = (struct st_context *) userData;
1252 struct gl_program *program = (struct gl_program *) data;
1253 destroy_program_variants(st, program);
1254 }
1255
1256
1257 /**
1258 * Walk over all shaders and programs to delete any variants which
1259 * belong to the given context.
1260 * This is called during context tear-down.
1261 */
1262 void
1263 st_destroy_program_variants(struct st_context *st)
1264 {
1265 /* ARB vert/frag program */
1266 _mesa_HashWalk(st->ctx->Shared->Programs,
1267 destroy_program_variants_cb, st);
1268
1269 /* GLSL vert/frag/geom shaders */
1270 _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1271 destroy_shader_program_variants_cb, st);
1272 }