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
;
57 ureg
= ureg_create(PIPE_SHADER_VERTEX
);
61 dst
= ureg_DECL_output(ureg
, TGSI_SEMANTIC_POSITION
, 0);
62 src
= ureg_DECL_immediate(ureg
, zero
, 4);
63 ureg_MOV(ureg
, dst
, src
);
66 tokens
= ureg_get_tokens(ureg
, &num_tokens
);
74 static struct svga_shader_variant
*
75 translate_vertex_program(struct svga_context
*svga
,
76 const struct svga_vertex_shader
*vs
,
77 const struct svga_compile_key
*key
)
79 if (svga_have_vgpu10(svga
)) {
80 return svga_tgsi_vgpu10_translate(svga
, &vs
->base
, key
,
84 return svga_tgsi_vgpu9_translate(svga
, &vs
->base
, key
,
91 * Replace the given shader's instruction with a simple / dummy shader.
92 * We use this when normal shader translation fails.
94 static struct svga_shader_variant
*
95 get_compiled_dummy_vertex_shader(struct svga_context
*svga
,
96 struct svga_vertex_shader
*vs
,
97 const struct svga_compile_key
*key
)
99 const struct tgsi_token
*dummy
= get_dummy_vertex_shader();
100 struct svga_shader_variant
*variant
;
106 FREE((void *) vs
->base
.tokens
);
107 vs
->base
.tokens
= dummy
;
109 variant
= translate_vertex_program(svga
, vs
, key
);
115 * Translate TGSI shader into an svga shader variant.
117 static enum pipe_error
118 compile_vs(struct svga_context
*svga
,
119 struct svga_vertex_shader
*vs
,
120 const struct svga_compile_key
*key
,
121 struct svga_shader_variant
**out_variant
)
123 struct svga_shader_variant
*variant
;
124 enum pipe_error ret
= PIPE_ERROR
;
126 variant
= translate_vertex_program(svga
, vs
, key
);
127 if (variant
== NULL
) {
128 debug_printf("Failed to compile vertex shader,"
129 " using dummy shader instead.\n");
130 variant
= get_compiled_dummy_vertex_shader(svga
, vs
, key
);
132 else if (svga_shader_too_large(svga
, variant
)) {
133 /* too big, use dummy shader */
134 debug_printf("Shader too large (%u bytes),"
135 " using dummy shader instead.\n",
136 (unsigned) (variant
->nr_tokens
137 * sizeof(variant
->tokens
[0])));
138 /* Free the too-large variant */
139 svga_destroy_shader_variant(svga
, SVGA3D_SHADERTYPE_VS
, variant
);
140 /* Use simple pass-through shader instead */
141 variant
= get_compiled_dummy_vertex_shader(svga
, vs
, key
);
148 ret
= svga_define_shader(svga
, SVGA3D_SHADERTYPE_VS
, variant
);
149 if (ret
!= PIPE_OK
) {
150 svga_destroy_shader_variant(svga
, SVGA3D_SHADERTYPE_VS
, variant
);
154 *out_variant
= variant
;
160 /* SVGA_NEW_PRESCALE, SVGA_NEW_RAST, SVGA_NEW_FS
163 make_vs_key(struct svga_context
*svga
, struct svga_compile_key
*key
)
165 const enum pipe_shader_type shader
= PIPE_SHADER_VERTEX
;
167 memset(key
, 0, sizeof *key
);
169 if (svga
->state
.sw
.need_swtnl
&& svga_have_vgpu10(svga
)) {
170 /* Set both of these flags, to match compile_passthrough_vs() */
171 key
->vs
.passthrough
= 1;
172 key
->vs
.undo_viewport
= 1;
176 /* SVGA_NEW_PRESCALE */
177 key
->vs
.need_prescale
= svga
->state
.hw_clear
.prescale
.enabled
&&
178 (svga
->curr
.gs
== NULL
);
181 key
->vs
.allow_psiz
= svga
->curr
.rast
->templ
.point_size_per_vertex
;
184 key
->vs
.fs_generic_inputs
= svga
->curr
.fs
->generic_inputs
;
186 svga_remap_generics(key
->vs
.fs_generic_inputs
, key
->generic_remap_table
);
188 /* SVGA_NEW_VELEMENT */
189 key
->vs
.adjust_attrib_range
= svga
->curr
.velems
->adjust_attrib_range
;
190 key
->vs
.adjust_attrib_w_1
= svga
->curr
.velems
->adjust_attrib_w_1
;
191 key
->vs
.attrib_is_pure_int
= svga
->curr
.velems
->attrib_is_pure_int
;
192 key
->vs
.adjust_attrib_itof
= svga
->curr
.velems
->adjust_attrib_itof
;
193 key
->vs
.adjust_attrib_utof
= svga
->curr
.velems
->adjust_attrib_utof
;
194 key
->vs
.attrib_is_bgra
= svga
->curr
.velems
->attrib_is_bgra
;
195 key
->vs
.attrib_puint_to_snorm
= svga
->curr
.velems
->attrib_puint_to_snorm
;
196 key
->vs
.attrib_puint_to_uscaled
= svga
->curr
.velems
->attrib_puint_to_uscaled
;
197 key
->vs
.attrib_puint_to_sscaled
= svga
->curr
.velems
->attrib_puint_to_sscaled
;
199 /* SVGA_NEW_TEXTURE_BINDING | SVGA_NEW_SAMPLER */
200 svga_init_shader_key_common(svga
, shader
, key
);
203 key
->clip_plane_enable
= svga
->curr
.rast
->templ
.clip_plane_enable
;
208 * svga_reemit_vs_bindings - Reemit the vertex shader bindings
211 svga_reemit_vs_bindings(struct svga_context
*svga
)
214 struct svga_winsys_gb_shader
*gbshader
= NULL
;
215 SVGA3dShaderId shaderId
= SVGA3D_INVALID_ID
;
217 assert(svga
->rebind
.flags
.vs
);
218 assert(svga_have_gb_objects(svga
));
220 if (svga
->state
.hw_draw
.vs
) {
221 gbshader
= svga
->state
.hw_draw
.vs
->gb_shader
;
222 shaderId
= svga
->state
.hw_draw
.vs
->id
;
225 if (!svga_need_to_rebind_resources(svga
)) {
226 ret
= svga
->swc
->resource_rebind(svga
->swc
, NULL
, gbshader
,
231 if (svga_have_vgpu10(svga
))
232 ret
= SVGA3D_vgpu10_SetShader(svga
->swc
, SVGA3D_SHADERTYPE_VS
,
235 ret
= SVGA3D_SetGBShader(svga
->swc
, SVGA3D_SHADERTYPE_VS
, gbshader
);
241 svga
->rebind
.flags
.vs
= FALSE
;
247 * The current vertex shader is already executed by the 'draw'
248 * module, so we just need to generate a simple vertex shader
249 * to pass through all those VS outputs that will
250 * be consumed by the fragment shader.
251 * Used when we employ the 'draw' module.
253 static enum pipe_error
254 compile_passthrough_vs(struct svga_context
*svga
,
255 struct svga_vertex_shader
*vs
,
256 struct svga_fragment_shader
*fs
,
257 struct svga_shader_variant
**out_variant
)
259 struct svga_shader_variant
*variant
= NULL
;
262 unsigned num_elements
;
263 struct svga_vertex_shader new_vs
;
264 struct ureg_src src
[PIPE_MAX_SHADER_INPUTS
];
265 struct ureg_dst dst
[PIPE_MAX_SHADER_OUTPUTS
];
266 struct ureg_program
*ureg
;
268 struct svga_compile_key key
;
271 assert(svga_have_vgpu10(svga
));
274 num_inputs
= fs
->base
.info
.num_inputs
;
276 ureg
= ureg_create(PIPE_SHADER_VERTEX
);
278 return PIPE_ERROR_OUT_OF_MEMORY
;
280 /* draw will always add position */
281 dst
[0] = ureg_DECL_output(ureg
, TGSI_SEMANTIC_POSITION
, 0);
282 src
[0] = ureg_DECL_vs_input(ureg
, 0);
286 * swtnl backend redefines the input layout based on the
287 * fragment shader's inputs. So we only need to passthrough
288 * those inputs that will be consumed by the fragment shader.
289 * Note: DX10 requires the number of vertex elements
290 * specified in the input layout to be no less than the
291 * number of inputs to the vertex shader.
293 for (i
= 0; i
< num_inputs
; i
++) {
294 switch (fs
->base
.info
.input_semantic_name
[i
]) {
295 case TGSI_SEMANTIC_COLOR
:
296 case TGSI_SEMANTIC_GENERIC
:
297 case TGSI_SEMANTIC_FOG
:
298 dst
[num_elements
] = ureg_DECL_output(ureg
,
299 fs
->base
.info
.input_semantic_name
[i
],
300 fs
->base
.info
.input_semantic_index
[i
]);
301 src
[num_elements
] = ureg_DECL_vs_input(ureg
, num_elements
);
309 for (i
= 0; i
< num_elements
; i
++) {
310 ureg_MOV(ureg
, dst
[i
], src
[i
]);
315 memset(&new_vs
, 0, sizeof(new_vs
));
316 new_vs
.base
.tokens
= ureg_get_tokens(ureg
, &num_tokens
);
317 tgsi_scan_shader(new_vs
.base
.tokens
, &new_vs
.base
.info
);
319 memset(&key
, 0, sizeof(key
));
320 key
.vs
.undo_viewport
= 1;
322 ret
= compile_vs(svga
, &new_vs
, &key
, &variant
);
326 ureg_free_tokens(new_vs
.base
.tokens
);
329 /* Overwrite the variant key to indicate it's a pass-through VS */
330 memset(&variant
->key
, 0, sizeof(variant
->key
));
331 variant
->key
.vs
.passthrough
= 1;
332 variant
->key
.vs
.undo_viewport
= 1;
334 *out_variant
= variant
;
340 static enum pipe_error
341 emit_hw_vs(struct svga_context
*svga
, unsigned dirty
)
343 struct svga_shader_variant
*variant
;
344 struct svga_vertex_shader
*vs
= svga
->curr
.vs
;
345 struct svga_fragment_shader
*fs
= svga
->curr
.fs
;
346 enum pipe_error ret
= PIPE_OK
;
347 struct svga_compile_key key
;
349 SVGA_STATS_TIME_PUSH(svga_sws(svga
), SVGA_STATS_TIME_EMITVS
);
351 /* If there is an active geometry shader, and it has stream output
352 * defined, then we will skip the stream output from the vertex shader
354 if (!svga_have_gs_streamout(svga
)) {
355 /* No GS stream out */
356 if (svga_have_vs_streamout(svga
)) {
357 /* Set VS stream out */
358 svga_set_stream_output(svga
, vs
->base
.stream_output
);
361 /* turn off stream out */
362 svga_set_stream_output(svga
, NULL
);
366 /* SVGA_NEW_NEED_SWTNL */
367 if (svga
->state
.sw
.need_swtnl
&& !svga_have_vgpu10(svga
)) {
368 /* No vertex shader is needed */
372 make_vs_key(svga
, &key
);
374 /* See if we already have a VS variant that matches the key */
375 variant
= svga_search_shader_key(&vs
->base
, &key
);
378 /* Create VS variant now */
379 if (key
.vs
.passthrough
) {
380 ret
= compile_passthrough_vs(svga
, vs
, fs
, &variant
);
383 ret
= compile_vs(svga
, vs
, &key
, &variant
);
388 /* insert the new variant at head of linked list */
390 variant
->next
= vs
->base
.variants
;
391 vs
->base
.variants
= variant
;
395 if (variant
!= svga
->state
.hw_draw
.vs
) {
396 /* Bind the new variant */
398 ret
= svga_set_shader(svga
, SVGA3D_SHADERTYPE_VS
, variant
);
401 svga
->rebind
.flags
.vs
= FALSE
;
404 svga
->dirty
|= SVGA_NEW_VS_VARIANT
;
405 svga
->state
.hw_draw
.vs
= variant
;
409 SVGA_STATS_TIME_POP(svga_sws(svga
));
413 struct svga_tracked_state svga_hw_vs
=
415 "vertex shader (hwtnl)",
418 SVGA_NEW_TEXTURE_BINDING
|
423 SVGA_NEW_NEED_SWTNL
),