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));
311 * Check and emit a range of shader constant registers, trying to coalesce
312 * successive shader constant updates in a single command in order to save
313 * space on the command buffer. This is a HWv8 feature.
315 static enum pipe_error
316 emit_const_range(struct svga_context
*svga
,
320 const float (*values
)[4])
325 assert(shader
== PIPE_SHADER_VERTEX
||
326 shader
== PIPE_SHADER_FRAGMENT
);
327 assert(!svga_have_vgpu10(svga
));
330 if (offset
+ count
> SVGA3D_CONSTREG_MAX
) {
331 debug_printf("svga: too many constants (offset %u + count %u = %u (max = %u))\n",
332 offset
, count
, offset
+ count
, SVGA3D_CONSTREG_MAX
);
336 if (offset
> SVGA3D_CONSTREG_MAX
) {
337 /* This isn't OK, but if we propagate an error all the way up we'll
338 * just get into more trouble.
339 * XXX note that offset is always zero at this time so this is moot.
344 if (offset
+ count
> SVGA3D_CONSTREG_MAX
) {
345 /* Just drop the extra constants for now.
346 * Ideally we should not have allowed the app to create a shader
347 * that exceeds our constant buffer size but there's no way to
348 * express that in gallium at this time.
350 count
= SVGA3D_CONSTREG_MAX
- offset
;
355 if (memcmp(svga
->state
.hw_draw
.cb
[shader
][offset
+ i
],
357 4 * sizeof(float)) != 0) {
358 /* Found one dirty constant
360 if (SVGA_DEBUG
& DEBUG_CONSTS
)
361 debug_printf("%s %s %d: %f %f %f %f\n",
363 shader
== PIPE_SHADER_VERTEX
? "VERT" : "FRAG",
370 /* Look for more consecutive dirty constants.
374 j
< i
+ MAX_CONST_REG_COUNT
&&
375 memcmp(svga
->state
.hw_draw
.cb
[shader
][offset
+ j
],
377 4 * sizeof(float)) != 0) {
379 if (SVGA_DEBUG
& DEBUG_CONSTS
)
380 debug_printf("%s %s %d: %f %f %f %f\n",
382 shader
== PIPE_SHADER_VERTEX
? "VERT" : "FRAG",
394 /* Send them all together.
396 if (svga_have_gb_objects(svga
)) {
397 ret
= SVGA3D_SetGBShaderConstsInline(svga
->swc
,
398 offset
+ i
, /* start */
400 svga_shader_type(shader
),
401 SVGA3D_CONST_TYPE_FLOAT
,
405 ret
= SVGA3D_SetShaderConsts(svga
->swc
,
407 svga_shader_type(shader
),
408 SVGA3D_CONST_TYPE_FLOAT
,
411 if (ret
!= PIPE_OK
) {
416 * Local copy of the hardware state.
418 memcpy(svga
->state
.hw_draw
.cb
[shader
][offset
+ i
],
420 (j
- i
) * 4 * sizeof(float));
433 * Emit all the constants in a constant buffer for a shader stage.
434 * On VGPU10, emit_consts_vgpu10 is used instead.
436 static enum pipe_error
437 emit_consts_vgpu9(struct svga_context
*svga
, unsigned shader
)
439 const struct pipe_constant_buffer
*cbuf
;
440 struct svga_screen
*ss
= svga_screen(svga
->pipe
.screen
);
441 struct pipe_transfer
*transfer
= NULL
;
443 const float (*data
)[4] = NULL
;
445 enum pipe_error ret
= PIPE_OK
;
446 const unsigned offset
= 0;
448 assert(shader
< PIPE_SHADER_TYPES
);
449 assert(!svga_have_vgpu10(svga
));
450 /* Only one constant buffer per shader is supported before VGPU10.
451 * This is only an approximate check against that.
453 assert(svga
->curr
.constbufs
[shader
][1].buffer
== NULL
);
455 cbuf
= &svga
->curr
.constbufs
[shader
][0];
457 if (svga
->curr
.constbufs
[shader
][0].buffer
) {
458 /* emit user-provided constants */
459 data
= (const float (*)[4])
460 pipe_buffer_map(&svga
->pipe
, svga
->curr
.constbufs
[shader
][0].buffer
,
461 PIPE_TRANSFER_READ
, &transfer
);
463 return PIPE_ERROR_OUT_OF_MEMORY
;
467 assert(cbuf
->buffer
->width0
>=
470 /* Use/apply the constant buffer size and offsets here */
471 count
= cbuf
->buffer_size
/ (4 * sizeof(float));
472 data
+= cbuf
->buffer_offset
/ (4 * sizeof(float));
474 if (ss
->hw_version
>= SVGA3D_HWVERSION_WS8_B1
) {
475 ret
= emit_const_range( svga
, shader
, offset
, count
, data
);
478 for (i
= 0; i
< count
; i
++) {
479 ret
= emit_const( svga
, shader
, offset
+ i
, data
[i
] );
480 if (ret
!= PIPE_OK
) {
486 pipe_buffer_unmap(&svga
->pipe
, transfer
);
488 if (ret
!= PIPE_OK
) {
493 /* emit extra shader constants */
495 const struct svga_shader_variant
*variant
= NULL
;
497 float extras
[MAX_EXTRA_CONSTS
][4];
501 case PIPE_SHADER_VERTEX
:
502 variant
= svga
->state
.hw_draw
.vs
;
503 count
= svga_get_extra_vs_constants(svga
, (float *) extras
);
505 case PIPE_SHADER_FRAGMENT
:
506 variant
= svga
->state
.hw_draw
.fs
;
507 count
= svga_get_extra_fs_constants(svga
, (float *) extras
);
510 assert(!"Unexpected shader type");
515 offset
= variant
->shader
->info
.file_max
[TGSI_FILE_CONSTANT
] + 1;
516 assert(count
<= Elements(extras
));
519 if (ss
->hw_version
>= SVGA3D_HWVERSION_WS8_B1
) {
520 ret
= emit_const_range(svga
, shader
, offset
, count
,
521 (const float (*) [4])extras
);
524 for (i
= 0; i
< count
; i
++) {
525 ret
= emit_const(svga
, shader
, offset
+ i
, extras
[i
]);
538 static enum pipe_error
539 emit_constbuf_vgpu10(struct svga_context
*svga
, unsigned shader
)
541 const struct pipe_constant_buffer
*cbuf
;
542 struct pipe_resource
*dst_buffer
= NULL
;
543 enum pipe_error ret
= PIPE_OK
;
544 struct pipe_transfer
*src_transfer
;
545 struct svga_winsys_surface
*dst_handle
;
546 float extras
[MAX_EXTRA_CONSTS
][4];
547 unsigned extra_count
, extra_size
, extra_offset
;
548 unsigned new_buf_size
;
549 void *src_map
= NULL
, *dst_map
;
551 const struct svga_shader_variant
*variant
;
553 assert(shader
== PIPE_SHADER_VERTEX
||
554 shader
== PIPE_SHADER_GEOMETRY
||
555 shader
== PIPE_SHADER_FRAGMENT
);
557 cbuf
= &svga
->curr
.constbufs
[shader
][0];
560 case PIPE_SHADER_VERTEX
:
561 variant
= svga
->state
.hw_draw
.vs
;
562 extra_count
= svga_get_extra_vs_constants(svga
, (float *) extras
);
564 case PIPE_SHADER_FRAGMENT
:
565 variant
= svga
->state
.hw_draw
.fs
;
566 extra_count
= svga_get_extra_fs_constants(svga
, (float *) extras
);
568 case PIPE_SHADER_GEOMETRY
:
569 variant
= svga
->state
.hw_draw
.gs
;
570 extra_count
= svga_get_extra_gs_constants(svga
, (float *) extras
);
573 assert(!"Unexpected shader type");
574 /* Don't return an error code since we don't want to keep re-trying
575 * this function and getting stuck in an infinite loop.
582 /* Compute extra constants size and offset in bytes */
583 extra_size
= extra_count
* 4 * sizeof(float);
584 extra_offset
= 4 * sizeof(float) * variant
->extra_const_start
;
586 if (cbuf
->buffer_size
+ extra_size
== 0)
587 return PIPE_OK
; /* nothing to do */
589 /* Typically, the cbuf->buffer here is a user-space buffer so mapping
590 * it is really cheap. If we ever get real HW buffers for constants
591 * we should void mapping and instead use a ResourceCopy command.
593 if (cbuf
->buffer_size
> 0) {
594 src_map
= pipe_buffer_map_range(&svga
->pipe
, cbuf
->buffer
,
595 cbuf
->buffer_offset
, cbuf
->buffer_size
,
596 PIPE_TRANSFER_READ
, &src_transfer
);
599 return PIPE_ERROR_OUT_OF_MEMORY
;
603 /* The new/dest buffer's size must be large enough to hold the original,
604 * user-specified constants, plus the extra constants.
605 * The size of the original constant buffer _should_ agree with what the
606 * shader is expecting, but it might not (it's not enforced anywhere by
609 new_buf_size
= MAX2(cbuf
->buffer_size
, extra_offset
) + extra_size
;
611 /* According to the DX10 spec, the constant buffer size must be
612 * in multiples of 16.
614 new_buf_size
= align(new_buf_size
, 16);
616 u_upload_alloc(svga
->const0_upload
, 0, new_buf_size
, &offset
,
617 &dst_buffer
, &dst_map
);
620 pipe_buffer_unmap(&svga
->pipe
, src_transfer
);
621 return PIPE_ERROR_OUT_OF_MEMORY
;
625 memcpy(dst_map
, src_map
, cbuf
->buffer_size
);
626 pipe_buffer_unmap(&svga
->pipe
, src_transfer
);
630 assert(extra_offset
+ extra_size
<= new_buf_size
);
631 memcpy((char *) dst_map
+ extra_offset
, extras
, extra_size
);
633 u_upload_unmap(svga
->const0_upload
);
635 /* Issue the SetSingleConstantBuffer command */
636 dst_handle
= svga_buffer_handle(svga
, dst_buffer
);
638 pipe_resource_reference(&dst_buffer
, NULL
);
639 return PIPE_ERROR_OUT_OF_MEMORY
;
642 assert(new_buf_size
% 16 == 0);
643 ret
= SVGA3D_vgpu10_SetSingleConstantBuffer(svga
->swc
,
645 svga_shader_type(shader
),
650 if (ret
!= PIPE_OK
) {
651 pipe_resource_reference(&dst_buffer
, NULL
);
655 /* Save this const buffer until it's replaced in the future.
656 * Otherwise, all references to the buffer will go away after the
657 * command buffer is submitted, it'll get recycled and we will have
658 * incorrect constant buffer bindings.
660 pipe_resource_reference(&svga
->state
.hw_draw
.constbuf
[shader
], dst_buffer
);
662 svga
->state
.hw_draw
.default_constbuf_size
[shader
] = new_buf_size
;
664 pipe_resource_reference(&dst_buffer
, NULL
);
670 static enum pipe_error
671 emit_consts_vgpu10(struct svga_context
*svga
, unsigned shader
)
674 unsigned dirty_constbufs
;
675 unsigned enabled_constbufs
;
677 /* Emit 0th constant buffer (with extra constants) */
678 ret
= emit_constbuf_vgpu10(svga
, shader
);
679 if (ret
!= PIPE_OK
) {
683 enabled_constbufs
= svga
->state
.hw_draw
.enabled_constbufs
[shader
] | 1u;
685 /* Emit other constant buffers (UBOs) */
686 dirty_constbufs
= svga
->state
.dirty_constbufs
[shader
] & ~1u;
688 while (dirty_constbufs
) {
689 unsigned index
= u_bit_scan(&dirty_constbufs
);
690 unsigned offset
= svga
->curr
.constbufs
[shader
][index
].buffer_offset
;
691 unsigned size
= svga
->curr
.constbufs
[shader
][index
].buffer_size
;
692 struct svga_buffer
*buffer
=
693 svga_buffer(svga
->curr
.constbufs
[shader
][index
].buffer
);
694 struct svga_winsys_surface
*handle
;
697 handle
= svga_buffer_handle(svga
, &buffer
->b
.b
);
698 enabled_constbufs
|= 1 << index
;
702 enabled_constbufs
&= ~(1 << index
);
707 if (size
% 16 != 0) {
708 /* GL's buffer range sizes can be any number of bytes but the
709 * SVGA3D device requires a multiple of 16 bytes.
711 const unsigned total_size
= buffer
->b
.b
.width0
;
713 if (offset
+ align(size
, 16) <= total_size
) {
714 /* round up size to multiple of 16 */
715 size
= align(size
, 16);
718 /* round down to mulitple of 16 (this may cause rendering problems
719 * but should avoid a device error).
725 assert(size
% 16 == 0);
726 ret
= SVGA3D_vgpu10_SetSingleConstantBuffer(svga
->swc
,
728 svga_shader_type(shader
),
736 svga
->state
.hw_draw
.enabled_constbufs
[shader
] = enabled_constbufs
;
737 svga
->state
.dirty_constbufs
[shader
] = 0;
742 static enum pipe_error
743 emit_fs_consts(struct svga_context
*svga
, unsigned dirty
)
745 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.fs
;
746 enum pipe_error ret
= PIPE_OK
;
748 /* SVGA_NEW_FS_VARIANT
753 /* SVGA_NEW_FS_CONST_BUFFER
755 if (svga_have_vgpu10(svga
)) {
756 ret
= emit_consts_vgpu10(svga
, PIPE_SHADER_FRAGMENT
);
759 ret
= emit_consts_vgpu9(svga
, PIPE_SHADER_FRAGMENT
);
766 struct svga_tracked_state svga_hw_fs_constants
=
769 (SVGA_NEW_FS_CONST_BUFFER
|
770 SVGA_NEW_FS_VARIANT
|
771 SVGA_NEW_TEXTURE_BINDING
),
777 static enum pipe_error
778 emit_vs_consts(struct svga_context
*svga
, unsigned dirty
)
780 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.vs
;
781 enum pipe_error ret
= PIPE_OK
;
783 /* SVGA_NEW_VS_VARIANT
788 /* SVGA_NEW_VS_CONST_BUFFER
790 if (svga_have_vgpu10(svga
)) {
791 ret
= emit_consts_vgpu10(svga
, PIPE_SHADER_VERTEX
);
794 ret
= emit_consts_vgpu9(svga
, PIPE_SHADER_VERTEX
);
801 struct svga_tracked_state svga_hw_vs_constants
=
805 SVGA_NEW_VS_CONST_BUFFER
|
806 SVGA_NEW_VS_VARIANT
),
811 static enum pipe_error
812 emit_gs_consts(struct svga_context
*svga
, unsigned dirty
)
814 const struct svga_shader_variant
*variant
= svga
->state
.hw_draw
.gs
;
815 enum pipe_error ret
= PIPE_OK
;
817 /* SVGA_NEW_GS_VARIANT
822 /* SVGA_NEW_GS_CONST_BUFFER
824 if (svga_have_vgpu10(svga
)) {
826 * If only the rasterizer state has changed and the current geometry
827 * shader does not emit wide points, then there is no reason to
828 * re-emit the GS constants, so skip it.
830 if (dirty
== SVGA_NEW_RAST
&& !variant
->key
.gs
.wide_point
)
833 ret
= emit_consts_vgpu10(svga
, PIPE_SHADER_GEOMETRY
);
840 struct svga_tracked_state svga_hw_gs_constants
=
843 (SVGA_NEW_GS_CONST_BUFFER
|
845 SVGA_NEW_GS_VARIANT
),