Commit | Line | Data |
---|---|---|
8ce75f8a SY |
1 | /********************************************************** |
2 | * Copyright 1998-2015 VMware, Inc. All rights reserved. | |
3 | * | |
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: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be | |
13 | * included in all copies or substantial portions of the Software. | |
14 | * | |
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 | |
22 | * SOFTWARE. | |
23 | * | |
24 | **********************************************************/ | |
25 | ||
26 | /* | |
27 | * svga3d_cmd.h -- | |
28 | * | |
29 | * SVGA 3d hardware cmd definitions | |
30 | */ | |
31 | ||
32 | #ifndef _SVGA3D_CMD_H_ | |
33 | #define _SVGA3D_CMD_H_ | |
34 | ||
35 | #define INCLUDE_ALLOW_MODULE | |
36 | #define INCLUDE_ALLOW_USERLEVEL | |
37 | #define INCLUDE_ALLOW_VMCORE | |
38 | ||
39 | #include "includeCheck.h" | |
40 | #include "svga3d_types.h" | |
41 | ||
42 | /* | |
43 | * Identifiers for commands in the command FIFO. | |
44 | * | |
45 | * IDs between 1000 and 1039 (inclusive) were used by obsolete versions of | |
46 | * the SVGA3D protocol and remain reserved; they should not be used in the | |
47 | * future. | |
48 | * | |
49 | * IDs between 1040 and 1999 (inclusive) are available for use by the | |
50 | * current SVGA3D protocol. | |
51 | * | |
52 | * FIFO clients other than SVGA3D should stay below 1000, or at 2000 | |
53 | * and up. | |
54 | */ | |
55 | ||
56 | typedef enum { | |
57 | SVGA_3D_CMD_LEGACY_BASE = 1000, | |
58 | SVGA_3D_CMD_BASE = 1040, | |
59 | ||
60 | SVGA_3D_CMD_SURFACE_DEFINE = 1040, | |
61 | SVGA_3D_CMD_SURFACE_DESTROY = 1041, | |
62 | SVGA_3D_CMD_SURFACE_COPY = 1042, | |
63 | SVGA_3D_CMD_SURFACE_STRETCHBLT = 1043, | |
64 | SVGA_3D_CMD_SURFACE_DMA = 1044, | |
65 | SVGA_3D_CMD_CONTEXT_DEFINE = 1045, | |
66 | SVGA_3D_CMD_CONTEXT_DESTROY = 1046, | |
67 | SVGA_3D_CMD_SETTRANSFORM = 1047, | |
68 | SVGA_3D_CMD_SETZRANGE = 1048, | |
69 | SVGA_3D_CMD_SETRENDERSTATE = 1049, | |
70 | SVGA_3D_CMD_SETRENDERTARGET = 1050, | |
71 | SVGA_3D_CMD_SETTEXTURESTATE = 1051, | |
72 | SVGA_3D_CMD_SETMATERIAL = 1052, | |
73 | SVGA_3D_CMD_SETLIGHTDATA = 1053, | |
74 | SVGA_3D_CMD_SETLIGHTENABLED = 1054, | |
75 | SVGA_3D_CMD_SETVIEWPORT = 1055, | |
76 | SVGA_3D_CMD_SETCLIPPLANE = 1056, | |
77 | SVGA_3D_CMD_CLEAR = 1057, | |
78 | SVGA_3D_CMD_PRESENT = 1058, | |
79 | SVGA_3D_CMD_SHADER_DEFINE = 1059, | |
80 | SVGA_3D_CMD_SHADER_DESTROY = 1060, | |
81 | SVGA_3D_CMD_SET_SHADER = 1061, | |
82 | SVGA_3D_CMD_SET_SHADER_CONST = 1062, | |
83 | SVGA_3D_CMD_DRAW_PRIMITIVES = 1063, | |
84 | SVGA_3D_CMD_SETSCISSORRECT = 1064, | |
85 | SVGA_3D_CMD_BEGIN_QUERY = 1065, | |
86 | SVGA_3D_CMD_END_QUERY = 1066, | |
87 | SVGA_3D_CMD_WAIT_FOR_QUERY = 1067, | |
88 | SVGA_3D_CMD_PRESENT_READBACK = 1068, | |
89 | SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN = 1069, | |
90 | SVGA_3D_CMD_SURFACE_DEFINE_V2 = 1070, | |
91 | SVGA_3D_CMD_GENERATE_MIPMAPS = 1071, | |
92 | SVGA_3D_CMD_VIDEO_CREATE_DECODER = 1072, | |
93 | SVGA_3D_CMD_VIDEO_DESTROY_DECODER = 1073, | |
94 | SVGA_3D_CMD_VIDEO_CREATE_PROCESSOR = 1074, | |
95 | SVGA_3D_CMD_VIDEO_DESTROY_PROCESSOR = 1075, | |
96 | SVGA_3D_CMD_VIDEO_DECODE_START_FRAME = 1076, | |
97 | SVGA_3D_CMD_VIDEO_DECODE_RENDER = 1077, | |
98 | SVGA_3D_CMD_VIDEO_DECODE_END_FRAME = 1078, | |
99 | SVGA_3D_CMD_VIDEO_PROCESS_FRAME = 1079, | |
100 | SVGA_3D_CMD_ACTIVATE_SURFACE = 1080, | |
101 | SVGA_3D_CMD_DEACTIVATE_SURFACE = 1081, | |
102 | SVGA_3D_CMD_SCREEN_DMA = 1082, | |
103 | SVGA_3D_CMD_SET_UNITY_SURFACE_COOKIE = 1083, | |
104 | SVGA_3D_CMD_OPEN_CONTEXT_SURFACE = 1084, | |
105 | ||
106 | SVGA_3D_CMD_LOGICOPS_BITBLT = 1085, | |
107 | SVGA_3D_CMD_LOGICOPS_TRANSBLT = 1086, | |
108 | SVGA_3D_CMD_LOGICOPS_STRETCHBLT = 1087, | |
109 | SVGA_3D_CMD_LOGICOPS_COLORFILL = 1088, | |
110 | SVGA_3D_CMD_LOGICOPS_ALPHABLEND = 1089, | |
111 | SVGA_3D_CMD_LOGICOPS_CLEARTYPEBLEND = 1090, | |
112 | ||
113 | SVGA_3D_CMD_SET_OTABLE_BASE = 1091, | |
114 | SVGA_3D_CMD_READBACK_OTABLE = 1092, | |
115 | ||
116 | SVGA_3D_CMD_DEFINE_GB_MOB = 1093, | |
117 | SVGA_3D_CMD_DESTROY_GB_MOB = 1094, | |
118 | SVGA_3D_CMD_DEAD3 = 1095, | |
119 | SVGA_3D_CMD_UPDATE_GB_MOB_MAPPING = 1096, | |
120 | ||
121 | SVGA_3D_CMD_DEFINE_GB_SURFACE = 1097, | |
122 | SVGA_3D_CMD_DESTROY_GB_SURFACE = 1098, | |
123 | SVGA_3D_CMD_BIND_GB_SURFACE = 1099, | |
124 | SVGA_3D_CMD_COND_BIND_GB_SURFACE = 1100, | |
125 | SVGA_3D_CMD_UPDATE_GB_IMAGE = 1101, | |
126 | SVGA_3D_CMD_UPDATE_GB_SURFACE = 1102, | |
127 | SVGA_3D_CMD_READBACK_GB_IMAGE = 1103, | |
128 | SVGA_3D_CMD_READBACK_GB_SURFACE = 1104, | |
129 | SVGA_3D_CMD_INVALIDATE_GB_IMAGE = 1105, | |
130 | SVGA_3D_CMD_INVALIDATE_GB_SURFACE = 1106, | |
131 | ||
132 | SVGA_3D_CMD_DEFINE_GB_CONTEXT = 1107, | |
133 | SVGA_3D_CMD_DESTROY_GB_CONTEXT = 1108, | |
134 | SVGA_3D_CMD_BIND_GB_CONTEXT = 1109, | |
135 | SVGA_3D_CMD_READBACK_GB_CONTEXT = 1110, | |
136 | SVGA_3D_CMD_INVALIDATE_GB_CONTEXT = 1111, | |
137 | ||
138 | SVGA_3D_CMD_DEFINE_GB_SHADER = 1112, | |
139 | SVGA_3D_CMD_DESTROY_GB_SHADER = 1113, | |
140 | SVGA_3D_CMD_BIND_GB_SHADER = 1114, | |
141 | ||
142 | SVGA_3D_CMD_SET_OTABLE_BASE64 = 1115, | |
143 | ||
144 | SVGA_3D_CMD_BEGIN_GB_QUERY = 1116, | |
145 | SVGA_3D_CMD_END_GB_QUERY = 1117, | |
146 | SVGA_3D_CMD_WAIT_FOR_GB_QUERY = 1118, | |
147 | ||
148 | SVGA_3D_CMD_NOP = 1119, | |
149 | ||
150 | SVGA_3D_CMD_ENABLE_GART = 1120, | |
151 | SVGA_3D_CMD_DISABLE_GART = 1121, | |
152 | SVGA_3D_CMD_MAP_MOB_INTO_GART = 1122, | |
153 | SVGA_3D_CMD_UNMAP_GART_RANGE = 1123, | |
154 | ||
155 | SVGA_3D_CMD_DEFINE_GB_SCREENTARGET = 1124, | |
156 | SVGA_3D_CMD_DESTROY_GB_SCREENTARGET = 1125, | |
157 | SVGA_3D_CMD_BIND_GB_SCREENTARGET = 1126, | |
158 | SVGA_3D_CMD_UPDATE_GB_SCREENTARGET = 1127, | |
159 | ||
160 | SVGA_3D_CMD_READBACK_GB_IMAGE_PARTIAL = 1128, | |
161 | SVGA_3D_CMD_INVALIDATE_GB_IMAGE_PARTIAL = 1129, | |
162 | ||
163 | SVGA_3D_CMD_SET_GB_SHADERCONSTS_INLINE = 1130, | |
164 | ||
165 | SVGA_3D_CMD_GB_SCREEN_DMA = 1131, | |
166 | SVGA_3D_CMD_BIND_GB_SURFACE_WITH_PITCH = 1132, | |
167 | SVGA_3D_CMD_GB_MOB_FENCE = 1133, | |
168 | SVGA_3D_CMD_DEFINE_GB_SURFACE_V2 = 1134, | |
169 | SVGA_3D_CMD_DEFINE_GB_MOB64 = 1135, | |
170 | SVGA_3D_CMD_REDEFINE_GB_MOB64 = 1136, | |
171 | SVGA_3D_CMD_NOP_ERROR = 1137, | |
172 | ||
173 | SVGA_3D_CMD_SET_VERTEX_STREAMS = 1138, | |
174 | SVGA_3D_CMD_SET_VERTEX_DECLS = 1139, | |
175 | SVGA_3D_CMD_SET_VERTEX_DIVISORS = 1140, | |
176 | SVGA_3D_CMD_DRAW = 1141, | |
177 | SVGA_3D_CMD_DRAW_INDEXED = 1142, | |
178 | ||
179 | /* | |
180 | * DX10 Commands | |
181 | */ | |
182 | SVGA_3D_CMD_DX_MIN = 1143, | |
183 | SVGA_3D_CMD_DX_DEFINE_CONTEXT = 1143, | |
184 | SVGA_3D_CMD_DX_DESTROY_CONTEXT = 1144, | |
185 | SVGA_3D_CMD_DX_BIND_CONTEXT = 1145, | |
186 | SVGA_3D_CMD_DX_READBACK_CONTEXT = 1146, | |
187 | SVGA_3D_CMD_DX_INVALIDATE_CONTEXT = 1147, | |
188 | SVGA_3D_CMD_DX_SET_SINGLE_CONSTANT_BUFFER = 1148, | |
189 | SVGA_3D_CMD_DX_SET_SHADER_RESOURCES = 1149, | |
190 | SVGA_3D_CMD_DX_SET_SHADER = 1150, | |
191 | SVGA_3D_CMD_DX_SET_SAMPLERS = 1151, | |
192 | SVGA_3D_CMD_DX_DRAW = 1152, | |
193 | SVGA_3D_CMD_DX_DRAW_INDEXED = 1153, | |
194 | SVGA_3D_CMD_DX_DRAW_INSTANCED = 1154, | |
195 | SVGA_3D_CMD_DX_DRAW_INDEXED_INSTANCED = 1155, | |
196 | SVGA_3D_CMD_DX_DRAW_AUTO = 1156, | |
197 | SVGA_3D_CMD_DX_SET_INPUT_LAYOUT = 1157, | |
198 | SVGA_3D_CMD_DX_SET_VERTEX_BUFFERS = 1158, | |
199 | SVGA_3D_CMD_DX_SET_INDEX_BUFFER = 1159, | |
200 | SVGA_3D_CMD_DX_SET_TOPOLOGY = 1160, | |
201 | SVGA_3D_CMD_DX_SET_RENDERTARGETS = 1161, | |
202 | SVGA_3D_CMD_DX_SET_BLEND_STATE = 1162, | |
203 | SVGA_3D_CMD_DX_SET_DEPTHSTENCIL_STATE = 1163, | |
204 | SVGA_3D_CMD_DX_SET_RASTERIZER_STATE = 1164, | |
205 | SVGA_3D_CMD_DX_DEFINE_QUERY = 1165, | |
206 | SVGA_3D_CMD_DX_DESTROY_QUERY = 1166, | |
207 | SVGA_3D_CMD_DX_BIND_QUERY = 1167, | |
208 | SVGA_3D_CMD_DX_SET_QUERY_OFFSET = 1168, | |
209 | SVGA_3D_CMD_DX_BEGIN_QUERY = 1169, | |
210 | SVGA_3D_CMD_DX_END_QUERY = 1170, | |
211 | SVGA_3D_CMD_DX_READBACK_QUERY = 1171, | |
212 | SVGA_3D_CMD_DX_SET_PREDICATION = 1172, | |
213 | SVGA_3D_CMD_DX_SET_SOTARGETS = 1173, | |
214 | SVGA_3D_CMD_DX_SET_VIEWPORTS = 1174, | |
215 | SVGA_3D_CMD_DX_SET_SCISSORRECTS = 1175, | |
216 | SVGA_3D_CMD_DX_CLEAR_RENDERTARGET_VIEW = 1176, | |
217 | SVGA_3D_CMD_DX_CLEAR_DEPTHSTENCIL_VIEW = 1177, | |
218 | SVGA_3D_CMD_DX_PRED_COPY_REGION = 1178, | |
219 | SVGA_3D_CMD_DX_PRED_COPY = 1179, | |
220 | SVGA_3D_CMD_DX_STRETCHBLT = 1180, | |
221 | SVGA_3D_CMD_DX_GENMIPS = 1181, | |
222 | SVGA_3D_CMD_DX_UPDATE_SUBRESOURCE = 1182, | |
223 | SVGA_3D_CMD_DX_READBACK_SUBRESOURCE = 1183, | |
224 | SVGA_3D_CMD_DX_INVALIDATE_SUBRESOURCE = 1184, | |
225 | SVGA_3D_CMD_DX_DEFINE_SHADERRESOURCE_VIEW = 1185, | |
226 | SVGA_3D_CMD_DX_DESTROY_SHADERRESOURCE_VIEW = 1186, | |
227 | SVGA_3D_CMD_DX_DEFINE_RENDERTARGET_VIEW = 1187, | |
228 | SVGA_3D_CMD_DX_DESTROY_RENDERTARGET_VIEW = 1188, | |
229 | SVGA_3D_CMD_DX_DEFINE_DEPTHSTENCIL_VIEW = 1189, | |
230 | SVGA_3D_CMD_DX_DESTROY_DEPTHSTENCIL_VIEW = 1190, | |
231 | SVGA_3D_CMD_DX_DEFINE_ELEMENTLAYOUT = 1191, | |
232 | SVGA_3D_CMD_DX_DESTROY_ELEMENTLAYOUT = 1192, | |
233 | SVGA_3D_CMD_DX_DEFINE_BLEND_STATE = 1193, | |
234 | SVGA_3D_CMD_DX_DESTROY_BLEND_STATE = 1194, | |
235 | SVGA_3D_CMD_DX_DEFINE_DEPTHSTENCIL_STATE = 1195, | |
236 | SVGA_3D_CMD_DX_DESTROY_DEPTHSTENCIL_STATE = 1196, | |
237 | SVGA_3D_CMD_DX_DEFINE_RASTERIZER_STATE = 1197, | |
238 | SVGA_3D_CMD_DX_DESTROY_RASTERIZER_STATE = 1198, | |
239 | SVGA_3D_CMD_DX_DEFINE_SAMPLER_STATE = 1199, | |
240 | SVGA_3D_CMD_DX_DESTROY_SAMPLER_STATE = 1200, | |
241 | SVGA_3D_CMD_DX_DEFINE_SHADER = 1201, | |
242 | SVGA_3D_CMD_DX_DESTROY_SHADER = 1202, | |
243 | SVGA_3D_CMD_DX_BIND_SHADER = 1203, | |
244 | SVGA_3D_CMD_DX_DEFINE_STREAMOUTPUT = 1204, | |
245 | SVGA_3D_CMD_DX_DESTROY_STREAMOUTPUT = 1205, | |
246 | SVGA_3D_CMD_DX_SET_STREAMOUTPUT = 1206, | |
247 | SVGA_3D_CMD_DX_SET_COTABLE = 1207, | |
248 | SVGA_3D_CMD_DX_READBACK_COTABLE = 1208, | |
249 | SVGA_3D_CMD_DX_BUFFER_COPY = 1209, | |
250 | SVGA_3D_CMD_DX_TRANSFER_FROM_BUFFER = 1210, | |
251 | SVGA_3D_CMD_DX_SURFACE_COPY_AND_READBACK = 1211, | |
252 | SVGA_3D_CMD_DX_MOVE_QUERY = 1212, | |
253 | SVGA_3D_CMD_DX_BIND_ALL_QUERY = 1213, | |
254 | SVGA_3D_CMD_DX_READBACK_ALL_QUERY = 1214, | |
255 | SVGA_3D_CMD_DX_PRED_TRANSFER_FROM_BUFFER = 1215, | |
256 | SVGA_3D_CMD_DX_MOB_FENCE_64 = 1216, | |
257 | SVGA_3D_CMD_DX_BIND_SHADER_ON_CONTEXT = 1217, | |
258 | SVGA_3D_CMD_DX_HINT = 1218, | |
259 | SVGA_3D_CMD_DX_BUFFER_UPDATE = 1219, | |
260 | SVGA_3D_CMD_DX_SET_VS_CONSTANT_BUFFER_OFFSET = 1220, | |
261 | SVGA_3D_CMD_DX_SET_PS_CONSTANT_BUFFER_OFFSET = 1221, | |
262 | SVGA_3D_CMD_DX_SET_GS_CONSTANT_BUFFER_OFFSET = 1222, | |
263 | ||
264 | /* | |
265 | * Reserve some IDs to be used for the DX11 shader types. | |
266 | */ | |
267 | SVGA_3D_CMD_DX_RESERVED1 = 1223, | |
268 | SVGA_3D_CMD_DX_RESERVED2 = 1224, | |
269 | SVGA_3D_CMD_DX_RESERVED3 = 1225, | |
270 | ||
271 | SVGA_3D_CMD_DX_MAX = 1226, | |
272 | SVGA_3D_CMD_MAX = 1226, | |
273 | SVGA_3D_CMD_FUTURE_MAX = 3000 | |
274 | } SVGAFifo3dCmdId; | |
275 | ||
276 | /* | |
277 | * FIFO command format definitions: | |
278 | */ | |
279 | ||
280 | /* | |
281 | * The data size header following cmdNum for every 3d command | |
282 | */ | |
283 | typedef | |
284 | #include "vmware_pack_begin.h" | |
285 | struct { | |
286 | uint32 id; | |
287 | uint32 size; | |
288 | } | |
289 | #include "vmware_pack_end.h" | |
290 | SVGA3dCmdHeader; | |
291 | ||
292 | typedef | |
293 | #include "vmware_pack_begin.h" | |
294 | struct { | |
295 | uint32 numMipLevels; | |
296 | } | |
297 | #include "vmware_pack_end.h" | |
298 | SVGA3dSurfaceFace; | |
299 | ||
300 | typedef | |
301 | #include "vmware_pack_begin.h" | |
302 | struct { | |
303 | uint32 sid; | |
304 | SVGA3dSurfaceFlags surfaceFlags; | |
305 | SVGA3dSurfaceFormat format; | |
306 | /* | |
307 | * If surfaceFlags has SVGA3D_SURFACE_CUBEMAP bit set, all SVGA3dSurfaceFace | |
308 | * structures must have the same value of numMipLevels field. | |
309 | * Otherwise, all but the first SVGA3dSurfaceFace structures must have the | |
310 | * numMipLevels set to 0. | |
311 | */ | |
312 | SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES]; | |
313 | /* | |
314 | * Followed by an SVGA3dSize structure for each mip level in each face. | |
315 | * | |
316 | * A note on surface sizes: Sizes are always specified in pixels, | |
317 | * even if the true surface size is not a multiple of the minimum | |
318 | * block size of the surface's format. For example, a 3x3x1 DXT1 | |
319 | * compressed texture would actually be stored as a 4x4x1 image in | |
320 | * memory. | |
321 | */ | |
322 | } | |
323 | #include "vmware_pack_end.h" | |
324 | SVGA3dCmdDefineSurface; /* SVGA_3D_CMD_SURFACE_DEFINE */ | |
325 | ||
326 | typedef | |
327 | #include "vmware_pack_begin.h" | |
328 | struct { | |
329 | uint32 sid; | |
330 | SVGA3dSurfaceFlags surfaceFlags; | |
331 | SVGA3dSurfaceFormat format; | |
332 | /* | |
333 | * If surfaceFlags has SVGA3D_SURFACE_CUBEMAP bit set, all SVGA3dSurfaceFace | |
334 | * structures must have the same value of numMipLevels field. | |
335 | * Otherwise, all but the first SVGA3dSurfaceFace structures must have the | |
336 | * numMipLevels set to 0. | |
337 | */ | |
338 | SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES]; | |
339 | uint32 multisampleCount; | |
340 | SVGA3dTextureFilter autogenFilter; | |
341 | /* | |
342 | * Followed by an SVGA3dSize structure for each mip level in each face. | |
343 | * | |
344 | * A note on surface sizes: Sizes are always specified in pixels, | |
345 | * even if the true surface size is not a multiple of the minimum | |
346 | * block size of the surface's format. For example, a 3x3x1 DXT1 | |
347 | * compressed texture would actually be stored as a 4x4x1 image in | |
348 | * memory. | |
349 | */ | |
350 | } | |
351 | #include "vmware_pack_end.h" | |
352 | SVGA3dCmdDefineSurface_v2; /* SVGA_3D_CMD_SURFACE_DEFINE_V2 */ | |
353 | ||
354 | typedef | |
355 | #include "vmware_pack_begin.h" | |
356 | struct { | |
357 | uint32 sid; | |
358 | } | |
359 | #include "vmware_pack_end.h" | |
360 | SVGA3dCmdDestroySurface; /* SVGA_3D_CMD_SURFACE_DESTROY */ | |
361 | ||
362 | typedef | |
363 | #include "vmware_pack_begin.h" | |
364 | struct { | |
365 | uint32 cid; | |
366 | } | |
367 | #include "vmware_pack_end.h" | |
368 | SVGA3dCmdDefineContext; /* SVGA_3D_CMD_CONTEXT_DEFINE */ | |
369 | ||
370 | typedef | |
371 | #include "vmware_pack_begin.h" | |
372 | struct { | |
373 | uint32 cid; | |
374 | } | |
375 | #include "vmware_pack_end.h" | |
376 | SVGA3dCmdDestroyContext; /* SVGA_3D_CMD_CONTEXT_DESTROY */ | |
377 | ||
378 | typedef | |
379 | #include "vmware_pack_begin.h" | |
380 | struct { | |
381 | uint32 cid; | |
382 | SVGA3dClearFlag clearFlag; | |
383 | uint32 color; | |
384 | float depth; | |
385 | uint32 stencil; | |
386 | /* Followed by variable number of SVGA3dRect structures */ | |
387 | } | |
388 | #include "vmware_pack_end.h" | |
389 | SVGA3dCmdClear; /* SVGA_3D_CMD_CLEAR */ | |
390 | ||
391 | typedef | |
392 | #include "vmware_pack_begin.h" | |
393 | struct { | |
394 | SVGA3dLightType type; | |
395 | SVGA3dBool inWorldSpace; | |
396 | float diffuse[4]; | |
397 | float specular[4]; | |
398 | float ambient[4]; | |
399 | float position[4]; | |
400 | float direction[4]; | |
401 | float range; | |
402 | float falloff; | |
403 | float attenuation0; | |
404 | float attenuation1; | |
405 | float attenuation2; | |
406 | float theta; | |
407 | float phi; | |
408 | } | |
409 | #include "vmware_pack_end.h" | |
410 | SVGA3dLightData; | |
411 | ||
412 | typedef | |
413 | #include "vmware_pack_begin.h" | |
414 | struct { | |
415 | uint32 sid; | |
416 | /* Followed by variable number of SVGA3dCopyRect structures */ | |
417 | } | |
418 | #include "vmware_pack_end.h" | |
419 | SVGA3dCmdPresent; /* SVGA_3D_CMD_PRESENT */ | |
420 | ||
421 | typedef | |
422 | #include "vmware_pack_begin.h" | |
423 | struct { | |
424 | SVGA3dRenderStateName state; | |
425 | union { | |
426 | uint32 uintValue; | |
427 | float floatValue; | |
428 | }; | |
429 | } | |
430 | #include "vmware_pack_end.h" | |
431 | SVGA3dRenderState; | |
432 | ||
433 | typedef | |
434 | #include "vmware_pack_begin.h" | |
435 | struct { | |
436 | uint32 cid; | |
437 | /* Followed by variable number of SVGA3dRenderState structures */ | |
438 | } | |
439 | #include "vmware_pack_end.h" | |
440 | SVGA3dCmdSetRenderState; /* SVGA_3D_CMD_SETRENDERSTATE */ | |
441 | ||
442 | typedef | |
443 | #include "vmware_pack_begin.h" | |
444 | struct { | |
445 | uint32 cid; | |
446 | SVGA3dRenderTargetType type; | |
447 | SVGA3dSurfaceImageId target; | |
448 | } | |
449 | #include "vmware_pack_end.h" | |
450 | SVGA3dCmdSetRenderTarget; /* SVGA_3D_CMD_SETRENDERTARGET */ | |
451 | ||
452 | typedef | |
453 | #include "vmware_pack_begin.h" | |
454 | struct { | |
455 | SVGA3dSurfaceImageId src; | |
456 | SVGA3dSurfaceImageId dest; | |
457 | /* Followed by variable number of SVGA3dCopyBox structures */ | |
458 | } | |
459 | #include "vmware_pack_end.h" | |
460 | SVGA3dCmdSurfaceCopy; /* SVGA_3D_CMD_SURFACE_COPY */ | |
461 | ||
462 | typedef | |
463 | #include "vmware_pack_begin.h" | |
464 | struct { | |
465 | SVGA3dSurfaceImageId src; | |
466 | SVGA3dSurfaceImageId dest; | |
467 | SVGA3dBox boxSrc; | |
468 | SVGA3dBox boxDest; | |
469 | SVGA3dStretchBltMode mode; | |
470 | } | |
471 | #include "vmware_pack_end.h" | |
472 | SVGA3dCmdSurfaceStretchBlt; /* SVGA_3D_CMD_SURFACE_STRETCHBLT */ | |
473 | ||
474 | typedef | |
475 | #include "vmware_pack_begin.h" | |
476 | struct { | |
477 | /* | |
478 | * If the discard flag is present in a surface DMA operation, the host may | |
479 | * discard the contents of the current mipmap level and face of the target | |
480 | * surface before applying the surface DMA contents. | |
481 | */ | |
482 | uint32 discard : 1; | |
483 | ||
484 | /* | |
485 | * If the unsynchronized flag is present, the host may perform this upload | |
486 | * without syncing to pending reads on this surface. | |
487 | */ | |
488 | uint32 unsynchronized : 1; | |
489 | ||
490 | /* | |
491 | * Guests *MUST* set the reserved bits to 0 before submitting the command | |
492 | * suffix as future flags may occupy these bits. | |
493 | */ | |
494 | uint32 reserved : 30; | |
495 | } | |
496 | #include "vmware_pack_end.h" | |
497 | SVGA3dSurfaceDMAFlags; | |
498 | ||
499 | typedef | |
500 | #include "vmware_pack_begin.h" | |
501 | struct { | |
502 | SVGAGuestImage guest; | |
503 | SVGA3dSurfaceImageId host; | |
504 | SVGA3dTransferType transfer; | |
505 | /* | |
506 | * Followed by variable number of SVGA3dCopyBox structures. For consistency | |
507 | * in all clipping logic and coordinate translation, we define the | |
508 | * "source" in each copyBox as the guest image and the | |
509 | * "destination" as the host image, regardless of transfer | |
510 | * direction. | |
511 | * | |
512 | * For efficiency, the SVGA3D device is free to copy more data than | |
513 | * specified. For example, it may round copy boxes outwards such | |
514 | * that they lie on particular alignment boundaries. | |
515 | */ | |
516 | } | |
517 | #include "vmware_pack_end.h" | |
518 | SVGA3dCmdSurfaceDMA; /* SVGA_3D_CMD_SURFACE_DMA */ | |
519 | ||
520 | /* | |
521 | * SVGA3dCmdSurfaceDMASuffix -- | |
522 | * | |
523 | * This is a command suffix that will appear after a SurfaceDMA command in | |
524 | * the FIFO. It contains some extra information that hosts may use to | |
525 | * optimize performance or protect the guest. This suffix exists to preserve | |
526 | * backwards compatibility while also allowing for new functionality to be | |
527 | * implemented. | |
528 | */ | |
529 | ||
530 | typedef | |
531 | #include "vmware_pack_begin.h" | |
532 | struct { | |
533 | uint32 suffixSize; | |
534 | ||
535 | /* | |
536 | * The maximum offset is used to determine the maximum offset from the | |
537 | * guestPtr base address that will be accessed or written to during this | |
538 | * surfaceDMA. If the suffix is supported, the host will respect this | |
539 | * boundary while performing surface DMAs. | |
540 | * | |
541 | * Defaults to MAX_UINT32 | |
542 | */ | |
543 | uint32 maximumOffset; | |
544 | ||
545 | /* | |
546 | * A set of flags that describes optimizations that the host may perform | |
547 | * while performing this surface DMA operation. The guest should never rely | |
548 | * on behaviour that is different when these flags are set for correctness. | |
549 | * | |
550 | * Defaults to 0 | |
551 | */ | |
552 | SVGA3dSurfaceDMAFlags flags; | |
553 | } | |
554 | #include "vmware_pack_end.h" | |
555 | SVGA3dCmdSurfaceDMASuffix; | |
556 | ||
557 | /* | |
558 | * SVGA_3D_CMD_DRAW_PRIMITIVES -- | |
559 | * | |
560 | * This command is the SVGA3D device's generic drawing entry point. | |
561 | * It can draw multiple ranges of primitives, optionally using an | |
562 | * index buffer, using an arbitrary collection of vertex buffers. | |
563 | * | |
564 | * Each SVGA3dVertexDecl defines a distinct vertex array to bind | |
565 | * during this draw call. The declarations specify which surface | |
566 | * the vertex data lives in, what that vertex data is used for, | |
567 | * and how to interpret it. | |
568 | * | |
569 | * Each SVGA3dPrimitiveRange defines a collection of primitives | |
570 | * to render using the same vertex arrays. An index buffer is | |
571 | * optional. | |
572 | */ | |
573 | ||
574 | typedef | |
575 | #include "vmware_pack_begin.h" | |
576 | struct { | |
577 | /* | |
578 | * A range hint is an optional specification for the range of indices | |
579 | * in an SVGA3dArray that will be used. If 'last' is zero, it is assumed | |
580 | * that the entire array will be used. | |
581 | * | |
582 | * These are only hints. The SVGA3D device may use them for | |
583 | * performance optimization if possible, but it's also allowed to | |
584 | * ignore these values. | |
585 | */ | |
586 | uint32 first; | |
587 | uint32 last; | |
588 | } | |
589 | #include "vmware_pack_end.h" | |
590 | SVGA3dArrayRangeHint; | |
591 | ||
592 | typedef | |
593 | #include "vmware_pack_begin.h" | |
594 | struct { | |
595 | /* | |
596 | * Define the origin and shape of a vertex or index array. Both | |
597 | * 'offset' and 'stride' are in bytes. The provided surface will be | |
598 | * reinterpreted as a flat array of bytes in the same format used | |
599 | * by surface DMA operations. To avoid unnecessary conversions, the | |
600 | * surface should be created with the SVGA3D_BUFFER format. | |
601 | * | |
602 | * Index 0 in the array starts 'offset' bytes into the surface. | |
603 | * Index 1 begins at byte 'offset + stride', etc. Array indices may | |
604 | * not be negative. | |
605 | */ | |
606 | uint32 surfaceId; | |
607 | uint32 offset; | |
608 | uint32 stride; | |
609 | } | |
610 | #include "vmware_pack_end.h" | |
611 | SVGA3dArray; | |
612 | ||
613 | typedef | |
614 | #include "vmware_pack_begin.h" | |
615 | struct { | |
616 | /* | |
617 | * Describe a vertex array's data type, and define how it is to be | |
618 | * used by the fixed function pipeline or the vertex shader. It | |
619 | * isn't useful to have two VertexDecls with the same | |
620 | * VertexArrayIdentity in one draw call. | |
621 | */ | |
622 | SVGA3dDeclType type; | |
623 | SVGA3dDeclMethod method; | |
624 | SVGA3dDeclUsage usage; | |
625 | uint32 usageIndex; | |
626 | } | |
627 | #include "vmware_pack_end.h" | |
628 | SVGA3dVertexArrayIdentity; | |
629 | ||
630 | typedef | |
631 | #include "vmware_pack_begin.h" | |
632 | struct SVGA3dVertexDecl { | |
633 | SVGA3dVertexArrayIdentity identity; | |
634 | SVGA3dArray array; | |
635 | SVGA3dArrayRangeHint rangeHint; | |
636 | } | |
637 | #include "vmware_pack_end.h" | |
638 | SVGA3dVertexDecl; | |
639 | ||
640 | typedef | |
641 | #include "vmware_pack_begin.h" | |
642 | struct SVGA3dPrimitiveRange { | |
643 | /* | |
644 | * Define a group of primitives to render, from sequential indices. | |
645 | * | |
646 | * The value of 'primitiveType' and 'primitiveCount' imply the | |
647 | * total number of vertices that will be rendered. | |
648 | */ | |
649 | SVGA3dPrimitiveType primType; | |
650 | uint32 primitiveCount; | |
651 | ||
652 | /* | |
653 | * Optional index buffer. If indexArray.surfaceId is | |
654 | * SVGA3D_INVALID_ID, we render without an index buffer. Rendering | |
655 | * without an index buffer is identical to rendering with an index | |
656 | * buffer containing the sequence [0, 1, 2, 3, ...]. | |
657 | * | |
658 | * If an index buffer is in use, indexWidth specifies the width in | |
659 | * bytes of each index value. It must be less than or equal to | |
660 | * indexArray.stride. | |
661 | * | |
662 | * (Currently, the SVGA3D device requires index buffers to be tightly | |
663 | * packed. In other words, indexWidth == indexArray.stride) | |
664 | */ | |
665 | SVGA3dArray indexArray; | |
666 | uint32 indexWidth; | |
667 | ||
668 | /* | |
669 | * Optional index bias. This number is added to all indices from | |
670 | * indexArray before they are used as vertex array indices. This | |
671 | * can be used in multiple ways: | |
672 | * | |
673 | * - When not using an indexArray, this bias can be used to | |
674 | * specify where in the vertex arrays to begin rendering. | |
675 | * | |
676 | * - A positive number here is equivalent to increasing the | |
677 | * offset in each vertex array. | |
678 | * | |
679 | * - A negative number can be used to render using a small | |
680 | * vertex array and an index buffer that contains large | |
681 | * values. This may be used by some applications that | |
682 | * crop a vertex buffer without modifying their index | |
683 | * buffer. | |
684 | * | |
685 | * Note that rendering with a negative bias value may be slower and | |
686 | * use more memory than rendering with a positive or zero bias. | |
687 | */ | |
688 | int32 indexBias; | |
689 | } | |
690 | #include "vmware_pack_end.h" | |
691 | SVGA3dPrimitiveRange; | |
692 | ||
693 | typedef | |
694 | #include "vmware_pack_begin.h" | |
695 | struct { | |
696 | uint32 cid; | |
697 | uint32 numVertexDecls; | |
698 | uint32 numRanges; | |
699 | ||
700 | /* | |
701 | * There are two variable size arrays after the | |
702 | * SVGA3dCmdDrawPrimitives structure. In order, | |
703 | * they are: | |
704 | * | |
705 | * 1. SVGA3dVertexDecl, quantity 'numVertexDecls', but no more than | |
706 | * SVGA3D_MAX_VERTEX_ARRAYS; | |
707 | * 2. SVGA3dPrimitiveRange, quantity 'numRanges', but no more than | |
708 | * SVGA3D_MAX_DRAW_PRIMITIVE_RANGES; | |
709 | * 3. Optionally, SVGA3dVertexDivisor, quantity 'numVertexDecls' (contains | |
710 | * the frequency divisor for the corresponding vertex decl). | |
711 | */ | |
712 | } | |
713 | #include "vmware_pack_end.h" | |
714 | SVGA3dCmdDrawPrimitives; /* SVGA_3D_CMD_DRAWPRIMITIVES */ | |
715 | ||
716 | typedef | |
717 | #include "vmware_pack_begin.h" | |
718 | struct { | |
719 | uint32 cid; | |
720 | ||
721 | uint32 primitiveCount; /* How many primitives to render */ | |
722 | uint32 startVertexLocation; /* Which vertex do we start rendering at. */ | |
723 | ||
724 | uint8 primitiveType; /* SVGA3dPrimitiveType */ | |
725 | uint8 padding[3]; | |
726 | } | |
727 | #include "vmware_pack_end.h" | |
728 | SVGA3dCmdDraw; | |
729 | ||
730 | typedef | |
731 | #include "vmware_pack_begin.h" | |
732 | struct { | |
733 | uint32 cid; | |
734 | ||
735 | uint8 primitiveType; /* SVGA3dPrimitiveType */ | |
736 | ||
737 | uint32 indexBufferSid; /* Valid index buffer sid. */ | |
738 | uint32 indexBufferOffset; /* Byte offset into the vertex buffer, almost */ | |
739 | /* always 0 for DX9 guests, non-zero for OpenGL */ | |
740 | /* guests. We can't represent non-multiple of */ | |
741 | /* stride offsets in D3D9Renderer... */ | |
742 | uint8 indexBufferStride; /* Allowable values = 1, 2, or 4 */ | |
743 | ||
744 | int32 baseVertexLocation; /* Bias applied to the index when selecting a */ | |
745 | /* vertex from the streams, may be negative */ | |
746 | ||
747 | uint32 primitiveCount; /* How many primitives to render */ | |
748 | uint32 pad0; | |
749 | uint16 pad1; | |
750 | } | |
751 | #include "vmware_pack_end.h" | |
752 | SVGA3dCmdDrawIndexed; | |
753 | ||
754 | typedef | |
755 | #include "vmware_pack_begin.h" | |
756 | struct { | |
757 | /* | |
758 | * Describe a vertex array's data type, and define how it is to be | |
759 | * used by the fixed function pipeline or the vertex shader. It | |
760 | * isn't useful to have two VertexDecls with the same | |
761 | * VertexArrayIdentity in one draw call. | |
762 | */ | |
763 | uint16 streamOffset; | |
764 | uint8 stream; | |
765 | uint8 type; /* SVGA3dDeclType */ | |
766 | uint8 method; /* SVGA3dDeclMethod */ | |
767 | uint8 usage; /* SVGA3dDeclUsage */ | |
768 | uint8 usageIndex; | |
769 | uint8 padding; | |
770 | ||
771 | } | |
772 | #include "vmware_pack_end.h" | |
773 | SVGA3dVertexElement; | |
774 | ||
775 | typedef | |
776 | #include "vmware_pack_begin.h" | |
777 | struct { | |
778 | uint32 cid; | |
779 | ||
780 | uint32 numElements; | |
781 | ||
782 | /* | |
783 | * Followed by numElements SVGA3dVertexElement structures. | |
784 | * | |
785 | * If numElements < SVGA3D_MAX_VERTEX_ARRAYS, the remaining elements | |
786 | * are cleared and will not be used by following draws. | |
787 | */ | |
788 | } | |
789 | #include "vmware_pack_end.h" | |
790 | SVGA3dCmdSetVertexDecls; | |
791 | ||
792 | typedef | |
793 | #include "vmware_pack_begin.h" | |
794 | struct { | |
795 | uint32 sid; | |
796 | uint32 stride; | |
797 | uint32 offset; | |
798 | } | |
799 | #include "vmware_pack_end.h" | |
800 | SVGA3dVertexStream; | |
801 | ||
802 | typedef | |
803 | #include "vmware_pack_begin.h" | |
804 | struct { | |
805 | uint32 cid; | |
806 | ||
807 | uint32 numStreams; | |
808 | /* | |
809 | * Followed by numStream SVGA3dVertexStream structures. | |
810 | * | |
811 | * If numStreams < SVGA3D_MAX_VERTEX_ARRAYS, the remaining streams | |
812 | * are cleared and will not be used by following draws. | |
813 | */ | |
814 | } | |
815 | #include "vmware_pack_end.h" | |
816 | SVGA3dCmdSetVertexStreams; | |
817 | ||
818 | typedef | |
819 | #include "vmware_pack_begin.h" | |
820 | struct { | |
821 | uint32 cid; | |
822 | uint32 numDivisors; | |
823 | } | |
824 | #include "vmware_pack_end.h" | |
825 | SVGA3dCmdSetVertexDivisors; | |
826 | ||
827 | typedef | |
828 | #include "vmware_pack_begin.h" | |
829 | struct { | |
830 | uint32 stage; | |
831 | SVGA3dTextureStateName name; | |
832 | union { | |
833 | uint32 value; | |
834 | float floatValue; | |
835 | }; | |
836 | } | |
837 | #include "vmware_pack_end.h" | |
838 | SVGA3dTextureState; | |
839 | ||
840 | typedef | |
841 | #include "vmware_pack_begin.h" | |
842 | struct { | |
843 | uint32 cid; | |
844 | /* Followed by variable number of SVGA3dTextureState structures */ | |
845 | } | |
846 | #include "vmware_pack_end.h" | |
847 | SVGA3dCmdSetTextureState; /* SVGA_3D_CMD_SETTEXTURESTATE */ | |
848 | ||
849 | typedef | |
850 | #include "vmware_pack_begin.h" | |
851 | struct { | |
852 | uint32 cid; | |
853 | SVGA3dTransformType type; | |
854 | float matrix[16]; | |
855 | } | |
856 | #include "vmware_pack_end.h" | |
857 | SVGA3dCmdSetTransform; /* SVGA_3D_CMD_SETTRANSFORM */ | |
858 | ||
859 | typedef | |
860 | #include "vmware_pack_begin.h" | |
861 | struct { | |
862 | float min; | |
863 | float max; | |
864 | } | |
865 | #include "vmware_pack_end.h" | |
866 | SVGA3dZRange; | |
867 | ||
868 | typedef | |
869 | #include "vmware_pack_begin.h" | |
870 | struct { | |
871 | uint32 cid; | |
872 | SVGA3dZRange zRange; | |
873 | } | |
874 | #include "vmware_pack_end.h" | |
875 | SVGA3dCmdSetZRange; /* SVGA_3D_CMD_SETZRANGE */ | |
876 | ||
877 | typedef | |
878 | #include "vmware_pack_begin.h" | |
879 | struct { | |
880 | float diffuse[4]; | |
881 | float ambient[4]; | |
882 | float specular[4]; | |
883 | float emissive[4]; | |
884 | float shininess; | |
885 | } | |
886 | #include "vmware_pack_end.h" | |
887 | SVGA3dMaterial; | |
888 | ||
889 | typedef | |
890 | #include "vmware_pack_begin.h" | |
891 | struct { | |
892 | uint32 cid; | |
893 | SVGA3dFace face; | |
894 | SVGA3dMaterial material; | |
895 | } | |
896 | #include "vmware_pack_end.h" | |
897 | SVGA3dCmdSetMaterial; /* SVGA_3D_CMD_SETMATERIAL */ | |
898 | ||
899 | typedef | |
900 | #include "vmware_pack_begin.h" | |
901 | struct { | |
902 | uint32 cid; | |
903 | uint32 index; | |
904 | SVGA3dLightData data; | |
905 | } | |
906 | #include "vmware_pack_end.h" | |
907 | SVGA3dCmdSetLightData; /* SVGA_3D_CMD_SETLIGHTDATA */ | |
908 | ||
909 | typedef | |
910 | #include "vmware_pack_begin.h" | |
911 | struct { | |
912 | uint32 cid; | |
913 | uint32 index; | |
914 | uint32 enabled; | |
915 | } | |
916 | #include "vmware_pack_end.h" | |
917 | SVGA3dCmdSetLightEnabled; /* SVGA_3D_CMD_SETLIGHTENABLED */ | |
918 | ||
919 | typedef | |
920 | #include "vmware_pack_begin.h" | |
921 | struct { | |
922 | uint32 cid; | |
923 | SVGA3dRect rect; | |
924 | } | |
925 | #include "vmware_pack_end.h" | |
926 | SVGA3dCmdSetViewport; /* SVGA_3D_CMD_SETVIEWPORT */ | |
927 | ||
928 | typedef | |
929 | #include "vmware_pack_begin.h" | |
930 | struct { | |
931 | uint32 cid; | |
932 | SVGA3dRect rect; | |
933 | } | |
934 | #include "vmware_pack_end.h" | |
935 | SVGA3dCmdSetScissorRect; /* SVGA_3D_CMD_SETSCISSORRECT */ | |
936 | ||
937 | typedef | |
938 | #include "vmware_pack_begin.h" | |
939 | struct { | |
940 | uint32 cid; | |
941 | uint32 index; | |
942 | float plane[4]; | |
943 | } | |
944 | #include "vmware_pack_end.h" | |
945 | SVGA3dCmdSetClipPlane; /* SVGA_3D_CMD_SETCLIPPLANE */ | |
946 | ||
947 | typedef | |
948 | #include "vmware_pack_begin.h" | |
949 | struct { | |
950 | uint32 cid; | |
951 | uint32 shid; | |
952 | SVGA3dShaderType type; | |
953 | /* Followed by variable number of DWORDs for shader bycode */ | |
954 | } | |
955 | #include "vmware_pack_end.h" | |
956 | SVGA3dCmdDefineShader; /* SVGA_3D_CMD_SHADER_DEFINE */ | |
957 | ||
958 | typedef | |
959 | #include "vmware_pack_begin.h" | |
960 | struct { | |
961 | uint32 cid; | |
962 | uint32 shid; | |
963 | SVGA3dShaderType type; | |
964 | } | |
965 | #include "vmware_pack_end.h" | |
966 | SVGA3dCmdDestroyShader; /* SVGA_3D_CMD_SHADER_DESTROY */ | |
967 | ||
968 | typedef | |
969 | #include "vmware_pack_begin.h" | |
970 | struct { | |
971 | uint32 cid; | |
972 | uint32 reg; /* register number */ | |
973 | SVGA3dShaderType type; | |
974 | SVGA3dShaderConstType ctype; | |
975 | uint32 values[4]; | |
976 | ||
977 | /* | |
978 | * Followed by a variable number of additional values. | |
979 | */ | |
980 | } | |
981 | #include "vmware_pack_end.h" | |
982 | SVGA3dCmdSetShaderConst; /* SVGA_3D_CMD_SET_SHADER_CONST */ | |
983 | ||
984 | typedef | |
985 | #include "vmware_pack_begin.h" | |
986 | struct { | |
987 | uint32 cid; | |
988 | SVGA3dShaderType type; | |
989 | uint32 shid; | |
990 | } | |
991 | #include "vmware_pack_end.h" | |
992 | SVGA3dCmdSetShader; /* SVGA_3D_CMD_SET_SHADER */ | |
993 | ||
994 | typedef | |
995 | #include "vmware_pack_begin.h" | |
996 | struct { | |
997 | uint32 cid; | |
998 | SVGA3dQueryType type; | |
999 | } | |
1000 | #include "vmware_pack_end.h" | |
1001 | SVGA3dCmdBeginQuery; /* SVGA_3D_CMD_BEGIN_QUERY */ | |
1002 | ||
1003 | typedef | |
1004 | #include "vmware_pack_begin.h" | |
1005 | struct { | |
1006 | uint32 cid; | |
1007 | SVGA3dQueryType type; | |
1008 | SVGAGuestPtr guestResult; /* Points to an SVGA3dQueryResult structure */ | |
1009 | } | |
1010 | #include "vmware_pack_end.h" | |
1011 | SVGA3dCmdEndQuery; /* SVGA_3D_CMD_END_QUERY */ | |
1012 | ||
1013 | ||
1014 | /* | |
1015 | * SVGA3D_CMD_WAIT_FOR_QUERY -- | |
1016 | * | |
1017 | * Will read the SVGA3dQueryResult structure pointed to by guestResult, | |
1018 | * and if the state member is set to anything else than | |
1019 | * SVGA3D_QUERYSTATE_PENDING, this command will always be a no-op. | |
1020 | * | |
1021 | * Otherwise, in addition to the query explicitly waited for, | |
1022 | * All queries with the same type and issued with the same cid, for which | |
1023 | * an SVGA_3D_CMD_END_QUERY command has previously been sent, will | |
1024 | * be finished after execution of this command. | |
1025 | * | |
1026 | * A query will be identified by the gmrId and offset of the guestResult | |
1027 | * member. If the device can't find an SVGA_3D_CMD_END_QUERY that has | |
1028 | * been sent previously with an indentical gmrId and offset, it will | |
1029 | * effectively end all queries with an identical type issued with the | |
1030 | * same cid, and the SVGA3dQueryResult structure pointed to by | |
1031 | * guestResult will not be written to. This property can be used to | |
1032 | * implement a query barrier for a given cid and query type. | |
1033 | */ | |
1034 | ||
1035 | typedef | |
1036 | #include "vmware_pack_begin.h" | |
1037 | struct { | |
1038 | uint32 cid; /* Same parameters passed to END_QUERY */ | |
1039 | SVGA3dQueryType type; | |
1040 | SVGAGuestPtr guestResult; | |
1041 | } | |
1042 | #include "vmware_pack_end.h" | |
1043 | SVGA3dCmdWaitForQuery; /* SVGA_3D_CMD_WAIT_FOR_QUERY */ | |
1044 | ||
1045 | typedef | |
1046 | #include "vmware_pack_begin.h" | |
1047 | struct { | |
1048 | uint32 totalSize; /* Set by guest before query is ended. */ | |
1049 | SVGA3dQueryState state; /* Set by host or guest. See SVGA3dQueryState. */ | |
1050 | union { /* Set by host on exit from PENDING state */ | |
1051 | uint32 result32; | |
1052 | uint32 queryCookie; /* May be used to identify which QueryGetData this | |
1053 | result corresponds to. */ | |
1054 | }; | |
1055 | } | |
1056 | #include "vmware_pack_end.h" | |
1057 | SVGA3dQueryResult; | |
1058 | ||
1059 | ||
1060 | /* | |
1061 | * SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN -- | |
1062 | * | |
1063 | * This is a blit from an SVGA3D surface to a Screen Object. | |
1064 | * This blit must be directed at a specific screen. | |
1065 | * | |
1066 | * The blit copies from a rectangular region of an SVGA3D surface | |
1067 | * image to a rectangular region of a screen. | |
1068 | * | |
1069 | * This command takes an optional variable-length list of clipping | |
1070 | * rectangles after the body of the command. If no rectangles are | |
1071 | * specified, there is no clipping region. The entire destRect is | |
1072 | * drawn to. If one or more rectangles are included, they describe | |
1073 | * a clipping region. The clip rectangle coordinates are measured | |
1074 | * relative to the top-left corner of destRect. | |
1075 | * | |
1076 | * The srcImage must be from mip=0 face=0. | |
1077 | * | |
1078 | * This supports scaling if the src and dest are of different sizes. | |
1079 | * | |
1080 | * Availability: | |
1081 | * SVGA_FIFO_CAP_SCREEN_OBJECT | |
1082 | */ | |
1083 | ||
1084 | typedef | |
1085 | #include "vmware_pack_begin.h" | |
1086 | struct { | |
1087 | SVGA3dSurfaceImageId srcImage; | |
1088 | SVGASignedRect srcRect; | |
1089 | uint32 destScreenId; /* Screen Object ID */ | |
1090 | SVGASignedRect destRect; | |
1091 | /* Clipping: zero or more SVGASignedRects follow */ | |
1092 | } | |
1093 | #include "vmware_pack_end.h" | |
1094 | SVGA3dCmdBlitSurfaceToScreen; /* SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN */ | |
1095 | ||
1096 | typedef | |
1097 | #include "vmware_pack_begin.h" | |
1098 | struct { | |
1099 | uint32 sid; | |
1100 | SVGA3dTextureFilter filter; | |
1101 | } | |
1102 | #include "vmware_pack_end.h" | |
1103 | SVGA3dCmdGenerateMipmaps; /* SVGA_3D_CMD_GENERATE_MIPMAPS */ | |
1104 | ||
1105 | ||
1106 | ||
1107 | typedef | |
1108 | #include "vmware_pack_begin.h" | |
1109 | struct { | |
1110 | uint32 sid; | |
1111 | } | |
1112 | #include "vmware_pack_end.h" | |
1113 | SVGA3dCmdActivateSurface; /* SVGA_3D_CMD_ACTIVATE_SURFACE */ | |
1114 | ||
1115 | typedef | |
1116 | #include "vmware_pack_begin.h" | |
1117 | struct { | |
1118 | uint32 sid; | |
1119 | } | |
1120 | #include "vmware_pack_end.h" | |
1121 | SVGA3dCmdDeactivateSurface; /* SVGA_3D_CMD_DEACTIVATE_SURFACE */ | |
1122 | ||
1123 | /* | |
1124 | * Screen DMA command | |
1125 | * | |
1126 | * Available with SVGA_FIFO_CAP_SCREEN_OBJECT_2. The SVGA_CAP_3D device | |
1127 | * cap bit is not required. | |
1128 | * | |
1129 | * - refBuffer and destBuffer are 32bit BGRX; refBuffer and destBuffer could | |
1130 | * be different, but it is required that guest makes sure refBuffer has | |
1131 | * exactly the same contents that were written to when last time screen DMA | |
1132 | * command is received by host. | |
1133 | * | |
1134 | * - changemap is generated by lib/blit, and it has the changes from last | |
1135 | * received screen DMA or more. | |
1136 | */ | |
1137 | ||
1138 | typedef | |
1139 | #include "vmware_pack_begin.h" | |
1140 | struct SVGA3dCmdScreenDMA { | |
1141 | uint32 screenId; | |
1142 | SVGAGuestImage refBuffer; | |
1143 | SVGAGuestImage destBuffer; | |
1144 | SVGAGuestImage changeMap; | |
1145 | } | |
1146 | #include "vmware_pack_end.h" | |
1147 | SVGA3dCmdScreenDMA; /* SVGA_3D_CMD_SCREEN_DMA */ | |
1148 | ||
1149 | /* | |
1150 | * Set Unity Surface Cookie | |
1151 | * | |
1152 | * Associates the supplied cookie with the surface id for use with | |
1153 | * Unity. This cookie is a hint from guest to host, there is no way | |
1154 | * for the guest to readback the cookie and the host is free to drop | |
1155 | * the cookie association at will. The default value for the cookie | |
1156 | * on all surfaces is 0. | |
1157 | */ | |
1158 | ||
1159 | typedef | |
1160 | #include "vmware_pack_begin.h" | |
1161 | struct SVGA3dCmdSetUnitySurfaceCookie { | |
1162 | uint32 sid; | |
1163 | uint64 cookie; | |
1164 | } | |
1165 | #include "vmware_pack_end.h" | |
1166 | SVGA3dCmdSetUnitySurfaceCookie; /* SVGA_3D_CMD_SET_UNITY_SURFACE_COOKIE */ | |
1167 | ||
1168 | /* | |
1169 | * Open a context-specific surface in a non-context-specific manner. | |
1170 | */ | |
1171 | ||
1172 | typedef | |
1173 | #include "vmware_pack_begin.h" | |
1174 | struct SVGA3dCmdOpenContextSurface { | |
1175 | uint32 sid; | |
1176 | } | |
1177 | #include "vmware_pack_end.h" | |
1178 | SVGA3dCmdOpenContextSurface; /* SVGA_3D_CMD_OPEN_CONTEXT_SURFACE */ | |
1179 | ||
1180 | ||
1181 | /* | |
1182 | * Logic ops | |
1183 | */ | |
1184 | ||
1185 | #define SVGA3D_LOTRANSBLT_HONORALPHA (0x01) | |
1186 | #define SVGA3D_LOSTRETCHBLT_MIRRORX (0x01) | |
1187 | #define SVGA3D_LOSTRETCHBLT_MIRRORY (0x02) | |
1188 | #define SVGA3D_LOALPHABLEND_SRCHASALPHA (0x01) | |
1189 | ||
1190 | typedef | |
1191 | #include "vmware_pack_begin.h" | |
1192 | struct SVGA3dCmdLogicOpsBitBlt { | |
1193 | /* | |
1194 | * All LogicOps surfaces are one-level | |
1195 | * surfaces so mipmap & face should always | |
1196 | * be zero. | |
1197 | */ | |
1198 | SVGA3dSurfaceImageId src; | |
1199 | SVGA3dSurfaceImageId dst; | |
1200 | SVGA3dLogicOp logicOp; | |
1201 | /* Followed by variable number of SVGA3dCopyBox structures */ | |
1202 | } | |
1203 | #include "vmware_pack_end.h" | |
1204 | SVGA3dCmdLogicOpsBitBlt; /* SVGA_3D_CMD_LOGICOPS_BITBLT */ | |
1205 | ||
1206 | ||
1207 | typedef | |
1208 | #include "vmware_pack_begin.h" | |
1209 | struct SVGA3dCmdLogicOpsTransBlt { | |
1210 | /* | |
1211 | * All LogicOps surfaces are one-level | |
1212 | * surfaces so mipmap & face should always | |
1213 | * be zero. | |
1214 | */ | |
1215 | SVGA3dSurfaceImageId src; | |
1216 | SVGA3dSurfaceImageId dst; | |
1217 | uint32 color; | |
1218 | uint32 flags; | |
1219 | SVGA3dBox srcBox; | |
1220 | SVGA3dBox dstBox; | |
1221 | } | |
1222 | #include "vmware_pack_end.h" | |
1223 | SVGA3dCmdLogicOpsTransBlt; /* SVGA_3D_CMD_LOGICOPS_TRANSBLT */ | |
1224 | ||
1225 | ||
1226 | typedef | |
1227 | #include "vmware_pack_begin.h" | |
1228 | struct SVGA3dCmdLogicOpsStretchBlt { | |
1229 | /* | |
1230 | * All LogicOps surfaces are one-level | |
1231 | * surfaces so mipmap & face should always | |
1232 | * be zero. | |
1233 | */ | |
1234 | SVGA3dSurfaceImageId src; | |
1235 | SVGA3dSurfaceImageId dst; | |
1236 | uint16 mode; | |
1237 | uint16 flags; | |
1238 | SVGA3dBox srcBox; | |
1239 | SVGA3dBox dstBox; | |
1240 | } | |
1241 | #include "vmware_pack_end.h" | |
1242 | SVGA3dCmdLogicOpsStretchBlt; /* SVGA_3D_CMD_LOGICOPS_STRETCHBLT */ | |
1243 | ||
1244 | ||
1245 | typedef | |
1246 | #include "vmware_pack_begin.h" | |
1247 | struct SVGA3dCmdLogicOpsColorFill { | |
1248 | /* | |
1249 | * All LogicOps surfaces are one-level | |
1250 | * surfaces so mipmap & face should always | |
1251 | * be zero. | |
1252 | */ | |
1253 | SVGA3dSurfaceImageId dst; | |
1254 | uint32 color; | |
1255 | SVGA3dLogicOp logicOp; | |
1256 | /* Followed by variable number of SVGA3dRect structures. */ | |
1257 | } | |
1258 | #include "vmware_pack_end.h" | |
1259 | SVGA3dCmdLogicOpsColorFill; /* SVGA_3D_CMD_LOGICOPS_COLORFILL */ | |
1260 | ||
1261 | ||
1262 | typedef | |
1263 | #include "vmware_pack_begin.h" | |
1264 | struct SVGA3dCmdLogicOpsAlphaBlend { | |
1265 | /* | |
1266 | * All LogicOps surfaces are one-level | |
1267 | * surfaces so mipmap & face should always | |
1268 | * be zero. | |
1269 | */ | |
1270 | SVGA3dSurfaceImageId src; | |
1271 | SVGA3dSurfaceImageId dst; | |
1272 | uint32 alphaVal; | |
1273 | uint32 flags; | |
1274 | SVGA3dBox srcBox; | |
1275 | SVGA3dBox dstBox; | |
1276 | } | |
1277 | #include "vmware_pack_end.h" | |
1278 | SVGA3dCmdLogicOpsAlphaBlend; /* SVGA_3D_CMD_LOGICOPS_ALPHABLEND */ | |
1279 | ||
1280 | #define SVGA3D_CLEARTYPE_INVALID_GAMMA_INDEX 0xFFFFFFFF | |
1281 | ||
1282 | #define SVGA3D_CLEARTYPE_GAMMA_WIDTH 512 | |
1283 | #define SVGA3D_CLEARTYPE_GAMMA_HEIGHT 16 | |
1284 | ||
1285 | typedef | |
1286 | #include "vmware_pack_begin.h" | |
1287 | struct SVGA3dCmdLogicOpsClearTypeBlend { | |
1288 | /* | |
1289 | * All LogicOps surfaces are one-level | |
1290 | * surfaces so mipmap & face should always | |
1291 | * be zero. | |
1292 | */ | |
1293 | SVGA3dSurfaceImageId tmp; | |
1294 | SVGA3dSurfaceImageId dst; | |
1295 | SVGA3dSurfaceImageId gammaSurf; | |
1296 | SVGA3dSurfaceImageId alphaSurf; | |
1297 | uint32 gamma; | |
1298 | uint32 color; | |
1299 | uint32 color2; | |
1300 | int32 alphaOffsetX; | |
1301 | int32 alphaOffsetY; | |
1302 | /* Followed by variable number of SVGA3dBox structures */ | |
1303 | } | |
1304 | #include "vmware_pack_end.h" | |
1305 | SVGA3dCmdLogicOpsClearTypeBlend; /* SVGA_3D_CMD_LOGICOPS_CLEARTYPEBLEND */ | |
1306 | ||
1307 | ||
1308 | /* | |
1309 | * Guest-backed objects definitions. | |
1310 | */ | |
1311 | ||
1312 | typedef | |
1313 | #include "vmware_pack_begin.h" | |
1314 | struct { | |
1315 | SVGAMobFormat ptDepth; | |
1316 | uint32 sizeInBytes; | |
1317 | PPN64 base; | |
1318 | } | |
1319 | #include "vmware_pack_end.h" | |
1320 | SVGAOTableMobEntry; | |
1321 | #define SVGA3D_OTABLE_MOB_ENTRY_SIZE (sizeof(SVGAOTableMobEntry)) | |
1322 | ||
1323 | typedef | |
1324 | #include "vmware_pack_begin.h" | |
1325 | struct { | |
1326 | SVGA3dSurfaceFormat format; | |
1327 | SVGA3dSurfaceFlags surfaceFlags; | |
1328 | uint32 numMipLevels; | |
1329 | uint32 multisampleCount; | |
1330 | SVGA3dTextureFilter autogenFilter; | |
1331 | SVGA3dSize size; | |
1332 | SVGAMobId mobid; | |
1333 | uint32 arraySize; | |
1334 | uint32 mobPitch; | |
1335 | uint32 pad[5]; | |
1336 | } | |
1337 | #include "vmware_pack_end.h" | |
1338 | SVGAOTableSurfaceEntry; | |
1339 | #define SVGA3D_OTABLE_SURFACE_ENTRY_SIZE (sizeof(SVGAOTableSurfaceEntry)) | |
1340 | ||
1341 | typedef | |
1342 | #include "vmware_pack_begin.h" | |
1343 | struct { | |
1344 | uint32 cid; | |
1345 | SVGAMobId mobid; | |
1346 | } | |
1347 | #include "vmware_pack_end.h" | |
1348 | SVGAOTableContextEntry; | |
1349 | #define SVGA3D_OTABLE_CONTEXT_ENTRY_SIZE (sizeof(SVGAOTableContextEntry)) | |
1350 | ||
1351 | typedef | |
1352 | #include "vmware_pack_begin.h" | |
1353 | struct { | |
1354 | SVGA3dShaderType type; | |
1355 | uint32 sizeInBytes; | |
1356 | uint32 offsetInBytes; | |
1357 | SVGAMobId mobid; | |
1358 | } | |
1359 | #include "vmware_pack_end.h" | |
1360 | SVGAOTableShaderEntry; | |
1361 | #define SVGA3D_OTABLE_SHADER_ENTRY_SIZE (sizeof(SVGAOTableShaderEntry)) | |
1362 | ||
1363 | #define SVGA_STFLAG_PRIMARY (1 << 0) | |
1364 | typedef uint32 SVGAScreenTargetFlags; | |
1365 | ||
1366 | typedef | |
1367 | #include "vmware_pack_begin.h" | |
1368 | struct { | |
1369 | SVGA3dSurfaceImageId image; | |
1370 | uint32 width; | |
1371 | uint32 height; | |
1372 | int32 xRoot; | |
1373 | int32 yRoot; | |
1374 | SVGAScreenTargetFlags flags; | |
1375 | uint32 dpi; | |
1376 | uint32 pad[7]; | |
1377 | } | |
1378 | #include "vmware_pack_end.h" | |
1379 | SVGAOTableScreenTargetEntry; | |
1380 | #define SVGA3D_OTABLE_SCREEN_TARGET_ENTRY_SIZE \ | |
1381 | (sizeof(SVGAOTableScreenTargetEntry)) | |
1382 | ||
1383 | typedef | |
1384 | #include "vmware_pack_begin.h" | |
1385 | struct { | |
1386 | float value[4]; | |
1387 | } | |
1388 | #include "vmware_pack_end.h" | |
1389 | SVGA3dShaderConstFloat; | |
1390 | ||
1391 | typedef | |
1392 | #include "vmware_pack_begin.h" | |
1393 | struct { | |
1394 | int32 value[4]; | |
1395 | } | |
1396 | #include "vmware_pack_end.h" | |
1397 | SVGA3dShaderConstInt; | |
1398 | ||
1399 | typedef | |
1400 | #include "vmware_pack_begin.h" | |
1401 | struct { | |
1402 | uint32 value; | |
1403 | } | |
1404 | #include "vmware_pack_end.h" | |
1405 | SVGA3dShaderConstBool; | |
1406 | ||
1407 | typedef | |
1408 | #include "vmware_pack_begin.h" | |
1409 | struct { | |
1410 | uint16 streamOffset; | |
1411 | uint8 stream; | |
1412 | uint8 type; | |
1413 | uint8 methodUsage; | |
1414 | uint8 usageIndex; | |
1415 | } | |
1416 | #include "vmware_pack_end.h" | |
1417 | SVGAGBVertexElement; | |
1418 | ||
1419 | typedef | |
1420 | #include "vmware_pack_begin.h" | |
1421 | struct { | |
1422 | uint32 sid; | |
1423 | uint16 stride; | |
1424 | uint32 offset; | |
1425 | } | |
1426 | #include "vmware_pack_end.h" | |
1427 | SVGAGBVertexStream; | |
1428 | typedef | |
1429 | #include "vmware_pack_begin.h" | |
1430 | struct { | |
1431 | SVGA3dRect viewport; | |
1432 | SVGA3dRect scissorRect; | |
1433 | SVGA3dZRange zRange; | |
1434 | ||
1435 | SVGA3dSurfaceImageId renderTargets[SVGA3D_RT_MAX]; | |
1436 | SVGAGBVertexElement decl1[4]; | |
1437 | ||
1438 | uint32 renderStates[SVGA3D_RS_MAX]; | |
1439 | SVGAGBVertexElement decl2[18]; | |
1440 | uint32 pad0[2]; | |
1441 | ||
1442 | struct { | |
1443 | SVGA3dFace face; | |
1444 | SVGA3dMaterial material; | |
1445 | } material; | |
1446 | ||
1447 | float clipPlanes[SVGA3D_NUM_CLIPPLANES][4]; | |
1448 | float matrices[SVGA3D_TRANSFORM_MAX][16]; | |
1449 | ||
1450 | SVGA3dBool lightEnabled[SVGA3D_NUM_LIGHTS]; | |
1451 | SVGA3dLightData lightData[SVGA3D_NUM_LIGHTS]; | |
1452 | ||
1453 | /* | |
1454 | * Shaders currently bound | |
1455 | */ | |
1456 | uint32 shaders[SVGA3D_NUM_SHADERTYPE_PREDX]; | |
1457 | SVGAGBVertexElement decl3[10]; | |
1458 | uint32 pad1[3]; | |
1459 | ||
1460 | uint32 occQueryActive; | |
1461 | uint32 occQueryValue; | |
1462 | ||
1463 | /* | |
1464 | * Int/Bool Shader constants | |
1465 | */ | |
1466 | SVGA3dShaderConstInt pShaderIValues[SVGA3D_CONSTINTREG_MAX]; | |
1467 | SVGA3dShaderConstInt vShaderIValues[SVGA3D_CONSTINTREG_MAX]; | |
1468 | uint16 pShaderBValues; | |
1469 | uint16 vShaderBValues; | |
1470 | ||
1471 | ||
1472 | SVGAGBVertexStream streams[SVGA3D_MAX_VERTEX_ARRAYS]; | |
1473 | SVGA3dVertexDivisor divisors[SVGA3D_MAX_VERTEX_ARRAYS]; | |
1474 | uint32 numVertexDecls; | |
1475 | uint32 numVertexStreams; | |
1476 | uint32 numVertexDivisors; | |
1477 | uint32 pad2[30]; | |
1478 | ||
1479 | /* | |
1480 | * Texture Stages | |
1481 | * | |
1482 | * SVGA3D_TS_INVALID through SVGA3D_TS_CONSTANT are in the | |
1483 | * textureStages array. | |
1484 | * SVGA3D_TS_COLOR_KEY is in tsColorKey. | |
1485 | */ | |
1486 | uint32 tsColorKey[SVGA3D_NUM_TEXTURE_UNITS]; | |
1487 | uint32 textureStages[SVGA3D_NUM_TEXTURE_UNITS][SVGA3D_TS_CONSTANT + 1]; | |
1488 | uint32 tsColorKeyEnable[SVGA3D_NUM_TEXTURE_UNITS]; | |
1489 | ||
1490 | /* | |
1491 | * Float Shader constants. | |
1492 | */ | |
1493 | SVGA3dShaderConstFloat pShaderFValues[SVGA3D_CONSTREG_MAX]; | |
1494 | SVGA3dShaderConstFloat vShaderFValues[SVGA3D_CONSTREG_MAX]; | |
1495 | } | |
1496 | #include "vmware_pack_end.h" | |
1497 | SVGAGBContextData; | |
1498 | #define SVGA3D_CONTEXT_DATA_SIZE (sizeof(SVGAGBContextData)) | |
1499 | ||
1500 | /* | |
1501 | * SVGA3dCmdSetOTableBase -- | |
1502 | * | |
1503 | * This command allows the guest to specify the base PPN of the | |
1504 | * specified object table. | |
1505 | */ | |
1506 | ||
1507 | typedef | |
1508 | #include "vmware_pack_begin.h" | |
1509 | struct { | |
1510 | SVGAOTableType type; | |
1511 | PPN baseAddress; | |
1512 | uint32 sizeInBytes; | |
1513 | uint32 validSizeInBytes; | |
1514 | SVGAMobFormat ptDepth; | |
1515 | } | |
1516 | #include "vmware_pack_end.h" | |
1517 | SVGA3dCmdSetOTableBase; /* SVGA_3D_CMD_SET_OTABLE_BASE */ | |
1518 | ||
1519 | typedef | |
1520 | #include "vmware_pack_begin.h" | |
1521 | struct { | |
1522 | SVGAOTableType type; | |
1523 | PPN64 baseAddress; | |
1524 | uint32 sizeInBytes; | |
1525 | uint32 validSizeInBytes; | |
1526 | SVGAMobFormat ptDepth; | |
1527 | } | |
1528 | #include "vmware_pack_end.h" | |
1529 | SVGA3dCmdSetOTableBase64; /* SVGA_3D_CMD_SET_OTABLE_BASE64 */ | |
1530 | ||
1531 | typedef | |
1532 | #include "vmware_pack_begin.h" | |
1533 | struct { | |
1534 | SVGAOTableType type; | |
1535 | } | |
1536 | #include "vmware_pack_end.h" | |
1537 | SVGA3dCmdReadbackOTable; /* SVGA_3D_CMD_READBACK_OTABLE */ | |
1538 | ||
1539 | /* | |
1540 | * Define a memory object (Mob) in the OTable. | |
1541 | */ | |
1542 | ||
1543 | typedef | |
1544 | #include "vmware_pack_begin.h" | |
1545 | struct SVGA3dCmdDefineGBMob { | |
1546 | SVGAMobId mobid; | |
1547 | SVGAMobFormat ptDepth; | |
1548 | PPN base; | |
1549 | uint32 sizeInBytes; | |
1550 | } | |
1551 | #include "vmware_pack_end.h" | |
1552 | SVGA3dCmdDefineGBMob; /* SVGA_3D_CMD_DEFINE_GB_MOB */ | |
1553 | ||
1554 | ||
1555 | /* | |
1556 | * Destroys an object in the OTable. | |
1557 | */ | |
1558 | ||
1559 | typedef | |
1560 | #include "vmware_pack_begin.h" | |
1561 | struct SVGA3dCmdDestroyGBMob { | |
1562 | SVGAMobId mobid; | |
1563 | } | |
1564 | #include "vmware_pack_end.h" | |
1565 | SVGA3dCmdDestroyGBMob; /* SVGA_3D_CMD_DESTROY_GB_MOB */ | |
1566 | ||
1567 | ||
1568 | /* | |
1569 | * Define a memory object (Mob) in the OTable with a PPN64 base. | |
1570 | */ | |
1571 | ||
1572 | typedef | |
1573 | #include "vmware_pack_begin.h" | |
1574 | struct SVGA3dCmdDefineGBMob64 { | |
1575 | SVGAMobId mobid; | |
1576 | SVGAMobFormat ptDepth; | |
1577 | PPN64 base; | |
1578 | uint32 sizeInBytes; | |
1579 | } | |
1580 | #include "vmware_pack_end.h" | |
1581 | SVGA3dCmdDefineGBMob64; /* SVGA_3D_CMD_DEFINE_GB_MOB64 */ | |
1582 | ||
1583 | /* | |
1584 | * Redefine an object in the OTable with PPN64 base. | |
1585 | */ | |
1586 | ||
1587 | typedef | |
1588 | #include "vmware_pack_begin.h" | |
1589 | struct SVGA3dCmdRedefineGBMob64 { | |
1590 | SVGAMobId mobid; | |
1591 | SVGAMobFormat ptDepth; | |
1592 | PPN64 base; | |
1593 | uint32 sizeInBytes; | |
1594 | } | |
1595 | #include "vmware_pack_end.h" | |
1596 | SVGA3dCmdRedefineGBMob64; /* SVGA_3D_CMD_REDEFINE_GB_MOB64 */ | |
1597 | ||
1598 | /* | |
1599 | * Notification that the page tables have been modified. | |
1600 | */ | |
1601 | ||
1602 | typedef | |
1603 | #include "vmware_pack_begin.h" | |
1604 | struct SVGA3dCmdUpdateGBMobMapping { | |
1605 | SVGAMobId mobid; | |
1606 | } | |
1607 | #include "vmware_pack_end.h" | |
1608 | SVGA3dCmdUpdateGBMobMapping; /* SVGA_3D_CMD_UPDATE_GB_MOB_MAPPING */ | |
1609 | ||
1610 | /* | |
1611 | * Define a guest-backed surface. | |
1612 | */ | |
1613 | ||
1614 | typedef | |
1615 | #include "vmware_pack_begin.h" | |
1616 | struct SVGA3dCmdDefineGBSurface { | |
1617 | uint32 sid; | |
1618 | SVGA3dSurfaceFlags surfaceFlags; | |
1619 | SVGA3dSurfaceFormat format; | |
1620 | uint32 numMipLevels; | |
1621 | uint32 multisampleCount; | |
1622 | SVGA3dTextureFilter autogenFilter; | |
1623 | SVGA3dSize size; | |
1624 | } | |
1625 | #include "vmware_pack_end.h" | |
1626 | SVGA3dCmdDefineGBSurface; /* SVGA_3D_CMD_DEFINE_GB_SURFACE */ | |
1627 | ||
1628 | /* | |
1629 | * Destroy a guest-backed surface. | |
1630 | */ | |
1631 | ||
1632 | typedef | |
1633 | #include "vmware_pack_begin.h" | |
1634 | struct SVGA3dCmdDestroyGBSurface { | |
1635 | uint32 sid; | |
1636 | } | |
1637 | #include "vmware_pack_end.h" | |
1638 | SVGA3dCmdDestroyGBSurface; /* SVGA_3D_CMD_DESTROY_GB_SURFACE */ | |
1639 | ||
1640 | /* | |
1641 | * Bind a guest-backed surface to a mob. | |
1642 | */ | |
1643 | ||
1644 | typedef | |
1645 | #include "vmware_pack_begin.h" | |
1646 | struct SVGA3dCmdBindGBSurface { | |
1647 | uint32 sid; | |
1648 | SVGAMobId mobid; | |
1649 | } | |
1650 | #include "vmware_pack_end.h" | |
1651 | SVGA3dCmdBindGBSurface; /* SVGA_3D_CMD_BIND_GB_SURFACE */ | |
1652 | ||
1653 | typedef | |
1654 | #include "vmware_pack_begin.h" | |
1655 | struct SVGA3dCmdBindGBSurfaceWithPitch { | |
1656 | uint32 sid; | |
1657 | SVGAMobId mobid; | |
1658 | uint32 baseLevelPitch; | |
1659 | } | |
1660 | #include "vmware_pack_end.h" | |
1661 | SVGA3dCmdBindGBSurfaceWithPitch; /* SVGA_3D_CMD_BIND_GB_SURFACE_WITH_PITCH */ | |
1662 | ||
1663 | /* | |
1664 | * Conditionally bind a mob to a guest-backed surface if testMobid | |
1665 | * matches the currently bound mob. Optionally issue a | |
1666 | * readback/update on the surface while it is still bound to the old | |
1667 | * mobid if the mobid is changed by this command. | |
1668 | */ | |
1669 | ||
1670 | #define SVGA3D_COND_BIND_GB_SURFACE_FLAG_READBACK (1 << 0) | |
1671 | #define SVGA3D_COND_BIND_GB_SURFACE_FLAG_UPDATE (1 << 1) | |
1672 | ||
1673 | typedef | |
1674 | #include "vmware_pack_begin.h" | |
1675 | struct{ | |
1676 | uint32 sid; | |
1677 | SVGAMobId testMobid; | |
1678 | SVGAMobId mobid; | |
1679 | uint32 flags; | |
1680 | } | |
1681 | #include "vmware_pack_end.h" | |
1682 | SVGA3dCmdCondBindGBSurface; /* SVGA_3D_CMD_COND_BIND_GB_SURFACE */ | |
1683 | ||
1684 | /* | |
1685 | * Update an image in a guest-backed surface. | |
1686 | * (Inform the device that the guest-contents have been updated.) | |
1687 | */ | |
1688 | ||
1689 | typedef | |
1690 | #include "vmware_pack_begin.h" | |
1691 | struct SVGA3dCmdUpdateGBImage { | |
1692 | SVGA3dSurfaceImageId image; | |
1693 | SVGA3dBox box; | |
1694 | } | |
1695 | #include "vmware_pack_end.h" | |
1696 | SVGA3dCmdUpdateGBImage; /* SVGA_3D_CMD_UPDATE_GB_IMAGE */ | |
1697 | ||
1698 | /* | |
1699 | * Update an entire guest-backed surface. | |
1700 | * (Inform the device that the guest-contents have been updated.) | |
1701 | */ | |
1702 | ||
1703 | typedef | |
1704 | #include "vmware_pack_begin.h" | |
1705 | struct SVGA3dCmdUpdateGBSurface { | |
1706 | uint32 sid; | |
1707 | } | |
1708 | #include "vmware_pack_end.h" | |
1709 | SVGA3dCmdUpdateGBSurface; /* SVGA_3D_CMD_UPDATE_GB_SURFACE */ | |
1710 | ||
1711 | /* | |
1712 | * Readback an image in a guest-backed surface. | |
1713 | * (Request the device to flush the dirty contents into the guest.) | |
1714 | */ | |
1715 | ||
1716 | typedef | |
1717 | #include "vmware_pack_begin.h" | |
1718 | struct SVGA3dCmdReadbackGBImage { | |
1719 | SVGA3dSurfaceImageId image; | |
1720 | } | |
1721 | #include "vmware_pack_end.h" | |
1722 | SVGA3dCmdReadbackGBImage; /* SVGA_3D_CMD_READBACK_GB_IMAGE */ | |
1723 | ||
1724 | /* | |
1725 | * Readback an entire guest-backed surface. | |
1726 | * (Request the device to flush the dirty contents into the guest.) | |
1727 | */ | |
1728 | ||
1729 | typedef | |
1730 | #include "vmware_pack_begin.h" | |
1731 | struct SVGA3dCmdReadbackGBSurface { | |
1732 | uint32 sid; | |
1733 | } | |
1734 | #include "vmware_pack_end.h" | |
1735 | SVGA3dCmdReadbackGBSurface; /* SVGA_3D_CMD_READBACK_GB_SURFACE */ | |
1736 | ||
1737 | /* | |
1738 | * Readback a sub rect of an image in a guest-backed surface. After | |
1739 | * issuing this command the driver is required to issue an update call | |
1740 | * of the same region before issuing any other commands that reference | |
1741 | * this surface or rendering is not guaranteed. | |
1742 | */ | |
1743 | ||
1744 | typedef | |
1745 | #include "vmware_pack_begin.h" | |
1746 | struct SVGA3dCmdReadbackGBImagePartial { | |
1747 | SVGA3dSurfaceImageId image; | |
1748 | SVGA3dBox box; | |
1749 | uint32 invertBox; | |
1750 | } | |
1751 | #include "vmware_pack_end.h" | |
1752 | SVGA3dCmdReadbackGBImagePartial; /* SVGA_3D_CMD_READBACK_GB_IMAGE_PARTIAL */ | |
1753 | ||
1754 | ||
1755 | /* | |
1756 | * Invalidate an image in a guest-backed surface. | |
1757 | * (Notify the device that the contents can be lost.) | |
1758 | */ | |
1759 | ||
1760 | typedef | |
1761 | #include "vmware_pack_begin.h" | |
1762 | struct SVGA3dCmdInvalidateGBImage { | |
1763 | SVGA3dSurfaceImageId image; | |
1764 | } | |
1765 | #include "vmware_pack_end.h" | |
1766 | SVGA3dCmdInvalidateGBImage; /* SVGA_3D_CMD_INVALIDATE_GB_IMAGE */ | |
1767 | ||
1768 | /* | |
1769 | * Invalidate an entire guest-backed surface. | |
1770 | * (Notify the device that the contents if all images can be lost.) | |
1771 | */ | |
1772 | ||
1773 | typedef | |
1774 | #include "vmware_pack_begin.h" | |
1775 | struct SVGA3dCmdInvalidateGBSurface { | |
1776 | uint32 sid; | |
1777 | } | |
1778 | #include "vmware_pack_end.h" | |
1779 | SVGA3dCmdInvalidateGBSurface; /* SVGA_3D_CMD_INVALIDATE_GB_SURFACE */ | |
1780 | ||
1781 | /* | |
1782 | * Invalidate a sub rect of an image in a guest-backed surface. After | |
1783 | * issuing this command the driver is required to issue an update call | |
1784 | * of the same region before issuing any other commands that reference | |
1785 | * this surface or rendering is not guaranteed. | |
1786 | */ | |
1787 | ||
1788 | typedef | |
1789 | #include "vmware_pack_begin.h" | |
1790 | struct SVGA3dCmdInvalidateGBImagePartial { | |
1791 | SVGA3dSurfaceImageId image; | |
1792 | SVGA3dBox box; | |
1793 | uint32 invertBox; | |
1794 | } | |
1795 | #include "vmware_pack_end.h" | |
1796 | SVGA3dCmdInvalidateGBImagePartial; /* SVGA_3D_CMD_INVALIDATE_GB_IMAGE_PARTIAL */ | |
1797 | ||
1798 | ||
1799 | /* | |
1800 | * Define a guest-backed context. | |
1801 | */ | |
1802 | ||
1803 | typedef | |
1804 | #include "vmware_pack_begin.h" | |
1805 | struct SVGA3dCmdDefineGBContext { | |
1806 | uint32 cid; | |
1807 | } | |
1808 | #include "vmware_pack_end.h" | |
1809 | SVGA3dCmdDefineGBContext; /* SVGA_3D_CMD_DEFINE_GB_CONTEXT */ | |
1810 | ||
1811 | /* | |
1812 | * Destroy a guest-backed context. | |
1813 | */ | |
1814 | ||
1815 | typedef | |
1816 | #include "vmware_pack_begin.h" | |
1817 | struct SVGA3dCmdDestroyGBContext { | |
1818 | uint32 cid; | |
1819 | } | |
1820 | #include "vmware_pack_end.h" | |
1821 | SVGA3dCmdDestroyGBContext; /* SVGA_3D_CMD_DESTROY_GB_CONTEXT */ | |
1822 | ||
1823 | /* | |
1824 | * Bind a guest-backed context. | |
1825 | * | |
1826 | * validContents should be set to 0 for new contexts, | |
1827 | * and 1 if this is an old context which is getting paged | |
1828 | * back on to the device. | |
1829 | * | |
1830 | * For new contexts, it is recommended that the driver | |
1831 | * issue commands to initialize all interesting state | |
1832 | * prior to rendering. | |
1833 | */ | |
1834 | ||
1835 | typedef | |
1836 | #include "vmware_pack_begin.h" | |
1837 | struct SVGA3dCmdBindGBContext { | |
1838 | uint32 cid; | |
1839 | SVGAMobId mobid; | |
1840 | uint32 validContents; | |
1841 | } | |
1842 | #include "vmware_pack_end.h" | |
1843 | SVGA3dCmdBindGBContext; /* SVGA_3D_CMD_BIND_GB_CONTEXT */ | |
1844 | ||
1845 | /* | |
1846 | * Readback a guest-backed context. | |
1847 | * (Request that the device flush the contents back into guest memory.) | |
1848 | */ | |
1849 | ||
1850 | typedef | |
1851 | #include "vmware_pack_begin.h" | |
1852 | struct SVGA3dCmdReadbackGBContext { | |
1853 | uint32 cid; | |
1854 | } | |
1855 | #include "vmware_pack_end.h" | |
1856 | SVGA3dCmdReadbackGBContext; /* SVGA_3D_CMD_READBACK_GB_CONTEXT */ | |
1857 | ||
1858 | /* | |
1859 | * Invalidate a guest-backed context. | |
1860 | */ | |
1861 | typedef | |
1862 | #include "vmware_pack_begin.h" | |
1863 | struct SVGA3dCmdInvalidateGBContext { | |
1864 | uint32 cid; | |
1865 | } | |
1866 | #include "vmware_pack_end.h" | |
1867 | SVGA3dCmdInvalidateGBContext; /* SVGA_3D_CMD_INVALIDATE_GB_CONTEXT */ | |
1868 | ||
1869 | /* | |
1870 | * Define a guest-backed shader. | |
1871 | */ | |
1872 | ||
1873 | typedef | |
1874 | #include "vmware_pack_begin.h" | |
1875 | struct SVGA3dCmdDefineGBShader { | |
1876 | uint32 shid; | |
1877 | SVGA3dShaderType type; | |
1878 | uint32 sizeInBytes; | |
1879 | } | |
1880 | #include "vmware_pack_end.h" | |
1881 | SVGA3dCmdDefineGBShader; /* SVGA_3D_CMD_DEFINE_GB_SHADER */ | |
1882 | ||
1883 | /* | |
1884 | * Bind a guest-backed shader. | |
1885 | */ | |
1886 | ||
1887 | typedef | |
1888 | #include "vmware_pack_begin.h" | |
1889 | struct SVGA3dCmdBindGBShader { | |
1890 | uint32 shid; | |
1891 | SVGAMobId mobid; | |
1892 | uint32 offsetInBytes; | |
1893 | } | |
1894 | #include "vmware_pack_end.h" | |
1895 | SVGA3dCmdBindGBShader; /* SVGA_3D_CMD_BIND_GB_SHADER */ | |
1896 | ||
1897 | /* | |
1898 | * Destroy a guest-backed shader. | |
1899 | */ | |
1900 | ||
1901 | typedef | |
1902 | #include "vmware_pack_begin.h" | |
1903 | struct SVGA3dCmdDestroyGBShader { | |
1904 | uint32 shid; | |
1905 | } | |
1906 | #include "vmware_pack_end.h" | |
1907 | SVGA3dCmdDestroyGBShader; /* SVGA_3D_CMD_DESTROY_GB_SHADER */ | |
1908 | ||
1909 | typedef | |
1910 | #include "vmware_pack_begin.h" | |
1911 | struct { | |
1912 | uint32 cid; | |
1913 | uint32 regStart; | |
1914 | SVGA3dShaderType shaderType; | |
1915 | SVGA3dShaderConstType constType; | |
1916 | ||
1917 | /* | |
1918 | * Followed by a variable number of shader constants. | |
1919 | * | |
1920 | * Note that FLOAT and INT constants are 4-dwords in length, while | |
1921 | * BOOL constants are 1-dword in length. | |
1922 | */ | |
1923 | } | |
1924 | #include "vmware_pack_end.h" | |
1925 | SVGA3dCmdSetGBShaderConstInline; /* SVGA_3D_CMD_SET_GB_SHADERCONSTS_INLINE */ | |
1926 | ||
1927 | ||
1928 | typedef | |
1929 | #include "vmware_pack_begin.h" | |
1930 | struct { | |
1931 | uint32 cid; | |
1932 | SVGA3dQueryType type; | |
1933 | } | |
1934 | #include "vmware_pack_end.h" | |
1935 | SVGA3dCmdBeginGBQuery; /* SVGA_3D_CMD_BEGIN_GB_QUERY */ | |
1936 | ||
1937 | typedef | |
1938 | #include "vmware_pack_begin.h" | |
1939 | struct { | |
1940 | uint32 cid; | |
1941 | SVGA3dQueryType type; | |
1942 | SVGAMobId mobid; | |
1943 | uint32 offset; | |
1944 | } | |
1945 | #include "vmware_pack_end.h" | |
1946 | SVGA3dCmdEndGBQuery; /* SVGA_3D_CMD_END_GB_QUERY */ | |
1947 | ||
1948 | ||
1949 | /* | |
1950 | * SVGA_3D_CMD_WAIT_FOR_GB_QUERY -- | |
1951 | * | |
1952 | * The semantics of this command are identical to the | |
1953 | * SVGA_3D_CMD_WAIT_FOR_QUERY except that the results are written | |
1954 | * to a Mob instead of a GMR. | |
1955 | */ | |
1956 | ||
1957 | typedef | |
1958 | #include "vmware_pack_begin.h" | |
1959 | struct { | |
1960 | uint32 cid; | |
1961 | SVGA3dQueryType type; | |
1962 | SVGAMobId mobid; | |
1963 | uint32 offset; | |
1964 | } | |
1965 | #include "vmware_pack_end.h" | |
1966 | SVGA3dCmdWaitForGBQuery; /* SVGA_3D_CMD_WAIT_FOR_GB_QUERY */ | |
1967 | ||
1968 | ||
1969 | typedef | |
1970 | #include "vmware_pack_begin.h" | |
1971 | struct { | |
1972 | SVGAMobId mobid; | |
1973 | uint32 mustBeZero; | |
1974 | uint32 initialized; | |
1975 | } | |
1976 | #include "vmware_pack_end.h" | |
1977 | SVGA3dCmdEnableGart; /* SVGA_3D_CMD_ENABLE_GART */ | |
1978 | ||
1979 | typedef | |
1980 | #include "vmware_pack_begin.h" | |
1981 | struct { | |
1982 | SVGAMobId mobid; | |
1983 | uint32 gartOffset; | |
1984 | } | |
1985 | #include "vmware_pack_end.h" | |
1986 | SVGA3dCmdMapMobIntoGart; /* SVGA_3D_CMD_MAP_MOB_INTO_GART */ | |
1987 | ||
1988 | ||
1989 | typedef | |
1990 | #include "vmware_pack_begin.h" | |
1991 | struct { | |
1992 | uint32 gartOffset; | |
1993 | uint32 numPages; | |
1994 | } | |
1995 | #include "vmware_pack_end.h" | |
1996 | SVGA3dCmdUnmapGartRange; /* SVGA_3D_CMD_UNMAP_GART_RANGE */ | |
1997 | ||
1998 | ||
1999 | /* | |
2000 | * Screen Targets | |
2001 | */ | |
2002 | ||
2003 | typedef | |
2004 | #include "vmware_pack_begin.h" | |
2005 | struct { | |
2006 | uint32 stid; | |
2007 | uint32 width; | |
2008 | uint32 height; | |
2009 | int32 xRoot; | |
2010 | int32 yRoot; | |
2011 | SVGAScreenTargetFlags flags; | |
2012 | ||
2013 | /* | |
2014 | * The physical DPI that the guest expects this screen displayed at. | |
2015 | * | |
2016 | * Guests which are not DPI-aware should set this to zero. | |
2017 | */ | |
2018 | uint32 dpi; | |
2019 | } | |
2020 | #include "vmware_pack_end.h" | |
2021 | SVGA3dCmdDefineGBScreenTarget; /* SVGA_3D_CMD_DEFINE_GB_SCREENTARGET */ | |
2022 | ||
2023 | typedef | |
2024 | #include "vmware_pack_begin.h" | |
2025 | struct { | |
2026 | uint32 stid; | |
2027 | } | |
2028 | #include "vmware_pack_end.h" | |
2029 | SVGA3dCmdDestroyGBScreenTarget; /* SVGA_3D_CMD_DESTROY_GB_SCREENTARGET */ | |
2030 | ||
2031 | typedef | |
2032 | #include "vmware_pack_begin.h" | |
2033 | struct { | |
2034 | uint32 stid; | |
2035 | SVGA3dSurfaceImageId image; | |
2036 | } | |
2037 | #include "vmware_pack_end.h" | |
2038 | SVGA3dCmdBindGBScreenTarget; /* SVGA_3D_CMD_BIND_GB_SCREENTARGET */ | |
2039 | ||
2040 | typedef | |
2041 | #include "vmware_pack_begin.h" | |
2042 | struct { | |
2043 | uint32 stid; | |
2044 | SVGA3dRect rect; | |
2045 | } | |
2046 | #include "vmware_pack_end.h" | |
2047 | SVGA3dCmdUpdateGBScreenTarget; /* SVGA_3D_CMD_UPDATE_GB_SCREENTARGET */ | |
2048 | ||
2049 | typedef | |
2050 | #include "vmware_pack_begin.h" | |
2051 | struct SVGA3dCmdGBScreenDMA { | |
2052 | uint32 screenId; | |
2053 | uint32 dead; | |
2054 | SVGAMobId destMobID; | |
2055 | uint32 destPitch; | |
2056 | SVGAMobId changeMapMobID; | |
2057 | } | |
2058 | #include "vmware_pack_end.h" | |
2059 | SVGA3dCmdGBScreenDMA; /* SVGA_3D_CMD_GB_SCREEN_DMA */ | |
2060 | ||
2061 | typedef | |
2062 | #include "vmware_pack_begin.h" | |
2063 | struct { | |
2064 | uint32 value; | |
2065 | uint32 mobId; | |
2066 | uint32 mobOffset; | |
2067 | } | |
2068 | #include "vmware_pack_end.h" | |
2069 | SVGA3dCmdGBMobFence; /* SVGA_3D_CMD_GB_MOB_FENCE*/ | |
2070 | ||
2071 | #endif /* _SVGA3D_CMD_H_ */ |