projects / mesa.git / blob
? search:


63ffad76426a0bf354747c9e55005f8e103cdd04
[mesa.git] / src / mesa / state_tracker / st_program.c
1 /**************************************************************************
2 *
3 * Copyright 2007 VMware, Inc.
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 VMWARE 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 <keithw@vmware.com>
30 * Brian Paul
31 */
32
33
34 #include "main/imports.h"
35 #include "main/hash.h"
36 #include "main/mtypes.h"
37 #include "program/prog_parameter.h"
38 #include "program/prog_print.h"
39 #include "program/programopt.h"
40
41 #include "pipe/p_context.h"
42 #include "pipe/p_defines.h"
43 #include "pipe/p_shader_tokens.h"
44 #include "draw/draw_context.h"
45 #include "tgsi/tgsi_dump.h"
46 #include "tgsi/tgsi_ureg.h"
47
48 #include "st_debug.h"
49 #include "st_cb_bitmap.h"
50 #include "st_cb_drawpixels.h"
51 #include "st_context.h"
52 #include "st_program.h"
53 #include "st_mesa_to_tgsi.h"
54 #include "cso_cache/cso_context.h"
55
56
57
58 /**
59 * Delete a vertex program variant. Note the caller must unlink
60 * the variant from the linked list.
61 */
62 static void
63 delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
64 {
65 if (vpv->driver_shader)
66 cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
67
68 if (vpv->draw_shader)
69 draw_delete_vertex_shader( st->draw, vpv->draw_shader );
70
71 if (vpv->tgsi.tokens)
72 ureg_free_tokens(vpv->tgsi.tokens);
73
74 free( vpv );
75 }
76
77
78
79 /**
80 * Clean out any old compilations:
81 */
82 void
83 st_release_vp_variants( struct st_context *st,
84 struct st_vertex_program *stvp )
85 {
86 struct st_vp_variant *vpv;
87
88 for (vpv = stvp->variants; vpv; ) {
89 struct st_vp_variant *next = vpv->next;
90 delete_vp_variant(st, vpv);
91 vpv = next;
92 }
93
94 stvp->variants = NULL;
95 }
96
97
98
99 /**
100 * Delete a fragment program variant. Note the caller must unlink
101 * the variant from the linked list.
102 */
103 static void
104 delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)
105 {
106 if (fpv->driver_shader)
107 cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
108 if (fpv->parameters)
109 _mesa_free_parameter_list(fpv->parameters);
110 if (fpv->tgsi.tokens)
111 ureg_free_tokens(fpv->tgsi.tokens);
112 free(fpv);
113 }
114
115
116 /**
117 * Free all variants of a fragment program.
118 */
119 void
120 st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)
121 {
122 struct st_fp_variant *fpv;
123
124 for (fpv = stfp->variants; fpv; ) {
125 struct st_fp_variant *next = fpv->next;
126 delete_fp_variant(st, fpv);
127 fpv = next;
128 }
129
130 stfp->variants = NULL;
131 }
132
133
134 /**
135 * Delete a geometry program variant. Note the caller must unlink
136 * the variant from the linked list.
137 */
138 static void
139 delete_gp_variant(struct st_context *st, struct st_gp_variant *gpv)
140 {
141 if (gpv->driver_shader)
142 cso_delete_geometry_shader(st->cso_context, gpv->driver_shader);
143
144 free(gpv);
145 }
146
147
148 /**
149 * Free all variants of a geometry program.
150 */
151 void
152 st_release_gp_variants(struct st_context *st, struct st_geometry_program *stgp)
153 {
154 struct st_gp_variant *gpv;
155
156 for (gpv = stgp->variants; gpv; ) {
157 struct st_gp_variant *next = gpv->next;
158 delete_gp_variant(st, gpv);
159 gpv = next;
160 }
161
162 stgp->variants = NULL;
163 }
164
165
166 /**
167 * Delete a tessellation control program variant. Note the caller must unlink
168 * the variant from the linked list.
169 */
170 static void
171 delete_tcp_variant(struct st_context *st, struct st_tcp_variant *tcpv)
172 {
173 if (tcpv->driver_shader)
174 cso_delete_tessctrl_shader(st->cso_context, tcpv->driver_shader);
175
176 free(tcpv);
177 }
178
179
180 /**
181 * Free all variants of a tessellation control program.
182 */
183 void
184 st_release_tcp_variants(struct st_context *st, struct st_tessctrl_program *sttcp)
185 {
186 struct st_tcp_variant *tcpv;
187
188 for (tcpv = sttcp->variants; tcpv; ) {
189 struct st_tcp_variant *next = tcpv->next;
190 delete_tcp_variant(st, tcpv);
191 tcpv = next;
192 }
193
194 sttcp->variants = NULL;
195 }
196
197
198 /**
199 * Delete a tessellation evaluation program variant. Note the caller must
200 * unlink the variant from the linked list.
201 */
202 static void
203 delete_tep_variant(struct st_context *st, struct st_tep_variant *tepv)
204 {
205 if (tepv->driver_shader)
206 cso_delete_tesseval_shader(st->cso_context, tepv->driver_shader);
207
208 free(tepv);
209 }
210
211
212 /**
213 * Free all variants of a tessellation evaluation program.
214 */
215 void
216 st_release_tep_variants(struct st_context *st, struct st_tesseval_program *sttep)
217 {
218 struct st_tep_variant *tepv;
219
220 for (tepv = sttep->variants; tepv; ) {
221 struct st_tep_variant *next = tepv->next;
222 delete_tep_variant(st, tepv);
223 tepv = next;
224 }
225
226 sttep->variants = NULL;
227 }
228
229
230 /**
231 * Translate a vertex program to create a new variant.
232 */
233 static struct st_vp_variant *
234 st_translate_vertex_program(struct st_context *st,
235 struct st_vertex_program *stvp,
236 const struct st_vp_variant_key *key)
237 {
238 struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
239 struct pipe_context *pipe = st->pipe;
240 struct ureg_program *ureg;
241 enum pipe_error error;
242 unsigned num_outputs;
243 GLuint attr;
244
245 stvp->num_inputs = 0;
246 stvp->num_outputs = 0;
247
248 if (stvp->Base.IsPositionInvariant)
249 _mesa_insert_mvp_code(st->ctx, &stvp->Base);
250
251 /*
252 * Determine number of inputs, the mappings between VERT_ATTRIB_x
253 * and TGSI generic input indexes, plus input attrib semantic info.
254 */
255 for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
256 if ((stvp->Base.Base.InputsRead & BITFIELD64_BIT(attr)) != 0) {
257 stvp->input_to_index[attr] = stvp->num_inputs;
258 stvp->index_to_input[stvp->num_inputs] = attr;
259 stvp->num_inputs++;
260 if ((stvp->Base.Base.DoubleInputsRead & BITFIELD64_BIT(attr)) != 0) {
261 /* add placeholder for second part of a double attribute */
262 stvp->index_to_input[stvp->num_inputs] = ST_DOUBLE_ATTRIB_PLACEHOLDER;
263 stvp->num_inputs++;
264 }
265 }
266 }
267 /* bit of a hack, presetup potentially unused edgeflag input */
268 stvp->input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
269 stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
270
271 /* Compute mapping of vertex program outputs to slots.
272 */
273 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
274 if ((stvp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {
275 stvp->result_to_output[attr] = ~0;
276 }
277 else {
278 unsigned slot = stvp->num_outputs++;
279
280 stvp->result_to_output[attr] = slot;
281 stvp->output_slot_to_attr[slot] = attr;
282
283 switch (attr) {
284 case VARYING_SLOT_POS:
285 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
286 stvp->output_semantic_index[slot] = 0;
287 break;
288 case VARYING_SLOT_COL0:
289 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
290 stvp->output_semantic_index[slot] = 0;
291 break;
292 case VARYING_SLOT_COL1:
293 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
294 stvp->output_semantic_index[slot] = 1;
295 break;
296 case VARYING_SLOT_BFC0:
297 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
298 stvp->output_semantic_index[slot] = 0;
299 break;
300 case VARYING_SLOT_BFC1:
301 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
302 stvp->output_semantic_index[slot] = 1;
303 break;
304 case VARYING_SLOT_FOGC:
305 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
306 stvp->output_semantic_index[slot] = 0;
307 break;
308 case VARYING_SLOT_PSIZ:
309 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
310 stvp->output_semantic_index[slot] = 0;
311 break;
312 case VARYING_SLOT_CLIP_DIST0:
313 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
314 stvp->output_semantic_index[slot] = 0;
315 break;
316 case VARYING_SLOT_CLIP_DIST1:
317 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
318 stvp->output_semantic_index[slot] = 1;
319 break;
320 case VARYING_SLOT_EDGE:
321 assert(0);
322 break;
323 case VARYING_SLOT_CLIP_VERTEX:
324 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
325 stvp->output_semantic_index[slot] = 0;
326 break;
327 case VARYING_SLOT_LAYER:
328 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
329 stvp->output_semantic_index[slot] = 0;
330 break;
331 case VARYING_SLOT_VIEWPORT:
332 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
333 stvp->output_semantic_index[slot] = 0;
334 break;
335
336 case VARYING_SLOT_TEX0:
337 case VARYING_SLOT_TEX1:
338 case VARYING_SLOT_TEX2:
339 case VARYING_SLOT_TEX3:
340 case VARYING_SLOT_TEX4:
341 case VARYING_SLOT_TEX5:
342 case VARYING_SLOT_TEX6:
343 case VARYING_SLOT_TEX7:
344 if (st->needs_texcoord_semantic) {
345 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
346 stvp->output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
347 break;
348 }
349 /* fall through */
350 case VARYING_SLOT_VAR0:
351 default:
352 assert(attr >= VARYING_SLOT_VAR0 ||
353 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
354 stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
355 stvp->output_semantic_index[slot] =
356 st_get_generic_varying_index(st, attr);
357 break;
358 }
359 }
360 }
361 /* similar hack to above, presetup potentially unused edgeflag output */
362 stvp->result_to_output[VARYING_SLOT_EDGE] = stvp->num_outputs;
363 stvp->output_semantic_name[stvp->num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
364 stvp->output_semantic_index[stvp->num_outputs] = 0;
365
366 if (!stvp->glsl_to_tgsi)
367 _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
368
369 ureg = ureg_create_with_screen(TGSI_PROCESSOR_VERTEX, st->pipe->screen);
370 if (ureg == NULL) {
371 free(vpv);
372 return NULL;
373 }
374
375 vpv->key = *key;
376
377 vpv->num_inputs = stvp->num_inputs;
378 num_outputs = stvp->num_outputs;
379 if (key->passthrough_edgeflags) {
380 vpv->num_inputs++;
381 num_outputs++;
382 }
383
384 if (ST_DEBUG & DEBUG_MESA) {
385 _mesa_print_program(&stvp->Base.Base);
386 _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
387 debug_printf("\n");
388 }
389
390 if (stvp->glsl_to_tgsi)
391 error = st_translate_program(st->ctx,
392 TGSI_PROCESSOR_VERTEX,
393 ureg,
394 stvp->glsl_to_tgsi,
395 &stvp->Base.Base,
396 /* inputs */
397 vpv->num_inputs,
398 stvp->input_to_index,
399 NULL, /* inputSlotToAttr */
400 NULL, /* input semantic name */
401 NULL, /* input semantic index */
402 NULL, /* interp mode */
403 NULL, /* interp location */
404 /* outputs */
405 num_outputs,
406 stvp->result_to_output,
407 stvp->output_slot_to_attr,
408 stvp->output_semantic_name,
409 stvp->output_semantic_index,
410 key->passthrough_edgeflags,
411 key->clamp_color);
412 else
413 error = st_translate_mesa_program(st->ctx,
414 TGSI_PROCESSOR_VERTEX,
415 ureg,
416 &stvp->Base.Base,
417 /* inputs */
418 vpv->num_inputs,
419 stvp->input_to_index,
420 NULL, /* input semantic name */
421 NULL, /* input semantic index */
422 NULL,
423 /* outputs */
424 num_outputs,
425 stvp->result_to_output,
426 stvp->output_semantic_name,
427 stvp->output_semantic_index,
428 key->passthrough_edgeflags,
429 key->clamp_color);
430
431 if (error)
432 goto fail;
433
434 vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );
435 if (!vpv->tgsi.tokens)
436 goto fail;
437
438 ureg_destroy( ureg );
439
440 if (stvp->glsl_to_tgsi) {
441 st_translate_stream_output_info(stvp->glsl_to_tgsi,
442 stvp->result_to_output,
443 &vpv->tgsi.stream_output);
444 }
445
446 if (ST_DEBUG & DEBUG_TGSI) {
447 tgsi_dump(vpv->tgsi.tokens, 0);
448 debug_printf("\n");
449 }
450
451 vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
452 return vpv;
453
454 fail:
455 debug_printf("%s: failed to translate Mesa program:\n", __func__);
456 _mesa_print_program(&stvp->Base.Base);
457 debug_assert(0);
458
459 ureg_destroy( ureg );
460 return NULL;
461 }
462
463
464 /**
465 * Find/create a vertex program variant.
466 */
467 struct st_vp_variant *
468 st_get_vp_variant(struct st_context *st,
469 struct st_vertex_program *stvp,
470 const struct st_vp_variant_key *key)
471 {
472 struct st_vp_variant *vpv;
473
474 /* Search for existing variant */
475 for (vpv = stvp->variants; vpv; vpv = vpv->next) {
476 if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
477 break;
478 }
479 }
480
481 if (!vpv) {
482 /* create now */
483 vpv = st_translate_vertex_program(st, stvp, key);
484 if (vpv) {
485 /* insert into list */
486 vpv->next = stvp->variants;
487 stvp->variants = vpv;
488 }
489 }
490
491 return vpv;
492 }
493
494
495 static unsigned
496 st_translate_interp(enum glsl_interp_qualifier glsl_qual, bool is_color)
497 {
498 switch (glsl_qual) {
499 case INTERP_QUALIFIER_NONE:
500 if (is_color)
501 return TGSI_INTERPOLATE_COLOR;
502 return TGSI_INTERPOLATE_PERSPECTIVE;
503 case INTERP_QUALIFIER_SMOOTH:
504 return TGSI_INTERPOLATE_PERSPECTIVE;
505 case INTERP_QUALIFIER_FLAT:
506 return TGSI_INTERPOLATE_CONSTANT;
507 case INTERP_QUALIFIER_NOPERSPECTIVE:
508 return TGSI_INTERPOLATE_LINEAR;
509 default:
510 assert(0 && "unexpected interp mode in st_translate_interp()");
511 return TGSI_INTERPOLATE_PERSPECTIVE;
512 }
513 }
514
515
516 /**
517 * Translate a Mesa fragment shader into a TGSI shader using extra info in
518 * the key.
519 * \return new fragment program variant
520 */
521 static struct st_fp_variant *
522 st_translate_fragment_program(struct st_context *st,
523 struct st_fragment_program *stfp,
524 const struct st_fp_variant_key *key)
525 {
526 struct pipe_context *pipe = st->pipe;
527 struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
528 GLboolean deleteFP = GL_FALSE;
529
530 GLuint outputMapping[FRAG_RESULT_MAX];
531 GLuint inputMapping[VARYING_SLOT_MAX];
532 GLuint inputSlotToAttr[VARYING_SLOT_MAX];
533 GLuint interpMode[PIPE_MAX_SHADER_INPUTS]; /* XXX size? */
534 GLuint interpLocation[PIPE_MAX_SHADER_INPUTS];
535 GLuint attr;
536 GLbitfield64 inputsRead;
537 struct ureg_program *ureg;
538
539 GLboolean write_all = GL_FALSE;
540
541 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
542 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
543 uint fs_num_inputs = 0;
544
545 ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
546 ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
547 uint fs_num_outputs = 0;
548
549 if (!variant)
550 return NULL;
551
552 assert(!(key->bitmap && key->drawpixels));
553 memset(inputSlotToAttr, ~0, sizeof(inputSlotToAttr));
554
555 if (key->bitmap) {
556 /* glBitmap drawing */
557 struct gl_fragment_program *fp; /* we free this temp program below */
558
559 st_make_bitmap_fragment_program(st, &stfp->Base,
560 &fp, &variant->bitmap_sampler);
561
562 variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
563 stfp = st_fragment_program(fp);
564 deleteFP = GL_TRUE;
565 }
566 else if (key->drawpixels) {
567 /* glDrawPixels drawing */
568 struct gl_fragment_program *fp; /* we free this temp program below */
569
570 if (key->drawpixels_z || key->drawpixels_stencil) {
571 fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,
572 key->drawpixels_stencil);
573 }
574 else {
575 /* RGBA */
576 st_make_drawpix_fragment_program(st, &stfp->Base, &fp);
577 variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
578 deleteFP = GL_TRUE;
579 }
580 stfp = st_fragment_program(fp);
581 }
582
583 if (!stfp->glsl_to_tgsi)
584 _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
585
586 /*
587 * Convert Mesa program inputs to TGSI input register semantics.
588 */
589 inputsRead = stfp->Base.Base.InputsRead;
590 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
591 if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
592 const GLuint slot = fs_num_inputs++;
593
594 inputMapping[attr] = slot;
595 inputSlotToAttr[slot] = attr;
596 if (stfp->Base.IsCentroid & BITFIELD64_BIT(attr))
597 interpLocation[slot] = TGSI_INTERPOLATE_LOC_CENTROID;
598 else if (stfp->Base.IsSample & BITFIELD64_BIT(attr))
599 interpLocation[slot] = TGSI_INTERPOLATE_LOC_SAMPLE;
600 else
601 interpLocation[slot] = TGSI_INTERPOLATE_LOC_CENTER;
602
603 if (stfp->Base.Base.SystemValuesRead & (SYSTEM_BIT_SAMPLE_ID |
604 SYSTEM_BIT_SAMPLE_POS) ||
605 key->persample_shading)
606 interpLocation[slot] = TGSI_INTERPOLATE_LOC_SAMPLE;
607
608 switch (attr) {
609 case VARYING_SLOT_POS:
610 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
611 input_semantic_index[slot] = 0;
612 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
613 break;
614 case VARYING_SLOT_COL0:
615 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
616 input_semantic_index[slot] = 0;
617 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
618 TRUE);
619 break;
620 case VARYING_SLOT_COL1:
621 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
622 input_semantic_index[slot] = 1;
623 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
624 TRUE);
625 break;
626 case VARYING_SLOT_FOGC:
627 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
628 input_semantic_index[slot] = 0;
629 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
630 break;
631 case VARYING_SLOT_FACE:
632 input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
633 input_semantic_index[slot] = 0;
634 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
635 break;
636 case VARYING_SLOT_PRIMITIVE_ID:
637 input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
638 input_semantic_index[slot] = 0;
639 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
640 break;
641 case VARYING_SLOT_LAYER:
642 input_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
643 input_semantic_index[slot] = 0;
644 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
645 break;
646 case VARYING_SLOT_VIEWPORT:
647 input_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
648 input_semantic_index[slot] = 0;
649 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
650 break;
651 case VARYING_SLOT_CLIP_DIST0:
652 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
653 input_semantic_index[slot] = 0;
654 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
655 break;
656 case VARYING_SLOT_CLIP_DIST1:
657 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
658 input_semantic_index[slot] = 1;
659 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
660 break;
661 /* In most cases, there is nothing special about these
662 * inputs, so adopt a convention to use the generic
663 * semantic name and the mesa VARYING_SLOT_ number as the
664 * index.
665 *
666 * All that is required is that the vertex shader labels
667 * its own outputs similarly, and that the vertex shader
668 * generates at least every output required by the
669 * fragment shader plus fixed-function hardware (such as
670 * BFC).
671 *
672 * However, some drivers may need us to identify the PNTC and TEXi
673 * varyings if, for example, their capability to replace them with
674 * sprite coordinates is limited.
675 */
676 case VARYING_SLOT_PNTC:
677 if (st->needs_texcoord_semantic) {
678 input_semantic_name[slot] = TGSI_SEMANTIC_PCOORD;
679 input_semantic_index[slot] = 0;
680 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
681 break;
682 }
683 /* fall through */
684 case VARYING_SLOT_TEX0:
685 case VARYING_SLOT_TEX1:
686 case VARYING_SLOT_TEX2:
687 case VARYING_SLOT_TEX3:
688 case VARYING_SLOT_TEX4:
689 case VARYING_SLOT_TEX5:
690 case VARYING_SLOT_TEX6:
691 case VARYING_SLOT_TEX7:
692 if (st->needs_texcoord_semantic) {
693 input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
694 input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
695 interpMode[slot] =
696 st_translate_interp(stfp->Base.InterpQualifier[attr], FALSE);
697 break;
698 }
699 /* fall through */
700 case VARYING_SLOT_VAR0:
701 default:
702 /* Semantic indices should be zero-based because drivers may choose
703 * to assign a fixed slot determined by that index.
704 * This is useful because ARB_separate_shader_objects uses location
705 * qualifiers for linkage, and if the semantic index corresponds to
706 * these locations, linkage passes in the driver become unecessary.
707 *
708 * If needs_texcoord_semantic is true, no semantic indices will be
709 * consumed for the TEXi varyings, and we can base the locations of
710 * the user varyings on VAR0. Otherwise, we use TEX0 as base index.
711 */
712 assert(attr >= VARYING_SLOT_VAR0 || attr == VARYING_SLOT_PNTC ||
713 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
714 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
715 input_semantic_index[slot] = st_get_generic_varying_index(st, attr);
716 if (attr == VARYING_SLOT_PNTC)
717 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
718 else
719 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
720 FALSE);
721 break;
722 }
723 }
724 else {
725 inputMapping[attr] = -1;
726 }
727 }
728
729 /*
730 * Semantics and mapping for outputs
731 */
732 {
733 uint numColors = 0;
734 GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
735
736 /* if z is written, emit that first */
737 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
738 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
739 fs_output_semantic_index[fs_num_outputs] = 0;
740 outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
741 fs_num_outputs++;
742 outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
743 }
744
745 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
746 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
747 fs_output_semantic_index[fs_num_outputs] = 0;
748 outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
749 fs_num_outputs++;
750 outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
751 }
752
753 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)) {
754 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_SAMPLEMASK;
755 fs_output_semantic_index[fs_num_outputs] = 0;
756 outputMapping[FRAG_RESULT_SAMPLE_MASK] = fs_num_outputs;
757 fs_num_outputs++;
758 outputsWritten &= ~(1 << FRAG_RESULT_SAMPLE_MASK);
759 }
760
761 /* handle remaining outputs (color) */
762 for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
763 if (outputsWritten & BITFIELD64_BIT(attr)) {
764 switch (attr) {
765 case FRAG_RESULT_DEPTH:
766 case FRAG_RESULT_STENCIL:
767 case FRAG_RESULT_SAMPLE_MASK:
768 /* handled above */
769 assert(0);
770 break;
771 case FRAG_RESULT_COLOR:
772 write_all = GL_TRUE; /* fallthrough */
773 default:
774 assert(attr == FRAG_RESULT_COLOR ||
775 (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
776 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
777 fs_output_semantic_index[fs_num_outputs] = numColors;
778 outputMapping[attr] = fs_num_outputs;
779 numColors++;
780 break;
781 }
782
783 fs_num_outputs++;
784 }
785 }
786 }
787
788 ureg = ureg_create_with_screen(TGSI_PROCESSOR_FRAGMENT, st->pipe->screen);
789 if (ureg == NULL) {
790 free(variant);
791 return NULL;
792 }
793
794 if (ST_DEBUG & DEBUG_MESA) {
795 _mesa_print_program(&stfp->Base.Base);
796 _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
797 debug_printf("\n");
798 }
799 if (write_all == GL_TRUE)
800 ureg_property(ureg, TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS, 1);
801
802 if (stfp->Base.FragDepthLayout != FRAG_DEPTH_LAYOUT_NONE) {
803 switch (stfp->Base.FragDepthLayout) {
804 case FRAG_DEPTH_LAYOUT_ANY:
805 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
806 TGSI_FS_DEPTH_LAYOUT_ANY);
807 break;
808 case FRAG_DEPTH_LAYOUT_GREATER:
809 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
810 TGSI_FS_DEPTH_LAYOUT_GREATER);
811 break;
812 case FRAG_DEPTH_LAYOUT_LESS:
813 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
814 TGSI_FS_DEPTH_LAYOUT_LESS);
815 break;
816 case FRAG_DEPTH_LAYOUT_UNCHANGED:
817 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
818 TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
819 break;
820 default:
821 assert(0);
822 }
823 }
824
825 if (stfp->glsl_to_tgsi)
826 st_translate_program(st->ctx,
827 TGSI_PROCESSOR_FRAGMENT,
828 ureg,
829 stfp->glsl_to_tgsi,
830 &stfp->Base.Base,
831 /* inputs */
832 fs_num_inputs,
833 inputMapping,
834 inputSlotToAttr,
835 input_semantic_name,
836 input_semantic_index,
837 interpMode,
838 interpLocation,
839 /* outputs */
840 fs_num_outputs,
841 outputMapping,
842 NULL,
843 fs_output_semantic_name,
844 fs_output_semantic_index, FALSE,
845 key->clamp_color );
846 else
847 st_translate_mesa_program(st->ctx,
848 TGSI_PROCESSOR_FRAGMENT,
849 ureg,
850 &stfp->Base.Base,
851 /* inputs */
852 fs_num_inputs,
853 inputMapping,
854 input_semantic_name,
855 input_semantic_index,
856 interpMode,
857 /* outputs */
858 fs_num_outputs,
859 outputMapping,
860 fs_output_semantic_name,
861 fs_output_semantic_index, FALSE,
862 key->clamp_color);
863
864 variant->tgsi.tokens = ureg_get_tokens( ureg, NULL );
865 ureg_destroy( ureg );
866
867 if (ST_DEBUG & DEBUG_TGSI) {
868 tgsi_dump(variant->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/);
869 debug_printf("\n");
870 }
871
872 /* fill in variant */
873 variant->driver_shader = pipe->create_fs_state(pipe, &variant->tgsi);
874 variant->key = *key;
875
876 if (deleteFP) {
877 /* Free the temporary program made above */
878 struct gl_fragment_program *fp = &stfp->Base;
879 _mesa_reference_fragprog(st->ctx, &fp, NULL);
880 }
881
882 return variant;
883 }
884
885
886 /**
887 * Translate fragment program if needed.
888 */
889 struct st_fp_variant *
890 st_get_fp_variant(struct st_context *st,
891 struct st_fragment_program *stfp,
892 const struct st_fp_variant_key *key)
893 {
894 struct st_fp_variant *fpv;
895
896 /* Search for existing variant */
897 for (fpv = stfp->variants; fpv; fpv = fpv->next) {
898 if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
899 break;
900 }
901 }
902
903 if (!fpv) {
904 /* create new */
905 fpv = st_translate_fragment_program(st, stfp, key);
906 if (fpv) {
907 /* insert into list */
908 fpv->next = stfp->variants;
909 stfp->variants = fpv;
910 }
911 }
912
913 return fpv;
914 }
915
916
917 /**
918 * Translate a program. This is common code for geometry and tessellation
919 * shaders.
920 */
921 static void
922 st_translate_program_common(struct st_context *st,
923 struct gl_program *prog,
924 struct glsl_to_tgsi_visitor *glsl_to_tgsi,
925 struct ureg_program *ureg,
926 unsigned tgsi_processor,
927 struct pipe_shader_state *out_state)
928 {
929 GLuint inputSlotToAttr[VARYING_SLOT_TESS_MAX];
930 GLuint inputMapping[VARYING_SLOT_TESS_MAX];
931 GLuint outputSlotToAttr[VARYING_SLOT_TESS_MAX];
932 GLuint outputMapping[VARYING_SLOT_TESS_MAX];
933 GLuint attr;
934
935 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
936 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
937 uint num_inputs = 0;
938
939 ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
940 ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
941 uint num_outputs = 0;
942
943 GLint i;
944
945 memset(inputSlotToAttr, 0, sizeof(inputSlotToAttr));
946 memset(inputMapping, 0, sizeof(inputMapping));
947 memset(outputSlotToAttr, 0, sizeof(outputSlotToAttr));
948 memset(outputMapping, 0, sizeof(outputMapping));
949 memset(out_state, 0, sizeof(*out_state));
950
951 /*
952 * Convert Mesa program inputs to TGSI input register semantics.
953 */
954 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
955 if ((prog->InputsRead & BITFIELD64_BIT(attr)) != 0) {
956 const GLuint slot = num_inputs++;
957
958 inputMapping[attr] = slot;
959 inputSlotToAttr[slot] = attr;
960
961 switch (attr) {
962 case VARYING_SLOT_PRIMITIVE_ID:
963 assert(tgsi_processor == TGSI_PROCESSOR_GEOMETRY);
964 input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
965 input_semantic_index[slot] = 0;
966 break;
967 case VARYING_SLOT_POS:
968 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
969 input_semantic_index[slot] = 0;
970 break;
971 case VARYING_SLOT_COL0:
972 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
973 input_semantic_index[slot] = 0;
974 break;
975 case VARYING_SLOT_COL1:
976 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
977 input_semantic_index[slot] = 1;
978 break;
979 case VARYING_SLOT_FOGC:
980 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
981 input_semantic_index[slot] = 0;
982 break;
983 case VARYING_SLOT_CLIP_VERTEX:
984 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
985 input_semantic_index[slot] = 0;
986 break;
987 case VARYING_SLOT_CLIP_DIST0:
988 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
989 input_semantic_index[slot] = 0;
990 break;
991 case VARYING_SLOT_CLIP_DIST1:
992 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
993 input_semantic_index[slot] = 1;
994 break;
995 case VARYING_SLOT_PSIZ:
996 input_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
997 input_semantic_index[slot] = 0;
998 break;
999 case VARYING_SLOT_TEX0:
1000 case VARYING_SLOT_TEX1:
1001 case VARYING_SLOT_TEX2:
1002 case VARYING_SLOT_TEX3:
1003 case VARYING_SLOT_TEX4:
1004 case VARYING_SLOT_TEX5:
1005 case VARYING_SLOT_TEX6:
1006 case VARYING_SLOT_TEX7:
1007 if (st->needs_texcoord_semantic) {
1008 input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1009 input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1010 break;
1011 }
1012 /* fall through */
1013 case VARYING_SLOT_VAR0:
1014 default:
1015 assert(attr >= VARYING_SLOT_VAR0 ||
1016 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1017 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1018 input_semantic_index[slot] =
1019 st_get_generic_varying_index(st, attr);
1020 break;
1021 }
1022 }
1023 }
1024
1025 /* Also add patch inputs. */
1026 for (attr = 0; attr < 32; attr++) {
1027 if (prog->PatchInputsRead & (1 << attr)) {
1028 GLuint slot = num_inputs++;
1029 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1030
1031 inputMapping[patch_attr] = slot;
1032 inputSlotToAttr[slot] = patch_attr;
1033 input_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1034 input_semantic_index[slot] = attr;
1035 }
1036 }
1037
1038 /* initialize output semantics to defaults */
1039 for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
1040 output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
1041 output_semantic_index[i] = 0;
1042 }
1043
1044 /*
1045 * Determine number of outputs, the (default) output register
1046 * mapping and the semantic information for each output.
1047 */
1048 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1049 if (prog->OutputsWritten & BITFIELD64_BIT(attr)) {
1050 GLuint slot = num_outputs++;
1051
1052 outputMapping[attr] = slot;
1053 outputSlotToAttr[slot] = attr;
1054
1055 switch (attr) {
1056 case VARYING_SLOT_POS:
1057 assert(slot == 0);
1058 output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1059 output_semantic_index[slot] = 0;
1060 break;
1061 case VARYING_SLOT_COL0:
1062 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1063 output_semantic_index[slot] = 0;
1064 break;
1065 case VARYING_SLOT_COL1:
1066 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1067 output_semantic_index[slot] = 1;
1068 break;
1069 case VARYING_SLOT_BFC0:
1070 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1071 output_semantic_index[slot] = 0;
1072 break;
1073 case VARYING_SLOT_BFC1:
1074 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1075 output_semantic_index[slot] = 1;
1076 break;
1077 case VARYING_SLOT_FOGC:
1078 output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1079 output_semantic_index[slot] = 0;
1080 break;
1081 case VARYING_SLOT_PSIZ:
1082 output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1083 output_semantic_index[slot] = 0;
1084 break;
1085 case VARYING_SLOT_CLIP_VERTEX:
1086 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1087 output_semantic_index[slot] = 0;
1088 break;
1089 case VARYING_SLOT_CLIP_DIST0:
1090 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1091 output_semantic_index[slot] = 0;
1092 break;
1093 case VARYING_SLOT_CLIP_DIST1:
1094 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1095 output_semantic_index[slot] = 1;
1096 break;
1097 case VARYING_SLOT_LAYER:
1098 output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
1099 output_semantic_index[slot] = 0;
1100 break;
1101 case VARYING_SLOT_PRIMITIVE_ID:
1102 output_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1103 output_semantic_index[slot] = 0;
1104 break;
1105 case VARYING_SLOT_VIEWPORT:
1106 output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
1107 output_semantic_index[slot] = 0;
1108 break;
1109 case VARYING_SLOT_TESS_LEVEL_OUTER:
1110 output_semantic_name[slot] = TGSI_SEMANTIC_TESSOUTER;
1111 output_semantic_index[slot] = 0;
1112 break;
1113 case VARYING_SLOT_TESS_LEVEL_INNER:
1114 output_semantic_name[slot] = TGSI_SEMANTIC_TESSINNER;
1115 output_semantic_index[slot] = 0;
1116 break;
1117 case VARYING_SLOT_TEX0:
1118 case VARYING_SLOT_TEX1:
1119 case VARYING_SLOT_TEX2:
1120 case VARYING_SLOT_TEX3:
1121 case VARYING_SLOT_TEX4:
1122 case VARYING_SLOT_TEX5:
1123 case VARYING_SLOT_TEX6:
1124 case VARYING_SLOT_TEX7:
1125 if (st->needs_texcoord_semantic) {
1126 output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1127 output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1128 break;
1129 }
1130 /* fall through */
1131 case VARYING_SLOT_VAR0:
1132 default:
1133 assert(slot < ARRAY_SIZE(output_semantic_name));
1134 assert(attr >= VARYING_SLOT_VAR0 ||
1135 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1136 output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1137 output_semantic_index[slot] =
1138 st_get_generic_varying_index(st, attr);
1139 break;
1140 }
1141 }
1142 }
1143
1144 /* Also add patch outputs. */
1145 for (attr = 0; attr < 32; attr++) {
1146 if (prog->PatchOutputsWritten & (1 << attr)) {
1147 GLuint slot = num_outputs++;
1148 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1149
1150 outputMapping[patch_attr] = slot;
1151 outputSlotToAttr[slot] = patch_attr;
1152 output_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1153 output_semantic_index[slot] = attr;
1154 }
1155 }
1156
1157 st_translate_program(st->ctx,
1158 tgsi_processor,
1159 ureg,
1160 glsl_to_tgsi,
1161 prog,
1162 /* inputs */
1163 num_inputs,
1164 inputMapping,
1165 inputSlotToAttr,
1166 input_semantic_name,
1167 input_semantic_index,
1168 NULL,
1169 NULL,
1170 /* outputs */
1171 num_outputs,
1172 outputMapping,
1173 outputSlotToAttr,
1174 output_semantic_name,
1175 output_semantic_index,
1176 FALSE,
1177 FALSE);
1178
1179 out_state->tokens = ureg_get_tokens(ureg, NULL);
1180 ureg_destroy(ureg);
1181
1182 st_translate_stream_output_info(glsl_to_tgsi,
1183 outputMapping,
1184 &out_state->stream_output);
1185
1186 if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1187 _mesa_print_program(prog);
1188 debug_printf("\n");
1189 }
1190
1191 if (ST_DEBUG & DEBUG_TGSI) {
1192 tgsi_dump(out_state->tokens, 0);
1193 debug_printf("\n");
1194 }
1195 }
1196
1197
1198 /**
1199 * Translate a geometry program to create a new variant.
1200 */
1201 static struct st_gp_variant *
1202 st_translate_geometry_program(struct st_context *st,
1203 struct st_geometry_program *stgp,
1204 const struct st_gp_variant_key *key)
1205 {
1206 struct pipe_context *pipe = st->pipe;
1207 struct ureg_program *ureg;
1208 struct st_gp_variant *gpv;
1209 struct pipe_shader_state state;
1210
1211 ureg = ureg_create_with_screen(TGSI_PROCESSOR_GEOMETRY, st->pipe->screen);
1212 if (ureg == NULL)
1213 return NULL;
1214
1215 ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, stgp->Base.InputType);
1216 ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, stgp->Base.OutputType);
1217 ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES,
1218 stgp->Base.VerticesOut);
1219 ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS, stgp->Base.Invocations);
1220
1221 st_translate_program_common(st, &stgp->Base.Base, stgp->glsl_to_tgsi, ureg,
1222 TGSI_PROCESSOR_GEOMETRY, &state);
1223
1224 gpv = CALLOC_STRUCT(st_gp_variant);
1225 if (!gpv) {
1226 ureg_free_tokens(state.tokens);
1227 return NULL;
1228 }
1229
1230 /* fill in new variant */
1231 gpv->driver_shader = pipe->create_gs_state(pipe, &state);
1232 gpv->key = *key;
1233
1234 ureg_free_tokens(state.tokens);
1235 return gpv;
1236 }
1237
1238
1239 /**
1240 * Get/create geometry program variant.
1241 */
1242 struct st_gp_variant *
1243 st_get_gp_variant(struct st_context *st,
1244 struct st_geometry_program *stgp,
1245 const struct st_gp_variant_key *key)
1246 {
1247 struct st_gp_variant *gpv;
1248
1249 /* Search for existing variant */
1250 for (gpv = stgp->variants; gpv; gpv = gpv->next) {
1251 if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
1252 break;
1253 }
1254 }
1255
1256 if (!gpv) {
1257 /* create new */
1258 gpv = st_translate_geometry_program(st, stgp, key);
1259 if (gpv) {
1260 /* insert into list */
1261 gpv->next = stgp->variants;
1262 stgp->variants = gpv;
1263 }
1264 }
1265
1266 return gpv;
1267 }
1268
1269
1270 /**
1271 * Translate a tessellation control program to create a new variant.
1272 */
1273 static struct st_tcp_variant *
1274 st_translate_tessctrl_program(struct st_context *st,
1275 struct st_tessctrl_program *sttcp,
1276 const struct st_tcp_variant_key *key)
1277 {
1278 struct pipe_context *pipe = st->pipe;
1279 struct ureg_program *ureg;
1280 struct st_tcp_variant *tcpv;
1281 struct pipe_shader_state state;
1282
1283 ureg = ureg_create_with_screen(TGSI_PROCESSOR_TESS_CTRL, pipe->screen);
1284 if (ureg == NULL) {
1285 return NULL;
1286 }
1287
1288 ureg_property(ureg, TGSI_PROPERTY_TCS_VERTICES_OUT,
1289 sttcp->Base.VerticesOut);
1290
1291 st_translate_program_common(st, &sttcp->Base.Base, sttcp->glsl_to_tgsi,
1292 ureg, TGSI_PROCESSOR_TESS_CTRL, &state);
1293
1294 tcpv = CALLOC_STRUCT(st_tcp_variant);
1295 if (!tcpv) {
1296 ureg_free_tokens(state.tokens);
1297 return NULL;
1298 }
1299
1300 /* fill in new variant */
1301 tcpv->driver_shader = pipe->create_tcs_state(pipe, &state);
1302 tcpv->key = *key;
1303
1304 ureg_free_tokens(state.tokens);
1305 return tcpv;
1306 }
1307
1308
1309 /**
1310 * Get/create tessellation control program variant.
1311 */
1312 struct st_tcp_variant *
1313 st_get_tcp_variant(struct st_context *st,
1314 struct st_tessctrl_program *sttcp,
1315 const struct st_tcp_variant_key *key)
1316 {
1317 struct st_tcp_variant *tcpv;
1318
1319 /* Search for existing variant */
1320 for (tcpv = sttcp->variants; tcpv; tcpv = tcpv->next) {
1321 if (memcmp(&tcpv->key, key, sizeof(*key)) == 0) {
1322 break;
1323 }
1324 }
1325
1326 if (!tcpv) {
1327 /* create new */
1328 tcpv = st_translate_tessctrl_program(st, sttcp, key);
1329 if (tcpv) {
1330 /* insert into list */
1331 tcpv->next = sttcp->variants;
1332 sttcp->variants = tcpv;
1333 }
1334 }
1335
1336 return tcpv;
1337 }
1338
1339
1340 /**
1341 * Translate a tessellation evaluation program to create a new variant.
1342 */
1343 static struct st_tep_variant *
1344 st_translate_tesseval_program(struct st_context *st,
1345 struct st_tesseval_program *sttep,
1346 const struct st_tep_variant_key *key)
1347 {
1348 struct pipe_context *pipe = st->pipe;
1349 struct ureg_program *ureg;
1350 struct st_tep_variant *tepv;
1351 struct pipe_shader_state state;
1352
1353 ureg = ureg_create_with_screen(TGSI_PROCESSOR_TESS_EVAL, pipe->screen);
1354 if (ureg == NULL) {
1355 return NULL;
1356 }
1357
1358 if (sttep->Base.PrimitiveMode == GL_ISOLINES)
1359 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, GL_LINES);
1360 else
1361 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, sttep->Base.PrimitiveMode);
1362
1363 switch (sttep->Base.Spacing) {
1364 case GL_EQUAL:
1365 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING, PIPE_TESS_SPACING_EQUAL);
1366 break;
1367 case GL_FRACTIONAL_EVEN:
1368 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1369 PIPE_TESS_SPACING_FRACTIONAL_EVEN);
1370 break;
1371 case GL_FRACTIONAL_ODD:
1372 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1373 PIPE_TESS_SPACING_FRACTIONAL_ODD);
1374 break;
1375 default:
1376 assert(0);
1377 }
1378
1379 ureg_property(ureg, TGSI_PROPERTY_TES_VERTEX_ORDER_CW,
1380 sttep->Base.VertexOrder == GL_CW);
1381 ureg_property(ureg, TGSI_PROPERTY_TES_POINT_MODE, sttep->Base.PointMode);
1382
1383 st_translate_program_common(st, &sttep->Base.Base, sttep->glsl_to_tgsi,
1384 ureg, TGSI_PROCESSOR_TESS_EVAL, &state);
1385
1386 tepv = CALLOC_STRUCT(st_tep_variant);
1387 if (!tepv) {
1388 ureg_free_tokens(state.tokens);
1389 return NULL;
1390 }
1391
1392 /* fill in new variant */
1393 tepv->driver_shader = pipe->create_tes_state(pipe, &state);
1394 tepv->key = *key;
1395
1396 ureg_free_tokens(state.tokens);
1397 return tepv;
1398 }
1399
1400
1401 /**
1402 * Get/create tessellation evaluation program variant.
1403 */
1404 struct st_tep_variant *
1405 st_get_tep_variant(struct st_context *st,
1406 struct st_tesseval_program *sttep,
1407 const struct st_tep_variant_key *key)
1408 {
1409 struct st_tep_variant *tepv;
1410
1411 /* Search for existing variant */
1412 for (tepv = sttep->variants; tepv; tepv = tepv->next) {
1413 if (memcmp(&tepv->key, key, sizeof(*key)) == 0) {
1414 break;
1415 }
1416 }
1417
1418 if (!tepv) {
1419 /* create new */
1420 tepv = st_translate_tesseval_program(st, sttep, key);
1421 if (tepv) {
1422 /* insert into list */
1423 tepv->next = sttep->variants;
1424 sttep->variants = tepv;
1425 }
1426 }
1427
1428 return tepv;
1429 }
1430
1431
1432 /**
1433 * Vert/Geom/Frag programs have per-context variants. Free all the
1434 * variants attached to the given program which match the given context.
1435 */
1436 static void
1437 destroy_program_variants(struct st_context *st, struct gl_program *program)
1438 {
1439 if (!program || program == &_mesa_DummyProgram)
1440 return;
1441
1442 switch (program->Target) {
1443 case GL_VERTEX_PROGRAM_ARB:
1444 {
1445 struct st_vertex_program *stvp = (struct st_vertex_program *) program;
1446 struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1447
1448 for (vpv = stvp->variants; vpv; ) {
1449 struct st_vp_variant *next = vpv->next;
1450 if (vpv->key.st == st) {
1451 /* unlink from list */
1452 *prevPtr = next;
1453 /* destroy this variant */
1454 delete_vp_variant(st, vpv);
1455 }
1456 else {
1457 prevPtr = &vpv->next;
1458 }
1459 vpv = next;
1460 }
1461 }
1462 break;
1463 case GL_FRAGMENT_PROGRAM_ARB:
1464 {
1465 struct st_fragment_program *stfp =
1466 (struct st_fragment_program *) program;
1467 struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1468
1469 for (fpv = stfp->variants; fpv; ) {
1470 struct st_fp_variant *next = fpv->next;
1471 if (fpv->key.st == st) {
1472 /* unlink from list */
1473 *prevPtr = next;
1474 /* destroy this variant */
1475 delete_fp_variant(st, fpv);
1476 }
1477 else {
1478 prevPtr = &fpv->next;
1479 }
1480 fpv = next;
1481 }
1482 }
1483 break;
1484 case GL_GEOMETRY_PROGRAM_NV:
1485 {
1486 struct st_geometry_program *stgp =
1487 (struct st_geometry_program *) program;
1488 struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
1489
1490 for (gpv = stgp->variants; gpv; ) {
1491 struct st_gp_variant *next = gpv->next;
1492 if (gpv->key.st == st) {
1493 /* unlink from list */
1494 *prevPtr = next;
1495 /* destroy this variant */
1496 delete_gp_variant(st, gpv);
1497 }
1498 else {
1499 prevPtr = &gpv->next;
1500 }
1501 gpv = next;
1502 }
1503 }
1504 break;
1505 case GL_TESS_CONTROL_PROGRAM_NV:
1506 {
1507 struct st_tessctrl_program *sttcp =
1508 (struct st_tessctrl_program *) program;
1509 struct st_tcp_variant *tcpv, **prevPtr = &sttcp->variants;
1510
1511 for (tcpv = sttcp->variants; tcpv; ) {
1512 struct st_tcp_variant *next = tcpv->next;
1513 if (tcpv->key.st == st) {
1514 /* unlink from list */
1515 *prevPtr = next;
1516 /* destroy this variant */
1517 delete_tcp_variant(st, tcpv);
1518 }
1519 else {
1520 prevPtr = &tcpv->next;
1521 }
1522 tcpv = next;
1523 }
1524 }
1525 break;
1526 case GL_TESS_EVALUATION_PROGRAM_NV:
1527 {
1528 struct st_tesseval_program *sttep =
1529 (struct st_tesseval_program *) program;
1530 struct st_tep_variant *tepv, **prevPtr = &sttep->variants;
1531
1532 for (tepv = sttep->variants; tepv; ) {
1533 struct st_tep_variant *next = tepv->next;
1534 if (tepv->key.st == st) {
1535 /* unlink from list */
1536 *prevPtr = next;
1537 /* destroy this variant */
1538 delete_tep_variant(st, tepv);
1539 }
1540 else {
1541 prevPtr = &tepv->next;
1542 }
1543 tepv = next;
1544 }
1545 }
1546 break;
1547 default:
1548 _mesa_problem(NULL, "Unexpected program target 0x%x in "
1549 "destroy_program_variants_cb()", program->Target);
1550 }
1551 }
1552
1553
1554 /**
1555 * Callback for _mesa_HashWalk. Free all the shader's program variants
1556 * which match the given context.
1557 */
1558 static void
1559 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1560 {
1561 struct st_context *st = (struct st_context *) userData;
1562 struct gl_shader *shader = (struct gl_shader *) data;
1563
1564 switch (shader->Type) {
1565 case GL_SHADER_PROGRAM_MESA:
1566 {
1567 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1568 GLuint i;
1569
1570 for (i = 0; i < shProg->NumShaders; i++) {
1571 destroy_program_variants(st, shProg->Shaders[i]->Program);
1572 }
1573
1574 for (i = 0; i < ARRAY_SIZE(shProg->_LinkedShaders); i++) {
1575 if (shProg->_LinkedShaders[i])
1576 destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1577 }
1578 }
1579 break;
1580 case GL_VERTEX_SHADER:
1581 case GL_FRAGMENT_SHADER:
1582 case GL_GEOMETRY_SHADER:
1583 case GL_TESS_CONTROL_SHADER:
1584 case GL_TESS_EVALUATION_SHADER:
1585 {
1586 destroy_program_variants(st, shader->Program);
1587 }
1588 break;
1589 default:
1590 assert(0);
1591 }
1592 }
1593
1594
1595 /**
1596 * Callback for _mesa_HashWalk. Free all the program variants which match
1597 * the given context.
1598 */
1599 static void
1600 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1601 {
1602 struct st_context *st = (struct st_context *) userData;
1603 struct gl_program *program = (struct gl_program *) data;
1604 destroy_program_variants(st, program);
1605 }
1606
1607
1608 /**
1609 * Walk over all shaders and programs to delete any variants which
1610 * belong to the given context.
1611 * This is called during context tear-down.
1612 */
1613 void
1614 st_destroy_program_variants(struct st_context *st)
1615 {
1616 /* ARB vert/frag program */
1617 _mesa_HashWalk(st->ctx->Shared->Programs,
1618 destroy_program_variants_cb, st);
1619
1620 /* GLSL vert/frag/geom shaders */
1621 _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1622 destroy_shader_program_variants_cb, st);
1623 }
1624
1625
1626 /**
1627 * For debugging, print/dump the current vertex program.
1628 */
1629 void
1630 st_print_current_vertex_program(void)
1631 {
1632 GET_CURRENT_CONTEXT(ctx);
1633
1634 if (ctx->VertexProgram._Current) {
1635 struct st_vertex_program *stvp =
1636 (struct st_vertex_program *) ctx->VertexProgram._Current;
1637 struct st_vp_variant *stv;
1638
1639 debug_printf("Vertex program %u\n", stvp->Base.Base.Id);
1640
1641 for (stv = stvp->variants; stv; stv = stv->next) {
1642 debug_printf("variant %p\n", stv);
1643 tgsi_dump(stv->tgsi.tokens, 0);
1644 }
1645 }
1646 }
1647
1648
1649 /**
1650 * Compile one shader variant.
1651 */
1652 void
1653 st_precompile_shader_variant(struct st_context *st,
1654 struct gl_program *prog)
1655 {
1656 switch (prog->Target) {
1657 case GL_VERTEX_PROGRAM_ARB: {
1658 struct st_vertex_program *p = (struct st_vertex_program *)prog;
1659 struct st_vp_variant_key key;
1660
1661 memset(&key, 0, sizeof(key));
1662 key.st = st;
1663 st_get_vp_variant(st, p, &key);
1664 break;
1665 }
1666
1667 case GL_TESS_CONTROL_PROGRAM_NV: {
1668 struct st_tessctrl_program *p = (struct st_tessctrl_program *)prog;
1669 struct st_tcp_variant_key key;
1670
1671 memset(&key, 0, sizeof(key));
1672 key.st = st;
1673 st_get_tcp_variant(st, p, &key);
1674 break;
1675 }
1676
1677 case GL_TESS_EVALUATION_PROGRAM_NV: {
1678 struct st_tesseval_program *p = (struct st_tesseval_program *)prog;
1679 struct st_tep_variant_key key;
1680
1681 memset(&key, 0, sizeof(key));
1682 key.st = st;
1683 st_get_tep_variant(st, p, &key);
1684 break;
1685 }
1686
1687 case GL_GEOMETRY_PROGRAM_NV: {
1688 struct st_geometry_program *p = (struct st_geometry_program *)prog;
1689 struct st_gp_variant_key key;
1690
1691 memset(&key, 0, sizeof(key));
1692 key.st = st;
1693 st_get_gp_variant(st, p, &key);
1694 break;
1695 }
1696
1697 case GL_FRAGMENT_PROGRAM_ARB: {
1698 struct st_fragment_program *p = (struct st_fragment_program *)prog;
1699 struct st_fp_variant_key key;
1700
1701 memset(&key, 0, sizeof(key));
1702 key.st = st;
1703 st_get_fp_variant(st, p, &key);
1704 break;
1705 }
1706
1707 default:
1708 assert(0);
1709 }
1710 }