2 /**********************************************************
3 * Copyright 2008-2009 VMware, Inc. All rights reserved.
5 * Permission is hereby granted, free of charge, to any person
6 * obtaining a copy of this software and associated documentation
7 * files (the "Software"), to deal in the Software without
8 * restriction, including without limitation the rights to use, copy,
9 * modify, merge, publish, distribute, sublicense, and/or sell copies
10 * of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
20 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
21 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 **********************************************************/
27 #include "util/u_format.h"
28 #include "util/u_inlines.h"
29 #include "util/u_memory.h"
30 #include "pipe/p_defines.h"
31 #include "util/u_upload_mgr.h"
33 #include "svga_screen.h"
34 #include "svga_context.h"
35 #include "svga_state.h"
37 #include "svga_tgsi.h"
38 #include "svga_debug.h"
39 #include "svga_resource_buffer.h"
40 #include "svga_shader.h"
42 #include "svga_hw_reg.h"
46 * Don't try to send more than 4kb of successive constants.
48 #define MAX_CONST_REG_COUNT 256 /**< number of float[4] constants */
51 * Extra space for svga-specific VS/PS constants (such as texcoord
52 * scale factors, vertex transformation scale/translation).
54 #define MAX_EXTRA_CONSTS 32
56 /** Guest-backed surface constant buffers must be this size */
57 #define GB_CONSTBUF_SIZE (SVGA3D_CONSTREG_MAX)
61 * Emit any extra shader-type-independent shader constants into the buffer
62 * pointed to by 'dest'.
63 * \return number of float[4] constants put into the 'dest' buffer
66 svga_get_extra_constants_common(struct svga_context
*svga
,
67 const struct svga_shader_variant
*variant
,
68 unsigned shader
, float *dest
)
70 uint32_t *dest_u
= (uint32_t *) dest
; // uint version of dest
74 for (i
= 0; i
< variant
->key
.num_textures
; i
++) {
75 struct pipe_sampler_view
*sv
= svga
->curr
.sampler_views
[shader
][i
];
77 struct pipe_resource
*tex
= sv
->texture
;
78 /* Scaling factors needed for handling unnormalized texture coordinates
79 * for texture rectangles.
81 if (variant
->key
.tex
[i
].unnormalized
) {
82 /* debug/sanity check */
83 assert(variant
->key
.tex
[i
].width_height_idx
== count
);
85 *dest
++ = 1.0 / (float)tex
->width0
;
86 *dest
++ = 1.0 / (float)tex
->height0
;
93 /* Store the sizes for texture buffers.
95 if (tex
->target
== PIPE_BUFFER
) {
96 unsigned bytes_per_element
= util_format_get_blocksize(sv
->format
);
97 *dest_u
++ = tex
->width0
/ bytes_per_element
;
112 * Emit any extra fragment shader constants into the buffer pointed
114 * \return number of float[4] constants put into the dest buffer
117 svga_get_extra_fs_constants(struct svga_context
*svga
, float *dest
)
119 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.fs
;
122 count
+= svga_get_extra_constants_common(svga
, variant
,
123 PIPE_SHADER_FRAGMENT
, dest
);
125 assert(count
<= MAX_EXTRA_CONSTS
);
131 * Emit extra constants needed for prescale computation into the
132 * the buffer pointed to by '*dest'. The updated buffer pointer
133 * will be returned in 'dest'.
136 svga_get_prescale_constants(struct svga_context
*svga
, float **dest
)
138 memcpy(*dest
, svga
->state
.hw_clear
.prescale
.scale
, 4 * sizeof(float));
141 memcpy(*dest
, svga
->state
.hw_clear
.prescale
.translate
, 4 * sizeof(float));
148 * Emit extra constants needed for point sprite emulation.
151 svga_get_pt_sprite_constants(struct svga_context
*svga
, float **dest
)
153 struct svga_screen
*screen
= svga_screen(svga
->pipe
.screen
);
156 dst
[0] = 1.0 / (svga
->curr
.viewport
.scale
[0] * 2);
157 dst
[1] = 1.0 / (svga
->curr
.viewport
.scale
[1] * 2);
158 dst
[2] = svga
->curr
.rast
->pointsize
;
159 dst
[3] = screen
->maxPointSize
;
165 * Emit user-defined clip plane coefficients into the buffer pointed to
166 * by '*dest'. The updated buffer pointer will be returned in 'dest'.
169 svga_get_clip_plane_constants(struct svga_context
*svga
,
170 const struct svga_shader_variant
*variant
,
176 if (svga_have_vgpu10(svga
)) {
177 /* append user-defined clip plane coefficients onto constant buffer */
178 unsigned clip_planes
= variant
->key
.clip_plane_enable
;
179 while (clip_planes
) {
180 int i
= u_bit_scan(&clip_planes
);
181 COPY_4V(*dest
, svga
->curr
.clip
.ucp
[i
]);
190 * Emit any extra vertex shader constants into the buffer pointed
192 * In particular, these would be the scale and bias factors computed
193 * from the framebuffer size which are used to copy with differences in
194 * GL vs D3D coordinate spaces. See svga_tgsi_insn.c for more info.
195 * \return number of float[4] constants put into the dest buffer
198 svga_get_extra_vs_constants(struct svga_context
*svga
, float *dest
)
200 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.vs
;
203 /* SVGA_NEW_VS_VARIANT
205 if (variant
->key
.vs
.need_prescale
) {
206 count
+= svga_get_prescale_constants(svga
, &dest
);
209 if (variant
->key
.vs
.undo_viewport
) {
210 /* Used to convert window coords back to NDC coords */
211 dest
[0] = 1.0f
/ svga
->curr
.viewport
.scale
[0];
212 dest
[1] = 1.0f
/ svga
->curr
.viewport
.scale
[1];
213 dest
[2] = -svga
->curr
.viewport
.translate
[0];
214 dest
[3] = -svga
->curr
.viewport
.translate
[1];
220 count
+= svga_get_clip_plane_constants(svga
, variant
, &dest
);
222 /* common constants */
223 count
+= svga_get_extra_constants_common(svga
, variant
,
224 PIPE_SHADER_VERTEX
, dest
);
226 assert(count
<= MAX_EXTRA_CONSTS
);
232 * Emit any extra geometry shader constants into the buffer pointed
236 svga_get_extra_gs_constants(struct svga_context
*svga
, float *dest
)
238 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.gs
;
241 /* SVGA_NEW_GS_VARIANT
244 /* Constants for point sprite
245 * These are used in the transformed gs that supports point sprite.
246 * They need to be added before the prescale constants.
248 if (variant
->key
.gs
.wide_point
) {
249 count
+= svga_get_pt_sprite_constants(svga
, &dest
);
252 if (variant
->key
.gs
.need_prescale
) {
253 count
+= svga_get_prescale_constants(svga
, &dest
);
257 count
+= svga_get_clip_plane_constants(svga
, variant
, &dest
);
259 /* common constants */
260 count
+= svga_get_extra_constants_common(svga
, variant
,
261 PIPE_SHADER_GEOMETRY
, dest
);
263 assert(count
<= MAX_EXTRA_CONSTS
);
268 * Check and emit one shader constant register.
269 * \param shader PIPE_SHADER_FRAGMENT or PIPE_SHADER_VERTEX
270 * \param i which float[4] constant to change
271 * \param value the new float[4] value
273 static enum pipe_error
274 emit_const(struct svga_context
*svga
, unsigned shader
, unsigned i
,
277 enum pipe_error ret
= PIPE_OK
;
279 assert(shader
< PIPE_SHADER_TYPES
);
280 assert(i
< SVGA3D_CONSTREG_MAX
);
281 assert(!svga_have_vgpu10(svga
));
283 if (memcmp(svga
->state
.hw_draw
.cb
[shader
][i
], value
,
284 4 * sizeof(float)) != 0) {
285 if (SVGA_DEBUG
& DEBUG_CONSTS
)
286 debug_printf("%s %s %u: %f %f %f %f\n",
288 shader
== PIPE_SHADER_VERTEX
? "VERT" : "FRAG",
295 ret
= SVGA3D_SetShaderConst( svga
->swc
,
297 svga_shader_type(shader
),
298 SVGA3D_CONST_TYPE_FLOAT
,
303 memcpy(svga
->state
.hw_draw
.cb
[shader
][i
], value
, 4 * sizeof(float));
305 svga
->hud
.num_const_updates
++;
313 * Check and emit a range of shader constant registers, trying to coalesce
314 * successive shader constant updates in a single command in order to save
315 * space on the command buffer. This is a HWv8 feature.
317 static enum pipe_error
318 emit_const_range(struct svga_context
*svga
,
322 const float (*values
)[4])
327 assert(shader
== PIPE_SHADER_VERTEX
||
328 shader
== PIPE_SHADER_FRAGMENT
);
329 assert(!svga_have_vgpu10(svga
));
332 if (offset
+ count
> SVGA3D_CONSTREG_MAX
) {
333 debug_printf("svga: too many constants (offset %u + count %u = %u (max = %u))\n",
334 offset
, count
, offset
+ count
, SVGA3D_CONSTREG_MAX
);
338 if (offset
> SVGA3D_CONSTREG_MAX
) {
339 /* This isn't OK, but if we propagate an error all the way up we'll
340 * just get into more trouble.
341 * XXX note that offset is always zero at this time so this is moot.
346 if (offset
+ count
> SVGA3D_CONSTREG_MAX
) {
347 /* Just drop the extra constants for now.
348 * Ideally we should not have allowed the app to create a shader
349 * that exceeds our constant buffer size but there's no way to
350 * express that in gallium at this time.
352 count
= SVGA3D_CONSTREG_MAX
- offset
;
357 if (memcmp(svga
->state
.hw_draw
.cb
[shader
][offset
+ i
],
359 4 * sizeof(float)) != 0) {
360 /* Found one dirty constant
362 if (SVGA_DEBUG
& DEBUG_CONSTS
)
363 debug_printf("%s %s %d: %f %f %f %f\n",
365 shader
== PIPE_SHADER_VERTEX
? "VERT" : "FRAG",
372 /* Look for more consecutive dirty constants.
376 j
< i
+ MAX_CONST_REG_COUNT
&&
377 memcmp(svga
->state
.hw_draw
.cb
[shader
][offset
+ j
],
379 4 * sizeof(float)) != 0) {
381 if (SVGA_DEBUG
& DEBUG_CONSTS
)
382 debug_printf("%s %s %d: %f %f %f %f\n",
384 shader
== PIPE_SHADER_VERTEX
? "VERT" : "FRAG",
396 /* Send them all together.
398 if (svga_have_gb_objects(svga
)) {
399 ret
= SVGA3D_SetGBShaderConstsInline(svga
->swc
,
400 offset
+ i
, /* start */
402 svga_shader_type(shader
),
403 SVGA3D_CONST_TYPE_FLOAT
,
407 ret
= SVGA3D_SetShaderConsts(svga
->swc
,
409 svga_shader_type(shader
),
410 SVGA3D_CONST_TYPE_FLOAT
,
413 if (ret
!= PIPE_OK
) {
418 * Local copy of the hardware state.
420 memcpy(svga
->state
.hw_draw
.cb
[shader
][offset
+ i
],
422 (j
- i
) * 4 * sizeof(float));
426 svga
->hud
.num_const_updates
++;
438 * Emit all the constants in a constant buffer for a shader stage.
439 * On VGPU10, emit_consts_vgpu10 is used instead.
441 static enum pipe_error
442 emit_consts_vgpu9(struct svga_context
*svga
, unsigned shader
)
444 const struct pipe_constant_buffer
*cbuf
;
445 struct svga_screen
*ss
= svga_screen(svga
->pipe
.screen
);
446 struct pipe_transfer
*transfer
= NULL
;
448 const float (*data
)[4] = NULL
;
450 enum pipe_error ret
= PIPE_OK
;
451 const unsigned offset
= 0;
453 assert(shader
< PIPE_SHADER_TYPES
);
454 assert(!svga_have_vgpu10(svga
));
455 /* Only one constant buffer per shader is supported before VGPU10.
456 * This is only an approximate check against that.
458 assert(svga
->curr
.constbufs
[shader
][1].buffer
== NULL
);
460 cbuf
= &svga
->curr
.constbufs
[shader
][0];
462 if (svga
->curr
.constbufs
[shader
][0].buffer
) {
463 /* emit user-provided constants */
464 data
= (const float (*)[4])
465 pipe_buffer_map(&svga
->pipe
, svga
->curr
.constbufs
[shader
][0].buffer
,
466 PIPE_TRANSFER_READ
, &transfer
);
468 return PIPE_ERROR_OUT_OF_MEMORY
;
472 assert(cbuf
->buffer
->width0
>=
475 /* Use/apply the constant buffer size and offsets here */
476 count
= cbuf
->buffer_size
/ (4 * sizeof(float));
477 data
+= cbuf
->buffer_offset
/ (4 * sizeof(float));
479 if (ss
->hw_version
>= SVGA3D_HWVERSION_WS8_B1
) {
480 ret
= emit_const_range( svga
, shader
, offset
, count
, data
);
483 for (i
= 0; i
< count
; i
++) {
484 ret
= emit_const( svga
, shader
, offset
+ i
, data
[i
] );
485 if (ret
!= PIPE_OK
) {
491 pipe_buffer_unmap(&svga
->pipe
, transfer
);
493 if (ret
!= PIPE_OK
) {
498 /* emit extra shader constants */
500 const struct svga_shader_variant
*variant
= NULL
;
502 float extras
[MAX_EXTRA_CONSTS
][4];
506 case PIPE_SHADER_VERTEX
:
507 variant
= svga
->state
.hw_draw
.vs
;
508 count
= svga_get_extra_vs_constants(svga
, (float *) extras
);
510 case PIPE_SHADER_FRAGMENT
:
511 variant
= svga
->state
.hw_draw
.fs
;
512 count
= svga_get_extra_fs_constants(svga
, (float *) extras
);
515 assert(!"Unexpected shader type");
520 offset
= variant
->shader
->info
.file_max
[TGSI_FILE_CONSTANT
] + 1;
521 assert(count
<= Elements(extras
));
524 if (ss
->hw_version
>= SVGA3D_HWVERSION_WS8_B1
) {
525 ret
= emit_const_range(svga
, shader
, offset
, count
,
526 (const float (*) [4])extras
);
529 for (i
= 0; i
< count
; i
++) {
530 ret
= emit_const(svga
, shader
, offset
+ i
, extras
[i
]);
543 static enum pipe_error
544 emit_constbuf_vgpu10(struct svga_context
*svga
, unsigned shader
)
546 const struct pipe_constant_buffer
*cbuf
;
547 struct pipe_resource
*dst_buffer
= NULL
;
548 enum pipe_error ret
= PIPE_OK
;
549 struct pipe_transfer
*src_transfer
;
550 struct svga_winsys_surface
*dst_handle
;
551 float extras
[MAX_EXTRA_CONSTS
][4];
552 unsigned extra_count
, extra_size
, extra_offset
;
553 unsigned new_buf_size
;
554 void *src_map
= NULL
, *dst_map
;
556 const struct svga_shader_variant
*variant
;
558 assert(shader
== PIPE_SHADER_VERTEX
||
559 shader
== PIPE_SHADER_GEOMETRY
||
560 shader
== PIPE_SHADER_FRAGMENT
);
562 cbuf
= &svga
->curr
.constbufs
[shader
][0];
565 case PIPE_SHADER_VERTEX
:
566 variant
= svga
->state
.hw_draw
.vs
;
567 extra_count
= svga_get_extra_vs_constants(svga
, (float *) extras
);
569 case PIPE_SHADER_FRAGMENT
:
570 variant
= svga
->state
.hw_draw
.fs
;
571 extra_count
= svga_get_extra_fs_constants(svga
, (float *) extras
);
573 case PIPE_SHADER_GEOMETRY
:
574 variant
= svga
->state
.hw_draw
.gs
;
575 extra_count
= svga_get_extra_gs_constants(svga
, (float *) extras
);
578 assert(!"Unexpected shader type");
579 /* Don't return an error code since we don't want to keep re-trying
580 * this function and getting stuck in an infinite loop.
587 /* Compute extra constants size and offset in bytes */
588 extra_size
= extra_count
* 4 * sizeof(float);
589 extra_offset
= 4 * sizeof(float) * variant
->extra_const_start
;
591 if (cbuf
->buffer_size
+ extra_size
== 0)
592 return PIPE_OK
; /* nothing to do */
594 /* Typically, the cbuf->buffer here is a user-space buffer so mapping
595 * it is really cheap. If we ever get real HW buffers for constants
596 * we should void mapping and instead use a ResourceCopy command.
598 if (cbuf
->buffer_size
> 0) {
599 src_map
= pipe_buffer_map_range(&svga
->pipe
, cbuf
->buffer
,
600 cbuf
->buffer_offset
, cbuf
->buffer_size
,
601 PIPE_TRANSFER_READ
, &src_transfer
);
604 return PIPE_ERROR_OUT_OF_MEMORY
;
608 /* The new/dest buffer's size must be large enough to hold the original,
609 * user-specified constants, plus the extra constants.
610 * The size of the original constant buffer _should_ agree with what the
611 * shader is expecting, but it might not (it's not enforced anywhere by
614 new_buf_size
= MAX2(cbuf
->buffer_size
, extra_offset
) + extra_size
;
616 /* According to the DX10 spec, the constant buffer size must be
617 * in multiples of 16.
619 new_buf_size
= align(new_buf_size
, 16);
621 u_upload_alloc(svga
->const0_upload
, 0, new_buf_size
,
622 CONST0_UPLOAD_ALIGNMENT
, &offset
,
623 &dst_buffer
, &dst_map
);
626 pipe_buffer_unmap(&svga
->pipe
, src_transfer
);
627 return PIPE_ERROR_OUT_OF_MEMORY
;
631 memcpy(dst_map
, src_map
, cbuf
->buffer_size
);
632 pipe_buffer_unmap(&svga
->pipe
, src_transfer
);
636 assert(extra_offset
+ extra_size
<= new_buf_size
);
637 memcpy((char *) dst_map
+ extra_offset
, extras
, extra_size
);
639 u_upload_unmap(svga
->const0_upload
);
641 /* Issue the SetSingleConstantBuffer command */
642 dst_handle
= svga_buffer_handle(svga
, dst_buffer
);
644 pipe_resource_reference(&dst_buffer
, NULL
);
645 return PIPE_ERROR_OUT_OF_MEMORY
;
648 assert(new_buf_size
% 16 == 0);
649 ret
= SVGA3D_vgpu10_SetSingleConstantBuffer(svga
->swc
,
651 svga_shader_type(shader
),
656 if (ret
!= PIPE_OK
) {
657 pipe_resource_reference(&dst_buffer
, NULL
);
661 /* Save this const buffer until it's replaced in the future.
662 * Otherwise, all references to the buffer will go away after the
663 * command buffer is submitted, it'll get recycled and we will have
664 * incorrect constant buffer bindings.
666 pipe_resource_reference(&svga
->state
.hw_draw
.constbuf
[shader
], dst_buffer
);
668 svga
->state
.hw_draw
.default_constbuf_size
[shader
] = new_buf_size
;
670 pipe_resource_reference(&dst_buffer
, NULL
);
672 svga
->hud
.num_const_buf_updates
++;
678 static enum pipe_error
679 emit_consts_vgpu10(struct svga_context
*svga
, unsigned shader
)
682 unsigned dirty_constbufs
;
683 unsigned enabled_constbufs
;
685 /* Emit 0th constant buffer (with extra constants) */
686 ret
= emit_constbuf_vgpu10(svga
, shader
);
687 if (ret
!= PIPE_OK
) {
691 enabled_constbufs
= svga
->state
.hw_draw
.enabled_constbufs
[shader
] | 1u;
693 /* Emit other constant buffers (UBOs) */
694 dirty_constbufs
= svga
->state
.dirty_constbufs
[shader
] & ~1u;
696 while (dirty_constbufs
) {
697 unsigned index
= u_bit_scan(&dirty_constbufs
);
698 unsigned offset
= svga
->curr
.constbufs
[shader
][index
].buffer_offset
;
699 unsigned size
= svga
->curr
.constbufs
[shader
][index
].buffer_size
;
700 struct svga_buffer
*buffer
=
701 svga_buffer(svga
->curr
.constbufs
[shader
][index
].buffer
);
702 struct svga_winsys_surface
*handle
;
705 handle
= svga_buffer_handle(svga
, &buffer
->b
.b
);
706 enabled_constbufs
|= 1 << index
;
710 enabled_constbufs
&= ~(1 << index
);
715 if (size
% 16 != 0) {
716 /* GL's buffer range sizes can be any number of bytes but the
717 * SVGA3D device requires a multiple of 16 bytes.
719 const unsigned total_size
= buffer
->b
.b
.width0
;
721 if (offset
+ align(size
, 16) <= total_size
) {
722 /* round up size to multiple of 16 */
723 size
= align(size
, 16);
726 /* round down to mulitple of 16 (this may cause rendering problems
727 * but should avoid a device error).
733 assert(size
% 16 == 0);
734 ret
= SVGA3D_vgpu10_SetSingleConstantBuffer(svga
->swc
,
736 svga_shader_type(shader
),
743 svga
->hud
.num_const_buf_updates
++;
746 svga
->state
.hw_draw
.enabled_constbufs
[shader
] = enabled_constbufs
;
747 svga
->state
.dirty_constbufs
[shader
] = 0;
752 static enum pipe_error
753 emit_fs_consts(struct svga_context
*svga
, unsigned dirty
)
755 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.fs
;
756 enum pipe_error ret
= PIPE_OK
;
758 /* SVGA_NEW_FS_VARIANT
763 /* SVGA_NEW_FS_CONST_BUFFER
765 if (svga_have_vgpu10(svga
)) {
766 ret
= emit_consts_vgpu10(svga
, PIPE_SHADER_FRAGMENT
);
769 ret
= emit_consts_vgpu9(svga
, PIPE_SHADER_FRAGMENT
);
776 struct svga_tracked_state svga_hw_fs_constants
=
779 (SVGA_NEW_FS_CONST_BUFFER
|
780 SVGA_NEW_FS_VARIANT
|
781 SVGA_NEW_TEXTURE_BINDING
),
787 static enum pipe_error
788 emit_vs_consts(struct svga_context
*svga
, unsigned dirty
)
790 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.vs
;
791 enum pipe_error ret
= PIPE_OK
;
793 /* SVGA_NEW_VS_VARIANT
798 /* SVGA_NEW_VS_CONST_BUFFER
800 if (svga_have_vgpu10(svga
)) {
801 ret
= emit_consts_vgpu10(svga
, PIPE_SHADER_VERTEX
);
804 ret
= emit_consts_vgpu9(svga
, PIPE_SHADER_VERTEX
);
811 struct svga_tracked_state svga_hw_vs_constants
=
815 SVGA_NEW_VS_CONST_BUFFER
|
816 SVGA_NEW_VS_VARIANT
),
821 static enum pipe_error
822 emit_gs_consts(struct svga_context
*svga
, unsigned dirty
)
824 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.gs
;
825 enum pipe_error ret
= PIPE_OK
;
827 /* SVGA_NEW_GS_VARIANT
832 /* SVGA_NEW_GS_CONST_BUFFER
834 if (svga_have_vgpu10(svga
)) {
836 * If only the rasterizer state has changed and the current geometry
837 * shader does not emit wide points, then there is no reason to
838 * re-emit the GS constants, so skip it.
840 if (dirty
== SVGA_NEW_RAST
&& !variant
->key
.gs
.wide_point
)
843 ret
= emit_consts_vgpu10(svga
, PIPE_SHADER_GEOMETRY
);
850 struct svga_tracked_state svga_hw_gs_constants
=
853 (SVGA_NEW_GS_CONST_BUFFER
|
855 SVGA_NEW_GS_VARIANT
),