1 /**********************************************************
2 * Copyright 2008-2009 VMware, Inc. All rights reserved.
4 * Permission is hereby granted, free of charge, to any person
5 * obtaining a copy of this software and associated documentation
6 * files (the "Software"), to deal in the Software without
7 * restriction, including without limitation the rights to use, copy,
8 * modify, merge, publish, distribute, sublicense, and/or sell copies
9 * of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 **********************************************************/
26 #include "util/u_inlines.h"
27 #include "pipe/p_defines.h"
28 #include "util/u_math.h"
29 #include "util/u_memory.h"
30 #include "util/u_bitmask.h"
31 #include "translate/translate.h"
32 #include "tgsi/tgsi_ureg.h"
34 #include "svga_context.h"
35 #include "svga_state.h"
37 #include "svga_shader.h"
38 #include "svga_tgsi.h"
40 #include "svga_hw_reg.h"
44 * If we fail to compile a vertex shader we'll use a dummy/fallback shader
45 * that simply emits a (0,0,0,1) vertex position.
47 static const struct tgsi_token
*
48 get_dummy_vertex_shader(void)
50 static const float zero
[4] = { 0.0, 0.0, 0.0, 1.0 };
51 struct ureg_program
*ureg
;
52 const struct tgsi_token
*tokens
;
56 ureg
= ureg_create(PIPE_SHADER_VERTEX
);
60 dst
= ureg_DECL_output(ureg
, TGSI_SEMANTIC_POSITION
, 0);
61 src
= ureg_DECL_immediate(ureg
, zero
, 4);
62 ureg_MOV(ureg
, dst
, src
);
65 tokens
= ureg_get_tokens(ureg
, NULL
);
73 static struct svga_shader_variant
*
74 translate_vertex_program(struct svga_context
*svga
,
75 const struct svga_vertex_shader
*vs
,
76 const struct svga_compile_key
*key
)
78 if (svga_have_vgpu10(svga
)) {
79 return svga_tgsi_vgpu10_translate(svga
, &vs
->base
, key
,
83 return svga_tgsi_vgpu9_translate(svga
, &vs
->base
, key
,
90 * Replace the given shader's instruction with a simple / dummy shader.
91 * We use this when normal shader translation fails.
93 static struct svga_shader_variant
*
94 get_compiled_dummy_vertex_shader(struct svga_context
*svga
,
95 struct svga_vertex_shader
*vs
,
96 const struct svga_compile_key
*key
)
98 const struct tgsi_token
*dummy
= get_dummy_vertex_shader();
99 struct svga_shader_variant
*variant
;
105 FREE((void *) vs
->base
.tokens
);
106 vs
->base
.tokens
= dummy
;
108 tgsi_scan_shader(vs
->base
.tokens
, &vs
->base
.info
);
109 vs
->generic_outputs
= svga_get_generic_outputs_mask(&vs
->base
.info
);
111 variant
= translate_vertex_program(svga
, vs
, key
);
117 * Translate TGSI shader into an svga shader variant.
119 static enum pipe_error
120 compile_vs(struct svga_context
*svga
,
121 struct svga_vertex_shader
*vs
,
122 const struct svga_compile_key
*key
,
123 struct svga_shader_variant
**out_variant
)
125 struct svga_shader_variant
*variant
;
126 enum pipe_error ret
= PIPE_ERROR
;
128 variant
= translate_vertex_program(svga
, vs
, key
);
129 if (variant
== NULL
) {
130 debug_printf("Failed to compile vertex shader,"
131 " using dummy shader instead.\n");
132 variant
= get_compiled_dummy_vertex_shader(svga
, vs
, key
);
134 else if (svga_shader_too_large(svga
, variant
)) {
135 /* too big, use dummy shader */
136 debug_printf("Shader too large (%u bytes),"
137 " using dummy shader instead.\n",
138 (unsigned) (variant
->nr_tokens
139 * sizeof(variant
->tokens
[0])));
140 /* Free the too-large variant */
141 svga_destroy_shader_variant(svga
, SVGA3D_SHADERTYPE_VS
, variant
);
142 /* Use simple pass-through shader instead */
143 variant
= get_compiled_dummy_vertex_shader(svga
, vs
, key
);
150 ret
= svga_define_shader(svga
, SVGA3D_SHADERTYPE_VS
, variant
);
151 if (ret
!= PIPE_OK
) {
152 svga_destroy_shader_variant(svga
, SVGA3D_SHADERTYPE_VS
, variant
);
156 *out_variant
= variant
;
162 /* SVGA_NEW_PRESCALE, SVGA_NEW_RAST, SVGA_NEW_FS
165 make_vs_key(struct svga_context
*svga
, struct svga_compile_key
*key
)
167 const enum pipe_shader_type shader
= PIPE_SHADER_VERTEX
;
169 memset(key
, 0, sizeof *key
);
171 if (svga
->state
.sw
.need_swtnl
&& svga_have_vgpu10(svga
)) {
172 /* Set both of these flags, to match compile_passthrough_vs() */
173 key
->vs
.passthrough
= 1;
174 key
->vs
.undo_viewport
= 1;
178 /* SVGA_NEW_PRESCALE */
179 key
->vs
.need_prescale
= svga
->state
.hw_clear
.prescale
.enabled
&&
180 (svga
->curr
.gs
== NULL
);
183 key
->vs
.allow_psiz
= svga
->curr
.rast
->templ
.point_size_per_vertex
;
186 key
->vs
.fs_generic_inputs
= svga
->curr
.fs
->generic_inputs
;
188 svga_remap_generics(key
->vs
.fs_generic_inputs
, key
->generic_remap_table
);
190 /* SVGA_NEW_VELEMENT */
191 key
->vs
.adjust_attrib_range
= svga
->curr
.velems
->adjust_attrib_range
;
192 key
->vs
.adjust_attrib_w_1
= svga
->curr
.velems
->adjust_attrib_w_1
;
193 key
->vs
.attrib_is_pure_int
= svga
->curr
.velems
->attrib_is_pure_int
;
194 key
->vs
.adjust_attrib_itof
= svga
->curr
.velems
->adjust_attrib_itof
;
195 key
->vs
.adjust_attrib_utof
= svga
->curr
.velems
->adjust_attrib_utof
;
196 key
->vs
.attrib_is_bgra
= svga
->curr
.velems
->attrib_is_bgra
;
197 key
->vs
.attrib_puint_to_snorm
= svga
->curr
.velems
->attrib_puint_to_snorm
;
198 key
->vs
.attrib_puint_to_uscaled
= svga
->curr
.velems
->attrib_puint_to_uscaled
;
199 key
->vs
.attrib_puint_to_sscaled
= svga
->curr
.velems
->attrib_puint_to_sscaled
;
201 /* SVGA_NEW_TEXTURE_BINDING | SVGA_NEW_SAMPLER */
202 svga_init_shader_key_common(svga
, shader
, key
);
205 key
->clip_plane_enable
= svga
->curr
.rast
->templ
.clip_plane_enable
;
210 * svga_reemit_vs_bindings - Reemit the vertex shader bindings
213 svga_reemit_vs_bindings(struct svga_context
*svga
)
216 struct svga_winsys_gb_shader
*gbshader
= NULL
;
217 SVGA3dShaderId shaderId
= SVGA3D_INVALID_ID
;
219 assert(svga
->rebind
.flags
.vs
);
220 assert(svga_have_gb_objects(svga
));
222 if (svga
->state
.hw_draw
.vs
) {
223 gbshader
= svga
->state
.hw_draw
.vs
->gb_shader
;
224 shaderId
= svga
->state
.hw_draw
.vs
->id
;
227 if (!svga_need_to_rebind_resources(svga
)) {
228 ret
= svga
->swc
->resource_rebind(svga
->swc
, NULL
, gbshader
,
233 if (svga_have_vgpu10(svga
))
234 ret
= SVGA3D_vgpu10_SetShader(svga
->swc
, SVGA3D_SHADERTYPE_VS
,
237 ret
= SVGA3D_SetGBShader(svga
->swc
, SVGA3D_SHADERTYPE_VS
, gbshader
);
243 svga
->rebind
.flags
.vs
= FALSE
;
249 * The current vertex shader is already executed by the 'draw'
250 * module, so we just need to generate a simple vertex shader
251 * to pass through all those VS outputs that will
252 * be consumed by the fragment shader.
253 * Used when we employ the 'draw' module.
255 static enum pipe_error
256 compile_passthrough_vs(struct svga_context
*svga
,
257 struct svga_vertex_shader
*vs
,
258 struct svga_fragment_shader
*fs
,
259 struct svga_shader_variant
**out_variant
)
261 struct svga_shader_variant
*variant
= NULL
;
264 unsigned num_elements
;
265 struct svga_vertex_shader new_vs
;
266 struct ureg_src src
[PIPE_MAX_SHADER_INPUTS
];
267 struct ureg_dst dst
[PIPE_MAX_SHADER_OUTPUTS
];
268 struct ureg_program
*ureg
;
269 struct svga_compile_key key
;
272 assert(svga_have_vgpu10(svga
));
275 num_inputs
= fs
->base
.info
.num_inputs
;
277 ureg
= ureg_create(PIPE_SHADER_VERTEX
);
279 return PIPE_ERROR_OUT_OF_MEMORY
;
281 /* draw will always add position */
282 dst
[0] = ureg_DECL_output(ureg
, TGSI_SEMANTIC_POSITION
, 0);
283 src
[0] = ureg_DECL_vs_input(ureg
, 0);
287 * swtnl backend redefines the input layout based on the
288 * fragment shader's inputs. So we only need to passthrough
289 * those inputs that will be consumed by the fragment shader.
290 * Note: DX10 requires the number of vertex elements
291 * specified in the input layout to be no less than the
292 * number of inputs to the vertex shader.
294 for (i
= 0; i
< num_inputs
; i
++) {
295 switch (fs
->base
.info
.input_semantic_name
[i
]) {
296 case TGSI_SEMANTIC_COLOR
:
297 case TGSI_SEMANTIC_GENERIC
:
298 case TGSI_SEMANTIC_FOG
:
299 dst
[num_elements
] = ureg_DECL_output(ureg
,
300 fs
->base
.info
.input_semantic_name
[i
],
301 fs
->base
.info
.input_semantic_index
[i
]);
302 src
[num_elements
] = ureg_DECL_vs_input(ureg
, num_elements
);
310 for (i
= 0; i
< num_elements
; i
++) {
311 ureg_MOV(ureg
, dst
[i
], src
[i
]);
316 memset(&new_vs
, 0, sizeof(new_vs
));
317 new_vs
.base
.tokens
= ureg_get_tokens(ureg
, NULL
);
318 tgsi_scan_shader(new_vs
.base
.tokens
, &new_vs
.base
.info
);
320 memset(&key
, 0, sizeof(key
));
321 key
.vs
.undo_viewport
= 1;
323 ret
= compile_vs(svga
, &new_vs
, &key
, &variant
);
327 ureg_free_tokens(new_vs
.base
.tokens
);
330 /* Overwrite the variant key to indicate it's a pass-through VS */
331 memset(&variant
->key
, 0, sizeof(variant
->key
));
332 variant
->key
.vs
.passthrough
= 1;
333 variant
->key
.vs
.undo_viewport
= 1;
335 *out_variant
= variant
;
341 static enum pipe_error
342 emit_hw_vs(struct svga_context
*svga
, unsigned dirty
)
344 struct svga_shader_variant
*variant
;
345 struct svga_vertex_shader
*vs
= svga
->curr
.vs
;
346 struct svga_fragment_shader
*fs
= svga
->curr
.fs
;
347 enum pipe_error ret
= PIPE_OK
;
348 struct svga_compile_key key
;
350 SVGA_STATS_TIME_PUSH(svga_sws(svga
), SVGA_STATS_TIME_EMITVS
);
352 /* If there is an active geometry shader, and it has stream output
353 * defined, then we will skip the stream output from the vertex shader
355 if (!svga_have_gs_streamout(svga
)) {
356 /* No GS stream out */
357 if (svga_have_vs_streamout(svga
)) {
358 /* Set VS stream out */
359 ret
= svga_set_stream_output(svga
, vs
->base
.stream_output
);
362 /* turn off stream out */
363 ret
= svga_set_stream_output(svga
, NULL
);
365 if (ret
!= PIPE_OK
) {
370 /* SVGA_NEW_NEED_SWTNL */
371 if (svga
->state
.sw
.need_swtnl
&& !svga_have_vgpu10(svga
)) {
372 /* No vertex shader is needed */
376 make_vs_key(svga
, &key
);
378 /* See if we already have a VS variant that matches the key */
379 variant
= svga_search_shader_key(&vs
->base
, &key
);
382 /* Create VS variant now */
383 if (key
.vs
.passthrough
) {
384 ret
= compile_passthrough_vs(svga
, vs
, fs
, &variant
);
387 ret
= compile_vs(svga
, vs
, &key
, &variant
);
392 /* insert the new variant at head of linked list */
394 variant
->next
= vs
->base
.variants
;
395 vs
->base
.variants
= variant
;
399 if (variant
!= svga
->state
.hw_draw
.vs
) {
400 /* Bind the new variant */
402 ret
= svga_set_shader(svga
, SVGA3D_SHADERTYPE_VS
, variant
);
405 svga
->rebind
.flags
.vs
= FALSE
;
408 svga
->dirty
|= SVGA_NEW_VS_VARIANT
;
409 svga
->state
.hw_draw
.vs
= variant
;
413 SVGA_STATS_TIME_POP(svga_sws(svga
));
417 struct svga_tracked_state svga_hw_vs
=
419 "vertex shader (hwtnl)",
422 SVGA_NEW_TEXTURE_BINDING
|
427 SVGA_NEW_NEED_SWTNL
),