1 /**************************************************************************
3 * Copyright 2007 VMware, Inc.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
29 * Keith Whitwell <keithw@vmware.com>
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"
41 #include "compiler/nir/nir.h"
43 #include "pipe/p_context.h"
44 #include "pipe/p_defines.h"
45 #include "pipe/p_shader_tokens.h"
46 #include "draw/draw_context.h"
47 #include "tgsi/tgsi_dump.h"
48 #include "tgsi/tgsi_emulate.h"
49 #include "tgsi/tgsi_parse.h"
50 #include "tgsi/tgsi_ureg.h"
53 #include "st_cb_bitmap.h"
54 #include "st_cb_drawpixels.h"
55 #include "st_context.h"
56 #include "st_program.h"
57 #include "st_mesa_to_tgsi.h"
58 #include "st_atifs_to_tgsi.h"
60 #include "cso_cache/cso_context.h"
65 * Delete a vertex program variant. Note the caller must unlink
66 * the variant from the linked list.
69 delete_vp_variant(struct st_context
*st
, struct st_vp_variant
*vpv
)
71 if (vpv
->driver_shader
)
72 cso_delete_vertex_shader(st
->cso_context
, vpv
->driver_shader
);
75 draw_delete_vertex_shader( st
->draw
, vpv
->draw_shader
);
77 if (((vpv
->tgsi
.type
== PIPE_SHADER_IR_TGSI
)) && vpv
->tgsi
.tokens
)
78 ureg_free_tokens(vpv
->tgsi
.tokens
);
86 * Clean out any old compilations:
89 st_release_vp_variants( struct st_context
*st
,
90 struct st_vertex_program
*stvp
)
92 struct st_vp_variant
*vpv
;
94 for (vpv
= stvp
->variants
; vpv
; ) {
95 struct st_vp_variant
*next
= vpv
->next
;
96 delete_vp_variant(st
, vpv
);
100 stvp
->variants
= NULL
;
102 if ((stvp
->tgsi
.type
== PIPE_SHADER_IR_TGSI
) && stvp
->tgsi
.tokens
) {
103 tgsi_free_tokens(stvp
->tgsi
.tokens
);
104 stvp
->tgsi
.tokens
= NULL
;
111 * Delete a fragment program variant. Note the caller must unlink
112 * the variant from the linked list.
115 delete_fp_variant(struct st_context
*st
, struct st_fp_variant
*fpv
)
117 if (fpv
->driver_shader
)
118 cso_delete_fragment_shader(st
->cso_context
, fpv
->driver_shader
);
124 * Free all variants of a fragment program.
127 st_release_fp_variants(struct st_context
*st
, struct st_fragment_program
*stfp
)
129 struct st_fp_variant
*fpv
;
131 for (fpv
= stfp
->variants
; fpv
; ) {
132 struct st_fp_variant
*next
= fpv
->next
;
133 delete_fp_variant(st
, fpv
);
137 stfp
->variants
= NULL
;
139 if ((stfp
->tgsi
.type
== PIPE_SHADER_IR_TGSI
) && stfp
->tgsi
.tokens
) {
140 ureg_free_tokens(stfp
->tgsi
.tokens
);
141 stfp
->tgsi
.tokens
= NULL
;
147 * Delete a basic program variant. Note the caller must unlink
148 * the variant from the linked list.
151 delete_basic_variant(struct st_context
*st
, struct st_basic_variant
*v
,
154 if (v
->driver_shader
) {
156 case GL_TESS_CONTROL_PROGRAM_NV
:
157 cso_delete_tessctrl_shader(st
->cso_context
, v
->driver_shader
);
159 case GL_TESS_EVALUATION_PROGRAM_NV
:
160 cso_delete_tesseval_shader(st
->cso_context
, v
->driver_shader
);
162 case GL_GEOMETRY_PROGRAM_NV
:
163 cso_delete_geometry_shader(st
->cso_context
, v
->driver_shader
);
165 case GL_COMPUTE_PROGRAM_NV
:
166 cso_delete_compute_shader(st
->cso_context
, v
->driver_shader
);
169 assert(!"this shouldn't occur");
178 * Free all basic program variants.
181 st_release_basic_variants(struct st_context
*st
, GLenum target
,
182 struct st_basic_variant
**variants
,
183 struct pipe_shader_state
*tgsi
)
185 struct st_basic_variant
*v
;
187 for (v
= *variants
; v
; ) {
188 struct st_basic_variant
*next
= v
->next
;
189 delete_basic_variant(st
, v
, target
);
196 ureg_free_tokens(tgsi
->tokens
);
203 * Free all variants of a compute program.
206 st_release_cp_variants(struct st_context
*st
, struct st_compute_program
*stcp
)
208 struct st_basic_variant
**variants
= &stcp
->variants
;
209 struct st_basic_variant
*v
;
211 for (v
= *variants
; v
; ) {
212 struct st_basic_variant
*next
= v
->next
;
213 delete_basic_variant(st
, v
, stcp
->Base
.Base
.Target
);
219 if (stcp
->tgsi
.prog
) {
220 ureg_free_tokens(stcp
->tgsi
.prog
);
221 stcp
->tgsi
.prog
= NULL
;
227 * Translate a vertex program.
230 st_translate_vertex_program(struct st_context
*st
,
231 struct st_vertex_program
*stvp
)
233 struct ureg_program
*ureg
;
234 enum pipe_error error
;
235 unsigned num_outputs
= 0;
237 unsigned input_to_index
[VERT_ATTRIB_MAX
] = {0};
238 unsigned output_slot_to_attr
[VARYING_SLOT_MAX
] = {0};
239 ubyte output_semantic_name
[VARYING_SLOT_MAX
] = {0};
240 ubyte output_semantic_index
[VARYING_SLOT_MAX
] = {0};
242 stvp
->num_inputs
= 0;
244 if (stvp
->Base
.IsPositionInvariant
)
245 _mesa_insert_mvp_code(st
->ctx
, &stvp
->Base
);
248 * Determine number of inputs, the mappings between VERT_ATTRIB_x
249 * and TGSI generic input indexes, plus input attrib semantic info.
251 for (attr
= 0; attr
< VERT_ATTRIB_MAX
; attr
++) {
252 if ((stvp
->Base
.Base
.InputsRead
& BITFIELD64_BIT(attr
)) != 0) {
253 input_to_index
[attr
] = stvp
->num_inputs
;
254 stvp
->index_to_input
[stvp
->num_inputs
] = attr
;
256 if ((stvp
->Base
.Base
.DoubleInputsRead
& BITFIELD64_BIT(attr
)) != 0) {
257 /* add placeholder for second part of a double attribute */
258 stvp
->index_to_input
[stvp
->num_inputs
] = ST_DOUBLE_ATTRIB_PLACEHOLDER
;
263 /* bit of a hack, presetup potentially unused edgeflag input */
264 input_to_index
[VERT_ATTRIB_EDGEFLAG
] = stvp
->num_inputs
;
265 stvp
->index_to_input
[stvp
->num_inputs
] = VERT_ATTRIB_EDGEFLAG
;
267 /* Compute mapping of vertex program outputs to slots.
269 for (attr
= 0; attr
< VARYING_SLOT_MAX
; attr
++) {
270 if ((stvp
->Base
.Base
.OutputsWritten
& BITFIELD64_BIT(attr
)) == 0) {
271 stvp
->result_to_output
[attr
] = ~0;
274 unsigned slot
= num_outputs
++;
276 stvp
->result_to_output
[attr
] = slot
;
277 output_slot_to_attr
[slot
] = attr
;
280 case VARYING_SLOT_POS
:
281 output_semantic_name
[slot
] = TGSI_SEMANTIC_POSITION
;
282 output_semantic_index
[slot
] = 0;
284 case VARYING_SLOT_COL0
:
285 output_semantic_name
[slot
] = TGSI_SEMANTIC_COLOR
;
286 output_semantic_index
[slot
] = 0;
288 case VARYING_SLOT_COL1
:
289 output_semantic_name
[slot
] = TGSI_SEMANTIC_COLOR
;
290 output_semantic_index
[slot
] = 1;
292 case VARYING_SLOT_BFC0
:
293 output_semantic_name
[slot
] = TGSI_SEMANTIC_BCOLOR
;
294 output_semantic_index
[slot
] = 0;
296 case VARYING_SLOT_BFC1
:
297 output_semantic_name
[slot
] = TGSI_SEMANTIC_BCOLOR
;
298 output_semantic_index
[slot
] = 1;
300 case VARYING_SLOT_FOGC
:
301 output_semantic_name
[slot
] = TGSI_SEMANTIC_FOG
;
302 output_semantic_index
[slot
] = 0;
304 case VARYING_SLOT_PSIZ
:
305 output_semantic_name
[slot
] = TGSI_SEMANTIC_PSIZE
;
306 output_semantic_index
[slot
] = 0;
308 case VARYING_SLOT_CLIP_DIST0
:
309 output_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPDIST
;
310 output_semantic_index
[slot
] = 0;
312 case VARYING_SLOT_CLIP_DIST1
:
313 output_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPDIST
;
314 output_semantic_index
[slot
] = 1;
316 case VARYING_SLOT_CULL_DIST0
:
317 case VARYING_SLOT_CULL_DIST1
:
318 /* these should have been lowered by GLSL */
321 case VARYING_SLOT_EDGE
:
324 case VARYING_SLOT_CLIP_VERTEX
:
325 output_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPVERTEX
;
326 output_semantic_index
[slot
] = 0;
328 case VARYING_SLOT_LAYER
:
329 output_semantic_name
[slot
] = TGSI_SEMANTIC_LAYER
;
330 output_semantic_index
[slot
] = 0;
332 case VARYING_SLOT_VIEWPORT
:
333 output_semantic_name
[slot
] = TGSI_SEMANTIC_VIEWPORT_INDEX
;
334 output_semantic_index
[slot
] = 0;
337 case VARYING_SLOT_TEX0
:
338 case VARYING_SLOT_TEX1
:
339 case VARYING_SLOT_TEX2
:
340 case VARYING_SLOT_TEX3
:
341 case VARYING_SLOT_TEX4
:
342 case VARYING_SLOT_TEX5
:
343 case VARYING_SLOT_TEX6
:
344 case VARYING_SLOT_TEX7
:
345 if (st
->needs_texcoord_semantic
) {
346 output_semantic_name
[slot
] = TGSI_SEMANTIC_TEXCOORD
;
347 output_semantic_index
[slot
] = attr
- VARYING_SLOT_TEX0
;
351 case VARYING_SLOT_VAR0
:
353 assert(attr
>= VARYING_SLOT_VAR0
||
354 (attr
>= VARYING_SLOT_TEX0
&& attr
<= VARYING_SLOT_TEX7
));
355 output_semantic_name
[slot
] = TGSI_SEMANTIC_GENERIC
;
356 output_semantic_index
[slot
] =
357 st_get_generic_varying_index(st
, attr
);
362 /* similar hack to above, presetup potentially unused edgeflag output */
363 stvp
->result_to_output
[VARYING_SLOT_EDGE
] = num_outputs
;
364 output_semantic_name
[num_outputs
] = TGSI_SEMANTIC_EDGEFLAG
;
365 output_semantic_index
[num_outputs
] = 0;
367 if (!stvp
->glsl_to_tgsi
&& !stvp
->shader_program
)
368 _mesa_remove_output_reads(&stvp
->Base
.Base
, PROGRAM_OUTPUT
);
370 if (stvp
->shader_program
) {
371 nir_shader
*nir
= st_glsl_to_nir(st
, &stvp
->Base
.Base
,
372 stvp
->shader_program
,
375 stvp
->tgsi
.type
= PIPE_SHADER_IR_NIR
;
376 stvp
->tgsi
.ir
.nir
= nir
;
378 st_translate_stream_output_info2(&stvp
->shader_program
->LinkedTransformFeedback
,
379 stvp
->result_to_output
,
380 &stvp
->tgsi
.stream_output
);
384 ureg
= ureg_create_with_screen(PIPE_SHADER_VERTEX
, st
->pipe
->screen
);
388 if (stvp
->Base
.Base
.ClipDistanceArraySize
)
389 ureg_property(ureg
, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED
,
390 stvp
->Base
.Base
.ClipDistanceArraySize
);
391 if (stvp
->Base
.Base
.CullDistanceArraySize
)
392 ureg_property(ureg
, TGSI_PROPERTY_NUM_CULLDIST_ENABLED
,
393 stvp
->Base
.Base
.CullDistanceArraySize
);
395 if (ST_DEBUG
& DEBUG_MESA
) {
396 _mesa_print_program(&stvp
->Base
.Base
);
397 _mesa_print_program_parameters(st
->ctx
, &stvp
->Base
.Base
);
401 if (stvp
->glsl_to_tgsi
) {
402 error
= st_translate_program(st
->ctx
,
410 NULL
, /* inputSlotToAttr */
411 NULL
, /* input semantic name */
412 NULL
, /* input semantic index */
413 NULL
, /* interp mode */
414 NULL
, /* interp location */
417 stvp
->result_to_output
,
419 output_semantic_name
,
420 output_semantic_index
);
422 st_translate_stream_output_info(stvp
->glsl_to_tgsi
,
423 stvp
->result_to_output
,
424 &stvp
->tgsi
.stream_output
);
426 free_glsl_to_tgsi_visitor(stvp
->glsl_to_tgsi
);
427 stvp
->glsl_to_tgsi
= NULL
;
429 error
= st_translate_mesa_program(st
->ctx
,
436 NULL
, /* input semantic name */
437 NULL
, /* input semantic index */
441 stvp
->result_to_output
,
442 output_semantic_name
,
443 output_semantic_index
);
446 debug_printf("%s: failed to translate Mesa program:\n", __func__
);
447 _mesa_print_program(&stvp
->Base
.Base
);
452 stvp
->tgsi
.tokens
= ureg_get_tokens(ureg
, NULL
);
454 return stvp
->tgsi
.tokens
!= NULL
;
457 static struct st_vp_variant
*
458 st_create_vp_variant(struct st_context
*st
,
459 struct st_vertex_program
*stvp
,
460 const struct st_vp_variant_key
*key
)
462 struct st_vp_variant
*vpv
= CALLOC_STRUCT(st_vp_variant
);
463 struct pipe_context
*pipe
= st
->pipe
;
466 vpv
->tgsi
.stream_output
= stvp
->tgsi
.stream_output
;
467 vpv
->num_inputs
= stvp
->num_inputs
;
469 if (stvp
->tgsi
.type
== PIPE_SHADER_IR_NIR
) {
470 vpv
->tgsi
.type
= PIPE_SHADER_IR_NIR
;
471 vpv
->tgsi
.ir
.nir
= nir_shader_clone(NULL
, stvp
->tgsi
.ir
.nir
);
472 if (key
->clamp_color
)
473 NIR_PASS_V(vpv
->tgsi
.ir
.nir
, nir_lower_clamp_color_outputs
);
474 if (key
->passthrough_edgeflags
)
475 NIR_PASS_V(vpv
->tgsi
.ir
.nir
, nir_lower_passthrough_edgeflags
);
477 st_finalize_nir(st
, &stvp
->Base
.Base
, vpv
->tgsi
.ir
.nir
);
479 vpv
->driver_shader
= pipe
->create_vs_state(pipe
, &vpv
->tgsi
);
480 /* driver takes ownership of IR: */
481 vpv
->tgsi
.ir
.nir
= NULL
;
485 vpv
->tgsi
.tokens
= tgsi_dup_tokens(stvp
->tgsi
.tokens
);
487 /* Emulate features. */
488 if (key
->clamp_color
|| key
->passthrough_edgeflags
) {
489 const struct tgsi_token
*tokens
;
491 (key
->clamp_color
? TGSI_EMU_CLAMP_COLOR_OUTPUTS
: 0) |
492 (key
->passthrough_edgeflags
? TGSI_EMU_PASSTHROUGH_EDGEFLAG
: 0);
494 tokens
= tgsi_emulate(vpv
->tgsi
.tokens
, flags
);
497 tgsi_free_tokens(vpv
->tgsi
.tokens
);
498 vpv
->tgsi
.tokens
= tokens
;
500 if (key
->passthrough_edgeflags
)
503 fprintf(stderr
, "mesa: cannot emulate deprecated features\n");
506 if (ST_DEBUG
& DEBUG_TGSI
) {
507 tgsi_dump(vpv
->tgsi
.tokens
, 0);
511 vpv
->driver_shader
= pipe
->create_vs_state(pipe
, &vpv
->tgsi
);
517 * Find/create a vertex program variant.
519 struct st_vp_variant
*
520 st_get_vp_variant(struct st_context
*st
,
521 struct st_vertex_program
*stvp
,
522 const struct st_vp_variant_key
*key
)
524 struct st_vp_variant
*vpv
;
526 /* Search for existing variant */
527 for (vpv
= stvp
->variants
; vpv
; vpv
= vpv
->next
) {
528 if (memcmp(&vpv
->key
, key
, sizeof(*key
)) == 0) {
535 vpv
= st_create_vp_variant(st
, stvp
, key
);
537 /* insert into list */
538 vpv
->next
= stvp
->variants
;
539 stvp
->variants
= vpv
;
548 st_translate_interp(enum glsl_interp_qualifier glsl_qual
, bool is_color
)
551 case INTERP_QUALIFIER_NONE
:
553 return TGSI_INTERPOLATE_COLOR
;
554 return TGSI_INTERPOLATE_PERSPECTIVE
;
555 case INTERP_QUALIFIER_SMOOTH
:
556 return TGSI_INTERPOLATE_PERSPECTIVE
;
557 case INTERP_QUALIFIER_FLAT
:
558 return TGSI_INTERPOLATE_CONSTANT
;
559 case INTERP_QUALIFIER_NOPERSPECTIVE
:
560 return TGSI_INTERPOLATE_LINEAR
;
562 assert(0 && "unexpected interp mode in st_translate_interp()");
563 return TGSI_INTERPOLATE_PERSPECTIVE
;
569 * Translate a Mesa fragment shader into a TGSI shader.
572 st_translate_fragment_program(struct st_context
*st
,
573 struct st_fragment_program
*stfp
)
575 GLuint outputMapping
[FRAG_RESULT_MAX
];
576 GLuint inputMapping
[VARYING_SLOT_MAX
];
577 GLuint inputSlotToAttr
[VARYING_SLOT_MAX
];
578 GLuint interpMode
[PIPE_MAX_SHADER_INPUTS
]; /* XXX size? */
579 GLuint interpLocation
[PIPE_MAX_SHADER_INPUTS
];
581 GLbitfield64 inputsRead
;
582 struct ureg_program
*ureg
;
584 GLboolean write_all
= GL_FALSE
;
586 ubyte input_semantic_name
[PIPE_MAX_SHADER_INPUTS
];
587 ubyte input_semantic_index
[PIPE_MAX_SHADER_INPUTS
];
588 uint fs_num_inputs
= 0;
590 ubyte fs_output_semantic_name
[PIPE_MAX_SHADER_OUTPUTS
];
591 ubyte fs_output_semantic_index
[PIPE_MAX_SHADER_OUTPUTS
];
592 uint fs_num_outputs
= 0;
594 memset(inputSlotToAttr
, ~0, sizeof(inputSlotToAttr
));
596 if (!stfp
->glsl_to_tgsi
&& !stfp
->shader_program
) {
597 _mesa_remove_output_reads(&stfp
->Base
.Base
, PROGRAM_OUTPUT
);
598 if (st
->ctx
->Const
.GLSLFragCoordIsSysVal
)
599 _mesa_program_fragment_position_to_sysval(&stfp
->Base
.Base
);
603 * Convert Mesa program inputs to TGSI input register semantics.
605 inputsRead
= stfp
->Base
.Base
.InputsRead
;
606 for (attr
= 0; attr
< VARYING_SLOT_MAX
; attr
++) {
607 if ((inputsRead
& BITFIELD64_BIT(attr
)) != 0) {
608 const GLuint slot
= fs_num_inputs
++;
610 inputMapping
[attr
] = slot
;
611 inputSlotToAttr
[slot
] = attr
;
612 if (stfp
->Base
.IsCentroid
& BITFIELD64_BIT(attr
))
613 interpLocation
[slot
] = TGSI_INTERPOLATE_LOC_CENTROID
;
614 else if (stfp
->Base
.IsSample
& BITFIELD64_BIT(attr
))
615 interpLocation
[slot
] = TGSI_INTERPOLATE_LOC_SAMPLE
;
617 interpLocation
[slot
] = TGSI_INTERPOLATE_LOC_CENTER
;
620 case VARYING_SLOT_POS
:
621 input_semantic_name
[slot
] = TGSI_SEMANTIC_POSITION
;
622 input_semantic_index
[slot
] = 0;
623 interpMode
[slot
] = TGSI_INTERPOLATE_LINEAR
;
625 case VARYING_SLOT_COL0
:
626 input_semantic_name
[slot
] = TGSI_SEMANTIC_COLOR
;
627 input_semantic_index
[slot
] = 0;
628 interpMode
[slot
] = st_translate_interp(stfp
->Base
.InterpQualifier
[attr
],
631 case VARYING_SLOT_COL1
:
632 input_semantic_name
[slot
] = TGSI_SEMANTIC_COLOR
;
633 input_semantic_index
[slot
] = 1;
634 interpMode
[slot
] = st_translate_interp(stfp
->Base
.InterpQualifier
[attr
],
637 case VARYING_SLOT_FOGC
:
638 input_semantic_name
[slot
] = TGSI_SEMANTIC_FOG
;
639 input_semantic_index
[slot
] = 0;
640 interpMode
[slot
] = TGSI_INTERPOLATE_PERSPECTIVE
;
642 case VARYING_SLOT_FACE
:
643 input_semantic_name
[slot
] = TGSI_SEMANTIC_FACE
;
644 input_semantic_index
[slot
] = 0;
645 interpMode
[slot
] = TGSI_INTERPOLATE_CONSTANT
;
647 case VARYING_SLOT_PRIMITIVE_ID
:
648 input_semantic_name
[slot
] = TGSI_SEMANTIC_PRIMID
;
649 input_semantic_index
[slot
] = 0;
650 interpMode
[slot
] = TGSI_INTERPOLATE_CONSTANT
;
652 case VARYING_SLOT_LAYER
:
653 input_semantic_name
[slot
] = TGSI_SEMANTIC_LAYER
;
654 input_semantic_index
[slot
] = 0;
655 interpMode
[slot
] = TGSI_INTERPOLATE_CONSTANT
;
657 case VARYING_SLOT_VIEWPORT
:
658 input_semantic_name
[slot
] = TGSI_SEMANTIC_VIEWPORT_INDEX
;
659 input_semantic_index
[slot
] = 0;
660 interpMode
[slot
] = TGSI_INTERPOLATE_CONSTANT
;
662 case VARYING_SLOT_CLIP_DIST0
:
663 input_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPDIST
;
664 input_semantic_index
[slot
] = 0;
665 interpMode
[slot
] = TGSI_INTERPOLATE_PERSPECTIVE
;
667 case VARYING_SLOT_CLIP_DIST1
:
668 input_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPDIST
;
669 input_semantic_index
[slot
] = 1;
670 interpMode
[slot
] = TGSI_INTERPOLATE_PERSPECTIVE
;
672 case VARYING_SLOT_CULL_DIST0
:
673 case VARYING_SLOT_CULL_DIST1
:
674 /* these should have been lowered by GLSL */
677 /* In most cases, there is nothing special about these
678 * inputs, so adopt a convention to use the generic
679 * semantic name and the mesa VARYING_SLOT_ number as the
682 * All that is required is that the vertex shader labels
683 * its own outputs similarly, and that the vertex shader
684 * generates at least every output required by the
685 * fragment shader plus fixed-function hardware (such as
688 * However, some drivers may need us to identify the PNTC and TEXi
689 * varyings if, for example, their capability to replace them with
690 * sprite coordinates is limited.
692 case VARYING_SLOT_PNTC
:
693 if (st
->needs_texcoord_semantic
) {
694 input_semantic_name
[slot
] = TGSI_SEMANTIC_PCOORD
;
695 input_semantic_index
[slot
] = 0;
696 interpMode
[slot
] = TGSI_INTERPOLATE_LINEAR
;
700 case VARYING_SLOT_TEX0
:
701 case VARYING_SLOT_TEX1
:
702 case VARYING_SLOT_TEX2
:
703 case VARYING_SLOT_TEX3
:
704 case VARYING_SLOT_TEX4
:
705 case VARYING_SLOT_TEX5
:
706 case VARYING_SLOT_TEX6
:
707 case VARYING_SLOT_TEX7
:
708 if (st
->needs_texcoord_semantic
) {
709 input_semantic_name
[slot
] = TGSI_SEMANTIC_TEXCOORD
;
710 input_semantic_index
[slot
] = attr
- VARYING_SLOT_TEX0
;
712 st_translate_interp(stfp
->Base
.InterpQualifier
[attr
], FALSE
);
716 case VARYING_SLOT_VAR0
:
718 /* Semantic indices should be zero-based because drivers may choose
719 * to assign a fixed slot determined by that index.
720 * This is useful because ARB_separate_shader_objects uses location
721 * qualifiers for linkage, and if the semantic index corresponds to
722 * these locations, linkage passes in the driver become unecessary.
724 * If needs_texcoord_semantic is true, no semantic indices will be
725 * consumed for the TEXi varyings, and we can base the locations of
726 * the user varyings on VAR0. Otherwise, we use TEX0 as base index.
728 assert(attr
>= VARYING_SLOT_VAR0
|| attr
== VARYING_SLOT_PNTC
||
729 (attr
>= VARYING_SLOT_TEX0
&& attr
<= VARYING_SLOT_TEX7
));
730 input_semantic_name
[slot
] = TGSI_SEMANTIC_GENERIC
;
731 input_semantic_index
[slot
] = st_get_generic_varying_index(st
, attr
);
732 if (attr
== VARYING_SLOT_PNTC
)
733 interpMode
[slot
] = TGSI_INTERPOLATE_LINEAR
;
735 interpMode
[slot
] = st_translate_interp(stfp
->Base
.InterpQualifier
[attr
],
741 inputMapping
[attr
] = -1;
746 * Semantics and mapping for outputs
750 GLbitfield64 outputsWritten
= stfp
->Base
.Base
.OutputsWritten
;
752 /* if z is written, emit that first */
753 if (outputsWritten
& BITFIELD64_BIT(FRAG_RESULT_DEPTH
)) {
754 fs_output_semantic_name
[fs_num_outputs
] = TGSI_SEMANTIC_POSITION
;
755 fs_output_semantic_index
[fs_num_outputs
] = 0;
756 outputMapping
[FRAG_RESULT_DEPTH
] = fs_num_outputs
;
758 outputsWritten
&= ~(1 << FRAG_RESULT_DEPTH
);
761 if (outputsWritten
& BITFIELD64_BIT(FRAG_RESULT_STENCIL
)) {
762 fs_output_semantic_name
[fs_num_outputs
] = TGSI_SEMANTIC_STENCIL
;
763 fs_output_semantic_index
[fs_num_outputs
] = 0;
764 outputMapping
[FRAG_RESULT_STENCIL
] = fs_num_outputs
;
766 outputsWritten
&= ~(1 << FRAG_RESULT_STENCIL
);
769 if (outputsWritten
& BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK
)) {
770 fs_output_semantic_name
[fs_num_outputs
] = TGSI_SEMANTIC_SAMPLEMASK
;
771 fs_output_semantic_index
[fs_num_outputs
] = 0;
772 outputMapping
[FRAG_RESULT_SAMPLE_MASK
] = fs_num_outputs
;
774 outputsWritten
&= ~(1 << FRAG_RESULT_SAMPLE_MASK
);
777 /* handle remaining outputs (color) */
778 for (attr
= 0; attr
< FRAG_RESULT_MAX
; attr
++) {
779 if (outputsWritten
& BITFIELD64_BIT(attr
)) {
781 case FRAG_RESULT_DEPTH
:
782 case FRAG_RESULT_STENCIL
:
783 case FRAG_RESULT_SAMPLE_MASK
:
787 case FRAG_RESULT_COLOR
:
788 write_all
= GL_TRUE
; /* fallthrough */
790 assert(attr
== FRAG_RESULT_COLOR
||
791 (FRAG_RESULT_DATA0
<= attr
&& attr
< FRAG_RESULT_MAX
));
792 fs_output_semantic_name
[fs_num_outputs
] = TGSI_SEMANTIC_COLOR
;
793 fs_output_semantic_index
[fs_num_outputs
] = numColors
;
794 outputMapping
[attr
] = fs_num_outputs
;
804 if (stfp
->shader_program
) {
805 nir_shader
*nir
= st_glsl_to_nir(st
, &stfp
->Base
.Base
,
806 stfp
->shader_program
,
807 MESA_SHADER_FRAGMENT
);
809 stfp
->tgsi
.type
= PIPE_SHADER_IR_NIR
;
810 stfp
->tgsi
.ir
.nir
= nir
;
815 ureg
= ureg_create_with_screen(PIPE_SHADER_FRAGMENT
, st
->pipe
->screen
);
819 if (ST_DEBUG
& DEBUG_MESA
) {
820 _mesa_print_program(&stfp
->Base
.Base
);
821 _mesa_print_program_parameters(st
->ctx
, &stfp
->Base
.Base
);
824 if (write_all
== GL_TRUE
)
825 ureg_property(ureg
, TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS
, 1);
827 if (stfp
->Base
.FragDepthLayout
!= FRAG_DEPTH_LAYOUT_NONE
) {
828 switch (stfp
->Base
.FragDepthLayout
) {
829 case FRAG_DEPTH_LAYOUT_ANY
:
830 ureg_property(ureg
, TGSI_PROPERTY_FS_DEPTH_LAYOUT
,
831 TGSI_FS_DEPTH_LAYOUT_ANY
);
833 case FRAG_DEPTH_LAYOUT_GREATER
:
834 ureg_property(ureg
, TGSI_PROPERTY_FS_DEPTH_LAYOUT
,
835 TGSI_FS_DEPTH_LAYOUT_GREATER
);
837 case FRAG_DEPTH_LAYOUT_LESS
:
838 ureg_property(ureg
, TGSI_PROPERTY_FS_DEPTH_LAYOUT
,
839 TGSI_FS_DEPTH_LAYOUT_LESS
);
841 case FRAG_DEPTH_LAYOUT_UNCHANGED
:
842 ureg_property(ureg
, TGSI_PROPERTY_FS_DEPTH_LAYOUT
,
843 TGSI_FS_DEPTH_LAYOUT_UNCHANGED
);
850 if (stfp
->glsl_to_tgsi
) {
851 st_translate_program(st
->ctx
,
852 PIPE_SHADER_FRAGMENT
,
861 input_semantic_index
,
868 fs_output_semantic_name
,
869 fs_output_semantic_index
);
871 free_glsl_to_tgsi_visitor(stfp
->glsl_to_tgsi
);
872 stfp
->glsl_to_tgsi
= NULL
;
873 } else if (stfp
->ati_fs
)
874 st_translate_atifs_program(ureg
,
881 input_semantic_index
,
886 fs_output_semantic_name
,
887 fs_output_semantic_index
);
889 st_translate_mesa_program(st
->ctx
,
890 PIPE_SHADER_FRAGMENT
,
897 input_semantic_index
,
902 fs_output_semantic_name
,
903 fs_output_semantic_index
);
905 stfp
->tgsi
.tokens
= ureg_get_tokens(ureg
, NULL
);
907 return stfp
->tgsi
.tokens
!= NULL
;
910 static struct st_fp_variant
*
911 st_create_fp_variant(struct st_context
*st
,
912 struct st_fragment_program
*stfp
,
913 const struct st_fp_variant_key
*key
)
915 struct pipe_context
*pipe
= st
->pipe
;
916 struct st_fp_variant
*variant
= CALLOC_STRUCT(st_fp_variant
);
917 struct pipe_shader_state tgsi
= {0};
918 struct gl_program_parameter_list
*params
= stfp
->Base
.Base
.Parameters
;
919 static const gl_state_index texcoord_state
[STATE_LENGTH
] =
920 { STATE_INTERNAL
, STATE_CURRENT_ATTRIB
, VERT_ATTRIB_TEX0
};
921 static const gl_state_index scale_state
[STATE_LENGTH
] =
922 { STATE_INTERNAL
, STATE_PT_SCALE
};
923 static const gl_state_index bias_state
[STATE_LENGTH
] =
924 { STATE_INTERNAL
, STATE_PT_BIAS
};
929 if (stfp
->tgsi
.type
== PIPE_SHADER_IR_NIR
) {
930 tgsi
.type
= PIPE_SHADER_IR_NIR
;
931 tgsi
.ir
.nir
= nir_shader_clone(NULL
, stfp
->tgsi
.ir
.nir
);
933 if (key
->clamp_color
)
934 NIR_PASS_V(tgsi
.ir
.nir
, nir_lower_clamp_color_outputs
);
936 if (key
->persample_shading
) {
937 nir_shader
*shader
= tgsi
.ir
.nir
;
938 nir_foreach_variable(var
, &shader
->inputs
)
939 var
->data
.sample
= true;
942 assert(!(key
->bitmap
&& key
->drawpixels
));
946 nir_lower_bitmap_options options
= {0};
948 variant
->bitmap_sampler
= ffs(~stfp
->Base
.Base
.SamplersUsed
) - 1;
949 options
.sampler
= variant
->bitmap_sampler
;
950 options
.swizzle_xxxx
= (st
->bitmap
.tex_format
== PIPE_FORMAT_L8_UNORM
);
952 NIR_PASS_V(tgsi
.ir
.nir
, nir_lower_bitmap
, &options
);
955 /* glDrawPixels (color only) */
956 if (key
->drawpixels
) {
957 nir_lower_drawpixels_options options
= {0};
958 unsigned samplers_used
= stfp
->Base
.Base
.SamplersUsed
;
960 /* Find the first unused slot. */
961 variant
->drawpix_sampler
= ffs(~samplers_used
) - 1;
962 options
.drawpix_sampler
= variant
->drawpix_sampler
;
963 samplers_used
|= (1 << variant
->drawpix_sampler
);
965 options
.pixel_maps
= key
->pixelMaps
;
966 if (key
->pixelMaps
) {
967 variant
->pixelmap_sampler
= ffs(~samplers_used
) - 1;
968 options
.pixelmap_sampler
= variant
->pixelmap_sampler
;
971 options
.scale_and_bias
= key
->scaleAndBias
;
972 if (key
->scaleAndBias
) {
973 _mesa_add_state_reference(params
, scale_state
);
974 memcpy(options
.scale_state_tokens
, scale_state
,
975 sizeof(options
.scale_state_tokens
));
976 _mesa_add_state_reference(params
, bias_state
);
977 memcpy(options
.bias_state_tokens
, bias_state
,
978 sizeof(options
.bias_state_tokens
));
981 _mesa_add_state_reference(params
, texcoord_state
);
982 memcpy(options
.texcoord_state_tokens
, texcoord_state
,
983 sizeof(options
.texcoord_state_tokens
));
985 NIR_PASS_V(tgsi
.ir
.nir
, nir_lower_drawpixels
, &options
);
988 st_finalize_nir(st
, &stfp
->Base
.Base
, tgsi
.ir
.nir
);
990 variant
->driver_shader
= pipe
->create_fs_state(pipe
, &tgsi
);
996 tgsi
.tokens
= stfp
->tgsi
.tokens
;
998 assert(!(key
->bitmap
&& key
->drawpixels
));
1000 /* Fix texture targets and add fog for ATI_fs */
1002 const struct tgsi_token
*tokens
= st_fixup_atifs(tgsi
.tokens
, key
);
1005 tgsi
.tokens
= tokens
;
1007 fprintf(stderr
, "mesa: cannot post-process ATI_fs\n");
1010 /* Emulate features. */
1011 if (key
->clamp_color
|| key
->persample_shading
) {
1012 const struct tgsi_token
*tokens
;
1014 (key
->clamp_color
? TGSI_EMU_CLAMP_COLOR_OUTPUTS
: 0) |
1015 (key
->persample_shading
? TGSI_EMU_FORCE_PERSAMPLE_INTERP
: 0);
1017 tokens
= tgsi_emulate(tgsi
.tokens
, flags
);
1020 if (tgsi
.tokens
!= stfp
->tgsi
.tokens
)
1021 tgsi_free_tokens(tgsi
.tokens
);
1022 tgsi
.tokens
= tokens
;
1024 fprintf(stderr
, "mesa: cannot emulate deprecated features\n");
1029 const struct tgsi_token
*tokens
;
1031 variant
->bitmap_sampler
= ffs(~stfp
->Base
.Base
.SamplersUsed
) - 1;
1033 tokens
= st_get_bitmap_shader(tgsi
.tokens
,
1034 st
->internal_target
,
1035 variant
->bitmap_sampler
,
1036 st
->needs_texcoord_semantic
,
1037 st
->bitmap
.tex_format
==
1038 PIPE_FORMAT_L8_UNORM
);
1041 if (tgsi
.tokens
!= stfp
->tgsi
.tokens
)
1042 tgsi_free_tokens(tgsi
.tokens
);
1043 tgsi
.tokens
= tokens
;
1045 fprintf(stderr
, "mesa: cannot create a shader for glBitmap\n");
1048 /* glDrawPixels (color only) */
1049 if (key
->drawpixels
) {
1050 const struct tgsi_token
*tokens
;
1051 unsigned scale_const
= 0, bias_const
= 0, texcoord_const
= 0;
1053 /* Find the first unused slot. */
1054 variant
->drawpix_sampler
= ffs(~stfp
->Base
.Base
.SamplersUsed
) - 1;
1056 if (key
->pixelMaps
) {
1057 unsigned samplers_used
= stfp
->Base
.Base
.SamplersUsed
|
1058 (1 << variant
->drawpix_sampler
);
1060 variant
->pixelmap_sampler
= ffs(~samplers_used
) - 1;
1063 if (key
->scaleAndBias
) {
1064 scale_const
= _mesa_add_state_reference(params
, scale_state
);
1065 bias_const
= _mesa_add_state_reference(params
, bias_state
);
1068 texcoord_const
= _mesa_add_state_reference(params
, texcoord_state
);
1070 tokens
= st_get_drawpix_shader(tgsi
.tokens
,
1071 st
->needs_texcoord_semantic
,
1072 key
->scaleAndBias
, scale_const
,
1073 bias_const
, key
->pixelMaps
,
1074 variant
->drawpix_sampler
,
1075 variant
->pixelmap_sampler
,
1076 texcoord_const
, st
->internal_target
);
1079 if (tgsi
.tokens
!= stfp
->tgsi
.tokens
)
1080 tgsi_free_tokens(tgsi
.tokens
);
1081 tgsi
.tokens
= tokens
;
1083 fprintf(stderr
, "mesa: cannot create a shader for glDrawPixels\n");
1086 if (ST_DEBUG
& DEBUG_TGSI
) {
1087 tgsi_dump(tgsi
.tokens
, 0);
1091 /* fill in variant */
1092 variant
->driver_shader
= pipe
->create_fs_state(pipe
, &tgsi
);
1093 variant
->key
= *key
;
1095 if (tgsi
.tokens
!= stfp
->tgsi
.tokens
)
1096 tgsi_free_tokens(tgsi
.tokens
);
1101 * Translate fragment program if needed.
1103 struct st_fp_variant
*
1104 st_get_fp_variant(struct st_context
*st
,
1105 struct st_fragment_program
*stfp
,
1106 const struct st_fp_variant_key
*key
)
1108 struct st_fp_variant
*fpv
;
1110 /* Search for existing variant */
1111 for (fpv
= stfp
->variants
; fpv
; fpv
= fpv
->next
) {
1112 if (memcmp(&fpv
->key
, key
, sizeof(*key
)) == 0) {
1119 fpv
= st_create_fp_variant(st
, stfp
, key
);
1121 /* insert into list */
1122 fpv
->next
= stfp
->variants
;
1123 stfp
->variants
= fpv
;
1132 * Translate a program. This is common code for geometry and tessellation
1136 st_translate_program_common(struct st_context
*st
,
1137 struct gl_program
*prog
,
1138 struct glsl_to_tgsi_visitor
*glsl_to_tgsi
,
1139 struct ureg_program
*ureg
,
1140 unsigned tgsi_processor
,
1141 struct pipe_shader_state
*out_state
)
1143 GLuint inputSlotToAttr
[VARYING_SLOT_TESS_MAX
];
1144 GLuint inputMapping
[VARYING_SLOT_TESS_MAX
];
1145 GLuint outputSlotToAttr
[VARYING_SLOT_TESS_MAX
];
1146 GLuint outputMapping
[VARYING_SLOT_TESS_MAX
];
1149 ubyte input_semantic_name
[PIPE_MAX_SHADER_INPUTS
];
1150 ubyte input_semantic_index
[PIPE_MAX_SHADER_INPUTS
];
1151 uint num_inputs
= 0;
1153 ubyte output_semantic_name
[PIPE_MAX_SHADER_OUTPUTS
];
1154 ubyte output_semantic_index
[PIPE_MAX_SHADER_OUTPUTS
];
1155 uint num_outputs
= 0;
1159 memset(inputSlotToAttr
, 0, sizeof(inputSlotToAttr
));
1160 memset(inputMapping
, 0, sizeof(inputMapping
));
1161 memset(outputSlotToAttr
, 0, sizeof(outputSlotToAttr
));
1162 memset(outputMapping
, 0, sizeof(outputMapping
));
1163 memset(out_state
, 0, sizeof(*out_state
));
1165 if (prog
->ClipDistanceArraySize
)
1166 ureg_property(ureg
, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED
,
1167 prog
->ClipDistanceArraySize
);
1168 if (prog
->CullDistanceArraySize
)
1169 ureg_property(ureg
, TGSI_PROPERTY_NUM_CULLDIST_ENABLED
,
1170 prog
->CullDistanceArraySize
);
1173 * Convert Mesa program inputs to TGSI input register semantics.
1175 for (attr
= 0; attr
< VARYING_SLOT_MAX
; attr
++) {
1176 if ((prog
->InputsRead
& BITFIELD64_BIT(attr
)) != 0) {
1177 const GLuint slot
= num_inputs
++;
1179 inputMapping
[attr
] = slot
;
1180 inputSlotToAttr
[slot
] = attr
;
1183 case VARYING_SLOT_PRIMITIVE_ID
:
1184 assert(tgsi_processor
== PIPE_SHADER_GEOMETRY
);
1185 input_semantic_name
[slot
] = TGSI_SEMANTIC_PRIMID
;
1186 input_semantic_index
[slot
] = 0;
1188 case VARYING_SLOT_POS
:
1189 input_semantic_name
[slot
] = TGSI_SEMANTIC_POSITION
;
1190 input_semantic_index
[slot
] = 0;
1192 case VARYING_SLOT_COL0
:
1193 input_semantic_name
[slot
] = TGSI_SEMANTIC_COLOR
;
1194 input_semantic_index
[slot
] = 0;
1196 case VARYING_SLOT_COL1
:
1197 input_semantic_name
[slot
] = TGSI_SEMANTIC_COLOR
;
1198 input_semantic_index
[slot
] = 1;
1200 case VARYING_SLOT_FOGC
:
1201 input_semantic_name
[slot
] = TGSI_SEMANTIC_FOG
;
1202 input_semantic_index
[slot
] = 0;
1204 case VARYING_SLOT_CLIP_VERTEX
:
1205 input_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPVERTEX
;
1206 input_semantic_index
[slot
] = 0;
1208 case VARYING_SLOT_CLIP_DIST0
:
1209 input_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPDIST
;
1210 input_semantic_index
[slot
] = 0;
1212 case VARYING_SLOT_CLIP_DIST1
:
1213 input_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPDIST
;
1214 input_semantic_index
[slot
] = 1;
1216 case VARYING_SLOT_CULL_DIST0
:
1217 case VARYING_SLOT_CULL_DIST1
:
1218 /* these should have been lowered by GLSL */
1221 case VARYING_SLOT_PSIZ
:
1222 input_semantic_name
[slot
] = TGSI_SEMANTIC_PSIZE
;
1223 input_semantic_index
[slot
] = 0;
1225 case VARYING_SLOT_TEX0
:
1226 case VARYING_SLOT_TEX1
:
1227 case VARYING_SLOT_TEX2
:
1228 case VARYING_SLOT_TEX3
:
1229 case VARYING_SLOT_TEX4
:
1230 case VARYING_SLOT_TEX5
:
1231 case VARYING_SLOT_TEX6
:
1232 case VARYING_SLOT_TEX7
:
1233 if (st
->needs_texcoord_semantic
) {
1234 input_semantic_name
[slot
] = TGSI_SEMANTIC_TEXCOORD
;
1235 input_semantic_index
[slot
] = attr
- VARYING_SLOT_TEX0
;
1239 case VARYING_SLOT_VAR0
:
1241 assert(attr
>= VARYING_SLOT_VAR0
||
1242 (attr
>= VARYING_SLOT_TEX0
&& attr
<= VARYING_SLOT_TEX7
));
1243 input_semantic_name
[slot
] = TGSI_SEMANTIC_GENERIC
;
1244 input_semantic_index
[slot
] =
1245 st_get_generic_varying_index(st
, attr
);
1251 /* Also add patch inputs. */
1252 for (attr
= 0; attr
< 32; attr
++) {
1253 if (prog
->PatchInputsRead
& (1u << attr
)) {
1254 GLuint slot
= num_inputs
++;
1255 GLuint patch_attr
= VARYING_SLOT_PATCH0
+ attr
;
1257 inputMapping
[patch_attr
] = slot
;
1258 inputSlotToAttr
[slot
] = patch_attr
;
1259 input_semantic_name
[slot
] = TGSI_SEMANTIC_PATCH
;
1260 input_semantic_index
[slot
] = attr
;
1264 /* initialize output semantics to defaults */
1265 for (i
= 0; i
< PIPE_MAX_SHADER_OUTPUTS
; i
++) {
1266 output_semantic_name
[i
] = TGSI_SEMANTIC_GENERIC
;
1267 output_semantic_index
[i
] = 0;
1271 * Determine number of outputs, the (default) output register
1272 * mapping and the semantic information for each output.
1274 for (attr
= 0; attr
< VARYING_SLOT_MAX
; attr
++) {
1275 if (prog
->OutputsWritten
& BITFIELD64_BIT(attr
)) {
1276 GLuint slot
= num_outputs
++;
1278 outputMapping
[attr
] = slot
;
1279 outputSlotToAttr
[slot
] = attr
;
1282 case VARYING_SLOT_POS
:
1284 output_semantic_name
[slot
] = TGSI_SEMANTIC_POSITION
;
1285 output_semantic_index
[slot
] = 0;
1287 case VARYING_SLOT_COL0
:
1288 output_semantic_name
[slot
] = TGSI_SEMANTIC_COLOR
;
1289 output_semantic_index
[slot
] = 0;
1291 case VARYING_SLOT_COL1
:
1292 output_semantic_name
[slot
] = TGSI_SEMANTIC_COLOR
;
1293 output_semantic_index
[slot
] = 1;
1295 case VARYING_SLOT_BFC0
:
1296 output_semantic_name
[slot
] = TGSI_SEMANTIC_BCOLOR
;
1297 output_semantic_index
[slot
] = 0;
1299 case VARYING_SLOT_BFC1
:
1300 output_semantic_name
[slot
] = TGSI_SEMANTIC_BCOLOR
;
1301 output_semantic_index
[slot
] = 1;
1303 case VARYING_SLOT_FOGC
:
1304 output_semantic_name
[slot
] = TGSI_SEMANTIC_FOG
;
1305 output_semantic_index
[slot
] = 0;
1307 case VARYING_SLOT_PSIZ
:
1308 output_semantic_name
[slot
] = TGSI_SEMANTIC_PSIZE
;
1309 output_semantic_index
[slot
] = 0;
1311 case VARYING_SLOT_CLIP_VERTEX
:
1312 output_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPVERTEX
;
1313 output_semantic_index
[slot
] = 0;
1315 case VARYING_SLOT_CLIP_DIST0
:
1316 output_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPDIST
;
1317 output_semantic_index
[slot
] = 0;
1319 case VARYING_SLOT_CLIP_DIST1
:
1320 output_semantic_name
[slot
] = TGSI_SEMANTIC_CLIPDIST
;
1321 output_semantic_index
[slot
] = 1;
1323 case VARYING_SLOT_CULL_DIST0
:
1324 case VARYING_SLOT_CULL_DIST1
:
1325 /* these should have been lowered by GLSL */
1328 case VARYING_SLOT_LAYER
:
1329 output_semantic_name
[slot
] = TGSI_SEMANTIC_LAYER
;
1330 output_semantic_index
[slot
] = 0;
1332 case VARYING_SLOT_PRIMITIVE_ID
:
1333 output_semantic_name
[slot
] = TGSI_SEMANTIC_PRIMID
;
1334 output_semantic_index
[slot
] = 0;
1336 case VARYING_SLOT_VIEWPORT
:
1337 output_semantic_name
[slot
] = TGSI_SEMANTIC_VIEWPORT_INDEX
;
1338 output_semantic_index
[slot
] = 0;
1340 case VARYING_SLOT_TESS_LEVEL_OUTER
:
1341 output_semantic_name
[slot
] = TGSI_SEMANTIC_TESSOUTER
;
1342 output_semantic_index
[slot
] = 0;
1344 case VARYING_SLOT_TESS_LEVEL_INNER
:
1345 output_semantic_name
[slot
] = TGSI_SEMANTIC_TESSINNER
;
1346 output_semantic_index
[slot
] = 0;
1348 case VARYING_SLOT_TEX0
:
1349 case VARYING_SLOT_TEX1
:
1350 case VARYING_SLOT_TEX2
:
1351 case VARYING_SLOT_TEX3
:
1352 case VARYING_SLOT_TEX4
:
1353 case VARYING_SLOT_TEX5
:
1354 case VARYING_SLOT_TEX6
:
1355 case VARYING_SLOT_TEX7
:
1356 if (st
->needs_texcoord_semantic
) {
1357 output_semantic_name
[slot
] = TGSI_SEMANTIC_TEXCOORD
;
1358 output_semantic_index
[slot
] = attr
- VARYING_SLOT_TEX0
;
1362 case VARYING_SLOT_VAR0
:
1364 assert(slot
< ARRAY_SIZE(output_semantic_name
));
1365 assert(attr
>= VARYING_SLOT_VAR0
||
1366 (attr
>= VARYING_SLOT_TEX0
&& attr
<= VARYING_SLOT_TEX7
));
1367 output_semantic_name
[slot
] = TGSI_SEMANTIC_GENERIC
;
1368 output_semantic_index
[slot
] =
1369 st_get_generic_varying_index(st
, attr
);
1375 /* Also add patch outputs. */
1376 for (attr
= 0; attr
< 32; attr
++) {
1377 if (prog
->PatchOutputsWritten
& (1u << attr
)) {
1378 GLuint slot
= num_outputs
++;
1379 GLuint patch_attr
= VARYING_SLOT_PATCH0
+ attr
;
1381 outputMapping
[patch_attr
] = slot
;
1382 outputSlotToAttr
[slot
] = patch_attr
;
1383 output_semantic_name
[slot
] = TGSI_SEMANTIC_PATCH
;
1384 output_semantic_index
[slot
] = attr
;
1388 st_translate_program(st
->ctx
,
1397 input_semantic_name
,
1398 input_semantic_index
,
1405 output_semantic_name
,
1406 output_semantic_index
);
1408 out_state
->tokens
= ureg_get_tokens(ureg
, NULL
);
1411 st_translate_stream_output_info(glsl_to_tgsi
,
1413 &out_state
->stream_output
);
1415 if ((ST_DEBUG
& DEBUG_TGSI
) && (ST_DEBUG
& DEBUG_MESA
)) {
1416 _mesa_print_program(prog
);
1420 if (ST_DEBUG
& DEBUG_TGSI
) {
1421 tgsi_dump(out_state
->tokens
, 0);
1428 * Translate a geometry program to create a new variant.
1431 st_translate_geometry_program(struct st_context
*st
,
1432 struct st_geometry_program
*stgp
)
1434 struct ureg_program
*ureg
;
1436 ureg
= ureg_create_with_screen(PIPE_SHADER_GEOMETRY
, st
->pipe
->screen
);
1440 ureg_property(ureg
, TGSI_PROPERTY_GS_INPUT_PRIM
, stgp
->Base
.InputType
);
1441 ureg_property(ureg
, TGSI_PROPERTY_GS_OUTPUT_PRIM
, stgp
->Base
.OutputType
);
1442 ureg_property(ureg
, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES
,
1443 stgp
->Base
.VerticesOut
);
1444 ureg_property(ureg
, TGSI_PROPERTY_GS_INVOCATIONS
, stgp
->Base
.Invocations
);
1446 st_translate_program_common(st
, &stgp
->Base
.Base
, stgp
->glsl_to_tgsi
, ureg
,
1447 PIPE_SHADER_GEOMETRY
, &stgp
->tgsi
);
1449 free_glsl_to_tgsi_visitor(stgp
->glsl_to_tgsi
);
1450 stgp
->glsl_to_tgsi
= NULL
;
1456 * Get/create a basic program variant.
1458 struct st_basic_variant
*
1459 st_get_basic_variant(struct st_context
*st
,
1460 unsigned pipe_shader
,
1461 struct pipe_shader_state
*tgsi
,
1462 struct st_basic_variant
**variants
)
1464 struct pipe_context
*pipe
= st
->pipe
;
1465 struct st_basic_variant
*v
;
1466 struct st_basic_variant_key key
;
1468 memset(&key
, 0, sizeof(key
));
1469 key
.st
= st
->has_shareable_shaders
? NULL
: st
;
1471 /* Search for existing variant */
1472 for (v
= *variants
; v
; v
= v
->next
) {
1473 if (memcmp(&v
->key
, &key
, sizeof(key
)) == 0) {
1480 v
= CALLOC_STRUCT(st_basic_variant
);
1482 /* fill in new variant */
1483 switch (pipe_shader
) {
1484 case PIPE_SHADER_TESS_CTRL
:
1485 v
->driver_shader
= pipe
->create_tcs_state(pipe
, tgsi
);
1487 case PIPE_SHADER_TESS_EVAL
:
1488 v
->driver_shader
= pipe
->create_tes_state(pipe
, tgsi
);
1490 case PIPE_SHADER_GEOMETRY
:
1491 v
->driver_shader
= pipe
->create_gs_state(pipe
, tgsi
);
1494 assert(!"unhandled shader type");
1501 /* insert into list */
1502 v
->next
= *variants
;
1512 * Translate a tessellation control program to create a new variant.
1515 st_translate_tessctrl_program(struct st_context
*st
,
1516 struct st_tessctrl_program
*sttcp
)
1518 struct ureg_program
*ureg
;
1520 ureg
= ureg_create_with_screen(PIPE_SHADER_TESS_CTRL
, st
->pipe
->screen
);
1524 ureg_property(ureg
, TGSI_PROPERTY_TCS_VERTICES_OUT
,
1525 sttcp
->Base
.VerticesOut
);
1527 st_translate_program_common(st
, &sttcp
->Base
.Base
, sttcp
->glsl_to_tgsi
,
1528 ureg
, PIPE_SHADER_TESS_CTRL
, &sttcp
->tgsi
);
1530 free_glsl_to_tgsi_visitor(sttcp
->glsl_to_tgsi
);
1531 sttcp
->glsl_to_tgsi
= NULL
;
1537 * Translate a tessellation evaluation program to create a new variant.
1540 st_translate_tesseval_program(struct st_context
*st
,
1541 struct st_tesseval_program
*sttep
)
1543 struct ureg_program
*ureg
;
1545 ureg
= ureg_create_with_screen(PIPE_SHADER_TESS_EVAL
, st
->pipe
->screen
);
1549 if (sttep
->Base
.PrimitiveMode
== GL_ISOLINES
)
1550 ureg_property(ureg
, TGSI_PROPERTY_TES_PRIM_MODE
, GL_LINES
);
1552 ureg_property(ureg
, TGSI_PROPERTY_TES_PRIM_MODE
, sttep
->Base
.PrimitiveMode
);
1554 switch (sttep
->Base
.Spacing
) {
1556 ureg_property(ureg
, TGSI_PROPERTY_TES_SPACING
, PIPE_TESS_SPACING_EQUAL
);
1558 case GL_FRACTIONAL_EVEN
:
1559 ureg_property(ureg
, TGSI_PROPERTY_TES_SPACING
,
1560 PIPE_TESS_SPACING_FRACTIONAL_EVEN
);
1562 case GL_FRACTIONAL_ODD
:
1563 ureg_property(ureg
, TGSI_PROPERTY_TES_SPACING
,
1564 PIPE_TESS_SPACING_FRACTIONAL_ODD
);
1570 ureg_property(ureg
, TGSI_PROPERTY_TES_VERTEX_ORDER_CW
,
1571 sttep
->Base
.VertexOrder
== GL_CW
);
1572 ureg_property(ureg
, TGSI_PROPERTY_TES_POINT_MODE
, sttep
->Base
.PointMode
);
1574 st_translate_program_common(st
, &sttep
->Base
.Base
, sttep
->glsl_to_tgsi
,
1575 ureg
, PIPE_SHADER_TESS_EVAL
, &sttep
->tgsi
);
1577 free_glsl_to_tgsi_visitor(sttep
->glsl_to_tgsi
);
1578 sttep
->glsl_to_tgsi
= NULL
;
1584 * Translate a compute program to create a new variant.
1587 st_translate_compute_program(struct st_context
*st
,
1588 struct st_compute_program
*stcp
)
1590 struct ureg_program
*ureg
;
1591 struct pipe_shader_state prog
;
1593 ureg
= ureg_create_with_screen(PIPE_SHADER_COMPUTE
, st
->pipe
->screen
);
1597 st_translate_program_common(st
, &stcp
->Base
.Base
, stcp
->glsl_to_tgsi
, ureg
,
1598 PIPE_SHADER_COMPUTE
, &prog
);
1600 stcp
->tgsi
.ir_type
= PIPE_SHADER_IR_TGSI
;
1601 stcp
->tgsi
.prog
= prog
.tokens
;
1602 stcp
->tgsi
.req_local_mem
= stcp
->Base
.SharedSize
;
1603 stcp
->tgsi
.req_private_mem
= 0;
1604 stcp
->tgsi
.req_input_mem
= 0;
1606 free_glsl_to_tgsi_visitor(stcp
->glsl_to_tgsi
);
1607 stcp
->glsl_to_tgsi
= NULL
;
1613 * Get/create compute program variant.
1615 struct st_basic_variant
*
1616 st_get_cp_variant(struct st_context
*st
,
1617 struct pipe_compute_state
*tgsi
,
1618 struct st_basic_variant
**variants
)
1620 struct pipe_context
*pipe
= st
->pipe
;
1621 struct st_basic_variant
*v
;
1622 struct st_basic_variant_key key
;
1624 memset(&key
, 0, sizeof(key
));
1625 key
.st
= st
->has_shareable_shaders
? NULL
: st
;
1627 /* Search for existing variant */
1628 for (v
= *variants
; v
; v
= v
->next
) {
1629 if (memcmp(&v
->key
, &key
, sizeof(key
)) == 0) {
1636 v
= CALLOC_STRUCT(st_basic_variant
);
1638 /* fill in new variant */
1639 v
->driver_shader
= pipe
->create_compute_state(pipe
, tgsi
);
1642 /* insert into list */
1643 v
->next
= *variants
;
1653 * Vert/Geom/Frag programs have per-context variants. Free all the
1654 * variants attached to the given program which match the given context.
1657 destroy_program_variants(struct st_context
*st
, struct gl_program
*target
)
1659 if (!target
|| target
== &_mesa_DummyProgram
)
1662 switch (target
->Target
) {
1663 case GL_VERTEX_PROGRAM_ARB
:
1665 struct st_vertex_program
*stvp
= (struct st_vertex_program
*) target
;
1666 struct st_vp_variant
*vpv
, **prevPtr
= &stvp
->variants
;
1668 for (vpv
= stvp
->variants
; vpv
; ) {
1669 struct st_vp_variant
*next
= vpv
->next
;
1670 if (vpv
->key
.st
== st
) {
1671 /* unlink from list */
1673 /* destroy this variant */
1674 delete_vp_variant(st
, vpv
);
1677 prevPtr
= &vpv
->next
;
1683 case GL_FRAGMENT_PROGRAM_ARB
:
1685 struct st_fragment_program
*stfp
=
1686 (struct st_fragment_program
*) target
;
1687 struct st_fp_variant
*fpv
, **prevPtr
= &stfp
->variants
;
1689 for (fpv
= stfp
->variants
; fpv
; ) {
1690 struct st_fp_variant
*next
= fpv
->next
;
1691 if (fpv
->key
.st
== st
) {
1692 /* unlink from list */
1694 /* destroy this variant */
1695 delete_fp_variant(st
, fpv
);
1698 prevPtr
= &fpv
->next
;
1704 case GL_GEOMETRY_PROGRAM_NV
:
1705 case GL_TESS_CONTROL_PROGRAM_NV
:
1706 case GL_TESS_EVALUATION_PROGRAM_NV
:
1707 case GL_COMPUTE_PROGRAM_NV
:
1709 struct st_geometry_program
*gp
= (struct st_geometry_program
*)target
;
1710 struct st_tessctrl_program
*tcp
= (struct st_tessctrl_program
*)target
;
1711 struct st_tesseval_program
*tep
= (struct st_tesseval_program
*)target
;
1712 struct st_compute_program
*cp
= (struct st_compute_program
*)target
;
1713 struct st_basic_variant
**variants
=
1714 target
->Target
== GL_GEOMETRY_PROGRAM_NV
? &gp
->variants
:
1715 target
->Target
== GL_TESS_CONTROL_PROGRAM_NV
? &tcp
->variants
:
1716 target
->Target
== GL_TESS_EVALUATION_PROGRAM_NV
? &tep
->variants
:
1717 target
->Target
== GL_COMPUTE_PROGRAM_NV
? &cp
->variants
:
1719 struct st_basic_variant
*v
, **prevPtr
= variants
;
1721 for (v
= *variants
; v
; ) {
1722 struct st_basic_variant
*next
= v
->next
;
1723 if (v
->key
.st
== st
) {
1724 /* unlink from list */
1726 /* destroy this variant */
1727 delete_basic_variant(st
, v
, target
->Target
);
1737 _mesa_problem(NULL
, "Unexpected program target 0x%x in "
1738 "destroy_program_variants_cb()", target
->Target
);
1744 * Callback for _mesa_HashWalk. Free all the shader's program variants
1745 * which match the given context.
1748 destroy_shader_program_variants_cb(GLuint key
, void *data
, void *userData
)
1750 struct st_context
*st
= (struct st_context
*) userData
;
1751 struct gl_shader
*shader
= (struct gl_shader
*) data
;
1753 switch (shader
->Type
) {
1754 case GL_SHADER_PROGRAM_MESA
:
1756 struct gl_shader_program
*shProg
= (struct gl_shader_program
*) data
;
1759 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1760 destroy_program_variants(st
, shProg
->Shaders
[i
]->Program
);
1763 for (i
= 0; i
< ARRAY_SIZE(shProg
->_LinkedShaders
); i
++) {
1764 if (shProg
->_LinkedShaders
[i
])
1765 destroy_program_variants(st
, shProg
->_LinkedShaders
[i
]->Program
);
1769 case GL_VERTEX_SHADER
:
1770 case GL_FRAGMENT_SHADER
:
1771 case GL_GEOMETRY_SHADER
:
1772 case GL_TESS_CONTROL_SHADER
:
1773 case GL_TESS_EVALUATION_SHADER
:
1774 case GL_COMPUTE_SHADER
:
1776 destroy_program_variants(st
, shader
->Program
);
1786 * Callback for _mesa_HashWalk. Free all the program variants which match
1787 * the given context.
1790 destroy_program_variants_cb(GLuint key
, void *data
, void *userData
)
1792 struct st_context
*st
= (struct st_context
*) userData
;
1793 struct gl_program
*program
= (struct gl_program
*) data
;
1794 destroy_program_variants(st
, program
);
1799 * Walk over all shaders and programs to delete any variants which
1800 * belong to the given context.
1801 * This is called during context tear-down.
1804 st_destroy_program_variants(struct st_context
*st
)
1806 /* If shaders can be shared with other contexts, the last context will
1807 * call DeleteProgram on all shaders, releasing everything.
1809 if (st
->has_shareable_shaders
)
1812 /* ARB vert/frag program */
1813 _mesa_HashWalk(st
->ctx
->Shared
->Programs
,
1814 destroy_program_variants_cb
, st
);
1816 /* GLSL vert/frag/geom shaders */
1817 _mesa_HashWalk(st
->ctx
->Shared
->ShaderObjects
,
1818 destroy_shader_program_variants_cb
, st
);
1823 * For debugging, print/dump the current vertex program.
1826 st_print_current_vertex_program(void)
1828 GET_CURRENT_CONTEXT(ctx
);
1830 if (ctx
->VertexProgram
._Current
) {
1831 struct st_vertex_program
*stvp
=
1832 (struct st_vertex_program
*) ctx
->VertexProgram
._Current
;
1833 struct st_vp_variant
*stv
;
1835 debug_printf("Vertex program %u\n", stvp
->Base
.Base
.Id
);
1837 for (stv
= stvp
->variants
; stv
; stv
= stv
->next
) {
1838 debug_printf("variant %p\n", stv
);
1839 tgsi_dump(stv
->tgsi
.tokens
, 0);
1846 * Compile one shader variant.
1849 st_precompile_shader_variant(struct st_context
*st
,
1850 struct gl_program
*prog
)
1852 switch (prog
->Target
) {
1853 case GL_VERTEX_PROGRAM_ARB
: {
1854 struct st_vertex_program
*p
= (struct st_vertex_program
*)prog
;
1855 struct st_vp_variant_key key
;
1857 memset(&key
, 0, sizeof(key
));
1858 key
.st
= st
->has_shareable_shaders
? NULL
: st
;
1859 st_get_vp_variant(st
, p
, &key
);
1863 case GL_TESS_CONTROL_PROGRAM_NV
: {
1864 struct st_tessctrl_program
*p
= (struct st_tessctrl_program
*)prog
;
1865 st_get_basic_variant(st
, PIPE_SHADER_TESS_CTRL
, &p
->tgsi
, &p
->variants
);
1869 case GL_TESS_EVALUATION_PROGRAM_NV
: {
1870 struct st_tesseval_program
*p
= (struct st_tesseval_program
*)prog
;
1871 st_get_basic_variant(st
, PIPE_SHADER_TESS_EVAL
, &p
->tgsi
, &p
->variants
);
1875 case GL_GEOMETRY_PROGRAM_NV
: {
1876 struct st_geometry_program
*p
= (struct st_geometry_program
*)prog
;
1877 st_get_basic_variant(st
, PIPE_SHADER_GEOMETRY
, &p
->tgsi
, &p
->variants
);
1881 case GL_FRAGMENT_PROGRAM_ARB
: {
1882 struct st_fragment_program
*p
= (struct st_fragment_program
*)prog
;
1883 struct st_fp_variant_key key
;
1885 memset(&key
, 0, sizeof(key
));
1886 key
.st
= st
->has_shareable_shaders
? NULL
: st
;
1887 st_get_fp_variant(st
, p
, &key
);
1891 case GL_COMPUTE_PROGRAM_NV
: {
1892 struct st_compute_program
*p
= (struct st_compute_program
*)prog
;
1893 st_get_cp_variant(st
, &p
->tgsi
, &p
->variants
);