DevVGA-SVGA3d-ogl.cpp@ 103914

Last change on this file since 103914 was 99775, checked in by vboxsync, 17 months ago
*: Mark functions as static if not used outside of a given compilation unit. Enables the compiler to optimize inlining, reduces the symbol tables, exposes unused functions and in some rare cases exposes mismtaches between function declarations and definitions, but most importantly reduces the number of parfait reports for the extern-function-no-forward-declaration category. This should not result in any functional changes, bugref:3409
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 309.7 KB

Line
1	/* $Id: DevVGA-SVGA3d-ogl.cpp 99775 2023-05-12 12:21:58Z vboxsync $ */
2	/** @file
3	* DevVMWare - VMWare SVGA device
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
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	/* Enable to disassemble defined shaders. (Windows host only) */
33	#if defined(RT_OS_WINDOWS) && defined(DEBUG) && 0 /* Disabled as we don't have the DirectX SDK avaible atm. */
34	# define DUMP_SHADER_DISASSEMBLY
35	#endif
36	#ifdef DEBUG_bird
37	//# define RTMEM_WRAP_TO_EF_APIS
38	#endif
39	#define LOG_GROUP LOG_GROUP_DEV_VMSVGA
40	#define GL_SILENCE_DEPRECATION /* shut up deprecated warnings on darwin (10.15 sdk) */
41	#include <VBox/vmm/pdmdev.h>
42	#include <VBox/version.h>
43	#include <VBox/err.h>
44	#include <VBox/log.h>
45	#include <VBox/vmm/pgm.h>
46	#include <VBox/AssertGuest.h>
47
48	#include <iprt/assert.h>
49	#include <iprt/semaphore.h>
50	#include <iprt/uuid.h>
51	#include <iprt/mem.h>
52
53	#include <VBoxVideo.h> /* required by DevVGA.h */
54	#include <VBoxVideo3D.h>
55
56	/* should go BEFORE any other DevVGA include to make all DevVGA.h config defines be visible */
57	#include "DevVGA.h"
58
59	#include "DevVGA-SVGA.h"
60	#include "DevVGA-SVGA3d.h"
61	#include "DevVGA-SVGA3d-internal.h"
62
63	#ifdef DUMP_SHADER_DISASSEMBLY
64	# include <d3dx9shader.h>
65	#endif
66
67	#include <stdlib.h>
68	#include <math.h>
69	#include <float.h> /* FLT_MIN */
70
71
72	/*********************************************************************************************************************************
73	* Defined Constants And Macros *
74	*********************************************************************************************************************************/
75	#ifndef VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE
76	# define VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE 1.0
77	#endif
78
79	#ifdef VMSVGA3D_DYNAMIC_LOAD
80	# define OGLGETPROCADDRESS glLdrGetProcAddress
81	#else
82	#ifdef RT_OS_WINDOWS
83	# define OGLGETPROCADDRESS MyWinGetProcAddress
84	DECLINLINE(PROC) MyWinGetProcAddress(const char *pszSymbol)
85	{
86	/* Khronos: [on failure] "some implementations will return other values. 1, 2, and 3 are used, as well as -1". */
87	PROC p = wglGetProcAddress(pszSymbol);
88	if (RT_VALID_PTR(p))
89	return p;
90	return 0;
91	}
92	#elif defined(RT_OS_DARWIN)
93	# include <dlfcn.h>
94	# define OGLGETPROCADDRESS MyNSGLGetProcAddress
95	/** Resolves an OpenGL symbol. */
96	static void MyNSGLGetProcAddress(const char pszSymbol)
97	{
98	/* Another copy in shaderapi.c. */
99	static void *s_pvImage = NULL;
100	if (s_pvImage == NULL)
101	s_pvImage = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
102	return s_pvImage ? dlsym(s_pvImage, pszSymbol) : NULL;
103	}
104
105	#else
106	# define OGLGETPROCADDRESS(x) glXGetProcAddress((const GLubyte *)x)
107	#endif
108	#endif
109
110	/* Invert y-coordinate for OpenGL's bottom left origin. */
111	#define D3D_TO_OGL_Y_COORD(ptrSurface, y_coordinate) (ptrSurface->paMipmapLevels[0].mipmapSize.height - (y_coordinate))
112	#define D3D_TO_OGL_Y_COORD_MIPLEVEL(ptrMipLevel, y_coordinate) (ptrMipLevel->size.height - (y_coordinate))
113
114	/**
115	* Macro for doing something and then checking for errors during initialization.
116	* Uses AssertLogRelMsg.
117	*/
118	#define VMSVGA3D_INIT_CHECKED(a_Expr) \
119	do \
120	{ \
121	a_Expr; \
122	GLenum iGlError = glGetError(); \
123	AssertLogRelMsg(iGlError == GL_NO_ERROR, ("VMSVGA3d: %s -> %#x\n", #a_Expr, iGlError)); \
124	} while (0)
125
126	/**
127	* Macro for doing something and then checking for errors during initialization,
128	* doing the same in the other context when enabled.
129	*
130	* This will try both profiles in dual profile builds. Caller must be in the
131	* default context.
132	*
133	* Uses AssertLogRelMsg to indicate trouble.
134	*/
135	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
136	# define VMSVGA3D_INIT_CHECKED_BOTH(a_pState, a_pContext, a_pOtherCtx, a_Expr) \
137	do \
138	{ \
139	for (uint32_t i = 0; i < 64; i++) if (glGetError() == GL_NO_ERROR) break; Assert(glGetError() == GL_NO_ERROR); \
140	a_Expr; \
141	GLenum iGlError = glGetError(); \
142	if (iGlError != GL_NO_ERROR) \
143	{ \
144	VMSVGA3D_SET_CURRENT_CONTEXT(a_pState, a_pOtherCtx); \
145	for (uint32_t i = 0; i < 64; i++) if (glGetError() == GL_NO_ERROR) break; Assert(glGetError() == GL_NO_ERROR); \
146	a_Expr; \
147	GLenum iGlError2 = glGetError(); \
148	AssertLogRelMsg(iGlError2 == GL_NO_ERROR, ("VMSVGA3d: %s -> %#x / %#x\n", #a_Expr, iGlError, iGlError2)); \
149	VMSVGA3D_SET_CURRENT_CONTEXT(a_pState, a_pContext); \
150	} \
151	} while (0)
152	#else
153	# define VMSVGA3D_INIT_CHECKED_BOTH(a_pState, a_pContext, a_pOtherCtx, a_Expr) VMSVGA3D_INIT_CHECKED(a_Expr)
154	#endif
155
156
157	/*********************************************************************************************************************************
158	* Global Variables *
159	*********************************************************************************************************************************/
160	/* Define the default light parameters as specified by MSDN. */
161	/** @todo move out; fetched from Wine */
162	const SVGA3dLightData vmsvga3d_default_light =
163	{
164	SVGA3D_LIGHTTYPE_DIRECTIONAL, /* type */
165	false, /* inWorldSpace */
166	{ 1.0f, 1.0f, 1.0f, 0.0f }, /* diffuse r,g,b,a */
167	{ 0.0f, 0.0f, 0.0f, 0.0f }, /* specular r,g,b,a */
168	{ 0.0f, 0.0f, 0.0f, 0.0f }, /* ambient r,g,b,a, */
169	{ 0.0f, 0.0f, 0.0f }, /* position x,y,z */
170	{ 0.0f, 0.0f, 1.0f }, /* direction x,y,z */
171	0.0f, /* range */
172	0.0f, /* falloff */
173	0.0f, 0.0f, 0.0f, /* attenuation 0,1,2 */
174	0.0f, /* theta */
175	0.0f /* phi */
176	};
177
178
179	/*********************************************************************************************************************************
180	* Internal Functions *
181	*********************************************************************************************************************************/
182	static int vmsvga3dContextDestroyOgl(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid);
183	static DECLCALLBACK(int) vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid);
184	static void vmsvgaColor2GLFloatArray(uint32_t color, GLfloat pRed, GLfloat pGreen, GLfloat pBlue, GLfloat pAlpha);
185	static DECLCALLBACK(int) vmsvga3dBackSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData);
186	static DECLCALLBACK(int) vmsvga3dBackSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4]);
187	static DECLCALLBACK(int) vmsvga3dBackShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type);
188	static DECLCALLBACK(int) vmsvga3dBackOcclusionQueryDelete(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext);
189	static DECLCALLBACK(int) vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext, PVMSVGA3DSURFACE pSurface);
190
191	/* Generated by VBoxDef2LazyLoad from the VBoxSVGA3D.def and VBoxSVGA3DObjC.def files. */
192	extern "C" int ExplicitlyLoadVBoxSVGA3D(bool fResolveAllImports, PRTERRINFO pErrInfo);
193
194
195	/**
196	* Checks if the given OpenGL extension is supported.
197	*
198	* @returns true if supported, false if not.
199	* @param pState The VMSVGA3d state.
200	* @param rsMinGLVersion The OpenGL version that introduced this feature
201	* into the core.
202	* @param pszWantedExtension The name of the OpenGL extension we want padded
203	* with one space at each end.
204	* @remarks Init time only.
205	*/
206	static bool vmsvga3dCheckGLExtension(PVMSVGA3DSTATE pState, float rsMinGLVersion, const char *pszWantedExtension)
207	{
208	RT_NOREF(rsMinGLVersion);
209	/* check padding. */
210	Assert(pszWantedExtension[0] == ' ');
211	Assert(pszWantedExtension[1] != ' ');
212	Assert(strchr(&pszWantedExtension[1], ' ') + 1 == strchr(pszWantedExtension, '\0'));
213
214	/* Look it up. */
215	bool fRet = false;
216	if (strstr(pState->pszExtensions, pszWantedExtension))
217	fRet = true;
218
219	/* Temporarily. Later start if (rsMinGLVersion != 0.0 && fActualGLVersion >= rsMinGLVersion) return true; */
220	#ifdef RT_OS_DARWIN
221	AssertMsg( rsMinGLVersion == 0.0
222	\|\| fRet == (pState->rsGLVersion >= rsMinGLVersion)
223	\|\| VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE == 2.1,
224	("%s actual:%d min:%d fRet=%d\n",
225	pszWantedExtension, (int)(pState->rsGLVersion * 10), (int)(rsMinGLVersion * 10), fRet));
226	#else
227	AssertMsg(rsMinGLVersion == 0.0 \|\| fRet == (pState->rsGLVersion >= rsMinGLVersion),
228	("%s actual:%d min:%d fRet=%d\n",
229	pszWantedExtension, (int)(pState->rsGLVersion * 10), (int)(rsMinGLVersion * 10), fRet));
230	#endif
231	return fRet;
232	}
233
234
235	/**
236	* Outputs GL_EXTENSIONS list to the release log.
237	*/
238	static void vmsvga3dLogRelExtensions(const char pszPrefix, const char pszExtensions)
239	{
240	/* OpenGL 3.0 interface (glGetString(GL_EXTENSIONS) return NULL). */
241	bool fBuffered = RTLogRelSetBuffering(true);
242
243	/*
244	* Determin the column widths first.
245	*/
246	size_t acchWidths[4] = { 1, 1, 1, 1 };
247	uint32_t i;
248	const char *psz = pszExtensions;
249	for (i = 0; ; i++)
250	{
251	while (*psz == ' ')
252	psz++;
253	if (!*psz)
254	break;
255
256	const char *pszEnd = strchr(psz, ' ');
257	AssertBreak(pszEnd);
258	size_t cch = pszEnd - psz;
259
260	uint32_t iColumn = i % RT_ELEMENTS(acchWidths);
261	if (acchWidths[iColumn] < cch)
262	acchWidths[iColumn] = cch;
263
264	psz = pszEnd;
265	}
266
267	/*
268	* Output it.
269	*/
270	LogRel(("VMSVGA3d: %sOpenGL extensions (%d):", pszPrefix, i));
271	psz = pszExtensions;
272	for (i = 0; ; i++)
273	{
274	while (*psz == ' ')
275	psz++;
276	if (!*psz)
277	break;
278
279	const char *pszEnd = strchr(psz, ' ');
280	AssertBreak(pszEnd);
281	size_t cch = pszEnd - psz;
282
283	uint32_t iColumn = i % RT_ELEMENTS(acchWidths);
284	if (iColumn == 0)
285	LogRel(("\nVMSVGA3d: %-.s", acchWidths[iColumn], cch, psz));
286	else if (iColumn != RT_ELEMENTS(acchWidths) - 1)
287	LogRel((" %-.s", acchWidths[iColumn], cch, psz));
288	else
289	LogRel((" %.*s", cch, psz));
290
291	psz = pszEnd;
292	}
293
294	RTLogRelSetBuffering(fBuffered);
295	LogRel(("\n"));
296	}
297
298	/**
299	* Gathers the GL_EXTENSIONS list, storing it as a space padded list at
300	* @a ppszExtensions.
301	*
302	* @returns VINF_SUCCESS or VERR_NO_STR_MEMORY
303	* @param ppszExtensions Pointer to the string pointer. Free with RTStrFree.
304	* @param fGLProfileVersion The OpenGL profile version.
305	*/
306	static int vmsvga3dGatherExtensions(char **ppszExtensions, float fGLProfileVersion)
307	{
308	int rc;
309	*ppszExtensions = NULL;
310
311	/*
312	* Try the old glGetString interface first.
313	*/
314	const char pszExtensions = (const char )glGetString(GL_EXTENSIONS);
315	if (pszExtensions)
316	{
317	rc = RTStrAAppendExN(ppszExtensions, 3, " ", (size_t)1, pszExtensions, RTSTR_MAX, " ", (size_t)1);
318	AssertLogRelRCReturn(rc, rc);
319	}
320	else
321	{
322	/*
323	* The new interface where each extension string is retrieved separately.
324	* Note! Cannot use VMSVGA3D_INIT_CHECKED_GL_GET_INTEGER_VALUE here because
325	* the above GL_EXTENSIONS error lingers on darwin. sucks.
326	*/
327	#ifndef GL_NUM_EXTENSIONS
328	# define GL_NUM_EXTENSIONS 0x821D
329	#endif
330	GLint cExtensions = 1024;
331	glGetIntegerv(GL_NUM_EXTENSIONS, &cExtensions);
332	Assert(cExtensions != 1024);
333
334	PFNGLGETSTRINGIPROC pfnGlGetStringi = (PFNGLGETSTRINGIPROC)OGLGETPROCADDRESS("glGetStringi");
335	AssertLogRelReturn(pfnGlGetStringi, VERR_NOT_SUPPORTED);
336
337	rc = RTStrAAppend(ppszExtensions, " ");
338	for (GLint i = 0; RT_SUCCESS(rc) && i < cExtensions; i++)
339	{
340	const char pszExt = (const char )pfnGlGetStringi(GL_EXTENSIONS, i);
341	if (pszExt)
342	rc = RTStrAAppendExN(ppszExtensions, 2, pfnGlGetStringi(GL_EXTENSIONS, i), RTSTR_MAX, " ", (size_t)1);
343	}
344	AssertRCReturn(rc, rc);
345	}
346
347	#if 1
348	/*
349	* Add extensions promoted into the core OpenGL profile.
350	*/
351	static const struct
352	{
353	float fGLVersion;
354	const char *pszzExtensions;
355	} s_aPromotedExtensions[] =
356	{
357	{
358	1.1f,
359	" GL_EXT_vertex_array \0"
360	" GL_EXT_polygon_offset \0"
361	" GL_EXT_blend_logic_op \0"
362	" GL_EXT_texture \0"
363	" GL_EXT_copy_texture \0"
364	" GL_EXT_subtexture \0"
365	" GL_EXT_texture_object \0"
366	" GL_ARB_framebuffer_object \0"
367	" GL_ARB_map_buffer_range \0"
368	" GL_ARB_vertex_array_object \0"
369	"\0"
370	},
371	{
372	1.2f,
373	" EXT_texture3D \0"
374	" EXT_bgra \0"
375	" EXT_packed_pixels \0"
376	" EXT_rescale_normal \0"
377	" EXT_separate_specular_color \0"
378	" SGIS_texture_edge_clamp \0"
379	" SGIS_texture_lod \0"
380	" EXT_draw_range_elements \0"
381	"\0"
382	},
383	{
384	1.3f,
385	" GL_ARB_texture_compression \0"
386	" GL_ARB_texture_cube_map \0"
387	" GL_ARB_multisample \0"
388	" GL_ARB_multitexture \0"
389	" GL_ARB_texture_env_add \0"
390	" GL_ARB_texture_env_combine \0"
391	" GL_ARB_texture_env_dot3 \0"
392	" GL_ARB_texture_border_clamp \0"
393	" GL_ARB_transpose_matrix \0"
394	"\0"
395	},
396	{
397	1.5f,
398	" GL_SGIS_generate_mipmap \0"
399	/" GL_NV_blend_equare \0"/
400	" GL_ARB_depth_texture \0"
401	" GL_ARB_shadow \0"
402	" GL_EXT_fog_coord \0"
403	" GL_EXT_multi_draw_arrays \0"
404	" GL_ARB_point_parameters \0"
405	" GL_EXT_secondary_color \0"
406	" GL_EXT_blend_func_separate \0"
407	" GL_EXT_stencil_wrap \0"
408	" GL_ARB_texture_env_crossbar \0"
409	" GL_EXT_texture_lod_bias \0"
410	" GL_ARB_texture_mirrored_repeat \0"
411	" GL_ARB_window_pos \0"
412	"\0"
413	},
414	{
415	1.6f,
416	" GL_ARB_vertex_buffer_object \0"
417	" GL_ARB_occlusion_query \0"
418	" GL_EXT_shadow_funcs \0"
419	},
420	{
421	2.0f,
422	" GL_ARB_shader_objects \0" /??/
423	" GL_ARB_vertex_shader \0" /??/
424	" GL_ARB_fragment_shader \0" /??/
425	" GL_ARB_shading_language_100 \0" /??/
426	" GL_ARB_draw_buffers \0"
427	" GL_ARB_texture_non_power_of_two \0"
428	" GL_ARB_point_sprite \0"
429	" GL_ATI_separate_stencil \0"
430	" GL_EXT_stencil_two_side \0"
431	"\0"
432	},
433	{
434	2.1f,
435	" GL_ARB_pixel_buffer_object \0"
436	" GL_EXT_texture_sRGB \0"
437	"\0"
438	},
439	{
440	3.0f,
441	" GL_ARB_framebuffer_object \0"
442	" GL_ARB_map_buffer_range \0"
443	" GL_ARB_vertex_array_object \0"
444	"\0"
445	},
446	{
447	3.1f,
448	" GL_ARB_copy_buffer \0"
449	" GL_ARB_uniform_buffer_object \0"
450	"\0"
451	},
452	{
453	3.2f,
454	" GL_ARB_vertex_array_bgra \0"
455	" GL_ARB_draw_elements_base_vertex \0"
456	" GL_ARB_fragment_coord_conventions \0"
457	" GL_ARB_provoking_vertex \0"
458	" GL_ARB_seamless_cube_map \0"
459	" GL_ARB_texture_multisample \0"
460	" GL_ARB_depth_clamp \0"
461	" GL_ARB_sync \0"
462	" GL_ARB_geometry_shader4 \0" /??/
463	"\0"
464	},
465	{
466	3.3f,
467	" GL_ARB_blend_func_extended \0"
468	" GL_ARB_sampler_objects \0"
469	" GL_ARB_explicit_attrib_location \0"
470	" GL_ARB_occlusion_query2 \0"
471	" GL_ARB_shader_bit_encoding \0"
472	" GL_ARB_texture_rgb10_a2ui \0"
473	" GL_ARB_texture_swizzle \0"
474	" GL_ARB_timer_query \0"
475	" GL_ARB_vertex_type_2_10_10_10_rev \0"
476	"\0"
477	},
478	{
479	4.0f,
480	" GL_ARB_texture_query_lod \0"
481	" GL_ARB_draw_indirect \0"
482	" GL_ARB_gpu_shader5 \0"
483	" GL_ARB_gpu_shader_fp64 \0"
484	" GL_ARB_shader_subroutine \0"
485	" GL_ARB_tessellation_shader \0"
486	" GL_ARB_texture_buffer_object_rgb32 \0"
487	" GL_ARB_texture_cube_map_array \0"
488	" GL_ARB_texture_gather \0"
489	" GL_ARB_transform_feedback2 \0"
490	" GL_ARB_transform_feedback3 \0"
491	"\0"
492	},
493	{
494	4.1f,
495	" GL_ARB_ES2_compatibility \0"
496	" GL_ARB_get_program_binary \0"
497	" GL_ARB_separate_shader_objects \0"
498	" GL_ARB_shader_precision \0"
499	" GL_ARB_vertex_attrib_64bit \0"
500	" GL_ARB_viewport_array \0"
501	"\0"
502	}
503	};
504
505	uint32_t cPromoted = 0;
506	for (uint32_t i = 0; i < RT_ELEMENTS(s_aPromotedExtensions) && s_aPromotedExtensions[i].fGLVersion <= fGLProfileVersion; i++)
507	{
508	const char *pszExt = s_aPromotedExtensions[i].pszzExtensions;
509	while (*pszExt)
510	{
511	# ifdef VBOX_STRICT
512	size_t cchExt = strlen(pszExt);
513	Assert(cchExt > 3);
514	Assert(pszExt[0] == ' ');
515	Assert(pszExt[1] != ' ');
516	Assert(pszExt[cchExt - 2] != ' ');
517	Assert(pszExt[cchExt - 1] == ' ');
518	# endif
519
520	if (strstr(*ppszExtensions, pszExt) == NULL)
521	{
522	if (cPromoted++ == 0)
523	{
524	rc = RTStrAAppend(ppszExtensions, " <promoted-extensions:> <promoted-extensions:> <promoted-extensions:> ");
525	AssertRCReturn(rc, rc);
526	}
527
528	rc = RTStrAAppend(ppszExtensions, pszExt);
529	AssertRCReturn(rc, rc);
530	}
531
532	pszExt = strchr(pszExt, '\0') + 1;
533	}
534	}
535	#endif
536
537	return VINF_SUCCESS;
538	}
539
540	/** Check whether this is an Intel GL driver.
541	*
542	* @returns true if this seems to be some Intel graphics.
543	*/
544	static bool vmsvga3dIsVendorIntel(void)
545	{
546	return RTStrNICmp((char *)glGetString(GL_VENDOR), "Intel", 5) == 0;
547	}
548
549	/**
550	* @interface_method_impl{VBOXVMSVGASHADERIF,pfnSwitchInitProfile}
551	*/
552	static DECLCALLBACK(void) vmsvga3dShaderIfSwitchInitProfile(PVBOXVMSVGASHADERIF pThis, bool fOtherProfile)
553	{
554	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
555	PVMSVGA3DSTATE pState = RT_FROM_MEMBER(pThis, VMSVGA3DSTATE, ShaderIf);
556	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pState->papContexts[fOtherProfile ? 2 : 1]);
557	#else
558	NOREF(pThis);
559	NOREF(fOtherProfile);
560	#endif
561	}
562
563
564	/**
565	* @interface_method_impl{VBOXVMSVGASHADERIF,pfnGetNextExtension}
566	*/
567	static DECLCALLBACK(bool) vmsvga3dShaderIfGetNextExtension(PVBOXVMSVGASHADERIF pThis, void **ppvEnumCtx,
568	char *pszBuf, size_t cbBuf, bool fOtherProfile)
569	{
570	PVMSVGA3DSTATE pState = RT_FROM_MEMBER(pThis, VMSVGA3DSTATE, ShaderIf);
571	const char pszCur = ppvEnumCtx ? (const char )ppvEnumCtx
572	: fOtherProfile ? pState->pszOtherExtensions : pState->pszExtensions;
573	while (*pszCur == ' ')
574	pszCur++;
575	if (!*pszCur)
576	return false;
577
578	const char *pszEnd = strchr(pszCur, ' ');
579	AssertReturn(pszEnd, false);
580	size_t cch = pszEnd - pszCur;
581	if (cch < cbBuf)
582	{
583	memcpy(pszBuf, pszCur, cch);
584	pszBuf[cch] = '\0';
585	}
586	else if (cbBuf > 0)
587	{
588	memcpy(pszBuf, "<overflow>", RT_MIN(sizeof("<overflow>"), cbBuf));
589	pszBuf[cbBuf - 1] = '\0';
590	}
591
592	ppvEnumCtx = (void )pszEnd;
593	return true;
594	}
595
596
597	/**
598	* Initializes the VMSVGA3D state during VGA device construction.
599	*
600	* Failure are generally not fatal, 3D support will just be disabled.
601	*
602	* @returns VBox status code.
603	* @param pDevIns The device instance.
604	* @param pThis The shared VGA/VMSVGA state where svga.p3dState will be
605	* modified.
606	* @param pThisCC The VGA/VMSVGA state for ring-3.
607	*/
608	static DECLCALLBACK(int) vmsvga3dBackInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
609	{
610	int rc;
611	RT_NOREF(pDevIns, pThis, pThisCC);
612
613	AssertCompile(GL_TRUE == 1);
614	AssertCompile(GL_FALSE == 0);
615
616	#ifdef VMSVGA3D_DYNAMIC_LOAD
617	rc = glLdrInit(pDevIns);
618	if (RT_FAILURE(rc))
619	{
620	LogRel(("VMSVGA3d: Error loading OpenGL library and resolving necessary functions: %Rrc\n", rc));
621	return rc;
622	}
623	#endif
624
625	/*
626	* Load and resolve imports from the external shared libraries.
627	*/
628	RTERRINFOSTATIC ErrInfo;
629	rc = ExplicitlyLoadVBoxSVGA3D(true /fResolveAllImports/, RTErrInfoInitStatic(&ErrInfo));
630	if (RT_FAILURE(rc))
631	{
632	LogRel(("VMSVGA3d: Error loading VBoxSVGA3D and resolving necessary functions: %Rrc - %s\n", rc, ErrInfo.Core.pszMsg));
633	return rc;
634	}
635	#ifdef RT_OS_DARWIN
636	rc = ExplicitlyLoadVBoxSVGA3DObjC(true /fResolveAllImports/, RTErrInfoInitStatic(&ErrInfo));
637	if (RT_FAILURE(rc))
638	{
639	LogRel(("VMSVGA3d: Error loading VBoxSVGA3DObjC and resolving necessary functions: %Rrc - %s\n", rc, ErrInfo.Core.pszMsg));
640	return rc;
641	}
642	#endif
643
644	#ifdef RT_OS_WINDOWS
645	/* Create event semaphore and async IO thread. */
646	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
647	rc = RTSemEventCreate(&pState->WndRequestSem);
648	if (RT_SUCCESS(rc))
649	{
650	rc = RTThreadCreate(&pState->pWindowThread, vmsvga3dWindowThread, pState->WndRequestSem, 0, RTTHREADTYPE_GUI, 0,
651	"VMSVGA3DWND");
652	if (RT_SUCCESS(rc))
653	return VINF_SUCCESS;
654
655	/* bail out. */
656	LogRel(("VMSVGA3d: RTThreadCreate failed: %Rrc\n", rc));
657	RTSemEventDestroy(pState->WndRequestSem);
658	}
659	else
660	LogRel(("VMSVGA3d: RTSemEventCreate failed: %Rrc\n", rc));
661	return rc;
662	#else
663	return VINF_SUCCESS;
664	#endif
665	}
666
667	static int vmsvga3dLoadGLFunctions(PVMSVGA3DSTATE pState)
668	{
669	/* A strict approach to get a proc address as recommended by Khronos:
670	* - "If the function is a core OpenGL function, then we need to check the OpenGL version".
671	* - "If the function is an extension, we need to check to see if the extension is supported."
672	*/
673
674	/* Get a function address, return VERR_NOT_IMPLEMENTED on failure. */
675	#define GLGETPROC_(ProcType, ProcName, NameSuffix) do { \
676	pState->ext.ProcName = (ProcType)OGLGETPROCADDRESS(#ProcName NameSuffix); \
677	AssertLogRelMsgReturn(pState->ext.ProcName, (#ProcName NameSuffix " missing"), VERR_NOT_IMPLEMENTED); \
678	} while(0)
679
680	/* Get an optional function address. LogRel on failure. */
681	#define GLGETPROCOPT_(ProcType, ProcName, NameSuffix) do { \
682	pState->ext.ProcName = (ProcType)OGLGETPROCADDRESS(#ProcName NameSuffix); \
683	if (!pState->ext.ProcName) \
684	{ \
685	LogRel(("VMSVGA3d: missing optional %s\n", #ProcName NameSuffix)); \
686	AssertFailed(); \
687	} \
688	} while(0)
689
690	/* OpenGL 2.0 or earlier core. Do not bother with extensions. */
691	GLGETPROC_(PFNGLGENQUERIESPROC , glGenQueries, "");
692	GLGETPROC_(PFNGLDELETEQUERIESPROC , glDeleteQueries, "");
693	GLGETPROC_(PFNGLBEGINQUERYPROC , glBeginQuery, "");
694	GLGETPROC_(PFNGLENDQUERYPROC , glEndQuery, "");
695	GLGETPROC_(PFNGLGETQUERYOBJECTUIVPROC , glGetQueryObjectuiv, "");
696	GLGETPROC_(PFNGLTEXIMAGE3DPROC , glTexImage3D, "");
697	GLGETPROC_(PFNGLTEXSUBIMAGE3DPROC , glTexSubImage3D, "");
698	GLGETPROC_(PFNGLGETCOMPRESSEDTEXIMAGEPROC , glGetCompressedTexImage, "");
699	GLGETPROC_(PFNGLCOMPRESSEDTEXIMAGE2DPROC , glCompressedTexImage2D, "");
700	GLGETPROC_(PFNGLCOMPRESSEDTEXIMAGE3DPROC , glCompressedTexImage3D, "");
701	GLGETPROC_(PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC , glCompressedTexSubImage2D, "");
702	GLGETPROC_(PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC , glCompressedTexSubImage3D, "");
703	GLGETPROC_(PFNGLPOINTPARAMETERFPROC , glPointParameterf, "");
704	GLGETPROC_(PFNGLBLENDEQUATIONSEPARATEPROC , glBlendEquationSeparate, "");
705	GLGETPROC_(PFNGLBLENDFUNCSEPARATEPROC , glBlendFuncSeparate, "");
706	GLGETPROC_(PFNGLSTENCILOPSEPARATEPROC , glStencilOpSeparate, "");
707	GLGETPROC_(PFNGLSTENCILFUNCSEPARATEPROC , glStencilFuncSeparate, "");
708	GLGETPROC_(PFNGLBINDBUFFERPROC , glBindBuffer, "");
709	GLGETPROC_(PFNGLDELETEBUFFERSPROC , glDeleteBuffers, "");
710	GLGETPROC_(PFNGLGENBUFFERSPROC , glGenBuffers, "");
711	GLGETPROC_(PFNGLBUFFERDATAPROC , glBufferData, "");
712	GLGETPROC_(PFNGLMAPBUFFERPROC , glMapBuffer, "");
713	GLGETPROC_(PFNGLUNMAPBUFFERPROC , glUnmapBuffer, "");
714	GLGETPROC_(PFNGLENABLEVERTEXATTRIBARRAYPROC , glEnableVertexAttribArray, "");
715	GLGETPROC_(PFNGLDISABLEVERTEXATTRIBARRAYPROC , glDisableVertexAttribArray, "");
716	GLGETPROC_(PFNGLVERTEXATTRIBPOINTERPROC , glVertexAttribPointer, "");
717	GLGETPROC_(PFNGLACTIVETEXTUREPROC , glActiveTexture, "");
718	/* glGetProgramivARB determines implementation limits for the program
719	* target (GL_FRAGMENT_PROGRAM_ARB, GL_VERTEX_PROGRAM_ARB).
720	* It differs from glGetProgramiv, which returns a parameter from a program object.
721	*/
722	GLGETPROC_(PFNGLGETPROGRAMIVARBPROC , glGetProgramivARB, "");
723	GLGETPROC_(PFNGLFOGCOORDPOINTERPROC , glFogCoordPointer, "");
724	#if VBOX_VMSVGA3D_GL_HACK_LEVEL < 0x102
725	GLGETPROC_(PFNGLBLENDCOLORPROC , glBlendColor, "");
726	GLGETPROC_(PFNGLBLENDEQUATIONPROC , glBlendEquation, "");
727	#endif
728	#if VBOX_VMSVGA3D_GL_HACK_LEVEL < 0x103
729	GLGETPROC_(PFNGLCLIENTACTIVETEXTUREPROC , glClientActiveTexture, "");
730	#endif
731	GLGETPROC_(PFNGLDRAWBUFFERSPROC , glDrawBuffers, "");
732	GLGETPROC_(PFNGLCREATESHADERPROC , glCreateShader, "");
733	GLGETPROC_(PFNGLSHADERSOURCEPROC , glShaderSource, "");
734	GLGETPROC_(PFNGLCOMPILESHADERPROC , glCompileShader, "");
735	GLGETPROC_(PFNGLGETSHADERIVPROC , glGetShaderiv, "");
736	GLGETPROC_(PFNGLGETSHADERINFOLOGPROC , glGetShaderInfoLog, "");
737	GLGETPROC_(PFNGLCREATEPROGRAMPROC , glCreateProgram, "");
738	GLGETPROC_(PFNGLATTACHSHADERPROC , glAttachShader, "");
739	GLGETPROC_(PFNGLLINKPROGRAMPROC , glLinkProgram, "");
740	GLGETPROC_(PFNGLGETPROGRAMIVPROC , glGetProgramiv, "");
741	GLGETPROC_(PFNGLGETPROGRAMINFOLOGPROC , glGetProgramInfoLog, "");
742	GLGETPROC_(PFNGLUSEPROGRAMPROC , glUseProgram, "");
743	GLGETPROC_(PFNGLGETUNIFORMLOCATIONPROC , glGetUniformLocation, "");
744	GLGETPROC_(PFNGLUNIFORM1IPROC , glUniform1i, "");
745	GLGETPROC_(PFNGLUNIFORM4FVPROC , glUniform4fv, "");
746	GLGETPROC_(PFNGLDETACHSHADERPROC , glDetachShader, "");
747	GLGETPROC_(PFNGLDELETESHADERPROC , glDeleteShader, "");
748	GLGETPROC_(PFNGLDELETEPROGRAMPROC , glDeleteProgram, "");
749
750	GLGETPROC_(PFNGLVERTEXATTRIB4FVPROC , glVertexAttrib4fv, "");
751	GLGETPROC_(PFNGLVERTEXATTRIB4UBVPROC , glVertexAttrib4ubv, "");
752	GLGETPROC_(PFNGLVERTEXATTRIB4NUBVPROC , glVertexAttrib4Nubv, "");
753	GLGETPROC_(PFNGLVERTEXATTRIB4SVPROC , glVertexAttrib4sv, "");
754	GLGETPROC_(PFNGLVERTEXATTRIB4NSVPROC , glVertexAttrib4Nsv, "");
755	GLGETPROC_(PFNGLVERTEXATTRIB4NUSVPROC , glVertexAttrib4Nusv, "");
756
757	/* OpenGL 3.0 core, GL_ARB_instanced_arrays. Same functions names in the ARB and core specs. */
758	if ( pState->rsGLVersion >= 3.0f
759	\|\| vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_framebuffer_object "))
760	{
761	GLGETPROC_(PFNGLISRENDERBUFFERPROC , glIsRenderbuffer, "");
762	GLGETPROC_(PFNGLBINDRENDERBUFFERPROC , glBindRenderbuffer, "");
763	GLGETPROC_(PFNGLDELETERENDERBUFFERSPROC , glDeleteRenderbuffers, "");
764	GLGETPROC_(PFNGLGENRENDERBUFFERSPROC , glGenRenderbuffers, "");
765	GLGETPROC_(PFNGLRENDERBUFFERSTORAGEPROC , glRenderbufferStorage, "");
766	GLGETPROC_(PFNGLGETRENDERBUFFERPARAMETERIVPROC , glGetRenderbufferParameteriv, "");
767	GLGETPROC_(PFNGLISFRAMEBUFFERPROC , glIsFramebuffer, "");
768	GLGETPROC_(PFNGLBINDFRAMEBUFFERPROC , glBindFramebuffer, "");
769	GLGETPROC_(PFNGLDELETEFRAMEBUFFERSPROC , glDeleteFramebuffers, "");
770	GLGETPROC_(PFNGLGENFRAMEBUFFERSPROC , glGenFramebuffers, "");
771	GLGETPROC_(PFNGLCHECKFRAMEBUFFERSTATUSPROC , glCheckFramebufferStatus, "");
772	GLGETPROC_(PFNGLFRAMEBUFFERTEXTURE1DPROC , glFramebufferTexture1D, "");
773	GLGETPROC_(PFNGLFRAMEBUFFERTEXTURE2DPROC , glFramebufferTexture2D, "");
774	GLGETPROC_(PFNGLFRAMEBUFFERTEXTURE3DPROC , glFramebufferTexture3D, "");
775	GLGETPROC_(PFNGLFRAMEBUFFERRENDERBUFFERPROC , glFramebufferRenderbuffer, "");
776	GLGETPROC_(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC , glGetFramebufferAttachmentParameteriv, "");
777	GLGETPROC_(PFNGLGENERATEMIPMAPPROC , glGenerateMipmap, "");
778	GLGETPROC_(PFNGLBLITFRAMEBUFFERPROC , glBlitFramebuffer, "");
779	GLGETPROC_(PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC , glRenderbufferStorageMultisample, "");
780	GLGETPROC_(PFNGLFRAMEBUFFERTEXTURELAYERPROC , glFramebufferTextureLayer, "");
781	}
782
783	/* OpenGL 3.1 core, GL_ARB_draw_instanced, GL_EXT_draw_instanced. */
784	if (pState->rsGLVersion >= 3.1f)
785	{
786	GLGETPROC_(PFNGLDRAWARRAYSINSTANCEDPROC , glDrawArraysInstanced, "");
787	GLGETPROC_(PFNGLDRAWELEMENTSINSTANCEDPROC , glDrawElementsInstanced, "");
788	}
789	else if (vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_draw_instanced "))
790	{
791	GLGETPROC_(PFNGLDRAWARRAYSINSTANCEDPROC , glDrawArraysInstanced, "ARB");
792	GLGETPROC_(PFNGLDRAWELEMENTSINSTANCEDPROC , glDrawElementsInstanced, "ARB");
793	}
794	else if (vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_draw_instanced "))
795	{
796	GLGETPROC_(PFNGLDRAWARRAYSINSTANCEDPROC , glDrawArraysInstanced, "EXT");
797	GLGETPROC_(PFNGLDRAWELEMENTSINSTANCEDPROC , glDrawElementsInstanced, "EXT");
798	}
799
800	/* OpenGL 3.2 core, GL_ARB_draw_elements_base_vertex. Same functions names in the ARB and core specs. */
801	if ( pState->rsGLVersion >= 3.2f
802	\|\| vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_draw_elements_base_vertex "))
803	{
804	GLGETPROC_(PFNGLDRAWELEMENTSBASEVERTEXPROC , glDrawElementsBaseVertex, "");
805	GLGETPROC_(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC , glDrawElementsInstancedBaseVertex, "");
806	}
807
808	/* Optional. OpenGL 3.2 core, GL_ARB_provoking_vertex. Same functions names in the ARB and core specs. */
809	if ( pState->rsGLVersion >= 3.2f
810	\|\| vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_provoking_vertex "))
811	{
812	GLGETPROCOPT_(PFNGLPROVOKINGVERTEXPROC , glProvokingVertex, "");
813	}
814
815	/* OpenGL 3.3 core, GL_ARB_instanced_arrays. */
816	if (pState->rsGLVersion >= 3.3f)
817	{
818	GLGETPROC_(PFNGLVERTEXATTRIBDIVISORPROC , glVertexAttribDivisor, "");
819	}
820	else if (vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_instanced_arrays "))
821	{
822	GLGETPROC_(PFNGLVERTEXATTRIBDIVISORARBPROC , glVertexAttribDivisor, "ARB");
823	}
824
825	#undef GLGETPROCOPT_
826	#undef GLGETPROC_
827
828	return VINF_SUCCESS;
829	}
830
831
832	DECLINLINE(GLenum) vmsvga3dCubemapFaceFromIndex(uint32_t iFace)
833	{
834	GLint Face;
835	switch (iFace)
836	{
837	case 0: Face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; break;
838	case 1: Face = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; break;
839	case 2: Face = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; break;
840	case 3: Face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; break;
841	case 4: Face = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; break;
842	default:
843	case 5: Face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; break;
844	}
845	return Face;
846	}
847
848
849	/* We must delay window creation until the PowerOn phase. Init is too early and will cause failures. */
850	static DECLCALLBACK(int) vmsvga3dBackPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
851	{
852	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
853	AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
854	PVMSVGA3DCONTEXT pContext;
855	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
856	PVMSVGA3DCONTEXT pOtherCtx;
857	#endif
858	int rc;
859	RT_NOREF(pDevIns, pThis);
860
861	if (pState->rsGLVersion != 0.0)
862	return VINF_SUCCESS; /* already initialized (load state) */
863
864	/*
865	* OpenGL function calls aren't possible without a valid current context, so create a fake one here.
866	*/
867	rc = vmsvga3dContextDefineOgl(pThisCC, 1, VMSVGA3D_DEF_CTX_F_INIT);
868	AssertRCReturn(rc, rc);
869
870	pContext = pState->papContexts[1];
871	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
872
873	#ifdef VMSVGA3D_DYNAMIC_LOAD
874	/* Context is set and it is possible now to resolve extension functions. */
875	rc = glLdrGetExtFunctions(pDevIns);
876	if (RT_FAILURE(rc))
877	{
878	LogRel(("VMSVGA3d: Error resolving extension functions: %Rrc\n", rc));
879	return rc;
880	}
881	#endif
882
883	LogRel(("VMSVGA3d: OpenGL version: %s\n"
884	"VMSVGA3d: OpenGL Vendor: %s\n"
885	"VMSVGA3d: OpenGL Renderer: %s\n"
886	"VMSVGA3d: OpenGL shader language version: %s\n",
887	glGetString(GL_VERSION), glGetString(GL_VENDOR), glGetString(GL_RENDERER),
888	glGetString(GL_SHADING_LANGUAGE_VERSION)));
889
890	rc = vmsvga3dGatherExtensions(&pState->pszExtensions, VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE);
891	AssertRCReturn(rc, rc);
892	vmsvga3dLogRelExtensions("", pState->pszExtensions);
893
894	pState->rsGLVersion = atof((const char *)glGetString(GL_VERSION));
895
896
897	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
898	/*
899	* Get the extension list for the alternative profile so we can better
900	* figure out the shader model and stuff.
901	*/
902	rc = vmsvga3dContextDefineOgl(pThisCC, 2, VMSVGA3D_DEF_CTX_F_INIT \| VMSVGA3D_DEF_CTX_F_OTHER_PROFILE);
903	AssertLogRelRCReturn(rc, rc);
904	pContext = pState->papContexts[1]; /* Array may have been reallocated. */
905
906	pOtherCtx = pState->papContexts[2];
907	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pOtherCtx);
908
909	LogRel(("VMSVGA3d: Alternative OpenGL version: %s\n"
910	"VMSVGA3d: Alternative OpenGL Vendor: %s\n"
911	"VMSVGA3d: Alternative OpenGL Renderer: %s\n"
912	"VMSVGA3d: Alternative OpenGL shader language version: %s\n",
913	glGetString(GL_VERSION), glGetString(GL_VENDOR), glGetString(GL_RENDERER),
914	glGetString(GL_SHADING_LANGUAGE_VERSION)));
915
916	rc = vmsvga3dGatherExtensions(&pState->pszOtherExtensions, VBOX_VMSVGA3D_OTHER_OGL_PROFILE);
917	AssertRCReturn(rc, rc);
918	vmsvga3dLogRelExtensions("Alternative ", pState->pszOtherExtensions);
919
920	pState->rsOtherGLVersion = atof((const char *)glGetString(GL_VERSION));
921
922	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
923	#else
924	pState->pszOtherExtensions = (char *)"";
925	pState->rsOtherGLVersion = pState->rsGLVersion;
926	#endif
927
928	/*
929	* Resolve GL function pointers and store them in pState->ext.
930	*/
931	rc = vmsvga3dLoadGLFunctions(pState);
932	if (RT_FAILURE(rc))
933	{
934	LogRel(("VMSVGA3d: missing required OpenGL function or extension; aborting\n"));
935	return rc;
936	}
937
938	/*
939	* Initialize the capabilities with sensible defaults.
940	*/
941	pState->caps.maxActiveLights = 1;
942	pState->caps.maxTextures = 1;
943	pState->caps.maxClipDistances = 4;
944	pState->caps.maxColorAttachments = 1;
945	pState->caps.maxRectangleTextureSize = 2048;
946	pState->caps.maxTextureAnisotropy = 1;
947	pState->caps.maxVertexShaderInstructions = 1024;
948	pState->caps.maxFragmentShaderInstructions = 1024;
949	pState->caps.vertexShaderVersion = SVGA3DVSVERSION_NONE;
950	pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_NONE;
951	pState->caps.flPointSize[0] = 1;
952	pState->caps.flPointSize[1] = 1;
953
954	/*
955	* Query capabilities
956	*/
957	pState->caps.fS3TCSupported = vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_texture_compression_s3tc ");
958	pState->caps.fTextureFilterAnisotropicSupported = vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_texture_filter_anisotropic ");
959
960	VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx, glGetIntegerv(GL_MAX_LIGHTS, &pState->caps.maxActiveLights));
961	VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx, glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &pState->caps.maxTextures));
962	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE /* The alternative profile has a higher number here (ati/darwin). */
963	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pOtherCtx);
964	VMSVGA3D_INIT_CHECKED_BOTH(pState, pOtherCtx, pContext, glGetIntegerv(GL_MAX_CLIP_DISTANCES, &pState->caps.maxClipDistances));
965	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
966	#else
967	VMSVGA3D_INIT_CHECKED(glGetIntegerv(GL_MAX_CLIP_DISTANCES, &pState->caps.maxClipDistances));
968	#endif
969	VMSVGA3D_INIT_CHECKED(glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &pState->caps.maxColorAttachments));
970	VMSVGA3D_INIT_CHECKED(glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE, &pState->caps.maxRectangleTextureSize));
971	if (pState->caps.fTextureFilterAnisotropicSupported)
972	VMSVGA3D_INIT_CHECKED(glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &pState->caps.maxTextureAnisotropy));
973	VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx, glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, pState->caps.flPointSize));
974
975	VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx,
976	pState->ext.glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB,
977	&pState->caps.maxFragmentShaderTemps));
978	VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx,
979	pState->ext.glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB,
980	&pState->caps.maxFragmentShaderInstructions));
981	VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx,
982	pState->ext.glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB,
983	&pState->caps.maxVertexShaderTemps));
984	VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx,
985	pState->ext.glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB,
986	&pState->caps.maxVertexShaderInstructions));
987
988	/* http://http://www.opengl.org/wiki/Detecting_the_Shader_Model
989	* ARB Assembly Language
990	* These are done through testing the presence of extensions. You should test them in this order:
991	* GL_NV_gpu_program4: SM 4.0 or better.
992	* GL_NV_vertex_program3: SM 3.0 or better.
993	* GL_ARB_fragment_program: SM 2.0 or better.
994	* ATI does not support higher than SM 2.0 functionality in assembly shaders.
995	*
996	*/
997	/** @todo distinguish between vertex and pixel shaders??? */
998	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE /* The alternative profile has a higher number here (ati/darwin). */
999	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pOtherCtx);
1000	const char pszShadingLanguageVersion = (const char )glGetString(GL_SHADING_LANGUAGE_VERSION);
1001	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
1002	#else
1003	const char pszShadingLanguageVersion = (const char )glGetString(GL_SHADING_LANGUAGE_VERSION);
1004	#endif
1005	float v = pszShadingLanguageVersion ? atof(pszShadingLanguageVersion) : 0.0f;
1006	if ( vmsvga3dCheckGLExtension(pState, 0.0f, " GL_NV_gpu_program4 ")
1007	\|\| strstr(pState->pszOtherExtensions, " GL_NV_gpu_program4 "))
1008	{
1009	pState->caps.vertexShaderVersion = SVGA3DVSVERSION_40;
1010	pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_40;
1011	}
1012	else
1013	if ( vmsvga3dCheckGLExtension(pState, 0.0f, " GL_NV_vertex_program3 ")
1014	\|\| strstr(pState->pszOtherExtensions, " GL_NV_vertex_program3 ")
1015	\|\| vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_shader_texture_lod ") /* Wine claims this suggests SM 3.0 support */
1016	\|\| strstr(pState->pszOtherExtensions, " GL_ARB_shader_texture_lod ")
1017	)
1018	{
1019	pState->caps.vertexShaderVersion = SVGA3DVSVERSION_30;
1020	pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_30;
1021	}
1022	else
1023	if ( vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_fragment_program ")
1024	\|\| strstr(pState->pszOtherExtensions, " GL_ARB_fragment_program "))
1025	{
1026	pState->caps.vertexShaderVersion = SVGA3DVSVERSION_20;
1027	pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_20;
1028	}
1029	else
1030	{
1031	LogRel(("VMSVGA3D: WARNING: unknown support for assembly shaders!!\n"));
1032	pState->caps.vertexShaderVersion = SVGA3DVSVERSION_11;
1033	pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_11;
1034	}
1035
1036	/* Now check the shading language version, in case it indicates a higher supported version. */
1037	if (v >= 3.30f)
1038	{
1039	pState->caps.vertexShaderVersion = RT_MAX(pState->caps.vertexShaderVersion, SVGA3DVSVERSION_40);
1040	pState->caps.fragmentShaderVersion = RT_MAX(pState->caps.fragmentShaderVersion, SVGA3DPSVERSION_40);
1041	}
1042	else
1043	if (v >= 1.20f)
1044	{
1045	pState->caps.vertexShaderVersion = RT_MAX(pState->caps.vertexShaderVersion, SVGA3DVSVERSION_20);
1046	pState->caps.fragmentShaderVersion = RT_MAX(pState->caps.fragmentShaderVersion, SVGA3DPSVERSION_20);
1047	}
1048
1049	if ( !vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_vertex_array_bgra ")
1050	&& !vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_vertex_array_bgra "))
1051	{
1052	LogRel(("VMSVGA3D: WARNING: Missing required extension GL_ARB_vertex_array_bgra (d3dcolor)!!!\n"));
1053	}
1054
1055	/*
1056	* Tweak capabilities.
1057	*/
1058	/* Intel Windows drivers return 31, while the guest expects 32 at least. */
1059	if ( pState->caps.maxVertexShaderTemps < 32
1060	&& vmsvga3dIsVendorIntel())
1061	pState->caps.maxVertexShaderTemps = 32;
1062
1063	#if 0
1064	SVGA3D_DEVCAP_MAX_FIXED_VERTEXBLEND = 11,
1065	SVGA3D_DEVCAP_QUERY_TYPES = 15,
1066	SVGA3D_DEVCAP_TEXTURE_GRADIENT_SAMPLING = 16,
1067	SVGA3D_DEVCAP_MAX_POINT_SIZE = 17,
1068	SVGA3D_DEVCAP_MAX_SHADER_TEXTURES = 18,
1069	SVGA3D_DEVCAP_MAX_VOLUME_EXTENT = 21,
1070	SVGA3D_DEVCAP_MAX_TEXTURE_REPEAT = 22,
1071	SVGA3D_DEVCAP_MAX_TEXTURE_ASPECT_RATIO = 23,
1072	SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY = 24,
1073	SVGA3D_DEVCAP_MAX_PRIMITIVE_COUNT = 25,
1074	SVGA3D_DEVCAP_MAX_VERTEX_INDEX = 26,
1075	SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS = 28,
1076	SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS = 29,
1077	SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS = 30,
1078	SVGA3D_DEVCAP_TEXTURE_OPS = 31,
1079	SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8 = 32,
1080	SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8 = 33,
1081	SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10 = 34,
1082	SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5 = 35,
1083	SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5 = 36,
1084	SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4 = 37,
1085	SVGA3D_DEVCAP_SURFACEFMT_R5G6B5 = 38,
1086	SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16 = 39,
1087	SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8 = 40,
1088	SVGA3D_DEVCAP_SURFACEFMT_ALPHA8 = 41,
1089	SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8 = 42,
1090	SVGA3D_DEVCAP_SURFACEFMT_Z_D16 = 43,
1091	SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8 = 44,
1092	SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8 = 45,
1093	SVGA3D_DEVCAP_SURFACEFMT_DXT1 = 46,
1094	SVGA3D_DEVCAP_SURFACEFMT_DXT2 = 47,
1095	SVGA3D_DEVCAP_SURFACEFMT_DXT3 = 48,
1096	SVGA3D_DEVCAP_SURFACEFMT_DXT4 = 49,
1097	SVGA3D_DEVCAP_SURFACEFMT_DXT5 = 50,
1098	SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8 = 51,
1099	SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10 = 52,
1100	SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8 = 53,
1101	SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8 = 54,
1102	SVGA3D_DEVCAP_SURFACEFMT_CxV8U8 = 55,
1103	SVGA3D_DEVCAP_SURFACEFMT_R_S10E5 = 56,
1104	SVGA3D_DEVCAP_SURFACEFMT_R_S23E8 = 57,
1105	SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5 = 58,
1106	SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8 = 59,
1107	SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5 = 60,
1108	SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8 = 61,
1109	SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEXTURES = 63,
1110	SVGA3D_DEVCAP_SURFACEFMT_V16U16 = 65,
1111	SVGA3D_DEVCAP_SURFACEFMT_G16R16 = 66,
1112	SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16 = 67,
1113	SVGA3D_DEVCAP_SURFACEFMT_UYVY = 68,
1114	SVGA3D_DEVCAP_SURFACEFMT_YUY2 = 69,
1115	SVGA3D_DEVCAP_MULTISAMPLE_NONMASKABLESAMPLES = 70,
1116	SVGA3D_DEVCAP_MULTISAMPLE_MASKABLESAMPLES = 71,
1117	SVGA3D_DEVCAP_ALPHATOCOVERAGE = 72,
1118	SVGA3D_DEVCAP_SUPERSAMPLE = 73,
1119	SVGA3D_DEVCAP_AUTOGENMIPMAPS = 74,
1120	SVGA3D_DEVCAP_SURFACEFMT_NV12 = 75,
1121	SVGA3D_DEVCAP_SURFACEFMT_AYUV = 76,
1122	SVGA3D_DEVCAP_SURFACEFMT_Z_DF16 = 79,
1123	SVGA3D_DEVCAP_SURFACEFMT_Z_DF24 = 80,
1124	SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT = 81,
1125	SVGA3D_DEVCAP_SURFACEFMT_ATI1 = 82,
1126	SVGA3D_DEVCAP_SURFACEFMT_ATI2 = 83,
1127	#endif
1128
1129	LogRel(("VMSVGA3d: Capabilities:\n"));
1130	LogRel(("VMSVGA3d: maxActiveLights=%-2d maxTextures=%-2d\n",
1131	pState->caps.maxActiveLights, pState->caps.maxTextures));
1132	LogRel(("VMSVGA3d: maxClipDistances=%-2d maxColorAttachments=%-2d maxClipDistances=%d\n",
1133	pState->caps.maxClipDistances, pState->caps.maxColorAttachments, pState->caps.maxClipDistances));
1134	LogRel(("VMSVGA3d: maxColorAttachments=%-2d maxTextureAnisotropy=%-2d maxRectangleTextureSize=%d\n",
1135	pState->caps.maxColorAttachments, pState->caps.maxTextureAnisotropy, pState->caps.maxRectangleTextureSize));
1136	LogRel(("VMSVGA3d: maxVertexShaderTemps=%-2d maxVertexShaderInstructions=%d maxFragmentShaderInstructions=%d\n",
1137	pState->caps.maxVertexShaderTemps, pState->caps.maxVertexShaderInstructions, pState->caps.maxFragmentShaderInstructions));
1138	LogRel(("VMSVGA3d: maxFragmentShaderTemps=%d flPointSize={%d.%02u, %d.%02u}\n",
1139	pState->caps.maxFragmentShaderTemps,
1140	(int)pState->caps.flPointSize[0], (int)(pState->caps.flPointSize[0] * 100) % 100,
1141	(int)pState->caps.flPointSize[1], (int)(pState->caps.flPointSize[1] * 100) % 100));
1142	LogRel(("VMSVGA3d: fragmentShaderVersion=%-2d vertexShaderVersion=%-2d\n",
1143	pState->caps.fragmentShaderVersion, pState->caps.vertexShaderVersion));
1144	LogRel(("VMSVGA3d: fS3TCSupported=%-2d fTextureFilterAnisotropicSupported=%d\n",
1145	pState->caps.fS3TCSupported, pState->caps.fTextureFilterAnisotropicSupported));
1146
1147
1148	/* Initialize the shader library. */
1149	pState->ShaderIf.pfnSwitchInitProfile = vmsvga3dShaderIfSwitchInitProfile;
1150	pState->ShaderIf.pfnGetNextExtension = vmsvga3dShaderIfGetNextExtension;
1151	rc = ShaderInitLib(&pState->ShaderIf);
1152	AssertRC(rc);
1153
1154	/* Cleanup */
1155	rc = vmsvga3dBackContextDestroy(pThisCC, 1);
1156	AssertRC(rc);
1157	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
1158	rc = vmsvga3dBackContextDestroy(pThisCC, 2);
1159	AssertRC(rc);
1160	#endif
1161
1162	if ( pState->rsGLVersion < 3.0
1163	&& pState->rsOtherGLVersion < 3.0 /* darwin: legacy profile hack */)
1164	{
1165	LogRel(("VMSVGA3d: unsupported OpenGL version; minimum is 3.0\n"));
1166	return VERR_NOT_IMPLEMENTED;
1167	}
1168
1169	return VINF_SUCCESS;
1170	}
1171
1172	static DECLCALLBACK(int) vmsvga3dBackReset(PVGASTATECC pThisCC)
1173	{
1174	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1175	AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
1176
1177	if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
1178	vmsvga3dContextDestroyOgl(pThisCC, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID);
1179
1180	return VINF_SUCCESS;
1181	}
1182
1183	static DECLCALLBACK(int) vmsvga3dBackTerminate(PVGASTATECC pThisCC)
1184	{
1185	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1186	AssertReturn(pState, VERR_WRONG_ORDER);
1187	int rc;
1188
1189	/* Terminate the shader library. */
1190	rc = ShaderDestroyLib();
1191	AssertRC(rc);
1192
1193	#ifdef RT_OS_WINDOWS
1194	/* Terminate the window creation thread. */
1195	rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_EXIT, 0, 0);
1196	AssertRCReturn(rc, rc);
1197
1198	RTSemEventDestroy(pState->WndRequestSem);
1199	#elif defined(RT_OS_DARWIN)
1200
1201	#elif defined(RT_OS_LINUX)
1202	/* signal to the thread that it is supposed to exit */
1203	pState->bTerminate = true;
1204	/* wait for it to terminate */
1205	rc = RTThreadWait(pState->pWindowThread, 10000, NULL);
1206	AssertRC(rc);
1207	XCloseDisplay(pState->display);
1208	#endif
1209
1210	RTStrFree(pState->pszExtensions);
1211	pState->pszExtensions = NULL;
1212	#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
1213	RTStrFree(pState->pszOtherExtensions);
1214	#endif
1215	pState->pszOtherExtensions = NULL;
1216
1217	return VINF_SUCCESS;
1218	}
1219
1220
1221	static DECLCALLBACK(void) vmsvga3dBackUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
1222	{
1223	/** @todo Move the visible framebuffer content here, don't wait for the guest to
1224	* redraw it. */
1225
1226	#ifdef RT_OS_DARWIN
1227	RT_NOREF(pOldViewport);
1228	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1229	if ( pState
1230	&& idScreen == 0
1231	&& pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
1232	{
1233	vmsvga3dCocoaViewUpdateViewport(pState->SharedCtx.cocoaView);
1234	}
1235	#else
1236	RT_NOREF(pThisCC, idScreen, pOldViewport);
1237	#endif
1238	}
1239
1240
1241	/**
1242	* Worker for vmsvga3dBackQueryCaps that figures out supported operations for a
1243	* given surface format capability.
1244	*
1245	* @returns Supported/indented operations (SVGA3DFORMAT_OP_XXX).
1246	* @param idx3dCaps The SVGA3D_CAPS_XXX value of the surface format.
1247	*
1248	* @remarks See fromat_cap_table in svga_format.c (mesa/gallium) for a reference
1249	* of implicit guest expectations:
1250	* http://cgit.freedesktop.org/mesa/mesa/tree/src/gallium/drivers/svga/svga_format.c
1251	*/
1252	static uint32_t vmsvga3dGetSurfaceFormatSupport(uint32_t idx3dCaps)
1253	{
1254	uint32_t result = 0;
1255
1256	/** @todo missing:
1257	*
1258	* SVGA3DFORMAT_OP_PIXELSIZE
1259	*/
1260
1261	switch (idx3dCaps)
1262	{
1263	case SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
1264	case SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
1265	case SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
1266	result \|= SVGA3DFORMAT_OP_MEMBEROFGROUP_ARGB
1267	\| SVGA3DFORMAT_OP_CONVERT_TO_ARGB
1268	\| SVGA3DFORMAT_OP_DISPLAYMODE /* Should not be set for alpha formats. */
1269	\| SVGA3DFORMAT_OP_3DACCELERATION; /* implies OP_DISPLAYMODE */
1270	break;
1271
1272	case SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
1273	case SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
1274	case SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
1275	case SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
1276	result \|= SVGA3DFORMAT_OP_MEMBEROFGROUP_ARGB
1277	\| SVGA3DFORMAT_OP_CONVERT_TO_ARGB
1278	\| SVGA3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET;
1279	break;
1280	}
1281
1282	/** @todo check hardware caps! */
1283	switch (idx3dCaps)
1284	{
1285	case SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
1286	case SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
1287	case SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
1288	case SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
1289	case SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
1290	case SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
1291	case SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
1292	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16:
1293	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8:
1294	case SVGA3D_DEVCAP_SURFACEFMT_ALPHA8:
1295	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8:
1296	result \|= SVGA3DFORMAT_OP_TEXTURE
1297	\| SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET
1298	\| SVGA3DFORMAT_OP_OFFSCREENPLAIN
1299	\| SVGA3DFORMAT_OP_SAME_FORMAT_RENDERTARGET
1300	\| SVGA3DFORMAT_OP_VOLUMETEXTURE
1301	\| SVGA3DFORMAT_OP_CUBETEXTURE
1302	\| SVGA3DFORMAT_OP_SRGBREAD
1303	\| SVGA3DFORMAT_OP_SRGBWRITE;
1304	break;
1305
1306	case SVGA3D_DEVCAP_SURFACEFMT_Z_D16:
1307	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8:
1308	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8:
1309	case SVGA3D_DEVCAP_SURFACEFMT_Z_DF16:
1310	case SVGA3D_DEVCAP_SURFACEFMT_Z_DF24:
1311	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT:
1312	result \|= SVGA3DFORMAT_OP_ZSTENCIL
1313	\| SVGA3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH
1314	\| SVGA3DFORMAT_OP_TEXTURE /* Necessary for Ubuntu Unity */;
1315	break;
1316
1317	case SVGA3D_DEVCAP_SURFACEFMT_DXT1:
1318	case SVGA3D_DEVCAP_SURFACEFMT_DXT2:
1319	case SVGA3D_DEVCAP_SURFACEFMT_DXT3:
1320	case SVGA3D_DEVCAP_SURFACEFMT_DXT4:
1321	case SVGA3D_DEVCAP_SURFACEFMT_DXT5:
1322	result \|= SVGA3DFORMAT_OP_TEXTURE
1323	\| SVGA3DFORMAT_OP_VOLUMETEXTURE
1324	\| SVGA3DFORMAT_OP_CUBETEXTURE
1325	\| SVGA3DFORMAT_OP_SRGBREAD;
1326	break;
1327
1328	case SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8:
1329	case SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10:
1330	case SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8:
1331	case SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8:
1332	case SVGA3D_DEVCAP_SURFACEFMT_CxV8U8:
1333	break;
1334
1335	case SVGA3D_DEVCAP_SURFACEFMT_R_S10E5:
1336	case SVGA3D_DEVCAP_SURFACEFMT_R_S23E8:
1337	case SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5:
1338	case SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8:
1339	case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5:
1340	case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8:
1341	result \|= SVGA3DFORMAT_OP_TEXTURE
1342	\| SVGA3DFORMAT_OP_VOLUMETEXTURE
1343	\| SVGA3DFORMAT_OP_CUBETEXTURE
1344	\| SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
1345	break;
1346
1347	case SVGA3D_DEVCAP_SURFACEFMT_V16U16:
1348	case SVGA3D_DEVCAP_SURFACEFMT_G16R16:
1349	case SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16:
1350	result \|= SVGA3DFORMAT_OP_TEXTURE
1351	\| SVGA3DFORMAT_OP_VOLUMETEXTURE
1352	\| SVGA3DFORMAT_OP_CUBETEXTURE
1353	\| SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
1354	break;
1355
1356	case SVGA3D_DEVCAP_SURFACEFMT_UYVY:
1357	case SVGA3D_DEVCAP_SURFACEFMT_YUY2:
1358	result \|= SVGA3DFORMAT_OP_OFFSCREENPLAIN
1359	\| SVGA3DFORMAT_OP_CONVERT_TO_ARGB
1360	\| SVGA3DFORMAT_OP_TEXTURE;
1361	break;
1362
1363	case SVGA3D_DEVCAP_SURFACEFMT_NV12:
1364	case SVGA3D_DEVCAP_DEAD10: /* SVGA3D_DEVCAP_SURFACEFMT_AYUV */
1365	break;
1366	}
1367	Log(("CAPS: %s =\n%s\n", vmsvga3dGetCapString(idx3dCaps), vmsvga3dGet3dFormatString(result)));
1368
1369	return result;
1370	}
1371
1372	#if 0 /* unused */
1373	static uint32_t vmsvga3dGetDepthFormatSupport(PVMSVGA3DSTATE pState3D, uint32_t idx3dCaps)
1374	{
1375	RT_NOREF(pState3D, idx3dCaps);
1376
1377	/** @todo test this somehow */
1378	uint32_t result = SVGA3DFORMAT_OP_ZSTENCIL \| SVGA3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH;
1379
1380	Log(("CAPS: %s =\n%s\n", vmsvga3dGetCapString(idx3dCaps), vmsvga3dGet3dFormatString(result)));
1381	return result;
1382	}
1383	#endif
1384
1385
1386	static DECLCALLBACK(int) vmsvga3dBackQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
1387	{
1388	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1389	AssertReturn(pState, VERR_NO_MEMORY);
1390	int rc = VINF_SUCCESS;
1391
1392	*pu32Val = 0;
1393
1394	/*
1395	* The capabilities access by current (2015-03-01) linux sources (gallium,
1396	* vmwgfx, xorg-video-vmware) are annotated, caps without xref annotations
1397	* aren't access.
1398	*/
1399
1400	switch (idx3dCaps)
1401	{
1402	/* Linux: vmwgfx_fifo.c in kmod; only used with SVGA_CAP_GBOBJECTS. */
1403	case SVGA3D_DEVCAP_3D:
1404	pu32Val = 1; / boolean? */
1405	break;
1406
1407	case SVGA3D_DEVCAP_MAX_LIGHTS:
1408	*pu32Val = pState->caps.maxActiveLights;
1409	break;
1410
1411	case SVGA3D_DEVCAP_MAX_TEXTURES:
1412	*pu32Val = pState->caps.maxTextures;
1413	break;
1414
1415	case SVGA3D_DEVCAP_MAX_CLIP_PLANES:
1416	*pu32Val = pState->caps.maxClipDistances;
1417	break;
1418
1419	/* Linux: svga_screen.c in gallium; 3.0 or later required. */
1420	case SVGA3D_DEVCAP_VERTEX_SHADER_VERSION:
1421	*pu32Val = pState->caps.vertexShaderVersion;
1422	break;
1423
1424	case SVGA3D_DEVCAP_VERTEX_SHADER:
1425	/* boolean? */
1426	*pu32Val = (pState->caps.vertexShaderVersion != SVGA3DVSVERSION_NONE);
1427	break;
1428
1429	/* Linux: svga_screen.c in gallium; 3.0 or later required. */
1430	case SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION:
1431	*pu32Val = pState->caps.fragmentShaderVersion;
1432	break;
1433
1434	case SVGA3D_DEVCAP_FRAGMENT_SHADER:
1435	/* boolean? */
1436	*pu32Val = (pState->caps.fragmentShaderVersion != SVGA3DPSVERSION_NONE);
1437	break;
1438
1439	case SVGA3D_DEVCAP_S23E8_TEXTURES:
1440	case SVGA3D_DEVCAP_S10E5_TEXTURES:
1441	/* Must be obsolete by now; surface format caps specify the same thing. */
1442	rc = VERR_INVALID_PARAMETER;
1443	break;
1444
1445	case SVGA3D_DEVCAP_MAX_FIXED_VERTEXBLEND:
1446	break;
1447
1448	/*
1449	* 2. The BUFFER_FORMAT capabilities are deprecated, and they always
1450	* return TRUE. Even on physical hardware that does not support
1451	* these formats natively, the SVGA3D device will provide an emulation
1452	* which should be invisible to the guest OS.
1453	*/
1454	case SVGA3D_DEVCAP_D16_BUFFER_FORMAT:
1455	case SVGA3D_DEVCAP_D24S8_BUFFER_FORMAT:
1456	case SVGA3D_DEVCAP_D24X8_BUFFER_FORMAT:
1457	*pu32Val = 1;
1458	break;
1459
1460	case SVGA3D_DEVCAP_QUERY_TYPES:
1461	break;
1462
1463	case SVGA3D_DEVCAP_TEXTURE_GRADIENT_SAMPLING:
1464	break;
1465
1466	/* Linux: svga_screen.c in gallium; capped at 80.0, default 1.0. */
1467	case SVGA3D_DEVCAP_MAX_POINT_SIZE:
1468	AssertCompile(sizeof(uint32_t) == sizeof(float));
1469	(float )pu32Val = pState->caps.flPointSize[1];
1470	break;
1471
1472	case SVGA3D_DEVCAP_MAX_SHADER_TEXTURES:
1473	/** @todo ?? */
1474	rc = VERR_INVALID_PARAMETER;
1475	break;
1476
1477	/* Linux: svga_screen.c in gallium (for PIPE_CAP_MAX_TEXTURE_2D_LEVELS); have default if missing. */
1478	case SVGA3D_DEVCAP_MAX_TEXTURE_WIDTH:
1479	case SVGA3D_DEVCAP_MAX_TEXTURE_HEIGHT:
1480	*pu32Val = pState->caps.maxRectangleTextureSize;
1481	break;
1482
1483	/* Linux: svga_screen.c in gallium (for PIPE_CAP_MAX_TEXTURE_3D_LEVELS); have default if missing. */
1484	case SVGA3D_DEVCAP_MAX_VOLUME_EXTENT:
1485	//*pu32Val = pCaps->MaxVolumeExtent;
1486	*pu32Val = 256;
1487	break;
1488
1489	case SVGA3D_DEVCAP_MAX_TEXTURE_REPEAT:
1490	pu32Val = 32768; / hardcoded in Wine */
1491	break;
1492
1493	case SVGA3D_DEVCAP_MAX_TEXTURE_ASPECT_RATIO:
1494	//*pu32Val = pCaps->MaxTextureAspectRatio;
1495	break;
1496
1497	/* Linux: svga_screen.c in gallium (for PIPE_CAPF_MAX_TEXTURE_ANISOTROPY); defaults to 4.0. */
1498	case SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY:
1499	*pu32Val = pState->caps.maxTextureAnisotropy;
1500	break;
1501
1502	case SVGA3D_DEVCAP_MAX_PRIMITIVE_COUNT:
1503	case SVGA3D_DEVCAP_MAX_VERTEX_INDEX:
1504	pu32Val = 0xFFFFF; / hardcoded in Wine */
1505	break;
1506
1507	/* Linux: svga_screen.c in gallium (for PIPE_SHADER_VERTEX/PIPE_SHADER_CAP_MAX_INSTRUCTIONS); defaults to 512. */
1508	case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_INSTRUCTIONS:
1509	*pu32Val = pState->caps.maxVertexShaderInstructions;
1510	break;
1511
1512	case SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS:
1513	*pu32Val = pState->caps.maxFragmentShaderInstructions;
1514	break;
1515
1516	/* Linux: svga_screen.c in gallium (for PIPE_SHADER_VERTEX/PIPE_SHADER_CAP_MAX_TEMPS); defaults to 32. */
1517	case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS:
1518	*pu32Val = pState->caps.maxVertexShaderTemps;
1519	break;
1520
1521	/* Linux: svga_screen.c in gallium (for PIPE_SHADER_FRAGMENT/PIPE_SHADER_CAP_MAX_TEMPS); defaults to 32. */
1522	case SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS:
1523	*pu32Val = pState->caps.maxFragmentShaderTemps;
1524	break;
1525
1526	case SVGA3D_DEVCAP_TEXTURE_OPS:
1527	break;
1528
1529	case SVGA3D_DEVCAP_DEAD4: /* SVGA3D_DEVCAP_MULTISAMPLE_NONMASKABLESAMPLES */
1530	break;
1531
1532	case SVGA3D_DEVCAP_DEAD5: /* SVGA3D_DEVCAP_MULTISAMPLE_MASKABLESAMPLES */
1533	break;
1534
1535	case SVGA3D_DEVCAP_DEAD7: /* SVGA3D_DEVCAP_ALPHATOCOVERAGE */
1536	break;
1537
1538	case SVGA3D_DEVCAP_DEAD6: /* SVGA3D_DEVCAP_SUPERSAMPLE */
1539	break;
1540
1541	case SVGA3D_DEVCAP_AUTOGENMIPMAPS:
1542	//*pu32Val = !!(pCaps->Caps2 & D3DCAPS2_CANAUTOGENMIPMAP);
1543	break;
1544
1545	case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEXTURES:
1546	break;
1547
1548	case SVGA3D_DEVCAP_MAX_RENDER_TARGETS: /** @todo same thing? */
1549	case SVGA3D_DEVCAP_MAX_SIMULTANEOUS_RENDER_TARGETS:
1550	*pu32Val = pState->caps.maxColorAttachments;
1551	break;
1552
1553	/*
1554	* This is the maximum number of SVGA context IDs that the guest
1555	* can define using SVGA_3D_CMD_CONTEXT_DEFINE.
1556	*/
1557	case SVGA3D_DEVCAP_MAX_CONTEXT_IDS:
1558	*pu32Val = SVGA3D_MAX_CONTEXT_IDS;
1559	break;
1560
1561	/*
1562	* This is the maximum number of SVGA surface IDs that the guest
1563	* can define using SVGA_3D_CMD_SURFACE_DEFINE*.
1564	*/
1565	case SVGA3D_DEVCAP_MAX_SURFACE_IDS:
1566	*pu32Val = SVGA3D_MAX_SURFACE_IDS;
1567	break;
1568
1569	#if 0 /* Appeared more recently, not yet implemented. */
1570	/* Linux: svga_screen.c in gallium; defaults to FALSE. */
1571	case SVGA3D_DEVCAP_LINE_AA:
1572	break;
1573	/* Linux: svga_screen.c in gallium; defaults to FALSE. */
1574	case SVGA3D_DEVCAP_LINE_STIPPLE:
1575	break;
1576	/* Linux: svga_screen.c in gallium; defaults to 1.0. */
1577	case SVGA3D_DEVCAP_MAX_LINE_WIDTH:
1578	break;
1579	/* Linux: svga_screen.c in gallium; defaults to 1.0. */
1580	case SVGA3D_DEVCAP_MAX_AA_LINE_WIDTH:
1581	break;
1582	#endif
1583
1584	/*
1585	* Supported surface formats.
1586	* Linux: svga_format.c in gallium, format_cap_table defines implicit expectations.
1587	*/
1588	case SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
1589	case SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
1590	case SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
1591	case SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
1592	case SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
1593	case SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
1594	case SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
1595	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16:
1596	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8:
1597	case SVGA3D_DEVCAP_SURFACEFMT_ALPHA8:
1598	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8:
1599	case SVGA3D_DEVCAP_SURFACEFMT_Z_D16:
1600	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8:
1601	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8:
1602	case SVGA3D_DEVCAP_SURFACEFMT_Z_DF16:
1603	case SVGA3D_DEVCAP_SURFACEFMT_Z_DF24:
1604	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT:
1605	case SVGA3D_DEVCAP_SURFACEFMT_DXT1:
1606	*pu32Val = vmsvga3dGetSurfaceFormatSupport(idx3dCaps);
1607	break;
1608
1609	case SVGA3D_DEVCAP_SURFACEFMT_DXT2:
1610	case SVGA3D_DEVCAP_SURFACEFMT_DXT3:
1611	case SVGA3D_DEVCAP_SURFACEFMT_DXT4:
1612	case SVGA3D_DEVCAP_SURFACEFMT_DXT5:
1613	case SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8:
1614	case SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10:
1615	case SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8:
1616	case SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8:
1617	case SVGA3D_DEVCAP_SURFACEFMT_CxV8U8:
1618	case SVGA3D_DEVCAP_SURFACEFMT_R_S10E5:
1619	case SVGA3D_DEVCAP_SURFACEFMT_R_S23E8:
1620	case SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5:
1621	case SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8:
1622	case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5:
1623	case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8:
1624	case SVGA3D_DEVCAP_SURFACEFMT_V16U16:
1625	case SVGA3D_DEVCAP_SURFACEFMT_G16R16:
1626	case SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16:
1627	case SVGA3D_DEVCAP_SURFACEFMT_UYVY:
1628	case SVGA3D_DEVCAP_SURFACEFMT_YUY2:
1629	case SVGA3D_DEVCAP_SURFACEFMT_NV12:
1630	case SVGA3D_DEVCAP_DEAD10: /* SVGA3D_DEVCAP_SURFACEFMT_AYUV */
1631	*pu32Val = vmsvga3dGetSurfaceFormatSupport(idx3dCaps);
1632	break;
1633
1634	/* Linux: Not referenced in current sources. */
1635	case SVGA3D_DEVCAP_SURFACEFMT_ATI1:
1636	case SVGA3D_DEVCAP_SURFACEFMT_ATI2:
1637	Log(("CAPS: Unknown CAP %s\n", vmsvga3dGetCapString(idx3dCaps)));
1638	rc = VERR_INVALID_PARAMETER;
1639	*pu32Val = 0;
1640	break;
1641
1642	default:
1643	Log(("CAPS: Unexpected CAP %d\n", idx3dCaps));
1644	rc = VERR_INVALID_PARAMETER;
1645	break;
1646	}
1647
1648	Log(("CAPS: %s - %x\n", vmsvga3dGetCapString(idx3dCaps), *pu32Val));
1649	return rc;
1650	}
1651
1652	/**
1653	* Convert SVGA format value to its OpenGL equivalent
1654	*
1655	* @remarks Clues to be had in format_texture_info table (wined3d/utils.c) with
1656	* help from wined3dformat_from_d3dformat().
1657	*/
1658	void vmsvga3dSurfaceFormat2OGL(PVMSVGA3DSURFACE pSurface, SVGA3dSurfaceFormat format)
1659	{
1660	#if 0
1661	#define AssertTestFmt(f) AssertMsgFailed(("Test me - " #f "\n"))
1662	#else
1663	#define AssertTestFmt(f) do {} while(0)
1664	#endif
1665	/* Init cbBlockGL for non-emulated formats. */
1666	pSurface->cbBlockGL = pSurface->cbBlock;
1667
1668	switch (format)
1669	{
1670	case SVGA3D_X8R8G8B8: /* D3DFMT_X8R8G8B8 - WINED3DFMT_B8G8R8X8_UNORM */
1671	pSurface->internalFormatGL = GL_RGB8;
1672	pSurface->formatGL = GL_BGRA;
1673	pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1674	break;
1675	case SVGA3D_A8R8G8B8: /* D3DFMT_A8R8G8B8 - WINED3DFMT_B8G8R8A8_UNORM */
1676	pSurface->internalFormatGL = GL_RGBA8;
1677	pSurface->formatGL = GL_BGRA;
1678	pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1679	break;
1680	case SVGA3D_R5G6B5: /* D3DFMT_R5G6B5 - WINED3DFMT_B5G6R5_UNORM */
1681	pSurface->internalFormatGL = GL_RGB5;
1682	pSurface->formatGL = GL_RGB;
1683	pSurface->typeGL = GL_UNSIGNED_SHORT_5_6_5;
1684	AssertTestFmt(SVGA3D_R5G6B5);
1685	break;
1686	case SVGA3D_X1R5G5B5: /* D3DFMT_X1R5G5B5 - WINED3DFMT_B5G5R5X1_UNORM */
1687	pSurface->internalFormatGL = GL_RGB5;
1688	pSurface->formatGL = GL_BGRA;
1689	pSurface->typeGL = GL_UNSIGNED_SHORT_1_5_5_5_REV;
1690	AssertTestFmt(SVGA3D_X1R5G5B5);
1691	break;
1692	case SVGA3D_A1R5G5B5: /* D3DFMT_A1R5G5B5 - WINED3DFMT_B5G5R5A1_UNORM */
1693	pSurface->internalFormatGL = GL_RGB5_A1;
1694	pSurface->formatGL = GL_BGRA;
1695	pSurface->typeGL = GL_UNSIGNED_SHORT_1_5_5_5_REV;
1696	AssertTestFmt(SVGA3D_A1R5G5B5);
1697	break;
1698	case SVGA3D_A4R4G4B4: /* D3DFMT_A4R4G4B4 - WINED3DFMT_B4G4R4A4_UNORM */
1699	pSurface->internalFormatGL = GL_RGBA4;
1700	pSurface->formatGL = GL_BGRA;
1701	pSurface->typeGL = GL_UNSIGNED_SHORT_4_4_4_4_REV;
1702	AssertTestFmt(SVGA3D_A4R4G4B4);
1703	break;
1704
1705	case SVGA3D_R8G8B8A8_UNORM:
1706	pSurface->internalFormatGL = GL_RGBA8;
1707	pSurface->formatGL = GL_RGBA;
1708	pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1709	break;
1710
1711	case SVGA3D_Z_D32: /* D3DFMT_D32 - WINED3DFMT_D32_UNORM */
1712	pSurface->internalFormatGL = GL_DEPTH_COMPONENT32;
1713	pSurface->formatGL = GL_DEPTH_COMPONENT;
1714	pSurface->typeGL = GL_UNSIGNED_INT;
1715	break;
1716	case SVGA3D_Z_D16: /* D3DFMT_D16 - WINED3DFMT_D16_UNORM */
1717	pSurface->internalFormatGL = GL_DEPTH_COMPONENT16; /** @todo Wine suggests GL_DEPTH_COMPONENT24. */
1718	pSurface->formatGL = GL_DEPTH_COMPONENT;
1719	pSurface->typeGL = GL_UNSIGNED_SHORT;
1720	AssertTestFmt(SVGA3D_Z_D16);
1721	break;
1722	case SVGA3D_Z_D24S8: /* D3DFMT_D24S8 - WINED3DFMT_D24_UNORM_S8_UINT */
1723	pSurface->internalFormatGL = GL_DEPTH24_STENCIL8;
1724	pSurface->formatGL = GL_DEPTH_STENCIL;
1725	pSurface->typeGL = GL_UNSIGNED_INT_24_8;
1726	break;
1727	case SVGA3D_Z_D15S1: /* D3DFMT_D15S1 - WINED3DFMT_S1_UINT_D15_UNORM */
1728	pSurface->internalFormatGL = GL_DEPTH_COMPONENT16; /** @todo ??? */
1729	pSurface->formatGL = GL_DEPTH_STENCIL;
1730	pSurface->typeGL = GL_UNSIGNED_SHORT;
1731	/** @todo Wine sources hints at no hw support for this, so test this one! */
1732	AssertTestFmt(SVGA3D_Z_D15S1);
1733	break;
1734	case SVGA3D_Z_D24X8: /* D3DFMT_D24X8 - WINED3DFMT_X8D24_UNORM */
1735	pSurface->internalFormatGL = GL_DEPTH_COMPONENT24;
1736	pSurface->formatGL = GL_DEPTH_COMPONENT;
1737	pSurface->typeGL = GL_UNSIGNED_INT;
1738	AssertTestFmt(SVGA3D_Z_D24X8);
1739	break;
1740
1741	/* Advanced D3D9 depth formats. */
1742	case SVGA3D_Z_DF16: /* D3DFMT_DF16? - not supported */
1743	pSurface->internalFormatGL = GL_DEPTH_COMPONENT16;
1744	pSurface->formatGL = GL_DEPTH_COMPONENT;
1745	pSurface->typeGL = GL_HALF_FLOAT;
1746	break;
1747
1748	case SVGA3D_Z_DF24: /* D3DFMT_DF24? - not supported */
1749	pSurface->internalFormatGL = GL_DEPTH_COMPONENT24;
1750	pSurface->formatGL = GL_DEPTH_COMPONENT;
1751	pSurface->typeGL = GL_FLOAT; /* ??? */
1752	break;
1753
1754	case SVGA3D_Z_D24S8_INT: /* D3DFMT_D24S8 */
1755	pSurface->internalFormatGL = GL_DEPTH24_STENCIL8;
1756	pSurface->formatGL = GL_DEPTH_STENCIL;
1757	pSurface->typeGL = GL_UNSIGNED_INT_24_8;
1758	break;
1759
1760	case SVGA3D_DXT1: /* D3DFMT_DXT1 - WINED3DFMT_DXT1 */
1761	pSurface->internalFormatGL = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
1762	pSurface->formatGL = GL_RGBA; /* not used */
1763	pSurface->typeGL = GL_UNSIGNED_BYTE; /* not used */
1764	break;
1765
1766	case SVGA3D_DXT2: /* D3DFMT_DXT2 */
1767	/* "DXT2 and DXT3 are the same from an API perspective." */
1768	RT_FALL_THRU();
1769	case SVGA3D_DXT3: /* D3DFMT_DXT3 - WINED3DFMT_DXT3 */
1770	pSurface->internalFormatGL = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
1771	pSurface->formatGL = GL_RGBA; /* not used */
1772	pSurface->typeGL = GL_UNSIGNED_BYTE; /* not used */
1773	break;
1774
1775	case SVGA3D_DXT4: /* D3DFMT_DXT4 */
1776	/* "DXT4 and DXT5 are the same from an API perspective." */
1777	RT_FALL_THRU();
1778	case SVGA3D_DXT5: /* D3DFMT_DXT5 - WINED3DFMT_DXT5 */
1779	pSurface->internalFormatGL = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
1780	pSurface->formatGL = GL_RGBA; /* not used */
1781	pSurface->typeGL = GL_UNSIGNED_BYTE; /* not used */
1782	break;
1783
1784	case SVGA3D_LUMINANCE8: /* D3DFMT_? - ? */
1785	pSurface->internalFormatGL = GL_LUMINANCE8_EXT;
1786	pSurface->formatGL = GL_LUMINANCE;
1787	pSurface->typeGL = GL_UNSIGNED_BYTE;
1788	break;
1789
1790	case SVGA3D_LUMINANCE16: /* D3DFMT_? - ? */
1791	pSurface->internalFormatGL = GL_LUMINANCE16_EXT;
1792	pSurface->formatGL = GL_LUMINANCE;
1793	pSurface->typeGL = GL_UNSIGNED_SHORT;
1794	break;
1795
1796	case SVGA3D_LUMINANCE4_ALPHA4: /* D3DFMT_? - ? */
1797	pSurface->internalFormatGL = GL_LUMINANCE4_ALPHA4_EXT;
1798	pSurface->formatGL = GL_LUMINANCE_ALPHA;
1799	pSurface->typeGL = GL_UNSIGNED_BYTE;
1800	break;
1801
1802	case SVGA3D_LUMINANCE8_ALPHA8: /* D3DFMT_? - ? */
1803	pSurface->internalFormatGL = GL_LUMINANCE8_ALPHA8_EXT;
1804	pSurface->formatGL = GL_LUMINANCE_ALPHA;
1805	pSurface->typeGL = GL_UNSIGNED_BYTE; /* unsigned_short causes issues even though this type should be 16-bit */
1806	break;
1807
1808	case SVGA3D_ALPHA8: /* D3DFMT_A8? - WINED3DFMT_A8_UNORM? */
1809	pSurface->internalFormatGL = GL_ALPHA8_EXT;
1810	pSurface->formatGL = GL_ALPHA;
1811	pSurface->typeGL = GL_UNSIGNED_BYTE;
1812	break;
1813
1814	#if 0
1815
1816	/* Bump-map formats */
1817	case SVGA3D_BUMPU8V8:
1818	return D3DFMT_V8U8;
1819	case SVGA3D_BUMPL6V5U5:
1820	return D3DFMT_L6V5U5;
1821	case SVGA3D_BUMPX8L8V8U8:
1822	return D3DFMT_X8L8V8U8;
1823	case SVGA3D_FORMAT_DEAD1:
1824	/* No corresponding D3D9 equivalent. */
1825	AssertFailedReturn(D3DFMT_UNKNOWN);
1826	/* signed bump-map formats */
1827	case SVGA3D_V8U8:
1828	return D3DFMT_V8U8;
1829	case SVGA3D_Q8W8V8U8:
1830	return D3DFMT_Q8W8V8U8;
1831	case SVGA3D_CxV8U8:
1832	return D3DFMT_CxV8U8;
1833	/* mixed bump-map formats */
1834	case SVGA3D_X8L8V8U8:
1835	return D3DFMT_X8L8V8U8;
1836	case SVGA3D_A2W10V10U10:
1837	return D3DFMT_A2W10V10U10;
1838	#endif
1839
1840	case SVGA3D_ARGB_S10E5: /* 16-bit floating-point ARGB / / D3DFMT_A16B16G16R16F - WINED3DFMT_R16G16B16A16_FLOAT */
1841	pSurface->internalFormatGL = GL_RGBA16F;
1842	pSurface->formatGL = GL_RGBA;
1843	#if 0 /* bird: wine uses half float, sounds correct to me... */
1844	pSurface->typeGL = GL_FLOAT;
1845	#else
1846	pSurface->typeGL = GL_HALF_FLOAT;
1847	AssertTestFmt(SVGA3D_ARGB_S10E5);
1848	#endif
1849	break;
1850
1851	case SVGA3D_ARGB_S23E8: /* 32-bit floating-point ARGB / / D3DFMT_A32B32G32R32F - WINED3DFMT_R32G32B32A32_FLOAT */
1852	pSurface->internalFormatGL = GL_RGBA32F;
1853	pSurface->formatGL = GL_RGBA;
1854	pSurface->typeGL = GL_FLOAT; /* ?? - same as wine, so probably correct */
1855	break;
1856
1857	case SVGA3D_A2R10G10B10: /* D3DFMT_A2R10G10B10 - WINED3DFMT_B10G10R10A2_UNORM */
1858	pSurface->internalFormatGL = GL_RGB10_A2; /* ?? - same as wine, so probably correct */
1859	#if 0 /* bird: Wine uses GL_BGRA instead of GL_RGBA. */
1860	pSurface->formatGL = GL_RGBA;
1861	#else
1862	pSurface->formatGL = GL_BGRA;
1863	#endif
1864	pSurface->typeGL = GL_UNSIGNED_INT;
1865	AssertTestFmt(SVGA3D_A2R10G10B10);
1866	break;
1867
1868
1869	/* Single- and dual-component floating point formats */
1870	case SVGA3D_R_S10E5: /* D3DFMT_R16F - WINED3DFMT_R16_FLOAT */
1871	pSurface->internalFormatGL = GL_R16F;
1872	pSurface->formatGL = GL_RED;
1873	#if 0 /* bird: wine uses half float, sounds correct to me... */
1874	pSurface->typeGL = GL_FLOAT;
1875	#else
1876	pSurface->typeGL = GL_HALF_FLOAT;
1877	AssertTestFmt(SVGA3D_R_S10E5);
1878	#endif
1879	break;
1880	case SVGA3D_R_S23E8: /* D3DFMT_R32F - WINED3DFMT_R32_FLOAT */
1881	pSurface->internalFormatGL = GL_R32F;
1882	pSurface->formatGL = GL_RED;
1883	pSurface->typeGL = GL_FLOAT;
1884	break;
1885	case SVGA3D_RG_S10E5: /* D3DFMT_G16R16F - WINED3DFMT_R16G16_FLOAT */
1886	pSurface->internalFormatGL = GL_RG16F;
1887	pSurface->formatGL = GL_RG;
1888	#if 0 /* bird: wine uses half float, sounds correct to me... */
1889	pSurface->typeGL = GL_FLOAT;
1890	#else
1891	pSurface->typeGL = GL_HALF_FLOAT;
1892	AssertTestFmt(SVGA3D_RG_S10E5);
1893	#endif
1894	break;
1895	case SVGA3D_RG_S23E8: /* D3DFMT_G32R32F - WINED3DFMT_R32G32_FLOAT */
1896	pSurface->internalFormatGL = GL_RG32F;
1897	pSurface->formatGL = GL_RG;
1898	pSurface->typeGL = GL_FLOAT;
1899	break;
1900
1901	/*
1902	* Any surface can be used as a buffer object, but SVGA3D_BUFFER is
1903	* the most efficient format to use when creating new surfaces
1904	* expressly for index or vertex data.
1905	*/
1906	case SVGA3D_BUFFER:
1907	pSurface->internalFormatGL = -1;
1908	pSurface->formatGL = -1;
1909	pSurface->typeGL = -1;
1910	break;
1911
1912	#if 0
1913	return D3DFMT_UNKNOWN;
1914
1915	case SVGA3D_V16U16:
1916	return D3DFMT_V16U16;
1917	#endif
1918
1919	case SVGA3D_G16R16: /* D3DFMT_G16R16 - WINED3DFMT_R16G16_UNORM */
1920	pSurface->internalFormatGL = GL_RG16;
1921	pSurface->formatGL = GL_RG;
1922	#if 0 /* bird: Wine uses GL_UNSIGNED_SHORT here. */
1923	pSurface->typeGL = GL_UNSIGNED_INT;
1924	#else
1925	pSurface->typeGL = GL_UNSIGNED_SHORT;
1926	AssertTestFmt(SVGA3D_G16R16);
1927	#endif
1928	break;
1929
1930	case SVGA3D_A16B16G16R16: /* D3DFMT_A16B16G16R16 - WINED3DFMT_R16G16B16A16_UNORM */
1931	pSurface->internalFormatGL = GL_RGBA16;
1932	pSurface->formatGL = GL_RGBA;
1933	#if 0 /* bird: Wine uses GL_UNSIGNED_SHORT here. */
1934	pSurface->typeGL = GL_UNSIGNED_INT; /* ??? */
1935	#else
1936	pSurface->typeGL = GL_UNSIGNED_SHORT;
1937	AssertTestFmt(SVGA3D_A16B16G16R16);
1938	#endif
1939	break;
1940
1941	case SVGA3D_R8G8B8A8_SNORM:
1942	pSurface->internalFormatGL = GL_RGB8;
1943	pSurface->formatGL = GL_BGRA;
1944	pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1945	AssertTestFmt(SVGA3D_R8G8B8A8_SNORM);
1946	break;
1947	case SVGA3D_R16G16_UNORM:
1948	pSurface->internalFormatGL = GL_RG16;
1949	pSurface->formatGL = GL_RG;
1950	pSurface->typeGL = GL_UNSIGNED_SHORT;
1951	AssertTestFmt(SVGA3D_R16G16_UNORM);
1952	break;
1953
1954	/* Packed Video formats */
1955	case SVGA3D_UYVY:
1956	case SVGA3D_YUY2:
1957	/* Use a BRGA texture to hold the data and convert it to an actual BGRA. */
1958	pSurface->fEmulated = true;
1959	pSurface->internalFormatGL = GL_RGBA8;
1960	pSurface->formatGL = GL_BGRA;
1961	pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1962	pSurface->cbBlockGL = 4 * pSurface->cxBlock * pSurface->cyBlock;
1963	break;
1964
1965	#if 0
1966	/* Planar video formats */
1967	case SVGA3D_NV12:
1968	return (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2');
1969
1970	/* Video format with alpha */
1971	case SVGA3D_FORMAT_DEAD2: /* Old SVGA3D_AYUV */
1972
1973	case SVGA3D_ATI1:
1974	case SVGA3D_ATI2:
1975	/* Unknown; only in DX10 & 11 */
1976	break;
1977	#endif
1978	default:
1979	AssertMsgFailed(("Unsupported format %d\n", format));
1980	break;
1981	}
1982	#undef AssertTestFmt
1983	}
1984
1985
1986	#if 0
1987	/**
1988	* Convert SVGA multi sample count value to its D3D equivalent
1989	*/
1990	D3DMULTISAMPLE_TYPE vmsvga3dMultipeSampleCount2D3D(uint32_t multisampleCount)
1991	{
1992	AssertCompile(D3DMULTISAMPLE_2_SAMPLES == 2);
1993	AssertCompile(D3DMULTISAMPLE_16_SAMPLES == 16);
1994
1995	if (multisampleCount > 16)
1996	return D3DMULTISAMPLE_NONE;
1997
1998	/** @todo exact same mapping as d3d? */
1999	return (D3DMULTISAMPLE_TYPE)multisampleCount;
2000	}
2001	#endif
2002
2003	/**
2004	* Destroy backend specific surface bits (part of SVGA_3D_CMD_SURFACE_DESTROY).
2005	*
2006	* @param pThisCC The device state.
2007	* @param fClearCOTableEntry Not relevant for this backend.
2008	* @param pSurface The surface being destroyed.
2009	*/
2010	static DECLCALLBACK(void) vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, bool fClearCOTableEntry, PVMSVGA3DSURFACE pSurface)
2011	{
2012	RT_NOREF(fClearCOTableEntry);
2013
2014	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2015	AssertReturnVoid(pState);
2016
2017	PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
2018	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
2019
2020	switch (pSurface->enmOGLResType)
2021	{
2022	case VMSVGA3D_OGLRESTYPE_BUFFER:
2023	Assert(pSurface->oglId.buffer != OPENGL_INVALID_ID);
2024	pState->ext.glDeleteBuffers(1, &pSurface->oglId.buffer);
2025	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2026	break;
2027
2028	case VMSVGA3D_OGLRESTYPE_TEXTURE:
2029	Assert(pSurface->oglId.texture != OPENGL_INVALID_ID);
2030	glDeleteTextures(1, &pSurface->oglId.texture);
2031	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2032	if (pSurface->fEmulated)
2033	{
2034	if (pSurface->idEmulated)
2035	{
2036	glDeleteTextures(1, &pSurface->idEmulated);
2037	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2038	}
2039	}
2040	else
2041	{
2042	Assert(!pSurface->idEmulated);
2043	}
2044	break;
2045
2046	case VMSVGA3D_OGLRESTYPE_RENDERBUFFER:
2047	Assert(pSurface->oglId.renderbuffer != OPENGL_INVALID_ID);
2048	pState->ext.glDeleteRenderbuffers(1, &pSurface->oglId.renderbuffer);
2049	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2050	break;
2051
2052	default:
2053	AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface),
2054	("hint=%#x, type=%d\n",
2055	(pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK), pSurface->enmOGLResType));
2056	break;
2057	}
2058	}
2059
2060
2061	static DECLCALLBACK(void) vmsvga3dBackSurfaceInvalidateImage(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface, uint32_t uFace, uint32_t uMipmap)
2062	{
2063	RT_NOREF(pThisCC, pSurface, uFace, uMipmap);
2064	}
2065
2066
2067	static DECLCALLBACK(int) vmsvga3dBackSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
2068	uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
2069	{
2070	int rc;
2071
2072	LogFunc(("Copy %d boxes from sid=%u face=%u mipmap=%u to sid=%u face=%u mipmap=%u\n",
2073	cCopyBoxes, src.sid, src.face, src.mipmap, dest.sid, dest.face, dest.mipmap));
2074
2075	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2076	AssertReturn(pState, VERR_INVALID_STATE);
2077
2078	PVMSVGA3DSURFACE pSurfaceSrc;
2079	rc = vmsvga3dSurfaceFromSid(pState, src.sid, &pSurfaceSrc);
2080	AssertRCReturn(rc, rc);
2081
2082	PVMSVGA3DSURFACE pSurfaceDst;
2083	rc = vmsvga3dSurfaceFromSid(pState, dest.sid, &pSurfaceDst);
2084	AssertRCReturn(rc, rc);
2085
2086	if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurfaceSrc))
2087	{
2088	/* The source surface is still in memory. */
2089	PVMSVGA3DMIPMAPLEVEL pMipmapLevelSrc;
2090	rc = vmsvga3dMipmapLevel(pSurfaceSrc, src.face, src.mipmap, &pMipmapLevelSrc);
2091	AssertRCReturn(rc, rc);
2092
2093	PVMSVGA3DMIPMAPLEVEL pMipmapLevelDst;
2094	rc = vmsvga3dMipmapLevel(pSurfaceDst, dest.face, dest.mipmap, &pMipmapLevelDst);
2095	AssertRCReturn(rc, rc);
2096
2097	/* The copy operation is performed on the shared context. */
2098	PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
2099	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
2100
2101	/* Use glTexSubImage to upload the data to the destination texture.
2102	* The latter must be an OpenGL texture.
2103	*/
2104	if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurfaceDst))
2105	{
2106	LogFunc(("dest sid=%u type=0x%x format=%d -> create texture\n", dest.sid, pSurfaceDst->f.s.surface1Flags, pSurfaceDst->format));
2107	rc = vmsvga3dBackCreateTexture(pThisCC, pContext, pContext->id, pSurfaceDst);
2108	AssertRCReturn(rc, rc);
2109	}
2110
2111	GLenum target;
2112	if (pSurfaceDst->targetGL == GL_TEXTURE_CUBE_MAP)
2113	target = vmsvga3dCubemapFaceFromIndex(dest.face);
2114	else
2115	{
2116	AssertMsg(pSurfaceDst->targetGL == GL_TEXTURE_2D, ("Test %#x\n", pSurfaceDst->targetGL));
2117	target = pSurfaceDst->targetGL;
2118	}
2119
2120	/* Save the unpacking parameters and set what we need here. */
2121	VMSVGAPACKPARAMS SavedParams;
2122	vmsvga3dOglSetUnpackParams(pState, pContext,
2123	pMipmapLevelSrc->mipmapSize.width,
2124	target == GL_TEXTURE_3D ? pMipmapLevelSrc->mipmapSize.height : 0,
2125	&SavedParams);
2126
2127	glBindTexture(pSurfaceDst->targetGL, pSurfaceDst->oglId.texture);
2128	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2129
2130	for (uint32_t i = 0; i < cCopyBoxes; ++i)
2131	{
2132	SVGA3dCopyBox clipBox = pBox[i];
2133	vmsvgaR3ClipCopyBox(&pMipmapLevelSrc->mipmapSize, &pMipmapLevelDst->mipmapSize, &clipBox);
2134	if ( !clipBox.w
2135	\|\| !clipBox.h
2136	\|\| !clipBox.d)
2137	{
2138	LogFunc(("Skipped empty box.\n"));
2139	continue;
2140	}
2141
2142	LogFunc(("copy box %d,%d,%d %dx%d to %d,%d,%d\n",
2143	clipBox.srcx, clipBox.srcy, clipBox.srcz, clipBox.w, clipBox.h, clipBox.x, clipBox.y, clipBox.z));
2144
2145	uint32_t const u32BlockX = clipBox.srcx / pSurfaceSrc->cxBlock;
2146	uint32_t const u32BlockY = clipBox.srcy / pSurfaceSrc->cyBlock;
2147	uint32_t const u32BlockZ = clipBox.srcz;
2148	Assert(u32BlockX * pSurfaceSrc->cxBlock == clipBox.srcx);
2149	Assert(u32BlockY * pSurfaceSrc->cyBlock == clipBox.srcy);
2150
2151	uint8_t const pSrcBits = (uint8_t )pMipmapLevelSrc->pSurfaceData
2152	+ pMipmapLevelSrc->cbSurfacePlane * u32BlockZ
2153	+ pMipmapLevelSrc->cbSurfacePitch * u32BlockY
2154	+ pSurfaceSrc->cbBlock * u32BlockX;
2155
2156	if (target == GL_TEXTURE_3D)
2157	{
2158	if ( pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2159	\|\| pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2160	\|\| pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2161	{
2162	uint32_t const cBlocksX = (clipBox.w + pSurfaceSrc->cxBlock - 1) / pSurfaceSrc->cxBlock;
2163	uint32_t const cBlocksY = (clipBox.h + pSurfaceSrc->cyBlock - 1) / pSurfaceSrc->cyBlock;
2164	uint32_t const imageSize = cBlocksX * cBlocksY * clipBox.d * pSurfaceSrc->cbBlock;
2165	pState->ext.glCompressedTexSubImage3D(target, dest.mipmap,
2166	clipBox.x, clipBox.y, clipBox.z,
2167	clipBox.w, clipBox.h, clipBox.d,
2168	pSurfaceSrc->internalFormatGL, (GLsizei)imageSize, pSrcBits);
2169	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2170	}
2171	else
2172	{
2173	pState->ext.glTexSubImage3D(target, dest.mipmap,
2174	clipBox.x, clipBox.y, clipBox.z,
2175	clipBox.w, clipBox.h, clipBox.d,
2176	pSurfaceSrc->formatGL, pSurfaceSrc->typeGL, pSrcBits);
2177	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2178	}
2179	}
2180	else
2181	{
2182	if ( pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2183	\|\| pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2184	\|\| pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2185	{
2186	uint32_t const cBlocksX = (clipBox.w + pSurfaceSrc->cxBlock - 1) / pSurfaceSrc->cxBlock;
2187	uint32_t const cBlocksY = (clipBox.h + pSurfaceSrc->cyBlock - 1) / pSurfaceSrc->cyBlock;
2188	uint32_t const imageSize = cBlocksX * cBlocksY * pSurfaceSrc->cbBlock;
2189	pState->ext.glCompressedTexSubImage2D(target, dest.mipmap,
2190	clipBox.x, clipBox.y, clipBox.w, clipBox.h,
2191	pSurfaceSrc->internalFormatGL, (GLsizei)imageSize, pSrcBits);
2192	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2193	}
2194	else
2195	{
2196	glTexSubImage2D(target, dest.mipmap,
2197	clipBox.x, clipBox.y, clipBox.w, clipBox.h,
2198	pSurfaceSrc->formatGL, pSurfaceSrc->typeGL, pSrcBits);
2199	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2200	}
2201	}
2202	}
2203
2204	glBindTexture(pSurfaceDst->targetGL, 0);
2205	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2206
2207	vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
2208
2209	return VINF_SUCCESS;
2210	}
2211
2212	PVGASTATE pThis = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVGASTATE);
2213	for (uint32_t i = 0; i < cCopyBoxes; i++)
2214	{
2215	SVGA3dBox destBox, srcBox;
2216
2217	srcBox.x = pBox[i].srcx;
2218	srcBox.y = pBox[i].srcy;
2219	srcBox.z = pBox[i].srcz;
2220	srcBox.w = pBox[i].w;
2221	srcBox.h = pBox[i].h;
2222	srcBox.d = pBox[i].d;
2223
2224	destBox.x = pBox[i].x;
2225	destBox.y = pBox[i].y;
2226	destBox.z = pBox[i].z;
2227	destBox.w = pBox[i].w;
2228	destBox.h = pBox[i].h;
2229	destBox.d = pBox[i].d;
2230
2231	/* No stretching is required, therefore use SVGA3D_STRETCH_BLT_POINT which translated to GL_NEAREST. */
2232	rc = vmsvga3dSurfaceStretchBlt(pThis, pThisCC, &dest, &destBox, &src, &srcBox, SVGA3D_STRETCH_BLT_POINT);
2233	AssertRCReturn(rc, rc);
2234	}
2235	return VINF_SUCCESS;
2236	}
2237
2238
2239	/**
2240	* Saves texture unpacking parameters and loads the specified ones.
2241	*
2242	* @param pState The VMSVGA3D state structure.
2243	* @param pContext The active context.
2244	* @param cxRow The number of pixels in a row. 0 for the entire width.
2245	* @param cyImage The height of the image in pixels. 0 for the entire height.
2246	* @param pSave Where to save stuff.
2247	*/
2248	void vmsvga3dOglSetUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, GLint cxRow, GLint cyImage,
2249	PVMSVGAPACKPARAMS pSave)
2250	{
2251	RT_NOREF(pState);
2252
2253	/*
2254	* Save (ignore errors, setting the defaults we want and avoids restore).
2255	*/
2256	pSave->iAlignment = 1;
2257	VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_UNPACK_ALIGNMENT, &pSave->iAlignment), pState, pContext);
2258	pSave->cxRow = 0;
2259	VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_UNPACK_ROW_LENGTH, &pSave->cxRow), pState, pContext);
2260	pSave->cyImage = 0;
2261	VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &pSave->cyImage), pState, pContext);
2262
2263	#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2264	pSave->fSwapBytes = GL_FALSE;
2265	glGetBooleanv(GL_UNPACK_SWAP_BYTES, &pSave->fSwapBytes);
2266	Assert(pSave->fSwapBytes == GL_FALSE);
2267
2268	pSave->fLsbFirst = GL_FALSE;
2269	glGetBooleanv(GL_UNPACK_LSB_FIRST, &pSave->fLsbFirst);
2270	Assert(pSave->fLsbFirst == GL_FALSE);
2271
2272	pSave->cSkipRows = 0;
2273	glGetIntegerv(GL_UNPACK_SKIP_ROWS, &pSave->cSkipRows);
2274	Assert(pSave->cSkipRows == 0);
2275
2276	pSave->cSkipPixels = 0;
2277	glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &pSave->cSkipPixels);
2278	Assert(pSave->cSkipPixels == 0);
2279
2280	pSave->cSkipImages = 0;
2281	glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &pSave->cSkipImages);
2282	Assert(pSave->cSkipImages == 0);
2283
2284	VMSVGA3D_CLEAR_GL_ERRORS();
2285	#endif
2286
2287	/*
2288	* Setup unpack.
2289	*
2290	* Note! We use 1 as alignment here because we currently don't do any
2291	* aligning of line pitches anywhere.
2292	*/
2293	pSave->fChanged = 0;
2294	if (pSave->iAlignment != 1)
2295	{
2296	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1), pState, pContext);
2297	pSave->fChanged \|= VMSVGAPACKPARAMS_ALIGNMENT;
2298	}
2299	if (pSave->cxRow != cxRow)
2300	{
2301	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, cxRow), pState, pContext);
2302	pSave->fChanged \|= VMSVGAPACKPARAMS_ROW_LENGTH;
2303	}
2304	if (pSave->cyImage != cyImage)
2305	{
2306	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, cyImage), pState, pContext);
2307	pSave->fChanged \|= VMSVGAPACKPARAMS_IMAGE_HEIGHT;
2308	}
2309	#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2310	if (pSave->fSwapBytes != 0)
2311	{
2312	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE), pState, pContext);
2313	pSave->fChanged \|= VMSVGAPACKPARAMS_SWAP_BYTES;
2314	}
2315	if (pSave->fLsbFirst != 0)
2316	{
2317	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE), pState, pContext);
2318	pSave->fChanged \|= VMSVGAPACKPARAMS_LSB_FIRST;
2319	}
2320	if (pSave->cSkipRows != 0)
2321	{
2322	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_ROWS, 0), pState, pContext);
2323	pSave->fChanged \|= VMSVGAPACKPARAMS_SKIP_ROWS;
2324	}
2325	if (pSave->cSkipPixels != 0)
2326	{
2327	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0), pState, pContext);
2328	pSave->fChanged \|= VMSVGAPACKPARAMS_SKIP_PIXELS;
2329	}
2330	if (pSave->cSkipImages != 0)
2331	{
2332	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0), pState, pContext);
2333	pSave->fChanged \|= VMSVGAPACKPARAMS_SKIP_IMAGES;
2334	}
2335	#endif
2336	}
2337
2338
2339	/**
2340	* Restores texture unpacking parameters.
2341	*
2342	* @param pState The VMSVGA3D state structure.
2343	* @param pContext The active context.
2344	* @param pSave Where stuff was saved.
2345	*/
2346	void vmsvga3dOglRestoreUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext,
2347	PCVMSVGAPACKPARAMS pSave)
2348	{
2349	RT_NOREF(pState);
2350
2351	if (pSave->fChanged & VMSVGAPACKPARAMS_ALIGNMENT)
2352	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, pSave->iAlignment), pState, pContext);
2353	if (pSave->fChanged & VMSVGAPACKPARAMS_ROW_LENGTH)
2354	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, pSave->cxRow), pState, pContext);
2355	if (pSave->fChanged & VMSVGAPACKPARAMS_IMAGE_HEIGHT)
2356	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, pSave->cyImage), pState, pContext);
2357	#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2358	if (pSave->fChanged & VMSVGAPACKPARAMS_SWAP_BYTES)
2359	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SWAP_BYTES, pSave->fSwapBytes), pState, pContext);
2360	if (pSave->fChanged & VMSVGAPACKPARAMS_LSB_FIRST)
2361	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_LSB_FIRST, pSave->fLsbFirst), pState, pContext);
2362	if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_ROWS)
2363	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_ROWS, pSave->cSkipRows), pState, pContext);
2364	if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_PIXELS)
2365	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_PIXELS, pSave->cSkipPixels), pState, pContext);
2366	if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_IMAGES)
2367	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_IMAGES, pSave->cSkipImages), pState, pContext);
2368	#endif
2369	}
2370
2371	/**
2372	* Create D3D/OpenGL texture object for the specified surface.
2373	*
2374	* Surfaces are created when needed.
2375	*
2376	* @param pThisCC The device context.
2377	* @param pContext The context.
2378	* @param idAssociatedContext Probably the same as pContext->id.
2379	* @param pSurface The surface to create the texture for.
2380	*/
2381	static DECLCALLBACK(int) vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
2382	PVMSVGA3DSURFACE pSurface)
2383	{
2384	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2385
2386	RT_NOREF(idAssociatedContext);
2387
2388	LogFunc(("sid=%u\n", pSurface->id));
2389
2390	uint32_t const numMipLevels = pSurface->cLevels;
2391
2392	/* Fugure out what kind of texture we are creating. */
2393	GLenum binding;
2394	GLenum target;
2395	if (pSurface->f.s.surface1Flags & SVGA3D_SURFACE_CUBEMAP)
2396	{
2397	Assert(pSurface->cFaces == 6);
2398
2399	binding = GL_TEXTURE_BINDING_CUBE_MAP;
2400	target = GL_TEXTURE_CUBE_MAP;
2401	}
2402	else
2403	{
2404	if (pSurface->paMipmapLevels[0].mipmapSize.depth > 1)
2405	{
2406	binding = GL_TEXTURE_BINDING_3D;
2407	target = GL_TEXTURE_3D;
2408	}
2409	else
2410	{
2411	Assert(pSurface->cFaces == 1);
2412
2413	binding = GL_TEXTURE_BINDING_2D;
2414	target = GL_TEXTURE_2D;
2415	}
2416	}
2417
2418	/* All textures are created in the SharedCtx. */
2419	uint32_t idPrevCtx = pState->idActiveContext;
2420	pContext = &pState->SharedCtx;
2421	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
2422
2423	glGenTextures(1, &pSurface->oglId.texture);
2424	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2425	if (pSurface->fEmulated)
2426	{
2427	glGenTextures(1, &pSurface->idEmulated);
2428	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2429	}
2430	pSurface->enmOGLResType = VMSVGA3D_OGLRESTYPE_TEXTURE;
2431
2432	GLint activeTexture = 0;
2433	glGetIntegerv(binding, &activeTexture);
2434	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2435
2436	/* Must bind texture to the current context in order to change it. */
2437	glBindTexture(target, pSurface->oglId.texture);
2438	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2439
2440	/* Set the unpacking parameters. */
2441	VMSVGAPACKPARAMS SavedParams;
2442	vmsvga3dOglSetUnpackParams(pState, pContext, 0, 0, &SavedParams);
2443
2444	/** @todo Set the mip map generation filter settings. */
2445
2446	/* Set the mipmap base and max level parameters. */
2447	glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
2448	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2449	glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, pSurface->cLevels - 1);
2450	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2451
2452	if (pSurface->fDirty)
2453	LogFunc(("sync dirty texture\n"));
2454
2455	/* Always allocate and initialize all mipmap levels; non-initialized mipmap levels used as render targets cause failures. */
2456	if (target == GL_TEXTURE_3D)
2457	{
2458	for (uint32_t i = 0; i < numMipLevels; ++i)
2459	{
2460	/* Allocate and initialize texture memory. Passing the zero filled pSurfaceData avoids
2461	* exposing random host memory to the guest and helps a with the fedora 21 surface
2462	* corruption issues (launchpad, background, search field, login).
2463	*/
2464	PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[i];
2465
2466	LogFunc(("sync dirty 3D texture mipmap level %d (pitch %x) (dirty %d)\n",
2467	i, pMipLevel->cbSurfacePitch, pMipLevel->fDirty));
2468
2469	if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2470	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2471	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2472	{
2473	pState->ext.glCompressedTexImage3D(GL_TEXTURE_3D,
2474	i,
2475	pSurface->internalFormatGL,
2476	pMipLevel->mipmapSize.width,
2477	pMipLevel->mipmapSize.height,
2478	pMipLevel->mipmapSize.depth,
2479	0,
2480	pMipLevel->cbSurface,
2481	pMipLevel->pSurfaceData);
2482	}
2483	else
2484	{
2485	pState->ext.glTexImage3D(GL_TEXTURE_3D,
2486	i,
2487	pSurface->internalFormatGL,
2488	pMipLevel->mipmapSize.width,
2489	pMipLevel->mipmapSize.height,
2490	pMipLevel->mipmapSize.depth,
2491	0, /* border */
2492	pSurface->formatGL,
2493	pSurface->typeGL,
2494	pMipLevel->pSurfaceData);
2495	}
2496	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2497
2498	pMipLevel->fDirty = false;
2499	}
2500	}
2501	else if (target == GL_TEXTURE_CUBE_MAP)
2502	{
2503	for (uint32_t iFace = 0; iFace < 6; ++iFace)
2504	{
2505	GLenum const Face = vmsvga3dCubemapFaceFromIndex(iFace);
2506
2507	for (uint32_t i = 0; i < numMipLevels; ++i)
2508	{
2509	PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[iFace * numMipLevels + i];
2510	Assert(pMipLevel->mipmapSize.width == pMipLevel->mipmapSize.height);
2511	Assert(pMipLevel->mipmapSize.depth == 1);
2512
2513	LogFunc(("sync cube texture face %d mipmap level %d (dirty %d)\n",
2514	iFace, i, pMipLevel->fDirty));
2515
2516	if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2517	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2518	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2519	{
2520	pState->ext.glCompressedTexImage2D(Face,
2521	i,
2522	pSurface->internalFormatGL,
2523	pMipLevel->mipmapSize.width,
2524	pMipLevel->mipmapSize.height,
2525	0,
2526	pMipLevel->cbSurface,
2527	pMipLevel->pSurfaceData);
2528	}
2529	else
2530	{
2531	glTexImage2D(Face,
2532	i,
2533	pSurface->internalFormatGL,
2534	pMipLevel->mipmapSize.width,
2535	pMipLevel->mipmapSize.height,
2536	0,
2537	pSurface->formatGL,
2538	pSurface->typeGL,
2539	pMipLevel->pSurfaceData);
2540	}
2541	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2542
2543	pMipLevel->fDirty = false;
2544	}
2545	}
2546	}
2547	else if (target == GL_TEXTURE_2D)
2548	{
2549	for (uint32_t i = 0; i < numMipLevels; ++i)
2550	{
2551	/* Allocate and initialize texture memory. Passing the zero filled pSurfaceData avoids
2552	* exposing random host memory to the guest and helps a with the fedora 21 surface
2553	* corruption issues (launchpad, background, search field, login).
2554	*/
2555	PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[i];
2556	Assert(pMipLevel->mipmapSize.depth == 1);
2557
2558	LogFunc(("sync dirty texture mipmap level %d (pitch %x) (dirty %d)\n",
2559	i, pMipLevel->cbSurfacePitch, pMipLevel->fDirty));
2560
2561	if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2562	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2563	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2564	{
2565	pState->ext.glCompressedTexImage2D(GL_TEXTURE_2D,
2566	i,
2567	pSurface->internalFormatGL,
2568	pMipLevel->mipmapSize.width,
2569	pMipLevel->mipmapSize.height,
2570	0,
2571	pMipLevel->cbSurface,
2572	pMipLevel->pSurfaceData);
2573	}
2574	else
2575	{
2576	glTexImage2D(GL_TEXTURE_2D,
2577	i,
2578	pSurface->internalFormatGL,
2579	pMipLevel->mipmapSize.width,
2580	pMipLevel->mipmapSize.height,
2581	0,
2582	pSurface->formatGL,
2583	pSurface->typeGL,
2584	NULL);
2585	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2586
2587	if (pSurface->fEmulated)
2588	{
2589	/* Bind the emulated texture and init it. */
2590	glBindTexture(GL_TEXTURE_2D, pSurface->idEmulated);
2591	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2592
2593	glTexImage2D(GL_TEXTURE_2D,
2594	i,
2595	pSurface->internalFormatGL,
2596	pMipLevel->mipmapSize.width,
2597	pMipLevel->mipmapSize.height,
2598	0,
2599	pSurface->formatGL,
2600	pSurface->typeGL,
2601	NULL);
2602	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2603	}
2604
2605	/* Fetch texture data: either to the actual or to the emulated texture.
2606	* The pSurfaceData buffer may be smaller than the entire texture
2607	* for emulated formats, in which case only part of the texture is synched.
2608	*/
2609	uint32_t cBlocksX = pMipLevel->mipmapSize.width / pSurface->cxBlock;
2610	uint32_t cBlocksY = pMipLevel->mipmapSize.height / pSurface->cyBlock;
2611	glTexSubImage2D(GL_TEXTURE_2D,
2612	i,
2613	0,
2614	0,
2615	cBlocksX,
2616	cBlocksY,
2617	pSurface->formatGL,
2618	pSurface->typeGL,
2619	pMipLevel->pSurfaceData);
2620	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2621
2622	if (pSurface->fEmulated)
2623	{
2624	/* Update the actual texture using the format converter. */
2625	FormatConvUpdateTexture(pState, pContext, pSurface, i);
2626
2627	/* Rebind the actual texture. */
2628	glBindTexture(GL_TEXTURE_2D, pSurface->oglId.texture);
2629	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2630	}
2631	}
2632	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2633
2634	pMipLevel->fDirty = false;
2635	}
2636	}
2637
2638	pSurface->fDirty = false;
2639
2640	/* Restore unpacking parameters. */
2641	vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
2642
2643	/* Restore the old active texture. */
2644	glBindTexture(target, activeTexture);
2645	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2646
2647	pSurface->f.s.surface1Flags \|= SVGA3D_SURFACE_HINT_TEXTURE;
2648	pSurface->targetGL = target;
2649	pSurface->bindingGL = binding;
2650
2651	if (idPrevCtx < pState->cContexts && pState->papContexts[idPrevCtx]->id == idPrevCtx)
2652	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pState->papContexts[idPrevCtx]);
2653	return VINF_SUCCESS;
2654	}
2655
2656
2657	/**
2658	* Backend worker for implementing SVGA_3D_CMD_SURFACE_STRETCHBLT.
2659	*
2660	* @returns VBox status code.
2661	* @param pThis The VGA device instance.
2662	* @param pState The VMSVGA3d state.
2663	* @param pDstSurface The destination host surface.
2664	* @param uDstFace The destination face (valid).
2665	* @param uDstMipmap The destination mipmap level (valid).
2666	* @param pDstBox The destination box.
2667	* @param pSrcSurface The source host surface.
2668	* @param uSrcFace The destination face (valid).
2669	* @param uSrcMipmap The source mimap level (valid).
2670	* @param pSrcBox The source box.
2671	* @param enmMode The strecht blt mode .
2672	* @param pContext The VMSVGA3d context (already current for OGL).
2673	*/
2674	static DECLCALLBACK(int) vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
2675	PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
2676	PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
2677	SVGA3dStretchBltMode enmMode, PVMSVGA3DCONTEXT pContext)
2678	{
2679	RT_NOREF(pThis);
2680
2681	AssertReturn( RT_BOOL(pSrcSurface->f.s.surface1Flags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
2682	== RT_BOOL(pDstSurface->f.s.surface1Flags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL), VERR_NOT_IMPLEMENTED);
2683
2684	GLenum glAttachment = GL_COLOR_ATTACHMENT0;
2685	GLbitfield glMask = GL_COLOR_BUFFER_BIT;
2686	if (pDstSurface->f.s.surface1Flags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
2687	{
2688	/** @todo Need GL_DEPTH_STENCIL_ATTACHMENT for depth/stencil formats? */
2689	glAttachment = GL_DEPTH_ATTACHMENT;
2690	glMask = GL_DEPTH_BUFFER_BIT;
2691	}
2692
2693	/* Activate the read and draw framebuffer objects. */
2694	pState->ext.glBindFramebuffer(GL_READ_FRAMEBUFFER, pContext->idReadFramebuffer);
2695	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2696	pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, pContext->idDrawFramebuffer);
2697	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2698
2699	/* Bind the source and destination objects to the right place. */
2700	GLenum textarget;
2701	if (pSrcSurface->targetGL == GL_TEXTURE_CUBE_MAP)
2702	textarget = vmsvga3dCubemapFaceFromIndex(uSrcFace);
2703	else
2704	{
2705	/// @todo later AssertMsg(pSrcSurface->targetGL == GL_TEXTURE_2D, ("%#x\n", pSrcSurface->targetGL));
2706	textarget = GL_TEXTURE_2D;
2707	}
2708	pState->ext.glFramebufferTexture2D(GL_READ_FRAMEBUFFER, glAttachment, textarget,
2709	pSrcSurface->oglId.texture, uSrcMipmap);
2710	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2711
2712	if (pDstSurface->targetGL == GL_TEXTURE_CUBE_MAP)
2713	textarget = vmsvga3dCubemapFaceFromIndex(uDstFace);
2714	else
2715	{
2716	/// @todo later AssertMsg(pDstSurface->targetGL == GL_TEXTURE_2D, ("%#x\n", pDstSurface->targetGL));
2717	textarget = GL_TEXTURE_2D;
2718	}
2719	pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, glAttachment, textarget,
2720	pDstSurface->oglId.texture, uDstMipmap);
2721	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2722
2723	Log(("src conv. (%d,%d)(%d,%d); dest conv (%d,%d)(%d,%d)\n",
2724	pSrcBox->x, D3D_TO_OGL_Y_COORD(pSrcSurface, pSrcBox->y + pSrcBox->h),
2725	pSrcBox->x + pSrcBox->w, D3D_TO_OGL_Y_COORD(pSrcSurface, pSrcBox->y),
2726	pDstBox->x, D3D_TO_OGL_Y_COORD(pDstSurface, pDstBox->y + pDstBox->h),
2727	pDstBox->x + pDstBox->w, D3D_TO_OGL_Y_COORD(pDstSurface, pDstBox->y)));
2728
2729	pState->ext.glBlitFramebuffer(pSrcBox->x,
2730	pSrcBox->y,
2731	pSrcBox->x + pSrcBox->w, /* exclusive. */
2732	pSrcBox->y + pSrcBox->h,
2733	pDstBox->x,
2734	pDstBox->y,
2735	pDstBox->x + pDstBox->w, /* exclusive. */
2736	pDstBox->y + pDstBox->h,
2737	glMask,
2738	(enmMode == SVGA3D_STRETCH_BLT_POINT) ? GL_NEAREST : GL_LINEAR);
2739	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2740
2741	/* Reset the frame buffer association */
2742	pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, pContext->idFramebuffer);
2743	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2744
2745	return VINF_SUCCESS;
2746	}
2747
2748	/**
2749	* Save texture packing parameters and loads those appropriate for the given
2750	* surface.
2751	*
2752	* @param pState The VMSVGA3D state structure.
2753	* @param pContext The active context.
2754	* @param pSurface The surface.
2755	* @param pSave Where to save stuff.
2756	*/
2757	void vmsvga3dOglSetPackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
2758	PVMSVGAPACKPARAMS pSave)
2759	{
2760	RT_NOREF(pState);
2761	/*
2762	* Save (ignore errors, setting the defaults we want and avoids restore).
2763	*/
2764	pSave->iAlignment = 1;
2765	VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_PACK_ALIGNMENT, &pSave->iAlignment), pState, pContext);
2766	pSave->cxRow = 0;
2767	VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_PACK_ROW_LENGTH, &pSave->cxRow), pState, pContext);
2768
2769	#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2770	pSave->cyImage = 0;
2771	glGetIntegerv(GL_PACK_IMAGE_HEIGHT, &pSave->cyImage);
2772	Assert(pSave->cyImage == 0);
2773
2774	pSave->fSwapBytes = GL_FALSE;
2775	glGetBooleanv(GL_PACK_SWAP_BYTES, &pSave->fSwapBytes);
2776	Assert(pSave->fSwapBytes == GL_FALSE);
2777
2778	pSave->fLsbFirst = GL_FALSE;
2779	glGetBooleanv(GL_PACK_LSB_FIRST, &pSave->fLsbFirst);
2780	Assert(pSave->fLsbFirst == GL_FALSE);
2781
2782	pSave->cSkipRows = 0;
2783	glGetIntegerv(GL_PACK_SKIP_ROWS, &pSave->cSkipRows);
2784	Assert(pSave->cSkipRows == 0);
2785
2786	pSave->cSkipPixels = 0;
2787	glGetIntegerv(GL_PACK_SKIP_PIXELS, &pSave->cSkipPixels);
2788	Assert(pSave->cSkipPixels == 0);
2789
2790	pSave->cSkipImages = 0;
2791	glGetIntegerv(GL_PACK_SKIP_IMAGES, &pSave->cSkipImages);
2792	Assert(pSave->cSkipImages == 0);
2793
2794	VMSVGA3D_CLEAR_GL_ERRORS();
2795	#endif
2796
2797	/*
2798	* Setup unpack.
2799	*
2800	* Note! We use 1 as alignment here because we currently don't do any
2801	* aligning of line pitches anywhere.
2802	*/
2803	NOREF(pSurface);
2804	if (pSave->iAlignment != 1)
2805	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_ALIGNMENT, 1), pState, pContext);
2806	if (pSave->cxRow != 0)
2807	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_ROW_LENGTH, 0), pState, pContext);
2808	#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2809	if (pSave->cyImage != 0)
2810	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0), pState, pContext);
2811	if (pSave->fSwapBytes != 0)
2812	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE), pState, pContext);
2813	if (pSave->fLsbFirst != 0)
2814	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE), pState, pContext);
2815	if (pSave->cSkipRows != 0)
2816	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_ROWS, 0), pState, pContext);
2817	if (pSave->cSkipPixels != 0)
2818	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_PIXELS, 0), pState, pContext);
2819	if (pSave->cSkipImages != 0)
2820	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_IMAGES, 0), pState, pContext);
2821	#endif
2822	}
2823
2824
2825	/**
2826	* Restores texture packing parameters.
2827	*
2828	* @param pState The VMSVGA3D state structure.
2829	* @param pContext The active context.
2830	* @param pSurface The surface.
2831	* @param pSave Where stuff was saved.
2832	*/
2833	void vmsvga3dOglRestorePackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
2834	PCVMSVGAPACKPARAMS pSave)
2835	{
2836	RT_NOREF(pState, pSurface);
2837	if (pSave->iAlignment != 1)
2838	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_ALIGNMENT, pSave->iAlignment), pState, pContext);
2839	if (pSave->cxRow != 0)
2840	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_ROW_LENGTH, pSave->cxRow), pState, pContext);
2841	#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2842	if (pSave->cyImage != 0)
2843	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_IMAGE_HEIGHT, pSave->cyImage), pState, pContext);
2844	if (pSave->fSwapBytes != 0)
2845	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SWAP_BYTES, pSave->fSwapBytes), pState, pContext);
2846	if (pSave->fLsbFirst != 0)
2847	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_LSB_FIRST, pSave->fLsbFirst), pState, pContext);
2848	if (pSave->cSkipRows != 0)
2849	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_ROWS, pSave->cSkipRows), pState, pContext);
2850	if (pSave->cSkipPixels != 0)
2851	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_PIXELS, pSave->cSkipPixels), pState, pContext);
2852	if (pSave->cSkipImages != 0)
2853	VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_IMAGES, pSave->cSkipImages), pState, pContext);
2854	#endif
2855	}
2856
2857
2858	/**
2859	* Backend worker for implementing SVGA_3D_CMD_SURFACE_DMA that copies one box.
2860	*
2861	* @returns Failure status code or @a rc.
2862	* @param pThis The shared VGA/VMSVGA instance data.
2863	* @param pThisCC The VGA/VMSVGA state for ring-3.
2864	* @param pState The VMSVGA3d state.
2865	* @param pSurface The host surface.
2866	* @param pMipLevel Mipmap level. The caller knows it already.
2867	* @param uHostFace The host face (valid).
2868	* @param uHostMipmap The host mipmap level (valid).
2869	* @param GuestPtr The guest pointer.
2870	* @param cbGuestPitch The guest pitch.
2871	* @param transfer The transfer direction.
2872	* @param pBox The box to copy (clipped, valid, except for guest's srcx, srcy, srcz).
2873	* @param pContext The context (for OpenGL).
2874	* @param rc The current rc for all boxes.
2875	* @param iBox The current box number (for Direct 3D).
2876	*/
2877	static DECLCALLBACK(int) vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
2878	PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
2879	SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
2880	SVGA3dCopyBox const *pBox, PVMSVGA3DCONTEXT pContext, int rc, int iBox)
2881	{
2882	RT_NOREF(iBox);
2883
2884	switch (pSurface->enmOGLResType)
2885	{
2886	case VMSVGA3D_OGLRESTYPE_TEXTURE:
2887	{
2888	uint32_t cbSurfacePitch;
2889	uint8_t *pDoubleBuffer;
2890	uint64_t offHst;
2891
2892	uint32_t const u32HostBlockX = pBox->x / pSurface->cxBlock;
2893	uint32_t const u32HostBlockY = pBox->y / pSurface->cyBlock;
2894	uint32_t const u32HostZ = pBox->z;
2895	Assert(u32HostBlockX * pSurface->cxBlock == pBox->x);
2896	Assert(u32HostBlockY * pSurface->cyBlock == pBox->y);
2897
2898	uint32_t const u32GuestBlockX = pBox->srcx / pSurface->cxBlock;
2899	uint32_t const u32GuestBlockY = pBox->srcy / pSurface->cyBlock;
2900	uint32_t const u32GuestZ = pBox->srcz / pSurface->cyBlock;
2901	Assert(u32GuestBlockX * pSurface->cxBlock == pBox->srcx);
2902	Assert(u32GuestBlockY * pSurface->cyBlock == pBox->srcy);
2903
2904	uint32_t const cBlocksX = (pBox->w + pSurface->cxBlock - 1) / pSurface->cxBlock;
2905	uint32_t const cBlocksY = (pBox->h + pSurface->cyBlock - 1) / pSurface->cyBlock;
2906	AssertMsgReturn(cBlocksX && cBlocksY, ("Empty box %dx%d\n", pBox->w, pBox->h), VERR_INTERNAL_ERROR);
2907
2908	GLenum texImageTarget;
2909	if (pSurface->targetGL == GL_TEXTURE_3D)
2910	{
2911	texImageTarget = GL_TEXTURE_3D;
2912	}
2913	else if (pSurface->targetGL == GL_TEXTURE_CUBE_MAP)
2914	{
2915	texImageTarget = vmsvga3dCubemapFaceFromIndex(uHostFace);
2916	}
2917	else
2918	{
2919	AssertMsg(pSurface->targetGL == GL_TEXTURE_2D, ("%#x\n", pSurface->targetGL));
2920	texImageTarget = GL_TEXTURE_2D;
2921	}
2922
2923	/* The buffer must be large enough to hold entire texture in the OpenGL format. */
2924	pDoubleBuffer = (uint8_t )RTMemAlloc(pSurface->cbBlockGL pMipLevel->cBlocks);
2925	AssertReturn(pDoubleBuffer, VERR_NO_MEMORY);
2926
2927	if (transfer == SVGA3D_READ_HOST_VRAM)
2928	{
2929	/* Read the entire texture to the double buffer. */
2930	GLint activeTexture;
2931
2932	/* Must bind texture to the current context in order to read it. */
2933	glGetIntegerv(pSurface->bindingGL, &activeTexture);
2934	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2935
2936	glBindTexture(pSurface->targetGL, GLTextureId(pSurface));
2937	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2938
2939	if (pSurface->fEmulated)
2940	{
2941	FormatConvReadTexture(pState, pContext, pSurface, uHostMipmap);
2942	}
2943
2944	/* Set row length and alignment of the input data. */
2945	VMSVGAPACKPARAMS SavedParams;
2946	vmsvga3dOglSetPackParams(pState, pContext, pSurface, &SavedParams);
2947
2948	if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2949	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2950	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2951	{
2952	pState->ext.glGetCompressedTexImage(texImageTarget, uHostMipmap, pDoubleBuffer);
2953	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2954	}
2955	else
2956	{
2957	glGetTexImage(texImageTarget, uHostMipmap, pSurface->formatGL, pSurface->typeGL, pDoubleBuffer);
2958	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2959	}
2960
2961	vmsvga3dOglRestorePackParams(pState, pContext, pSurface, &SavedParams);
2962
2963	/* Restore the old active texture. */
2964	glBindTexture(pSurface->targetGL, activeTexture);
2965	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2966
2967	offHst = u32HostBlockX * pSurface->cbBlock + u32HostBlockY * pMipLevel->cbSurfacePitch + u32HostZ * pMipLevel->cbSurfacePlane;
2968	cbSurfacePitch = pMipLevel->cbSurfacePitch;
2969	}
2970	else
2971	{
2972	/* The buffer will contain only the copied rectangle. */
2973	offHst = 0;
2974	cbSurfacePitch = cBlocksX * pSurface->cbBlock;
2975	}
2976
2977	uint64_t offGst = u32GuestBlockX * pSurface->cbBlock + u32GuestBlockY * cbGuestPitch + u32GuestZ * cbGuestPitch * pMipLevel->mipmapSize.height;
2978
2979	for (uint32_t iPlane = 0; iPlane < pBox->d; ++iPlane)
2980	{
2981	AssertBreak(offHst < UINT32_MAX);
2982	AssertBreak(offGst < UINT32_MAX);
2983
2984	rc = vmsvgaR3GmrTransfer(pThis,
2985	pThisCC,
2986	transfer,
2987	pDoubleBuffer,
2988	pMipLevel->cbSurface,
2989	(uint32_t)offHst,
2990	cbSurfacePitch,
2991	GuestPtr,
2992	(uint32_t)offGst,
2993	cbGuestPitch,
2994	cBlocksX * pSurface->cbBlock,
2995	cBlocksY);
2996	AssertRC(rc);
2997
2998	offHst += pMipLevel->cbSurfacePlane;
2999	offGst += pMipLevel->mipmapSize.height * cbGuestPitch;
3000	}
3001
3002	/* Update the opengl surface data. */
3003	if (transfer == SVGA3D_WRITE_HOST_VRAM)
3004	{
3005	GLint activeTexture = 0;
3006	glGetIntegerv(pSurface->bindingGL, &activeTexture);
3007	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3008
3009	/* Must bind texture to the current context in order to change it. */
3010	glBindTexture(pSurface->targetGL, GLTextureId(pSurface));
3011	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3012
3013	LogFunc(("copy texture mipmap level %d (pitch %x)\n", uHostMipmap, pMipLevel->cbSurfacePitch));
3014
3015	/* Set row length and alignment of the input data. */
3016	/* We do not need to set ROW_LENGTH to w here, because the image in pDoubleBuffer is tightly packed. */
3017	VMSVGAPACKPARAMS SavedParams;
3018	vmsvga3dOglSetUnpackParams(pState, pContext, 0, 0, &SavedParams);
3019
3020	if (texImageTarget == GL_TEXTURE_3D)
3021	{
3022	if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
3023	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
3024	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
3025	{
3026	pState->ext.glCompressedTexSubImage3D(texImageTarget,
3027	uHostMipmap,
3028	pBox->x,
3029	pBox->y,
3030	pBox->z,
3031	pBox->w,
3032	pBox->h,
3033	pBox->d,
3034	pSurface->internalFormatGL,
3035	cbSurfacePitch * cBlocksY * pBox->d,
3036	pDoubleBuffer);
3037	}
3038	else
3039	{
3040	pState->ext.glTexSubImage3D(texImageTarget,
3041	uHostMipmap,
3042	u32HostBlockX,
3043	u32HostBlockY,
3044	pBox->z,
3045	cBlocksX,
3046	cBlocksY,
3047	pBox->d,
3048	pSurface->formatGL,
3049	pSurface->typeGL,
3050	pDoubleBuffer);
3051	}
3052	}
3053	else
3054	{
3055	if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
3056	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
3057	\|\| pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
3058	{
3059	pState->ext.glCompressedTexSubImage2D(texImageTarget,
3060	uHostMipmap,
3061	pBox->x,
3062	pBox->y,
3063	pBox->w,
3064	pBox->h,
3065	pSurface->internalFormatGL,
3066	cbSurfacePitch * cBlocksY,
3067	pDoubleBuffer);
3068	}
3069	else
3070	{
3071	glTexSubImage2D(texImageTarget,
3072	uHostMipmap,
3073	u32HostBlockX,
3074	u32HostBlockY,
3075	cBlocksX,
3076	cBlocksY,
3077	pSurface->formatGL,
3078	pSurface->typeGL,
3079	pDoubleBuffer);
3080	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3081
3082	if (pSurface->fEmulated)
3083	{
3084	/* Convert the texture to the actual texture if necessary */
3085	FormatConvUpdateTexture(pState, pContext, pSurface, uHostMipmap);
3086	}
3087	}
3088	}
3089	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3090
3091	/* Restore old values. */
3092	vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
3093
3094	/* Restore the old active texture. */
3095	glBindTexture(pSurface->targetGL, activeTexture);
3096	VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3097	}
3098
3099	Log4(("first line:\n%.Rhxd\n", cBlocksX pSurface->cbBlock, pDoubleBuffer));
3100
3101	/* Free the double buffer. */
3102	RTMemFree(pDoubleBuffer);
3103	break;
3104	}
3105
3106	case VMSVGA3D_OGLRESTYPE_BUFFER:
3107	{
3108	/* Buffers are uncompressed. */
3109	AssertReturn(pSurface->cxBlock == 1 && pSurface->cyBlock == 1, VERR_INTERNAL_ERROR);
3110
3111	/* Caller already clipped pBox and buffers are 1-dimensional. */
3112	Assert(pBox->y == 0 && pBox->h == 1 && pBox->z == 0 && pBox->d == 1);
3113
3114	VMSVGA3D_CLEAR_GL_ERRORS();
3115	pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pSurface->oglId.buffer);
3116	if (VMSVGA3D_GL_IS_SUCCESS(pContext))
3117	{
3118	GLenum enmGlTransfer = (transfer == SVGA3D_READ_HOST_VRAM) ? GL_READ_ONLY : GL_WRITE_ONLY;
3119	uint8_t pbData = (uint8_t )pState->ext.glMapBuffer(GL_ARRAY_BUFFER, enmGlTransfer);
3120	if (RT_LIKELY(pbData != NULL))
3121	{
3122	#if defined(VBOX_STRICT) && defined(RT_OS_DARWIN)
3123	GLint cbStrictBufSize;
3124	glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &cbStrictBufSize);
3125	Assert(VMSVGA3D_GL_IS_SUCCESS(pContext));
3126	AssertMsg(cbStrictBufSize >= (int32_t)pMipLevel->cbSurface,
3127	("cbStrictBufSize=%#x cbSurface=%#x pContext->id=%#x\n", (uint32_t)cbStrictBufSize, pMipLevel->cbSurface, pContext->id));
3128	#endif
3129	Log(("Lock %s memory for rectangle (%d,%d)(%d,%d)\n",
3130	(pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_VERTEXBUFFER ? "vertex" :
3131	(pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_INDEXBUFFER ? "index" : "buffer",
3132	pBox->x, pBox->y, pBox->x + pBox->w, pBox->y + pBox->h));
3133
3134	/* The caller already copied the data to the pMipLevel->pSurfaceData buffer, see VMSVGA3DSURFACE_NEEDS_DATA. */
3135	uint32_t const offHst = pBox->x * pSurface->cbBlock;
3136	uint32_t const cbWidth = pBox->w * pSurface->cbBlock;
3137
3138	memcpy(pbData + offHst, (uint8_t *)pMipLevel->pSurfaceData + offHst, cbWidth);
3139
3140	Log4(("Buffer updated at [0x%x;0x%x):\n%.Rhxd\n", offHst, offHst + cbWidth, cbWidth, (uint8_t )pbData + offHst));
3141
3142	pState->ext.glUnmapBuffer(GL_ARRAY_BUFFER);
3143	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3144	}
3145	else
3146	VMSVGA3D_GL_GET_AND_COMPLAIN(pState, pContext, ("glMapBuffer(GL_ARRAY_BUFFER, %#x) -> NULL\n", enmGlTransfer));
3147	}
3148	else
3149	VMSVGA3D_GL_COMPLAIN(pState, pContext, ("glBindBuffer(GL_ARRAY_BUFFER, %#x)\n", pSurface->oglId.buffer));
3150	pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);
3151	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3152	break;
3153	}
3154
3155	default:
3156	AssertFailed();
3157	break;
3158	}
3159
3160	return rc;
3161	}
3162
3163	static DECLCALLBACK(int) vmsvga3dBackGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
3164	{
3165	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3166	PVMSVGA3DSURFACE pSurface;
3167	int rc = VINF_SUCCESS;
3168	PVMSVGA3DCONTEXT pContext;
3169	uint32_t cid;
3170	GLint activeTexture = 0;
3171
3172	AssertReturn(pState, VERR_NO_MEMORY);
3173
3174	rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
3175	AssertRCReturn(rc, rc);
3176
3177	Assert(filter != SVGA3D_TEX_FILTER_FLATCUBIC);
3178	Assert(filter != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
3179	pSurface->autogenFilter = filter;
3180
3181	LogFunc(("sid=%u filter=%d\n", sid, filter));
3182
3183	cid = SVGA3D_INVALID_ID;
3184	pContext = &pState->SharedCtx;
3185	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
3186
3187	if (pSurface->oglId.texture == OPENGL_INVALID_ID)
3188	{
3189	/* Unknown surface type; turn it into a texture. */
3190	LogFunc(("unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->f.s.surface1Flags, pSurface->format));
3191	rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
3192	AssertRCReturn(rc, rc);
3193	}
3194	else
3195	{
3196	/** @todo new filter */
3197	AssertFailed();
3198	}
3199
3200	glGetIntegerv(pSurface->bindingGL, &activeTexture);
3201	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3202
3203	/* Must bind texture to the current context in order to change it. */
3204	glBindTexture(pSurface->targetGL, pSurface->oglId.texture);
3205	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3206
3207	/* Generate the mip maps. */
3208	pState->ext.glGenerateMipmap(pSurface->targetGL);
3209	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3210
3211	/* Restore the old texture. */
3212	glBindTexture(pSurface->targetGL, activeTexture);
3213	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3214
3215	return VINF_SUCCESS;
3216	}
3217
3218
3219	#ifdef RT_OS_LINUX
3220	/**
3221	* X11 event handling thread.
3222	*
3223	* @returns VINF_SUCCESS (ignored)
3224	* @param hThreadSelf thread handle
3225	* @param pvUser pointer to pState structure
3226	*/
3227	static DECLCALLBACK(int) vmsvga3dXEventThread(RTTHREAD hThreadSelf, void *pvUser)
3228	{
3229	RT_NOREF(hThreadSelf);
3230	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pvUser;
3231	while (!pState->bTerminate)
3232	{
3233	while (XPending(pState->display) > 0)
3234	{
3235	XEvent event;
3236	XNextEvent(pState->display, &event);
3237
3238	switch (event.type)
3239	{
3240	default:
3241	break;
3242	}
3243	}
3244	/* sleep for 16ms to not burn too many cycles */
3245	RTThreadSleep(16);
3246	}
3247	return VINF_SUCCESS;
3248	}
3249	#endif // RT_OS_LINUX
3250
3251
3252	/**
3253	* Create a new 3d context
3254	*
3255	* @returns VBox status code.
3256	* @param pThisCC The VGA/VMSVGA state for ring-3.
3257	* @param cid Context id
3258	* @param fFlags VMSVGA3D_DEF_CTX_F_XXX.
3259	*/
3260	int vmsvga3dContextDefineOgl(PVGASTATECC pThisCC, uint32_t cid, uint32_t fFlags)
3261	{
3262	int rc;
3263	PVMSVGA3DCONTEXT pContext;
3264	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3265
3266	AssertReturn(pState, VERR_NO_MEMORY);
3267	AssertReturn( cid < SVGA3D_MAX_CONTEXT_IDS
3268	\|\| (cid == VMSVGA3D_SHARED_CTX_ID && (fFlags & VMSVGA3D_DEF_CTX_F_SHARED_CTX)), VERR_INVALID_PARAMETER);
3269	#if !defined(VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE) \|\| !(defined(RT_OS_DARWIN))
3270	AssertReturn(!(fFlags & VMSVGA3D_DEF_CTX_F_OTHER_PROFILE), VERR_INTERNAL_ERROR_3);
3271	#endif
3272
3273	Log(("vmsvga3dContextDefine id %x\n", cid));
3274
3275	if (cid == VMSVGA3D_SHARED_CTX_ID)
3276	pContext = &pState->SharedCtx;
3277	else
3278	{
3279	if (cid >= pState->cContexts)
3280	{
3281	/* Grow the array. */
3282	uint32_t cNew = RT_ALIGN(cid + 15, 16);
3283	void pvNew = RTMemRealloc(pState->papContexts, sizeof(pState->papContexts[0]) cNew);
3284	AssertReturn(pvNew, VERR_NO_MEMORY);
3285	pState->papContexts = (PVMSVGA3DCONTEXT *)pvNew;
3286	while (pState->cContexts < cNew)
3287	{
3288	pContext = (PVMSVGA3DCONTEXT)RTMemAllocZ(sizeof(*pContext));
3289	AssertReturn(pContext, VERR_NO_MEMORY);
3290	pContext->id = SVGA3D_INVALID_ID;
3291	pState->papContexts[pState->cContexts++] = pContext;
3292	}
3293	}
3294	/* If one already exists with this id, then destroy it now. */
3295	if (pState->papContexts[cid]->id != SVGA3D_INVALID_ID)
3296	vmsvga3dBackContextDestroy(pThisCC, cid);
3297
3298	pContext = pState->papContexts[cid];
3299	}
3300
3301	/*
3302	* Find or create the shared context if needed (necessary for sharing e.g. textures between contexts).
3303	*/
3304	PVMSVGA3DCONTEXT pSharedCtx = NULL;
3305	if (!(fFlags & (VMSVGA3D_DEF_CTX_F_INIT \| VMSVGA3D_DEF_CTX_F_SHARED_CTX)))
3306	{
3307	pSharedCtx = &pState->SharedCtx;
3308	if (pSharedCtx->id != VMSVGA3D_SHARED_CTX_ID)
3309	{
3310	rc = vmsvga3dContextDefineOgl(pThisCC, VMSVGA3D_SHARED_CTX_ID, VMSVGA3D_DEF_CTX_F_SHARED_CTX);
3311	AssertLogRelRCReturn(rc, rc);
3312
3313	/* Create resources which use the shared context. */
3314	vmsvga3dOnSharedContextDefine(pState);
3315	}
3316	}
3317
3318	/*
3319	* Initialize the context.
3320	*/
3321	memset(pContext, 0, sizeof(*pContext));
3322	pContext->id = cid;
3323	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTextures); i++)
3324	pContext->aSidActiveTextures[i] = SVGA3D_INVALID_ID;
3325
3326	pContext->state.shidVertex = SVGA3D_INVALID_ID;
3327	pContext->state.shidPixel = SVGA3D_INVALID_ID;
3328	pContext->idFramebuffer = OPENGL_INVALID_ID;
3329	pContext->idReadFramebuffer = OPENGL_INVALID_ID;
3330	pContext->idDrawFramebuffer = OPENGL_INVALID_ID;
3331
3332	rc = ShaderContextCreate(&pContext->pShaderContext);
3333	AssertRCReturn(rc, rc);
3334
3335	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderTargets); i++)
3336	pContext->state.aRenderTargets[i] = SVGA3D_INVALID_ID;
3337
3338	#ifdef RT_OS_WINDOWS
3339	/* Create a context window with minimal 4x4 size. We will never use the swapchain
3340	* to present the rendered image. Rendered images from the guest will be copied to
3341	* the VMSVGA SCREEN object, which can be either an offscreen render target or
3342	* system memory in the guest VRAM.
3343	*/
3344	rc = vmsvga3dContextWindowCreate(pState->hInstance, pState->pWindowThread, pState->WndRequestSem, &pContext->hwnd);
3345	AssertRCReturn(rc, rc);
3346
3347	pContext->hdc = GetDC(pContext->hwnd);
3348	AssertMsgReturn(pContext->hdc, ("GetDC %x failed with %d\n", pContext->hwnd, GetLastError()), VERR_INTERNAL_ERROR);
3349
3350	PIXELFORMATDESCRIPTOR pfd = {
3351	sizeof(PIXELFORMATDESCRIPTOR), /* size of this pfd */
3352	1, /* version number */
3353	PFD_DRAW_TO_WINDOW \| /* support window */
3354	PFD_SUPPORT_OPENGL, /* support OpenGL */
3355	PFD_TYPE_RGBA, /* RGBA type */
3356	24, /* 24-bit color depth */
3357	0, 0, 0, 0, 0, 0, /* color bits ignored */
3358	8, /* alpha buffer */
3359	0, /* shift bit ignored */
3360	0, /* no accumulation buffer */
3361	0, 0, 0, 0, /* accum bits ignored */
3362	16, /* set depth buffer */
3363	16, /* set stencil buffer */
3364	0, /* no auxiliary buffer */
3365	PFD_MAIN_PLANE, /* main layer */
3366	0, /* reserved */
3367	0, 0, 0 /* layer masks ignored */
3368	};
3369	int pixelFormat;
3370	BOOL ret;
3371
3372	pixelFormat = ChoosePixelFormat(pContext->hdc, &pfd);
3373	/** @todo is this really necessary?? */
3374	pixelFormat = ChoosePixelFormat(pContext->hdc, &pfd);
3375	AssertMsgReturn(pixelFormat != 0, ("ChoosePixelFormat failed with %d\n", GetLastError()), VERR_INTERNAL_ERROR);
3376
3377	ret = SetPixelFormat(pContext->hdc, pixelFormat, &pfd);
3378	AssertMsgReturn(ret == TRUE, ("SetPixelFormat failed with %d\n", GetLastError()), VERR_INTERNAL_ERROR);
3379
3380	pContext->hglrc = wglCreateContext(pContext->hdc);
3381	AssertMsgReturn(pContext->hglrc, ("wglCreateContext %x failed with %d\n", pContext->hdc, GetLastError()), VERR_INTERNAL_ERROR);
3382
3383	if (pSharedCtx)
3384	{
3385	ret = wglShareLists(pSharedCtx->hglrc, pContext->hglrc);
3386	AssertMsg(ret == TRUE, ("wglShareLists(%p, %p) failed with %d\n", pSharedCtx->hglrc, pContext->hglrc, GetLastError()));
3387	}
3388
3389	#elif defined(RT_OS_DARWIN)
3390	pContext->fOtherProfile = RT_BOOL(fFlags & VMSVGA3D_DEF_CTX_F_OTHER_PROFILE);
3391
3392	NativeNSOpenGLContextRef pShareContext = pSharedCtx ? pSharedCtx->cocoaContext : NULL;
3393	vmsvga3dCocoaCreateViewAndContext(&pContext->cocoaView, &pContext->cocoaContext,
3394	NULL,
3395	4, 4,
3396	pShareContext, pContext->fOtherProfile);
3397
3398	#else
3399	if (pState->display == NULL)
3400	{
3401	/* get an X display and make sure we have glX 1.3 */
3402	pState->display = XOpenDisplay(0);
3403	AssertLogRelMsgReturn(pState->display, ("XOpenDisplay failed"), VERR_INTERNAL_ERROR);
3404	int glxMajor, glxMinor;
3405	Bool ret = glXQueryVersion(pState->display, &glxMajor, &glxMinor);
3406	AssertLogRelMsgReturn(ret && glxMajor == 1 && glxMinor >= 3, ("glX >=1.3 not present"), VERR_INTERNAL_ERROR);
3407	/* start our X event handling thread */
3408	rc = RTThreadCreate(&pState->pWindowThread, vmsvga3dXEventThread, pState, 0, RTTHREADTYPE_GUI, RTTHREADFLAGS_WAITABLE, "VMSVGA3DXEVENT");
3409	AssertLogRelMsgReturn(RT_SUCCESS(rc), ("Async IO Thread creation for 3d window handling failed rc=%Rrc\n", rc), rc);
3410	}
3411
3412	Window defaultRootWindow = XDefaultRootWindow(pState->display);
3413	/* Create a small 4x4 window required for GL context. */
3414	int attrib[] =
3415	{
3416	GLX_RGBA,
3417	GLX_RED_SIZE, 1,
3418	GLX_GREEN_SIZE, 1,
3419	GLX_BLUE_SIZE, 1,
3420	//GLX_ALPHA_SIZE, 1, this flips the bbos screen
3421	GLX_DOUBLEBUFFER,
3422	None
3423	};
3424	XVisualInfo *vi = glXChooseVisual(pState->display, DefaultScreen(pState->display), attrib);
3425	AssertLogRelMsgReturn(vi, ("glXChooseVisual failed"), VERR_INTERNAL_ERROR);
3426	XSetWindowAttributes swa;
3427	swa.colormap = XCreateColormap(pState->display, defaultRootWindow, vi->visual, AllocNone);
3428	AssertLogRelMsgReturn(swa.colormap, ("XCreateColormap failed"), VERR_INTERNAL_ERROR);
3429	swa.border_pixel = 0;
3430	swa.background_pixel = 0;
3431	swa.event_mask = StructureNotifyMask;
3432	unsigned long flags = CWBorderPixel \| CWBackPixel \| CWColormap \| CWEventMask;
3433	pContext->window = XCreateWindow(pState->display, defaultRootWindow,
3434	0, 0, 4, 4,
3435	0, vi->depth, InputOutput,
3436	vi->visual, flags, &swa);
3437	AssertLogRelMsgReturn(pContext->window, ("XCreateWindow failed"), VERR_INTERNAL_ERROR);
3438
3439	/* The window is hidden by default and never mapped, because we only render offscreen and never present to it. */
3440
3441	GLXContext shareContext = pSharedCtx ? pSharedCtx->glxContext : NULL;
3442	pContext->glxContext = glXCreateContext(pState->display, vi, shareContext, GL_TRUE);
3443	XFree(vi);
3444	AssertLogRelMsgReturn(pContext->glxContext, ("glXCreateContext failed"), VERR_INTERNAL_ERROR);
3445	#endif
3446
3447	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
3448
3449	/* NULL during the first PowerOn call. */
3450	if (pState->ext.glGenFramebuffers)
3451	{
3452	/* Create a framebuffer object for this context. */
3453	pState->ext.glGenFramebuffers(1, &pContext->idFramebuffer);
3454	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3455
3456	/* Bind the object to the framebuffer target. */
3457	pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, pContext->idFramebuffer);
3458	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3459
3460	/* Create read and draw framebuffer objects for this context. */
3461	pState->ext.glGenFramebuffers(1, &pContext->idReadFramebuffer);
3462	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3463
3464	pState->ext.glGenFramebuffers(1, &pContext->idDrawFramebuffer);
3465	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3466
3467	}
3468	#if 0
3469	/** @todo move to shader lib!!! */
3470	/* Clear the screen */
3471	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
3472
3473	glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
3474	glClearIndex(0);
3475	glClearDepth(1);
3476	glClearStencil(0xffff);
3477	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
3478	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
3479	glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
3480	if (pState->ext.glProvokingVertex)
3481	pState->ext.glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);
3482	/** @todo move to shader lib!!! */
3483	#endif
3484	return VINF_SUCCESS;
3485	}
3486
3487	#if defined(RT_OS_LINUX)
3488	/*
3489	* HW accelerated graphics output.
3490	*/
3491
3492	/**
3493	* VMSVGA3d screen data.
3494	*
3495	* Allocated on the heap and pointed to by VMSVGASCREENOBJECT::pHwScreen.
3496	*/
3497	typedef struct VMSVGAHWSCREEN
3498	{
3499	/* OpenGL context, which is used for the screen updates. */
3500	GLXContext glxctx;
3501
3502	/* The overlay window. */
3503	Window xwindow;
3504
3505	/* The RGBA texture which hold the screen content. */
3506	GLuint idScreenTexture;
3507
3508	/* Read and draw framebuffer objects for copying a surface to the screen texture. */
3509	GLuint idReadFramebuffer;
3510	GLuint idDrawFramebuffer;
3511	} VMSVGAHWSCREEN;
3512
3513	/* Send a notification to the UI. */
3514	#if 0 /* Unused */
3515	static int vmsvga3dDrvNotifyHwScreen(PVGASTATECC pThisCC, VBOX3D_NOTIFY_TYPE enmNotification,
3516	uint32_t idScreen, Pixmap pixmap, void *pvData, size_t cbData)
3517	{
3518	uint8_t au8Buffer[128];
3519	AssertLogRelMsgReturn(cbData <= sizeof(au8Buffer) - sizeof(VBOX3DNOTIFY),
3520	("cbData %zu", cbData),
3521	VERR_INVALID_PARAMETER);
3522
3523	VBOX3DNOTIFY p = (VBOX3DNOTIFY )&au8Buffer[0];
3524	p->enmNotification = enmNotification;
3525	p->iDisplay = idScreen;
3526	p->u32Reserved = 0;
3527	p->cbData = cbData + sizeof(uint64_t);
3528	/* au8Data consists of a 64 bit pixmap handle followed by notification specific data. */
3529	AssertCompile(sizeof(pixmap) <= sizeof(uint64_t));
3530	(uint64_t )&p->au8Data[0] = (uint64_t)pixmap;
3531	memcpy(&p->au8Data[sizeof(uint64_t)], pvData, cbData);
3532
3533	int rc = pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
3534	return rc;
3535	}
3536	#endif /* Unused */
3537
3538	static void vmsvga3dDrvNotifyHwOverlay(PVGASTATECC pThisCC, VBOX3D_NOTIFY_TYPE enmNotification, uint32_t idScreen)
3539	{
3540	uint8_t au8Buffer[128];
3541	VBOX3DNOTIFY p = (VBOX3DNOTIFY )&au8Buffer[0];
3542	p->enmNotification = enmNotification;
3543	p->iDisplay = idScreen;
3544	p->u32Reserved = 0;
3545	p->cbData = sizeof(uint64_t);
3546	(uint64_t )&p->au8Data[0] = 0;
3547
3548	pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
3549	}
3550
3551	/* Get X Window handle of the UI Framebuffer window. */
3552	static int vmsvga3dDrvQueryWindow(PVGASTATECC pThisCC, uint32_t idScreen, Window *pWindow)
3553	{
3554	uint8_t au8Buffer[128];
3555	VBOX3DNOTIFY p = (VBOX3DNOTIFY )&au8Buffer[0];
3556	p->enmNotification = VBOX3D_NOTIFY_TYPE_HW_OVERLAY_GET_ID;
3557	p->iDisplay = idScreen;
3558	p->u32Reserved = 0;
3559	p->cbData = sizeof(uint64_t);
3560	(uint64_t )&p->au8Data[0] = 0;
3561
3562	int rc = pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
3563	if (RT_SUCCESS(rc))
3564	{
3565	pWindow = (Window)(uint64_t *)&p->au8Data[0];
3566	}
3567	return rc;
3568	}
3569
3570	static int ctxErrorHandler(Display dpy, XErrorEvent ev)
3571	{
3572	RT_NOREF(dpy);
3573	LogRel4(("VMSVGA: XError %d\n", (int)ev->error_code));
3574	return 0;
3575	}
3576
3577	/* Create an overlay X window for the HW accelerated screen. */
3578	static int vmsvga3dHwScreenCreate(PVMSVGA3DSTATE pState, Window parentWindow, unsigned int cWidth, unsigned int cHeight, VMSVGAHWSCREEN *p)
3579	{
3580	int (oldHandler)(Display, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
3581
3582	int rc = VINF_SUCCESS;
3583
3584	XWindowAttributes parentAttr;
3585	if (XGetWindowAttributes(pState->display, parentWindow, &parentAttr) == 0)
3586	return VERR_INVALID_PARAMETER;
3587
3588	int const idxParentScreen = XScreenNumberOfScreen(parentAttr.screen);
3589
3590	/*
3591	* Create a new GL context, which will be used for copying to the screen.
3592	*/
3593
3594	/* FBConfig attributes for the overlay window. */
3595	static int const aConfigAttribList[] =
3596	{
3597	GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, // Must support GLX windows
3598	GLX_DOUBLEBUFFER, False, // Double buffering had a much lower performance.
3599	GLX_RED_SIZE, 8, // True color RGB with 8 bits per channel.
3600	GLX_GREEN_SIZE, 8,
3601	GLX_BLUE_SIZE, 8,
3602	GLX_ALPHA_SIZE, 8,
3603	GLX_STENCIL_SIZE, 0, // No stencil buffer
3604	GLX_DEPTH_SIZE, 0, // No depth buffer
3605	None
3606	};
3607
3608	/* Find a suitable FB config. */
3609	int cConfigs = 0;
3610	GLXFBConfig *paConfigs = glXChooseFBConfig(pState->display, idxParentScreen, aConfigAttribList, &cConfigs);
3611	LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: paConfigs %p cConfigs %d\n", (void *)paConfigs, cConfigs));
3612	if (paConfigs)
3613	{
3614	XVisualInfo *vi = NULL;
3615	int i = 0;
3616	for (; i < cConfigs; ++i)
3617	{
3618	/* Use XFree to free the data returned in the previous iteration of this loop. */
3619	if (vi)
3620	XFree(vi);
3621
3622	vi = glXGetVisualFromFBConfig(pState->display, paConfigs[i]);
3623	if (!vi)
3624	continue;
3625
3626	LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: %p vid %lu screen %d depth %d r %lu g %lu b %lu clrmap %d bitsperrgb %d\n",
3627	(void *)vi->visual, vi->visualid, vi->screen, vi->depth,
3628	vi->red_mask, vi->green_mask, vi->blue_mask, vi->colormap_size, vi->bits_per_rgb));
3629
3630	/* Same screen as the parent window. */
3631	if (vi->screen != idxParentScreen)
3632	continue;
3633
3634	/* Search for 32 bits per pixel. */
3635	if (vi->depth != 32)
3636	continue;
3637
3638	/* 8 bits per color component is enough. */
3639	if (vi->bits_per_rgb != 8)
3640	continue;
3641
3642	/* Render to pixmap. */
3643	int value = 0;
3644	glXGetFBConfigAttrib(pState->display, paConfigs[i], GLX_DRAWABLE_TYPE, &value);
3645	if (!(value & GLX_WINDOW_BIT))
3646	continue;
3647
3648	/* This FB config can be used. */
3649	break;
3650	}
3651
3652	if (i < cConfigs)
3653	{
3654	/* Found a suitable config with index i. */
3655
3656	/* Create an overlay window. */
3657	XSetWindowAttributes swa;
3658	RT_ZERO(swa);
3659
3660	swa.colormap = XCreateColormap(pState->display, parentWindow, vi->visual, AllocNone);
3661	AssertLogRelMsg(swa.colormap, ("XCreateColormap failed"));
3662	swa.border_pixel = 0;
3663	swa.background_pixel = 0;
3664	swa.event_mask = StructureNotifyMask;
3665	swa.override_redirect = 1;
3666	unsigned long const swaAttrs = CWBorderPixel \| CWBackPixel \| CWColormap \| CWEventMask \| CWOverrideRedirect;
3667	p->xwindow = XCreateWindow(pState->display, parentWindow,
3668	0, 0, cWidth, cHeight, 0, vi->depth, InputOutput,
3669	vi->visual, swaAttrs, &swa);
3670	LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->xwindow %ld\n", p->xwindow));
3671	if (p->xwindow)
3672	{
3673
3674	p->glxctx = glXCreateContext(pState->display, vi, pState->SharedCtx.glxContext, GL_TRUE);
3675	LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->glxctx %p\n", (void *)p->glxctx));
3676	if (p->glxctx)
3677	{
3678	XMapWindow(pState->display, p->xwindow);
3679	}
3680	else
3681	{
3682	LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: glXCreateContext failed\n"));
3683	rc = VERR_NOT_SUPPORTED;
3684	}
3685	}
3686	else
3687	{
3688	LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: XCreateWindow failed\n"));
3689	rc = VERR_NOT_SUPPORTED;
3690	}
3691
3692	XSync(pState->display, False);
3693	}
3694	else
3695	{
3696	/* A suitable config is not found. */
3697	LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: no FBConfig\n"));
3698	rc = VERR_NOT_SUPPORTED;
3699	}
3700
3701	if (vi)
3702	XFree(vi);
3703
3704	/* "Use XFree to free the memory returned by glXChooseFBConfig." */
3705	XFree(paConfigs);
3706	}
3707	else
3708	{
3709	/* glXChooseFBConfig failed. */
3710	rc = VERR_NOT_SUPPORTED;
3711	}
3712
3713	XSetErrorHandler(oldHandler);
3714	return rc;
3715	}
3716
3717	/* Destroy a HW accelerated screen. */
3718	static void vmsvga3dHwScreenDestroy(PVMSVGA3DSTATE pState, VMSVGAHWSCREEN *p)
3719	{
3720	if (p)
3721	{
3722	LogRel4(("VMSVGA: vmsvga3dHwScreenDestroy: p->xwindow %ld, ctx %p\n", p->xwindow, (void *)p->glxctx));
3723	if (p->glxctx)
3724	{
3725	/* GLX context is changed here, so other code has to set the appropriate context again. */
3726	VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
3727
3728	glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
3729
3730	/* Clean up OpenGL. */
3731	if (p->idReadFramebuffer != OPENGL_INVALID_ID)
3732	pState->ext.glDeleteFramebuffers(1, &p->idReadFramebuffer);
3733	if (p->idDrawFramebuffer != OPENGL_INVALID_ID)
3734	pState->ext.glDeleteFramebuffers(1, &p->idDrawFramebuffer);
3735	if (p->idScreenTexture != OPENGL_INVALID_ID)
3736	glDeleteTextures(1, &p->idScreenTexture);
3737
3738	glXMakeCurrent(pState->display, None, NULL);
3739
3740	glXDestroyContext(pState->display, p->glxctx);
3741	}
3742
3743	if (p->xwindow)
3744	XDestroyWindow(pState->display, p->xwindow);
3745
3746	RT_ZERO(*p);
3747	}
3748	}
3749
3750	#define GLCHECK() \
3751	do { \
3752	int glErr = glGetError(); \
3753	if (glErr != GL_NO_ERROR) LogRel4(("VMSVGA: GL error 0x%x @%d\n", glErr, __LINE__)); \
3754	} while(0)
3755
3756	static DECLCALLBACK(int) vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
3757	{
3758	LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: screen %u\n", pScreen->idScreen));
3759
3760	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3761	AssertReturn(pState, VERR_NOT_SUPPORTED);
3762
3763	if (!pThis->svga.f3DOverlayEnabled)
3764	return VERR_NOT_SUPPORTED;
3765
3766	Assert(pScreen->pHwScreen == NULL);
3767
3768	VMSVGAHWSCREEN p = (VMSVGAHWSCREEN )RTMemAllocZ(sizeof(VMSVGAHWSCREEN));
3769	AssertPtrReturn(p, VERR_NO_MEMORY);
3770
3771	/* Query the parent window ID from the UI framebuffer.
3772	* If it is there then
3773	* the device will create a texture for the screen content and an overlay window to present the screen content.
3774	* otherwise
3775	* the device will use the guest VRAM system memory for the screen content.
3776	*/
3777	Window parentWindow;
3778	int rc = vmsvga3dDrvQueryWindow(pThisCC, pScreen->idScreen, &parentWindow);
3779	if (RT_SUCCESS(rc))
3780	{
3781	/* Create the hardware accelerated screen. */
3782	rc = vmsvga3dHwScreenCreate(pState, parentWindow, pScreen->cWidth, pScreen->cHeight, p);
3783	if (RT_SUCCESS(rc))
3784	{
3785	/*
3786	* Setup the OpenGL context of the screen. The context will be used to draw on the screen.
3787	*/
3788
3789	/* GLX context is changed here, so other code has to set the appropriate context again. */
3790	VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
3791
3792	Bool const fSuccess = glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
3793	if (fSuccess)
3794	{
3795	/* Set GL state. */
3796	glClearColor(0, 0, 0, 1);
3797	glEnable(GL_TEXTURE_2D);
3798	glDisable(GL_DEPTH_TEST);
3799	glDisable(GL_CULL_FACE);
3800
3801	/* The RGBA texture which hold the screen content. */
3802	glGenTextures(1, &p->idScreenTexture); GLCHECK();
3803	glBindTexture(GL_TEXTURE_2D, p->idScreenTexture); GLCHECK();
3804	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); GLCHECK();
3805	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); GLCHECK();
3806	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, pScreen->cWidth, pScreen->cHeight, 0,
3807	GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); GLCHECK();
3808
3809	/* Create read and draw framebuffer objects for this screen. */
3810	pState->ext.glGenFramebuffers(1, &p->idReadFramebuffer); GLCHECK();
3811	pState->ext.glGenFramebuffers(1, &p->idDrawFramebuffer); GLCHECK();
3812
3813	/* Work in screen coordinates. */
3814	glMatrixMode(GL_MODELVIEW);
3815	glLoadIdentity();
3816	glOrtho(0, pScreen->cWidth, 0, pScreen->cHeight, -1, 1);
3817	glMatrixMode(GL_PROJECTION);
3818	glLoadIdentity();
3819
3820	/* Clear the texture. */
3821	pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, p->idDrawFramebuffer); GLCHECK();
3822	pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
3823	p->idScreenTexture, 0); GLCHECK();
3824
3825	glClear(GL_COLOR_BUFFER_BIT);
3826
3827	pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); GLCHECK();
3828
3829	glXMakeCurrent(pState->display, None, NULL);
3830
3831	XSync(pState->display, False);
3832
3833	vmsvga3dDrvNotifyHwOverlay(pThisCC, VBOX3D_NOTIFY_TYPE_HW_OVERLAY_CREATED, pScreen->idScreen);
3834	}
3835	else
3836	{
3837	LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: failed to set current context\n"));
3838	rc = VERR_NOT_SUPPORTED;
3839	}
3840	}
3841	}
3842	else
3843	{
3844	LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: no framebuffer\n"));
3845	}
3846
3847	if (RT_SUCCESS(rc))
3848	{
3849	LogRel(("VMSVGA: Using HW accelerated screen %u\n", pScreen->idScreen));
3850	pScreen->pHwScreen = p;
3851	}
3852	else
3853	{
3854	LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: %Rrc\n", rc));
3855	vmsvga3dHwScreenDestroy(pState, p);
3856	RTMemFree(p);
3857	}
3858
3859	return rc;
3860	}
3861
3862	static DECLCALLBACK(int) vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
3863	{
3864	LogRel4(("VMSVGA: vmsvga3dBackDestroyScreen: screen %u\n", pScreen->idScreen));
3865
3866	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3867	AssertReturn(pState, VERR_NOT_SUPPORTED);
3868
3869	int (oldHandler)(Display, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
3870
3871	VMSVGAHWSCREEN *p = pScreen->pHwScreen;
3872	if (p)
3873	{
3874	pScreen->pHwScreen = NULL;
3875
3876	vmsvga3dDrvNotifyHwOverlay(pThisCC, VBOX3D_NOTIFY_TYPE_HW_OVERLAY_DESTROYED, pScreen->idScreen);
3877
3878	vmsvga3dHwScreenDestroy(pState, p);
3879	RTMemFree(p);
3880	}
3881
3882	XSetErrorHandler(oldHandler);
3883
3884	return VINF_SUCCESS;
3885	}
3886
3887	/* Blit a surface to the GLX pixmap. */
3888	static DECLCALLBACK(int) vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
3889	SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
3890	SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects)
3891	{
3892	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3893	AssertReturn(pState, VERR_NOT_SUPPORTED);
3894
3895	VMSVGAHWSCREEN *p = pScreen->pHwScreen;
3896	AssertReturn(p, VERR_NOT_SUPPORTED);
3897
3898	PVMSVGA3DSURFACE pSurface;
3899	int rc = vmsvga3dSurfaceFromSid(pState, srcImage.sid, &pSurface);
3900	AssertRCReturn(rc, rc);
3901
3902	if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
3903	{
3904	LogFunc(("src sid=%u flags=0x%x format=%d -> create texture\n", srcImage.sid, pSurface->f.s.surface1Flags, pSurface->format));
3905	rc = vmsvga3dBackCreateTexture(pThisCC, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID, pSurface);
3906	AssertRCReturn(rc, rc);
3907	}
3908
3909	AssertReturn(pSurface->enmOGLResType == VMSVGA3D_OGLRESTYPE_TEXTURE, VERR_NOT_SUPPORTED);
3910
3911	PVMSVGA3DMIPMAPLEVEL pMipLevel;
3912	rc = vmsvga3dMipmapLevel(pSurface, srcImage.face, srcImage.mipmap, &pMipLevel);
3913	AssertRCReturn(rc, rc);
3914
3915	/** @todo Implement. */
3916	RT_NOREF(cRects, paRects);
3917
3918	/* GLX context is changed here, so other code has to set appropriate context again. */
3919	VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
3920
3921	int (oldHandler)(Display, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
3922
3923	Bool fSuccess = glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
3924	if (fSuccess)
3925	{
3926	/* Activate the read and draw framebuffer objects. */
3927	pState->ext.glBindFramebuffer(GL_READ_FRAMEBUFFER, p->idReadFramebuffer); GLCHECK();
3928	pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, p->idDrawFramebuffer); GLCHECK();
3929
3930	/* Bind the source and destination objects to the right place. */
3931	pState->ext.glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
3932	pSurface->oglId.texture, 0); GLCHECK();
3933	pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
3934	p->idScreenTexture, 0); GLCHECK();
3935
3936	pState->ext.glBlitFramebuffer(srcRect.left,
3937	srcRect.top,
3938	srcRect.right,
3939	srcRect.bottom,
3940	destRect.left,
3941	destRect.top,
3942	destRect.right,
3943	destRect.bottom,
3944	GL_COLOR_BUFFER_BIT,
3945	GL_NEAREST); GLCHECK();
3946
3947	/* Reset the frame buffer association */
3948	pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, 0); GLCHECK();
3949
3950	/* Update the overlay window. */
3951	glClear(GL_COLOR_BUFFER_BIT);
3952
3953	glBindTexture(GL_TEXTURE_2D, p->idScreenTexture); GLCHECK();
3954
3955	GLint const w = pScreen->cWidth;
3956	GLint const h = pScreen->cHeight;
3957
3958	glBegin(GL_QUADS);
3959	glTexCoord2f(0.0f, 0.0f); glVertex2i(0, h);
3960	glTexCoord2f(0.0f, 1.0f); glVertex2i(0, 0);
3961	glTexCoord2f(1.0f, 1.0f); glVertex2i(w, 0);
3962	glTexCoord2f(1.0f, 0.0f); glVertex2i(w, h);
3963	glEnd(); GLCHECK();
3964
3965	glBindTexture(GL_TEXTURE_2D, 0); GLCHECK();
3966
3967	glXMakeCurrent(pState->display, None, NULL);
3968	}
3969	else
3970	{
3971	LogRel4(("VMSVGA: vmsvga3dBackSurfaceBlitToScreen: screen %u, glXMakeCurrent for pixmap failed\n", pScreen->idScreen));
3972	}
3973
3974	XSetErrorHandler(oldHandler);
3975
3976	return VINF_SUCCESS;
3977	}
3978
3979	#else /* !RT_OS_LINUX */
3980
3981	static DECLCALLBACK(int) vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
3982	{
3983	RT_NOREF(pThis, pThisCC, pScreen);
3984	return VERR_NOT_IMPLEMENTED;
3985	}
3986
3987	static DECLCALLBACK(int) vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
3988	{
3989	RT_NOREF(pThisCC, pScreen);
3990	return VERR_NOT_IMPLEMENTED;
3991	}
3992
3993	static DECLCALLBACK(int) vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
3994	SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
3995	SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects)
3996	{
3997	RT_NOREF(pThisCC, pScreen, destRect, srcImage, srcRect, cRects, paRects);
3998	return VERR_NOT_IMPLEMENTED;
3999	}
4000	#endif
4001
4002	/**
4003	* Create a new 3d context
4004	*
4005	* @returns VBox status code.
4006	* @param pThisCC The VGA/VMSVGA state for ring-3.
4007	* @param cid Context id
4008	*/
4009	static DECLCALLBACK(int) vmsvga3dBackContextDefine(PVGASTATECC pThisCC, uint32_t cid)
4010	{
4011	return vmsvga3dContextDefineOgl(pThisCC, cid, 0/fFlags/);
4012	}
4013
4014	/**
4015	* Destroys a 3d context.
4016	*
4017	* @returns VBox status code.
4018	* @param pThisCC The VGA/VMSVGA state for ring-3.
4019	* @param pContext The context to destroy.
4020	* @param cid Context id
4021	*/
4022	static int vmsvga3dContextDestroyOgl(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid)
4023	{
4024	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4025	AssertReturn(pState, VERR_NO_MEMORY);
4026	AssertReturn(pContext, VERR_INVALID_PARAMETER);
4027	AssertReturn(pContext->id == cid, VERR_INVALID_PARAMETER);
4028	Log(("vmsvga3dContextDestroyOgl id %x\n", cid));
4029
4030	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
4031
4032	if (pContext->id == VMSVGA3D_SHARED_CTX_ID)
4033	{
4034	/* Delete resources which use the shared context. */
4035	vmsvga3dOnSharedContextDestroy(pState);
4036	}
4037
4038	/* Destroy all leftover pixel shaders. */
4039	for (uint32_t i = 0; i < pContext->cPixelShaders; i++)
4040	{
4041	if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
4042	vmsvga3dBackShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
4043	}
4044	if (pContext->paPixelShader)
4045	RTMemFree(pContext->paPixelShader);
4046
4047	/* Destroy all leftover vertex shaders. */
4048	for (uint32_t i = 0; i < pContext->cVertexShaders; i++)
4049	{
4050	if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
4051	vmsvga3dBackShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
4052	}
4053	if (pContext->paVertexShader)
4054	RTMemFree(pContext->paVertexShader);
4055
4056	if (pContext->state.paVertexShaderConst)
4057	RTMemFree(pContext->state.paVertexShaderConst);
4058	if (pContext->state.paPixelShaderConst)
4059	RTMemFree(pContext->state.paPixelShaderConst);
4060
4061	if (pContext->pShaderContext)
4062	{
4063	int rc = ShaderContextDestroy(pContext->pShaderContext);
4064	AssertRC(rc);
4065	}
4066
4067	if (pContext->idFramebuffer != OPENGL_INVALID_ID)
4068	{
4069	/* Unbind the object from the framebuffer target. */
4070	pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, 0 /* back buffer */);
4071	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4072	pState->ext.glDeleteFramebuffers(1, &pContext->idFramebuffer);
4073	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4074
4075	if (pContext->idReadFramebuffer != OPENGL_INVALID_ID)
4076	{
4077	pState->ext.glDeleteFramebuffers(1, &pContext->idReadFramebuffer);
4078	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4079	}
4080	if (pContext->idDrawFramebuffer != OPENGL_INVALID_ID)
4081	{
4082	pState->ext.glDeleteFramebuffers(1, &pContext->idDrawFramebuffer);
4083	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4084	}
4085	}
4086
4087	vmsvga3dBackOcclusionQueryDelete(pThisCC, pContext);
4088
4089	#ifdef RT_OS_WINDOWS
4090	wglMakeCurrent(pContext->hdc, NULL);
4091	wglDeleteContext(pContext->hglrc);
4092	ReleaseDC(pContext->hwnd, pContext->hdc);
4093
4094	/* Destroy the window we've created. */
4095	int rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_DESTROYWINDOW, (WPARAM)pContext->hwnd, 0);
4096	AssertRC(rc);
4097	#elif defined(RT_OS_DARWIN)
4098	vmsvga3dCocoaDestroyViewAndContext(pContext->cocoaView, pContext->cocoaContext);
4099	#elif defined(RT_OS_LINUX)
4100	glXMakeCurrent(pState->display, None, NULL);
4101	glXDestroyContext(pState->display, pContext->glxContext);
4102	XDestroyWindow(pState->display, pContext->window);
4103	#endif
4104
4105	memset(pContext, 0, sizeof(*pContext));
4106	pContext->id = SVGA3D_INVALID_ID;
4107
4108	VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
4109	return VINF_SUCCESS;
4110	}
4111
4112	/**
4113	* Destroy an existing 3d context
4114	*
4115	* @returns VBox status code.
4116	* @param pThisCC The VGA/VMSVGA state for ring-3.
4117	* @param cid Context id
4118	*/
4119	static DECLCALLBACK(int) vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
4120	{
4121	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4122	AssertReturn(pState, VERR_WRONG_ORDER);
4123
4124	/*
4125	* Resolve the context and hand it to the common worker function.
4126	*/
4127	if ( cid < pState->cContexts
4128	&& pState->papContexts[cid]->id == cid)
4129	return vmsvga3dContextDestroyOgl(pThisCC, pState->papContexts[cid], cid);
4130
4131	AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
4132	return VINF_SUCCESS;
4133	}
4134
4135	/**
4136	* Worker for vmsvga3dBackChangeMode that resizes a context.
4137	*
4138	* @param pState The VMSVGA3d state.
4139	* @param pContext The context.
4140	*/
4141	static void vmsvga3dChangeModeOneContext(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
4142	{
4143	RT_NOREF(pState, pContext);
4144	/* Do nothing. The window is not used for presenting. */
4145	}
4146
4147	/* Handle resize */
4148	static DECLCALLBACK(int) vmsvga3dBackChangeMode(PVGASTATECC pThisCC)
4149	{
4150	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4151	AssertReturn(pState, VERR_NO_MEMORY);
4152
4153	/* Resize the shared context too. */
4154	if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
4155	vmsvga3dChangeModeOneContext(pState, &pState->SharedCtx);
4156
4157	/* Resize all active contexts. */
4158	for (uint32_t i = 0; i < pState->cContexts; i++)
4159	{
4160	PVMSVGA3DCONTEXT pContext = pState->papContexts[i];
4161	if (pContext->id != SVGA3D_INVALID_ID)
4162	vmsvga3dChangeModeOneContext(pState, pContext);
4163	}
4164
4165	return VINF_SUCCESS;
4166	}
4167
4168
4169	static DECLCALLBACK(int) vmsvga3dBackSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
4170	{
4171	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4172	AssertReturn(pState, VERR_NO_MEMORY);
4173	bool fModelViewChanged = false;
4174
4175	Log(("vmsvga3dSetTransform cid=%u %s\n", cid, vmsvgaTransformToString(type)));
4176
4177	ASSERT_GUEST_RETURN((unsigned)type < SVGA3D_TRANSFORM_MAX, VERR_INVALID_PARAMETER);
4178
4179	PVMSVGA3DCONTEXT pContext;
4180	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4181	AssertRCReturn(rc, rc);
4182
4183	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
4184
4185	/* Save this matrix for vm state save/restore. */
4186	pContext->state.aTransformState[type].fValid = true;
4187	memcpy(pContext->state.aTransformState[type].matrix, matrix, sizeof(pContext->state.aTransformState[type].matrix));
4188	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_TRANSFORM;
4189
4190	Log(("Matrix [%d %d %d %d]\n", (int)(matrix[0] * 10.0), (int)(matrix[1] * 10.0), (int)(matrix[2] * 10.0), (int)(matrix[3] * 10.0)));
4191	Log((" [%d %d %d %d]\n", (int)(matrix[4] * 10.0), (int)(matrix[5] * 10.0), (int)(matrix[6] * 10.0), (int)(matrix[7] * 10.0)));
4192	Log((" [%d %d %d %d]\n", (int)(matrix[8] * 10.0), (int)(matrix[9] * 10.0), (int)(matrix[10] * 10.0), (int)(matrix[11] * 10.0)));
4193	Log((" [%d %d %d %d]\n", (int)(matrix[12] * 10.0), (int)(matrix[13] * 10.0), (int)(matrix[14] * 10.0), (int)(matrix[15] * 10.0)));
4194
4195	switch (type)
4196	{
4197	case SVGA3D_TRANSFORM_VIEW:
4198	/* View * World = Model View */
4199	glMatrixMode(GL_MODELVIEW);
4200	glLoadMatrixf(matrix);
4201	if (pContext->state.aTransformState[SVGA3D_TRANSFORM_WORLD].fValid)
4202	glMultMatrixf(pContext->state.aTransformState[SVGA3D_TRANSFORM_WORLD].matrix);
4203	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4204	fModelViewChanged = true;
4205	break;
4206
4207	case SVGA3D_TRANSFORM_PROJECTION:
4208	{
4209	rc = ShaderTransformProjection(pContext->state.RectViewPort.w, pContext->state.RectViewPort.h, matrix, false /* fPretransformed */);
4210	AssertRCReturn(rc, rc);
4211	break;
4212	}
4213
4214	case SVGA3D_TRANSFORM_TEXTURE0:
4215	glMatrixMode(GL_TEXTURE);
4216	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4217	glLoadMatrixf(matrix);
4218	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4219	break;
4220
4221	case SVGA3D_TRANSFORM_TEXTURE1:
4222	case SVGA3D_TRANSFORM_TEXTURE2:
4223	case SVGA3D_TRANSFORM_TEXTURE3:
4224	case SVGA3D_TRANSFORM_TEXTURE4:
4225	case SVGA3D_TRANSFORM_TEXTURE5:
4226	case SVGA3D_TRANSFORM_TEXTURE6:
4227	case SVGA3D_TRANSFORM_TEXTURE7:
4228	Log(("vmsvga3dSetTransform: unsupported SVGA3D_TRANSFORM_TEXTUREx transform!!\n"));
4229	return VERR_INVALID_PARAMETER;
4230
4231	case SVGA3D_TRANSFORM_WORLD:
4232	/* View * World = Model View */
4233	glMatrixMode(GL_MODELVIEW);
4234	if (pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].fValid)
4235	glLoadMatrixf(pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].matrix);
4236	else
4237	glLoadIdentity();
4238	glMultMatrixf(matrix);
4239	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4240	fModelViewChanged = true;
4241	break;
4242
4243	case SVGA3D_TRANSFORM_WORLD1:
4244	case SVGA3D_TRANSFORM_WORLD2:
4245	case SVGA3D_TRANSFORM_WORLD3:
4246	Log(("vmsvga3dSetTransform: unsupported SVGA3D_TRANSFORM_WORLDx transform!!\n"));
4247	return VERR_INVALID_PARAMETER;
4248
4249	default:
4250	Log(("vmsvga3dSetTransform: unknown type!!\n"));
4251	return VERR_INVALID_PARAMETER;
4252	}
4253
4254	/* Apparently we need to reset the light and clip data after modifying the modelview matrix. */
4255	if (fModelViewChanged)
4256	{
4257	/* Reprogram the clip planes. */
4258	for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aClipPlane); j++)
4259	{
4260	if (pContext->state.aClipPlane[j].fValid == true)
4261	vmsvga3dBackSetClipPlane(pThisCC, cid, j, pContext->state.aClipPlane[j].plane);
4262	}
4263
4264	/* Reprogram the light data. */
4265	for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aLightData); j++)
4266	{
4267	if (pContext->state.aLightData[j].fValidData == true)
4268	vmsvga3dBackSetLightData(pThisCC, cid, j, &pContext->state.aLightData[j].data);
4269	}
4270	}
4271
4272	return VINF_SUCCESS;
4273	}
4274
4275	static DECLCALLBACK(int) vmsvga3dBackSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
4276	{
4277	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4278	AssertReturn(pState, VERR_NO_MEMORY);
4279
4280	Log(("vmsvga3dSetZRange cid=%u min=%d max=%d\n", cid, (uint32_t)(zRange.min * 100.0), (uint32_t)(zRange.max * 100.0)));
4281
4282	PVMSVGA3DCONTEXT pContext;
4283	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4284	AssertRCReturn(rc, rc);
4285
4286	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
4287
4288	pContext->state.zRange = zRange;
4289	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_ZRANGE;
4290
4291	if (zRange.min < -1.0)
4292	zRange.min = -1.0;
4293	if (zRange.max > 1.0)
4294	zRange.max = 1.0;
4295
4296	glDepthRange((GLdouble)zRange.min, (GLdouble)zRange.max);
4297	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4298	return VINF_SUCCESS;
4299	}
4300
4301	/**
4302	* Convert SVGA blend op value to its OpenGL equivalent
4303	*/
4304	static GLenum vmsvga3dBlendOp2GL(uint32_t blendOp)
4305	{
4306	switch (blendOp)
4307	{
4308	case SVGA3D_BLENDOP_ZERO:
4309	return GL_ZERO;
4310	case SVGA3D_BLENDOP_ONE:
4311	return GL_ONE;
4312	case SVGA3D_BLENDOP_SRCCOLOR:
4313	return GL_SRC_COLOR;
4314	case SVGA3D_BLENDOP_INVSRCCOLOR:
4315	return GL_ONE_MINUS_SRC_COLOR;
4316	case SVGA3D_BLENDOP_SRCALPHA:
4317	return GL_SRC_ALPHA;
4318	case SVGA3D_BLENDOP_INVSRCALPHA:
4319	return GL_ONE_MINUS_SRC_ALPHA;
4320	case SVGA3D_BLENDOP_DESTALPHA:
4321	return GL_DST_ALPHA;
4322	case SVGA3D_BLENDOP_INVDESTALPHA:
4323	return GL_ONE_MINUS_DST_ALPHA;
4324	case SVGA3D_BLENDOP_DESTCOLOR:
4325	return GL_DST_COLOR;
4326	case SVGA3D_BLENDOP_INVDESTCOLOR:
4327	return GL_ONE_MINUS_DST_COLOR;
4328	case SVGA3D_BLENDOP_SRCALPHASAT:
4329	return GL_SRC_ALPHA_SATURATE;
4330	case SVGA3D_BLENDOP_BLENDFACTOR:
4331	return GL_CONSTANT_COLOR;
4332	case SVGA3D_BLENDOP_INVBLENDFACTOR:
4333	return GL_ONE_MINUS_CONSTANT_COLOR;
4334	default:
4335	AssertFailed();
4336	return GL_ONE;
4337	}
4338	}
4339
4340	static GLenum vmsvga3dBlendEquation2GL(uint32_t blendEq)
4341	{
4342	switch (blendEq)
4343	{
4344	case SVGA3D_BLENDEQ_ADD:
4345	return GL_FUNC_ADD;
4346	case SVGA3D_BLENDEQ_SUBTRACT:
4347	return GL_FUNC_SUBTRACT;
4348	case SVGA3D_BLENDEQ_REVSUBTRACT:
4349	return GL_FUNC_REVERSE_SUBTRACT;
4350	case SVGA3D_BLENDEQ_MINIMUM:
4351	return GL_MIN;
4352	case SVGA3D_BLENDEQ_MAXIMUM:
4353	return GL_MAX;
4354	default:
4355	/* SVGA3D_BLENDEQ_INVALID means that the render state has not been set, therefore use default. */
4356	AssertMsg(blendEq == SVGA3D_BLENDEQ_INVALID, ("blendEq=%d (%#x)\n", blendEq, blendEq));
4357	return GL_FUNC_ADD;
4358	}
4359	}
4360
4361	static GLenum vmsvgaCmpFunc2GL(uint32_t cmpFunc)
4362	{
4363	switch (cmpFunc)
4364	{
4365	case SVGA3D_CMP_NEVER:
4366	return GL_NEVER;
4367	case SVGA3D_CMP_LESS:
4368	return GL_LESS;
4369	case SVGA3D_CMP_EQUAL:
4370	return GL_EQUAL;
4371	case SVGA3D_CMP_LESSEQUAL:
4372	return GL_LEQUAL;
4373	case SVGA3D_CMP_GREATER:
4374	return GL_GREATER;
4375	case SVGA3D_CMP_NOTEQUAL:
4376	return GL_NOTEQUAL;
4377	case SVGA3D_CMP_GREATEREQUAL:
4378	return GL_GEQUAL;
4379	case SVGA3D_CMP_ALWAYS:
4380	return GL_ALWAYS;
4381	default:
4382	Assert(cmpFunc == SVGA3D_CMP_INVALID);
4383	return GL_LESS;
4384	}
4385	}
4386
4387	static GLenum vmsvgaStencipOp2GL(uint32_t stencilOp)
4388	{
4389	switch (stencilOp)
4390	{
4391	case SVGA3D_STENCILOP_KEEP:
4392	return GL_KEEP;
4393	case SVGA3D_STENCILOP_ZERO:
4394	return GL_ZERO;
4395	case SVGA3D_STENCILOP_REPLACE:
4396	return GL_REPLACE;
4397	case SVGA3D_STENCILOP_INCRSAT:
4398	return GL_INCR_WRAP;
4399	case SVGA3D_STENCILOP_DECRSAT:
4400	return GL_DECR_WRAP;
4401	case SVGA3D_STENCILOP_INVERT:
4402	return GL_INVERT;
4403	case SVGA3D_STENCILOP_INCR:
4404	return GL_INCR;
4405	case SVGA3D_STENCILOP_DECR:
4406	return GL_DECR;
4407	default:
4408	Assert(stencilOp == SVGA3D_STENCILOP_INVALID);
4409	return GL_KEEP;
4410	}
4411	}
4412
4413	static DECLCALLBACK(int) vmsvga3dBackSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
4414	{
4415	uint32_t val = UINT32_MAX; /* Shut up MSC. */
4416	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4417	AssertReturn(pState, VERR_NO_MEMORY);
4418
4419	Log(("vmsvga3dSetRenderState cid=%u cRenderStates=%d\n", cid, cRenderStates));
4420
4421	PVMSVGA3DCONTEXT pContext;
4422	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4423	AssertRCReturn(rc, rc);
4424
4425	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
4426
4427	for (unsigned i = 0; i < cRenderStates; i++)
4428	{
4429	GLenum enableCap = ~(GLenum)0;
4430	Log(("vmsvga3dSetRenderState: cid=%u state=%s (%d) val=%x\n", cid, vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
4431	/* Save the render state for vm state saving. */
4432	ASSERT_GUEST_RETURN((unsigned)pRenderState[i].state < SVGA3D_RS_MAX, VERR_INVALID_PARAMETER);
4433	pContext->state.aRenderState[pRenderState[i].state] = pRenderState[i];
4434
4435	switch (pRenderState[i].state)
4436	{
4437	case SVGA3D_RS_ZENABLE: /* SVGA3dBool */
4438	enableCap = GL_DEPTH_TEST;
4439	val = pRenderState[i].uintValue;
4440	break;
4441
4442	case SVGA3D_RS_ZWRITEENABLE: /* SVGA3dBool */
4443	glDepthMask(!!pRenderState[i].uintValue);
4444	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4445	break;
4446
4447	case SVGA3D_RS_ALPHATESTENABLE: /* SVGA3dBool */
4448	enableCap = GL_ALPHA_TEST;
4449	val = pRenderState[i].uintValue;
4450	break;
4451
4452	case SVGA3D_RS_DITHERENABLE: /* SVGA3dBool */
4453	enableCap = GL_DITHER;
4454	val = pRenderState[i].uintValue;
4455	break;
4456
4457	case SVGA3D_RS_FOGENABLE: /* SVGA3dBool */
4458	enableCap = GL_FOG;
4459	val = pRenderState[i].uintValue;
4460	break;
4461
4462	case SVGA3D_RS_SPECULARENABLE: /* SVGA3dBool */
4463	Log(("vmsvga3dSetRenderState: WARNING: not applicable.\n"));
4464	break;
4465
4466	case SVGA3D_RS_LIGHTINGENABLE: /* SVGA3dBool */
4467	enableCap = GL_LIGHTING;
4468	val = pRenderState[i].uintValue;
4469	break;
4470
4471	case SVGA3D_RS_NORMALIZENORMALS: /* SVGA3dBool */
4472	/* not applicable */
4473	Log(("vmsvga3dSetRenderState: WARNING: not applicable.\n"));
4474	break;
4475
4476	case SVGA3D_RS_POINTSPRITEENABLE: /* SVGA3dBool */
4477	enableCap = GL_POINT_SPRITE_ARB;
4478	val = pRenderState[i].uintValue;
4479	break;
4480
4481	case SVGA3D_RS_POINTSIZE: /* float */
4482	/** @todo we need to apply scaling for point sizes below the min or above the max; see Wine) */
4483	if (pRenderState[i].floatValue < pState->caps.flPointSize[0])
4484	pRenderState[i].floatValue = pState->caps.flPointSize[0];
4485	if (pRenderState[i].floatValue > pState->caps.flPointSize[1])
4486	pRenderState[i].floatValue = pState->caps.flPointSize[1];
4487
4488	glPointSize(pRenderState[i].floatValue);
4489	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4490	Log(("SVGA3D_RS_POINTSIZE: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
4491	break;
4492
4493	case SVGA3D_RS_POINTSIZEMIN: /* float */
4494	pState->ext.glPointParameterf(GL_POINT_SIZE_MIN, pRenderState[i].floatValue);
4495	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4496	Log(("SVGA3D_RS_POINTSIZEMIN: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
4497	break;
4498
4499	case SVGA3D_RS_POINTSIZEMAX: /* float */
4500	pState->ext.glPointParameterf(GL_POINT_SIZE_MAX, pRenderState[i].floatValue);
4501	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4502	Log(("SVGA3D_RS_POINTSIZEMAX: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
4503	break;
4504
4505	case SVGA3D_RS_POINTSCALEENABLE: /* SVGA3dBool */
4506	case SVGA3D_RS_POINTSCALE_A: /* float */
4507	case SVGA3D_RS_POINTSCALE_B: /* float */
4508	case SVGA3D_RS_POINTSCALE_C: /* float */
4509	Log(("vmsvga3dSetRenderState: WARNING: not applicable.\n"));
4510	break;
4511
4512	case SVGA3D_RS_AMBIENT: /* SVGA3dColor */
4513	{
4514	GLfloat color[4]; /* red, green, blue, alpha */
4515
4516	vmsvgaColor2GLFloatArray(pRenderState[i].uintValue, &color[0], &color[1], &color[2], &color[3]);
4517
4518	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, color);
4519	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4520	break;
4521	}
4522
4523	case SVGA3D_RS_CLIPPLANEENABLE: /* SVGA3dClipPlanes */
4524	{
4525	for (uint32_t j = 0; j < SVGA3D_NUM_CLIPPLANES; j++)
4526	{
4527	if (pRenderState[i].uintValue & RT_BIT(j))
4528	glEnable(GL_CLIP_PLANE0 + j);
4529	else
4530	glDisable(GL_CLIP_PLANE0 + j);
4531	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4532	}
4533	break;
4534	}
4535
4536	case SVGA3D_RS_FOGCOLOR: /* SVGA3dColor */
4537	{
4538	GLfloat color[4]; /* red, green, blue, alpha */
4539
4540	vmsvgaColor2GLFloatArray(pRenderState[i].uintValue, &color[0], &color[1], &color[2], &color[3]);
4541
4542	glFogfv(GL_FOG_COLOR, color);
4543	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4544	break;
4545	}
4546
4547	case SVGA3D_RS_FOGSTART: /* float */
4548	glFogf(GL_FOG_START, pRenderState[i].floatValue);
4549	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4550	break;
4551
4552	case SVGA3D_RS_FOGEND: /* float */
4553	glFogf(GL_FOG_END, pRenderState[i].floatValue);
4554	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4555	break;
4556
4557	case SVGA3D_RS_FOGDENSITY: /* float */
4558	glFogf(GL_FOG_DENSITY, pRenderState[i].floatValue);
4559	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4560	break;
4561
4562	case SVGA3D_RS_RANGEFOGENABLE: /* SVGA3dBool */
4563	glFogi(GL_FOG_COORD_SRC, (pRenderState[i].uintValue) ? GL_FOG_COORD : GL_FRAGMENT_DEPTH);
4564	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4565	break;
4566
4567	case SVGA3D_RS_FOGMODE: /* SVGA3dFogMode */
4568	{
4569	SVGA3dFogMode mode;
4570	mode.uintValue = pRenderState[i].uintValue;
4571
4572	enableCap = GL_FOG_MODE;
4573	switch (mode.function)
4574	{
4575	case SVGA3D_FOGFUNC_EXP:
4576	val = GL_EXP;
4577	break;
4578	case SVGA3D_FOGFUNC_EXP2:
4579	val = GL_EXP2;
4580	break;
4581	case SVGA3D_FOGFUNC_LINEAR:
4582	val = GL_LINEAR;
4583	break;
4584	default:
4585	AssertMsgFailedReturn(("Unexpected fog function %d\n", mode.function), VERR_INTERNAL_ERROR);
4586	break;
4587	}
4588
4589	/** @todo how to switch between vertex and pixel fog modes??? */
4590	Assert(mode.type == SVGA3D_FOGTYPE_PIXEL);
4591	#if 0
4592	/* The fog type determines the render state. */
4593	switch (mode.type)
4594	{
4595	case SVGA3D_FOGTYPE_VERTEX:
4596	renderState = D3DRS_FOGVERTEXMODE;
4597	break;
4598	case SVGA3D_FOGTYPE_PIXEL:
4599	renderState = D3DRS_FOGTABLEMODE;
4600	break;
4601	default:
4602	AssertMsgFailedReturn(("Unexpected fog type %d\n", mode.type), VERR_INTERNAL_ERROR);
4603	break;
4604	}
4605	#endif
4606
4607	/* Set the fog base to depth or range. */
4608	switch (mode.base)
4609	{
4610	case SVGA3D_FOGBASE_DEPTHBASED:
4611	glFogi(GL_FOG_COORD_SRC, GL_FRAGMENT_DEPTH);
4612	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4613	break;
4614	case SVGA3D_FOGBASE_RANGEBASED:
4615	glFogi(GL_FOG_COORD_SRC, GL_FOG_COORD);
4616	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4617	break;
4618	default:
4619	/* ignore */
4620	AssertMsgFailed(("Unexpected fog base %d\n", mode.base));
4621	break;
4622	}
4623	break;
4624	}
4625
4626	case SVGA3D_RS_FILLMODE: /* SVGA3dFillMode */
4627	{
4628	SVGA3dFillMode mode;
4629
4630	mode.uintValue = pRenderState[i].uintValue;
4631
4632	switch (mode.mode)
4633	{
4634	case SVGA3D_FILLMODE_POINT:
4635	val = GL_POINT;
4636	break;
4637	case SVGA3D_FILLMODE_LINE:
4638	val = GL_LINE;
4639	break;
4640	case SVGA3D_FILLMODE_FILL:
4641	val = GL_FILL;
4642	break;
4643	default:
4644	AssertMsgFailedReturn(("Unexpected fill mode %d\n", mode.mode), VERR_INTERNAL_ERROR);
4645	break;
4646	}
4647	/* Only front and back faces. Also recent Mesa guest drivers initialize the 'face' to zero. */
4648	ASSERT_GUEST(mode.face == SVGA3D_FACE_FRONT_BACK \|\| mode.face == SVGA3D_FACE_INVALID);
4649	glPolygonMode(GL_FRONT_AND_BACK, val);
4650	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4651	break;
4652	}
4653
4654	case SVGA3D_RS_SHADEMODE: /* SVGA3dShadeMode */
4655	switch (pRenderState[i].uintValue)
4656	{
4657	case SVGA3D_SHADEMODE_FLAT:
4658	val = GL_FLAT;
4659	break;
4660
4661	case SVGA3D_SHADEMODE_SMOOTH:
4662	val = GL_SMOOTH;
4663	break;
4664
4665	default:
4666	AssertMsgFailedReturn(("Unexpected shade mode %d\n", pRenderState[i].uintValue), VERR_INTERNAL_ERROR);
4667	break;
4668	}
4669
4670	glShadeModel(val);
4671	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4672	break;
4673
4674	case SVGA3D_RS_LINEPATTERN: /* SVGA3dLinePattern */
4675	/* No longer supported by d3d; mesagl comments suggest not all backends support it */
4676	/** @todo */
4677	Log(("WARNING: SVGA3D_RS_LINEPATTERN %x not supported!!\n", pRenderState[i].uintValue));
4678	/*
4679	renderState = D3DRS_LINEPATTERN;
4680	val = pRenderState[i].uintValue;
4681	*/
4682	break;
4683
4684	case SVGA3D_RS_ANTIALIASEDLINEENABLE: /* SVGA3dBool */
4685	enableCap = GL_LINE_SMOOTH;
4686	val = pRenderState[i].uintValue;
4687	break;
4688
4689	case SVGA3D_RS_LINEWIDTH: /* float */
4690	glLineWidth(pRenderState[i].floatValue);
4691	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4692	break;
4693
4694	case SVGA3D_RS_SEPARATEALPHABLENDENABLE: /* SVGA3dBool */
4695	{
4696	/* Refresh the blending state based on the new enable setting.
4697	* This will take existing states and set them using either glBlend* or glBlend*Separate.
4698	*/
4699	static SVGA3dRenderStateName const saRefreshState[] =
4700	{
4701	SVGA3D_RS_SRCBLEND,
4702	SVGA3D_RS_BLENDEQUATION
4703	};
4704	SVGA3dRenderState renderstate[RT_ELEMENTS(saRefreshState)];
4705	for (uint32_t j = 0; j < RT_ELEMENTS(saRefreshState); ++j)
4706	{
4707	renderstate[j].state = saRefreshState[j];
4708	renderstate[j].uintValue = pContext->state.aRenderState[saRefreshState[j]].uintValue;
4709	}
4710
4711	rc = vmsvga3dBackSetRenderState(pThisCC, cid, 2, renderstate);
4712	AssertRCReturn(rc, rc);
4713
4714	if (pContext->state.aRenderState[SVGA3D_RS_BLENDENABLE].uintValue != 0)
4715	continue; /* Ignore if blend is enabled */
4716	/* Apply SVGA3D_RS_SEPARATEALPHABLENDENABLE as SVGA3D_RS_BLENDENABLE */
4717	} RT_FALL_THRU();
4718
4719	case SVGA3D_RS_BLENDENABLE: /* SVGA3dBool */
4720	enableCap = GL_BLEND;
4721	val = pRenderState[i].uintValue;
4722	break;
4723
4724	case SVGA3D_RS_SRCBLENDALPHA: /* SVGA3dBlendOp */
4725	case SVGA3D_RS_DSTBLENDALPHA: /* SVGA3dBlendOp */
4726	case SVGA3D_RS_SRCBLEND: /* SVGA3dBlendOp */
4727	case SVGA3D_RS_DSTBLEND: /* SVGA3dBlendOp */
4728	{
4729	GLint srcRGB, srcAlpha, dstRGB, dstAlpha;
4730	GLint blendop = vmsvga3dBlendOp2GL(pRenderState[i].uintValue);
4731
4732	glGetIntegerv(GL_BLEND_SRC_RGB, &srcRGB);
4733	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4734	glGetIntegerv(GL_BLEND_DST_RGB, &dstRGB);
4735	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4736	glGetIntegerv(GL_BLEND_DST_ALPHA, &dstAlpha);
4737	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4738	glGetIntegerv(GL_BLEND_SRC_ALPHA, &srcAlpha);
4739	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4740
4741	switch (pRenderState[i].state)
4742	{
4743	case SVGA3D_RS_SRCBLEND:
4744	srcRGB = blendop;
4745	break;
4746	case SVGA3D_RS_DSTBLEND:
4747	dstRGB = blendop;
4748	break;
4749	case SVGA3D_RS_SRCBLENDALPHA:
4750	srcAlpha = blendop;
4751	break;
4752	case SVGA3D_RS_DSTBLENDALPHA:
4753	dstAlpha = blendop;
4754	break;
4755	default:
4756	/* not possible; shut up gcc */
4757	AssertFailed();
4758	break;
4759	}
4760
4761	if (pContext->state.aRenderState[SVGA3D_RS_SEPARATEALPHABLENDENABLE].uintValue != 0)
4762	pState->ext.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
4763	else
4764	glBlendFunc(srcRGB, dstRGB);
4765	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4766	break;
4767	}
4768
4769	case SVGA3D_RS_BLENDEQUATIONALPHA: /* SVGA3dBlendEquation */
4770	case SVGA3D_RS_BLENDEQUATION: /* SVGA3dBlendEquation */
4771	if (pContext->state.aRenderState[SVGA3D_RS_SEPARATEALPHABLENDENABLE].uintValue != 0)
4772	{
4773	GLenum const modeRGB = vmsvga3dBlendEquation2GL(pContext->state.aRenderState[SVGA3D_RS_BLENDEQUATION].uintValue);
4774	GLenum const modeAlpha = vmsvga3dBlendEquation2GL(pContext->state.aRenderState[SVGA3D_RS_BLENDEQUATIONALPHA].uintValue);
4775	pState->ext.glBlendEquationSeparate(modeRGB, modeAlpha);
4776	}
4777	else
4778	{
4779	#if VBOX_VMSVGA3D_GL_HACK_LEVEL >= 0x102
4780	glBlendEquation(vmsvga3dBlendEquation2GL(pRenderState[i].uintValue));
4781	#else
4782	pState->ext.glBlendEquation(vmsvga3dBlendEquation2GL(pRenderState[i].uintValue));
4783	#endif
4784	}
4785	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4786	break;
4787
4788	case SVGA3D_RS_BLENDCOLOR: /* SVGA3dColor */
4789	{
4790	GLfloat red, green, blue, alpha;
4791
4792	vmsvgaColor2GLFloatArray(pRenderState[i].uintValue, &red, &green, &blue, &alpha);
4793
4794	#if VBOX_VMSVGA3D_GL_HACK_LEVEL >= 0x102
4795	glBlendColor(red, green, blue, alpha);
4796	#else
4797	pState->ext.glBlendColor(red, green, blue, alpha);
4798	#endif
4799	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4800	break;
4801	}
4802
4803	case SVGA3D_RS_CULLMODE: /* SVGA3dFace */
4804	{
4805	GLenum mode = GL_BACK; /* default for OpenGL */
4806
4807	switch (pRenderState[i].uintValue)
4808	{
4809	case SVGA3D_FACE_NONE:
4810	break;
4811	case SVGA3D_FACE_FRONT:
4812	mode = GL_FRONT;
4813	break;
4814	case SVGA3D_FACE_BACK:
4815	mode = GL_BACK;
4816	break;
4817	case SVGA3D_FACE_FRONT_BACK:
4818	mode = GL_FRONT_AND_BACK;
4819	break;
4820	default:
4821	AssertMsgFailedReturn(("Unexpected cull mode %d\n", pRenderState[i].uintValue), VERR_INTERNAL_ERROR);
4822	break;
4823	}
4824	enableCap = GL_CULL_FACE;
4825	if (pRenderState[i].uintValue != SVGA3D_FACE_NONE)
4826	{
4827	glCullFace(mode);
4828	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4829	val = 1;
4830	}
4831	else
4832	val = 0;
4833	break;
4834	}
4835
4836	case SVGA3D_RS_ZFUNC: /* SVGA3dCmpFunc */
4837	glDepthFunc(vmsvgaCmpFunc2GL(pRenderState[i].uintValue));
4838	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4839	break;
4840
4841	case SVGA3D_RS_ALPHAFUNC: /* SVGA3dCmpFunc */
4842	{
4843	GLclampf ref;
4844
4845	glGetFloatv(GL_ALPHA_TEST_REF, &ref);
4846	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4847	glAlphaFunc(vmsvgaCmpFunc2GL(pRenderState[i].uintValue), ref);
4848	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4849	break;
4850	}
4851
4852	case SVGA3D_RS_ALPHAREF: /* float (0.0 .. 1.0) */
4853	{
4854	GLint func;
4855
4856	glGetIntegerv(GL_ALPHA_TEST_FUNC, &func);
4857	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4858	glAlphaFunc(func, pRenderState[i].floatValue);
4859	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4860	break;
4861	}
4862
4863	case SVGA3D_RS_STENCILENABLE2SIDED: /* SVGA3dBool */
4864	{
4865	/* Refresh the stencil state based on the new enable setting.
4866	* This will take existing states and set them using either glStencil or glStencil*Separate.
4867	*/
4868	static SVGA3dRenderStateName const saRefreshState[] =
4869	{
4870	SVGA3D_RS_STENCILFUNC,
4871	SVGA3D_RS_STENCILFAIL,
4872	SVGA3D_RS_CCWSTENCILFUNC,
4873	SVGA3D_RS_CCWSTENCILFAIL
4874	};
4875	SVGA3dRenderState renderstate[RT_ELEMENTS(saRefreshState)];
4876	for (uint32_t j = 0; j < RT_ELEMENTS(saRefreshState); ++j)
4877	{
4878	renderstate[j].state = saRefreshState[j];
4879	renderstate[j].uintValue = pContext->state.aRenderState[saRefreshState[j]].uintValue;
4880	}
4881
4882	rc = vmsvga3dBackSetRenderState(pThisCC, cid, RT_ELEMENTS(renderstate), renderstate);
4883	AssertRCReturn(rc, rc);
4884
4885	if (pContext->state.aRenderState[SVGA3D_RS_STENCILENABLE].uintValue != 0)
4886	continue; /* Ignore if stencil is enabled */
4887	/* Apply SVGA3D_RS_STENCILENABLE2SIDED as SVGA3D_RS_STENCILENABLE. */
4888	} RT_FALL_THRU();
4889
4890	case SVGA3D_RS_STENCILENABLE: /* SVGA3dBool */
4891	enableCap = GL_STENCIL_TEST;
4892	val = pRenderState[i].uintValue;
4893	break;
4894
4895	case SVGA3D_RS_STENCILFUNC: /* SVGA3dCmpFunc */
4896	case SVGA3D_RS_STENCILREF: /* uint32_t */
4897	case SVGA3D_RS_STENCILMASK: /* uint32_t */
4898	{
4899	GLint func, ref;
4900	GLuint mask;
4901
4902	/* Query current values to have all parameters for glStencilFunc[Separate]. */
4903	glGetIntegerv(GL_STENCIL_FUNC, &func);
4904	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4905	glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)&mask);
4906	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4907	glGetIntegerv(GL_STENCIL_REF, &ref);
4908	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4909
4910	/* Update the changed value. */
4911	switch (pRenderState[i].state)
4912	{
4913	case SVGA3D_RS_STENCILFUNC: /* SVGA3dCmpFunc */
4914	func = vmsvgaCmpFunc2GL(pRenderState[i].uintValue);
4915	break;
4916
4917	case SVGA3D_RS_STENCILREF: /* uint32_t */
4918	ref = pRenderState[i].uintValue;
4919	break;
4920
4921	case SVGA3D_RS_STENCILMASK: /* uint32_t */
4922	mask = pRenderState[i].uintValue;
4923	break;
4924
4925	default:
4926	/* not possible; shut up gcc */
4927	AssertFailed();
4928	break;
4929	}
4930
4931	if (pContext->state.aRenderState[SVGA3D_RS_STENCILENABLE2SIDED].uintValue != 0)
4932	{
4933	pState->ext.glStencilFuncSeparate(GL_FRONT, func, ref, mask);
4934	}
4935	else
4936	{
4937	glStencilFunc(func, ref, mask);
4938	}
4939	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4940	break;
4941	}
4942
4943	case SVGA3D_RS_STENCILWRITEMASK: /* uint32_t */
4944	glStencilMask(pRenderState[i].uintValue);
4945	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4946	break;
4947
4948	case SVGA3D_RS_STENCILFAIL: /* SVGA3dStencilOp */
4949	case SVGA3D_RS_STENCILZFAIL: /* SVGA3dStencilOp */
4950	case SVGA3D_RS_STENCILPASS: /* SVGA3dStencilOp */
4951	{
4952	GLint sfail, dpfail, dppass;
4953	GLenum const stencilop = vmsvgaStencipOp2GL(pRenderState[i].uintValue);
4954
4955	glGetIntegerv(GL_STENCIL_FAIL, &sfail);
4956	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4957	glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &dpfail);
4958	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4959	glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &dppass);
4960	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4961
4962	switch (pRenderState[i].state)
4963	{
4964	case SVGA3D_RS_STENCILFAIL: /* SVGA3dStencilOp */
4965	sfail = stencilop;
4966	break;
4967	case SVGA3D_RS_STENCILZFAIL: /* SVGA3dStencilOp */
4968	dpfail = stencilop;
4969	break;
4970	case SVGA3D_RS_STENCILPASS: /* SVGA3dStencilOp */
4971	dppass = stencilop;
4972	break;
4973	default:
4974	/* not possible; shut up gcc */
4975	AssertFailed();
4976	break;
4977	}
4978	if (pContext->state.aRenderState[SVGA3D_RS_STENCILENABLE2SIDED].uintValue != 0)
4979	{
4980	pState->ext.glStencilOpSeparate(GL_FRONT, sfail, dpfail, dppass);
4981	}
4982	else
4983	{
4984	glStencilOp(sfail, dpfail, dppass);
4985	}
4986	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4987	break;
4988	}
4989
4990	case SVGA3D_RS_CCWSTENCILFUNC: /* SVGA3dCmpFunc */
4991	{
4992	GLint ref;
4993	GLuint mask;
4994	GLint const func = vmsvgaCmpFunc2GL(pRenderState[i].uintValue);
4995
4996	/* GL_STENCIL_VALUE_MASK and GL_STENCIL_REF are the same for both GL_FRONT and GL_BACK. */
4997	glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)&mask);
4998	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4999	glGetIntegerv(GL_STENCIL_REF, &ref);
5000	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5001
5002	pState->ext.glStencilFuncSeparate(GL_BACK, func, ref, mask);
5003	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5004	break;
5005	}
5006
5007	case SVGA3D_RS_CCWSTENCILFAIL: /* SVGA3dStencilOp */
5008	case SVGA3D_RS_CCWSTENCILZFAIL: /* SVGA3dStencilOp */
5009	case SVGA3D_RS_CCWSTENCILPASS: /* SVGA3dStencilOp */
5010	{
5011	GLint sfail, dpfail, dppass;
5012	GLenum const stencilop = vmsvgaStencipOp2GL(pRenderState[i].uintValue);
5013
5014	glGetIntegerv(GL_STENCIL_BACK_FAIL, &sfail);
5015	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5016	glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &dpfail);
5017	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5018	glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &dppass);
5019	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5020
5021	switch (pRenderState[i].state)
5022	{
5023	case SVGA3D_RS_CCWSTENCILFAIL: /* SVGA3dStencilOp */
5024	sfail = stencilop;
5025	break;
5026	case SVGA3D_RS_CCWSTENCILZFAIL: /* SVGA3dStencilOp */
5027	dpfail = stencilop;
5028	break;
5029	case SVGA3D_RS_CCWSTENCILPASS: /* SVGA3dStencilOp */
5030	dppass = stencilop;
5031	break;
5032	default:
5033	/* not possible; shut up gcc */
5034	AssertFailed();
5035	break;
5036	}
5037	pState->ext.glStencilOpSeparate(GL_BACK, sfail, dpfail, dppass);
5038	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5039	break;
5040	}
5041
5042	case SVGA3D_RS_ZBIAS: /* float */
5043	/** @todo unknown meaning; depth bias is not identical
5044	renderState = D3DRS_DEPTHBIAS;
5045	val = pRenderState[i].uintValue;
5046	*/
5047	Log(("vmsvga3dSetRenderState: WARNING unsupported SVGA3D_RS_ZBIAS\n"));
5048	break;
5049
5050	case SVGA3D_RS_DEPTHBIAS: /* float */
5051	{
5052	GLfloat factor;
5053
5054	/** @todo not sure if the d3d & ogl definitions are identical. */
5055
5056	/* Do not change the factor part. */
5057	glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &factor);
5058	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5059
5060	glPolygonOffset(factor, pRenderState[i].floatValue);
5061	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5062	break;
5063	}
5064
5065	case SVGA3D_RS_SLOPESCALEDEPTHBIAS: /* float */
5066	{
5067	GLfloat units;
5068
5069	/** @todo not sure if the d3d & ogl definitions are identical. */
5070
5071	/* Do not change the factor part. */
5072	glGetFloatv(GL_POLYGON_OFFSET_UNITS, &units);
5073	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5074
5075	glPolygonOffset(pRenderState[i].floatValue, units);
5076	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5077	break;
5078	}
5079
5080	case SVGA3D_RS_COLORWRITEENABLE: /* SVGA3dColorMask */
5081	{
5082	GLboolean red, green, blue, alpha;
5083	SVGA3dColorMask mask;
5084
5085	mask.uintValue = pRenderState[i].uintValue;
5086
5087	red = mask.red;
5088	green = mask.green;
5089	blue = mask.blue;
5090	alpha = mask.alpha;
5091
5092	glColorMask(red, green, blue, alpha);
5093	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5094	break;
5095	}
5096
5097	case SVGA3D_RS_COLORWRITEENABLE1: /* SVGA3dColorMask to D3DCOLORWRITEENABLE_* */
5098	case SVGA3D_RS_COLORWRITEENABLE2: /* SVGA3dColorMask to D3DCOLORWRITEENABLE_* */
5099	case SVGA3D_RS_COLORWRITEENABLE3: /* SVGA3dColorMask to D3DCOLORWRITEENABLE_* */
5100	Log(("vmsvga3dSetRenderState: WARNING SVGA3D_RS_COLORWRITEENABLEx not supported!!\n"));
5101	break;
5102
5103	case SVGA3D_RS_SCISSORTESTENABLE: /* SVGA3dBool */
5104	enableCap = GL_SCISSOR_TEST;
5105	val = pRenderState[i].uintValue;
5106	break;
5107
5108	#if 0
5109	case SVGA3D_RS_DIFFUSEMATERIALSOURCE: /* SVGA3dVertexMaterial */
5110	AssertCompile(D3DMCS_COLOR2 == SVGA3D_VERTEXMATERIAL_SPECULAR);
5111	renderState = D3DRS_DIFFUSEMATERIALSOURCE;
5112	val = pRenderState[i].uintValue;
5113	break;
5114
5115	case SVGA3D_RS_SPECULARMATERIALSOURCE: /* SVGA3dVertexMaterial */
5116	renderState = D3DRS_SPECULARMATERIALSOURCE;
5117	val = pRenderState[i].uintValue;
5118	break;
5119
5120	case SVGA3D_RS_AMBIENTMATERIALSOURCE: /* SVGA3dVertexMaterial */
5121	renderState = D3DRS_AMBIENTMATERIALSOURCE;
5122	val = pRenderState[i].uintValue;
5123	break;
5124
5125	case SVGA3D_RS_EMISSIVEMATERIALSOURCE: /* SVGA3dVertexMaterial */
5126	renderState = D3DRS_EMISSIVEMATERIALSOURCE;
5127	val = pRenderState[i].uintValue;
5128	break;
5129	#endif
5130
5131	case SVGA3D_RS_WRAP3: /* SVGA3dWrapFlags */
5132	case SVGA3D_RS_WRAP4: /* SVGA3dWrapFlags */
5133	case SVGA3D_RS_WRAP5: /* SVGA3dWrapFlags */
5134	case SVGA3D_RS_WRAP6: /* SVGA3dWrapFlags */
5135	case SVGA3D_RS_WRAP7: /* SVGA3dWrapFlags */
5136	case SVGA3D_RS_WRAP8: /* SVGA3dWrapFlags */
5137	case SVGA3D_RS_WRAP9: /* SVGA3dWrapFlags */
5138	case SVGA3D_RS_WRAP10: /* SVGA3dWrapFlags */
5139	case SVGA3D_RS_WRAP11: /* SVGA3dWrapFlags */
5140	case SVGA3D_RS_WRAP12: /* SVGA3dWrapFlags */
5141	case SVGA3D_RS_WRAP13: /* SVGA3dWrapFlags */
5142	case SVGA3D_RS_WRAP14: /* SVGA3dWrapFlags */
5143	case SVGA3D_RS_WRAP15: /* SVGA3dWrapFlags */
5144	Log(("vmsvga3dSetRenderState: WARNING unsupported SVGA3D_WRAPx (x >= 3)\n"));
5145	break;
5146
5147	case SVGA3D_RS_LASTPIXEL: /* SVGA3dBool */
5148	case SVGA3D_RS_TWEENFACTOR: /* float */
5149	case SVGA3D_RS_INDEXEDVERTEXBLENDENABLE: /* SVGA3dBool */
5150	case SVGA3D_RS_VERTEXBLEND: /* SVGA3dVertexBlendFlags */
5151	Log(("vmsvga3dSetRenderState: WARNING not applicable!!\n"));
5152	break;
5153
5154	case SVGA3D_RS_MULTISAMPLEANTIALIAS: /* SVGA3dBool */
5155	enableCap = GL_MULTISAMPLE;
5156	val = pRenderState[i].uintValue;
5157	break;
5158
5159	case SVGA3D_RS_MULTISAMPLEMASK: /* uint32_t */
5160	Log(("vmsvga3dSetRenderState: WARNING not applicable??!!\n"));
5161	break;
5162
5163	case SVGA3D_RS_COORDINATETYPE: /* SVGA3dCoordinateType */
5164	Assert(pRenderState[i].uintValue == SVGA3D_COORDINATE_LEFTHANDED);
5165	/** @todo setup a view matrix to scale the world space by -1 in the z-direction for right handed coordinates. */
5166	/*
5167	renderState = D3DRS_COORDINATETYPE;
5168	val = pRenderState[i].uintValue;
5169	*/
5170	break;
5171
5172	case SVGA3D_RS_FRONTWINDING: /* SVGA3dFrontWinding */
5173	Assert(pRenderState[i].uintValue == SVGA3D_FRONTWINDING_CW);
5174	/* Invert the selected mode because of y-inversion (?) */
5175	glFrontFace((pRenderState[i].uintValue != SVGA3D_FRONTWINDING_CW) ? GL_CW : GL_CCW);
5176	VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5177	break;
5178
5179	case SVGA3D_RS_OUTPUTGAMMA: /* float */
5180	//AssertFailed();
5181	/*
5182	D3DRS_SRGBWRITEENABLE ??
5183	renderState = D3DRS_OUTPUTGAMMA;
5184	val = pRenderState[i].uintValue;
5185	*/
5186	break;
5187
5188	#if 0
5189
5190	case SVGA3D_RS_VERTEXMATERIALENABLE: /* SVGA3dBool */
5191	//AssertFailed();
5192	renderState = D3DRS_INDEXEDVERTEXBLENDENABLE; /* correct?? */
5193	val = pRenderState[i].uintValue;
5194	break;
5195
5196	case SVGA3D_RS_TEXTUREFACTOR: /* SVGA3dColor */
5197	renderState = D3DRS_TEXTUREFACTOR;
5198	val = pRenderState[i].uintValue;
5199	break;
5200
5201	case SVGA3D_RS_LOCALVIEWER: /* SVGA3dBool */
5202	renderState = D3DRS_LOCALVIEWER;
5203	val = pRenderState[i].uintValue;
5204	break;
5205
5206	case SVGA3D_RS_ZVISIBLE: /* SVGA3dBool */
5207	AssertFailed();
5208	/*
5209	renderState = D3DRS_ZVISIBLE;
5210	val = pRenderState[i].uintValue;
5211	*/
5212	break;
5213
5214	case SVGA3D_RS_CLIPPING: /* SVGA3dBool */
5215	renderState = D3DRS_CLIPPING;
5216	val = pRenderState[i].uintValue;
5217	break;
5218
5219	case SVGA3D_RS_WRAP0: /* SVGA3dWrapFlags */
5220	glTexParameter GL_TEXTURE_WRAP_S
5221	Assert(SVGA3D_WRAPCOORD_3 == D3DWRAPCOORD_3);
5222	renderState = D3DRS_WRAP0;
5223	val = pRenderState[i].uintValue;
5224	break;
5225
5226	case SVGA3D_RS_WRAP1: /* SVGA3dWrapFlags */
5227	glTexParameter GL_TEXTURE_WRAP_T
5228	renderState = D3DRS_WRAP1;
5229	val = pRenderState[i].uintValue;
5230	break;
5231
5232	case SVGA3D_RS_WRAP2: /* SVGA3dWrapFlags */
5233	glTexParameter GL_TEXTURE_WRAP_R
5234	renderState = D3DRS_WRAP2;
5235	val = pRenderState[i].uintValue;
5236	break;
5237
5238
5239	case SVGA3D_RS_SEPARATEALPHABLENDENABLE: /* SVGA3dBool */
5240	renderState = D3DRS_SEPARATEALPHABLENDENABLE;
5241	val = pRenderState[i].uintValue;
5242	break;
5243
5244
5245	case SVGA3D_RS_BLENDEQUATIONALPHA: /* SVGA3dBlendEquation */
5246	renderState = D3DRS_BLENDOPALPHA;
5247	val = pRenderState[i].uintValue;
5248	break;
5249
5250	case SVGA3D_RS_TRANSPARENCYANTIALIAS: /* SVGA3dTransparencyAntialiasType */
5251	AssertFailed();
5252	/*
5253	renderState = D3DRS_TRANSPARENCYANTIALIAS;
5254	val = pRenderState[i].uintValue;
5255	*/
5256	break;
5257
5258	#endif
5259	default:
5260	AssertFailed();
5261	break;
5262	}
5263
5264	if (enableCap != ~(GLenum)0)
5265	{
5266	if (val)
5267	glEnable(enableCap);
5268	else
5269	glDisable(enableCap);
5270	}
5271	}
5272
5273	return VINF_SUCCESS;
5274	}
5275
5276	static DECLCALLBACK(int) vmsvga3dBackSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
5277	{
5278	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5279
5280	AssertReturn(pState, VERR_NO_MEMORY);
5281	AssertReturn((unsigned)type < SVGA3D_RT_MAX, VERR_INVALID_PARAMETER);
5282
5283	LogFunc(("cid=%u type=%x sid=%u\n", cid, type, target.sid));
5284
5285	PVMSVGA3DCONTEXT pContext;
5286	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5287	AssertRCReturn(rc, rc);
5288
5289	VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
5290
5291	/* Save for vm state save/restore. */
5292	pContext->state.aRenderTargets[type] = target.sid;
5293
5294	if (target.sid == SVGA3D_INVALID_ID)
5295	{
5296	/* Disable render target. */
5297	switch (type)
5298