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 **********************************************************/
29 * Command construction utility for the SVGA3D protocol used by
30 * the VMware SVGA device, based on the svgautil library.
33 #include "svga_winsys.h"
34 #include "svga_screen_buffer.h"
35 #include "svga_screen_texture.h"
39 *----------------------------------------------------------------------
41 * surface_to_surfaceid --
43 * Utility function for surface ids.
44 * Can handle null surface. Does a surface_reallocation so you need
45 * to have allocated the fifo space before converting.
51 * One surface relocation is preformed for texture handle.
53 *----------------------------------------------------------------------
57 void surface_to_surfaceid(struct svga_winsys_context
*swc
, // IN
58 struct pipe_surface
*surface
, // IN
59 SVGA3dSurfaceImageId
*id
, // OUT
63 struct svga_surface
*s
= svga_surface(surface
);
64 swc
->surface_relocation(swc
, &id
->sid
, s
->handle
, flags
);
65 id
->face
= s
->real_face
; /* faces have the same order */
66 id
->mipmap
= s
->real_level
;
69 id
->sid
= SVGA3D_INVALID_ID
;
77 *----------------------------------------------------------------------
79 * SVGA3D_FIFOReserve --
81 * Reserve space for an SVGA3D FIFO command.
83 * The 2D SVGA commands have been around for a while, so they
84 * have a rather asymmetric structure. The SVGA3D protocol is
85 * more uniform: each command begins with a header containing the
86 * command number and the full size.
88 * This is a convenience wrapper around SVGA_FIFOReserve. We
89 * reserve space for the whole command, and write the header.
91 * This function must be paired with SVGA_FIFOCommitAll().
94 * Returns a pointer to the space reserved for command-specific
95 * data. It must be 'cmdSize' bytes long.
98 * Begins a FIFO reservation.
100 *----------------------------------------------------------------------
104 SVGA3D_FIFOReserve(struct svga_winsys_context
*swc
,
106 uint32 cmdSize
, // IN
107 uint32 nr_relocs
) // IN
109 SVGA3dCmdHeader
*header
;
111 header
= swc
->reserve(swc
, sizeof *header
+ cmdSize
, nr_relocs
);
116 header
->size
= cmdSize
;
123 SVGA_FIFOCommitAll(struct svga_winsys_context
*swc
)
130 *----------------------------------------------------------------------
132 * SVGA3D_DefineContext --
134 * Create a new context, to be referred to with the provided ID.
136 * Context objects encapsulate all render state, and shader
137 * objects are per-context.
139 * Surfaces are not per-context. The same surface can be shared
140 * between multiple contexts, and surface operations can occur
143 * If the provided context ID already existed, it is redefined.
145 * Context IDs are arbitrary small non-negative integers,
146 * global to the entire SVGA device.
154 *----------------------------------------------------------------------
158 SVGA3D_DefineContext(struct svga_winsys_context
*swc
) // IN
160 SVGA3dCmdDefineContext
*cmd
;
162 cmd
= SVGA3D_FIFOReserve(swc
,
163 SVGA_3D_CMD_CONTEXT_DEFINE
, sizeof *cmd
, 0);
165 return PIPE_ERROR_OUT_OF_MEMORY
;
176 *----------------------------------------------------------------------
178 * SVGA3D_DestroyContext --
180 * Delete a context created with SVGA3D_DefineContext.
188 *----------------------------------------------------------------------
192 SVGA3D_DestroyContext(struct svga_winsys_context
*swc
) // IN
194 SVGA3dCmdDestroyContext
*cmd
;
196 cmd
= SVGA3D_FIFOReserve(swc
,
197 SVGA_3D_CMD_CONTEXT_DESTROY
, sizeof *cmd
, 0);
199 return PIPE_ERROR_OUT_OF_MEMORY
;
210 *----------------------------------------------------------------------
212 * SVGA3D_BeginDefineSurface --
214 * Begin a SURFACE_DEFINE command. This reserves space for it in
215 * the FIFO, and returns pointers to the command's faces and
218 * This function must be paired with SVGA_FIFOCommitAll().
219 * The faces and mipSizes arrays are initialized to zero.
221 * This creates a "surface" object in the SVGA3D device,
222 * with the provided surface ID (sid). Surfaces are generic
223 * containers for host VRAM objects like textures, vertex
224 * buffers, and depth/stencil buffers.
226 * Surfaces are hierarchial:
228 * - Surface may have multiple faces (for cube maps)
230 * - Each face has a list of mipmap levels
232 * - Each mipmap image may have multiple volume
233 * slices, if the image is three dimensional.
235 * - Each slice is a 2D array of 'blocks'
237 * - Each block may be one or more pixels.
238 * (Usually 1, more for DXT or YUV formats.)
240 * Surfaces are generic host VRAM objects. The SVGA3D device
241 * may optimize surfaces according to the format they were
242 * created with, but this format does not limit the ways in
243 * which the surface may be used. For example, a depth surface
244 * can be used as a texture, or a floating point image may
245 * be used as a vertex buffer. Some surface usages may be
246 * lower performance, due to software emulation, but any
247 * usage should work with any surface.
249 * If 'sid' is already defined, the old surface is deleted
250 * and this new surface replaces it.
252 * Surface IDs are arbitrary small non-negative integers,
253 * global to the entire SVGA device.
256 * Returns pointers to arrays allocated in the FIFO for 'faces'
260 * Begins a FIFO reservation.
262 *----------------------------------------------------------------------
266 SVGA3D_BeginDefineSurface(struct svga_winsys_context
*swc
,
267 struct svga_winsys_surface
*sid
, // IN
268 SVGA3dSurfaceFlags flags
, // IN
269 SVGA3dSurfaceFormat format
, // IN
270 SVGA3dSurfaceFace
**faces
, // OUT
271 SVGA3dSize
**mipSizes
, // OUT
272 uint32 numMipSizes
) // IN
274 SVGA3dCmdDefineSurface
*cmd
;
276 cmd
= SVGA3D_FIFOReserve(swc
,
277 SVGA_3D_CMD_SURFACE_DEFINE
, sizeof *cmd
+
278 sizeof **mipSizes
* numMipSizes
, 1);
280 return PIPE_ERROR_OUT_OF_MEMORY
;
282 swc
->surface_relocation(swc
, &cmd
->sid
, sid
, PIPE_BUFFER_USAGE_GPU_WRITE
);
283 cmd
->surfaceFlags
= flags
;
284 cmd
->format
= format
;
286 *faces
= &cmd
->face
[0];
287 *mipSizes
= (SVGA3dSize
*) &cmd
[1];
289 memset(*faces
, 0, sizeof **faces
* SVGA3D_MAX_SURFACE_FACES
);
290 memset(*mipSizes
, 0, sizeof **mipSizes
* numMipSizes
);
297 *----------------------------------------------------------------------
299 * SVGA3D_DefineSurface2D --
301 * This is a simplified version of SVGA3D_BeginDefineSurface(),
302 * which does not support cube maps, mipmaps, or volume textures.
310 *----------------------------------------------------------------------
314 SVGA3D_DefineSurface2D(struct svga_winsys_context
*swc
, // IN
315 struct svga_winsys_surface
*sid
, // IN
318 SVGA3dSurfaceFormat format
) // IN
320 SVGA3dSize
*mipSizes
;
321 SVGA3dSurfaceFace
*faces
;
324 ret
= SVGA3D_BeginDefineSurface(swc
,
325 sid
, 0, format
, &faces
, &mipSizes
, 1);
329 faces
[0].numMipLevels
= 1;
331 mipSizes
[0].width
= width
;
332 mipSizes
[0].height
= height
;
333 mipSizes
[0].depth
= 1;
342 *----------------------------------------------------------------------
344 * SVGA3D_DestroySurface --
346 * Release the host VRAM encapsulated by a particular surface ID.
354 *----------------------------------------------------------------------
358 SVGA3D_DestroySurface(struct svga_winsys_context
*swc
,
359 struct svga_winsys_surface
*sid
) // IN
361 SVGA3dCmdDestroySurface
*cmd
;
363 cmd
= SVGA3D_FIFOReserve(swc
,
364 SVGA_3D_CMD_SURFACE_DESTROY
, sizeof *cmd
, 1);
366 return PIPE_ERROR_OUT_OF_MEMORY
;
368 swc
->surface_relocation(swc
, &cmd
->sid
, sid
, PIPE_BUFFER_USAGE_GPU_READ
);
376 *----------------------------------------------------------------------
378 * SVGA3D_BeginSurfaceDMA--
380 * Begin a SURFACE_DMA command. This reserves space for it in
381 * the FIFO, and returns a pointer to the command's box array.
382 * This function must be paired with SVGA_FIFOCommitAll().
384 * When the SVGA3D device asynchronously processes this FIFO
385 * command, a DMA operation is performed between host VRAM and
386 * a generic SVGAGuestPtr. The guest pointer may refer to guest
387 * VRAM (provided by the SVGA PCI device) or to guest system
388 * memory that has been set up as a Guest Memory Region (GMR)
389 * by the SVGA device.
391 * The guest's DMA buffer must remain valid (not freed, paged out,
392 * or overwritten) until the host has finished processing this
393 * command. The guest can determine that the host has finished
394 * by using the SVGA device's FIFO Fence mechanism.
396 * The guest's image buffer can be an arbitrary size and shape.
397 * Guest image data is interpreted according to the SVGA3D surface
398 * format specified when the surface was defined.
400 * The caller may optionally define the guest image's pitch.
401 * guestImage->pitch can either be zero (assume image is tightly
402 * packed) or it must be the number of bytes between vertically
403 * adjacent image blocks.
405 * The provided copybox list specifies which regions of the source
406 * image are to be copied, and where they appear on the destination.
408 * NOTE: srcx/srcy are always on the guest image and x/y are
409 * always on the host image, regardless of the actual transfer
412 * For efficiency, the SVGA3D device is free to copy more data
413 * than specified. For example, it may round copy boxes outwards
414 * such that they lie on particular alignment boundaries.
416 *----------------------------------------------------------------------
420 SVGA3D_SurfaceDMA(struct svga_winsys_context
*swc
,
421 struct svga_transfer
*st
, // IN
422 SVGA3dTransferType transfer
, // IN
423 const SVGA3dCopyBox
*boxes
, // IN
424 uint32 numBoxes
) // IN
426 struct svga_texture
*texture
= svga_texture(st
->base
.texture
);
427 SVGA3dCmdSurfaceDMA
*cmd
;
428 SVGA3dCmdSurfaceDMASuffix
*pSuffix
;
429 uint32 boxesSize
= sizeof *boxes
* numBoxes
;
430 unsigned region_flags
;
431 unsigned surface_flags
;
433 if(transfer
== SVGA3D_WRITE_HOST_VRAM
) {
434 region_flags
= PIPE_BUFFER_USAGE_GPU_READ
;
435 surface_flags
= PIPE_BUFFER_USAGE_GPU_WRITE
;
437 else if(transfer
== SVGA3D_READ_HOST_VRAM
) {
438 region_flags
= PIPE_BUFFER_USAGE_GPU_WRITE
;
439 surface_flags
= PIPE_BUFFER_USAGE_GPU_READ
;
443 return PIPE_ERROR_BAD_INPUT
;
446 cmd
= SVGA3D_FIFOReserve(swc
,
447 SVGA_3D_CMD_SURFACE_DMA
,
448 sizeof *cmd
+ boxesSize
+ sizeof *pSuffix
,
451 return PIPE_ERROR_OUT_OF_MEMORY
;
453 swc
->region_relocation(swc
, &cmd
->guest
.ptr
, st
->hwbuf
, 0, region_flags
);
454 cmd
->guest
.pitch
= st
->base
.stride
;
456 swc
->surface_relocation(swc
, &cmd
->host
.sid
, texture
->handle
, surface_flags
);
457 cmd
->host
.face
= st
->base
.face
; /* PIPE_TEX_FACE_* and SVGA3D_CUBEFACE_* match */
458 cmd
->host
.mipmap
= st
->base
.level
;
460 cmd
->transfer
= transfer
;
462 memcpy(&cmd
[1], boxes
, boxesSize
);
464 pSuffix
= (SVGA3dCmdSurfaceDMASuffix
*)((uint8_t*)cmd
+ sizeof *cmd
+ boxesSize
);
465 pSuffix
->suffixSize
= sizeof *pSuffix
;
466 pSuffix
->maximumOffset
= st
->hw_nblocksy
*st
->base
.stride
;
467 memset(&pSuffix
->flags
, 0, sizeof pSuffix
->flags
);
476 SVGA3D_BufferDMA(struct svga_winsys_context
*swc
,
477 struct svga_winsys_buffer
*guest
,
478 struct svga_winsys_surface
*host
,
479 SVGA3dTransferType transfer
, // IN
482 SVGA3dSurfaceDMAFlags flags
) // IN
484 SVGA3dCmdSurfaceDMA
*cmd
;
486 SVGA3dCmdSurfaceDMASuffix
*pSuffix
;
487 unsigned region_flags
;
488 unsigned surface_flags
;
490 if(transfer
== SVGA3D_WRITE_HOST_VRAM
) {
491 region_flags
= PIPE_BUFFER_USAGE_GPU_READ
;
492 surface_flags
= PIPE_BUFFER_USAGE_GPU_WRITE
;
494 else if(transfer
== SVGA3D_READ_HOST_VRAM
) {
495 region_flags
= PIPE_BUFFER_USAGE_GPU_WRITE
;
496 surface_flags
= PIPE_BUFFER_USAGE_GPU_READ
;
500 return PIPE_ERROR_BAD_INPUT
;
503 cmd
= SVGA3D_FIFOReserve(swc
,
504 SVGA_3D_CMD_SURFACE_DMA
,
505 sizeof *cmd
+ sizeof *box
+ sizeof *pSuffix
,
508 return PIPE_ERROR_OUT_OF_MEMORY
;
510 swc
->region_relocation(swc
, &cmd
->guest
.ptr
, guest
, 0, region_flags
);
511 cmd
->guest
.pitch
= 0;
513 swc
->surface_relocation(swc
, &cmd
->host
.sid
, host
, surface_flags
);
515 cmd
->host
.mipmap
= 0;
517 cmd
->transfer
= transfer
;
519 box
= (SVGA3dCopyBox
*)&cmd
[1];
530 pSuffix
= (SVGA3dCmdSurfaceDMASuffix
*)((uint8_t*)cmd
+ sizeof *cmd
+ sizeof *box
);
531 pSuffix
->suffixSize
= sizeof *pSuffix
;
532 pSuffix
->maximumOffset
= offset
+ size
;
533 pSuffix
->flags
= flags
;
542 *----------------------------------------------------------------------
544 * SVGA3D_SetRenderTarget --
546 * Bind a surface object to a particular render target attachment
547 * point on the current context. Render target attachment points
548 * exist for color buffers, a depth buffer, and a stencil buffer.
550 * The SVGA3D device is quite lenient about the types of surfaces
551 * that may be used as render targets. The color buffers must
552 * all be the same size, but the depth and stencil buffers do not
553 * have to be the same size as the color buffer. All attachments
556 * Some combinations of render target formats may require software
557 * emulation, depending on the capabilities of the host graphics
558 * API and graphics hardware.
566 *----------------------------------------------------------------------
570 SVGA3D_SetRenderTarget(struct svga_winsys_context
*swc
,
571 SVGA3dRenderTargetType type
, // IN
572 struct pipe_surface
*surface
) // IN
574 SVGA3dCmdSetRenderTarget
*cmd
;
576 cmd
= SVGA3D_FIFOReserve(swc
,
577 SVGA_3D_CMD_SETRENDERTARGET
, sizeof *cmd
, 1);
579 return PIPE_ERROR_OUT_OF_MEMORY
;
586 surface_to_surfaceid(swc
, surface
, &cmd
->target
, PIPE_BUFFER_USAGE_GPU_WRITE
);
599 *----------------------------------------------------------------------
601 * SVGA3D_DefineShader --
603 * Upload the bytecode for a new shader. The bytecode is "SVGA3D
604 * format", which is theoretically a binary-compatible superset
605 * of Microsoft's DirectX shader bytecode. In practice, the
606 * SVGA3D bytecode doesn't yet have any extensions to DirectX's
609 * The SVGA3D device supports shader models 1.1 through 2.0.
611 * The caller chooses a shader ID (small positive integer) by
612 * which this shader will be identified in future commands. This
613 * ID is in a namespace which is per-context and per-shader-type.
615 * 'bytecodeLen' is specified in bytes. It must be a multiple of 4.
623 *----------------------------------------------------------------------
627 SVGA3D_DefineShader(struct svga_winsys_context
*swc
,
629 SVGA3dShaderType type
, // IN
630 const uint32
*bytecode
, // IN
631 uint32 bytecodeLen
) // IN
633 SVGA3dCmdDefineShader
*cmd
;
635 assert(bytecodeLen
% 4 == 0);
637 cmd
= SVGA3D_FIFOReserve(swc
,
638 SVGA_3D_CMD_SHADER_DEFINE
, sizeof *cmd
+ bytecodeLen
,
641 return PIPE_ERROR_OUT_OF_MEMORY
;
646 memcpy(&cmd
[1], bytecode
, bytecodeLen
);
654 *----------------------------------------------------------------------
656 * SVGA3D_DestroyShader --
658 * Delete a shader that was created by SVGA3D_DefineShader. If
659 * the shader was the current vertex or pixel shader for its
660 * context, rendering results are undefined until a new shader is
669 *----------------------------------------------------------------------
673 SVGA3D_DestroyShader(struct svga_winsys_context
*swc
,
675 SVGA3dShaderType type
) // IN
677 SVGA3dCmdDestroyShader
*cmd
;
679 cmd
= SVGA3D_FIFOReserve(swc
,
680 SVGA_3D_CMD_SHADER_DESTROY
, sizeof *cmd
,
683 return PIPE_ERROR_OUT_OF_MEMORY
;
695 *----------------------------------------------------------------------
697 * SVGA3D_SetShaderConst --
699 * Set the value of a shader constant.
701 * Shader constants are analogous to uniform variables in GLSL,
702 * except that they belong to the render context rather than to
703 * an individual shader.
705 * Constants may have one of three types: A 4-vector of floats,
706 * a 4-vector of integers, or a single boolean flag.
714 *----------------------------------------------------------------------
718 SVGA3D_SetShaderConst(struct svga_winsys_context
*swc
,
720 SVGA3dShaderType type
, // IN
721 SVGA3dShaderConstType ctype
, // IN
722 const void *value
) // IN
724 SVGA3dCmdSetShaderConst
*cmd
;
726 cmd
= SVGA3D_FIFOReserve(swc
,
727 SVGA_3D_CMD_SET_SHADER_CONST
, sizeof *cmd
,
730 return PIPE_ERROR_OUT_OF_MEMORY
;
739 case SVGA3D_CONST_TYPE_FLOAT
:
740 case SVGA3D_CONST_TYPE_INT
:
741 memcpy(&cmd
->values
, value
, sizeof cmd
->values
);
744 case SVGA3D_CONST_TYPE_BOOL
:
745 memset(&cmd
->values
, 0, sizeof cmd
->values
);
746 cmd
->values
[0] = *(uint32
*)value
;
764 *----------------------------------------------------------------------
766 * SVGA3D_SetShader --
768 * Switch active shaders. This binds a new vertex or pixel shader
769 * to the specified context.
771 * A shader ID of SVGA3D_INVALID_ID unbinds any shader, switching
772 * back to the fixed function vertex or pixel pipeline.
780 *----------------------------------------------------------------------
784 SVGA3D_SetShader(struct svga_winsys_context
*swc
,
785 SVGA3dShaderType type
, // IN
788 SVGA3dCmdSetShader
*cmd
;
790 cmd
= SVGA3D_FIFOReserve(swc
,
791 SVGA_3D_CMD_SET_SHADER
, sizeof *cmd
,
794 return PIPE_ERROR_OUT_OF_MEMORY
;
806 *----------------------------------------------------------------------
808 * SVGA3D_BeginClear --
810 * Begin a CLEAR command. This reserves space for it in the FIFO,
811 * and returns a pointer to the command's rectangle array. This
812 * function must be paired with SVGA_FIFOCommitAll().
814 * Clear is a rendering operation which fills a list of
815 * rectangles with constant values on all render target types
816 * indicated by 'flags'.
818 * Clear is not affected by clipping, depth test, or other
819 * render state which affects the fragment pipeline.
825 * May write to attached render target surfaces.
827 *----------------------------------------------------------------------
831 SVGA3D_BeginClear(struct svga_winsys_context
*swc
,
832 SVGA3dClearFlag flags
, // IN
835 uint32 stencil
, // IN
836 SVGA3dRect
**rects
, // OUT
837 uint32 numRects
) // IN
841 cmd
= SVGA3D_FIFOReserve(swc
,
843 sizeof *cmd
+ sizeof **rects
* numRects
,
846 return PIPE_ERROR_OUT_OF_MEMORY
;
849 cmd
->clearFlag
= flags
;
852 cmd
->stencil
= stencil
;
853 *rects
= (SVGA3dRect
*) &cmd
[1];
860 *----------------------------------------------------------------------
862 * SVGA3D_ClearRect --
864 * This is a simplified version of SVGA3D_BeginClear().
872 *----------------------------------------------------------------------
876 SVGA3D_ClearRect(struct svga_winsys_context
*swc
,
877 SVGA3dClearFlag flags
, // IN
880 uint32 stencil
, // IN
889 ret
= SVGA3D_BeginClear(swc
, flags
, color
, depth
, stencil
, &rect
, 1);
891 return PIPE_ERROR_OUT_OF_MEMORY
;
893 memset(rect
, 0, sizeof *rect
);
905 *----------------------------------------------------------------------
907 * SVGA3D_BeginDrawPrimitives --
909 * Begin a DRAW_PRIMITIVES command. This reserves space for it in
910 * the FIFO, and returns a pointer to the command's arrays.
911 * This function must be paired with SVGA_FIFOCommitAll().
913 * Drawing commands consist of two variable-length arrays:
914 * SVGA3dVertexDecl elements declare a set of vertex buffers to
915 * use while rendering, and SVGA3dPrimitiveRange elements specify
916 * groups of primitives each with an optional index buffer.
918 * The decls and ranges arrays are initialized to zero.
924 * May write to attached render target surfaces.
926 *----------------------------------------------------------------------
930 SVGA3D_BeginDrawPrimitives(struct svga_winsys_context
*swc
,
931 SVGA3dVertexDecl
**decls
, // OUT
932 uint32 numVertexDecls
, // IN
933 SVGA3dPrimitiveRange
**ranges
, // OUT
934 uint32 numRanges
) // IN
936 SVGA3dCmdDrawPrimitives
*cmd
;
937 SVGA3dVertexDecl
*declArray
;
938 SVGA3dPrimitiveRange
*rangeArray
;
939 uint32 declSize
= sizeof **decls
* numVertexDecls
;
940 uint32 rangeSize
= sizeof **ranges
* numRanges
;
942 cmd
= SVGA3D_FIFOReserve(swc
,
943 SVGA_3D_CMD_DRAW_PRIMITIVES
,
944 sizeof *cmd
+ declSize
+ rangeSize
,
945 numVertexDecls
+ numRanges
);
947 return PIPE_ERROR_OUT_OF_MEMORY
;
950 cmd
->numVertexDecls
= numVertexDecls
;
951 cmd
->numRanges
= numRanges
;
953 declArray
= (SVGA3dVertexDecl
*) &cmd
[1];
954 rangeArray
= (SVGA3dPrimitiveRange
*) &declArray
[numVertexDecls
];
956 memset(declArray
, 0, declSize
);
957 memset(rangeArray
, 0, rangeSize
);
960 *ranges
= rangeArray
;
967 *----------------------------------------------------------------------
969 * SVGA3D_BeginSurfaceCopy --
971 * Begin a SURFACE_COPY command. This reserves space for it in
972 * the FIFO, and returns a pointer to the command's arrays. This
973 * function must be paired with SVGA_FIFOCommitAll().
975 * The box array is initialized with zeroes.
981 * Asynchronously copies a list of boxes from surface to surface.
983 *----------------------------------------------------------------------
987 SVGA3D_BeginSurfaceCopy(struct svga_winsys_context
*swc
,
988 struct pipe_surface
*src
, // IN
989 struct pipe_surface
*dest
, // IN
990 SVGA3dCopyBox
**boxes
, // OUT
991 uint32 numBoxes
) // IN
993 SVGA3dCmdSurfaceCopy
*cmd
;
994 uint32 boxesSize
= sizeof **boxes
* numBoxes
;
996 cmd
= SVGA3D_FIFOReserve(swc
,
997 SVGA_3D_CMD_SURFACE_COPY
, sizeof *cmd
+ boxesSize
,
1000 return PIPE_ERROR_OUT_OF_MEMORY
;
1002 surface_to_surfaceid(swc
, src
, &cmd
->src
, PIPE_BUFFER_USAGE_GPU_READ
);
1003 surface_to_surfaceid(swc
, dest
, &cmd
->dest
, PIPE_BUFFER_USAGE_GPU_WRITE
);
1004 *boxes
= (SVGA3dCopyBox
*) &cmd
[1];
1006 memset(*boxes
, 0, boxesSize
);
1013 *----------------------------------------------------------------------
1015 * SVGA3D_SurfaceStretchBlt --
1017 * Issue a SURFACE_STRETCHBLT command: an asynchronous
1018 * surface-to-surface blit, with scaling.
1024 * Asynchronously copies one box from surface to surface.
1026 *----------------------------------------------------------------------
1030 SVGA3D_SurfaceStretchBlt(struct svga_winsys_context
*swc
,
1031 struct pipe_surface
*src
, // IN
1032 struct pipe_surface
*dest
, // IN
1033 SVGA3dBox
*boxSrc
, // IN
1034 SVGA3dBox
*boxDest
, // IN
1035 SVGA3dStretchBltMode mode
) // IN
1037 SVGA3dCmdSurfaceStretchBlt
*cmd
;
1039 cmd
= SVGA3D_FIFOReserve(swc
,
1040 SVGA_3D_CMD_SURFACE_STRETCHBLT
, sizeof *cmd
,
1043 return PIPE_ERROR_OUT_OF_MEMORY
;
1045 surface_to_surfaceid(swc
, src
, &cmd
->src
, PIPE_BUFFER_USAGE_GPU_READ
);
1046 surface_to_surfaceid(swc
, dest
, &cmd
->dest
, PIPE_BUFFER_USAGE_GPU_WRITE
);
1047 cmd
->boxSrc
= *boxSrc
;
1048 cmd
->boxDest
= *boxDest
;
1057 *----------------------------------------------------------------------
1059 * SVGA3D_SetViewport --
1061 * Set the current context's viewport rectangle. The viewport
1062 * is clipped to the dimensions of the current render target,
1063 * then all rendering is clipped to the viewport.
1071 *----------------------------------------------------------------------
1075 SVGA3D_SetViewport(struct svga_winsys_context
*swc
,
1076 SVGA3dRect
*rect
) // IN
1078 SVGA3dCmdSetViewport
*cmd
;
1080 cmd
= SVGA3D_FIFOReserve(swc
,
1081 SVGA_3D_CMD_SETVIEWPORT
, sizeof *cmd
,
1084 return PIPE_ERROR_OUT_OF_MEMORY
;
1086 cmd
->cid
= swc
->cid
;
1097 *----------------------------------------------------------------------
1099 * SVGA3D_SetScissorRect --
1101 * Set the current context's scissor rectangle. If scissor
1102 * is enabled then all rendering is clipped to the scissor.
1110 *----------------------------------------------------------------------
1114 SVGA3D_SetScissorRect(struct svga_winsys_context
*swc
,
1115 SVGA3dRect
*rect
) // IN
1117 SVGA3dCmdSetScissorRect
*cmd
;
1119 cmd
= SVGA3D_FIFOReserve(swc
,
1120 SVGA_3D_CMD_SETSCISSORRECT
, sizeof *cmd
,
1123 return PIPE_ERROR_OUT_OF_MEMORY
;
1125 cmd
->cid
= swc
->cid
;
1133 *----------------------------------------------------------------------
1135 * SVGA3D_SetClipPlane --
1137 * Set one of the current context's clip planes. If the clip
1138 * plane is enabled then all 3d rendering is clipped to against
1147 *----------------------------------------------------------------------
1150 enum pipe_error
SVGA3D_SetClipPlane(struct svga_winsys_context
*swc
,
1151 uint32 index
, const float *plane
)
1153 SVGA3dCmdSetClipPlane
*cmd
;
1155 cmd
= SVGA3D_FIFOReserve(swc
,
1156 SVGA_3D_CMD_SETCLIPPLANE
, sizeof *cmd
,
1159 return PIPE_ERROR_OUT_OF_MEMORY
;
1161 cmd
->cid
= swc
->cid
;
1163 cmd
->plane
[0] = plane
[0];
1164 cmd
->plane
[1] = plane
[1];
1165 cmd
->plane
[2] = plane
[2];
1166 cmd
->plane
[3] = plane
[3];
1173 *----------------------------------------------------------------------
1175 * SVGA3D_SetZRange --
1177 * Set the range of the depth buffer to use. 'min' and 'max'
1178 * are values between 0.0 and 1.0.
1186 *----------------------------------------------------------------------
1190 SVGA3D_SetZRange(struct svga_winsys_context
*swc
,
1194 SVGA3dCmdSetZRange
*cmd
;
1196 cmd
= SVGA3D_FIFOReserve(swc
,
1197 SVGA_3D_CMD_SETZRANGE
, sizeof *cmd
,
1200 return PIPE_ERROR_OUT_OF_MEMORY
;
1202 cmd
->cid
= swc
->cid
;
1203 cmd
->zRange
.min
= zMin
;
1204 cmd
->zRange
.max
= zMax
;
1212 *----------------------------------------------------------------------
1214 * SVGA3D_BeginSetTextureState --
1216 * Begin a SETTEXTURESTATE command. This reserves space for it in
1217 * the FIFO, and returns a pointer to the command's texture state
1218 * array. This function must be paired with SVGA_FIFOCommitAll().
1220 * This command sets rendering state which is per-texture-unit.
1222 * XXX: Individual texture states need documentation. However,
1223 * they are very similar to the texture states defined by
1224 * Direct3D. The D3D documentation is a good starting point
1225 * for understanding SVGA3D texture states.
1233 *----------------------------------------------------------------------
1237 SVGA3D_BeginSetTextureState(struct svga_winsys_context
*swc
,
1238 SVGA3dTextureState
**states
, // OUT
1239 uint32 numStates
) // IN
1241 SVGA3dCmdSetTextureState
*cmd
;
1243 cmd
= SVGA3D_FIFOReserve(swc
,
1244 SVGA_3D_CMD_SETTEXTURESTATE
,
1245 sizeof *cmd
+ sizeof **states
* numStates
,
1248 return PIPE_ERROR_OUT_OF_MEMORY
;
1250 cmd
->cid
= swc
->cid
;
1251 *states
= (SVGA3dTextureState
*) &cmd
[1];
1258 *----------------------------------------------------------------------
1260 * SVGA3D_BeginSetRenderState --
1262 * Begin a SETRENDERSTATE command. This reserves space for it in
1263 * the FIFO, and returns a pointer to the command's texture state
1264 * array. This function must be paired with SVGA_FIFOCommitAll().
1266 * This command sets rendering state which is global to the context.
1268 * XXX: Individual render states need documentation. However,
1269 * they are very similar to the render states defined by
1270 * Direct3D. The D3D documentation is a good starting point
1271 * for understanding SVGA3D render states.
1279 *----------------------------------------------------------------------
1283 SVGA3D_BeginSetRenderState(struct svga_winsys_context
*swc
,
1284 SVGA3dRenderState
**states
, // OUT
1285 uint32 numStates
) // IN
1287 SVGA3dCmdSetRenderState
*cmd
;
1289 cmd
= SVGA3D_FIFOReserve(swc
,
1290 SVGA_3D_CMD_SETRENDERSTATE
,
1291 sizeof *cmd
+ sizeof **states
* numStates
,
1294 return PIPE_ERROR_OUT_OF_MEMORY
;
1296 cmd
->cid
= swc
->cid
;
1297 *states
= (SVGA3dRenderState
*) &cmd
[1];
1304 *----------------------------------------------------------------------
1306 * SVGA3D_BeginQuery--
1308 * Issues a SVGA_3D_CMD_BEGIN_QUERY command.
1314 * Commits space in the FIFO memory.
1316 *----------------------------------------------------------------------
1320 SVGA3D_BeginQuery(struct svga_winsys_context
*swc
,
1321 SVGA3dQueryType type
) // IN
1323 SVGA3dCmdBeginQuery
*cmd
;
1325 cmd
= SVGA3D_FIFOReserve(swc
,
1326 SVGA_3D_CMD_BEGIN_QUERY
,
1330 return PIPE_ERROR_OUT_OF_MEMORY
;
1332 cmd
->cid
= swc
->cid
;
1342 *----------------------------------------------------------------------
1346 * Issues a SVGA_3D_CMD_END_QUERY command.
1352 * Commits space in the FIFO memory.
1354 *----------------------------------------------------------------------
1358 SVGA3D_EndQuery(struct svga_winsys_context
*swc
,
1359 SVGA3dQueryType type
, // IN
1360 struct svga_winsys_buffer
*buffer
) // IN/OUT
1362 SVGA3dCmdEndQuery
*cmd
;
1364 cmd
= SVGA3D_FIFOReserve(swc
,
1365 SVGA_3D_CMD_END_QUERY
,
1369 return PIPE_ERROR_OUT_OF_MEMORY
;
1371 cmd
->cid
= swc
->cid
;
1374 swc
->region_relocation(swc
, &cmd
->guestResult
, buffer
, 0,
1375 PIPE_BUFFER_USAGE_GPU_WRITE
);
1384 *----------------------------------------------------------------------
1386 * SVGA3D_WaitForQuery--
1388 * Issues a SVGA_3D_CMD_WAIT_FOR_QUERY command. This reserves space
1389 * for it in the FIFO. This doesn't actually wait for the query to
1390 * finish but instead tells the host to start a wait at the driver
1391 * level. The caller can wait on the status variable in the
1392 * guestPtr memory or send an insert fence instruction after this
1393 * command and wait on the fence.
1399 * Commits space in the FIFO memory.
1401 *----------------------------------------------------------------------
1405 SVGA3D_WaitForQuery(struct svga_winsys_context
*swc
,
1406 SVGA3dQueryType type
, // IN
1407 struct svga_winsys_buffer
*buffer
) // IN/OUT
1409 SVGA3dCmdWaitForQuery
*cmd
;
1411 cmd
= SVGA3D_FIFOReserve(swc
,
1412 SVGA_3D_CMD_WAIT_FOR_QUERY
,
1416 return PIPE_ERROR_OUT_OF_MEMORY
;
1418 cmd
->cid
= swc
->cid
;
1421 swc
->region_relocation(swc
, &cmd
->guestResult
, buffer
, 0,
1422 PIPE_BUFFER_USAGE_GPU_WRITE
);