DevVGA-SVGA3d-internal.h@ 100108

Last change on this file since 100108 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 58.8 KB

Line
1	/* $Id: DevVGA-SVGA3d-internal.h 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* DevVMWare - VMWare SVGA device - 3D part, internal header.
4	*/
5
6	/*
7	* Copyright (C) 2013-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#ifndef VBOX_INCLUDED_SRC_Graphics_DevVGA_SVGA3d_internal_h
29	#define VBOX_INCLUDED_SRC_Graphics_DevVGA_SVGA3d_internal_h
30	#ifndef RT_WITHOUT_PRAGMA_ONCE
31	# pragma once
32	#endif
33
34	/*
35	* Assert sane compilation environment.
36	*/
37	#ifndef IN_RING3
38	# error "VMSVGA3D_INCL_INTERNALS is only for ring-3 code"
39	#endif
40	#ifdef VMSVGA3D_OPENGL
41	# if defined(VMSVGA3D_DIRECT3D)
42	# error "Both VMSVGA3D_DIRECT3D and VMSVGA3D_OPENGL cannot be defined at the same time."
43	# endif
44	#elif !defined(VMSVGA3D_DIRECT3D)
45	# error "Either VMSVGA3D_OPENGL or VMSVGA3D_DIRECT3D must be defined."
46	#endif
47
48
49	/*********************************************************************************************************************************
50	* Header Files *
51	*********************************************************************************************************************************/
52	#include "DevVGA-SVGA3d.h"
53
54	#if defined(VMSVGA3D_DYNAMIC_LOAD) && defined(VMSVGA3D_OPENGL)
55	# include "DevVGA-SVGA3d-glLdr.h"
56	#endif
57
58	#ifdef RT_OS_WINDOWS
59	# include <iprt/win/windows.h>
60	# ifdef VMSVGA3D_DIRECT3D
61	# include <d3d9.h>
62	# include <iprt/avl.h>
63	# else
64	# include <GL/gl.h>
65	# include "vmsvga_glext/wglext.h"
66	# endif
67
68	#elif defined(RT_OS_DARWIN)
69	# include <OpenGL/OpenGL.h>
70	# include <OpenGL/gl3.h>
71	# include <OpenGL/gl3ext.h>
72	# define GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
73	# include <OpenGL/gl.h>
74	# include "DevVGA-SVGA3d-cocoa.h"
75	/* work around conflicting definition of GLhandleARB in VMware's glext.h */
76	//#define GL_ARB_shader_objects
77	// HACK
78	typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
79	typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture);
80	typedef void (APIENTRYP PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params);
81	# if 0
82	# define GL_RGBA_S3TC 0x83A2
83	# define GL_ALPHA8_EXT 0x803c
84	# define GL_LUMINANCE8_EXT 0x8040
85	# define GL_LUMINANCE16_EXT 0x8042
86	# define GL_LUMINANCE4_ALPHA4_EXT 0x8043
87	# define GL_LUMINANCE8_ALPHA8_EXT 0x8045
88	# define GL_INT_2_10_10_10_REV 0x8D9F
89	# endif
90
91	#else
92	# include <X11/Xlib.h>
93	# include <X11/Xatom.h>
94	# include <GL/gl.h>
95	# include <GL/glx.h>
96	# define VBOX_VMSVGA3D_GL_HACK_LEVEL 0x103
97	#endif
98
99	#ifdef VMSVGA3D_OPENGL
100	# ifndef __glext_h__
101	# undef GL_GLEXT_VERSION /** @todo r=bird: We include GL/glext.h above which also defines this and we'll end up with
102	* a clash if the system one does not use the same header guard as ours. So, I'm wondering
103	* whether this include is really needed, and if it is, whether we should use a unique header
104	* guard macro on it, so we'll have the same problems everywhere... */
105	# endif
106	# include "vmsvga_glext/glext.h"
107	# include "shaderlib/shaderlib.h"
108	#endif
109
110	#ifdef VMSVGA3D_DX
111	#include "DevVGA-SVGA3d-dx-shader.h"
112	#endif
113
114
115	/*********************************************************************************************************************************
116	* Defined Constants And Macros *
117	*********************************************************************************************************************************/
118	#ifdef VMSVGA3D_OPENGL
119	/** OpenGL: Create a dedicated context for handling surfaces in, thus
120	* avoiding orphaned surfaces after context destruction.
121	*
122	* This cures, for instance, an assertion on fedora 21 that happens in
123	* vmsvga3dSurfaceStretchBlt if the login screen and the desktop has different
124	* sizes. The context of the login screen seems to have just been destroyed
125	* earlier and I believe the driver/X/whoever is attemting to strech the old
126	* screen content onto the new sized screen.
127	*
128	* @remarks This probably comes at a slight preformance expense, as we currently
129	* switches context when setting up the surface the first time. Not sure
130	* if we really need to, but as this is an experiment, I'm playing it safe.
131	* @remarks The define has been made default, thus should no longer be used.
132	*/
133	# define VMSVGA3D_OGL_WITH_SHARED_CTX
134	/** Fake surface ID for the shared context. */
135	# define VMSVGA3D_SHARED_CTX_ID UINT32_C(0xffffeeee)
136
137	/** @def VBOX_VMSVGA3D_GL_HACK_LEVEL
138	* Turns out that on Linux gl.h may often define the first 2-4 OpenGL versions
139	* worth of extensions, but missing out on a function pointer of fifteen. This
140	* causes headache for us when we use the function pointers below. This hack
141	* changes the code to call the known problematic functions directly.
142	* The value is ((x)<<16 \| (y)) where x and y are taken from the GL_VERSION_x_y.
143	*/
144	# ifndef VBOX_VMSVGA3D_GL_HACK_LEVEL
145	# define VBOX_VMSVGA3D_GL_HACK_LEVEL 0
146	# endif
147
148	/** Invalid OpenGL ID. */
149	# define OPENGL_INVALID_ID 0
150
151	# define VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState) \
152	do { (pState)->idActiveContext = OPENGL_INVALID_ID; } while (0)
153
154	/** @def VMSVGA3D_SET_CURRENT_CONTEXT
155	* Makes sure the @a pContext is the active OpenGL context.
156	* @parm pState The VMSVGA3d state.
157	* @parm pContext The new context.
158	*/
159	# ifdef RT_OS_WINDOWS
160	# define VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext) \
161	do { \
162	if ((pState)->idActiveContext != (pContext)->id) \
163	{ \
164	BOOL fMakeCurrentRc = wglMakeCurrent((pContext)->hdc, (pContext)->hglrc); \
165	Assert(fMakeCurrentRc == TRUE); RT_NOREF_PV(fMakeCurrentRc); \
166	LogFlowFunc(("Changing context: %#x -> %#x\n", (pState)->idActiveContext, (pContext)->id)); \
167	(pState)->idActiveContext = (pContext)->id; \
168	} \
169	} while (0)
170
171	# elif defined(RT_OS_DARWIN)
172	# define VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext) \
173	do { \
174	if ((pState)->idActiveContext != (pContext)->id) \
175	{ \
176	vmsvga3dCocoaViewMakeCurrentContext((pContext)->cocoaView, (pContext)->cocoaContext); \
177	LogFlowFunc(("Changing context: %#x -> %#x\n", (pState)->idActiveContext, (pContext)->id)); \
178	(pState)->idActiveContext = (pContext)->id; \
179	} \
180	} while (0)
181	# else
182	# define VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext) \
183	do { \
184	if ((pState)->idActiveContext != (pContext)->id) \
185	{ \
186	Bool fMakeCurrentRc = glXMakeCurrent((pState)->display, \
187	(pContext)->window, \
188	(pContext)->glxContext); \
189	Assert(fMakeCurrentRc == True); RT_NOREF_PV(fMakeCurrentRc); \
190	LogFlowFunc(("Changing context: %#x -> %#x\n", (pState)->idActiveContext, (pContext)->id)); \
191	(pState)->idActiveContext = (pContext)->id; \
192	} \
193	} while (0)
194	# endif
195
196	/** @def VMSVGA3D_CLEAR_GL_ERRORS
197	* Clears all pending OpenGL errors.
198	*
199	* If I understood this correctly, OpenGL maintains a bitmask internally and
200	* glGetError gets the next bit (clearing it) from the bitmap and translates it
201	* into a GL_XXX constant value which it then returns. A single OpenGL call can
202	* set more than one bit, and they stick around across calls, from what I
203	* understand.
204	*
205	* So in order to be able to use glGetError to check whether a function
206	* succeeded, we need to call glGetError until all error bits have been cleared.
207	* This macro does that (in all types of builds).
208	*
209	* @sa VMSVGA3D_GET_GL_ERROR, VMSVGA3D_GL_IS_SUCCESS
210	*/
211	# define VMSVGA3D_CLEAR_GL_ERRORS() \
212	do { \
213	if (RT_UNLIKELY(glGetError() != GL_NO_ERROR)) /* predict no errors pending */ \
214	{ \
215	uint32_t iErrorClearingLoopsLeft = 64; \
216	while (glGetError() != GL_NO_ERROR && iErrorClearingLoopsLeft > 0) \
217	iErrorClearingLoopsLeft--; \
218	} \
219	} while (0)
220
221	/** @def VMSVGA3D_GET_LAST_GL_ERROR
222	* Gets the last OpenGL error, stores it in a_pContext->lastError and returns
223	* it.
224	*
225	* @returns Same as glGetError.
226	* @param a_pContext The context to store the error in.
227	*
228	* @sa VMSVGA3D_GL_IS_SUCCESS, VMSVGA3D_GL_COMPLAIN
229	*/
230	# define VMSVGA3D_GET_GL_ERROR(a_pContext) ((a_pContext)->lastError = glGetError())
231
232	/** @def VMSVGA3D_GL_SUCCESS
233	* Checks whether VMSVGA3D_GET_LAST_GL_ERROR() return GL_NO_ERROR.
234	*
235	* Will call glGetError() and store the result in a_pContext->lastError.
236	* Will predict GL_NO_ERROR outcome.
237	*
238	* @returns True on success, false on error.
239	* @parm a_pContext The context to store the error in.
240	*
241	* @sa VMSVGA3D_GET_GL_ERROR, VMSVGA3D_GL_COMPLAIN
242	*/
243	# define VMSVGA3D_GL_IS_SUCCESS(a_pContext) RT_LIKELY((((a_pContext)->lastError = glGetError()) == GL_NO_ERROR))
244
245	/** @def VMSVGA3D_GL_COMPLAIN
246	* Complains about one or more OpenGL errors (first in a_pContext->lastError).
247	*
248	* Strict builds will trigger an assertion, while other builds will put the
249	* first few occurences in the release log.
250	*
251	* All GL errors will be cleared after invocation. Assumes lastError
252	* is an error, will not check for GL_NO_ERROR.
253	*
254	* @param a_pState The 3D state structure.
255	* @param a_pContext The context that holds the first error.
256	* @param a_LogRelDetails Argument list for LogRel or similar that describes
257	* the operation in greater detail.
258	*
259	* @sa VMSVGA3D_GET_GL_ERROR, VMSVGA3D_GL_IS_SUCCESS
260	*/
261	# ifdef VBOX_STRICT
262	# define VMSVGA3D_GL_COMPLAIN(a_pState, a_pContext, a_LogRelDetails) \
263	do { \
264	AssertMsg((a_pState)->idActiveContext == (a_pContext)->id, \
265	("idActiveContext=%#x id=%x\n", (a_pState)->idActiveContext, (a_pContext)->id)); \
266	RTAssertMsg2Weak a_LogRelDetails; \
267	GLenum iNextError; \
268	while ((iNextError = glGetError()) != GL_NO_ERROR) \
269	RTAssertMsg2Weak("next error: %#x\n", iNextError); \
270	AssertMsgFailed(("first error: %#x (idActiveContext=%#x)\n", (a_pContext)->lastError, (a_pContext)->id)); \
271	} while (0)
272	# else
273	# define VMSVGA3D_GL_COMPLAIN(a_pState, a_pContext, a_LogRelDetails) \
274	do { \
275	LogRelMax(32, ("VMSVGA3d: OpenGL error %#x (idActiveContext=%#x) on line %u ", (a_pContext)->lastError, (a_pContext)->id, __LINE__)); \
276	GLenum iNextError; \
277	while ((iNextError = glGetError()) != GL_NO_ERROR) \
278	LogRelMax(32, (" - also error %#x ", iNextError)); \
279	LogRelMax(32, a_LogRelDetails); \
280	} while (0)
281	# endif
282
283	/** @def VMSVGA3D_GL_GET_AND_COMPLAIN
284	* Combination of VMSVGA3D_GET_GL_ERROR and VMSVGA3D_GL_COMPLAIN, assuming that
285	* there is a pending error.
286	*
287	* @param a_pState The 3D state structure.
288	* @param a_pContext The context that holds the first error.
289	* @param a_LogRelDetails Argument list for LogRel or similar that describes
290	* the operation in greater detail.
291	*
292	* @sa VMSVGA3D_GET_GL_ERROR, VMSVGA3D_GL_IS_SUCCESS, VMSVGA3D_GL_COMPLAIN
293	*/
294	# define VMSVGA3D_GL_GET_AND_COMPLAIN(a_pState, a_pContext, a_LogRelDetails) \
295	do { \
296	VMSVGA3D_GET_GL_ERROR(a_pContext); \
297	VMSVGA3D_GL_COMPLAIN(a_pState, a_pContext, a_LogRelDetails); \
298	} while (0)
299
300	/** @def VMSVGA3D_GL_ASSERT_SUCCESS
301	* Asserts that VMSVGA3D_GL_IS_SUCCESS is true, complains if not.
302	*
303	* Uses VMSVGA3D_GL_COMPLAIN for complaining, so check it out wrt to release
304	* logging in non-strict builds.
305	*
306	* @param a_pState The 3D state structure.
307	* @param a_pContext The context that holds the first error.
308	* @param a_LogRelDetails Argument list for LogRel or similar that describes
309	* the operation in greater detail.
310	*
311	* @sa VMSVGA3D_GET_GL_ERROR, VMSVGA3D_GL_IS_SUCCESS, VMSVGA3D_GL_COMPLAIN
312	*/
313	# define VMSVGA3D_GL_ASSERT_SUCCESS(a_pState, a_pContext, a_LogRelDetails) \
314	if (VMSVGA3D_GL_IS_SUCCESS(a_pContext)) \
315	{ /* likely */ } \
316	else do { \
317	VMSVGA3D_GL_COMPLAIN(a_pState, a_pContext, a_LogRelDetails); \
318	} while (0)
319
320	/** @def VMSVGA3D_ASSERT_GL_CALL_EX
321	* Executes the specified OpenGL API call and asserts that it succeeded, variant
322	* with extra logging flexibility.
323	*
324	* ASSUMES no GL errors pending prior to invocation - caller should use
325	* VMSVGA3D_CLEAR_GL_ERRORS if uncertain.
326	*
327	* Uses VMSVGA3D_GL_COMPLAIN for complaining, so check it out wrt to release
328	* logging in non-strict builds.
329	*
330	* @param a_GlCall Expression making an OpenGL call.
331	* @param a_pState The 3D state structure.
332	* @param a_pContext The context that holds the first error.
333	* @param a_LogRelDetails Argument list for LogRel or similar that describes
334	* the operation in greater detail.
335	*
336	* @sa VMSVGA3D_ASSERT_GL_CALL, VMSVGA3D_GL_ASSERT_SUCCESS,
337	* VMSVGA3D_GET_GL_ERROR, VMSVGA3D_GL_IS_SUCCESS, VMSVGA3D_GL_COMPLAIN
338	*/
339	# define VMSVGA3D_ASSERT_GL_CALL_EX(a_GlCall, a_pState, a_pContext, a_LogRelDetails) \
340	do { \
341	(a_GlCall); \
342	VMSVGA3D_GL_ASSERT_SUCCESS(a_pState, a_pContext, a_LogRelDetails); \
343	} while (0)
344
345	/** @def VMSVGA3D_ASSERT_GL_CALL
346	* Executes the specified OpenGL API call and asserts that it succeeded.
347	*
348	* ASSUMES no GL errors pending prior to invocation - caller should use
349	* VMSVGA3D_CLEAR_GL_ERRORS if uncertain.
350	*
351	* Uses VMSVGA3D_GL_COMPLAIN for complaining, so check it out wrt to release
352	* logging in non-strict builds.
353	*
354	* @param a_GlCall Expression making an OpenGL call.
355	* @param a_pState The 3D state structure.
356	* @param a_pContext The context that holds the first error.
357	*
358	* @sa VMSVGA3D_ASSERT_GL_CALL_EX, VMSVGA3D_GL_ASSERT_SUCCESS,
359	* VMSVGA3D_GET_GL_ERROR, VMSVGA3D_GL_IS_SUCCESS, VMSVGA3D_GL_COMPLAIN
360	*/
361	# define VMSVGA3D_ASSERT_GL_CALL(a_GlCall, a_pState, a_pContext) \
362	VMSVGA3D_ASSERT_GL_CALL_EX(a_GlCall, a_pState, a_pContext, ("%s\n", #a_GlCall))
363
364
365	/** @def VMSVGA3D_CHECK_LAST_ERROR
366	* Checks that the last OpenGL error code indicates success.
367	*
368	* Will assert and return VERR_INTERNAL_ERROR in strict builds, in other
369	* builds it will do nothing and is a NOOP.
370	*
371	* @parm pState The VMSVGA3d state.
372	* @parm pContext The context.
373	*
374	* @todo Replace with proper error handling, it's crazy to return
375	* VERR_INTERNAL_ERROR in strict builds and just barge on ahead in
376	* release builds.
377	*/
378	/** @todo Rename to VMSVGA3D_CHECK_LAST_ERROR_RETURN */
379	# ifdef VBOX_STRICT
380	# define VMSVGA3D_CHECK_LAST_ERROR(pState, pContext) do { \
381	Assert((pState)->idActiveContext == (pContext)->id); \
382	(pContext)->lastError = glGetError(); \
383	AssertMsgReturn((pContext)->lastError == GL_NO_ERROR, \
384	("%s (%d): last error 0x%x\n", __FUNCTION__, __LINE__, (pContext)->lastError), \
385	VERR_INTERNAL_ERROR); \
386	} while (0)
387	# else
388	# define VMSVGA3D_CHECK_LAST_ERROR(pState, pContext) do { } while (0)
389	# endif
390
391	/** @def VMSVGA3D_CHECK_LAST_ERROR_WARN
392	* Checks that the last OpenGL error code indicates success.
393	*
394	* Will assert in strict builds, otherwise it's a NOOP.
395	*
396	* @parm pState The VMSVGA3d state.
397	* @parm pContext The new context.
398	*/
399	# ifdef VBOX_STRICT
400	# define VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext) do { \
401	Assert((pState)->idActiveContext == (pContext)->id); \
402	(pContext)->lastError = glGetError(); \
403	AssertMsg((pContext)->lastError == GL_NO_ERROR, ("%s (%d): last error 0x%x\n", __FUNCTION__, __LINE__, (pContext)->lastError)); \
404	} while (0)
405	# else
406	# define VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext) do { } while (0)
407	# endif
408
409	#endif /* VMSVGA3D_OPENGL */
410
411
412	/*********************************************************************************************************************************
413	* Structures and Typedefs *
414	*********************************************************************************************************************************/
415	/**
416	* Mipmap level.
417	*/
418	typedef struct VMSVGA3DMIPMAPLEVEL
419	{
420	/** The mipmap size: width, height and depth. */
421	SVGA3dSize mipmapSize;
422	/** Width in blocks: (width + cxBlock - 1) / cxBlock. SSM: not saved, recalculated on load. */
423	uint32_t cBlocksX;
424	/** Height in blocks: (height + cyBlock - 1) / cyBlock. SSM: not saved, recalculated on load. */
425	uint32_t cBlocksY;
426	/** Number of blocks: cBlocksX * cBlocksY * mipmapSize.depth. SSM: not saved, recalculated on load. */
427	uint32_t cBlocks;
428	/** The scanline/pitch size in bytes: at least cBlocksX * cbBlock. */
429	uint32_t cbSurfacePitch;
430	/** The size (in bytes) of the mipmap plane: cbSurfacePitch * cBlocksY */
431	uint32_t cbSurfacePlane;
432	/** The size (in bytes) of the mipmap data when using the format the surface was
433	* defined with: cbSurfacePlane * mipmapSize.z */
434	uint32_t cbSurface;
435	/** Pointer to the mipmap bytes (cbSurface). Often NULL. If the surface has
436	* been realized in hardware, this may be outdated. */
437	void *pSurfaceData;
438	/** Set if pvSurfaceData contains data not realized in hardware or pushed to the
439	* hardware surface yet. */
440	bool fDirty;
441	} VMSVGA3DMIPMAPLEVEL;
442	/** Pointer to a mipmap level. */
443	typedef VMSVGA3DMIPMAPLEVEL *PVMSVGA3DMIPMAPLEVEL;
444
445
446	#ifdef VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
447	/**
448	* SSM descriptor table for the VMSVGA3DMIPMAPLEVEL structure.
449	*/
450	static SSMFIELD const g_aVMSVGA3DMIPMAPLEVELFields[] =
451	{
452	SSMFIELD_ENTRY( VMSVGA3DMIPMAPLEVEL, mipmapSize),
453	SSMFIELD_ENTRY( VMSVGA3DMIPMAPLEVEL, cbSurface),
454	SSMFIELD_ENTRY( VMSVGA3DMIPMAPLEVEL, cbSurfacePitch),
455	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DMIPMAPLEVEL, pSurfaceData),
456	SSMFIELD_ENTRY_IGNORE( VMSVGA3DMIPMAPLEVEL, fDirty),
457	SSMFIELD_ENTRY_TERM()
458	};
459	#endif
460
461	typedef struct VMSVGATRANSFORMSTATE
462	{
463	bool fValid;
464	float matrix[16];
465	} VMSVGATRANSFORMSTATE;
466	typedef VMSVGATRANSFORMSTATE *PVMSVGATRANSFORMSTATE;
467
468	typedef struct VMSVGAMATERIALSTATE
469	{
470	bool fValid;
471	SVGA3dMaterial material;
472	} VMSVGAMATERIALSTATE;
473	typedef VMSVGAMATERIALSTATE *PVMSVGAMATERIALSTATE;
474
475	typedef struct VMSVGACLIPPLANESTATE
476	{
477	bool fValid;
478	float plane[4];
479	} VMSVGACLIPPLANESTATE;
480	typedef VMSVGACLIPPLANESTATE *PVMSVGACLIPPLANESTATE;
481
482	typedef struct VMSVGALIGHTSTATE
483	{
484	bool fEnabled;
485	bool fValidData;
486	SVGA3dLightData data;
487	} VMSVGALIGHTSTATE;
488	typedef VMSVGALIGHTSTATE *PVMSVGALIGHTSTATE;
489
490	typedef struct VMSVGASHADERCONST
491	{
492	bool fValid;
493	SVGA3dShaderConstType ctype;
494	uint32_t value[4];
495	} VMSVGASHADERCONST;
496	typedef VMSVGASHADERCONST *PVMSVGASHADERCONST;
497
498	#ifdef VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
499	/**
500	* SSM descriptor table for the VMSVGASHADERCONST structure.
501	*/
502	static SSMFIELD const g_aVMSVGASHADERCONSTFields[] =
503	{
504	SSMFIELD_ENTRY( VMSVGASHADERCONST, fValid),
505	SSMFIELD_ENTRY( VMSVGASHADERCONST, ctype),
506	SSMFIELD_ENTRY( VMSVGASHADERCONST, value),
507	SSMFIELD_ENTRY_TERM()
508	};
509	#endif
510
511	#ifdef VMSVGA3D_DIRECT3D
512
513	/* What kind of Direct3D resource has been created for the VMSVGA3D surface. */
514	typedef enum VMSVGA3DD3DRESTYPE
515	{
516	VMSVGA3D_D3DRESTYPE_NONE = 0,
517	VMSVGA3D_D3DRESTYPE_SURFACE = 1,
518	VMSVGA3D_D3DRESTYPE_TEXTURE = 2,
519	VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE = 3,
520	VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE = 4,
521	VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER = 5,
522	VMSVGA3D_D3DRESTYPE_INDEX_BUFFER = 6
523	} VMSVGA3DD3DRESTYPE;
524
525	/**
526	*
527	*/
528	typedef struct
529	{
530	/** Key is context id. */
531	AVLU32NODECORE Core;
532	union
533	{
534	IDirect3DTexture9 *pTexture;
535	IDirect3DCubeTexture9 *pCubeTexture;
536	IDirect3DVolumeTexture9 *pVolumeTexture;
537	} u;
538	} VMSVGA3DSHAREDSURFACE;
539	typedef VMSVGA3DSHAREDSURFACE *PVMSVGA3DSHAREDSURFACE;
540	#endif /* VMSVGA3D_DIRECT3D */
541
542	#ifdef VMSVGA3D_OPENGL
543	/* What kind of OpenGL resource has been created for the VMSVGA3D surface. */
544	typedef enum VMSVGA3DOGLRESTYPE
545	{
546	VMSVGA3D_OGLRESTYPE_NONE = 0,
547	VMSVGA3D_OGLRESTYPE_BUFFER = 1,
548	VMSVGA3D_OGLRESTYPE_TEXTURE = 2,
549	VMSVGA3D_OGLRESTYPE_RENDERBUFFER = 3
550	} VMSVGA3DOGLRESTYPE;
551	#endif
552
553	/* The 3D backend surface. The actual structure is 3D API specific. */
554	typedef struct VMSVGA3DBACKENDSURFACE *PVMSVGA3DBACKENDSURFACE;
555
556	/**
557	* VMSVGA3d surface.
558	*/
559	typedef struct VMSVGA3DSURFACE
560	{
561	PVMSVGA3DBACKENDSURFACE pBackendSurface;
562
563	uint32_t id; /** @todo sid */
564	/* Which context created the corresponding resource.
565	* SVGA_ID_INVALID means that resource has not been created yet.
566	* A resource has been created if VMSVGA3DSURFACE_HAS_HW_SURFACE is true.
567	*
568	*/
569	uint32_t idAssociatedContext;
570
571	/** @todo Only numArrayElements field is used currently. The code uses old fields cLevels, etc for anything else. */
572	VMSVGA3D_SURFACE_DESC surfaceDesc;
573
574	union
575	{
576	struct
577	{
578	SVGA3dSurface1Flags surface1Flags;
579	SVGA3dSurface2Flags surface2Flags;
580	} s;
581	SVGA3dSurfaceAllFlags surfaceFlags;
582	} f;
583	SVGA3dSurfaceFormat format;
584	#ifdef VMSVGA3D_OPENGL
585	GLint internalFormatGL;
586	GLint formatGL;
587	GLint typeGL;
588	VMSVGA3DOGLRESTYPE enmOGLResType; /* Which resource was created for the surface. */
589	union
590	{
591	GLuint texture;
592	GLuint buffer;
593	GLuint renderbuffer;
594	} oglId;
595	GLenum targetGL; /* GL_TEXTURE_* */
596	GLenum bindingGL; /* GL_TEXTURE_BINDING_* */
597	/* Emulated formats */
598	bool fEmulated; /* Whether the texture format is emulated. */
599	GLuint idEmulated; /* GL name of the intermediate texture. */
600	#endif
601	uint32_t cFaces; /* Number of faces: 6 for cubemaps, 1 for everything else. */
602	uint32_t cLevels; /* Number of mipmap levels per face. */
603	PVMSVGA3DMIPMAPLEVEL paMipmapLevels; /* surfaceDesc.numArrayElements * cLevels elements. */
604	uint32_t multiSampleCount;
605	SVGA3dTextureFilter autogenFilter;
606	#ifdef VMSVGA3D_DIRECT3D
607	D3DFORMAT formatD3D;
608	DWORD fUsageD3D;
609	D3DMULTISAMPLE_TYPE multiSampleTypeD3D;
610	#endif
611
612	uint32_t cbBlock; /* block/pixel size in bytes */
613	/* Dimensions of the surface block, usually 1x1 except for compressed formats. */
614	uint32_t cxBlock; /* Block width in pixels. SSM: not saved, recalculated on load. */
615	uint32_t cyBlock; /* Block height in pixels. SSM: not saved, recalculated on load. */
616	#ifdef VMSVGA3D_OPENGL
617	uint32_t cbBlockGL; /* Block size of the OpenGL texture, same as cbBlock for not-emulated formats. */
618	#endif
619
620	/* Dirty state; surface was manually updated. */
621	bool fDirty;
622
623	#ifdef VMSVGA3D_DIRECT3D
624	/* Handle for shared objects (currently only textures & render targets). */
625	HANDLE hSharedObject;
626	/** Event query inserted after each GPU operation that updates or uses this surface. */
627	IDirect3DQuery9 *pQuery;
628	/** The context id where the query has been created. */
629	uint32_t idQueryContext;
630	/** The type of actually created D3D resource. */
631	VMSVGA3DD3DRESTYPE enmD3DResType;
632	union
633	{
634	IDirect3DSurface9 *pSurface;
635	IDirect3DTexture9 *pTexture;
636	IDirect3DCubeTexture9 *pCubeTexture;
637	IDirect3DVolumeTexture9 *pVolumeTexture;
638	IDirect3DVertexBuffer9 *pVertexBuffer;
639	IDirect3DIndexBuffer9 *pIndexBuffer;
640	} u;
641	union
642	{
643	IDirect3DTexture9 *pTexture;
644	IDirect3DCubeTexture9 *pCubeTexture;
645	IDirect3DVolumeTexture9 *pVolumeTexture;
646	} bounce;
647	/** AVL tree containing VMSVGA3DSHAREDSURFACE structures. */
648	AVLU32TREE pSharedObjectTree;
649	bool fStencilAsTexture;
650	D3DFORMAT d3dfmtRequested;
651	union
652	{
653	IDirect3DTexture9 *pTexture;
654	IDirect3DCubeTexture9 *pCubeTexture;
655	IDirect3DVolumeTexture9 *pVolumeTexture;
656	} emulated;
657	#endif
658	} VMSVGA3DSURFACE;
659	/** Pointer to a 3d surface. */
660	typedef VMSVGA3DSURFACE *PVMSVGA3DSURFACE;
661
662	#ifdef VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
663	/**
664	* SSM descriptor table for the VMSVGA3DSURFACE structure.
665	*/
666	static SSMFIELD const g_aVMSVGA3DSURFACEFields[] =
667	{
668	SSMFIELD_ENTRY( VMSVGA3DSURFACE, id),
669	SSMFIELD_ENTRY( VMSVGA3DSURFACE, idAssociatedContext),
670	SSMFIELD_ENTRY( VMSVGA3DSURFACE, f.s.surface1Flags),
671	SSMFIELD_ENTRY_VER( VMSVGA3DSURFACE, f.s.surface2Flags, VGA_SAVEDSTATE_VERSION_VMSVGA_DX_SFLAGS),
672	SSMFIELD_ENTRY( VMSVGA3DSURFACE, format),
673	# ifdef VMSVGA3D_OPENGL
674	SSMFIELD_ENTRY( VMSVGA3DSURFACE, internalFormatGL),
675	SSMFIELD_ENTRY( VMSVGA3DSURFACE, formatGL),
676	SSMFIELD_ENTRY( VMSVGA3DSURFACE, typeGL),
677	# endif
678	SSMFIELD_ENTRY( VMSVGA3DSURFACE, cFaces),
679	SSMFIELD_ENTRY( VMSVGA3DSURFACE, cLevels),
680	SSMFIELD_ENTRY( VMSVGA3DSURFACE, multiSampleCount),
681	SSMFIELD_ENTRY( VMSVGA3DSURFACE, autogenFilter),
682	SSMFIELD_ENTRY( VMSVGA3DSURFACE, cbBlock),
683	SSMFIELD_ENTRY_TERM()
684	};
685	#endif
686
687	/** Mask we frequently apply to VMSVGA3DSURFACE::flags for decing what kind
688	* of surface we're dealing. */
689	#define VMSVGA3D_SURFACE_HINT_SWITCH_MASK \
690	( SVGA3D_SURFACE_HINT_INDEXBUFFER \| SVGA3D_SURFACE_HINT_VERTEXBUFFER \
691	\| SVGA3D_SURFACE_HINT_TEXTURE \| SVGA3D_SURFACE_HINT_RENDERTARGET \
692	\| SVGA3D_SURFACE_HINT_DEPTHSTENCIL \| SVGA3D_SURFACE_CUBEMAP )
693
694	/** @def VMSVGA3DSURFACE_HAS_HW_SURFACE
695	* Checks whether the surface has a host hardware/library surface.
696	* @returns true/false
697	* @param a_pSurface The VMSVGA3d surface.
698	*/
699	#ifdef VMSVGA3D_DIRECT3D
700	# define VMSVGA3DSURFACE_HAS_HW_SURFACE(a_pSurface) ((a_pSurface)->pBackendSurface != NULL \|\| (a_pSurface)->u.pSurface != NULL)
701	#else
702	# define VMSVGA3DSURFACE_HAS_HW_SURFACE(a_pSurface) ((a_pSurface)->pBackendSurface != NULL \|\| (a_pSurface)->oglId.texture != OPENGL_INVALID_ID)
703	#endif
704
705	/** @def VMSVGA3DSURFACE_NEEDS_DATA
706	* Checks whether SurfaceDMA transfers must always update pSurfaceData,
707	* even if the surface has a host hardware resource.
708	* @returns true/false
709	* @param a_pSurface The VMSVGA3d surface.
710	*/
711	#ifdef VMSVGA3D_DIRECT3D
712	# define VMSVGA3DSURFACE_NEEDS_DATA(a_pSurface) \
713	( (a_pSurface)->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER \
714	\|\| (a_pSurface)->enmD3DResType == VMSVGA3D_D3DRESTYPE_INDEX_BUFFER)
715	#else
716	# define VMSVGA3DSURFACE_NEEDS_DATA(a_pSurface) \
717	((a_pSurface)->enmOGLResType == VMSVGA3D_OGLRESTYPE_BUFFER)
718	#endif
719
720
721	typedef struct VMSVGA3DSHADER
722	{
723	uint32_t id; /** @todo Rename to shid. */
724	uint32_t cid;
725	SVGA3dShaderType type;
726	uint32_t cbData;
727	void *pShaderProgram;
728	union
729	{
730	#ifdef VMSVGA3D_DIRECT3D
731	IDirect3DVertexShader9 *pVertexShader;
732	IDirect3DPixelShader9 *pPixelShader;
733	#else
734	void *pVertexShader;
735	void *pPixelShader;
736	#endif
737	} u;
738	} VMSVGA3DSHADER;
739	typedef VMSVGA3DSHADER *PVMSVGA3DSHADER;
740
741	#ifdef VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
742	/**
743	* SSM descriptor table for the VMSVGA3DSHADER structure.
744	*/
745	static SSMFIELD const g_aVMSVGA3DSHADERFields[] =
746	{
747	SSMFIELD_ENTRY( VMSVGA3DSHADER, id),
748	SSMFIELD_ENTRY( VMSVGA3DSHADER, cid),
749	SSMFIELD_ENTRY( VMSVGA3DSHADER, type),
750	SSMFIELD_ENTRY( VMSVGA3DSHADER, cbData),
751	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSHADER, pShaderProgram),
752	SSMFIELD_ENTRY_TERM()
753	};
754	#endif
755
756	/** @name VMSVGA3D_UPDATE_XXX - ...
757	* @{ */
758	#define VMSVGA3D_UPDATE_SCISSORRECT RT_BIT_32(0)
759	#define VMSVGA3D_UPDATE_ZRANGE RT_BIT_32(1)
760	#define VMSVGA3D_UPDATE_VIEWPORT RT_BIT_32(2)
761	#define VMSVGA3D_UPDATE_VERTEXSHADER RT_BIT_32(3)
762	#define VMSVGA3D_UPDATE_PIXELSHADER RT_BIT_32(4)
763	#define VMSVGA3D_UPDATE_TRANSFORM RT_BIT_32(5)
764	#define VMSVGA3D_UPDATE_MATERIAL RT_BIT_32(6)
765	/** @} */
766
767	/* Query states. Mostly used for saved state. */
768	typedef enum VMSVGA3DQUERYSTATE
769	{
770	VMSVGA3DQUERYSTATE_NULL = 0, /* Not created. */
771	VMSVGA3DQUERYSTATE_SIGNALED = 1, /* Result obtained. The guest may or may not read the result yet. */
772	VMSVGA3DQUERYSTATE_BUILDING = 2, /* In process of collecting data. */
773	VMSVGA3DQUERYSTATE_ISSUED = 3, /* Data collected, but result is not yet obtained. */
774	VMSVGA3DQUERYSTATE_32BIT = 0x7fffffff
775	} VMSVGA3DQUERYSTATE;
776	AssertCompileSize(VMSVGA3DQUERYSTATE, sizeof(uint32_t));
777
778	typedef struct VMSVGA3DQUERY
779	{
780	#ifdef VMSVGA3D_DIRECT3D
781	IDirect3DQuery9 *pQuery;
782	#else /* VMSVGA3D_OPENGL */
783	GLuint idQuery;
784	#endif
785	VMSVGA3DQUERYSTATE enmQueryState; /* VMSVGA3DQUERYSTATE_. State is implicitly _NULL if pQuery is NULL. /
786	uint32_t u32QueryResult; /* Generic result. Enough for all VGPU9 queries. */
787	} VMSVGA3DQUERY;
788
789	#ifdef VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
790	/**
791	* SSM descriptor table for the VMSVGA3DQUERY structure.
792	*/
793	static SSMFIELD const g_aVMSVGA3DQUERYFields[] =
794	{
795	#ifdef VMSVGA3D_DIRECT3D
796	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DQUERY, pQuery),
797	#else /* VMSVGA3D_OPENGL */
798	SSMFIELD_ENTRY_IGNORE( VMSVGA3DQUERY, idQuery),
799	#endif
800	SSMFIELD_ENTRY( VMSVGA3DQUERY, enmQueryState),
801	SSMFIELD_ENTRY( VMSVGA3DQUERY, u32QueryResult),
802	SSMFIELD_ENTRY_TERM()
803	};
804	#endif
805
806	#ifdef VMSVGA3D_DIRECT3D
807	#define VMSVGA3DQUERY_EXISTS(p) ((p)->pQuery && (p)->enmQueryState != VMSVGA3DQUERYSTATE_NULL)
808	#else
809	#define VMSVGA3DQUERY_EXISTS(p) ((p)->idQuery && (p)->enmQueryState != VMSVGA3DQUERYSTATE_NULL)
810	#endif
811
812	/**
813	* VMSVGA3d context.
814	*/
815	typedef struct VMSVGA3DCONTEXT
816	{
817	/** @todo Legacy contexts with DX backend. */
818
819	uint32_t id;
820	#ifdef RT_OS_WINDOWS
821	# ifdef VMSVGA3D_DIRECT3D
822	IDirect3DDevice9Ex *pDevice;
823	# else
824	/* Device context of the context window. */
825	HDC hdc;
826	/* OpenGL rendering context handle. */
827	HGLRC hglrc;
828	# endif
829	/* Device context window handle. */
830	HWND hwnd;
831	#elif defined(RT_OS_DARWIN)
832	/* OpenGL rendering context */
833	NativeNSOpenGLContextRef cocoaContext;
834	NativeNSViewRef cocoaView;
835	bool fOtherProfile;
836	#else
837	/** XGL rendering context handle */
838	GLXContext glxContext;
839	/** Device context window handle */
840	Window window;
841	#endif
842
843	#ifdef VMSVGA3D_OPENGL
844	/* Framebuffer object associated with this context. */
845	GLuint idFramebuffer;
846	/* Read and draw framebuffer objects for various operations. */
847	GLuint idReadFramebuffer;
848	GLuint idDrawFramebuffer;
849	/* Last GL error recorded. */
850	GLenum lastError;
851	void *pShaderContext;
852	#endif
853
854	/* Current selected texture surfaces (if any) */
855	uint32_t aSidActiveTextures[SVGA3D_MAX_SAMPLERS];
856	/* Per context pixel and vertex shaders. */
857	uint32_t cPixelShaders;
858	PVMSVGA3DSHADER paPixelShader;
859	uint32_t cVertexShaders;
860	PVMSVGA3DSHADER paVertexShader;
861	/* Keep track of the internal state to be able to recreate the context properly (save/restore, window resize). */
862	struct
863	{
864	/** VMSVGA3D_UPDATE_XXX */
865	uint32_t u32UpdateFlags;
866
867	SVGA3dRenderState aRenderState[SVGA3D_RS_MAX];
868	/* aTextureStates contains both TextureStageStates and SamplerStates, therefore [SVGA3D_MAX_SAMPLERS]. */
869	SVGA3dTextureState aTextureStates[SVGA3D_MAX_SAMPLERS][SVGA3D_TS_MAX];
870	VMSVGATRANSFORMSTATE aTransformState[SVGA3D_TRANSFORM_MAX];
871	VMSVGAMATERIALSTATE aMaterial[SVGA3D_FACE_MAX];
872	/* The aClipPlane array has a wrong (greater) size. Keep it for now because the array is a part of the saved state. */
873	/** @todo Replace SVGA3D_CLIPPLANE_5 with SVGA3D_NUM_CLIPPLANES and increase the saved state version. */
874	VMSVGACLIPPLANESTATE aClipPlane[SVGA3D_CLIPPLANE_5];
875	VMSVGALIGHTSTATE aLightData[SVGA3D_MAX_LIGHTS];
876
877	uint32_t aRenderTargets[SVGA3D_RT_MAX];
878	SVGA3dRect RectScissor;
879	SVGA3dRect RectViewPort;
880	SVGA3dZRange zRange;
881	uint32_t shidPixel;
882	uint32_t shidVertex;
883
884	uint32_t cPixelShaderConst;
885	PVMSVGASHADERCONST paPixelShaderConst;
886	uint32_t cVertexShaderConst;
887	PVMSVGASHADERCONST paVertexShaderConst;
888	} state;
889
890	/* Occlusion query. */
891	VMSVGA3DQUERY occlusion;
892
893	#ifdef VMSVGA3D_DIRECT3D
894	/* State which is currently applied to the D3D device. It is recreated as needed and not saved.
895	* The purpose is to remember the currently applied state and do not re-apply it if it has not changed.
896	* Unnecessary state changes are very bad for performance.
897	*/
898	struct
899	{
900	/* Vertex declaration. */
901	IDirect3DVertexDeclaration9 *pVertexDecl;
902	uint32_t cVertexElements;
903	D3DVERTEXELEMENT9 aVertexElements[SVGA3D_MAX_VERTEX_ARRAYS + 1];
904	} d3dState;
905	#endif
906	} VMSVGA3DCONTEXT;
907	/** Pointer to a VMSVGA3d context. */
908	typedef VMSVGA3DCONTEXT *PVMSVGA3DCONTEXT;
909
910	#ifdef VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
911	/* Verify that constants did not change for the legacy context saved state data. */
912	AssertCompile(SVGA3D_RS_MAX == 99);
913	AssertCompile(SVGA3D_TRANSFORM_MAX == 15);
914	AssertCompile(SVGA3D_FACE_MAX == 5);
915	AssertCompile(SVGA3D_CLIPPLANE_5 == (1 << 5));
916	AssertCompile(SVGA3D_MAX_LIGHTS == 32);
917	AssertCompile(SVGA3D_RT_MAX == 10);
918
919	/**
920	* SSM descriptor table for the VMSVGA3DCONTEXT structure.
921	*/
922	static SSMFIELD const g_aVMSVGA3DCONTEXTFields[] =
923	{
924	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, id),
925
926	# ifdef RT_OS_WINDOWS
927	# ifdef VMSVGA3D_DIRECT3D
928	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, pDevice),
929	# else
930	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, hdc),
931	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, hglrc),
932	# endif
933	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, hwnd),
934	# elif defined(RT_OS_DARWIN)
935	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, cocoaContext),
936	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, cocoaView),
937	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, fOtherProfile),
938	# else
939	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, glxContext),
940	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, window),
941	# endif
942
943	#ifdef VMSVGA3D_OPENGL
944	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, idFramebuffer),
945	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, idReadFramebuffer),
946	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, idDrawFramebuffer),
947	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, lastError),
948	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, pShaderContext),
949	#endif
950
951	SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, aSidActiveTextures),
952	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, cPixelShaders),
953	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, paPixelShader),
954	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, cVertexShaders),
955	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, paVertexShader),
956	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.u32UpdateFlags),
957
958	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aRenderState),
959	SSMFIELD_ENTRY_OLD( state.aTextureStates,
960	sizeof(SVGA3dTextureState) * /SVGA3D_MAX_TEXTURE_STAGE=/ 8 * /SVGA3D_TS_MAX=/ 30),
961	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aTransformState),
962	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aMaterial),
963	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aClipPlane),
964	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aLightData),
965
966	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aRenderTargets),
967	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.RectScissor),
968	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.RectViewPort),
969	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.zRange),
970	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.shidPixel),
971	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.shidVertex),
972	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.cPixelShaderConst),
973	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, state.paPixelShaderConst),
974	SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.cVertexShaderConst),
975	SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, state.paVertexShaderConst),
976	SSMFIELD_ENTRY_TERM()
977	};
978	#endif /* VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS */
979
980
981	#ifdef VMSVGA3D_DX
982	/* The 3D backend DX context. The actual structure is 3D API specific. */
983	typedef struct VMSVGA3DBACKENDDXCONTEXT *PVMSVGA3DBACKENDDXCONTEXT;
984
985	/**
986	* VMSVGA3D DX context (VGPU10+). DX contexts ids are a separate namespace from legacy context ids.
987	*/
988	typedef struct VMSVGA3DDXCONTEXT
989	{
990	/** The DX context id. */
991	uint32_t cid;
992	/** . */
993	uint32_t u32Reserved;
994	/** . */
995	uint32_t cRenderTargets;
996	/** Backend specific data. */
997	PVMSVGA3DBACKENDDXCONTEXT pBackendDXContext;
998	/** Copy of the guest memory for this context. The guest will be updated on unbind. */
999	SVGADXContextMobFormat svgaDXContext;
1000	/* Context-Object Tables bound to this context. */
1001	PVMSVGAMOB aCOTMobs[SVGA_COTABLE_MAX];
1002	struct
1003	{
1004	SVGACOTableDXRTViewEntry *paRTView;
1005	SVGACOTableDXDSViewEntry *paDSView;
1006	SVGACOTableDXSRViewEntry *paSRView;
1007	SVGACOTableDXElementLayoutEntry *paElementLayout;
1008	SVGACOTableDXBlendStateEntry *paBlendState;
1009	SVGACOTableDXDepthStencilEntry *paDepthStencil;
1010	SVGACOTableDXRasterizerStateEntry *paRasterizerState;
1011	SVGACOTableDXSamplerEntry *paSampler;
1012	SVGACOTableDXStreamOutputEntry *paStreamOutput;
1013	SVGACOTableDXQueryEntry *paQuery;
1014	SVGACOTableDXShaderEntry *paShader;
1015	SVGACOTableDXUAViewEntry *paUAView;
1016	uint32_t cRTView;
1017	uint32_t cDSView;
1018	uint32_t cSRView;
1019	uint32_t cElementLayout;
1020	uint32_t cBlendState;
1021	uint32_t cDepthStencil;
1022	uint32_t cRasterizerState;
1023	uint32_t cSampler;
1024	uint32_t cStreamOutput;
1025	uint32_t cQuery;
1026	uint32_t cShader;
1027	uint32_t cUAView;
1028	} cot;
1029	} VMSVGA3DDXCONTEXT;
1030	/** Pointer to a VMSVGA3D DX context. */
1031	typedef VMSVGA3DDXCONTEXT *PVMSVGA3DDXCONTEXT;
1032	#endif /* VMSVGA3D_DX */
1033
1034
1035	#ifdef VMSVGA3D_OPENGL
1036	typedef struct VMSVGA3DFORMATCONVERTER *PVMSVGA3DFORMATCONVERTER;
1037	#endif
1038
1039	/* The 3D backend. The actual structure is 3D API specific. */
1040	typedef struct VMSVGA3DBACKEND *PVMSVGA3DBACKEND;
1041
1042	/**
1043	* VMSVGA3d state data.
1044	*
1045	* Allocated on the heap and pointed to by VMSVGAState::p3dState.
1046	*/
1047	typedef struct VMSVGA3DSTATE
1048	{
1049	/** Backend specific data. */
1050	PVMSVGA3DBACKEND pBackend;
1051
1052	/** The size of papContexts. */
1053	uint32_t cContexts;
1054	/** The size of papSurfaces. */
1055	uint32_t cSurfaces;
1056	#ifdef VMSVGA3D_DX
1057	/** The size of papDXContexts. */
1058	uint32_t cDXContexts;
1059	/** Reserved. */
1060	uint32_t u32Reserved;
1061	#endif
1062	/** Contexts indexed by ID. Grown as needed. */
1063	PVMSVGA3DCONTEXT *papContexts;
1064	/** Surfaces indexed by ID. Grown as needed. */
1065	PVMSVGA3DSURFACE *papSurfaces;
1066	#ifdef VMSVGA3D_DX
1067	/** DX contexts indexed by ID. Grown as needed. */
1068	PVMSVGA3DDXCONTEXT *papDXContexts;
1069	#endif
1070
1071	#ifdef RT_OS_WINDOWS
1072	# ifdef VMSVGA3D_DIRECT3D
1073	IDirect3D9Ex *pD3D9;
1074	D3DCAPS9 caps;
1075	bool fSupportedSurfaceINTZ;
1076	bool fSupportedSurfaceNULL;
1077	bool fSupportedFormatUYVY : 1;
1078	bool fSupportedFormatYUY2 : 1;
1079	bool fSupportedFormatA8B8G8R8 : 1;
1080	# endif
1081	/** Window Thread. */
1082	R3PTRTYPE(RTTHREAD) pWindowThread;
1083	DWORD idWindowThread;
1084	HMODULE hInstance;
1085	/** Window request semaphore. */
1086	RTSEMEVENT WndRequestSem;
1087	#elif defined(RT_OS_DARWIN)
1088	#else
1089	/* The X display */
1090	Display *display;
1091	R3PTRTYPE(RTTHREAD) pWindowThread;
1092	bool bTerminate;
1093	#endif
1094
1095	#ifdef VMSVGA3D_OPENGL
1096	float rsGLVersion;
1097	/* Current active context. */
1098	uint32_t idActiveContext;
1099
1100	struct
1101	{
1102	PFNGLISRENDERBUFFERPROC glIsRenderbuffer;
1103	PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer;
1104	PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers;
1105	PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers;
1106	PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage;
1107	PFNGLGETRENDERBUFFERPARAMETERIVPROC glGetRenderbufferParameteriv;
1108	PFNGLISFRAMEBUFFERPROC glIsFramebuffer;
1109	PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer;
1110	PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers;
1111	PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers;
1112	PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus;
1113	PFNGLFRAMEBUFFERTEXTURE1DPROC glFramebufferTexture1D;
1114	PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D;
1115	PFNGLFRAMEBUFFERTEXTURE3DPROC glFramebufferTexture3D;
1116	PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer;
1117	PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glGetFramebufferAttachmentParameteriv;
1118	PFNGLGENERATEMIPMAPPROC glGenerateMipmap;
1119	PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer;
1120	PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample;
1121	PFNGLFRAMEBUFFERTEXTURELAYERPROC glFramebufferTextureLayer;
1122	PFNGLPOINTPARAMETERFPROC glPointParameterf;
1123	#if VBOX_VMSVGA3D_GL_HACK_LEVEL < 0x102
1124	PFNGLBLENDCOLORPROC glBlendColor;
1125	PFNGLBLENDEQUATIONPROC glBlendEquation;
1126	#endif
1127	PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate;
1128	PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate;
1129	PFNGLSTENCILOPSEPARATEPROC glStencilOpSeparate;
1130	PFNGLSTENCILFUNCSEPARATEPROC glStencilFuncSeparate;
1131	PFNGLBINDBUFFERPROC glBindBuffer;
1132	PFNGLDELETEBUFFERSPROC glDeleteBuffers;
1133	PFNGLGENBUFFERSPROC glGenBuffers;
1134	PFNGLBUFFERDATAPROC glBufferData;
1135	PFNGLMAPBUFFERPROC glMapBuffer;
1136	PFNGLUNMAPBUFFERPROC glUnmapBuffer;
1137	PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
1138	PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
1139	PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
1140	PFNGLFOGCOORDPOINTERPROC glFogCoordPointer;
1141	PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glDrawElementsInstancedBaseVertex;
1142	PFNGLDRAWELEMENTSBASEVERTEXPROC glDrawElementsBaseVertex;
1143	PFNGLACTIVETEXTUREPROC glActiveTexture;
1144	#if VBOX_VMSVGA3D_GL_HACK_LEVEL < 0x103
1145	PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture;
1146	#endif
1147	PFNGLGETPROGRAMIVARBPROC glGetProgramivARB;
1148	PFNGLPROVOKINGVERTEXPROC glProvokingVertex;
1149	PFNGLGENQUERIESPROC glGenQueries;
1150	PFNGLDELETEQUERIESPROC glDeleteQueries;
1151	PFNGLBEGINQUERYPROC glBeginQuery;
1152	PFNGLENDQUERYPROC glEndQuery;
1153	PFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv;
1154	PFNGLTEXIMAGE3DPROC glTexImage3D;
1155	PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D;
1156	PFNGLVERTEXATTRIBDIVISORPROC glVertexAttribDivisor;
1157	PFNGLDRAWARRAYSINSTANCEDPROC glDrawArraysInstanced;
1158	PFNGLDRAWELEMENTSINSTANCEDPROC glDrawElementsInstanced;
1159	PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage;
1160	PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D;
1161	PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D;
1162	PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D;
1163	PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D;
1164	PFNGLDRAWBUFFERSPROC glDrawBuffers;
1165	PFNGLCREATESHADERPROC glCreateShader;
1166	PFNGLSHADERSOURCEPROC glShaderSource;
1167	PFNGLCOMPILESHADERPROC glCompileShader;
1168	PFNGLGETSHADERIVPROC glGetShaderiv;
1169	PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
1170	PFNGLCREATEPROGRAMPROC glCreateProgram;
1171	PFNGLATTACHSHADERPROC glAttachShader;
1172	PFNGLLINKPROGRAMPROC glLinkProgram;
1173	PFNGLGETPROGRAMIVPROC glGetProgramiv;
1174	PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
1175	PFNGLUSEPROGRAMPROC glUseProgram;
1176	PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
1177	PFNGLUNIFORM1IPROC glUniform1i;
1178	PFNGLUNIFORM4FVPROC glUniform4fv;
1179	PFNGLDETACHSHADERPROC glDetachShader;
1180	PFNGLDELETESHADERPROC glDeleteShader;
1181	PFNGLDELETEPROGRAMPROC glDeleteProgram;
1182	PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv;
1183	PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv;
1184	PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv;
1185	PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv;
1186	PFNGLVERTEXATTRIB4NSVPROC glVertexAttrib4Nsv;
1187	PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv;
1188	} ext;
1189
1190	struct
1191	{
1192	bool fS3TCSupported : 1;
1193	bool fTextureFilterAnisotropicSupported : 1;
1194	GLint maxActiveLights;
1195	GLint maxTextures;
1196	GLint maxClipDistances;
1197	GLint maxColorAttachments;
1198	GLint maxRectangleTextureSize;
1199	GLint maxTextureAnisotropy;
1200	GLint maxVertexShaderInstructions;
1201	GLint maxFragmentShaderInstructions;
1202	GLint maxVertexShaderTemps;
1203	GLint maxFragmentShaderTemps;
1204	GLfloat flPointSize[2];
1205	SVGA3dPixelShaderVersion fragmentShaderVersion;
1206	SVGA3dVertexShaderVersion vertexShaderVersion;
1207	} caps;
1208
1209	/** The GL_EXTENSIONS value (space padded) for the default OpenGL profile.
1210	* Free with RTStrFree. */
1211	R3PTRTYPE(char *) pszExtensions;
1212
1213	/** The GL_EXTENSIONS value (space padded) for the other OpenGL profile.
1214	* Free with RTStrFree.
1215	*
1216	* This is used to detect shader model version since some implementations
1217	* (darwin) hides extensions that have made it into core and probably a
1218	* bunch of others when using a OpenGL core profile instead of a legacy one */
1219	R3PTRTYPE(char *) pszOtherExtensions;
1220	/** The version of the other GL profile. */
1221	float rsOtherGLVersion;
1222
1223	/** Shader talk back interface. */
1224	VBOXVMSVGASHADERIF ShaderIf;
1225
1226	# ifdef VMSVGA3D_OPENGL
1227	/** The shared context. */
1228	VMSVGA3DCONTEXT SharedCtx;
1229
1230	/** Conversion of emulated formats. Resources are created on the SharedCtx. */
1231	PVMSVGA3DFORMATCONVERTER pConv;
1232	# endif
1233	#endif /* VMSVGA3D_OPENGL */
1234	} VMSVGA3DSTATE;
1235
1236	#ifdef VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
1237	/**
1238	* SSM descriptor table for the VMSVGA3DSTATE structure.
1239	*
1240	* @remarks This isn't a complete structure markup, only fields with state.
1241	*/
1242	static SSMFIELD const g_aVMSVGA3DSTATEFields[] =
1243	{
1244	# ifdef VMSVGA3D_OPENGL
1245	SSMFIELD_ENTRY( VMSVGA3DSTATE, rsGLVersion), /** @todo Why are we saving the GL version?? */
1246	# endif
1247	SSMFIELD_ENTRY( VMSVGA3DSTATE, cContexts),
1248	SSMFIELD_ENTRY( VMSVGA3DSTATE, cSurfaces),
1249	SSMFIELD_ENTRY_TERM()
1250	};
1251	#endif /* VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS */
1252
1253
1254	#ifdef VMSVGA3D_DIRECT3D
1255	D3DFORMAT vmsvga3dSurfaceFormat2D3D(SVGA3dSurfaceFormat format);
1256	D3DMULTISAMPLE_TYPE vmsvga3dMultipeSampleCount2D3D(uint32_t multisampleCount);
1257	DECLCALLBACK(int) vmsvga3dSharedSurfaceDestroyTree(PAVLU32NODECORE pNode, void *pvParam);
1258	int vmsvga3dSurfaceFlush(PVMSVGA3DSURFACE pSurface);
1259	#endif /* VMSVGA3D_DIRECT3D */
1260
1261
1262	#ifdef VMSVGA3D_OPENGL
1263	/** Save and setup everything. */
1264	# define VMSVGA3D_PARANOID_TEXTURE_PACKING
1265
1266	/** @name VMSVGAPACKPARAMS_* - which packing parameters were set.
1267	* @{ */
1268	# define VMSVGAPACKPARAMS_ALIGNMENT RT_BIT_32(0)
1269	# define VMSVGAPACKPARAMS_ROW_LENGTH RT_BIT_32(1)
1270	# define VMSVGAPACKPARAMS_IMAGE_HEIGHT RT_BIT_32(2)
1271	# define VMSVGAPACKPARAMS_SWAP_BYTES RT_BIT_32(3)
1272	# define VMSVGAPACKPARAMS_LSB_FIRST RT_BIT_32(4)
1273	# define VMSVGAPACKPARAMS_SKIP_ROWS RT_BIT_32(5)
1274	# define VMSVGAPACKPARAMS_SKIP_PIXELS RT_BIT_32(6)
1275	# define VMSVGAPACKPARAMS_SKIP_IMAGES RT_BIT_32(7)
1276	/** @} */
1277
1278	/**
1279	* Saved texture packing parameters (shared by both pack and unpack).
1280	*/
1281	typedef struct VMSVGAPACKPARAMS
1282	{
1283	uint32_t fChanged;
1284	GLint iAlignment;
1285	GLint cxRow;
1286	GLint cyImage;
1287	# ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
1288	GLboolean fSwapBytes;
1289	GLboolean fLsbFirst;
1290	GLint cSkipRows;
1291	GLint cSkipPixels;
1292	GLint cSkipImages;
1293	# endif
1294	} VMSVGAPACKPARAMS;
1295	/** Pointer to saved texture packing parameters. */
1296	typedef VMSVGAPACKPARAMS *PVMSVGAPACKPARAMS;
1297	/** Pointer to const saved texture packing parameters. */
1298	typedef VMSVGAPACKPARAMS const *PCVMSVGAPACKPARAMS;
1299
1300	void vmsvga3dOglSetPackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
1301	PVMSVGAPACKPARAMS pSave);
1302	void vmsvga3dOglRestorePackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
1303	PCVMSVGAPACKPARAMS pSave);
1304	void vmsvga3dOglSetUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, GLint cxRow, GLint cyImage,
1305	PVMSVGAPACKPARAMS pSave);
1306	void vmsvga3dOglRestoreUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext,
1307	PCVMSVGAPACKPARAMS pSave);
1308
1309	/** @name VMSVGA3D_DEF_CTX_F_XXX - vmsvga3dContextDefineOgl flags.
1310	* @{ */
1311	/** When clear, the context is created using the default OpenGL profile.
1312	* When set, it's created using the alternative profile. The latter is only
1313	* allowed if the VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE is set. */
1314	# define VMSVGA3D_DEF_CTX_F_OTHER_PROFILE RT_BIT_32(0)
1315	/** Defining the shared context. */
1316	# define VMSVGA3D_DEF_CTX_F_SHARED_CTX RT_BIT_32(1)
1317	/** Defining the init time context (EMT). */
1318	# define VMSVGA3D_DEF_CTX_F_INIT RT_BIT_32(2)
1319	/** @} */
1320	int vmsvga3dContextDefineOgl(PVGASTATECC pThisCC, uint32_t cid, uint32_t fFlags);
1321	void vmsvga3dSurfaceFormat2OGL(PVMSVGA3DSURFACE pSurface, SVGA3dSurfaceFormat format);
1322
1323	#endif /* VMSVGA3D_OPENGL */
1324
1325
1326	/* DevVGA-SVGA3d-shared.cpp: */
1327	int vmsvga3dSaveShaderConst(PVMSVGA3DCONTEXT pContext, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype,
1328	uint32_t val1, uint32_t val2, uint32_t val3, uint32_t val4);
1329
1330
1331	DECLINLINE(int) vmsvga3dContextFromCid(PVMSVGA3DSTATE pState, uint32_t cid, PVMSVGA3DCONTEXT *ppContext)
1332	{
1333	AssertReturn(cid < pState->cContexts, VERR_INVALID_PARAMETER);
1334	PVMSVGA3DCONTEXT const pContext = pState->papContexts[cid];
1335	if (RT_LIKELY(pContext && pContext->id == cid))
1336	{
1337	*ppContext = pContext;
1338	return VINF_SUCCESS;
1339	}
1340	LogRelMax(64, ("VMSVGA: unknown cid=%u (%s cid=%u)\n", cid, pContext ? "expected" : "null", pContext ? pContext->id : -1));
1341	return VERR_INVALID_PARAMETER;
1342	}
1343
1344	#ifdef VMSVGA3D_DX
1345	DECLINLINE(int) vmsvga3dDXContextFromCid(PVMSVGA3DSTATE pState, uint32_t cid, PVMSVGA3DDXCONTEXT *ppDXContext)
1346	{
1347	*ppDXContext = NULL;
1348	AssertReturn(cid < pState->cDXContexts, VERR_INVALID_PARAMETER);
1349	PVMSVGA3DDXCONTEXT const pDXContext = pState->papDXContexts[cid];
1350	if (RT_LIKELY(pDXContext && pDXContext->cid == cid))
1351	{
1352	*ppDXContext = pDXContext;
1353	return VINF_SUCCESS;
1354	}
1355	LogRelMax(64, ("VMSVGA: unknown DX cid=%u (%s cid=%u)\n", cid, pDXContext ? "expected" : "null", pDXContext ? pDXContext->cid : -1));
1356	return VERR_INVALID_PARAMETER;
1357	}
1358	#endif
1359
1360	DECLINLINE(int) vmsvga3dSurfaceFromSid(PVMSVGA3DSTATE pState, uint32_t sid, PVMSVGA3DSURFACE *ppSurface)
1361	{
1362	AssertReturn(sid < pState->cSurfaces, VERR_INVALID_PARAMETER);
1363	PVMSVGA3DSURFACE const pSurface = pState->papSurfaces[sid];
1364	if (RT_LIKELY(pSurface && pSurface->id == sid))
1365	{
1366	*ppSurface = pSurface;
1367	return VINF_SUCCESS;
1368	}
1369	LogRelMax(64, ("VMSVGA: unknown sid=%u (%s sid=%u)\n", sid, pSurface ? "expected" : "null", pSurface ? pSurface->id : -1));
1370	return VERR_INVALID_PARAMETER;
1371	}
1372
1373	DECLINLINE(int) vmsvga3dMipmapLevel(PVMSVGA3DSURFACE pSurface, uint32_t iArrayElement, uint32_t mipmap,
1374	PVMSVGA3DMIPMAPLEVEL *ppMipmapLevel)
1375	{
1376	AssertMsgReturn(iArrayElement < pSurface->surfaceDesc.numArrayElements,
1377	("numArrayElements %d, iArrayElement %d\n", pSurface->surfaceDesc.numArrayElements, iArrayElement),
1378	VERR_INVALID_PARAMETER);
1379	AssertMsgReturn(mipmap < pSurface->cLevels,
1380	("numMipLevels %d, mipmap %d", pSurface->cLevels, mipmap),
1381	VERR_INVALID_PARAMETER);
1382
1383	ppMipmapLevel = &pSurface->paMipmapLevels[iArrayElement pSurface->cLevels + mipmap];
1384	return VINF_SUCCESS;
1385	}
1386
1387	void vmsvga3dInfoSurfaceToBitmap(PCDBGFINFOHLP pHlp, PVMSVGA3DSURFACE pSurface,
1388	const char pszPath, const char pszNamePrefix, const char *pszNameSuffix);
1389
1390	void vmsvga3dSurfaceMapInit(VMSVGA3D_MAPPED_SURFACE pMap, VMSVGA3D_SURFACE_MAP enmMapType, SVGA3dBox const pBox,
1391	PVMSVGA3DSURFACE pSurface, void *pvData, uint32_t cbRowPitch, uint32_t cbDepthPitch);
1392
1393	#if defined(RT_OS_WINDOWS)
1394	#define D3D_RELEASE(ptr) do { \
1395	if (ptr) \
1396	{ \
1397	(ptr)->Release(); \
1398	(ptr) = 0; \
1399	} \
1400	} while (0)
1401	#endif
1402
1403	#if defined(VMSVGA3D_DIRECT3D)
1404	HRESULT D3D9UpdateTexture(PVMSVGA3DCONTEXT pContext,
1405	PVMSVGA3DSURFACE pSurface);
1406	HRESULT D3D9GetRenderTargetData(PVMSVGA3DCONTEXT pContext,
1407	PVMSVGA3DSURFACE pSurface,
1408	uint32_t uFace,
1409	uint32_t uMipmap);
1410	HRESULT D3D9GetSurfaceLevel(PVMSVGA3DSURFACE pSurface,
1411	uint32_t uFace,
1412	uint32_t uMipmap,
1413	bool fBounce,
1414	IDirect3DSurface9 **ppD3DSurface);
1415	D3DFORMAT D3D9GetActualFormat(PVMSVGA3DSTATE pState,
1416	D3DFORMAT d3dfmt);
1417	bool D3D9CheckDeviceFormat(IDirect3D9 *pD3D9,
1418	DWORD Usage,
1419	D3DRESOURCETYPE RType,
1420	D3DFORMAT CheckFormat);
1421	#endif
1422
1423	#ifdef VMSVGA3D_OPENGL
1424	void vmsvga3dOnSharedContextDefine(PVMSVGA3DSTATE pState);
1425	void vmsvga3dOnSharedContextDestroy(PVMSVGA3DSTATE pState);
1426
1427	DECLINLINE(GLuint) GLTextureId(PVMSVGA3DSURFACE pSurface)
1428	{
1429	return pSurface->fEmulated ? pSurface->idEmulated : pSurface->oglId.texture;
1430	}
1431
1432	void FormatConvUpdateTexture(PVMSVGA3DSTATE pState,
1433	PVMSVGA3DCONTEXT pCurrentContext,
1434	PVMSVGA3DSURFACE pSurface,
1435	uint32_t iMipmap);
1436	void FormatConvReadTexture(PVMSVGA3DSTATE pState,
1437	PVMSVGA3DCONTEXT pCurrentContext,
1438	PVMSVGA3DSURFACE pSurface,
1439	uint32_t iMipmap);
1440	#endif
1441
1442	int vmsvga3dShaderParse(SVGA3dShaderType type, uint32_t cbShaderData, uint32_t *pShaderData);
1443	void vmsvga3dShaderLogRel(char const pszMsg, SVGA3dShaderType type, uint32_t cbShaderData, uint32_t const pShaderData);
1444
1445	#endif /* !VBOX_INCLUDED_SRC_Graphics_DevVGA_SVGA3d_internal_h */
1446

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-internal.h@ 100108

Download in other formats: