VirtualBox

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-ogl.cpp@ 91867

Last change on this file since 91867 was 91774, checked in by vboxsync, 3 years ago

DevVGA-SVGA3d-ogl.cpp: Shut up warnings about deprecated functions in the 10.15 SDK on darwin.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 309.3 KB
Line 
1/* $Id: DevVGA-SVGA3d-ogl.cpp 91774 2021-10-17 10:36:21Z vboxsync $ */
2/** @file
3 * DevVMWare - VMWare SVGA device
4 */
5
6/*
7 * Copyright (C) 2013-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22/* Enable to disassemble defined shaders. (Windows host only) */
23#if defined(RT_OS_WINDOWS) && defined(DEBUG) && 0 /* Disabled as we don't have the DirectX SDK avaible atm. */
24# define DUMP_SHADER_DISASSEMBLY
25#endif
26#ifdef DEBUG_bird
27//# define RTMEM_WRAP_TO_EF_APIS
28#endif
29#define LOG_GROUP LOG_GROUP_DEV_VMSVGA
30#define GL_SILENCE_DEPRECATION /* shut up deprecated warnings on darwin (10.15 sdk) */
31#include <VBox/vmm/pdmdev.h>
32#include <VBox/version.h>
33#include <VBox/err.h>
34#include <VBox/log.h>
35#include <VBox/vmm/pgm.h>
36#include <VBox/AssertGuest.h>
37
38#include <iprt/assert.h>
39#include <iprt/semaphore.h>
40#include <iprt/uuid.h>
41#include <iprt/mem.h>
42
43#include <VBoxVideo.h> /* required by DevVGA.h */
44#include <VBoxVideo3D.h>
45
46/* should go BEFORE any other DevVGA include to make all DevVGA.h config defines be visible */
47#include "DevVGA.h"
48
49#include "DevVGA-SVGA.h"
50#include "DevVGA-SVGA3d.h"
51#include "DevVGA-SVGA3d-internal.h"
52
53#ifdef DUMP_SHADER_DISASSEMBLY
54# include <d3dx9shader.h>
55#endif
56
57#include <stdlib.h>
58#include <math.h>
59#include <float.h> /* FLT_MIN */
60
61
62/*********************************************************************************************************************************
63* Defined Constants And Macros *
64*********************************************************************************************************************************/
65#ifndef VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE
66# define VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE 1.0
67#endif
68
69#ifdef VMSVGA3D_DYNAMIC_LOAD
70# define OGLGETPROCADDRESS glLdrGetProcAddress
71#else
72#ifdef RT_OS_WINDOWS
73# define OGLGETPROCADDRESS MyWinGetProcAddress
74DECLINLINE(PROC) MyWinGetProcAddress(const char *pszSymbol)
75{
76 /* Khronos: [on failure] "some implementations will return other values. 1, 2, and 3 are used, as well as -1". */
77 PROC p = wglGetProcAddress(pszSymbol);
78 if (RT_VALID_PTR(p))
79 return p;
80 return 0;
81}
82#elif defined(RT_OS_DARWIN)
83# include <dlfcn.h>
84# define OGLGETPROCADDRESS MyNSGLGetProcAddress
85/** Resolves an OpenGL symbol. */
86static void *MyNSGLGetProcAddress(const char *pszSymbol)
87{
88 /* Another copy in shaderapi.c. */
89 static void *s_pvImage = NULL;
90 if (s_pvImage == NULL)
91 s_pvImage = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
92 return s_pvImage ? dlsym(s_pvImage, pszSymbol) : NULL;
93}
94
95#else
96# define OGLGETPROCADDRESS(x) glXGetProcAddress((const GLubyte *)x)
97#endif
98#endif
99
100/* Invert y-coordinate for OpenGL's bottom left origin. */
101#define D3D_TO_OGL_Y_COORD(ptrSurface, y_coordinate) (ptrSurface->paMipmapLevels[0].mipmapSize.height - (y_coordinate))
102#define D3D_TO_OGL_Y_COORD_MIPLEVEL(ptrMipLevel, y_coordinate) (ptrMipLevel->size.height - (y_coordinate))
103
104/**
105 * Macro for doing something and then checking for errors during initialization.
106 * Uses AssertLogRelMsg.
107 */
108#define VMSVGA3D_INIT_CHECKED(a_Expr) \
109 do \
110 { \
111 a_Expr; \
112 GLenum iGlError = glGetError(); \
113 AssertLogRelMsg(iGlError == GL_NO_ERROR, ("VMSVGA3d: %s -> %#x\n", #a_Expr, iGlError)); \
114 } while (0)
115
116/**
117 * Macro for doing something and then checking for errors during initialization,
118 * doing the same in the other context when enabled.
119 *
120 * This will try both profiles in dual profile builds. Caller must be in the
121 * default context.
122 *
123 * Uses AssertLogRelMsg to indicate trouble.
124 */
125#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
126# define VMSVGA3D_INIT_CHECKED_BOTH(a_pState, a_pContext, a_pOtherCtx, a_Expr) \
127 do \
128 { \
129 for (uint32_t i = 0; i < 64; i++) if (glGetError() == GL_NO_ERROR) break; Assert(glGetError() == GL_NO_ERROR); \
130 a_Expr; \
131 GLenum iGlError = glGetError(); \
132 if (iGlError != GL_NO_ERROR) \
133 { \
134 VMSVGA3D_SET_CURRENT_CONTEXT(a_pState, a_pOtherCtx); \
135 for (uint32_t i = 0; i < 64; i++) if (glGetError() == GL_NO_ERROR) break; Assert(glGetError() == GL_NO_ERROR); \
136 a_Expr; \
137 GLenum iGlError2 = glGetError(); \
138 AssertLogRelMsg(iGlError2 == GL_NO_ERROR, ("VMSVGA3d: %s -> %#x / %#x\n", #a_Expr, iGlError, iGlError2)); \
139 VMSVGA3D_SET_CURRENT_CONTEXT(a_pState, a_pContext); \
140 } \
141 } while (0)
142#else
143# define VMSVGA3D_INIT_CHECKED_BOTH(a_pState, a_pContext, a_pOtherCtx, a_Expr) VMSVGA3D_INIT_CHECKED(a_Expr)
144#endif
145
146
147/*********************************************************************************************************************************
148* Global Variables *
149*********************************************************************************************************************************/
150/* Define the default light parameters as specified by MSDN. */
151/** @todo move out; fetched from Wine */
152const SVGA3dLightData vmsvga3d_default_light =
153{
154 SVGA3D_LIGHTTYPE_DIRECTIONAL, /* type */
155 false, /* inWorldSpace */
156 { 1.0f, 1.0f, 1.0f, 0.0f }, /* diffuse r,g,b,a */
157 { 0.0f, 0.0f, 0.0f, 0.0f }, /* specular r,g,b,a */
158 { 0.0f, 0.0f, 0.0f, 0.0f }, /* ambient r,g,b,a, */
159 { 0.0f, 0.0f, 0.0f }, /* position x,y,z */
160 { 0.0f, 0.0f, 1.0f }, /* direction x,y,z */
161 0.0f, /* range */
162 0.0f, /* falloff */
163 0.0f, 0.0f, 0.0f, /* attenuation 0,1,2 */
164 0.0f, /* theta */
165 0.0f /* phi */
166};
167
168
169/*********************************************************************************************************************************
170* Internal Functions *
171*********************************************************************************************************************************/
172static int vmsvga3dContextDestroyOgl(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid);
173static DECLCALLBACK(int) vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid);
174static void vmsvgaColor2GLFloatArray(uint32_t color, GLfloat *pRed, GLfloat *pGreen, GLfloat *pBlue, GLfloat *pAlpha);
175static DECLCALLBACK(int) vmsvga3dBackSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData);
176static DECLCALLBACK(int) vmsvga3dBackSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4]);
177static DECLCALLBACK(int) vmsvga3dBackShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type);
178static DECLCALLBACK(int) vmsvga3dBackOcclusionQueryDelete(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext);
179static DECLCALLBACK(int) vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext, PVMSVGA3DSURFACE pSurface);
180
181/* Generated by VBoxDef2LazyLoad from the VBoxSVGA3D.def and VBoxSVGA3DObjC.def files. */
182extern "C" int ExplicitlyLoadVBoxSVGA3D(bool fResolveAllImports, PRTERRINFO pErrInfo);
183
184
185/**
186 * Checks if the given OpenGL extension is supported.
187 *
188 * @returns true if supported, false if not.
189 * @param pState The VMSVGA3d state.
190 * @param rsMinGLVersion The OpenGL version that introduced this feature
191 * into the core.
192 * @param pszWantedExtension The name of the OpenGL extension we want padded
193 * with one space at each end.
194 * @remarks Init time only.
195 */
196static bool vmsvga3dCheckGLExtension(PVMSVGA3DSTATE pState, float rsMinGLVersion, const char *pszWantedExtension)
197{
198 RT_NOREF(rsMinGLVersion);
199 /* check padding. */
200 Assert(pszWantedExtension[0] == ' ');
201 Assert(pszWantedExtension[1] != ' ');
202 Assert(strchr(&pszWantedExtension[1], ' ') + 1 == strchr(pszWantedExtension, '\0'));
203
204 /* Look it up. */
205 bool fRet = false;
206 if (strstr(pState->pszExtensions, pszWantedExtension))
207 fRet = true;
208
209 /* Temporarily. Later start if (rsMinGLVersion != 0.0 && fActualGLVersion >= rsMinGLVersion) return true; */
210#ifdef RT_OS_DARWIN
211 AssertMsg( rsMinGLVersion == 0.0
212 || fRet == (pState->rsGLVersion >= rsMinGLVersion)
213 || VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE == 2.1,
214 ("%s actual:%d min:%d fRet=%d\n",
215 pszWantedExtension, (int)(pState->rsGLVersion * 10), (int)(rsMinGLVersion * 10), fRet));
216#else
217 AssertMsg(rsMinGLVersion == 0.0 || fRet == (pState->rsGLVersion >= rsMinGLVersion),
218 ("%s actual:%d min:%d fRet=%d\n",
219 pszWantedExtension, (int)(pState->rsGLVersion * 10), (int)(rsMinGLVersion * 10), fRet));
220#endif
221 return fRet;
222}
223
224
225/**
226 * Outputs GL_EXTENSIONS list to the release log.
227 */
228static void vmsvga3dLogRelExtensions(const char *pszPrefix, const char *pszExtensions)
229{
230 /* OpenGL 3.0 interface (glGetString(GL_EXTENSIONS) return NULL). */
231 bool fBuffered = RTLogRelSetBuffering(true);
232
233 /*
234 * Determin the column widths first.
235 */
236 size_t acchWidths[4] = { 1, 1, 1, 1 };
237 uint32_t i;
238 const char *psz = pszExtensions;
239 for (i = 0; ; i++)
240 {
241 while (*psz == ' ')
242 psz++;
243 if (!*psz)
244 break;
245
246 const char *pszEnd = strchr(psz, ' ');
247 AssertBreak(pszEnd);
248 size_t cch = pszEnd - psz;
249
250 uint32_t iColumn = i % RT_ELEMENTS(acchWidths);
251 if (acchWidths[iColumn] < cch)
252 acchWidths[iColumn] = cch;
253
254 psz = pszEnd;
255 }
256
257 /*
258 * Output it.
259 */
260 LogRel(("VMSVGA3d: %sOpenGL extensions (%d):", pszPrefix, i));
261 psz = pszExtensions;
262 for (i = 0; ; i++)
263 {
264 while (*psz == ' ')
265 psz++;
266 if (!*psz)
267 break;
268
269 const char *pszEnd = strchr(psz, ' ');
270 AssertBreak(pszEnd);
271 size_t cch = pszEnd - psz;
272
273 uint32_t iColumn = i % RT_ELEMENTS(acchWidths);
274 if (iColumn == 0)
275 LogRel(("\nVMSVGA3d: %-*.*s", acchWidths[iColumn], cch, psz));
276 else if (iColumn != RT_ELEMENTS(acchWidths) - 1)
277 LogRel((" %-*.*s", acchWidths[iColumn], cch, psz));
278 else
279 LogRel((" %.*s", cch, psz));
280
281 psz = pszEnd;
282 }
283
284 RTLogRelSetBuffering(fBuffered);
285 LogRel(("\n"));
286}
287
288/**
289 * Gathers the GL_EXTENSIONS list, storing it as a space padded list at
290 * @a ppszExtensions.
291 *
292 * @returns VINF_SUCCESS or VERR_NO_STR_MEMORY
293 * @param ppszExtensions Pointer to the string pointer. Free with RTStrFree.
294 * @param fGLProfileVersion The OpenGL profile version.
295 */
296static int vmsvga3dGatherExtensions(char **ppszExtensions, float fGLProfileVersion)
297{
298 int rc;
299 *ppszExtensions = NULL;
300
301 /*
302 * Try the old glGetString interface first.
303 */
304 const char *pszExtensions = (const char *)glGetString(GL_EXTENSIONS);
305 if (pszExtensions)
306 {
307 rc = RTStrAAppendExN(ppszExtensions, 3, " ", (size_t)1, pszExtensions, RTSTR_MAX, " ", (size_t)1);
308 AssertLogRelRCReturn(rc, rc);
309 }
310 else
311 {
312 /*
313 * The new interface where each extension string is retrieved separately.
314 * Note! Cannot use VMSVGA3D_INIT_CHECKED_GL_GET_INTEGER_VALUE here because
315 * the above GL_EXTENSIONS error lingers on darwin. sucks.
316 */
317#ifndef GL_NUM_EXTENSIONS
318# define GL_NUM_EXTENSIONS 0x821D
319#endif
320 GLint cExtensions = 1024;
321 glGetIntegerv(GL_NUM_EXTENSIONS, &cExtensions);
322 Assert(cExtensions != 1024);
323
324 PFNGLGETSTRINGIPROC pfnGlGetStringi = (PFNGLGETSTRINGIPROC)OGLGETPROCADDRESS("glGetStringi");
325 AssertLogRelReturn(pfnGlGetStringi, VERR_NOT_SUPPORTED);
326
327 rc = RTStrAAppend(ppszExtensions, " ");
328 for (GLint i = 0; RT_SUCCESS(rc) && i < cExtensions; i++)
329 {
330 const char *pszExt = (const char *)pfnGlGetStringi(GL_EXTENSIONS, i);
331 if (pszExt)
332 rc = RTStrAAppendExN(ppszExtensions, 2, pfnGlGetStringi(GL_EXTENSIONS, i), RTSTR_MAX, " ", (size_t)1);
333 }
334 AssertRCReturn(rc, rc);
335 }
336
337#if 1
338 /*
339 * Add extensions promoted into the core OpenGL profile.
340 */
341 static const struct
342 {
343 float fGLVersion;
344 const char *pszzExtensions;
345 } s_aPromotedExtensions[] =
346 {
347 {
348 1.1f,
349 " GL_EXT_vertex_array \0"
350 " GL_EXT_polygon_offset \0"
351 " GL_EXT_blend_logic_op \0"
352 " GL_EXT_texture \0"
353 " GL_EXT_copy_texture \0"
354 " GL_EXT_subtexture \0"
355 " GL_EXT_texture_object \0"
356 " GL_ARB_framebuffer_object \0"
357 " GL_ARB_map_buffer_range \0"
358 " GL_ARB_vertex_array_object \0"
359 "\0"
360 },
361 {
362 1.2f,
363 " EXT_texture3D \0"
364 " EXT_bgra \0"
365 " EXT_packed_pixels \0"
366 " EXT_rescale_normal \0"
367 " EXT_separate_specular_color \0"
368 " SGIS_texture_edge_clamp \0"
369 " SGIS_texture_lod \0"
370 " EXT_draw_range_elements \0"
371 "\0"
372 },
373 {
374 1.3f,
375 " GL_ARB_texture_compression \0"
376 " GL_ARB_texture_cube_map \0"
377 " GL_ARB_multisample \0"
378 " GL_ARB_multitexture \0"
379 " GL_ARB_texture_env_add \0"
380 " GL_ARB_texture_env_combine \0"
381 " GL_ARB_texture_env_dot3 \0"
382 " GL_ARB_texture_border_clamp \0"
383 " GL_ARB_transpose_matrix \0"
384 "\0"
385 },
386 {
387 1.5f,
388 " GL_SGIS_generate_mipmap \0"
389 /*" GL_NV_blend_equare \0"*/
390 " GL_ARB_depth_texture \0"
391 " GL_ARB_shadow \0"
392 " GL_EXT_fog_coord \0"
393 " GL_EXT_multi_draw_arrays \0"
394 " GL_ARB_point_parameters \0"
395 " GL_EXT_secondary_color \0"
396 " GL_EXT_blend_func_separate \0"
397 " GL_EXT_stencil_wrap \0"
398 " GL_ARB_texture_env_crossbar \0"
399 " GL_EXT_texture_lod_bias \0"
400 " GL_ARB_texture_mirrored_repeat \0"
401 " GL_ARB_window_pos \0"
402 "\0"
403 },
404 {
405 1.6f,
406 " GL_ARB_vertex_buffer_object \0"
407 " GL_ARB_occlusion_query \0"
408 " GL_EXT_shadow_funcs \0"
409 },
410 {
411 2.0f,
412 " GL_ARB_shader_objects \0" /*??*/
413 " GL_ARB_vertex_shader \0" /*??*/
414 " GL_ARB_fragment_shader \0" /*??*/
415 " GL_ARB_shading_language_100 \0" /*??*/
416 " GL_ARB_draw_buffers \0"
417 " GL_ARB_texture_non_power_of_two \0"
418 " GL_ARB_point_sprite \0"
419 " GL_ATI_separate_stencil \0"
420 " GL_EXT_stencil_two_side \0"
421 "\0"
422 },
423 {
424 2.1f,
425 " GL_ARB_pixel_buffer_object \0"
426 " GL_EXT_texture_sRGB \0"
427 "\0"
428 },
429 {
430 3.0f,
431 " GL_ARB_framebuffer_object \0"
432 " GL_ARB_map_buffer_range \0"
433 " GL_ARB_vertex_array_object \0"
434 "\0"
435 },
436 {
437 3.1f,
438 " GL_ARB_copy_buffer \0"
439 " GL_ARB_uniform_buffer_object \0"
440 "\0"
441 },
442 {
443 3.2f,
444 " GL_ARB_vertex_array_bgra \0"
445 " GL_ARB_draw_elements_base_vertex \0"
446 " GL_ARB_fragment_coord_conventions \0"
447 " GL_ARB_provoking_vertex \0"
448 " GL_ARB_seamless_cube_map \0"
449 " GL_ARB_texture_multisample \0"
450 " GL_ARB_depth_clamp \0"
451 " GL_ARB_sync \0"
452 " GL_ARB_geometry_shader4 \0" /*??*/
453 "\0"
454 },
455 {
456 3.3f,
457 " GL_ARB_blend_func_extended \0"
458 " GL_ARB_sampler_objects \0"
459 " GL_ARB_explicit_attrib_location \0"
460 " GL_ARB_occlusion_query2 \0"
461 " GL_ARB_shader_bit_encoding \0"
462 " GL_ARB_texture_rgb10_a2ui \0"
463 " GL_ARB_texture_swizzle \0"
464 " GL_ARB_timer_query \0"
465 " GL_ARB_vertex_type_2_10_10_10_rev \0"
466 "\0"
467 },
468 {
469 4.0f,
470 " GL_ARB_texture_query_lod \0"
471 " GL_ARB_draw_indirect \0"
472 " GL_ARB_gpu_shader5 \0"
473 " GL_ARB_gpu_shader_fp64 \0"
474 " GL_ARB_shader_subroutine \0"
475 " GL_ARB_tessellation_shader \0"
476 " GL_ARB_texture_buffer_object_rgb32 \0"
477 " GL_ARB_texture_cube_map_array \0"
478 " GL_ARB_texture_gather \0"
479 " GL_ARB_transform_feedback2 \0"
480 " GL_ARB_transform_feedback3 \0"
481 "\0"
482 },
483 {
484 4.1f,
485 " GL_ARB_ES2_compatibility \0"
486 " GL_ARB_get_program_binary \0"
487 " GL_ARB_separate_shader_objects \0"
488 " GL_ARB_shader_precision \0"
489 " GL_ARB_vertex_attrib_64bit \0"
490 " GL_ARB_viewport_array \0"
491 "\0"
492 }
493 };
494
495 uint32_t cPromoted = 0;
496 for (uint32_t i = 0; i < RT_ELEMENTS(s_aPromotedExtensions) && s_aPromotedExtensions[i].fGLVersion <= fGLProfileVersion; i++)
497 {
498 const char *pszExt = s_aPromotedExtensions[i].pszzExtensions;
499 while (*pszExt)
500 {
501# ifdef VBOX_STRICT
502 size_t cchExt = strlen(pszExt);
503 Assert(cchExt > 3);
504 Assert(pszExt[0] == ' ');
505 Assert(pszExt[1] != ' ');
506 Assert(pszExt[cchExt - 2] != ' ');
507 Assert(pszExt[cchExt - 1] == ' ');
508# endif
509
510 if (strstr(*ppszExtensions, pszExt) == NULL)
511 {
512 if (cPromoted++ == 0)
513 {
514 rc = RTStrAAppend(ppszExtensions, " <promoted-extensions:> <promoted-extensions:> <promoted-extensions:> ");
515 AssertRCReturn(rc, rc);
516 }
517
518 rc = RTStrAAppend(ppszExtensions, pszExt);
519 AssertRCReturn(rc, rc);
520 }
521
522 pszExt = strchr(pszExt, '\0') + 1;
523 }
524 }
525#endif
526
527 return VINF_SUCCESS;
528}
529
530/** Check whether this is an Intel GL driver.
531 *
532 * @returns true if this seems to be some Intel graphics.
533 */
534static bool vmsvga3dIsVendorIntel(void)
535{
536 return RTStrNICmp((char *)glGetString(GL_VENDOR), "Intel", 5) == 0;
537}
538
539/**
540 * @interface_method_impl{VBOXVMSVGASHADERIF,pfnSwitchInitProfile}
541 */
542static DECLCALLBACK(void) vmsvga3dShaderIfSwitchInitProfile(PVBOXVMSVGASHADERIF pThis, bool fOtherProfile)
543{
544#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
545 PVMSVGA3DSTATE pState = RT_FROM_MEMBER(pThis, VMSVGA3DSTATE, ShaderIf);
546 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pState->papContexts[fOtherProfile ? 2 : 1]);
547#else
548 NOREF(pThis);
549 NOREF(fOtherProfile);
550#endif
551}
552
553
554/**
555 * @interface_method_impl{VBOXVMSVGASHADERIF,pfnGetNextExtension}
556 */
557static DECLCALLBACK(bool) vmsvga3dShaderIfGetNextExtension(PVBOXVMSVGASHADERIF pThis, void **ppvEnumCtx,
558 char *pszBuf, size_t cbBuf, bool fOtherProfile)
559{
560 PVMSVGA3DSTATE pState = RT_FROM_MEMBER(pThis, VMSVGA3DSTATE, ShaderIf);
561 const char *pszCur = *ppvEnumCtx ? (const char *)*ppvEnumCtx
562 : fOtherProfile ? pState->pszOtherExtensions : pState->pszExtensions;
563 while (*pszCur == ' ')
564 pszCur++;
565 if (!*pszCur)
566 return false;
567
568 const char *pszEnd = strchr(pszCur, ' ');
569 AssertReturn(pszEnd, false);
570 size_t cch = pszEnd - pszCur;
571 if (cch < cbBuf)
572 {
573 memcpy(pszBuf, pszCur, cch);
574 pszBuf[cch] = '\0';
575 }
576 else if (cbBuf > 0)
577 {
578 memcpy(pszBuf, "<overflow>", RT_MIN(sizeof("<overflow>"), cbBuf));
579 pszBuf[cbBuf - 1] = '\0';
580 }
581
582 *ppvEnumCtx = (void *)pszEnd;
583 return true;
584}
585
586
587/**
588 * Initializes the VMSVGA3D state during VGA device construction.
589 *
590 * Failure are generally not fatal, 3D support will just be disabled.
591 *
592 * @returns VBox status code.
593 * @param pDevIns The device instance.
594 * @param pThis The shared VGA/VMSVGA state where svga.p3dState will be
595 * modified.
596 * @param pThisCC The VGA/VMSVGA state for ring-3.
597 */
598static DECLCALLBACK(int) vmsvga3dBackInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
599{
600 int rc;
601 RT_NOREF(pDevIns, pThis);
602
603 AssertCompile(GL_TRUE == 1);
604 AssertCompile(GL_FALSE == 0);
605
606#ifdef VMSVGA3D_DYNAMIC_LOAD
607 rc = glLdrInit(pDevIns);
608 if (RT_FAILURE(rc))
609 {
610 LogRel(("VMSVGA3d: Error loading OpenGL library and resolving necessary functions: %Rrc\n", rc));
611 return rc;
612 }
613#endif
614
615 /*
616 * Load and resolve imports from the external shared libraries.
617 */
618 RTERRINFOSTATIC ErrInfo;
619 rc = ExplicitlyLoadVBoxSVGA3D(true /*fResolveAllImports*/, RTErrInfoInitStatic(&ErrInfo));
620 if (RT_FAILURE(rc))
621 {
622 LogRel(("VMSVGA3d: Error loading VBoxSVGA3D and resolving necessary functions: %Rrc - %s\n", rc, ErrInfo.Core.pszMsg));
623 return rc;
624 }
625#ifdef RT_OS_DARWIN
626 rc = ExplicitlyLoadVBoxSVGA3DObjC(true /*fResolveAllImports*/, RTErrInfoInitStatic(&ErrInfo));
627 if (RT_FAILURE(rc))
628 {
629 LogRel(("VMSVGA3d: Error loading VBoxSVGA3DObjC and resolving necessary functions: %Rrc - %s\n", rc, ErrInfo.Core.pszMsg));
630 return rc;
631 }
632#endif
633
634 /*
635 * Allocate the state.
636 */
637 pThisCC->svga.p3dState = (PVMSVGA3DSTATE)RTMemAllocZ(sizeof(VMSVGA3DSTATE));
638 AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
639
640#ifdef RT_OS_WINDOWS
641 /* Create event semaphore and async IO thread. */
642 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
643 rc = RTSemEventCreate(&pState->WndRequestSem);
644 if (RT_SUCCESS(rc))
645 {
646 rc = RTThreadCreate(&pState->pWindowThread, vmsvga3dWindowThread, pState->WndRequestSem, 0, RTTHREADTYPE_GUI, 0,
647 "VMSVGA3DWND");
648 if (RT_SUCCESS(rc))
649 return VINF_SUCCESS;
650
651 /* bail out. */
652 LogRel(("VMSVGA3d: RTThreadCreate failed: %Rrc\n", rc));
653 RTSemEventDestroy(pState->WndRequestSem);
654 }
655 else
656 LogRel(("VMSVGA3d: RTSemEventCreate failed: %Rrc\n", rc));
657 RTMemFree(pThisCC->svga.p3dState);
658 pThisCC->svga.p3dState = NULL;
659 return rc;
660#else
661 return VINF_SUCCESS;
662#endif
663}
664
665static int vmsvga3dLoadGLFunctions(PVMSVGA3DSTATE pState)
666{
667 /* A strict approach to get a proc address as recommended by Khronos:
668 * - "If the function is a core OpenGL function, then we need to check the OpenGL version".
669 * - "If the function is an extension, we need to check to see if the extension is supported."
670 */
671
672/* Get a function address, return VERR_NOT_IMPLEMENTED on failure. */
673#define GLGETPROC_(ProcType, ProcName, NameSuffix) do { \
674 pState->ext.ProcName = (ProcType)OGLGETPROCADDRESS(#ProcName NameSuffix); \
675 AssertLogRelMsgReturn(pState->ext.ProcName, (#ProcName NameSuffix " missing"), VERR_NOT_IMPLEMENTED); \
676} while(0)
677
678/* Get an optional function address. LogRel on failure. */
679#define GLGETPROCOPT_(ProcType, ProcName, NameSuffix) do { \
680 pState->ext.ProcName = (ProcType)OGLGETPROCADDRESS(#ProcName NameSuffix); \
681 if (!pState->ext.ProcName) \
682 { \
683 LogRel(("VMSVGA3d: missing optional %s\n", #ProcName NameSuffix)); \
684 AssertFailed(); \
685 } \
686} while(0)
687
688 /* OpenGL 2.0 or earlier core. Do not bother with extensions. */
689 GLGETPROC_(PFNGLGENQUERIESPROC , glGenQueries, "");
690 GLGETPROC_(PFNGLDELETEQUERIESPROC , glDeleteQueries, "");
691 GLGETPROC_(PFNGLBEGINQUERYPROC , glBeginQuery, "");
692 GLGETPROC_(PFNGLENDQUERYPROC , glEndQuery, "");
693 GLGETPROC_(PFNGLGETQUERYOBJECTUIVPROC , glGetQueryObjectuiv, "");
694 GLGETPROC_(PFNGLTEXIMAGE3DPROC , glTexImage3D, "");
695 GLGETPROC_(PFNGLTEXSUBIMAGE3DPROC , glTexSubImage3D, "");
696 GLGETPROC_(PFNGLGETCOMPRESSEDTEXIMAGEPROC , glGetCompressedTexImage, "");
697 GLGETPROC_(PFNGLCOMPRESSEDTEXIMAGE2DPROC , glCompressedTexImage2D, "");
698 GLGETPROC_(PFNGLCOMPRESSEDTEXIMAGE3DPROC , glCompressedTexImage3D, "");
699 GLGETPROC_(PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC , glCompressedTexSubImage2D, "");
700 GLGETPROC_(PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC , glCompressedTexSubImage3D, "");
701 GLGETPROC_(PFNGLPOINTPARAMETERFPROC , glPointParameterf, "");
702 GLGETPROC_(PFNGLBLENDEQUATIONSEPARATEPROC , glBlendEquationSeparate, "");
703 GLGETPROC_(PFNGLBLENDFUNCSEPARATEPROC , glBlendFuncSeparate, "");
704 GLGETPROC_(PFNGLSTENCILOPSEPARATEPROC , glStencilOpSeparate, "");
705 GLGETPROC_(PFNGLSTENCILFUNCSEPARATEPROC , glStencilFuncSeparate, "");
706 GLGETPROC_(PFNGLBINDBUFFERPROC , glBindBuffer, "");
707 GLGETPROC_(PFNGLDELETEBUFFERSPROC , glDeleteBuffers, "");
708 GLGETPROC_(PFNGLGENBUFFERSPROC , glGenBuffers, "");
709 GLGETPROC_(PFNGLBUFFERDATAPROC , glBufferData, "");
710 GLGETPROC_(PFNGLMAPBUFFERPROC , glMapBuffer, "");
711 GLGETPROC_(PFNGLUNMAPBUFFERPROC , glUnmapBuffer, "");
712 GLGETPROC_(PFNGLENABLEVERTEXATTRIBARRAYPROC , glEnableVertexAttribArray, "");
713 GLGETPROC_(PFNGLDISABLEVERTEXATTRIBARRAYPROC , glDisableVertexAttribArray, "");
714 GLGETPROC_(PFNGLVERTEXATTRIBPOINTERPROC , glVertexAttribPointer, "");
715 GLGETPROC_(PFNGLACTIVETEXTUREPROC , glActiveTexture, "");
716 /* glGetProgramivARB determines implementation limits for the program
717 * target (GL_FRAGMENT_PROGRAM_ARB, GL_VERTEX_PROGRAM_ARB).
718 * It differs from glGetProgramiv, which returns a parameter from a program object.
719 */
720 GLGETPROC_(PFNGLGETPROGRAMIVARBPROC , glGetProgramivARB, "");
721 GLGETPROC_(PFNGLFOGCOORDPOINTERPROC , glFogCoordPointer, "");
722#if VBOX_VMSVGA3D_GL_HACK_LEVEL < 0x102
723 GLGETPROC_(PFNGLBLENDCOLORPROC , glBlendColor, "");
724 GLGETPROC_(PFNGLBLENDEQUATIONPROC , glBlendEquation, "");
725#endif
726#if VBOX_VMSVGA3D_GL_HACK_LEVEL < 0x103
727 GLGETPROC_(PFNGLCLIENTACTIVETEXTUREPROC , glClientActiveTexture, "");
728#endif
729 GLGETPROC_(PFNGLDRAWBUFFERSPROC , glDrawBuffers, "");
730 GLGETPROC_(PFNGLCREATESHADERPROC , glCreateShader, "");
731 GLGETPROC_(PFNGLSHADERSOURCEPROC , glShaderSource, "");
732 GLGETPROC_(PFNGLCOMPILESHADERPROC , glCompileShader, "");
733 GLGETPROC_(PFNGLGETSHADERIVPROC , glGetShaderiv, "");
734 GLGETPROC_(PFNGLGETSHADERINFOLOGPROC , glGetShaderInfoLog, "");
735 GLGETPROC_(PFNGLCREATEPROGRAMPROC , glCreateProgram, "");
736 GLGETPROC_(PFNGLATTACHSHADERPROC , glAttachShader, "");
737 GLGETPROC_(PFNGLLINKPROGRAMPROC , glLinkProgram, "");
738 GLGETPROC_(PFNGLGETPROGRAMIVPROC , glGetProgramiv, "");
739 GLGETPROC_(PFNGLGETPROGRAMINFOLOGPROC , glGetProgramInfoLog, "");
740 GLGETPROC_(PFNGLUSEPROGRAMPROC , glUseProgram, "");
741 GLGETPROC_(PFNGLGETUNIFORMLOCATIONPROC , glGetUniformLocation, "");
742 GLGETPROC_(PFNGLUNIFORM1IPROC , glUniform1i, "");
743 GLGETPROC_(PFNGLUNIFORM4FVPROC , glUniform4fv, "");
744 GLGETPROC_(PFNGLDETACHSHADERPROC , glDetachShader, "");
745 GLGETPROC_(PFNGLDELETESHADERPROC , glDeleteShader, "");
746 GLGETPROC_(PFNGLDELETEPROGRAMPROC , glDeleteProgram, "");
747
748 GLGETPROC_(PFNGLVERTEXATTRIB4FVPROC , glVertexAttrib4fv, "");
749 GLGETPROC_(PFNGLVERTEXATTRIB4UBVPROC , glVertexAttrib4ubv, "");
750 GLGETPROC_(PFNGLVERTEXATTRIB4NUBVPROC , glVertexAttrib4Nubv, "");
751 GLGETPROC_(PFNGLVERTEXATTRIB4SVPROC , glVertexAttrib4sv, "");
752 GLGETPROC_(PFNGLVERTEXATTRIB4NSVPROC , glVertexAttrib4Nsv, "");
753 GLGETPROC_(PFNGLVERTEXATTRIB4NUSVPROC , glVertexAttrib4Nusv, "");
754
755 /* OpenGL 3.0 core, GL_ARB_instanced_arrays. Same functions names in the ARB and core specs. */
756 if ( pState->rsGLVersion >= 3.0f
757 || vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_framebuffer_object "))
758 {
759 GLGETPROC_(PFNGLISRENDERBUFFERPROC , glIsRenderbuffer, "");
760 GLGETPROC_(PFNGLBINDRENDERBUFFERPROC , glBindRenderbuffer, "");
761 GLGETPROC_(PFNGLDELETERENDERBUFFERSPROC , glDeleteRenderbuffers, "");
762 GLGETPROC_(PFNGLGENRENDERBUFFERSPROC , glGenRenderbuffers, "");
763 GLGETPROC_(PFNGLRENDERBUFFERSTORAGEPROC , glRenderbufferStorage, "");
764 GLGETPROC_(PFNGLGETRENDERBUFFERPARAMETERIVPROC , glGetRenderbufferParameteriv, "");
765 GLGETPROC_(PFNGLISFRAMEBUFFERPROC , glIsFramebuffer, "");
766 GLGETPROC_(PFNGLBINDFRAMEBUFFERPROC , glBindFramebuffer, "");
767 GLGETPROC_(PFNGLDELETEFRAMEBUFFERSPROC , glDeleteFramebuffers, "");
768 GLGETPROC_(PFNGLGENFRAMEBUFFERSPROC , glGenFramebuffers, "");
769 GLGETPROC_(PFNGLCHECKFRAMEBUFFERSTATUSPROC , glCheckFramebufferStatus, "");
770 GLGETPROC_(PFNGLFRAMEBUFFERTEXTURE1DPROC , glFramebufferTexture1D, "");
771 GLGETPROC_(PFNGLFRAMEBUFFERTEXTURE2DPROC , glFramebufferTexture2D, "");
772 GLGETPROC_(PFNGLFRAMEBUFFERTEXTURE3DPROC , glFramebufferTexture3D, "");
773 GLGETPROC_(PFNGLFRAMEBUFFERRENDERBUFFERPROC , glFramebufferRenderbuffer, "");
774 GLGETPROC_(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC , glGetFramebufferAttachmentParameteriv, "");
775 GLGETPROC_(PFNGLGENERATEMIPMAPPROC , glGenerateMipmap, "");
776 GLGETPROC_(PFNGLBLITFRAMEBUFFERPROC , glBlitFramebuffer, "");
777 GLGETPROC_(PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC , glRenderbufferStorageMultisample, "");
778 GLGETPROC_(PFNGLFRAMEBUFFERTEXTURELAYERPROC , glFramebufferTextureLayer, "");
779 }
780
781 /* OpenGL 3.1 core, GL_ARB_draw_instanced, GL_EXT_draw_instanced. */
782 if (pState->rsGLVersion >= 3.1f)
783 {
784 GLGETPROC_(PFNGLDRAWARRAYSINSTANCEDPROC , glDrawArraysInstanced, "");
785 GLGETPROC_(PFNGLDRAWELEMENTSINSTANCEDPROC , glDrawElementsInstanced, "");
786 }
787 else if (vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_draw_instanced "))
788 {
789 GLGETPROC_(PFNGLDRAWARRAYSINSTANCEDPROC , glDrawArraysInstanced, "ARB");
790 GLGETPROC_(PFNGLDRAWELEMENTSINSTANCEDPROC , glDrawElementsInstanced, "ARB");
791 }
792 else if (vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_draw_instanced "))
793 {
794 GLGETPROC_(PFNGLDRAWARRAYSINSTANCEDPROC , glDrawArraysInstanced, "EXT");
795 GLGETPROC_(PFNGLDRAWELEMENTSINSTANCEDPROC , glDrawElementsInstanced, "EXT");
796 }
797
798 /* OpenGL 3.2 core, GL_ARB_draw_elements_base_vertex. Same functions names in the ARB and core specs. */
799 if ( pState->rsGLVersion >= 3.2f
800 || vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_draw_elements_base_vertex "))
801 {
802 GLGETPROC_(PFNGLDRAWELEMENTSBASEVERTEXPROC , glDrawElementsBaseVertex, "");
803 GLGETPROC_(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC , glDrawElementsInstancedBaseVertex, "");
804 }
805
806 /* Optional. OpenGL 3.2 core, GL_ARB_provoking_vertex. Same functions names in the ARB and core specs. */
807 if ( pState->rsGLVersion >= 3.2f
808 || vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_provoking_vertex "))
809 {
810 GLGETPROCOPT_(PFNGLPROVOKINGVERTEXPROC , glProvokingVertex, "");
811 }
812
813 /* OpenGL 3.3 core, GL_ARB_instanced_arrays. */
814 if (pState->rsGLVersion >= 3.3f)
815 {
816 GLGETPROC_(PFNGLVERTEXATTRIBDIVISORPROC , glVertexAttribDivisor, "");
817 }
818 else if (vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_instanced_arrays "))
819 {
820 GLGETPROC_(PFNGLVERTEXATTRIBDIVISORARBPROC , glVertexAttribDivisor, "ARB");
821 }
822
823#undef GLGETPROCOPT_
824#undef GLGETPROC_
825
826 return VINF_SUCCESS;
827}
828
829
830DECLINLINE(GLenum) vmsvga3dCubemapFaceFromIndex(uint32_t iFace)
831{
832 GLint Face;
833 switch (iFace)
834 {
835 case 0: Face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; break;
836 case 1: Face = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; break;
837 case 2: Face = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; break;
838 case 3: Face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; break;
839 case 4: Face = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; break;
840 default:
841 case 5: Face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; break;
842 }
843 return Face;
844}
845
846
847/* We must delay window creation until the PowerOn phase. Init is too early and will cause failures. */
848static DECLCALLBACK(int) vmsvga3dBackPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
849{
850 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
851 AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
852 PVMSVGA3DCONTEXT pContext;
853#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
854 PVMSVGA3DCONTEXT pOtherCtx;
855#endif
856 int rc;
857 RT_NOREF(pDevIns, pThis);
858
859 if (pState->rsGLVersion != 0.0)
860 return VINF_SUCCESS; /* already initialized (load state) */
861
862 /*
863 * OpenGL function calls aren't possible without a valid current context, so create a fake one here.
864 */
865 rc = vmsvga3dContextDefineOgl(pThisCC, 1, VMSVGA3D_DEF_CTX_F_INIT);
866 AssertRCReturn(rc, rc);
867
868 pContext = pState->papContexts[1];
869 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
870
871#ifdef VMSVGA3D_DYNAMIC_LOAD
872 /* Context is set and it is possible now to resolve extension functions. */
873 rc = glLdrGetExtFunctions(pDevIns);
874 if (RT_FAILURE(rc))
875 {
876 LogRel(("VMSVGA3d: Error resolving extension functions: %Rrc\n", rc));
877 return rc;
878 }
879#endif
880
881 LogRel(("VMSVGA3d: OpenGL version: %s\n"
882 "VMSVGA3d: OpenGL Vendor: %s\n"
883 "VMSVGA3d: OpenGL Renderer: %s\n"
884 "VMSVGA3d: OpenGL shader language version: %s\n",
885 glGetString(GL_VERSION), glGetString(GL_VENDOR), glGetString(GL_RENDERER),
886 glGetString(GL_SHADING_LANGUAGE_VERSION)));
887
888 rc = vmsvga3dGatherExtensions(&pState->pszExtensions, VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE);
889 AssertRCReturn(rc, rc);
890 vmsvga3dLogRelExtensions("", pState->pszExtensions);
891
892 pState->rsGLVersion = atof((const char *)glGetString(GL_VERSION));
893
894
895#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
896 /*
897 * Get the extension list for the alternative profile so we can better
898 * figure out the shader model and stuff.
899 */
900 rc = vmsvga3dContextDefineOgl(pThisCC, 2, VMSVGA3D_DEF_CTX_F_INIT | VMSVGA3D_DEF_CTX_F_OTHER_PROFILE);
901 AssertLogRelRCReturn(rc, rc);
902 pContext = pState->papContexts[1]; /* Array may have been reallocated. */
903
904 pOtherCtx = pState->papContexts[2];
905 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pOtherCtx);
906
907 LogRel(("VMSVGA3d: Alternative OpenGL version: %s\n"
908 "VMSVGA3d: Alternative OpenGL Vendor: %s\n"
909 "VMSVGA3d: Alternative OpenGL Renderer: %s\n"
910 "VMSVGA3d: Alternative OpenGL shader language version: %s\n",
911 glGetString(GL_VERSION), glGetString(GL_VENDOR), glGetString(GL_RENDERER),
912 glGetString(GL_SHADING_LANGUAGE_VERSION)));
913
914 rc = vmsvga3dGatherExtensions(&pState->pszOtherExtensions, VBOX_VMSVGA3D_OTHER_OGL_PROFILE);
915 AssertRCReturn(rc, rc);
916 vmsvga3dLogRelExtensions("Alternative ", pState->pszOtherExtensions);
917
918 pState->rsOtherGLVersion = atof((const char *)glGetString(GL_VERSION));
919
920 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
921#else
922 pState->pszOtherExtensions = (char *)"";
923 pState->rsOtherGLVersion = pState->rsGLVersion;
924#endif
925
926 /*
927 * Resolve GL function pointers and store them in pState->ext.
928 */
929 rc = vmsvga3dLoadGLFunctions(pState);
930 if (RT_FAILURE(rc))
931 {
932 LogRel(("VMSVGA3d: missing required OpenGL function or extension; aborting\n"));
933 return rc;
934 }
935
936 /*
937 * Initialize the capabilities with sensible defaults.
938 */
939 pState->caps.maxActiveLights = 1;
940 pState->caps.maxTextures = 1;
941 pState->caps.maxClipDistances = 4;
942 pState->caps.maxColorAttachments = 1;
943 pState->caps.maxRectangleTextureSize = 2048;
944 pState->caps.maxTextureAnisotropy = 1;
945 pState->caps.maxVertexShaderInstructions = 1024;
946 pState->caps.maxFragmentShaderInstructions = 1024;
947 pState->caps.vertexShaderVersion = SVGA3DVSVERSION_NONE;
948 pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_NONE;
949 pState->caps.flPointSize[0] = 1;
950 pState->caps.flPointSize[1] = 1;
951
952 /*
953 * Query capabilities
954 */
955 pState->caps.fS3TCSupported = vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_texture_compression_s3tc ");
956 pState->caps.fTextureFilterAnisotropicSupported = vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_texture_filter_anisotropic ");
957
958 VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx, glGetIntegerv(GL_MAX_LIGHTS, &pState->caps.maxActiveLights));
959 VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx, glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &pState->caps.maxTextures));
960#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE /* The alternative profile has a higher number here (ati/darwin). */
961 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pOtherCtx);
962 VMSVGA3D_INIT_CHECKED_BOTH(pState, pOtherCtx, pContext, glGetIntegerv(GL_MAX_CLIP_DISTANCES, &pState->caps.maxClipDistances));
963 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
964#else
965 VMSVGA3D_INIT_CHECKED(glGetIntegerv(GL_MAX_CLIP_DISTANCES, &pState->caps.maxClipDistances));
966#endif
967 VMSVGA3D_INIT_CHECKED(glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &pState->caps.maxColorAttachments));
968 VMSVGA3D_INIT_CHECKED(glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE, &pState->caps.maxRectangleTextureSize));
969 if (pState->caps.fTextureFilterAnisotropicSupported)
970 VMSVGA3D_INIT_CHECKED(glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &pState->caps.maxTextureAnisotropy));
971 VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx, glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, pState->caps.flPointSize));
972
973 VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx,
974 pState->ext.glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB,
975 &pState->caps.maxFragmentShaderTemps));
976 VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx,
977 pState->ext.glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB,
978 &pState->caps.maxFragmentShaderInstructions));
979 VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx,
980 pState->ext.glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB,
981 &pState->caps.maxVertexShaderTemps));
982 VMSVGA3D_INIT_CHECKED_BOTH(pState, pContext, pOtherCtx,
983 pState->ext.glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB,
984 &pState->caps.maxVertexShaderInstructions));
985
986 /* http://http://www.opengl.org/wiki/Detecting_the_Shader_Model
987 * ARB Assembly Language
988 * These are done through testing the presence of extensions. You should test them in this order:
989 * GL_NV_gpu_program4: SM 4.0 or better.
990 * GL_NV_vertex_program3: SM 3.0 or better.
991 * GL_ARB_fragment_program: SM 2.0 or better.
992 * ATI does not support higher than SM 2.0 functionality in assembly shaders.
993 *
994 */
995 /** @todo distinguish between vertex and pixel shaders??? */
996#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE /* The alternative profile has a higher number here (ati/darwin). */
997 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pOtherCtx);
998 const char *pszShadingLanguageVersion = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
999 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
1000#else
1001 const char *pszShadingLanguageVersion = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
1002#endif
1003 float v = pszShadingLanguageVersion ? atof(pszShadingLanguageVersion) : 0.0f;
1004 if ( vmsvga3dCheckGLExtension(pState, 0.0f, " GL_NV_gpu_program4 ")
1005 || strstr(pState->pszOtherExtensions, " GL_NV_gpu_program4 "))
1006 {
1007 pState->caps.vertexShaderVersion = SVGA3DVSVERSION_40;
1008 pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_40;
1009 }
1010 else
1011 if ( vmsvga3dCheckGLExtension(pState, 0.0f, " GL_NV_vertex_program3 ")
1012 || strstr(pState->pszOtherExtensions, " GL_NV_vertex_program3 ")
1013 || vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_shader_texture_lod ") /* Wine claims this suggests SM 3.0 support */
1014 || strstr(pState->pszOtherExtensions, " GL_ARB_shader_texture_lod ")
1015 )
1016 {
1017 pState->caps.vertexShaderVersion = SVGA3DVSVERSION_30;
1018 pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_30;
1019 }
1020 else
1021 if ( vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_fragment_program ")
1022 || strstr(pState->pszOtherExtensions, " GL_ARB_fragment_program "))
1023 {
1024 pState->caps.vertexShaderVersion = SVGA3DVSVERSION_20;
1025 pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_20;
1026 }
1027 else
1028 {
1029 LogRel(("VMSVGA3D: WARNING: unknown support for assembly shaders!!\n"));
1030 pState->caps.vertexShaderVersion = SVGA3DVSVERSION_11;
1031 pState->caps.fragmentShaderVersion = SVGA3DPSVERSION_11;
1032 }
1033
1034 /* Now check the shading language version, in case it indicates a higher supported version. */
1035 if (v >= 3.30f)
1036 {
1037 pState->caps.vertexShaderVersion = RT_MAX(pState->caps.vertexShaderVersion, SVGA3DVSVERSION_40);
1038 pState->caps.fragmentShaderVersion = RT_MAX(pState->caps.fragmentShaderVersion, SVGA3DPSVERSION_40);
1039 }
1040 else
1041 if (v >= 1.20f)
1042 {
1043 pState->caps.vertexShaderVersion = RT_MAX(pState->caps.vertexShaderVersion, SVGA3DVSVERSION_20);
1044 pState->caps.fragmentShaderVersion = RT_MAX(pState->caps.fragmentShaderVersion, SVGA3DPSVERSION_20);
1045 }
1046
1047 if ( !vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_vertex_array_bgra ")
1048 && !vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_vertex_array_bgra "))
1049 {
1050 LogRel(("VMSVGA3D: WARNING: Missing required extension GL_ARB_vertex_array_bgra (d3dcolor)!!!\n"));
1051 }
1052
1053 /*
1054 * Tweak capabilities.
1055 */
1056 /* Intel Windows drivers return 31, while the guest expects 32 at least. */
1057 if ( pState->caps.maxVertexShaderTemps < 32
1058 && vmsvga3dIsVendorIntel())
1059 pState->caps.maxVertexShaderTemps = 32;
1060
1061#if 0
1062 SVGA3D_DEVCAP_MAX_FIXED_VERTEXBLEND = 11,
1063 SVGA3D_DEVCAP_QUERY_TYPES = 15,
1064 SVGA3D_DEVCAP_TEXTURE_GRADIENT_SAMPLING = 16,
1065 SVGA3D_DEVCAP_MAX_POINT_SIZE = 17,
1066 SVGA3D_DEVCAP_MAX_SHADER_TEXTURES = 18,
1067 SVGA3D_DEVCAP_MAX_VOLUME_EXTENT = 21,
1068 SVGA3D_DEVCAP_MAX_TEXTURE_REPEAT = 22,
1069 SVGA3D_DEVCAP_MAX_TEXTURE_ASPECT_RATIO = 23,
1070 SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY = 24,
1071 SVGA3D_DEVCAP_MAX_PRIMITIVE_COUNT = 25,
1072 SVGA3D_DEVCAP_MAX_VERTEX_INDEX = 26,
1073 SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS = 28,
1074 SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS = 29,
1075 SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS = 30,
1076 SVGA3D_DEVCAP_TEXTURE_OPS = 31,
1077 SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8 = 32,
1078 SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8 = 33,
1079 SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10 = 34,
1080 SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5 = 35,
1081 SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5 = 36,
1082 SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4 = 37,
1083 SVGA3D_DEVCAP_SURFACEFMT_R5G6B5 = 38,
1084 SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16 = 39,
1085 SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8 = 40,
1086 SVGA3D_DEVCAP_SURFACEFMT_ALPHA8 = 41,
1087 SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8 = 42,
1088 SVGA3D_DEVCAP_SURFACEFMT_Z_D16 = 43,
1089 SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8 = 44,
1090 SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8 = 45,
1091 SVGA3D_DEVCAP_SURFACEFMT_DXT1 = 46,
1092 SVGA3D_DEVCAP_SURFACEFMT_DXT2 = 47,
1093 SVGA3D_DEVCAP_SURFACEFMT_DXT3 = 48,
1094 SVGA3D_DEVCAP_SURFACEFMT_DXT4 = 49,
1095 SVGA3D_DEVCAP_SURFACEFMT_DXT5 = 50,
1096 SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8 = 51,
1097 SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10 = 52,
1098 SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8 = 53,
1099 SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8 = 54,
1100 SVGA3D_DEVCAP_SURFACEFMT_CxV8U8 = 55,
1101 SVGA3D_DEVCAP_SURFACEFMT_R_S10E5 = 56,
1102 SVGA3D_DEVCAP_SURFACEFMT_R_S23E8 = 57,
1103 SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5 = 58,
1104 SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8 = 59,
1105 SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5 = 60,
1106 SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8 = 61,
1107 SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEXTURES = 63,
1108 SVGA3D_DEVCAP_SURFACEFMT_V16U16 = 65,
1109 SVGA3D_DEVCAP_SURFACEFMT_G16R16 = 66,
1110 SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16 = 67,
1111 SVGA3D_DEVCAP_SURFACEFMT_UYVY = 68,
1112 SVGA3D_DEVCAP_SURFACEFMT_YUY2 = 69,
1113 SVGA3D_DEVCAP_MULTISAMPLE_NONMASKABLESAMPLES = 70,
1114 SVGA3D_DEVCAP_MULTISAMPLE_MASKABLESAMPLES = 71,
1115 SVGA3D_DEVCAP_ALPHATOCOVERAGE = 72,
1116 SVGA3D_DEVCAP_SUPERSAMPLE = 73,
1117 SVGA3D_DEVCAP_AUTOGENMIPMAPS = 74,
1118 SVGA3D_DEVCAP_SURFACEFMT_NV12 = 75,
1119 SVGA3D_DEVCAP_SURFACEFMT_AYUV = 76,
1120 SVGA3D_DEVCAP_SURFACEFMT_Z_DF16 = 79,
1121 SVGA3D_DEVCAP_SURFACEFMT_Z_DF24 = 80,
1122 SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT = 81,
1123 SVGA3D_DEVCAP_SURFACEFMT_ATI1 = 82,
1124 SVGA3D_DEVCAP_SURFACEFMT_ATI2 = 83,
1125#endif
1126
1127 LogRel(("VMSVGA3d: Capabilities:\n"));
1128 LogRel(("VMSVGA3d: maxActiveLights=%-2d maxTextures=%-2d\n",
1129 pState->caps.maxActiveLights, pState->caps.maxTextures));
1130 LogRel(("VMSVGA3d: maxClipDistances=%-2d maxColorAttachments=%-2d maxClipDistances=%d\n",
1131 pState->caps.maxClipDistances, pState->caps.maxColorAttachments, pState->caps.maxClipDistances));
1132 LogRel(("VMSVGA3d: maxColorAttachments=%-2d maxTextureAnisotropy=%-2d maxRectangleTextureSize=%d\n",
1133 pState->caps.maxColorAttachments, pState->caps.maxTextureAnisotropy, pState->caps.maxRectangleTextureSize));
1134 LogRel(("VMSVGA3d: maxVertexShaderTemps=%-2d maxVertexShaderInstructions=%d maxFragmentShaderInstructions=%d\n",
1135 pState->caps.maxVertexShaderTemps, pState->caps.maxVertexShaderInstructions, pState->caps.maxFragmentShaderInstructions));
1136 LogRel(("VMSVGA3d: maxFragmentShaderTemps=%d flPointSize={%d.%02u, %d.%02u}\n",
1137 pState->caps.maxFragmentShaderTemps,
1138 (int)pState->caps.flPointSize[0], (int)(pState->caps.flPointSize[0] * 100) % 100,
1139 (int)pState->caps.flPointSize[1], (int)(pState->caps.flPointSize[1] * 100) % 100));
1140 LogRel(("VMSVGA3d: fragmentShaderVersion=%-2d vertexShaderVersion=%-2d\n",
1141 pState->caps.fragmentShaderVersion, pState->caps.vertexShaderVersion));
1142 LogRel(("VMSVGA3d: fS3TCSupported=%-2d fTextureFilterAnisotropicSupported=%d\n",
1143 pState->caps.fS3TCSupported, pState->caps.fTextureFilterAnisotropicSupported));
1144
1145
1146 /* Initialize the shader library. */
1147 pState->ShaderIf.pfnSwitchInitProfile = vmsvga3dShaderIfSwitchInitProfile;
1148 pState->ShaderIf.pfnGetNextExtension = vmsvga3dShaderIfGetNextExtension;
1149 rc = ShaderInitLib(&pState->ShaderIf);
1150 AssertRC(rc);
1151
1152 /* Cleanup */
1153 rc = vmsvga3dBackContextDestroy(pThisCC, 1);
1154 AssertRC(rc);
1155#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
1156 rc = vmsvga3dBackContextDestroy(pThisCC, 2);
1157 AssertRC(rc);
1158#endif
1159
1160 if ( pState->rsGLVersion < 3.0
1161 && pState->rsOtherGLVersion < 3.0 /* darwin: legacy profile hack */)
1162 {
1163 LogRel(("VMSVGA3d: unsupported OpenGL version; minimum is 3.0\n"));
1164 return VERR_NOT_IMPLEMENTED;
1165 }
1166
1167 return VINF_SUCCESS;
1168}
1169
1170static DECLCALLBACK(int) vmsvga3dBackReset(PVGASTATECC pThisCC)
1171{
1172 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1173 AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
1174
1175 /* Destroy all leftover surfaces. */
1176 for (uint32_t i = 0; i < pState->cSurfaces; i++)
1177 {
1178 if (pState->papSurfaces[i]->id != SVGA3D_INVALID_ID)
1179 vmsvga3dSurfaceDestroy(pThisCC, pState->papSurfaces[i]->id);
1180 }
1181
1182 /* Destroy all leftover contexts. */
1183 for (uint32_t i = 0; i < pState->cContexts; i++)
1184 {
1185 if (pState->papContexts[i]->id != SVGA3D_INVALID_ID)
1186 vmsvga3dBackContextDestroy(pThisCC, pState->papContexts[i]->id);
1187 }
1188
1189 if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
1190 vmsvga3dContextDestroyOgl(pThisCC, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID);
1191
1192 return VINF_SUCCESS;
1193}
1194
1195static DECLCALLBACK(int) vmsvga3dBackTerminate(PVGASTATECC pThisCC)
1196{
1197 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1198 AssertReturn(pState, VERR_WRONG_ORDER);
1199 int rc;
1200
1201 rc = vmsvga3dBackReset(pThisCC);
1202 AssertRCReturn(rc, rc);
1203
1204 /* Terminate the shader library. */
1205 rc = ShaderDestroyLib();
1206 AssertRC(rc);
1207
1208#ifdef RT_OS_WINDOWS
1209 /* Terminate the window creation thread. */
1210 rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_EXIT, 0, 0);
1211 AssertRCReturn(rc, rc);
1212
1213 RTSemEventDestroy(pState->WndRequestSem);
1214#elif defined(RT_OS_DARWIN)
1215
1216#elif defined(RT_OS_LINUX)
1217 /* signal to the thread that it is supposed to exit */
1218 pState->bTerminate = true;
1219 /* wait for it to terminate */
1220 rc = RTThreadWait(pState->pWindowThread, 10000, NULL);
1221 AssertRC(rc);
1222 XCloseDisplay(pState->display);
1223#endif
1224
1225 RTStrFree(pState->pszExtensions);
1226 pState->pszExtensions = NULL;
1227#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
1228 RTStrFree(pState->pszOtherExtensions);
1229#endif
1230 pState->pszOtherExtensions = NULL;
1231
1232 return VINF_SUCCESS;
1233}
1234
1235
1236static DECLCALLBACK(void) vmsvga3dBackUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
1237{
1238 /** @todo Move the visible framebuffer content here, don't wait for the guest to
1239 * redraw it. */
1240
1241#ifdef RT_OS_DARWIN
1242 RT_NOREF(pOldViewport);
1243 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1244 if ( pState
1245 && idScreen == 0
1246 && pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
1247 {
1248 vmsvga3dCocoaViewUpdateViewport(pState->SharedCtx.cocoaView);
1249 }
1250#else
1251 RT_NOREF(pThisCC, idScreen, pOldViewport);
1252#endif
1253}
1254
1255
1256/**
1257 * Worker for vmsvga3dBackQueryCaps that figures out supported operations for a
1258 * given surface format capability.
1259 *
1260 * @returns Supported/indented operations (SVGA3DFORMAT_OP_XXX).
1261 * @param idx3dCaps The SVGA3D_CAPS_XXX value of the surface format.
1262 *
1263 * @remarks See fromat_cap_table in svga_format.c (mesa/gallium) for a reference
1264 * of implicit guest expectations:
1265 * http://cgit.freedesktop.org/mesa/mesa/tree/src/gallium/drivers/svga/svga_format.c
1266 */
1267static uint32_t vmsvga3dGetSurfaceFormatSupport(uint32_t idx3dCaps)
1268{
1269 uint32_t result = 0;
1270
1271 /** @todo missing:
1272 *
1273 * SVGA3DFORMAT_OP_PIXELSIZE
1274 */
1275
1276 switch (idx3dCaps)
1277 {
1278 case SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
1279 case SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
1280 case SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
1281 result |= SVGA3DFORMAT_OP_MEMBEROFGROUP_ARGB
1282 | SVGA3DFORMAT_OP_CONVERT_TO_ARGB
1283 | SVGA3DFORMAT_OP_DISPLAYMODE /* Should not be set for alpha formats. */
1284 | SVGA3DFORMAT_OP_3DACCELERATION; /* implies OP_DISPLAYMODE */
1285 break;
1286
1287 case SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
1288 case SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
1289 case SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
1290 case SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
1291 result |= SVGA3DFORMAT_OP_MEMBEROFGROUP_ARGB
1292 | SVGA3DFORMAT_OP_CONVERT_TO_ARGB
1293 | SVGA3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET;
1294 break;
1295 }
1296
1297 /** @todo check hardware caps! */
1298 switch (idx3dCaps)
1299 {
1300 case SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
1301 case SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
1302 case SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
1303 case SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
1304 case SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
1305 case SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
1306 case SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
1307 case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16:
1308 case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8:
1309 case SVGA3D_DEVCAP_SURFACEFMT_ALPHA8:
1310 case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8:
1311 result |= SVGA3DFORMAT_OP_TEXTURE
1312 | SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET
1313 | SVGA3DFORMAT_OP_OFFSCREENPLAIN
1314 | SVGA3DFORMAT_OP_SAME_FORMAT_RENDERTARGET
1315 | SVGA3DFORMAT_OP_VOLUMETEXTURE
1316 | SVGA3DFORMAT_OP_CUBETEXTURE
1317 | SVGA3DFORMAT_OP_SRGBREAD
1318 | SVGA3DFORMAT_OP_SRGBWRITE;
1319 break;
1320
1321 case SVGA3D_DEVCAP_SURFACEFMT_Z_D16:
1322 case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8:
1323 case SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8:
1324 case SVGA3D_DEVCAP_SURFACEFMT_Z_DF16:
1325 case SVGA3D_DEVCAP_SURFACEFMT_Z_DF24:
1326 case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT:
1327 result |= SVGA3DFORMAT_OP_ZSTENCIL
1328 | SVGA3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH
1329 | SVGA3DFORMAT_OP_TEXTURE /* Necessary for Ubuntu Unity */;
1330 break;
1331
1332 case SVGA3D_DEVCAP_SURFACEFMT_DXT1:
1333 case SVGA3D_DEVCAP_SURFACEFMT_DXT2:
1334 case SVGA3D_DEVCAP_SURFACEFMT_DXT3:
1335 case SVGA3D_DEVCAP_SURFACEFMT_DXT4:
1336 case SVGA3D_DEVCAP_SURFACEFMT_DXT5:
1337 result |= SVGA3DFORMAT_OP_TEXTURE
1338 | SVGA3DFORMAT_OP_VOLUMETEXTURE
1339 | SVGA3DFORMAT_OP_CUBETEXTURE
1340 | SVGA3DFORMAT_OP_SRGBREAD;
1341 break;
1342
1343 case SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8:
1344 case SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10:
1345 case SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8:
1346 case SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8:
1347 case SVGA3D_DEVCAP_SURFACEFMT_CxV8U8:
1348 break;
1349
1350 case SVGA3D_DEVCAP_SURFACEFMT_R_S10E5:
1351 case SVGA3D_DEVCAP_SURFACEFMT_R_S23E8:
1352 case SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5:
1353 case SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8:
1354 case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5:
1355 case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8:
1356 result |= SVGA3DFORMAT_OP_TEXTURE
1357 | SVGA3DFORMAT_OP_VOLUMETEXTURE
1358 | SVGA3DFORMAT_OP_CUBETEXTURE
1359 | SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
1360 break;
1361
1362 case SVGA3D_DEVCAP_SURFACEFMT_V16U16:
1363 case SVGA3D_DEVCAP_SURFACEFMT_G16R16:
1364 case SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16:
1365 result |= SVGA3DFORMAT_OP_TEXTURE
1366 | SVGA3DFORMAT_OP_VOLUMETEXTURE
1367 | SVGA3DFORMAT_OP_CUBETEXTURE
1368 | SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET;
1369 break;
1370
1371 case SVGA3D_DEVCAP_SURFACEFMT_UYVY:
1372 case SVGA3D_DEVCAP_SURFACEFMT_YUY2:
1373 result |= SVGA3DFORMAT_OP_OFFSCREENPLAIN
1374 | SVGA3DFORMAT_OP_CONVERT_TO_ARGB
1375 | SVGA3DFORMAT_OP_TEXTURE;
1376 break;
1377
1378 case SVGA3D_DEVCAP_SURFACEFMT_NV12:
1379 case SVGA3D_DEVCAP_DEAD10: /* SVGA3D_DEVCAP_SURFACEFMT_AYUV */
1380 break;
1381 }
1382 Log(("CAPS: %s =\n%s\n", vmsvga3dGetCapString(idx3dCaps), vmsvga3dGet3dFormatString(result)));
1383
1384 return result;
1385}
1386
1387#if 0 /* unused */
1388static uint32_t vmsvga3dGetDepthFormatSupport(PVMSVGA3DSTATE pState3D, uint32_t idx3dCaps)
1389{
1390 RT_NOREF(pState3D, idx3dCaps);
1391
1392 /** @todo test this somehow */
1393 uint32_t result = SVGA3DFORMAT_OP_ZSTENCIL | SVGA3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH;
1394
1395 Log(("CAPS: %s =\n%s\n", vmsvga3dGetCapString(idx3dCaps), vmsvga3dGet3dFormatString(result)));
1396 return result;
1397}
1398#endif
1399
1400
1401static DECLCALLBACK(int) vmsvga3dBackQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
1402{
1403 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1404 AssertReturn(pState, VERR_NO_MEMORY);
1405 int rc = VINF_SUCCESS;
1406
1407 *pu32Val = 0;
1408
1409 /*
1410 * The capabilities access by current (2015-03-01) linux sources (gallium,
1411 * vmwgfx, xorg-video-vmware) are annotated, caps without xref annotations
1412 * aren't access.
1413 */
1414
1415 switch (idx3dCaps)
1416 {
1417 /* Linux: vmwgfx_fifo.c in kmod; only used with SVGA_CAP_GBOBJECTS. */
1418 case SVGA3D_DEVCAP_3D:
1419 *pu32Val = 1; /* boolean? */
1420 break;
1421
1422 case SVGA3D_DEVCAP_MAX_LIGHTS:
1423 *pu32Val = pState->caps.maxActiveLights;
1424 break;
1425
1426 case SVGA3D_DEVCAP_MAX_TEXTURES:
1427 *pu32Val = pState->caps.maxTextures;
1428 break;
1429
1430 case SVGA3D_DEVCAP_MAX_CLIP_PLANES:
1431 *pu32Val = pState->caps.maxClipDistances;
1432 break;
1433
1434 /* Linux: svga_screen.c in gallium; 3.0 or later required. */
1435 case SVGA3D_DEVCAP_VERTEX_SHADER_VERSION:
1436 *pu32Val = pState->caps.vertexShaderVersion;
1437 break;
1438
1439 case SVGA3D_DEVCAP_VERTEX_SHADER:
1440 /* boolean? */
1441 *pu32Val = (pState->caps.vertexShaderVersion != SVGA3DVSVERSION_NONE);
1442 break;
1443
1444 /* Linux: svga_screen.c in gallium; 3.0 or later required. */
1445 case SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION:
1446 *pu32Val = pState->caps.fragmentShaderVersion;
1447 break;
1448
1449 case SVGA3D_DEVCAP_FRAGMENT_SHADER:
1450 /* boolean? */
1451 *pu32Val = (pState->caps.fragmentShaderVersion != SVGA3DPSVERSION_NONE);
1452 break;
1453
1454 case SVGA3D_DEVCAP_S23E8_TEXTURES:
1455 case SVGA3D_DEVCAP_S10E5_TEXTURES:
1456 /* Must be obsolete by now; surface format caps specify the same thing. */
1457 rc = VERR_INVALID_PARAMETER;
1458 break;
1459
1460 case SVGA3D_DEVCAP_MAX_FIXED_VERTEXBLEND:
1461 break;
1462
1463 /*
1464 * 2. The BUFFER_FORMAT capabilities are deprecated, and they always
1465 * return TRUE. Even on physical hardware that does not support
1466 * these formats natively, the SVGA3D device will provide an emulation
1467 * which should be invisible to the guest OS.
1468 */
1469 case SVGA3D_DEVCAP_D16_BUFFER_FORMAT:
1470 case SVGA3D_DEVCAP_D24S8_BUFFER_FORMAT:
1471 case SVGA3D_DEVCAP_D24X8_BUFFER_FORMAT:
1472 *pu32Val = 1;
1473 break;
1474
1475 case SVGA3D_DEVCAP_QUERY_TYPES:
1476 break;
1477
1478 case SVGA3D_DEVCAP_TEXTURE_GRADIENT_SAMPLING:
1479 break;
1480
1481 /* Linux: svga_screen.c in gallium; capped at 80.0, default 1.0. */
1482 case SVGA3D_DEVCAP_MAX_POINT_SIZE:
1483 AssertCompile(sizeof(uint32_t) == sizeof(float));
1484 *(float *)pu32Val = pState->caps.flPointSize[1];
1485 break;
1486
1487 case SVGA3D_DEVCAP_MAX_SHADER_TEXTURES:
1488 /** @todo ?? */
1489 rc = VERR_INVALID_PARAMETER;
1490 break;
1491
1492 /* Linux: svga_screen.c in gallium (for PIPE_CAP_MAX_TEXTURE_2D_LEVELS); have default if missing. */
1493 case SVGA3D_DEVCAP_MAX_TEXTURE_WIDTH:
1494 case SVGA3D_DEVCAP_MAX_TEXTURE_HEIGHT:
1495 *pu32Val = pState->caps.maxRectangleTextureSize;
1496 break;
1497
1498 /* Linux: svga_screen.c in gallium (for PIPE_CAP_MAX_TEXTURE_3D_LEVELS); have default if missing. */
1499 case SVGA3D_DEVCAP_MAX_VOLUME_EXTENT:
1500 //*pu32Val = pCaps->MaxVolumeExtent;
1501 *pu32Val = 256;
1502 break;
1503
1504 case SVGA3D_DEVCAP_MAX_TEXTURE_REPEAT:
1505 *pu32Val = 32768; /* hardcoded in Wine */
1506 break;
1507
1508 case SVGA3D_DEVCAP_MAX_TEXTURE_ASPECT_RATIO:
1509 //*pu32Val = pCaps->MaxTextureAspectRatio;
1510 break;
1511
1512 /* Linux: svga_screen.c in gallium (for PIPE_CAPF_MAX_TEXTURE_ANISOTROPY); defaults to 4.0. */
1513 case SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY:
1514 *pu32Val = pState->caps.maxTextureAnisotropy;
1515 break;
1516
1517 case SVGA3D_DEVCAP_MAX_PRIMITIVE_COUNT:
1518 case SVGA3D_DEVCAP_MAX_VERTEX_INDEX:
1519 *pu32Val = 0xFFFFF; /* hardcoded in Wine */
1520 break;
1521
1522 /* Linux: svga_screen.c in gallium (for PIPE_SHADER_VERTEX/PIPE_SHADER_CAP_MAX_INSTRUCTIONS); defaults to 512. */
1523 case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_INSTRUCTIONS:
1524 *pu32Val = pState->caps.maxVertexShaderInstructions;
1525 break;
1526
1527 case SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS:
1528 *pu32Val = pState->caps.maxFragmentShaderInstructions;
1529 break;
1530
1531 /* Linux: svga_screen.c in gallium (for PIPE_SHADER_VERTEX/PIPE_SHADER_CAP_MAX_TEMPS); defaults to 32. */
1532 case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS:
1533 *pu32Val = pState->caps.maxVertexShaderTemps;
1534 break;
1535
1536 /* Linux: svga_screen.c in gallium (for PIPE_SHADER_FRAGMENT/PIPE_SHADER_CAP_MAX_TEMPS); defaults to 32. */
1537 case SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS:
1538 *pu32Val = pState->caps.maxFragmentShaderTemps;
1539 break;
1540
1541 case SVGA3D_DEVCAP_TEXTURE_OPS:
1542 break;
1543
1544 case SVGA3D_DEVCAP_DEAD4: /* SVGA3D_DEVCAP_MULTISAMPLE_NONMASKABLESAMPLES */
1545 break;
1546
1547 case SVGA3D_DEVCAP_DEAD5: /* SVGA3D_DEVCAP_MULTISAMPLE_MASKABLESAMPLES */
1548 break;
1549
1550 case SVGA3D_DEVCAP_DEAD7: /* SVGA3D_DEVCAP_ALPHATOCOVERAGE */
1551 break;
1552
1553 case SVGA3D_DEVCAP_DEAD6: /* SVGA3D_DEVCAP_SUPERSAMPLE */
1554 break;
1555
1556 case SVGA3D_DEVCAP_AUTOGENMIPMAPS:
1557 //*pu32Val = !!(pCaps->Caps2 & D3DCAPS2_CANAUTOGENMIPMAP);
1558 break;
1559
1560 case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEXTURES:
1561 break;
1562
1563 case SVGA3D_DEVCAP_MAX_RENDER_TARGETS: /** @todo same thing? */
1564 case SVGA3D_DEVCAP_MAX_SIMULTANEOUS_RENDER_TARGETS:
1565 *pu32Val = pState->caps.maxColorAttachments;
1566 break;
1567
1568 /*
1569 * This is the maximum number of SVGA context IDs that the guest
1570 * can define using SVGA_3D_CMD_CONTEXT_DEFINE.
1571 */
1572 case SVGA3D_DEVCAP_MAX_CONTEXT_IDS:
1573 *pu32Val = SVGA3D_MAX_CONTEXT_IDS;
1574 break;
1575
1576 /*
1577 * This is the maximum number of SVGA surface IDs that the guest
1578 * can define using SVGA_3D_CMD_SURFACE_DEFINE*.
1579 */
1580 case SVGA3D_DEVCAP_MAX_SURFACE_IDS:
1581 *pu32Val = SVGA3D_MAX_SURFACE_IDS;
1582 break;
1583
1584#if 0 /* Appeared more recently, not yet implemented. */
1585 /* Linux: svga_screen.c in gallium; defaults to FALSE. */
1586 case SVGA3D_DEVCAP_LINE_AA:
1587 break;
1588 /* Linux: svga_screen.c in gallium; defaults to FALSE. */
1589 case SVGA3D_DEVCAP_LINE_STIPPLE:
1590 break;
1591 /* Linux: svga_screen.c in gallium; defaults to 1.0. */
1592 case SVGA3D_DEVCAP_MAX_LINE_WIDTH:
1593 break;
1594 /* Linux: svga_screen.c in gallium; defaults to 1.0. */
1595 case SVGA3D_DEVCAP_MAX_AA_LINE_WIDTH:
1596 break;
1597#endif
1598
1599 /*
1600 * Supported surface formats.
1601 * Linux: svga_format.c in gallium, format_cap_table defines implicit expectations.
1602 */
1603 case SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
1604 case SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
1605 case SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
1606 case SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
1607 case SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
1608 case SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
1609 case SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
1610 case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16:
1611 case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8:
1612 case SVGA3D_DEVCAP_SURFACEFMT_ALPHA8:
1613 case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8:
1614 case SVGA3D_DEVCAP_SURFACEFMT_Z_D16:
1615 case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8:
1616 case SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8:
1617 case SVGA3D_DEVCAP_SURFACEFMT_Z_DF16:
1618 case SVGA3D_DEVCAP_SURFACEFMT_Z_DF24:
1619 case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT:
1620 case SVGA3D_DEVCAP_SURFACEFMT_DXT1:
1621 *pu32Val = vmsvga3dGetSurfaceFormatSupport(idx3dCaps);
1622 break;
1623
1624 case SVGA3D_DEVCAP_SURFACEFMT_DXT2:
1625 case SVGA3D_DEVCAP_SURFACEFMT_DXT3:
1626 case SVGA3D_DEVCAP_SURFACEFMT_DXT4:
1627 case SVGA3D_DEVCAP_SURFACEFMT_DXT5:
1628 case SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8:
1629 case SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10:
1630 case SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8:
1631 case SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8:
1632 case SVGA3D_DEVCAP_SURFACEFMT_CxV8U8:
1633 case SVGA3D_DEVCAP_SURFACEFMT_R_S10E5:
1634 case SVGA3D_DEVCAP_SURFACEFMT_R_S23E8:
1635 case SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5:
1636 case SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8:
1637 case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5:
1638 case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8:
1639 case SVGA3D_DEVCAP_SURFACEFMT_V16U16:
1640 case SVGA3D_DEVCAP_SURFACEFMT_G16R16:
1641 case SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16:
1642 case SVGA3D_DEVCAP_SURFACEFMT_UYVY:
1643 case SVGA3D_DEVCAP_SURFACEFMT_YUY2:
1644 case SVGA3D_DEVCAP_SURFACEFMT_NV12:
1645 case SVGA3D_DEVCAP_DEAD10: /* SVGA3D_DEVCAP_SURFACEFMT_AYUV */
1646 *pu32Val = vmsvga3dGetSurfaceFormatSupport(idx3dCaps);
1647 break;
1648
1649 /* Linux: Not referenced in current sources. */
1650 case SVGA3D_DEVCAP_SURFACEFMT_ATI1:
1651 case SVGA3D_DEVCAP_SURFACEFMT_ATI2:
1652 Log(("CAPS: Unknown CAP %s\n", vmsvga3dGetCapString(idx3dCaps)));
1653 rc = VERR_INVALID_PARAMETER;
1654 *pu32Val = 0;
1655 break;
1656
1657 default:
1658 Log(("CAPS: Unexpected CAP %d\n", idx3dCaps));
1659 rc = VERR_INVALID_PARAMETER;
1660 break;
1661 }
1662
1663 Log(("CAPS: %s - %x\n", vmsvga3dGetCapString(idx3dCaps), *pu32Val));
1664 return rc;
1665}
1666
1667/**
1668 * Convert SVGA format value to its OpenGL equivalent
1669 *
1670 * @remarks Clues to be had in format_texture_info table (wined3d/utils.c) with
1671 * help from wined3dformat_from_d3dformat().
1672 */
1673void vmsvga3dSurfaceFormat2OGL(PVMSVGA3DSURFACE pSurface, SVGA3dSurfaceFormat format)
1674{
1675#if 0
1676#define AssertTestFmt(f) AssertMsgFailed(("Test me - " #f "\n"))
1677#else
1678#define AssertTestFmt(f) do {} while(0)
1679#endif
1680 /* Init cbBlockGL for non-emulated formats. */
1681 pSurface->cbBlockGL = pSurface->cbBlock;
1682
1683 switch (format)
1684 {
1685 case SVGA3D_X8R8G8B8: /* D3DFMT_X8R8G8B8 - WINED3DFMT_B8G8R8X8_UNORM */
1686 pSurface->internalFormatGL = GL_RGB8;
1687 pSurface->formatGL = GL_BGRA;
1688 pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1689 break;
1690 case SVGA3D_A8R8G8B8: /* D3DFMT_A8R8G8B8 - WINED3DFMT_B8G8R8A8_UNORM */
1691 pSurface->internalFormatGL = GL_RGBA8;
1692 pSurface->formatGL = GL_BGRA;
1693 pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1694 break;
1695 case SVGA3D_R5G6B5: /* D3DFMT_R5G6B5 - WINED3DFMT_B5G6R5_UNORM */
1696 pSurface->internalFormatGL = GL_RGB5;
1697 pSurface->formatGL = GL_RGB;
1698 pSurface->typeGL = GL_UNSIGNED_SHORT_5_6_5;
1699 AssertTestFmt(SVGA3D_R5G6B5);
1700 break;
1701 case SVGA3D_X1R5G5B5: /* D3DFMT_X1R5G5B5 - WINED3DFMT_B5G5R5X1_UNORM */
1702 pSurface->internalFormatGL = GL_RGB5;
1703 pSurface->formatGL = GL_BGRA;
1704 pSurface->typeGL = GL_UNSIGNED_SHORT_1_5_5_5_REV;
1705 AssertTestFmt(SVGA3D_X1R5G5B5);
1706 break;
1707 case SVGA3D_A1R5G5B5: /* D3DFMT_A1R5G5B5 - WINED3DFMT_B5G5R5A1_UNORM */
1708 pSurface->internalFormatGL = GL_RGB5_A1;
1709 pSurface->formatGL = GL_BGRA;
1710 pSurface->typeGL = GL_UNSIGNED_SHORT_1_5_5_5_REV;
1711 AssertTestFmt(SVGA3D_A1R5G5B5);
1712 break;
1713 case SVGA3D_A4R4G4B4: /* D3DFMT_A4R4G4B4 - WINED3DFMT_B4G4R4A4_UNORM */
1714 pSurface->internalFormatGL = GL_RGBA4;
1715 pSurface->formatGL = GL_BGRA;
1716 pSurface->typeGL = GL_UNSIGNED_SHORT_4_4_4_4_REV;
1717 AssertTestFmt(SVGA3D_A4R4G4B4);
1718 break;
1719
1720 case SVGA3D_R8G8B8A8_UNORM:
1721 pSurface->internalFormatGL = GL_RGBA8;
1722 pSurface->formatGL = GL_RGBA;
1723 pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1724 break;
1725
1726 case SVGA3D_Z_D32: /* D3DFMT_D32 - WINED3DFMT_D32_UNORM */
1727 pSurface->internalFormatGL = GL_DEPTH_COMPONENT32;
1728 pSurface->formatGL = GL_DEPTH_COMPONENT;
1729 pSurface->typeGL = GL_UNSIGNED_INT;
1730 break;
1731 case SVGA3D_Z_D16: /* D3DFMT_D16 - WINED3DFMT_D16_UNORM */
1732 pSurface->internalFormatGL = GL_DEPTH_COMPONENT16; /** @todo Wine suggests GL_DEPTH_COMPONENT24. */
1733 pSurface->formatGL = GL_DEPTH_COMPONENT;
1734 pSurface->typeGL = GL_UNSIGNED_SHORT;
1735 AssertTestFmt(SVGA3D_Z_D16);
1736 break;
1737 case SVGA3D_Z_D24S8: /* D3DFMT_D24S8 - WINED3DFMT_D24_UNORM_S8_UINT */
1738 pSurface->internalFormatGL = GL_DEPTH24_STENCIL8;
1739 pSurface->formatGL = GL_DEPTH_STENCIL;
1740 pSurface->typeGL = GL_UNSIGNED_INT_24_8;
1741 break;
1742 case SVGA3D_Z_D15S1: /* D3DFMT_D15S1 - WINED3DFMT_S1_UINT_D15_UNORM */
1743 pSurface->internalFormatGL = GL_DEPTH_COMPONENT16; /** @todo ??? */
1744 pSurface->formatGL = GL_DEPTH_STENCIL;
1745 pSurface->typeGL = GL_UNSIGNED_SHORT;
1746 /** @todo Wine sources hints at no hw support for this, so test this one! */
1747 AssertTestFmt(SVGA3D_Z_D15S1);
1748 break;
1749 case SVGA3D_Z_D24X8: /* D3DFMT_D24X8 - WINED3DFMT_X8D24_UNORM */
1750 pSurface->internalFormatGL = GL_DEPTH_COMPONENT24;
1751 pSurface->formatGL = GL_DEPTH_COMPONENT;
1752 pSurface->typeGL = GL_UNSIGNED_INT;
1753 AssertTestFmt(SVGA3D_Z_D24X8);
1754 break;
1755
1756 /* Advanced D3D9 depth formats. */
1757 case SVGA3D_Z_DF16: /* D3DFMT_DF16? - not supported */
1758 pSurface->internalFormatGL = GL_DEPTH_COMPONENT16;
1759 pSurface->formatGL = GL_DEPTH_COMPONENT;
1760 pSurface->typeGL = GL_HALF_FLOAT;
1761 break;
1762
1763 case SVGA3D_Z_DF24: /* D3DFMT_DF24? - not supported */
1764 pSurface->internalFormatGL = GL_DEPTH_COMPONENT24;
1765 pSurface->formatGL = GL_DEPTH_COMPONENT;
1766 pSurface->typeGL = GL_FLOAT; /* ??? */
1767 break;
1768
1769 case SVGA3D_Z_D24S8_INT: /* D3DFMT_D24S8 */
1770 pSurface->internalFormatGL = GL_DEPTH24_STENCIL8;
1771 pSurface->formatGL = GL_DEPTH_STENCIL;
1772 pSurface->typeGL = GL_UNSIGNED_INT_24_8;
1773 break;
1774
1775 case SVGA3D_DXT1: /* D3DFMT_DXT1 - WINED3DFMT_DXT1 */
1776 pSurface->internalFormatGL = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
1777 pSurface->formatGL = GL_RGBA; /* not used */
1778 pSurface->typeGL = GL_UNSIGNED_BYTE; /* not used */
1779 break;
1780
1781 case SVGA3D_DXT2: /* D3DFMT_DXT2 */
1782 /* "DXT2 and DXT3 are the same from an API perspective." */
1783 RT_FALL_THRU();
1784 case SVGA3D_DXT3: /* D3DFMT_DXT3 - WINED3DFMT_DXT3 */
1785 pSurface->internalFormatGL = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
1786 pSurface->formatGL = GL_RGBA; /* not used */
1787 pSurface->typeGL = GL_UNSIGNED_BYTE; /* not used */
1788 break;
1789
1790 case SVGA3D_DXT4: /* D3DFMT_DXT4 */
1791 /* "DXT4 and DXT5 are the same from an API perspective." */
1792 RT_FALL_THRU();
1793 case SVGA3D_DXT5: /* D3DFMT_DXT5 - WINED3DFMT_DXT5 */
1794 pSurface->internalFormatGL = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
1795 pSurface->formatGL = GL_RGBA; /* not used */
1796 pSurface->typeGL = GL_UNSIGNED_BYTE; /* not used */
1797 break;
1798
1799 case SVGA3D_LUMINANCE8: /* D3DFMT_? - ? */
1800 pSurface->internalFormatGL = GL_LUMINANCE8_EXT;
1801 pSurface->formatGL = GL_LUMINANCE;
1802 pSurface->typeGL = GL_UNSIGNED_BYTE;
1803 break;
1804
1805 case SVGA3D_LUMINANCE16: /* D3DFMT_? - ? */
1806 pSurface->internalFormatGL = GL_LUMINANCE16_EXT;
1807 pSurface->formatGL = GL_LUMINANCE;
1808 pSurface->typeGL = GL_UNSIGNED_SHORT;
1809 break;
1810
1811 case SVGA3D_LUMINANCE4_ALPHA4: /* D3DFMT_? - ? */
1812 pSurface->internalFormatGL = GL_LUMINANCE4_ALPHA4_EXT;
1813 pSurface->formatGL = GL_LUMINANCE_ALPHA;
1814 pSurface->typeGL = GL_UNSIGNED_BYTE;
1815 break;
1816
1817 case SVGA3D_LUMINANCE8_ALPHA8: /* D3DFMT_? - ? */
1818 pSurface->internalFormatGL = GL_LUMINANCE8_ALPHA8_EXT;
1819 pSurface->formatGL = GL_LUMINANCE_ALPHA;
1820 pSurface->typeGL = GL_UNSIGNED_BYTE; /* unsigned_short causes issues even though this type should be 16-bit */
1821 break;
1822
1823 case SVGA3D_ALPHA8: /* D3DFMT_A8? - WINED3DFMT_A8_UNORM? */
1824 pSurface->internalFormatGL = GL_ALPHA8_EXT;
1825 pSurface->formatGL = GL_ALPHA;
1826 pSurface->typeGL = GL_UNSIGNED_BYTE;
1827 break;
1828
1829#if 0
1830
1831 /* Bump-map formats */
1832 case SVGA3D_BUMPU8V8:
1833 return D3DFMT_V8U8;
1834 case SVGA3D_BUMPL6V5U5:
1835 return D3DFMT_L6V5U5;
1836 case SVGA3D_BUMPX8L8V8U8:
1837 return D3DFMT_X8L8V8U8;
1838 case SVGA3D_FORMAT_DEAD1:
1839 /* No corresponding D3D9 equivalent. */
1840 AssertFailedReturn(D3DFMT_UNKNOWN);
1841 /* signed bump-map formats */
1842 case SVGA3D_V8U8:
1843 return D3DFMT_V8U8;
1844 case SVGA3D_Q8W8V8U8:
1845 return D3DFMT_Q8W8V8U8;
1846 case SVGA3D_CxV8U8:
1847 return D3DFMT_CxV8U8;
1848 /* mixed bump-map formats */
1849 case SVGA3D_X8L8V8U8:
1850 return D3DFMT_X8L8V8U8;
1851 case SVGA3D_A2W10V10U10:
1852 return D3DFMT_A2W10V10U10;
1853#endif
1854
1855 case SVGA3D_ARGB_S10E5: /* 16-bit floating-point ARGB */ /* D3DFMT_A16B16G16R16F - WINED3DFMT_R16G16B16A16_FLOAT */
1856 pSurface->internalFormatGL = GL_RGBA16F;
1857 pSurface->formatGL = GL_RGBA;
1858#if 0 /* bird: wine uses half float, sounds correct to me... */
1859 pSurface->typeGL = GL_FLOAT;
1860#else
1861 pSurface->typeGL = GL_HALF_FLOAT;
1862 AssertTestFmt(SVGA3D_ARGB_S10E5);
1863#endif
1864 break;
1865
1866 case SVGA3D_ARGB_S23E8: /* 32-bit floating-point ARGB */ /* D3DFMT_A32B32G32R32F - WINED3DFMT_R32G32B32A32_FLOAT */
1867 pSurface->internalFormatGL = GL_RGBA32F;
1868 pSurface->formatGL = GL_RGBA;
1869 pSurface->typeGL = GL_FLOAT; /* ?? - same as wine, so probably correct */
1870 break;
1871
1872 case SVGA3D_A2R10G10B10: /* D3DFMT_A2R10G10B10 - WINED3DFMT_B10G10R10A2_UNORM */
1873 pSurface->internalFormatGL = GL_RGB10_A2; /* ?? - same as wine, so probably correct */
1874#if 0 /* bird: Wine uses GL_BGRA instead of GL_RGBA. */
1875 pSurface->formatGL = GL_RGBA;
1876#else
1877 pSurface->formatGL = GL_BGRA;
1878#endif
1879 pSurface->typeGL = GL_UNSIGNED_INT;
1880 AssertTestFmt(SVGA3D_A2R10G10B10);
1881 break;
1882
1883
1884 /* Single- and dual-component floating point formats */
1885 case SVGA3D_R_S10E5: /* D3DFMT_R16F - WINED3DFMT_R16_FLOAT */
1886 pSurface->internalFormatGL = GL_R16F;
1887 pSurface->formatGL = GL_RED;
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_R_S10E5);
1893#endif
1894 break;
1895 case SVGA3D_R_S23E8: /* D3DFMT_R32F - WINED3DFMT_R32_FLOAT */
1896 pSurface->internalFormatGL = GL_R32F;
1897 pSurface->formatGL = GL_RED;
1898 pSurface->typeGL = GL_FLOAT;
1899 break;
1900 case SVGA3D_RG_S10E5: /* D3DFMT_G16R16F - WINED3DFMT_R16G16_FLOAT */
1901 pSurface->internalFormatGL = GL_RG16F;
1902 pSurface->formatGL = GL_RG;
1903#if 0 /* bird: wine uses half float, sounds correct to me... */
1904 pSurface->typeGL = GL_FLOAT;
1905#else
1906 pSurface->typeGL = GL_HALF_FLOAT;
1907 AssertTestFmt(SVGA3D_RG_S10E5);
1908#endif
1909 break;
1910 case SVGA3D_RG_S23E8: /* D3DFMT_G32R32F - WINED3DFMT_R32G32_FLOAT */
1911 pSurface->internalFormatGL = GL_RG32F;
1912 pSurface->formatGL = GL_RG;
1913 pSurface->typeGL = GL_FLOAT;
1914 break;
1915
1916 /*
1917 * Any surface can be used as a buffer object, but SVGA3D_BUFFER is
1918 * the most efficient format to use when creating new surfaces
1919 * expressly for index or vertex data.
1920 */
1921 case SVGA3D_BUFFER:
1922 pSurface->internalFormatGL = -1;
1923 pSurface->formatGL = -1;
1924 pSurface->typeGL = -1;
1925 break;
1926
1927#if 0
1928 return D3DFMT_UNKNOWN;
1929
1930 case SVGA3D_V16U16:
1931 return D3DFMT_V16U16;
1932#endif
1933
1934 case SVGA3D_G16R16: /* D3DFMT_G16R16 - WINED3DFMT_R16G16_UNORM */
1935 pSurface->internalFormatGL = GL_RG16;
1936 pSurface->formatGL = GL_RG;
1937#if 0 /* bird: Wine uses GL_UNSIGNED_SHORT here. */
1938 pSurface->typeGL = GL_UNSIGNED_INT;
1939#else
1940 pSurface->typeGL = GL_UNSIGNED_SHORT;
1941 AssertTestFmt(SVGA3D_G16R16);
1942#endif
1943 break;
1944
1945 case SVGA3D_A16B16G16R16: /* D3DFMT_A16B16G16R16 - WINED3DFMT_R16G16B16A16_UNORM */
1946 pSurface->internalFormatGL = GL_RGBA16;
1947 pSurface->formatGL = GL_RGBA;
1948#if 0 /* bird: Wine uses GL_UNSIGNED_SHORT here. */
1949 pSurface->typeGL = GL_UNSIGNED_INT; /* ??? */
1950#else
1951 pSurface->typeGL = GL_UNSIGNED_SHORT;
1952 AssertTestFmt(SVGA3D_A16B16G16R16);
1953#endif
1954 break;
1955
1956 case SVGA3D_R8G8B8A8_SNORM:
1957 pSurface->internalFormatGL = GL_RGB8;
1958 pSurface->formatGL = GL_BGRA;
1959 pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1960 AssertTestFmt(SVGA3D_R8G8B8A8_SNORM);
1961 break;
1962 case SVGA3D_R16G16_UNORM:
1963 pSurface->internalFormatGL = GL_RG16;
1964 pSurface->formatGL = GL_RG;
1965 pSurface->typeGL = GL_UNSIGNED_SHORT;
1966 AssertTestFmt(SVGA3D_R16G16_UNORM);
1967 break;
1968
1969 /* Packed Video formats */
1970 case SVGA3D_UYVY:
1971 case SVGA3D_YUY2:
1972 /* Use a BRGA texture to hold the data and convert it to an actual BGRA. */
1973 pSurface->fEmulated = true;
1974 pSurface->internalFormatGL = GL_RGBA8;
1975 pSurface->formatGL = GL_BGRA;
1976 pSurface->typeGL = GL_UNSIGNED_INT_8_8_8_8_REV;
1977 pSurface->cbBlockGL = 4 * pSurface->cxBlock * pSurface->cyBlock;
1978 break;
1979
1980#if 0
1981 /* Planar video formats */
1982 case SVGA3D_NV12:
1983 return (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2');
1984
1985 /* Video format with alpha */
1986 case SVGA3D_FORMAT_DEAD2: /* Old SVGA3D_AYUV */
1987
1988 case SVGA3D_ATI1:
1989 case SVGA3D_ATI2:
1990 /* Unknown; only in DX10 & 11 */
1991 break;
1992#endif
1993 default:
1994 AssertMsgFailed(("Unsupported format %d\n", format));
1995 break;
1996 }
1997#undef AssertTestFmt
1998}
1999
2000
2001#if 0
2002/**
2003 * Convert SVGA multi sample count value to its D3D equivalent
2004 */
2005D3DMULTISAMPLE_TYPE vmsvga3dMultipeSampleCount2D3D(uint32_t multisampleCount)
2006{
2007 AssertCompile(D3DMULTISAMPLE_2_SAMPLES == 2);
2008 AssertCompile(D3DMULTISAMPLE_16_SAMPLES == 16);
2009
2010 if (multisampleCount > 16)
2011 return D3DMULTISAMPLE_NONE;
2012
2013 /** @todo exact same mapping as d3d? */
2014 return (D3DMULTISAMPLE_TYPE)multisampleCount;
2015}
2016#endif
2017
2018/**
2019 * Destroy backend specific surface bits (part of SVGA_3D_CMD_SURFACE_DESTROY).
2020 *
2021 * @param pThisCC The device state.
2022 * @param pSurface The surface being destroyed.
2023 */
2024static DECLCALLBACK(void) vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface)
2025{
2026 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2027 AssertReturnVoid(pState);
2028
2029 PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
2030 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
2031
2032 switch (pSurface->enmOGLResType)
2033 {
2034 case VMSVGA3D_OGLRESTYPE_BUFFER:
2035 Assert(pSurface->oglId.buffer != OPENGL_INVALID_ID);
2036 pState->ext.glDeleteBuffers(1, &pSurface->oglId.buffer);
2037 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2038 break;
2039
2040 case VMSVGA3D_OGLRESTYPE_TEXTURE:
2041 Assert(pSurface->oglId.texture != OPENGL_INVALID_ID);
2042 glDeleteTextures(1, &pSurface->oglId.texture);
2043 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2044 if (pSurface->fEmulated)
2045 {
2046 if (pSurface->idEmulated)
2047 {
2048 glDeleteTextures(1, &pSurface->idEmulated);
2049 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2050 }
2051 }
2052 else
2053 {
2054 Assert(!pSurface->idEmulated);
2055 }
2056 break;
2057
2058 case VMSVGA3D_OGLRESTYPE_RENDERBUFFER:
2059 Assert(pSurface->oglId.renderbuffer != OPENGL_INVALID_ID);
2060 pState->ext.glDeleteRenderbuffers(1, &pSurface->oglId.renderbuffer);
2061 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2062 break;
2063
2064 default:
2065 AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface),
2066 ("hint=%#x, type=%d\n",
2067 (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK), pSurface->enmOGLResType));
2068 break;
2069 }
2070}
2071
2072
2073static DECLCALLBACK(int) vmsvga3dBackSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
2074 uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
2075{
2076 int rc;
2077
2078 LogFunc(("Copy %d boxes from sid=%u face=%u mipmap=%u to sid=%u face=%u mipmap=%u\n",
2079 cCopyBoxes, src.sid, src.face, src.mipmap, dest.sid, dest.face, dest.mipmap));
2080
2081 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2082 AssertReturn(pState, VERR_INVALID_STATE);
2083
2084 PVMSVGA3DSURFACE pSurfaceSrc;
2085 rc = vmsvga3dSurfaceFromSid(pState, src.sid, &pSurfaceSrc);
2086 AssertRCReturn(rc, rc);
2087
2088 PVMSVGA3DSURFACE pSurfaceDst;
2089 rc = vmsvga3dSurfaceFromSid(pState, dest.sid, &pSurfaceDst);
2090 AssertRCReturn(rc, rc);
2091
2092 if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurfaceSrc))
2093 {
2094 /* The source surface is still in memory. */
2095 PVMSVGA3DMIPMAPLEVEL pMipmapLevelSrc;
2096 rc = vmsvga3dMipmapLevel(pSurfaceSrc, src.face, src.mipmap, &pMipmapLevelSrc);
2097 AssertRCReturn(rc, rc);
2098
2099 PVMSVGA3DMIPMAPLEVEL pMipmapLevelDst;
2100 rc = vmsvga3dMipmapLevel(pSurfaceDst, dest.face, dest.mipmap, &pMipmapLevelDst);
2101 AssertRCReturn(rc, rc);
2102
2103 /* The copy operation is performed on the shared context. */
2104 PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
2105 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
2106
2107 /* Use glTexSubImage to upload the data to the destination texture.
2108 * The latter must be an OpenGL texture.
2109 */
2110 if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurfaceDst))
2111 {
2112 LogFunc(("dest sid=%u type=0x%x format=%d -> create texture\n", dest.sid, pSurfaceDst->surfaceFlags, pSurfaceDst->format));
2113 rc = vmsvga3dBackCreateTexture(pThisCC, pContext, pContext->id, pSurfaceDst);
2114 AssertRCReturn(rc, rc);
2115 }
2116
2117 GLenum target;
2118 if (pSurfaceDst->targetGL == GL_TEXTURE_CUBE_MAP)
2119 target = vmsvga3dCubemapFaceFromIndex(dest.face);
2120 else
2121 {
2122 AssertMsg(pSurfaceDst->targetGL == GL_TEXTURE_2D, ("Test %#x\n", pSurfaceDst->targetGL));
2123 target = pSurfaceDst->targetGL;
2124 }
2125
2126 /* Save the unpacking parameters and set what we need here. */
2127 VMSVGAPACKPARAMS SavedParams;
2128 vmsvga3dOglSetUnpackParams(pState, pContext,
2129 pMipmapLevelSrc->mipmapSize.width,
2130 target == GL_TEXTURE_3D ? pMipmapLevelSrc->mipmapSize.height : 0,
2131 &SavedParams);
2132
2133 glBindTexture(pSurfaceDst->targetGL, pSurfaceDst->oglId.texture);
2134 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2135
2136 for (uint32_t i = 0; i < cCopyBoxes; ++i)
2137 {
2138 SVGA3dCopyBox clipBox = pBox[i];
2139 vmsvgaR3ClipCopyBox(&pMipmapLevelSrc->mipmapSize, &pMipmapLevelDst->mipmapSize, &clipBox);
2140 if ( !clipBox.w
2141 || !clipBox.h
2142 || !clipBox.d)
2143 {
2144 LogFunc(("Skipped empty box.\n"));
2145 continue;
2146 }
2147
2148 LogFunc(("copy box %d,%d,%d %dx%d to %d,%d,%d\n",
2149 clipBox.srcx, clipBox.srcy, clipBox.srcz, clipBox.w, clipBox.h, clipBox.x, clipBox.y, clipBox.z));
2150
2151 uint32_t const u32BlockX = clipBox.srcx / pSurfaceSrc->cxBlock;
2152 uint32_t const u32BlockY = clipBox.srcy / pSurfaceSrc->cyBlock;
2153 uint32_t const u32BlockZ = clipBox.srcz;
2154 Assert(u32BlockX * pSurfaceSrc->cxBlock == clipBox.srcx);
2155 Assert(u32BlockY * pSurfaceSrc->cyBlock == clipBox.srcy);
2156
2157 uint8_t const *pSrcBits = (uint8_t *)pMipmapLevelSrc->pSurfaceData
2158 + pMipmapLevelSrc->cbSurfacePlane * u32BlockZ
2159 + pMipmapLevelSrc->cbSurfacePitch * u32BlockY
2160 + pSurfaceSrc->cbBlock * u32BlockX;
2161
2162 if (target == GL_TEXTURE_3D)
2163 {
2164 if ( pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2165 || pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2166 || pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2167 {
2168 uint32_t const cBlocksX = (clipBox.w + pSurfaceSrc->cxBlock - 1) / pSurfaceSrc->cxBlock;
2169 uint32_t const cBlocksY = (clipBox.h + pSurfaceSrc->cyBlock - 1) / pSurfaceSrc->cyBlock;
2170 uint32_t const imageSize = cBlocksX * cBlocksY * clipBox.d * pSurfaceSrc->cbBlock;
2171 pState->ext.glCompressedTexSubImage3D(target, dest.mipmap,
2172 clipBox.x, clipBox.y, clipBox.z,
2173 clipBox.w, clipBox.h, clipBox.d,
2174 pSurfaceSrc->internalFormatGL, (GLsizei)imageSize, pSrcBits);
2175 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2176 }
2177 else
2178 {
2179 pState->ext.glTexSubImage3D(target, dest.mipmap,
2180 clipBox.x, clipBox.y, clipBox.z,
2181 clipBox.w, clipBox.h, clipBox.d,
2182 pSurfaceSrc->formatGL, pSurfaceSrc->typeGL, pSrcBits);
2183 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2184 }
2185 }
2186 else
2187 {
2188 if ( pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2189 || pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2190 || pSurfaceDst->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2191 {
2192 uint32_t const cBlocksX = (clipBox.w + pSurfaceSrc->cxBlock - 1) / pSurfaceSrc->cxBlock;
2193 uint32_t const cBlocksY = (clipBox.h + pSurfaceSrc->cyBlock - 1) / pSurfaceSrc->cyBlock;
2194 uint32_t const imageSize = cBlocksX * cBlocksY * pSurfaceSrc->cbBlock;
2195 pState->ext.glCompressedTexSubImage2D(target, dest.mipmap,
2196 clipBox.x, clipBox.y, clipBox.w, clipBox.h,
2197 pSurfaceSrc->internalFormatGL, (GLsizei)imageSize, pSrcBits);
2198 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2199 }
2200 else
2201 {
2202 glTexSubImage2D(target, dest.mipmap,
2203 clipBox.x, clipBox.y, clipBox.w, clipBox.h,
2204 pSurfaceSrc->formatGL, pSurfaceSrc->typeGL, pSrcBits);
2205 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2206 }
2207 }
2208 }
2209
2210 glBindTexture(pSurfaceDst->targetGL, 0);
2211 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2212
2213 vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
2214
2215 return VINF_SUCCESS;
2216 }
2217
2218 PVGASTATE pThis = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVGASTATE);
2219 for (uint32_t i = 0; i < cCopyBoxes; i++)
2220 {
2221 SVGA3dBox destBox, srcBox;
2222
2223 srcBox.x = pBox[i].srcx;
2224 srcBox.y = pBox[i].srcy;
2225 srcBox.z = pBox[i].srcz;
2226 srcBox.w = pBox[i].w;
2227 srcBox.h = pBox[i].h;
2228 srcBox.d = pBox[i].d;
2229
2230 destBox.x = pBox[i].x;
2231 destBox.y = pBox[i].y;
2232 destBox.z = pBox[i].z;
2233 destBox.w = pBox[i].w;
2234 destBox.h = pBox[i].h;
2235 destBox.d = pBox[i].d;
2236
2237 /* No stretching is required, therefore use SVGA3D_STRETCH_BLT_POINT which translated to GL_NEAREST. */
2238 rc = vmsvga3dSurfaceStretchBlt(pThis, pThisCC, &dest, &destBox, &src, &srcBox, SVGA3D_STRETCH_BLT_POINT);
2239 AssertRCReturn(rc, rc);
2240 }
2241 return VINF_SUCCESS;
2242}
2243
2244
2245/**
2246 * Saves texture unpacking parameters and loads the specified ones.
2247 *
2248 * @param pState The VMSVGA3D state structure.
2249 * @param pContext The active context.
2250 * @param cxRow The number of pixels in a row. 0 for the entire width.
2251 * @param cyImage The height of the image in pixels. 0 for the entire height.
2252 * @param pSave Where to save stuff.
2253 */
2254void vmsvga3dOglSetUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, GLint cxRow, GLint cyImage,
2255 PVMSVGAPACKPARAMS pSave)
2256{
2257 RT_NOREF(pState);
2258
2259 /*
2260 * Save (ignore errors, setting the defaults we want and avoids restore).
2261 */
2262 pSave->iAlignment = 1;
2263 VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_UNPACK_ALIGNMENT, &pSave->iAlignment), pState, pContext);
2264 pSave->cxRow = 0;
2265 VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_UNPACK_ROW_LENGTH, &pSave->cxRow), pState, pContext);
2266 pSave->cyImage = 0;
2267 VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &pSave->cyImage), pState, pContext);
2268
2269#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2270 pSave->fSwapBytes = GL_FALSE;
2271 glGetBooleanv(GL_UNPACK_SWAP_BYTES, &pSave->fSwapBytes);
2272 Assert(pSave->fSwapBytes == GL_FALSE);
2273
2274 pSave->fLsbFirst = GL_FALSE;
2275 glGetBooleanv(GL_UNPACK_LSB_FIRST, &pSave->fLsbFirst);
2276 Assert(pSave->fLsbFirst == GL_FALSE);
2277
2278 pSave->cSkipRows = 0;
2279 glGetIntegerv(GL_UNPACK_SKIP_ROWS, &pSave->cSkipRows);
2280 Assert(pSave->cSkipRows == 0);
2281
2282 pSave->cSkipPixels = 0;
2283 glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &pSave->cSkipPixels);
2284 Assert(pSave->cSkipPixels == 0);
2285
2286 pSave->cSkipImages = 0;
2287 glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &pSave->cSkipImages);
2288 Assert(pSave->cSkipImages == 0);
2289
2290 VMSVGA3D_CLEAR_GL_ERRORS();
2291#endif
2292
2293 /*
2294 * Setup unpack.
2295 *
2296 * Note! We use 1 as alignment here because we currently don't do any
2297 * aligning of line pitches anywhere.
2298 */
2299 pSave->fChanged = 0;
2300 if (pSave->iAlignment != 1)
2301 {
2302 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1), pState, pContext);
2303 pSave->fChanged |= VMSVGAPACKPARAMS_ALIGNMENT;
2304 }
2305 if (pSave->cxRow != cxRow)
2306 {
2307 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, cxRow), pState, pContext);
2308 pSave->fChanged |= VMSVGAPACKPARAMS_ROW_LENGTH;
2309 }
2310 if (pSave->cyImage != cyImage)
2311 {
2312 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, cyImage), pState, pContext);
2313 pSave->fChanged |= VMSVGAPACKPARAMS_IMAGE_HEIGHT;
2314 }
2315#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2316 if (pSave->fSwapBytes != 0)
2317 {
2318 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE), pState, pContext);
2319 pSave->fChanged |= VMSVGAPACKPARAMS_SWAP_BYTES;
2320 }
2321 if (pSave->fLsbFirst != 0)
2322 {
2323 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE), pState, pContext);
2324 pSave->fChanged |= VMSVGAPACKPARAMS_LSB_FIRST;
2325 }
2326 if (pSave->cSkipRows != 0)
2327 {
2328 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_ROWS, 0), pState, pContext);
2329 pSave->fChanged |= VMSVGAPACKPARAMS_SKIP_ROWS;
2330 }
2331 if (pSave->cSkipPixels != 0)
2332 {
2333 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0), pState, pContext);
2334 pSave->fChanged |= VMSVGAPACKPARAMS_SKIP_PIXELS;
2335 }
2336 if (pSave->cSkipImages != 0)
2337 {
2338 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0), pState, pContext);
2339 pSave->fChanged |= VMSVGAPACKPARAMS_SKIP_IMAGES;
2340 }
2341#endif
2342}
2343
2344
2345/**
2346 * Restores texture unpacking parameters.
2347 *
2348 * @param pState The VMSVGA3D state structure.
2349 * @param pContext The active context.
2350 * @param pSave Where stuff was saved.
2351 */
2352void vmsvga3dOglRestoreUnpackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext,
2353 PCVMSVGAPACKPARAMS pSave)
2354{
2355 RT_NOREF(pState);
2356
2357 if (pSave->fChanged & VMSVGAPACKPARAMS_ALIGNMENT)
2358 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, pSave->iAlignment), pState, pContext);
2359 if (pSave->fChanged & VMSVGAPACKPARAMS_ROW_LENGTH)
2360 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, pSave->cxRow), pState, pContext);
2361 if (pSave->fChanged & VMSVGAPACKPARAMS_IMAGE_HEIGHT)
2362 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, pSave->cyImage), pState, pContext);
2363#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2364 if (pSave->fChanged & VMSVGAPACKPARAMS_SWAP_BYTES)
2365 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SWAP_BYTES, pSave->fSwapBytes), pState, pContext);
2366 if (pSave->fChanged & VMSVGAPACKPARAMS_LSB_FIRST)
2367 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_LSB_FIRST, pSave->fLsbFirst), pState, pContext);
2368 if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_ROWS)
2369 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_ROWS, pSave->cSkipRows), pState, pContext);
2370 if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_PIXELS)
2371 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_PIXELS, pSave->cSkipPixels), pState, pContext);
2372 if (pSave->fChanged & VMSVGAPACKPARAMS_SKIP_IMAGES)
2373 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_UNPACK_SKIP_IMAGES, pSave->cSkipImages), pState, pContext);
2374#endif
2375}
2376
2377/**
2378 * Create D3D/OpenGL texture object for the specified surface.
2379 *
2380 * Surfaces are created when needed.
2381 *
2382 * @param pThisCC The device context.
2383 * @param pContext The context.
2384 * @param idAssociatedContext Probably the same as pContext->id.
2385 * @param pSurface The surface to create the texture for.
2386 */
2387static DECLCALLBACK(int) vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
2388 PVMSVGA3DSURFACE pSurface)
2389{
2390 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2391
2392 RT_NOREF(idAssociatedContext);
2393
2394 LogFunc(("sid=%u\n", pSurface->id));
2395
2396 uint32_t const numMipLevels = pSurface->cLevels;
2397
2398 /* Fugure out what kind of texture we are creating. */
2399 GLenum binding;
2400 GLenum target;
2401 if (pSurface->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
2402 {
2403 Assert(pSurface->cFaces == 6);
2404
2405 binding = GL_TEXTURE_BINDING_CUBE_MAP;
2406 target = GL_TEXTURE_CUBE_MAP;
2407 }
2408 else
2409 {
2410 if (pSurface->paMipmapLevels[0].mipmapSize.depth > 1)
2411 {
2412 binding = GL_TEXTURE_BINDING_3D;
2413 target = GL_TEXTURE_3D;
2414 }
2415 else
2416 {
2417 Assert(pSurface->cFaces == 1);
2418
2419 binding = GL_TEXTURE_BINDING_2D;
2420 target = GL_TEXTURE_2D;
2421 }
2422 }
2423
2424 /* All textures are created in the SharedCtx. */
2425 uint32_t idPrevCtx = pState->idActiveContext;
2426 pContext = &pState->SharedCtx;
2427 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
2428
2429 glGenTextures(1, &pSurface->oglId.texture);
2430 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2431 if (pSurface->fEmulated)
2432 {
2433 glGenTextures(1, &pSurface->idEmulated);
2434 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2435 }
2436 pSurface->enmOGLResType = VMSVGA3D_OGLRESTYPE_TEXTURE;
2437
2438 GLint activeTexture = 0;
2439 glGetIntegerv(binding, &activeTexture);
2440 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2441
2442 /* Must bind texture to the current context in order to change it. */
2443 glBindTexture(target, pSurface->oglId.texture);
2444 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2445
2446 /* Set the unpacking parameters. */
2447 VMSVGAPACKPARAMS SavedParams;
2448 vmsvga3dOglSetUnpackParams(pState, pContext, 0, 0, &SavedParams);
2449
2450 /** @todo Set the mip map generation filter settings. */
2451
2452 /* Set the mipmap base and max level parameters. */
2453 glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
2454 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2455 glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, pSurface->cLevels - 1);
2456 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2457
2458 if (pSurface->fDirty)
2459 LogFunc(("sync dirty texture\n"));
2460
2461 /* Always allocate and initialize all mipmap levels; non-initialized mipmap levels used as render targets cause failures. */
2462 if (target == GL_TEXTURE_3D)
2463 {
2464 for (uint32_t i = 0; i < numMipLevels; ++i)
2465 {
2466 /* Allocate and initialize texture memory. Passing the zero filled pSurfaceData avoids
2467 * exposing random host memory to the guest and helps a with the fedora 21 surface
2468 * corruption issues (launchpad, background, search field, login).
2469 */
2470 PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[i];
2471
2472 LogFunc(("sync dirty 3D texture mipmap level %d (pitch %x) (dirty %d)\n",
2473 i, pMipLevel->cbSurfacePitch, pMipLevel->fDirty));
2474
2475 if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2476 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2477 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2478 {
2479 pState->ext.glCompressedTexImage3D(GL_TEXTURE_3D,
2480 i,
2481 pSurface->internalFormatGL,
2482 pMipLevel->mipmapSize.width,
2483 pMipLevel->mipmapSize.height,
2484 pMipLevel->mipmapSize.depth,
2485 0,
2486 pMipLevel->cbSurface,
2487 pMipLevel->pSurfaceData);
2488 }
2489 else
2490 {
2491 pState->ext.glTexImage3D(GL_TEXTURE_3D,
2492 i,
2493 pSurface->internalFormatGL,
2494 pMipLevel->mipmapSize.width,
2495 pMipLevel->mipmapSize.height,
2496 pMipLevel->mipmapSize.depth,
2497 0, /* border */
2498 pSurface->formatGL,
2499 pSurface->typeGL,
2500 pMipLevel->pSurfaceData);
2501 }
2502 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2503
2504 pMipLevel->fDirty = false;
2505 }
2506 }
2507 else if (target == GL_TEXTURE_CUBE_MAP)
2508 {
2509 for (uint32_t iFace = 0; iFace < 6; ++iFace)
2510 {
2511 GLenum const Face = vmsvga3dCubemapFaceFromIndex(iFace);
2512
2513 for (uint32_t i = 0; i < numMipLevels; ++i)
2514 {
2515 PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[iFace * numMipLevels + i];
2516 Assert(pMipLevel->mipmapSize.width == pMipLevel->mipmapSize.height);
2517 Assert(pMipLevel->mipmapSize.depth == 1);
2518
2519 LogFunc(("sync cube texture face %d mipmap level %d (dirty %d)\n",
2520 iFace, i, pMipLevel->fDirty));
2521
2522 if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2523 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2524 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2525 {
2526 pState->ext.glCompressedTexImage2D(Face,
2527 i,
2528 pSurface->internalFormatGL,
2529 pMipLevel->mipmapSize.width,
2530 pMipLevel->mipmapSize.height,
2531 0,
2532 pMipLevel->cbSurface,
2533 pMipLevel->pSurfaceData);
2534 }
2535 else
2536 {
2537 glTexImage2D(Face,
2538 i,
2539 pSurface->internalFormatGL,
2540 pMipLevel->mipmapSize.width,
2541 pMipLevel->mipmapSize.height,
2542 0,
2543 pSurface->formatGL,
2544 pSurface->typeGL,
2545 pMipLevel->pSurfaceData);
2546 }
2547 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2548
2549 pMipLevel->fDirty = false;
2550 }
2551 }
2552 }
2553 else if (target == GL_TEXTURE_2D)
2554 {
2555 for (uint32_t i = 0; i < numMipLevels; ++i)
2556 {
2557 /* Allocate and initialize texture memory. Passing the zero filled pSurfaceData avoids
2558 * exposing random host memory to the guest and helps a with the fedora 21 surface
2559 * corruption issues (launchpad, background, search field, login).
2560 */
2561 PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[i];
2562 Assert(pMipLevel->mipmapSize.depth == 1);
2563
2564 LogFunc(("sync dirty texture mipmap level %d (pitch %x) (dirty %d)\n",
2565 i, pMipLevel->cbSurfacePitch, pMipLevel->fDirty));
2566
2567 if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2568 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2569 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2570 {
2571 pState->ext.glCompressedTexImage2D(GL_TEXTURE_2D,
2572 i,
2573 pSurface->internalFormatGL,
2574 pMipLevel->mipmapSize.width,
2575 pMipLevel->mipmapSize.height,
2576 0,
2577 pMipLevel->cbSurface,
2578 pMipLevel->pSurfaceData);
2579 }
2580 else
2581 {
2582 glTexImage2D(GL_TEXTURE_2D,
2583 i,
2584 pSurface->internalFormatGL,
2585 pMipLevel->mipmapSize.width,
2586 pMipLevel->mipmapSize.height,
2587 0,
2588 pSurface->formatGL,
2589 pSurface->typeGL,
2590 NULL);
2591 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2592
2593 if (pSurface->fEmulated)
2594 {
2595 /* Bind the emulated texture and init it. */
2596 glBindTexture(GL_TEXTURE_2D, pSurface->idEmulated);
2597 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2598
2599 glTexImage2D(GL_TEXTURE_2D,
2600 i,
2601 pSurface->internalFormatGL,
2602 pMipLevel->mipmapSize.width,
2603 pMipLevel->mipmapSize.height,
2604 0,
2605 pSurface->formatGL,
2606 pSurface->typeGL,
2607 NULL);
2608 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2609 }
2610
2611 /* Fetch texture data: either to the actual or to the emulated texture.
2612 * The pSurfaceData buffer may be smaller than the entire texture
2613 * for emulated formats, in which case only part of the texture is synched.
2614 */
2615 uint32_t cBlocksX = pMipLevel->mipmapSize.width / pSurface->cxBlock;
2616 uint32_t cBlocksY = pMipLevel->mipmapSize.height / pSurface->cyBlock;
2617 glTexSubImage2D(GL_TEXTURE_2D,
2618 i,
2619 0,
2620 0,
2621 cBlocksX,
2622 cBlocksY,
2623 pSurface->formatGL,
2624 pSurface->typeGL,
2625 pMipLevel->pSurfaceData);
2626 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2627
2628 if (pSurface->fEmulated)
2629 {
2630 /* Update the actual texture using the format converter. */
2631 FormatConvUpdateTexture(pState, pContext, pSurface, i);
2632
2633 /* Rebind the actual texture. */
2634 glBindTexture(GL_TEXTURE_2D, pSurface->oglId.texture);
2635 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2636 }
2637 }
2638 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2639
2640 pMipLevel->fDirty = false;
2641 }
2642 }
2643
2644 pSurface->fDirty = false;
2645
2646 /* Restore unpacking parameters. */
2647 vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
2648
2649 /* Restore the old active texture. */
2650 glBindTexture(target, activeTexture);
2651 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2652
2653 pSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_TEXTURE;
2654 pSurface->targetGL = target;
2655 pSurface->bindingGL = binding;
2656
2657 if (idPrevCtx < pState->cContexts && pState->papContexts[idPrevCtx]->id == idPrevCtx)
2658 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pState->papContexts[idPrevCtx]);
2659 return VINF_SUCCESS;
2660}
2661
2662
2663/**
2664 * Backend worker for implementing SVGA_3D_CMD_SURFACE_STRETCHBLT.
2665 *
2666 * @returns VBox status code.
2667 * @param pThis The VGA device instance.
2668 * @param pState The VMSVGA3d state.
2669 * @param pDstSurface The destination host surface.
2670 * @param uDstFace The destination face (valid).
2671 * @param uDstMipmap The destination mipmap level (valid).
2672 * @param pDstBox The destination box.
2673 * @param pSrcSurface The source host surface.
2674 * @param uSrcFace The destination face (valid).
2675 * @param uSrcMipmap The source mimap level (valid).
2676 * @param pSrcBox The source box.
2677 * @param enmMode The strecht blt mode .
2678 * @param pContext The VMSVGA3d context (already current for OGL).
2679 */
2680static DECLCALLBACK(int) vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
2681 PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
2682 PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
2683 SVGA3dStretchBltMode enmMode, PVMSVGA3DCONTEXT pContext)
2684{
2685 RT_NOREF(pThis);
2686
2687 AssertReturn( RT_BOOL(pSrcSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
2688 == RT_BOOL(pDstSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL), VERR_NOT_IMPLEMENTED);
2689
2690 GLenum glAttachment = GL_COLOR_ATTACHMENT0;
2691 GLbitfield glMask = GL_COLOR_BUFFER_BIT;
2692 if (pDstSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
2693 {
2694 /** @todo Need GL_DEPTH_STENCIL_ATTACHMENT for depth/stencil formats? */
2695 glAttachment = GL_DEPTH_ATTACHMENT;
2696 glMask = GL_DEPTH_BUFFER_BIT;
2697 }
2698
2699 /* Activate the read and draw framebuffer objects. */
2700 pState->ext.glBindFramebuffer(GL_READ_FRAMEBUFFER, pContext->idReadFramebuffer);
2701 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2702 pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, pContext->idDrawFramebuffer);
2703 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2704
2705 /* Bind the source and destination objects to the right place. */
2706 GLenum textarget;
2707 if (pSrcSurface->targetGL == GL_TEXTURE_CUBE_MAP)
2708 textarget = vmsvga3dCubemapFaceFromIndex(uSrcFace);
2709 else
2710 {
2711 /// @todo later AssertMsg(pSrcSurface->targetGL == GL_TEXTURE_2D, ("%#x\n", pSrcSurface->targetGL));
2712 textarget = GL_TEXTURE_2D;
2713 }
2714 pState->ext.glFramebufferTexture2D(GL_READ_FRAMEBUFFER, glAttachment, textarget,
2715 pSrcSurface->oglId.texture, uSrcMipmap);
2716 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2717
2718 if (pDstSurface->targetGL == GL_TEXTURE_CUBE_MAP)
2719 textarget = vmsvga3dCubemapFaceFromIndex(uDstFace);
2720 else
2721 {
2722 /// @todo later AssertMsg(pDstSurface->targetGL == GL_TEXTURE_2D, ("%#x\n", pDstSurface->targetGL));
2723 textarget = GL_TEXTURE_2D;
2724 }
2725 pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, glAttachment, textarget,
2726 pDstSurface->oglId.texture, uDstMipmap);
2727 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2728
2729 Log(("src conv. (%d,%d)(%d,%d); dest conv (%d,%d)(%d,%d)\n",
2730 pSrcBox->x, D3D_TO_OGL_Y_COORD(pSrcSurface, pSrcBox->y + pSrcBox->h),
2731 pSrcBox->x + pSrcBox->w, D3D_TO_OGL_Y_COORD(pSrcSurface, pSrcBox->y),
2732 pDstBox->x, D3D_TO_OGL_Y_COORD(pDstSurface, pDstBox->y + pDstBox->h),
2733 pDstBox->x + pDstBox->w, D3D_TO_OGL_Y_COORD(pDstSurface, pDstBox->y)));
2734
2735 pState->ext.glBlitFramebuffer(pSrcBox->x,
2736 pSrcBox->y,
2737 pSrcBox->x + pSrcBox->w, /* exclusive. */
2738 pSrcBox->y + pSrcBox->h,
2739 pDstBox->x,
2740 pDstBox->y,
2741 pDstBox->x + pDstBox->w, /* exclusive. */
2742 pDstBox->y + pDstBox->h,
2743 glMask,
2744 (enmMode == SVGA3D_STRETCH_BLT_POINT) ? GL_NEAREST : GL_LINEAR);
2745 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2746
2747 /* Reset the frame buffer association */
2748 pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, pContext->idFramebuffer);
2749 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
2750
2751 return VINF_SUCCESS;
2752}
2753
2754/**
2755 * Save texture packing parameters and loads those appropriate for the given
2756 * surface.
2757 *
2758 * @param pState The VMSVGA3D state structure.
2759 * @param pContext The active context.
2760 * @param pSurface The surface.
2761 * @param pSave Where to save stuff.
2762 */
2763void vmsvga3dOglSetPackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
2764 PVMSVGAPACKPARAMS pSave)
2765{
2766 RT_NOREF(pState);
2767 /*
2768 * Save (ignore errors, setting the defaults we want and avoids restore).
2769 */
2770 pSave->iAlignment = 1;
2771 VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_PACK_ALIGNMENT, &pSave->iAlignment), pState, pContext);
2772 pSave->cxRow = 0;
2773 VMSVGA3D_ASSERT_GL_CALL(glGetIntegerv(GL_PACK_ROW_LENGTH, &pSave->cxRow), pState, pContext);
2774
2775#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2776 pSave->cyImage = 0;
2777 glGetIntegerv(GL_PACK_IMAGE_HEIGHT, &pSave->cyImage);
2778 Assert(pSave->cyImage == 0);
2779
2780 pSave->fSwapBytes = GL_FALSE;
2781 glGetBooleanv(GL_PACK_SWAP_BYTES, &pSave->fSwapBytes);
2782 Assert(pSave->fSwapBytes == GL_FALSE);
2783
2784 pSave->fLsbFirst = GL_FALSE;
2785 glGetBooleanv(GL_PACK_LSB_FIRST, &pSave->fLsbFirst);
2786 Assert(pSave->fLsbFirst == GL_FALSE);
2787
2788 pSave->cSkipRows = 0;
2789 glGetIntegerv(GL_PACK_SKIP_ROWS, &pSave->cSkipRows);
2790 Assert(pSave->cSkipRows == 0);
2791
2792 pSave->cSkipPixels = 0;
2793 glGetIntegerv(GL_PACK_SKIP_PIXELS, &pSave->cSkipPixels);
2794 Assert(pSave->cSkipPixels == 0);
2795
2796 pSave->cSkipImages = 0;
2797 glGetIntegerv(GL_PACK_SKIP_IMAGES, &pSave->cSkipImages);
2798 Assert(pSave->cSkipImages == 0);
2799
2800 VMSVGA3D_CLEAR_GL_ERRORS();
2801#endif
2802
2803 /*
2804 * Setup unpack.
2805 *
2806 * Note! We use 1 as alignment here because we currently don't do any
2807 * aligning of line pitches anywhere.
2808 */
2809 NOREF(pSurface);
2810 if (pSave->iAlignment != 1)
2811 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_ALIGNMENT, 1), pState, pContext);
2812 if (pSave->cxRow != 0)
2813 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_ROW_LENGTH, 0), pState, pContext);
2814#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2815 if (pSave->cyImage != 0)
2816 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0), pState, pContext);
2817 if (pSave->fSwapBytes != 0)
2818 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE), pState, pContext);
2819 if (pSave->fLsbFirst != 0)
2820 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE), pState, pContext);
2821 if (pSave->cSkipRows != 0)
2822 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_ROWS, 0), pState, pContext);
2823 if (pSave->cSkipPixels != 0)
2824 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_PIXELS, 0), pState, pContext);
2825 if (pSave->cSkipImages != 0)
2826 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_IMAGES, 0), pState, pContext);
2827#endif
2828}
2829
2830
2831/**
2832 * Restores texture packing parameters.
2833 *
2834 * @param pState The VMSVGA3D state structure.
2835 * @param pContext The active context.
2836 * @param pSurface The surface.
2837 * @param pSave Where stuff was saved.
2838 */
2839void vmsvga3dOglRestorePackParams(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface,
2840 PCVMSVGAPACKPARAMS pSave)
2841{
2842 RT_NOREF(pState, pSurface);
2843 if (pSave->iAlignment != 1)
2844 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_ALIGNMENT, pSave->iAlignment), pState, pContext);
2845 if (pSave->cxRow != 0)
2846 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_ROW_LENGTH, pSave->cxRow), pState, pContext);
2847#ifdef VMSVGA3D_PARANOID_TEXTURE_PACKING
2848 if (pSave->cyImage != 0)
2849 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_IMAGE_HEIGHT, pSave->cyImage), pState, pContext);
2850 if (pSave->fSwapBytes != 0)
2851 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SWAP_BYTES, pSave->fSwapBytes), pState, pContext);
2852 if (pSave->fLsbFirst != 0)
2853 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_LSB_FIRST, pSave->fLsbFirst), pState, pContext);
2854 if (pSave->cSkipRows != 0)
2855 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_ROWS, pSave->cSkipRows), pState, pContext);
2856 if (pSave->cSkipPixels != 0)
2857 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_PIXELS, pSave->cSkipPixels), pState, pContext);
2858 if (pSave->cSkipImages != 0)
2859 VMSVGA3D_ASSERT_GL_CALL(glPixelStorei(GL_PACK_SKIP_IMAGES, pSave->cSkipImages), pState, pContext);
2860#endif
2861}
2862
2863
2864/**
2865 * Backend worker for implementing SVGA_3D_CMD_SURFACE_DMA that copies one box.
2866 *
2867 * @returns Failure status code or @a rc.
2868 * @param pThis The shared VGA/VMSVGA instance data.
2869 * @param pThisCC The VGA/VMSVGA state for ring-3.
2870 * @param pState The VMSVGA3d state.
2871 * @param pSurface The host surface.
2872 * @param pMipLevel Mipmap level. The caller knows it already.
2873 * @param uHostFace The host face (valid).
2874 * @param uHostMipmap The host mipmap level (valid).
2875 * @param GuestPtr The guest pointer.
2876 * @param cbGuestPitch The guest pitch.
2877 * @param transfer The transfer direction.
2878 * @param pBox The box to copy (clipped, valid, except for guest's srcx, srcy, srcz).
2879 * @param pContext The context (for OpenGL).
2880 * @param rc The current rc for all boxes.
2881 * @param iBox The current box number (for Direct 3D).
2882 */
2883static DECLCALLBACK(int) vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
2884 PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
2885 SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
2886 SVGA3dCopyBox const *pBox, PVMSVGA3DCONTEXT pContext, int rc, int iBox)
2887{
2888 RT_NOREF(iBox);
2889
2890 switch (pSurface->enmOGLResType)
2891 {
2892 case VMSVGA3D_OGLRESTYPE_TEXTURE:
2893 {
2894 uint32_t cbSurfacePitch;
2895 uint8_t *pDoubleBuffer;
2896 uint64_t offHst;
2897
2898 uint32_t const u32HostBlockX = pBox->x / pSurface->cxBlock;
2899 uint32_t const u32HostBlockY = pBox->y / pSurface->cyBlock;
2900 uint32_t const u32HostZ = pBox->z;
2901 Assert(u32HostBlockX * pSurface->cxBlock == pBox->x);
2902 Assert(u32HostBlockY * pSurface->cyBlock == pBox->y);
2903
2904 uint32_t const u32GuestBlockX = pBox->srcx / pSurface->cxBlock;
2905 uint32_t const u32GuestBlockY = pBox->srcy / pSurface->cyBlock;
2906 uint32_t const u32GuestZ = pBox->srcz / pSurface->cyBlock;
2907 Assert(u32GuestBlockX * pSurface->cxBlock == pBox->srcx);
2908 Assert(u32GuestBlockY * pSurface->cyBlock == pBox->srcy);
2909
2910 uint32_t const cBlocksX = (pBox->w + pSurface->cxBlock - 1) / pSurface->cxBlock;
2911 uint32_t const cBlocksY = (pBox->h + pSurface->cyBlock - 1) / pSurface->cyBlock;
2912 AssertMsgReturn(cBlocksX && cBlocksY, ("Empty box %dx%d\n", pBox->w, pBox->h), VERR_INTERNAL_ERROR);
2913
2914 GLenum texImageTarget;
2915 if (pSurface->targetGL == GL_TEXTURE_3D)
2916 {
2917 texImageTarget = GL_TEXTURE_3D;
2918 }
2919 else if (pSurface->targetGL == GL_TEXTURE_CUBE_MAP)
2920 {
2921 texImageTarget = vmsvga3dCubemapFaceFromIndex(uHostFace);
2922 }
2923 else
2924 {
2925 AssertMsg(pSurface->targetGL == GL_TEXTURE_2D, ("%#x\n", pSurface->targetGL));
2926 texImageTarget = GL_TEXTURE_2D;
2927 }
2928
2929 /* The buffer must be large enough to hold entire texture in the OpenGL format. */
2930 pDoubleBuffer = (uint8_t *)RTMemAlloc(pSurface->cbBlockGL * pMipLevel->cBlocks);
2931 AssertReturn(pDoubleBuffer, VERR_NO_MEMORY);
2932
2933 if (transfer == SVGA3D_READ_HOST_VRAM)
2934 {
2935 /* Read the entire texture to the double buffer. */
2936 GLint activeTexture;
2937
2938 /* Must bind texture to the current context in order to read it. */
2939 glGetIntegerv(pSurface->bindingGL, &activeTexture);
2940 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2941
2942 glBindTexture(pSurface->targetGL, GLTextureId(pSurface));
2943 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2944
2945 if (pSurface->fEmulated)
2946 {
2947 FormatConvReadTexture(pState, pContext, pSurface, uHostMipmap);
2948 }
2949
2950 /* Set row length and alignment of the input data. */
2951 VMSVGAPACKPARAMS SavedParams;
2952 vmsvga3dOglSetPackParams(pState, pContext, pSurface, &SavedParams);
2953
2954 if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
2955 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
2956 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2957 {
2958 pState->ext.glGetCompressedTexImage(texImageTarget, uHostMipmap, pDoubleBuffer);
2959 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2960 }
2961 else
2962 {
2963 glGetTexImage(texImageTarget, uHostMipmap, pSurface->formatGL, pSurface->typeGL, pDoubleBuffer);
2964 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2965 }
2966
2967 vmsvga3dOglRestorePackParams(pState, pContext, pSurface, &SavedParams);
2968
2969 /* Restore the old active texture. */
2970 glBindTexture(pSurface->targetGL, activeTexture);
2971 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
2972
2973 offHst = u32HostBlockX * pSurface->cbBlock + u32HostBlockY * pMipLevel->cbSurfacePitch + u32HostZ * pMipLevel->cbSurfacePlane;
2974 cbSurfacePitch = pMipLevel->cbSurfacePitch;
2975 }
2976 else
2977 {
2978 /* The buffer will contain only the copied rectangle. */
2979 offHst = 0;
2980 cbSurfacePitch = cBlocksX * pSurface->cbBlock;
2981 }
2982
2983 uint64_t offGst = u32GuestBlockX * pSurface->cbBlock + u32GuestBlockY * cbGuestPitch + u32GuestZ * cbGuestPitch * pMipLevel->mipmapSize.height;
2984
2985 for (uint32_t iPlane = 0; iPlane < pBox->d; ++iPlane)
2986 {
2987 AssertBreak(offHst < UINT32_MAX);
2988 AssertBreak(offGst < UINT32_MAX);
2989
2990 rc = vmsvgaR3GmrTransfer(pThis,
2991 pThisCC,
2992 transfer,
2993 pDoubleBuffer,
2994 pMipLevel->cbSurface,
2995 (uint32_t)offHst,
2996 cbSurfacePitch,
2997 GuestPtr,
2998 (uint32_t)offGst,
2999 cbGuestPitch,
3000 cBlocksX * pSurface->cbBlock,
3001 cBlocksY);
3002 AssertRC(rc);
3003
3004 offHst += pMipLevel->cbSurfacePlane;
3005 offGst += pMipLevel->mipmapSize.height * cbGuestPitch;
3006 }
3007
3008 /* Update the opengl surface data. */
3009 if (transfer == SVGA3D_WRITE_HOST_VRAM)
3010 {
3011 GLint activeTexture = 0;
3012 glGetIntegerv(pSurface->bindingGL, &activeTexture);
3013 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3014
3015 /* Must bind texture to the current context in order to change it. */
3016 glBindTexture(pSurface->targetGL, GLTextureId(pSurface));
3017 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3018
3019 LogFunc(("copy texture mipmap level %d (pitch %x)\n", uHostMipmap, pMipLevel->cbSurfacePitch));
3020
3021 /* Set row length and alignment of the input data. */
3022 /* We do not need to set ROW_LENGTH to w here, because the image in pDoubleBuffer is tightly packed. */
3023 VMSVGAPACKPARAMS SavedParams;
3024 vmsvga3dOglSetUnpackParams(pState, pContext, 0, 0, &SavedParams);
3025
3026 if (texImageTarget == GL_TEXTURE_3D)
3027 {
3028 if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
3029 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
3030 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
3031 {
3032 pState->ext.glCompressedTexSubImage3D(texImageTarget,
3033 uHostMipmap,
3034 pBox->x,
3035 pBox->y,
3036 pBox->z,
3037 pBox->w,
3038 pBox->h,
3039 pBox->d,
3040 pSurface->internalFormatGL,
3041 cbSurfacePitch * cBlocksY * pBox->d,
3042 pDoubleBuffer);
3043 }
3044 else
3045 {
3046 pState->ext.glTexSubImage3D(texImageTarget,
3047 uHostMipmap,
3048 u32HostBlockX,
3049 u32HostBlockY,
3050 pBox->z,
3051 cBlocksX,
3052 cBlocksY,
3053 pBox->d,
3054 pSurface->formatGL,
3055 pSurface->typeGL,
3056 pDoubleBuffer);
3057 }
3058 }
3059 else
3060 {
3061 if ( pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
3062 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
3063 || pSurface->internalFormatGL == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
3064 {
3065 pState->ext.glCompressedTexSubImage2D(texImageTarget,
3066 uHostMipmap,
3067 pBox->x,
3068 pBox->y,
3069 pBox->w,
3070 pBox->h,
3071 pSurface->internalFormatGL,
3072 cbSurfacePitch * cBlocksY,
3073 pDoubleBuffer);
3074 }
3075 else
3076 {
3077 glTexSubImage2D(texImageTarget,
3078 uHostMipmap,
3079 u32HostBlockX,
3080 u32HostBlockY,
3081 cBlocksX,
3082 cBlocksY,
3083 pSurface->formatGL,
3084 pSurface->typeGL,
3085 pDoubleBuffer);
3086 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3087
3088 if (pSurface->fEmulated)
3089 {
3090 /* Convert the texture to the actual texture if necessary */
3091 FormatConvUpdateTexture(pState, pContext, pSurface, uHostMipmap);
3092 }
3093 }
3094 }
3095 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3096
3097 /* Restore old values. */
3098 vmsvga3dOglRestoreUnpackParams(pState, pContext, &SavedParams);
3099
3100 /* Restore the old active texture. */
3101 glBindTexture(pSurface->targetGL, activeTexture);
3102 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
3103 }
3104
3105 Log4(("first line:\n%.*Rhxd\n", cBlocksX * pSurface->cbBlock, pDoubleBuffer));
3106
3107 /* Free the double buffer. */
3108 RTMemFree(pDoubleBuffer);
3109 break;
3110 }
3111
3112 case VMSVGA3D_OGLRESTYPE_BUFFER:
3113 {
3114 /* Buffers are uncompressed. */
3115 AssertReturn(pSurface->cxBlock == 1 && pSurface->cyBlock == 1, VERR_INTERNAL_ERROR);
3116
3117 /* Caller already clipped pBox and buffers are 1-dimensional. */
3118 Assert(pBox->y == 0 && pBox->h == 1 && pBox->z == 0 && pBox->d == 1);
3119
3120 VMSVGA3D_CLEAR_GL_ERRORS();
3121 pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pSurface->oglId.buffer);
3122 if (VMSVGA3D_GL_IS_SUCCESS(pContext))
3123 {
3124 GLenum enmGlTransfer = (transfer == SVGA3D_READ_HOST_VRAM) ? GL_READ_ONLY : GL_WRITE_ONLY;
3125 uint8_t *pbData = (uint8_t *)pState->ext.glMapBuffer(GL_ARRAY_BUFFER, enmGlTransfer);
3126 if (RT_LIKELY(pbData != NULL))
3127 {
3128#if defined(VBOX_STRICT) && defined(RT_OS_DARWIN)
3129 GLint cbStrictBufSize;
3130 glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &cbStrictBufSize);
3131 Assert(VMSVGA3D_GL_IS_SUCCESS(pContext));
3132 AssertMsg(cbStrictBufSize >= (int32_t)pMipLevel->cbSurface,
3133 ("cbStrictBufSize=%#x cbSurface=%#x pContext->id=%#x\n", (uint32_t)cbStrictBufSize, pMipLevel->cbSurface, pContext->id));
3134#endif
3135 Log(("Lock %s memory for rectangle (%d,%d)(%d,%d)\n",
3136 (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_VERTEXBUFFER ? "vertex" :
3137 (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_INDEXBUFFER ? "index" : "buffer",
3138 pBox->x, pBox->y, pBox->x + pBox->w, pBox->y + pBox->h));
3139
3140 /* The caller already copied the data to the pMipLevel->pSurfaceData buffer, see VMSVGA3DSURFACE_NEEDS_DATA. */
3141 uint32_t const offHst = pBox->x * pSurface->cbBlock;
3142 uint32_t const cbWidth = pBox->w * pSurface->cbBlock;
3143
3144 memcpy(pbData + offHst, (uint8_t *)pMipLevel->pSurfaceData + offHst, cbWidth);
3145
3146 Log4(("Buffer updated at [0x%x;0x%x):\n%.*Rhxd\n", offHst, offHst + cbWidth, cbWidth, (uint8_t *)pbData + offHst));
3147
3148 pState->ext.glUnmapBuffer(GL_ARRAY_BUFFER);
3149 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3150 }
3151 else
3152 VMSVGA3D_GL_GET_AND_COMPLAIN(pState, pContext, ("glMapBuffer(GL_ARRAY_BUFFER, %#x) -> NULL\n", enmGlTransfer));
3153 }
3154 else
3155 VMSVGA3D_GL_COMPLAIN(pState, pContext, ("glBindBuffer(GL_ARRAY_BUFFER, %#x)\n", pSurface->oglId.buffer));
3156 pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);
3157 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3158 break;
3159 }
3160
3161 default:
3162 AssertFailed();
3163 break;
3164 }
3165
3166 return rc;
3167}
3168
3169static DECLCALLBACK(int) vmsvga3dBackGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
3170{
3171 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3172 PVMSVGA3DSURFACE pSurface;
3173 int rc = VINF_SUCCESS;
3174 PVMSVGA3DCONTEXT pContext;
3175 uint32_t cid;
3176 GLint activeTexture = 0;
3177
3178 AssertReturn(pState, VERR_NO_MEMORY);
3179
3180 rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
3181 AssertRCReturn(rc, rc);
3182
3183 Assert(filter != SVGA3D_TEX_FILTER_FLATCUBIC);
3184 Assert(filter != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
3185 pSurface->autogenFilter = filter;
3186
3187 LogFunc(("sid=%u filter=%d\n", sid, filter));
3188
3189 cid = SVGA3D_INVALID_ID;
3190 pContext = &pState->SharedCtx;
3191 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
3192
3193 if (pSurface->oglId.texture == OPENGL_INVALID_ID)
3194 {
3195 /* Unknown surface type; turn it into a texture. */
3196 LogFunc(("unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
3197 rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
3198 AssertRCReturn(rc, rc);
3199 }
3200 else
3201 {
3202 /** @todo new filter */
3203 AssertFailed();
3204 }
3205
3206 glGetIntegerv(pSurface->bindingGL, &activeTexture);
3207 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3208
3209 /* Must bind texture to the current context in order to change it. */
3210 glBindTexture(pSurface->targetGL, pSurface->oglId.texture);
3211 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3212
3213 /* Generate the mip maps. */
3214 pState->ext.glGenerateMipmap(pSurface->targetGL);
3215 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3216
3217 /* Restore the old texture. */
3218 glBindTexture(pSurface->targetGL, activeTexture);
3219 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3220
3221 return VINF_SUCCESS;
3222}
3223
3224
3225#ifdef RT_OS_LINUX
3226/**
3227 * X11 event handling thread.
3228 *
3229 * @returns VINF_SUCCESS (ignored)
3230 * @param hThreadSelf thread handle
3231 * @param pvUser pointer to pState structure
3232 */
3233DECLCALLBACK(int) vmsvga3dXEventThread(RTTHREAD hThreadSelf, void *pvUser)
3234{
3235 RT_NOREF(hThreadSelf);
3236 PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pvUser;
3237 while (!pState->bTerminate)
3238 {
3239 while (XPending(pState->display) > 0)
3240 {
3241 XEvent event;
3242 XNextEvent(pState->display, &event);
3243
3244 switch (event.type)
3245 {
3246 default:
3247 break;
3248 }
3249 }
3250 /* sleep for 16ms to not burn too many cycles */
3251 RTThreadSleep(16);
3252 }
3253 return VINF_SUCCESS;
3254}
3255#endif // RT_OS_LINUX
3256
3257
3258/**
3259 * Create a new 3d context
3260 *
3261 * @returns VBox status code.
3262 * @param pThisCC The VGA/VMSVGA state for ring-3.
3263 * @param cid Context id
3264 * @param fFlags VMSVGA3D_DEF_CTX_F_XXX.
3265 */
3266int vmsvga3dContextDefineOgl(PVGASTATECC pThisCC, uint32_t cid, uint32_t fFlags)
3267{
3268 int rc;
3269 PVMSVGA3DCONTEXT pContext;
3270 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3271
3272 AssertReturn(pState, VERR_NO_MEMORY);
3273 AssertReturn( cid < SVGA3D_MAX_CONTEXT_IDS
3274 || (cid == VMSVGA3D_SHARED_CTX_ID && (fFlags & VMSVGA3D_DEF_CTX_F_SHARED_CTX)), VERR_INVALID_PARAMETER);
3275#if !defined(VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE) || !(defined(RT_OS_DARWIN))
3276 AssertReturn(!(fFlags & VMSVGA3D_DEF_CTX_F_OTHER_PROFILE), VERR_INTERNAL_ERROR_3);
3277#endif
3278
3279 Log(("vmsvga3dContextDefine id %x\n", cid));
3280
3281 if (cid == VMSVGA3D_SHARED_CTX_ID)
3282 pContext = &pState->SharedCtx;
3283 else
3284 {
3285 if (cid >= pState->cContexts)
3286 {
3287 /* Grow the array. */
3288 uint32_t cNew = RT_ALIGN(cid + 15, 16);
3289 void *pvNew = RTMemRealloc(pState->papContexts, sizeof(pState->papContexts[0]) * cNew);
3290 AssertReturn(pvNew, VERR_NO_MEMORY);
3291 pState->papContexts = (PVMSVGA3DCONTEXT *)pvNew;
3292 while (pState->cContexts < cNew)
3293 {
3294 pContext = (PVMSVGA3DCONTEXT)RTMemAllocZ(sizeof(*pContext));
3295 AssertReturn(pContext, VERR_NO_MEMORY);
3296 pContext->id = SVGA3D_INVALID_ID;
3297 pState->papContexts[pState->cContexts++] = pContext;
3298 }
3299 }
3300 /* If one already exists with this id, then destroy it now. */
3301 if (pState->papContexts[cid]->id != SVGA3D_INVALID_ID)
3302 vmsvga3dBackContextDestroy(pThisCC, cid);
3303
3304 pContext = pState->papContexts[cid];
3305 }
3306
3307 /*
3308 * Find or create the shared context if needed (necessary for sharing e.g. textures between contexts).
3309 */
3310 PVMSVGA3DCONTEXT pSharedCtx = NULL;
3311 if (!(fFlags & (VMSVGA3D_DEF_CTX_F_INIT | VMSVGA3D_DEF_CTX_F_SHARED_CTX)))
3312 {
3313 pSharedCtx = &pState->SharedCtx;
3314 if (pSharedCtx->id != VMSVGA3D_SHARED_CTX_ID)
3315 {
3316 rc = vmsvga3dContextDefineOgl(pThisCC, VMSVGA3D_SHARED_CTX_ID, VMSVGA3D_DEF_CTX_F_SHARED_CTX);
3317 AssertLogRelRCReturn(rc, rc);
3318
3319 /* Create resources which use the shared context. */
3320 vmsvga3dOnSharedContextDefine(pState);
3321 }
3322 }
3323
3324 /*
3325 * Initialize the context.
3326 */
3327 memset(pContext, 0, sizeof(*pContext));
3328 pContext->id = cid;
3329 for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTextures); i++)
3330 pContext->aSidActiveTextures[i] = SVGA3D_INVALID_ID;
3331
3332 pContext->state.shidVertex = SVGA3D_INVALID_ID;
3333 pContext->state.shidPixel = SVGA3D_INVALID_ID;
3334 pContext->idFramebuffer = OPENGL_INVALID_ID;
3335 pContext->idReadFramebuffer = OPENGL_INVALID_ID;
3336 pContext->idDrawFramebuffer = OPENGL_INVALID_ID;
3337
3338 rc = ShaderContextCreate(&pContext->pShaderContext);
3339 AssertRCReturn(rc, rc);
3340
3341 for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderTargets); i++)
3342 pContext->state.aRenderTargets[i] = SVGA3D_INVALID_ID;
3343
3344#ifdef RT_OS_WINDOWS
3345 /* Create a context window with minimal 4x4 size. We will never use the swapchain
3346 * to present the rendered image. Rendered images from the guest will be copied to
3347 * the VMSVGA SCREEN object, which can be either an offscreen render target or
3348 * system memory in the guest VRAM.
3349 */
3350 rc = vmsvga3dContextWindowCreate(pState->hInstance, pState->pWindowThread, pState->WndRequestSem, &pContext->hwnd);
3351 AssertRCReturn(rc, rc);
3352
3353 pContext->hdc = GetDC(pContext->hwnd);
3354 AssertMsgReturn(pContext->hdc, ("GetDC %x failed with %d\n", pContext->hwnd, GetLastError()), VERR_INTERNAL_ERROR);
3355
3356 PIXELFORMATDESCRIPTOR pfd = {
3357 sizeof(PIXELFORMATDESCRIPTOR), /* size of this pfd */
3358 1, /* version number */
3359 PFD_DRAW_TO_WINDOW | /* support window */
3360 PFD_SUPPORT_OPENGL, /* support OpenGL */
3361 PFD_TYPE_RGBA, /* RGBA type */
3362 24, /* 24-bit color depth */
3363 0, 0, 0, 0, 0, 0, /* color bits ignored */
3364 8, /* alpha buffer */
3365 0, /* shift bit ignored */
3366 0, /* no accumulation buffer */
3367 0, 0, 0, 0, /* accum bits ignored */
3368 16, /* set depth buffer */
3369 16, /* set stencil buffer */
3370 0, /* no auxiliary buffer */
3371 PFD_MAIN_PLANE, /* main layer */
3372 0, /* reserved */
3373 0, 0, 0 /* layer masks ignored */
3374 };
3375 int pixelFormat;
3376 BOOL ret;
3377
3378 pixelFormat = ChoosePixelFormat(pContext->hdc, &pfd);
3379 /** @todo is this really necessary?? */
3380 pixelFormat = ChoosePixelFormat(pContext->hdc, &pfd);
3381 AssertMsgReturn(pixelFormat != 0, ("ChoosePixelFormat failed with %d\n", GetLastError()), VERR_INTERNAL_ERROR);
3382
3383 ret = SetPixelFormat(pContext->hdc, pixelFormat, &pfd);
3384 AssertMsgReturn(ret == TRUE, ("SetPixelFormat failed with %d\n", GetLastError()), VERR_INTERNAL_ERROR);
3385
3386 pContext->hglrc = wglCreateContext(pContext->hdc);
3387 AssertMsgReturn(pContext->hglrc, ("wglCreateContext %x failed with %d\n", pContext->hdc, GetLastError()), VERR_INTERNAL_ERROR);
3388
3389 if (pSharedCtx)
3390 {
3391 ret = wglShareLists(pSharedCtx->hglrc, pContext->hglrc);
3392 AssertMsg(ret == TRUE, ("wglShareLists(%p, %p) failed with %d\n", pSharedCtx->hglrc, pContext->hglrc, GetLastError()));
3393 }
3394
3395#elif defined(RT_OS_DARWIN)
3396 pContext->fOtherProfile = RT_BOOL(fFlags & VMSVGA3D_DEF_CTX_F_OTHER_PROFILE);
3397
3398 NativeNSOpenGLContextRef pShareContext = pSharedCtx ? pSharedCtx->cocoaContext : NULL;
3399 vmsvga3dCocoaCreateViewAndContext(&pContext->cocoaView, &pContext->cocoaContext,
3400 NULL,
3401 4, 4,
3402 pShareContext, pContext->fOtherProfile);
3403
3404#else
3405 if (pState->display == NULL)
3406 {
3407 /* get an X display and make sure we have glX 1.3 */
3408 pState->display = XOpenDisplay(0);
3409 AssertLogRelMsgReturn(pState->display, ("XOpenDisplay failed"), VERR_INTERNAL_ERROR);
3410 int glxMajor, glxMinor;
3411 Bool ret = glXQueryVersion(pState->display, &glxMajor, &glxMinor);
3412 AssertLogRelMsgReturn(ret && glxMajor == 1 && glxMinor >= 3, ("glX >=1.3 not present"), VERR_INTERNAL_ERROR);
3413 /* start our X event handling thread */
3414 rc = RTThreadCreate(&pState->pWindowThread, vmsvga3dXEventThread, pState, 0, RTTHREADTYPE_GUI, RTTHREADFLAGS_WAITABLE, "VMSVGA3DXEVENT");
3415 AssertLogRelMsgReturn(RT_SUCCESS(rc), ("Async IO Thread creation for 3d window handling failed rc=%Rrc\n", rc), rc);
3416 }
3417
3418 Window defaultRootWindow = XDefaultRootWindow(pState->display);
3419 /* Create a small 4x4 window required for GL context. */
3420 int attrib[] =
3421 {
3422 GLX_RGBA,
3423 GLX_RED_SIZE, 1,
3424 GLX_GREEN_SIZE, 1,
3425 GLX_BLUE_SIZE, 1,
3426 //GLX_ALPHA_SIZE, 1, this flips the bbos screen
3427 GLX_DOUBLEBUFFER,
3428 None
3429 };
3430 XVisualInfo *vi = glXChooseVisual(pState->display, DefaultScreen(pState->display), attrib);
3431 AssertLogRelMsgReturn(vi, ("glXChooseVisual failed"), VERR_INTERNAL_ERROR);
3432 XSetWindowAttributes swa;
3433 swa.colormap = XCreateColormap(pState->display, defaultRootWindow, vi->visual, AllocNone);
3434 AssertLogRelMsgReturn(swa.colormap, ("XCreateColormap failed"), VERR_INTERNAL_ERROR);
3435 swa.border_pixel = 0;
3436 swa.background_pixel = 0;
3437 swa.event_mask = StructureNotifyMask;
3438 unsigned long flags = CWBorderPixel | CWBackPixel | CWColormap | CWEventMask;
3439 pContext->window = XCreateWindow(pState->display, defaultRootWindow,
3440 0, 0, 4, 4,
3441 0, vi->depth, InputOutput,
3442 vi->visual, flags, &swa);
3443 AssertLogRelMsgReturn(pContext->window, ("XCreateWindow failed"), VERR_INTERNAL_ERROR);
3444
3445 /* The window is hidden by default and never mapped, because we only render offscreen and never present to it. */
3446
3447 GLXContext shareContext = pSharedCtx ? pSharedCtx->glxContext : NULL;
3448 pContext->glxContext = glXCreateContext(pState->display, vi, shareContext, GL_TRUE);
3449 AssertLogRelMsgReturn(pContext->glxContext, ("glXCreateContext failed"), VERR_INTERNAL_ERROR);
3450#endif
3451
3452 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
3453
3454 /* NULL during the first PowerOn call. */
3455 if (pState->ext.glGenFramebuffers)
3456 {
3457 /* Create a framebuffer object for this context. */
3458 pState->ext.glGenFramebuffers(1, &pContext->idFramebuffer);
3459 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3460
3461 /* Bind the object to the framebuffer target. */
3462 pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, pContext->idFramebuffer);
3463 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3464
3465 /* Create read and draw framebuffer objects for this context. */
3466 pState->ext.glGenFramebuffers(1, &pContext->idReadFramebuffer);
3467 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3468
3469 pState->ext.glGenFramebuffers(1, &pContext->idDrawFramebuffer);
3470 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
3471
3472 }
3473#if 0
3474 /** @todo move to shader lib!!! */
3475 /* Clear the screen */
3476 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
3477
3478 glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
3479 glClearIndex(0);
3480 glClearDepth(1);
3481 glClearStencil(0xffff);
3482 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
3483 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
3484 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
3485 if (pState->ext.glProvokingVertex)
3486 pState->ext.glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);
3487 /** @todo move to shader lib!!! */
3488#endif
3489 return VINF_SUCCESS;
3490}
3491
3492#if defined(RT_OS_LINUX)
3493/*
3494 * HW accelerated graphics output.
3495 */
3496
3497/**
3498 * VMSVGA3d screen data.
3499 *
3500 * Allocated on the heap and pointed to by VMSVGASCREENOBJECT::pHwScreen.
3501 */
3502typedef struct VMSVGAHWSCREEN
3503{
3504 /* OpenGL context, which is used for the screen updates. */
3505 GLXContext glxctx;
3506
3507 /* The overlay window. */
3508 Window xwindow;
3509
3510 /* The RGBA texture which hold the screen content. */
3511 GLuint idScreenTexture;
3512
3513 /* Read and draw framebuffer objects for copying a surface to the screen texture. */
3514 GLuint idReadFramebuffer;
3515 GLuint idDrawFramebuffer;
3516} VMSVGAHWSCREEN;
3517
3518/* Send a notification to the UI. */
3519#if 0 /* Unused */
3520static int vmsvga3dDrvNotifyHwScreen(PVGASTATECC pThisCC, VBOX3D_NOTIFY_TYPE enmNotification,
3521 uint32_t idScreen, Pixmap pixmap, void *pvData, size_t cbData)
3522{
3523 uint8_t au8Buffer[128];
3524 AssertLogRelMsgReturn(cbData <= sizeof(au8Buffer) - sizeof(VBOX3DNOTIFY),
3525 ("cbData %zu", cbData),
3526 VERR_INVALID_PARAMETER);
3527
3528 VBOX3DNOTIFY *p = (VBOX3DNOTIFY *)&au8Buffer[0];
3529 p->enmNotification = enmNotification;
3530 p->iDisplay = idScreen;
3531 p->u32Reserved = 0;
3532 p->cbData = cbData + sizeof(uint64_t);
3533 /* au8Data consists of a 64 bit pixmap handle followed by notification specific data. */
3534 AssertCompile(sizeof(pixmap) <= sizeof(uint64_t));
3535 *(uint64_t *)&p->au8Data[0] = (uint64_t)pixmap;
3536 memcpy(&p->au8Data[sizeof(uint64_t)], pvData, cbData);
3537
3538 int rc = pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
3539 return rc;
3540}
3541#endif /* Unused */
3542
3543static void vmsvga3dDrvNotifyHwOverlay(PVGASTATECC pThisCC, VBOX3D_NOTIFY_TYPE enmNotification, uint32_t idScreen)
3544{
3545 uint8_t au8Buffer[128];
3546 VBOX3DNOTIFY *p = (VBOX3DNOTIFY *)&au8Buffer[0];
3547 p->enmNotification = enmNotification;
3548 p->iDisplay = idScreen;
3549 p->u32Reserved = 0;
3550 p->cbData = sizeof(uint64_t);
3551 *(uint64_t *)&p->au8Data[0] = 0;
3552
3553 pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
3554}
3555
3556/* Get X Window handle of the UI Framebuffer window. */
3557static int vmsvga3dDrvQueryWindow(PVGASTATECC pThisCC, uint32_t idScreen, Window *pWindow)
3558{
3559 uint8_t au8Buffer[128];
3560 VBOX3DNOTIFY *p = (VBOX3DNOTIFY *)&au8Buffer[0];
3561 p->enmNotification = VBOX3D_NOTIFY_TYPE_HW_OVERLAY_GET_ID;
3562 p->iDisplay = idScreen;
3563 p->u32Reserved = 0;
3564 p->cbData = sizeof(uint64_t);
3565 *(uint64_t *)&p->au8Data[0] = 0;
3566
3567 int rc = pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
3568 if (RT_SUCCESS(rc))
3569 {
3570 *pWindow = (Window)*(uint64_t *)&p->au8Data[0];
3571 }
3572 return rc;
3573}
3574
3575static int ctxErrorHandler(Display *dpy, XErrorEvent *ev)
3576{
3577 RT_NOREF(dpy);
3578 LogRel4(("VMSVGA: XError %d\n", (int)ev->error_code));
3579 return 0;
3580}
3581
3582/* Create an overlay X window for the HW accelerated screen. */
3583static int vmsvga3dHwScreenCreate(PVMSVGA3DSTATE pState, Window parentWindow, unsigned int cWidth, unsigned int cHeight, VMSVGAHWSCREEN *p)
3584{
3585 int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
3586
3587 int rc = VINF_SUCCESS;
3588
3589 XWindowAttributes parentAttr;
3590 if (XGetWindowAttributes(pState->display, parentWindow, &parentAttr) == 0)
3591 return VERR_INVALID_PARAMETER;
3592
3593 int const idxParentScreen = XScreenNumberOfScreen(parentAttr.screen);
3594
3595 /*
3596 * Create a new GL context, which will be used for copying to the screen.
3597 */
3598
3599 /* FBConfig attributes for the overlay window. */
3600 static int const aConfigAttribList[] =
3601 {
3602 GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, // Must support GLX windows
3603 GLX_DOUBLEBUFFER, False, // Double buffering had a much lower performance.
3604 GLX_RED_SIZE, 8, // True color RGB with 8 bits per channel.
3605 GLX_GREEN_SIZE, 8,
3606 GLX_BLUE_SIZE, 8,
3607 GLX_ALPHA_SIZE, 8,
3608 GLX_STENCIL_SIZE, 0, // No stencil buffer
3609 GLX_DEPTH_SIZE, 0, // No depth buffer
3610 None
3611 };
3612
3613 /* Find a suitable FB config. */
3614 int cConfigs = 0;
3615 GLXFBConfig *paConfigs = glXChooseFBConfig(pState->display, idxParentScreen, aConfigAttribList, &cConfigs);
3616 LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: paConfigs %p cConfigs %d\n", (void *)paConfigs, cConfigs));
3617 if (paConfigs)
3618 {
3619 XVisualInfo *vi = NULL;
3620 int i = 0;
3621 for (; i < cConfigs; ++i)
3622 {
3623 /* Use XFree to free the data returned in the previous iteration of this loop. */
3624 if (vi)
3625 XFree(vi);
3626
3627 vi = glXGetVisualFromFBConfig(pState->display, paConfigs[i]);
3628 if (!vi)
3629 continue;
3630
3631 LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: %p vid %lu screen %d depth %d r %lu g %lu b %lu clrmap %d bitsperrgb %d\n",
3632 (void *)vi->visual, vi->visualid, vi->screen, vi->depth,
3633 vi->red_mask, vi->green_mask, vi->blue_mask, vi->colormap_size, vi->bits_per_rgb));
3634
3635 /* Same screen as the parent window. */
3636 if (vi->screen != idxParentScreen)
3637 continue;
3638
3639 /* Search for 32 bits per pixel. */
3640 if (vi->depth != 32)
3641 continue;
3642
3643 /* 8 bits per color component is enough. */
3644 if (vi->bits_per_rgb != 8)
3645 continue;
3646
3647 /* Render to pixmap. */
3648 int value = 0;
3649 glXGetFBConfigAttrib(pState->display, paConfigs[i], GLX_DRAWABLE_TYPE, &value);
3650 if (!(value & GLX_WINDOW_BIT))
3651 continue;
3652
3653 /* This FB config can be used. */
3654 break;
3655 }
3656
3657 if (i < cConfigs)
3658 {
3659 /* Found a suitable config with index i. */
3660
3661 /* Create an overlay window. */
3662 XSetWindowAttributes swa;
3663 RT_ZERO(swa);
3664
3665 swa.colormap = XCreateColormap(pState->display, parentWindow, vi->visual, AllocNone);
3666 AssertLogRelMsg(swa.colormap, ("XCreateColormap failed"));
3667 swa.border_pixel = 0;
3668 swa.background_pixel = 0;
3669 swa.event_mask = StructureNotifyMask;
3670 swa.override_redirect = 1;
3671 unsigned long const swaAttrs = CWBorderPixel | CWBackPixel | CWColormap | CWEventMask | CWOverrideRedirect;
3672 p->xwindow = XCreateWindow(pState->display, parentWindow,
3673 0, 0, cWidth, cHeight, 0, vi->depth, InputOutput,
3674 vi->visual, swaAttrs, &swa);
3675 LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->xwindow %ld\n", p->xwindow));
3676 if (p->xwindow)
3677 {
3678
3679 p->glxctx = glXCreateContext(pState->display, vi, pState->SharedCtx.glxContext, GL_TRUE);
3680 LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->glxctx %p\n", (void *)p->glxctx));
3681 if (p->glxctx)
3682 {
3683 XMapWindow(pState->display, p->xwindow);
3684 }
3685 else
3686 {
3687 LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: glXCreateContext failed\n"));
3688 rc = VERR_NOT_SUPPORTED;
3689 }
3690 }
3691 else
3692 {
3693 LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: XCreateWindow failed\n"));
3694 rc = VERR_NOT_SUPPORTED;
3695 }
3696
3697 XSync(pState->display, False);
3698 }
3699 else
3700 {
3701 /* A suitable config is not found. */
3702 LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: no FBConfig\n"));
3703 rc = VERR_NOT_SUPPORTED;
3704 }
3705
3706 if (vi)
3707 XFree(vi);
3708
3709 /* "Use XFree to free the memory returned by glXChooseFBConfig." */
3710 XFree(paConfigs);
3711 }
3712 else
3713 {
3714 /* glXChooseFBConfig failed. */
3715 rc = VERR_NOT_SUPPORTED;
3716 }
3717
3718 XSetErrorHandler(oldHandler);
3719 return rc;
3720}
3721
3722/* Destroy a HW accelerated screen. */
3723static void vmsvga3dHwScreenDestroy(PVMSVGA3DSTATE pState, VMSVGAHWSCREEN *p)
3724{
3725 if (p)
3726 {
3727 LogRel4(("VMSVGA: vmsvga3dHwScreenDestroy: p->xwindow %ld, ctx %p\n", p->xwindow, (void *)p->glxctx));
3728 if (p->glxctx)
3729 {
3730 /* GLX context is changed here, so other code has to set the appropriate context again. */
3731 VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
3732
3733 glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
3734
3735 /* Clean up OpenGL. */
3736 if (p->idReadFramebuffer != OPENGL_INVALID_ID)
3737 pState->ext.glDeleteFramebuffers(1, &p->idReadFramebuffer);
3738 if (p->idDrawFramebuffer != OPENGL_INVALID_ID)
3739 pState->ext.glDeleteFramebuffers(1, &p->idDrawFramebuffer);
3740 if (p->idScreenTexture != OPENGL_INVALID_ID)
3741 glDeleteTextures(1, &p->idScreenTexture);
3742
3743 glXMakeCurrent(pState->display, None, NULL);
3744
3745 glXDestroyContext(pState->display, p->glxctx);
3746 }
3747
3748 if (p->xwindow)
3749 XDestroyWindow(pState->display, p->xwindow);
3750
3751 RT_ZERO(*p);
3752 }
3753}
3754
3755#define GLCHECK() \
3756 do { \
3757 int glErr = glGetError(); \
3758 if (glErr != GL_NO_ERROR) LogRel4(("VMSVGA: GL error 0x%x @%d\n", glErr, __LINE__)); \
3759 } while(0)
3760
3761static DECLCALLBACK(int) vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
3762{
3763 LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: screen %u\n", pScreen->idScreen));
3764
3765 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3766 AssertReturn(pState, VERR_NOT_SUPPORTED);
3767
3768 if (!pThis->svga.f3DOverlayEnabled)
3769 return VERR_NOT_SUPPORTED;
3770
3771 Assert(pScreen->pHwScreen == NULL);
3772
3773 VMSVGAHWSCREEN *p = (VMSVGAHWSCREEN *)RTMemAllocZ(sizeof(VMSVGAHWSCREEN));
3774 AssertPtrReturn(p, VERR_NO_MEMORY);
3775
3776 /* Query the parent window ID from the UI framebuffer.
3777 * If it is there then
3778 * the device will create a texture for the screen content and an overlay window to present the screen content.
3779 * otherwise
3780 * the device will use the guest VRAM system memory for the screen content.
3781 */
3782 Window parentWindow;
3783 int rc = vmsvga3dDrvQueryWindow(pThisCC, pScreen->idScreen, &parentWindow);
3784 if (RT_SUCCESS(rc))
3785 {
3786 /* Create the hardware accelerated screen. */
3787 rc = vmsvga3dHwScreenCreate(pState, parentWindow, pScreen->cWidth, pScreen->cHeight, p);
3788 if (RT_SUCCESS(rc))
3789 {
3790 /*
3791 * Setup the OpenGL context of the screen. The context will be used to draw on the screen.
3792 */
3793
3794 /* GLX context is changed here, so other code has to set the appropriate context again. */
3795 VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
3796
3797 Bool const fSuccess = glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
3798 if (fSuccess)
3799 {
3800 /* Set GL state. */
3801 glClearColor(0, 0, 0, 1);
3802 glEnable(GL_TEXTURE_2D);
3803 glDisable(GL_DEPTH_TEST);
3804 glDisable(GL_CULL_FACE);
3805
3806 /* The RGBA texture which hold the screen content. */
3807 glGenTextures(1, &p->idScreenTexture); GLCHECK();
3808 glBindTexture(GL_TEXTURE_2D, p->idScreenTexture); GLCHECK();
3809 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); GLCHECK();
3810 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); GLCHECK();
3811 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, pScreen->cWidth, pScreen->cHeight, 0,
3812 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); GLCHECK();
3813
3814 /* Create read and draw framebuffer objects for this screen. */
3815 pState->ext.glGenFramebuffers(1, &p->idReadFramebuffer); GLCHECK();
3816 pState->ext.glGenFramebuffers(1, &p->idDrawFramebuffer); GLCHECK();
3817
3818 /* Work in screen coordinates. */
3819 glMatrixMode(GL_MODELVIEW);
3820 glLoadIdentity();
3821 glOrtho(0, pScreen->cWidth, 0, pScreen->cHeight, -1, 1);
3822 glMatrixMode(GL_PROJECTION);
3823 glLoadIdentity();
3824
3825 /* Clear the texture. */
3826 pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, p->idDrawFramebuffer); GLCHECK();
3827 pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
3828 p->idScreenTexture, 0); GLCHECK();
3829
3830 glClear(GL_COLOR_BUFFER_BIT);
3831
3832 pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); GLCHECK();
3833
3834 glXMakeCurrent(pState->display, None, NULL);
3835
3836 XSync(pState->display, False);
3837
3838 vmsvga3dDrvNotifyHwOverlay(pThisCC, VBOX3D_NOTIFY_TYPE_HW_OVERLAY_CREATED, pScreen->idScreen);
3839 }
3840 else
3841 {
3842 LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: failed to set current context\n"));
3843 rc = VERR_NOT_SUPPORTED;
3844 }
3845 }
3846 }
3847 else
3848 {
3849 LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: no framebuffer\n"));
3850 }
3851
3852 if (RT_SUCCESS(rc))
3853 {
3854 LogRel(("VMSVGA: Using HW accelerated screen %u\n", pScreen->idScreen));
3855 pScreen->pHwScreen = p;
3856 }
3857 else
3858 {
3859 LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: %Rrc\n", rc));
3860 vmsvga3dHwScreenDestroy(pState, p);
3861 RTMemFree(p);
3862 }
3863
3864 return rc;
3865}
3866
3867static DECLCALLBACK(int) vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
3868{
3869 LogRel4(("VMSVGA: vmsvga3dBackDestroyScreen: screen %u\n", pScreen->idScreen));
3870
3871 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3872 AssertReturn(pState, VERR_NOT_SUPPORTED);
3873
3874 int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
3875
3876 VMSVGAHWSCREEN *p = pScreen->pHwScreen;
3877 if (p)
3878 {
3879 pScreen->pHwScreen = NULL;
3880
3881 vmsvga3dDrvNotifyHwOverlay(pThisCC, VBOX3D_NOTIFY_TYPE_HW_OVERLAY_DESTROYED, pScreen->idScreen);
3882
3883 vmsvga3dHwScreenDestroy(pState, p);
3884 RTMemFree(p);
3885 }
3886
3887 XSetErrorHandler(oldHandler);
3888
3889 return VINF_SUCCESS;
3890}
3891
3892/* Blit a surface to the GLX pixmap. */
3893static DECLCALLBACK(int) vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
3894 SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
3895 SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects)
3896{
3897 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3898 AssertReturn(pState, VERR_NOT_SUPPORTED);
3899
3900 VMSVGAHWSCREEN *p = pScreen->pHwScreen;
3901 AssertReturn(p, VERR_NOT_SUPPORTED);
3902
3903 PVMSVGA3DSURFACE pSurface;
3904 int rc = vmsvga3dSurfaceFromSid(pState, srcImage.sid, &pSurface);
3905 AssertRCReturn(rc, rc);
3906
3907 if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
3908 {
3909 LogFunc(("src sid=%u flags=0x%x format=%d -> create texture\n", srcImage.sid, pSurface->surfaceFlags, pSurface->format));
3910 rc = vmsvga3dBackCreateTexture(pThisCC, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID, pSurface);
3911 AssertRCReturn(rc, rc);
3912 }
3913
3914 AssertReturn(pSurface->enmOGLResType == VMSVGA3D_OGLRESTYPE_TEXTURE, VERR_NOT_SUPPORTED);
3915
3916 PVMSVGA3DMIPMAPLEVEL pMipLevel;
3917 rc = vmsvga3dMipmapLevel(pSurface, srcImage.face, srcImage.mipmap, &pMipLevel);
3918 AssertRCReturn(rc, rc);
3919
3920 /** @todo Implement. */
3921 RT_NOREF(cRects, paRects);
3922
3923 /* GLX context is changed here, so other code has to set appropriate context again. */
3924 VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
3925
3926 int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
3927
3928 Bool fSuccess = glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
3929 if (fSuccess)
3930 {
3931 /* Activate the read and draw framebuffer objects. */
3932 pState->ext.glBindFramebuffer(GL_READ_FRAMEBUFFER, p->idReadFramebuffer); GLCHECK();
3933 pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, p->idDrawFramebuffer); GLCHECK();
3934
3935 /* Bind the source and destination objects to the right place. */
3936 pState->ext.glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
3937 pSurface->oglId.texture, 0); GLCHECK();
3938 pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
3939 p->idScreenTexture, 0); GLCHECK();
3940
3941 pState->ext.glBlitFramebuffer(srcRect.left,
3942 srcRect.top,
3943 srcRect.right,
3944 srcRect.bottom,
3945 destRect.left,
3946 destRect.top,
3947 destRect.right,
3948 destRect.bottom,
3949 GL_COLOR_BUFFER_BIT,
3950 GL_NEAREST); GLCHECK();
3951
3952 /* Reset the frame buffer association */
3953 pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, 0); GLCHECK();
3954
3955 /* Update the overlay window. */
3956 glClear(GL_COLOR_BUFFER_BIT);
3957
3958 glBindTexture(GL_TEXTURE_2D, p->idScreenTexture); GLCHECK();
3959
3960 GLint const w = pScreen->cWidth;
3961 GLint const h = pScreen->cHeight;
3962
3963 glBegin(GL_QUADS);
3964 glTexCoord2f(0.0f, 0.0f); glVertex2i(0, h);
3965 glTexCoord2f(0.0f, 1.0f); glVertex2i(0, 0);
3966 glTexCoord2f(1.0f, 1.0f); glVertex2i(w, 0);
3967 glTexCoord2f(1.0f, 0.0f); glVertex2i(w, h);
3968 glEnd(); GLCHECK();
3969
3970 glBindTexture(GL_TEXTURE_2D, 0); GLCHECK();
3971
3972 glXMakeCurrent(pState->display, None, NULL);
3973 }
3974 else
3975 {
3976 LogRel4(("VMSVGA: vmsvga3dBackSurfaceBlitToScreen: screen %u, glXMakeCurrent for pixmap failed\n", pScreen->idScreen));
3977 }
3978
3979 XSetErrorHandler(oldHandler);
3980
3981 return VINF_SUCCESS;
3982}
3983
3984#else /* !RT_OS_LINUX */
3985
3986static DECLCALLBACK(int) vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
3987{
3988 RT_NOREF(pThis, pThisCC, pScreen);
3989 return VERR_NOT_IMPLEMENTED;
3990}
3991
3992static DECLCALLBACK(int) vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
3993{
3994 RT_NOREF(pThisCC, pScreen);
3995 return VERR_NOT_IMPLEMENTED;
3996}
3997
3998static DECLCALLBACK(int) vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
3999 SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
4000 SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects)
4001{
4002 RT_NOREF(pThisCC, pScreen, destRect, srcImage, srcRect, cRects, paRects);
4003 return VERR_NOT_IMPLEMENTED;
4004}
4005#endif
4006
4007/**
4008 * Create a new 3d context
4009 *
4010 * @returns VBox status code.
4011 * @param pThisCC The VGA/VMSVGA state for ring-3.
4012 * @param cid Context id
4013 */
4014static DECLCALLBACK(int) vmsvga3dBackContextDefine(PVGASTATECC pThisCC, uint32_t cid)
4015{
4016 return vmsvga3dContextDefineOgl(pThisCC, cid, 0/*fFlags*/);
4017}
4018
4019/**
4020 * Destroys a 3d context.
4021 *
4022 * @returns VBox status code.
4023 * @param pThisCC The VGA/VMSVGA state for ring-3.
4024 * @param pContext The context to destroy.
4025 * @param cid Context id
4026 */
4027static int vmsvga3dContextDestroyOgl(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid)
4028{
4029 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4030 AssertReturn(pState, VERR_NO_MEMORY);
4031 AssertReturn(pContext, VERR_INVALID_PARAMETER);
4032 AssertReturn(pContext->id == cid, VERR_INVALID_PARAMETER);
4033 Log(("vmsvga3dContextDestroyOgl id %x\n", cid));
4034
4035 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
4036
4037 if (pContext->id == VMSVGA3D_SHARED_CTX_ID)
4038 {
4039 /* Delete resources which use the shared context. */
4040 vmsvga3dOnSharedContextDestroy(pState);
4041 }
4042
4043 /* Destroy all leftover pixel shaders. */
4044 for (uint32_t i = 0; i < pContext->cPixelShaders; i++)
4045 {
4046 if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
4047 vmsvga3dBackShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
4048 }
4049 if (pContext->paPixelShader)
4050 RTMemFree(pContext->paPixelShader);
4051
4052 /* Destroy all leftover vertex shaders. */
4053 for (uint32_t i = 0; i < pContext->cVertexShaders; i++)
4054 {
4055 if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
4056 vmsvga3dBackShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
4057 }
4058 if (pContext->paVertexShader)
4059 RTMemFree(pContext->paVertexShader);
4060
4061 if (pContext->state.paVertexShaderConst)
4062 RTMemFree(pContext->state.paVertexShaderConst);
4063 if (pContext->state.paPixelShaderConst)
4064 RTMemFree(pContext->state.paPixelShaderConst);
4065
4066 if (pContext->pShaderContext)
4067 {
4068 int rc = ShaderContextDestroy(pContext->pShaderContext);
4069 AssertRC(rc);
4070 }
4071
4072 if (pContext->idFramebuffer != OPENGL_INVALID_ID)
4073 {
4074 /* Unbind the object from the framebuffer target. */
4075 pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, 0 /* back buffer */);
4076 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4077 pState->ext.glDeleteFramebuffers(1, &pContext->idFramebuffer);
4078 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4079
4080 if (pContext->idReadFramebuffer != OPENGL_INVALID_ID)
4081 {
4082 pState->ext.glDeleteFramebuffers(1, &pContext->idReadFramebuffer);
4083 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4084 }
4085 if (pContext->idDrawFramebuffer != OPENGL_INVALID_ID)
4086 {
4087 pState->ext.glDeleteFramebuffers(1, &pContext->idDrawFramebuffer);
4088 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4089 }
4090 }
4091
4092 vmsvga3dBackOcclusionQueryDelete(pThisCC, pContext);
4093
4094#ifdef RT_OS_WINDOWS
4095 wglMakeCurrent(pContext->hdc, NULL);
4096 wglDeleteContext(pContext->hglrc);
4097 ReleaseDC(pContext->hwnd, pContext->hdc);
4098
4099 /* Destroy the window we've created. */
4100 int rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_DESTROYWINDOW, (WPARAM)pContext->hwnd, 0);
4101 AssertRC(rc);
4102#elif defined(RT_OS_DARWIN)
4103 vmsvga3dCocoaDestroyViewAndContext(pContext->cocoaView, pContext->cocoaContext);
4104#elif defined(RT_OS_LINUX)
4105 glXMakeCurrent(pState->display, None, NULL);
4106 glXDestroyContext(pState->display, pContext->glxContext);
4107 XDestroyWindow(pState->display, pContext->window);
4108#endif
4109
4110 memset(pContext, 0, sizeof(*pContext));
4111 pContext->id = SVGA3D_INVALID_ID;
4112
4113 VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
4114 return VINF_SUCCESS;
4115}
4116
4117/**
4118 * Destroy an existing 3d context
4119 *
4120 * @returns VBox status code.
4121 * @param pThisCC The VGA/VMSVGA state for ring-3.
4122 * @param cid Context id
4123 */
4124static DECLCALLBACK(int) vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
4125{
4126 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4127 AssertReturn(pState, VERR_WRONG_ORDER);
4128
4129 /*
4130 * Resolve the context and hand it to the common worker function.
4131 */
4132 if ( cid < pState->cContexts
4133 && pState->papContexts[cid]->id == cid)
4134 return vmsvga3dContextDestroyOgl(pThisCC, pState->papContexts[cid], cid);
4135
4136 AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
4137 return VINF_SUCCESS;
4138}
4139
4140/**
4141 * Worker for vmsvga3dBackChangeMode that resizes a context.
4142 *
4143 * @param pState The VMSVGA3d state.
4144 * @param pContext The context.
4145 */
4146static void vmsvga3dChangeModeOneContext(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
4147{
4148 RT_NOREF(pState, pContext);
4149 /* Do nothing. The window is not used for presenting. */
4150}
4151
4152/* Handle resize */
4153static DECLCALLBACK(int) vmsvga3dBackChangeMode(PVGASTATECC pThisCC)
4154{
4155 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4156 AssertReturn(pState, VERR_NO_MEMORY);
4157
4158 /* Resize the shared context too. */
4159 if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
4160 vmsvga3dChangeModeOneContext(pState, &pState->SharedCtx);
4161
4162 /* Resize all active contexts. */
4163 for (uint32_t i = 0; i < pState->cContexts; i++)
4164 {
4165 PVMSVGA3DCONTEXT pContext = pState->papContexts[i];
4166 if (pContext->id != SVGA3D_INVALID_ID)
4167 vmsvga3dChangeModeOneContext(pState, pContext);
4168 }
4169
4170 return VINF_SUCCESS;
4171}
4172
4173
4174static DECLCALLBACK(int) vmsvga3dBackSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
4175{
4176 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4177 AssertReturn(pState, VERR_NO_MEMORY);
4178 bool fModelViewChanged = false;
4179
4180 Log(("vmsvga3dSetTransform cid=%u %s\n", cid, vmsvgaTransformToString(type)));
4181
4182 ASSERT_GUEST_RETURN((unsigned)type < SVGA3D_TRANSFORM_MAX, VERR_INVALID_PARAMETER);
4183
4184 PVMSVGA3DCONTEXT pContext;
4185 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4186 AssertRCReturn(rc, rc);
4187
4188 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
4189
4190 /* Save this matrix for vm state save/restore. */
4191 pContext->state.aTransformState[type].fValid = true;
4192 memcpy(pContext->state.aTransformState[type].matrix, matrix, sizeof(pContext->state.aTransformState[type].matrix));
4193 pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_TRANSFORM;
4194
4195 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)));
4196 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)));
4197 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)));
4198 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)));
4199
4200 switch (type)
4201 {
4202 case SVGA3D_TRANSFORM_VIEW:
4203 /* View * World = Model View */
4204 glMatrixMode(GL_MODELVIEW);
4205 glLoadMatrixf(matrix);
4206 if (pContext->state.aTransformState[SVGA3D_TRANSFORM_WORLD].fValid)
4207 glMultMatrixf(pContext->state.aTransformState[SVGA3D_TRANSFORM_WORLD].matrix);
4208 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4209 fModelViewChanged = true;
4210 break;
4211
4212 case SVGA3D_TRANSFORM_PROJECTION:
4213 {
4214 rc = ShaderTransformProjection(pContext->state.RectViewPort.w, pContext->state.RectViewPort.h, matrix, false /* fPretransformed */);
4215 AssertRCReturn(rc, rc);
4216 break;
4217 }
4218
4219 case SVGA3D_TRANSFORM_TEXTURE0:
4220 glMatrixMode(GL_TEXTURE);
4221 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4222 glLoadMatrixf(matrix);
4223 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4224 break;
4225
4226 case SVGA3D_TRANSFORM_TEXTURE1:
4227 case SVGA3D_TRANSFORM_TEXTURE2:
4228 case SVGA3D_TRANSFORM_TEXTURE3:
4229 case SVGA3D_TRANSFORM_TEXTURE4:
4230 case SVGA3D_TRANSFORM_TEXTURE5:
4231 case SVGA3D_TRANSFORM_TEXTURE6:
4232 case SVGA3D_TRANSFORM_TEXTURE7:
4233 Log(("vmsvga3dSetTransform: unsupported SVGA3D_TRANSFORM_TEXTUREx transform!!\n"));
4234 return VERR_INVALID_PARAMETER;
4235
4236 case SVGA3D_TRANSFORM_WORLD:
4237 /* View * World = Model View */
4238 glMatrixMode(GL_MODELVIEW);
4239 if (pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].fValid)
4240 glLoadMatrixf(pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].matrix);
4241 else
4242 glLoadIdentity();
4243 glMultMatrixf(matrix);
4244 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4245 fModelViewChanged = true;
4246 break;
4247
4248 case SVGA3D_TRANSFORM_WORLD1:
4249 case SVGA3D_TRANSFORM_WORLD2:
4250 case SVGA3D_TRANSFORM_WORLD3:
4251 Log(("vmsvga3dSetTransform: unsupported SVGA3D_TRANSFORM_WORLDx transform!!\n"));
4252 return VERR_INVALID_PARAMETER;
4253
4254 default:
4255 Log(("vmsvga3dSetTransform: unknown type!!\n"));
4256 return VERR_INVALID_PARAMETER;
4257 }
4258
4259 /* Apparently we need to reset the light and clip data after modifying the modelview matrix. */
4260 if (fModelViewChanged)
4261 {
4262 /* Reprogram the clip planes. */
4263 for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aClipPlane); j++)
4264 {
4265 if (pContext->state.aClipPlane[j].fValid == true)
4266 vmsvga3dBackSetClipPlane(pThisCC, cid, j, pContext->state.aClipPlane[j].plane);
4267 }
4268
4269 /* Reprogram the light data. */
4270 for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aLightData); j++)
4271 {
4272 if (pContext->state.aLightData[j].fValidData == true)
4273 vmsvga3dBackSetLightData(pThisCC, cid, j, &pContext->state.aLightData[j].data);
4274 }
4275 }
4276
4277 return VINF_SUCCESS;
4278}
4279
4280static DECLCALLBACK(int) vmsvga3dBackSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
4281{
4282 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4283 AssertReturn(pState, VERR_NO_MEMORY);
4284
4285 Log(("vmsvga3dSetZRange cid=%u min=%d max=%d\n", cid, (uint32_t)(zRange.min * 100.0), (uint32_t)(zRange.max * 100.0)));
4286
4287 PVMSVGA3DCONTEXT pContext;
4288 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4289 AssertRCReturn(rc, rc);
4290
4291 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
4292
4293 pContext->state.zRange = zRange;
4294 pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_ZRANGE;
4295
4296 if (zRange.min < -1.0)
4297 zRange.min = -1.0;
4298 if (zRange.max > 1.0)
4299 zRange.max = 1.0;
4300
4301 glDepthRange((GLdouble)zRange.min, (GLdouble)zRange.max);
4302 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4303 return VINF_SUCCESS;
4304}
4305
4306/**
4307 * Convert SVGA blend op value to its OpenGL equivalent
4308 */
4309static GLenum vmsvga3dBlendOp2GL(uint32_t blendOp)
4310{
4311 switch (blendOp)
4312 {
4313 case SVGA3D_BLENDOP_ZERO:
4314 return GL_ZERO;
4315 case SVGA3D_BLENDOP_ONE:
4316 return GL_ONE;
4317 case SVGA3D_BLENDOP_SRCCOLOR:
4318 return GL_SRC_COLOR;
4319 case SVGA3D_BLENDOP_INVSRCCOLOR:
4320 return GL_ONE_MINUS_SRC_COLOR;
4321 case SVGA3D_BLENDOP_SRCALPHA:
4322 return GL_SRC_ALPHA;
4323 case SVGA3D_BLENDOP_INVSRCALPHA:
4324 return GL_ONE_MINUS_SRC_ALPHA;
4325 case SVGA3D_BLENDOP_DESTALPHA:
4326 return GL_DST_ALPHA;
4327 case SVGA3D_BLENDOP_INVDESTALPHA:
4328 return GL_ONE_MINUS_DST_ALPHA;
4329 case SVGA3D_BLENDOP_DESTCOLOR:
4330 return GL_DST_COLOR;
4331 case SVGA3D_BLENDOP_INVDESTCOLOR:
4332 return GL_ONE_MINUS_DST_COLOR;
4333 case SVGA3D_BLENDOP_SRCALPHASAT:
4334 return GL_SRC_ALPHA_SATURATE;
4335 case SVGA3D_BLENDOP_BLENDFACTOR:
4336 return GL_CONSTANT_COLOR;
4337 case SVGA3D_BLENDOP_INVBLENDFACTOR:
4338 return GL_ONE_MINUS_CONSTANT_COLOR;
4339 default:
4340 AssertFailed();
4341 return GL_ONE;
4342 }
4343}
4344
4345static GLenum vmsvga3dBlendEquation2GL(uint32_t blendEq)
4346{
4347 switch (blendEq)
4348 {
4349 case SVGA3D_BLENDEQ_ADD:
4350 return GL_FUNC_ADD;
4351 case SVGA3D_BLENDEQ_SUBTRACT:
4352 return GL_FUNC_SUBTRACT;
4353 case SVGA3D_BLENDEQ_REVSUBTRACT:
4354 return GL_FUNC_REVERSE_SUBTRACT;
4355 case SVGA3D_BLENDEQ_MINIMUM:
4356 return GL_MIN;
4357 case SVGA3D_BLENDEQ_MAXIMUM:
4358 return GL_MAX;
4359 default:
4360 /* SVGA3D_BLENDEQ_INVALID means that the render state has not been set, therefore use default. */
4361 AssertMsg(blendEq == SVGA3D_BLENDEQ_INVALID, ("blendEq=%d (%#x)\n", blendEq, blendEq));
4362 return GL_FUNC_ADD;
4363 }
4364}
4365
4366static GLenum vmsvgaCmpFunc2GL(uint32_t cmpFunc)
4367{
4368 switch (cmpFunc)
4369 {
4370 case SVGA3D_CMP_NEVER:
4371 return GL_NEVER;
4372 case SVGA3D_CMP_LESS:
4373 return GL_LESS;
4374 case SVGA3D_CMP_EQUAL:
4375 return GL_EQUAL;
4376 case SVGA3D_CMP_LESSEQUAL:
4377 return GL_LEQUAL;
4378 case SVGA3D_CMP_GREATER:
4379 return GL_GREATER;
4380 case SVGA3D_CMP_NOTEQUAL:
4381 return GL_NOTEQUAL;
4382 case SVGA3D_CMP_GREATEREQUAL:
4383 return GL_GEQUAL;
4384 case SVGA3D_CMP_ALWAYS:
4385 return GL_ALWAYS;
4386 default:
4387 Assert(cmpFunc == SVGA3D_CMP_INVALID);
4388 return GL_LESS;
4389 }
4390}
4391
4392static GLenum vmsvgaStencipOp2GL(uint32_t stencilOp)
4393{
4394 switch (stencilOp)
4395 {
4396 case SVGA3D_STENCILOP_KEEP:
4397 return GL_KEEP;
4398 case SVGA3D_STENCILOP_ZERO:
4399 return GL_ZERO;
4400 case SVGA3D_STENCILOP_REPLACE:
4401 return GL_REPLACE;
4402 case SVGA3D_STENCILOP_INCRSAT:
4403 return GL_INCR_WRAP;
4404 case SVGA3D_STENCILOP_DECRSAT:
4405 return GL_DECR_WRAP;
4406 case SVGA3D_STENCILOP_INVERT:
4407 return GL_INVERT;
4408 case SVGA3D_STENCILOP_INCR:
4409 return GL_INCR;
4410 case SVGA3D_STENCILOP_DECR:
4411 return GL_DECR;
4412 default:
4413 Assert(stencilOp == SVGA3D_STENCILOP_INVALID);
4414 return GL_KEEP;
4415 }
4416}
4417
4418static DECLCALLBACK(int) vmsvga3dBackSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
4419{
4420 uint32_t val = UINT32_MAX; /* Shut up MSC. */
4421 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4422 AssertReturn(pState, VERR_NO_MEMORY);
4423
4424 Log(("vmsvga3dSetRenderState cid=%u cRenderStates=%d\n", cid, cRenderStates));
4425
4426 PVMSVGA3DCONTEXT pContext;
4427 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4428 AssertRCReturn(rc, rc);
4429
4430 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
4431
4432 for (unsigned i = 0; i < cRenderStates; i++)
4433 {
4434 GLenum enableCap = ~(GLenum)0;
4435 Log(("vmsvga3dSetRenderState: cid=%u state=%s (%d) val=%x\n", cid, vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
4436 /* Save the render state for vm state saving. */
4437 ASSERT_GUEST_RETURN((unsigned)pRenderState[i].state < SVGA3D_RS_MAX, VERR_INVALID_PARAMETER);
4438 pContext->state.aRenderState[pRenderState[i].state] = pRenderState[i];
4439
4440 switch (pRenderState[i].state)
4441 {
4442 case SVGA3D_RS_ZENABLE: /* SVGA3dBool */
4443 enableCap = GL_DEPTH_TEST;
4444 val = pRenderState[i].uintValue;
4445 break;
4446
4447 case SVGA3D_RS_ZWRITEENABLE: /* SVGA3dBool */
4448 glDepthMask(!!pRenderState[i].uintValue);
4449 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4450 break;
4451
4452 case SVGA3D_RS_ALPHATESTENABLE: /* SVGA3dBool */
4453 enableCap = GL_ALPHA_TEST;
4454 val = pRenderState[i].uintValue;
4455 break;
4456
4457 case SVGA3D_RS_DITHERENABLE: /* SVGA3dBool */
4458 enableCap = GL_DITHER;
4459 val = pRenderState[i].uintValue;
4460 break;
4461
4462 case SVGA3D_RS_FOGENABLE: /* SVGA3dBool */
4463 enableCap = GL_FOG;
4464 val = pRenderState[i].uintValue;
4465 break;
4466
4467 case SVGA3D_RS_SPECULARENABLE: /* SVGA3dBool */
4468 Log(("vmsvga3dSetRenderState: WARNING: not applicable.\n"));
4469 break;
4470
4471 case SVGA3D_RS_LIGHTINGENABLE: /* SVGA3dBool */
4472 enableCap = GL_LIGHTING;
4473 val = pRenderState[i].uintValue;
4474 break;
4475
4476 case SVGA3D_RS_NORMALIZENORMALS: /* SVGA3dBool */
4477 /* not applicable */
4478 Log(("vmsvga3dSetRenderState: WARNING: not applicable.\n"));
4479 break;
4480
4481 case SVGA3D_RS_POINTSPRITEENABLE: /* SVGA3dBool */
4482 enableCap = GL_POINT_SPRITE_ARB;
4483 val = pRenderState[i].uintValue;
4484 break;
4485
4486 case SVGA3D_RS_POINTSIZE: /* float */
4487 /** @todo we need to apply scaling for point sizes below the min or above the max; see Wine) */
4488 if (pRenderState[i].floatValue < pState->caps.flPointSize[0])
4489 pRenderState[i].floatValue = pState->caps.flPointSize[0];
4490 if (pRenderState[i].floatValue > pState->caps.flPointSize[1])
4491 pRenderState[i].floatValue = pState->caps.flPointSize[1];
4492
4493 glPointSize(pRenderState[i].floatValue);
4494 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4495 Log(("SVGA3D_RS_POINTSIZE: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
4496 break;
4497
4498 case SVGA3D_RS_POINTSIZEMIN: /* float */
4499 pState->ext.glPointParameterf(GL_POINT_SIZE_MIN, pRenderState[i].floatValue);
4500 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4501 Log(("SVGA3D_RS_POINTSIZEMIN: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
4502 break;
4503
4504 case SVGA3D_RS_POINTSIZEMAX: /* float */
4505 pState->ext.glPointParameterf(GL_POINT_SIZE_MAX, pRenderState[i].floatValue);
4506 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4507 Log(("SVGA3D_RS_POINTSIZEMAX: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
4508 break;
4509
4510 case SVGA3D_RS_POINTSCALEENABLE: /* SVGA3dBool */
4511 case SVGA3D_RS_POINTSCALE_A: /* float */
4512 case SVGA3D_RS_POINTSCALE_B: /* float */
4513 case SVGA3D_RS_POINTSCALE_C: /* float */
4514 Log(("vmsvga3dSetRenderState: WARNING: not applicable.\n"));
4515 break;
4516
4517 case SVGA3D_RS_AMBIENT: /* SVGA3dColor */
4518 {
4519 GLfloat color[4]; /* red, green, blue, alpha */
4520
4521 vmsvgaColor2GLFloatArray(pRenderState[i].uintValue, &color[0], &color[1], &color[2], &color[3]);
4522
4523 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, color);
4524 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4525 break;
4526 }
4527
4528 case SVGA3D_RS_CLIPPLANEENABLE: /* SVGA3dClipPlanes */
4529 {
4530 for (uint32_t j = 0; j < SVGA3D_NUM_CLIPPLANES; j++)
4531 {
4532 if (pRenderState[i].uintValue & RT_BIT(j))
4533 glEnable(GL_CLIP_PLANE0 + j);
4534 else
4535 glDisable(GL_CLIP_PLANE0 + j);
4536 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4537 }
4538 break;
4539 }
4540
4541 case SVGA3D_RS_FOGCOLOR: /* SVGA3dColor */
4542 {
4543 GLfloat color[4]; /* red, green, blue, alpha */
4544
4545 vmsvgaColor2GLFloatArray(pRenderState[i].uintValue, &color[0], &color[1], &color[2], &color[3]);
4546
4547 glFogfv(GL_FOG_COLOR, color);
4548 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4549 break;
4550 }
4551
4552 case SVGA3D_RS_FOGSTART: /* float */
4553 glFogf(GL_FOG_START, pRenderState[i].floatValue);
4554 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4555 break;
4556
4557 case SVGA3D_RS_FOGEND: /* float */
4558 glFogf(GL_FOG_END, pRenderState[i].floatValue);
4559 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4560 break;
4561
4562 case SVGA3D_RS_FOGDENSITY: /* float */
4563 glFogf(GL_FOG_DENSITY, pRenderState[i].floatValue);
4564 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4565 break;
4566
4567 case SVGA3D_RS_RANGEFOGENABLE: /* SVGA3dBool */
4568 glFogi(GL_FOG_COORD_SRC, (pRenderState[i].uintValue) ? GL_FOG_COORD : GL_FRAGMENT_DEPTH);
4569 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4570 break;
4571
4572 case SVGA3D_RS_FOGMODE: /* SVGA3dFogMode */
4573 {
4574 SVGA3dFogMode mode;
4575 mode.uintValue = pRenderState[i].uintValue;
4576
4577 enableCap = GL_FOG_MODE;
4578 switch (mode.function)
4579 {
4580 case SVGA3D_FOGFUNC_EXP:
4581 val = GL_EXP;
4582 break;
4583 case SVGA3D_FOGFUNC_EXP2:
4584 val = GL_EXP2;
4585 break;
4586 case SVGA3D_FOGFUNC_LINEAR:
4587 val = GL_LINEAR;
4588 break;
4589 default:
4590 AssertMsgFailedReturn(("Unexpected fog function %d\n", mode.function), VERR_INTERNAL_ERROR);
4591 break;
4592 }
4593
4594 /** @todo how to switch between vertex and pixel fog modes??? */
4595 Assert(mode.type == SVGA3D_FOGTYPE_PIXEL);
4596#if 0
4597 /* The fog type determines the render state. */
4598 switch (mode.type)
4599 {
4600 case SVGA3D_FOGTYPE_VERTEX:
4601 renderState = D3DRS_FOGVERTEXMODE;
4602 break;
4603 case SVGA3D_FOGTYPE_PIXEL:
4604 renderState = D3DRS_FOGTABLEMODE;
4605 break;
4606 default:
4607 AssertMsgFailedReturn(("Unexpected fog type %d\n", mode.type), VERR_INTERNAL_ERROR);
4608 break;
4609 }
4610#endif
4611
4612 /* Set the fog base to depth or range. */
4613 switch (mode.base)
4614 {
4615 case SVGA3D_FOGBASE_DEPTHBASED:
4616 glFogi(GL_FOG_COORD_SRC, GL_FRAGMENT_DEPTH);
4617 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4618 break;
4619 case SVGA3D_FOGBASE_RANGEBASED:
4620 glFogi(GL_FOG_COORD_SRC, GL_FOG_COORD);
4621 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4622 break;
4623 default:
4624 /* ignore */
4625 AssertMsgFailed(("Unexpected fog base %d\n", mode.base));
4626 break;
4627 }
4628 break;
4629 }
4630
4631 case SVGA3D_RS_FILLMODE: /* SVGA3dFillMode */
4632 {
4633 SVGA3dFillMode mode;
4634
4635 mode.uintValue = pRenderState[i].uintValue;
4636
4637 switch (mode.mode)
4638 {
4639 case SVGA3D_FILLMODE_POINT:
4640 val = GL_POINT;
4641 break;
4642 case SVGA3D_FILLMODE_LINE:
4643 val = GL_LINE;
4644 break;
4645 case SVGA3D_FILLMODE_FILL:
4646 val = GL_FILL;
4647 break;
4648 default:
4649 AssertMsgFailedReturn(("Unexpected fill mode %d\n", mode.mode), VERR_INTERNAL_ERROR);
4650 break;
4651 }
4652 /* Only front and back faces. Also recent Mesa guest drivers initialize the 'face' to zero. */
4653 ASSERT_GUEST(mode.face == SVGA3D_FACE_FRONT_BACK || mode.face == SVGA3D_FACE_INVALID);
4654 glPolygonMode(GL_FRONT_AND_BACK, val);
4655 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4656 break;
4657 }
4658
4659 case SVGA3D_RS_SHADEMODE: /* SVGA3dShadeMode */
4660 switch (pRenderState[i].uintValue)
4661 {
4662 case SVGA3D_SHADEMODE_FLAT:
4663 val = GL_FLAT;
4664 break;
4665
4666 case SVGA3D_SHADEMODE_SMOOTH:
4667 val = GL_SMOOTH;
4668 break;
4669
4670 default:
4671 AssertMsgFailedReturn(("Unexpected shade mode %d\n", pRenderState[i].uintValue), VERR_INTERNAL_ERROR);
4672 break;
4673 }
4674
4675 glShadeModel(val);
4676 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4677 break;
4678
4679 case SVGA3D_RS_LINEPATTERN: /* SVGA3dLinePattern */
4680 /* No longer supported by d3d; mesagl comments suggest not all backends support it */
4681 /** @todo */
4682 Log(("WARNING: SVGA3D_RS_LINEPATTERN %x not supported!!\n", pRenderState[i].uintValue));
4683 /*
4684 renderState = D3DRS_LINEPATTERN;
4685 val = pRenderState[i].uintValue;
4686 */
4687 break;
4688
4689 case SVGA3D_RS_ANTIALIASEDLINEENABLE: /* SVGA3dBool */
4690 enableCap = GL_LINE_SMOOTH;
4691 val = pRenderState[i].uintValue;
4692 break;
4693
4694 case SVGA3D_RS_LINEWIDTH: /* float */
4695 glLineWidth(pRenderState[i].floatValue);
4696 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4697 break;
4698
4699 case SVGA3D_RS_SEPARATEALPHABLENDENABLE: /* SVGA3dBool */
4700 {
4701 /* Refresh the blending state based on the new enable setting.
4702 * This will take existing states and set them using either glBlend* or glBlend*Separate.
4703 */
4704 static SVGA3dRenderStateName const saRefreshState[] =
4705 {
4706 SVGA3D_RS_SRCBLEND,
4707 SVGA3D_RS_BLENDEQUATION
4708 };
4709 SVGA3dRenderState renderstate[RT_ELEMENTS(saRefreshState)];
4710 for (uint32_t j = 0; j < RT_ELEMENTS(saRefreshState); ++j)
4711 {
4712 renderstate[j].state = saRefreshState[j];
4713 renderstate[j].uintValue = pContext->state.aRenderState[saRefreshState[j]].uintValue;
4714 }
4715
4716 rc = vmsvga3dBackSetRenderState(pThisCC, cid, 2, renderstate);
4717 AssertRCReturn(rc, rc);
4718
4719 if (pContext->state.aRenderState[SVGA3D_RS_BLENDENABLE].uintValue != 0)
4720 continue; /* Ignore if blend is enabled */
4721 /* Apply SVGA3D_RS_SEPARATEALPHABLENDENABLE as SVGA3D_RS_BLENDENABLE */
4722 } RT_FALL_THRU();
4723
4724 case SVGA3D_RS_BLENDENABLE: /* SVGA3dBool */
4725 enableCap = GL_BLEND;
4726 val = pRenderState[i].uintValue;
4727 break;
4728
4729 case SVGA3D_RS_SRCBLENDALPHA: /* SVGA3dBlendOp */
4730 case SVGA3D_RS_DSTBLENDALPHA: /* SVGA3dBlendOp */
4731 case SVGA3D_RS_SRCBLEND: /* SVGA3dBlendOp */
4732 case SVGA3D_RS_DSTBLEND: /* SVGA3dBlendOp */
4733 {
4734 GLint srcRGB, srcAlpha, dstRGB, dstAlpha;
4735 GLint blendop = vmsvga3dBlendOp2GL(pRenderState[i].uintValue);
4736
4737 glGetIntegerv(GL_BLEND_SRC_RGB, &srcRGB);
4738 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4739 glGetIntegerv(GL_BLEND_DST_RGB, &dstRGB);
4740 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4741 glGetIntegerv(GL_BLEND_DST_ALPHA, &dstAlpha);
4742 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4743 glGetIntegerv(GL_BLEND_SRC_ALPHA, &srcAlpha);
4744 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4745
4746 switch (pRenderState[i].state)
4747 {
4748 case SVGA3D_RS_SRCBLEND:
4749 srcRGB = blendop;
4750 break;
4751 case SVGA3D_RS_DSTBLEND:
4752 dstRGB = blendop;
4753 break;
4754 case SVGA3D_RS_SRCBLENDALPHA:
4755 srcAlpha = blendop;
4756 break;
4757 case SVGA3D_RS_DSTBLENDALPHA:
4758 dstAlpha = blendop;
4759 break;
4760 default:
4761 /* not possible; shut up gcc */
4762 AssertFailed();
4763 break;
4764 }
4765
4766 if (pContext->state.aRenderState[SVGA3D_RS_SEPARATEALPHABLENDENABLE].uintValue != 0)
4767 pState->ext.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
4768 else
4769 glBlendFunc(srcRGB, dstRGB);
4770 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4771 break;
4772 }
4773
4774 case SVGA3D_RS_BLENDEQUATIONALPHA: /* SVGA3dBlendEquation */
4775 case SVGA3D_RS_BLENDEQUATION: /* SVGA3dBlendEquation */
4776 if (pContext->state.aRenderState[SVGA3D_RS_SEPARATEALPHABLENDENABLE].uintValue != 0)
4777 {
4778 GLenum const modeRGB = vmsvga3dBlendEquation2GL(pContext->state.aRenderState[SVGA3D_RS_BLENDEQUATION].uintValue);
4779 GLenum const modeAlpha = vmsvga3dBlendEquation2GL(pContext->state.aRenderState[SVGA3D_RS_BLENDEQUATIONALPHA].uintValue);
4780 pState->ext.glBlendEquationSeparate(modeRGB, modeAlpha);
4781 }
4782 else
4783 {
4784#if VBOX_VMSVGA3D_GL_HACK_LEVEL >= 0x102
4785 glBlendEquation(vmsvga3dBlendEquation2GL(pRenderState[i].uintValue));
4786#else
4787 pState->ext.glBlendEquation(vmsvga3dBlendEquation2GL(pRenderState[i].uintValue));
4788#endif
4789 }
4790 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4791 break;
4792
4793 case SVGA3D_RS_BLENDCOLOR: /* SVGA3dColor */
4794 {
4795 GLfloat red, green, blue, alpha;
4796
4797 vmsvgaColor2GLFloatArray(pRenderState[i].uintValue, &red, &green, &blue, &alpha);
4798
4799#if VBOX_VMSVGA3D_GL_HACK_LEVEL >= 0x102
4800 glBlendColor(red, green, blue, alpha);
4801#else
4802 pState->ext.glBlendColor(red, green, blue, alpha);
4803#endif
4804 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4805 break;
4806 }
4807
4808 case SVGA3D_RS_CULLMODE: /* SVGA3dFace */
4809 {
4810 GLenum mode = GL_BACK; /* default for OpenGL */
4811
4812 switch (pRenderState[i].uintValue)
4813 {
4814 case SVGA3D_FACE_NONE:
4815 break;
4816 case SVGA3D_FACE_FRONT:
4817 mode = GL_FRONT;
4818 break;
4819 case SVGA3D_FACE_BACK:
4820 mode = GL_BACK;
4821 break;
4822 case SVGA3D_FACE_FRONT_BACK:
4823 mode = GL_FRONT_AND_BACK;
4824 break;
4825 default:
4826 AssertMsgFailedReturn(("Unexpected cull mode %d\n", pRenderState[i].uintValue), VERR_INTERNAL_ERROR);
4827 break;
4828 }
4829 enableCap = GL_CULL_FACE;
4830 if (pRenderState[i].uintValue != SVGA3D_FACE_NONE)
4831 {
4832 glCullFace(mode);
4833 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4834 val = 1;
4835 }
4836 else
4837 val = 0;
4838 break;
4839 }
4840
4841 case SVGA3D_RS_ZFUNC: /* SVGA3dCmpFunc */
4842 glDepthFunc(vmsvgaCmpFunc2GL(pRenderState[i].uintValue));
4843 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4844 break;
4845
4846 case SVGA3D_RS_ALPHAFUNC: /* SVGA3dCmpFunc */
4847 {
4848 GLclampf ref;
4849
4850 glGetFloatv(GL_ALPHA_TEST_REF, &ref);
4851 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4852 glAlphaFunc(vmsvgaCmpFunc2GL(pRenderState[i].uintValue), ref);
4853 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4854 break;
4855 }
4856
4857 case SVGA3D_RS_ALPHAREF: /* float (0.0 .. 1.0) */
4858 {
4859 GLint func;
4860
4861 glGetIntegerv(GL_ALPHA_TEST_FUNC, &func);
4862 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4863 glAlphaFunc(func, pRenderState[i].floatValue);
4864 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4865 break;
4866 }
4867
4868 case SVGA3D_RS_STENCILENABLE2SIDED: /* SVGA3dBool */
4869 {
4870 /* Refresh the stencil state based on the new enable setting.
4871 * This will take existing states and set them using either glStencil or glStencil*Separate.
4872 */
4873 static SVGA3dRenderStateName const saRefreshState[] =
4874 {
4875 SVGA3D_RS_STENCILFUNC,
4876 SVGA3D_RS_STENCILFAIL,
4877 SVGA3D_RS_CCWSTENCILFUNC,
4878 SVGA3D_RS_CCWSTENCILFAIL
4879 };
4880 SVGA3dRenderState renderstate[RT_ELEMENTS(saRefreshState)];
4881 for (uint32_t j = 0; j < RT_ELEMENTS(saRefreshState); ++j)
4882 {
4883 renderstate[j].state = saRefreshState[j];
4884 renderstate[j].uintValue = pContext->state.aRenderState[saRefreshState[j]].uintValue;
4885 }
4886
4887 rc = vmsvga3dBackSetRenderState(pThisCC, cid, RT_ELEMENTS(renderstate), renderstate);
4888 AssertRCReturn(rc, rc);
4889
4890 if (pContext->state.aRenderState[SVGA3D_RS_STENCILENABLE].uintValue != 0)
4891 continue; /* Ignore if stencil is enabled */
4892 /* Apply SVGA3D_RS_STENCILENABLE2SIDED as SVGA3D_RS_STENCILENABLE. */
4893 } RT_FALL_THRU();
4894
4895 case SVGA3D_RS_STENCILENABLE: /* SVGA3dBool */
4896 enableCap = GL_STENCIL_TEST;
4897 val = pRenderState[i].uintValue;
4898 break;
4899
4900 case SVGA3D_RS_STENCILFUNC: /* SVGA3dCmpFunc */
4901 case SVGA3D_RS_STENCILREF: /* uint32_t */
4902 case SVGA3D_RS_STENCILMASK: /* uint32_t */
4903 {
4904 GLint func, ref;
4905 GLuint mask;
4906
4907 /* Query current values to have all parameters for glStencilFunc[Separate]. */
4908 glGetIntegerv(GL_STENCIL_FUNC, &func);
4909 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4910 glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)&mask);
4911 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4912 glGetIntegerv(GL_STENCIL_REF, &ref);
4913 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4914
4915 /* Update the changed value. */
4916 switch (pRenderState[i].state)
4917 {
4918 case SVGA3D_RS_STENCILFUNC: /* SVGA3dCmpFunc */
4919 func = vmsvgaCmpFunc2GL(pRenderState[i].uintValue);
4920 break;
4921
4922 case SVGA3D_RS_STENCILREF: /* uint32_t */
4923 ref = pRenderState[i].uintValue;
4924 break;
4925
4926 case SVGA3D_RS_STENCILMASK: /* uint32_t */
4927 mask = pRenderState[i].uintValue;
4928 break;
4929
4930 default:
4931 /* not possible; shut up gcc */
4932 AssertFailed();
4933 break;
4934 }
4935
4936 if (pContext->state.aRenderState[SVGA3D_RS_STENCILENABLE2SIDED].uintValue != 0)
4937 {
4938 pState->ext.glStencilFuncSeparate(GL_FRONT, func, ref, mask);
4939 }
4940 else
4941 {
4942 glStencilFunc(func, ref, mask);
4943 }
4944 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4945 break;
4946 }
4947
4948 case SVGA3D_RS_STENCILWRITEMASK: /* uint32_t */
4949 glStencilMask(pRenderState[i].uintValue);
4950 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4951 break;
4952
4953 case SVGA3D_RS_STENCILFAIL: /* SVGA3dStencilOp */
4954 case SVGA3D_RS_STENCILZFAIL: /* SVGA3dStencilOp */
4955 case SVGA3D_RS_STENCILPASS: /* SVGA3dStencilOp */
4956 {
4957 GLint sfail, dpfail, dppass;
4958 GLenum const stencilop = vmsvgaStencipOp2GL(pRenderState[i].uintValue);
4959
4960 glGetIntegerv(GL_STENCIL_FAIL, &sfail);
4961 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4962 glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &dpfail);
4963 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4964 glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &dppass);
4965 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4966
4967 switch (pRenderState[i].state)
4968 {
4969 case SVGA3D_RS_STENCILFAIL: /* SVGA3dStencilOp */
4970 sfail = stencilop;
4971 break;
4972 case SVGA3D_RS_STENCILZFAIL: /* SVGA3dStencilOp */
4973 dpfail = stencilop;
4974 break;
4975 case SVGA3D_RS_STENCILPASS: /* SVGA3dStencilOp */
4976 dppass = stencilop;
4977 break;
4978 default:
4979 /* not possible; shut up gcc */
4980 AssertFailed();
4981 break;
4982 }
4983 if (pContext->state.aRenderState[SVGA3D_RS_STENCILENABLE2SIDED].uintValue != 0)
4984 {
4985 pState->ext.glStencilOpSeparate(GL_FRONT, sfail, dpfail, dppass);
4986 }
4987 else
4988 {
4989 glStencilOp(sfail, dpfail, dppass);
4990 }
4991 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
4992 break;
4993 }
4994
4995 case SVGA3D_RS_CCWSTENCILFUNC: /* SVGA3dCmpFunc */
4996 {
4997 GLint ref;
4998 GLuint mask;
4999 GLint const func = vmsvgaCmpFunc2GL(pRenderState[i].uintValue);
5000
5001 /* GL_STENCIL_VALUE_MASK and GL_STENCIL_REF are the same for both GL_FRONT and GL_BACK. */
5002 glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)&mask);
5003 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5004 glGetIntegerv(GL_STENCIL_REF, &ref);
5005 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5006
5007 pState->ext.glStencilFuncSeparate(GL_BACK, func, ref, mask);
5008 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5009 break;
5010 }
5011
5012 case SVGA3D_RS_CCWSTENCILFAIL: /* SVGA3dStencilOp */
5013 case SVGA3D_RS_CCWSTENCILZFAIL: /* SVGA3dStencilOp */
5014 case SVGA3D_RS_CCWSTENCILPASS: /* SVGA3dStencilOp */
5015 {
5016 GLint sfail, dpfail, dppass;
5017 GLenum const stencilop = vmsvgaStencipOp2GL(pRenderState[i].uintValue);
5018
5019 glGetIntegerv(GL_STENCIL_BACK_FAIL, &sfail);
5020 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5021 glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &dpfail);
5022 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5023 glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &dppass);
5024 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5025
5026 switch (pRenderState[i].state)
5027 {
5028 case SVGA3D_RS_CCWSTENCILFAIL: /* SVGA3dStencilOp */
5029 sfail = stencilop;
5030 break;
5031 case SVGA3D_RS_CCWSTENCILZFAIL: /* SVGA3dStencilOp */
5032 dpfail = stencilop;
5033 break;
5034 case SVGA3D_RS_CCWSTENCILPASS: /* SVGA3dStencilOp */
5035 dppass = stencilop;
5036 break;
5037 default:
5038 /* not possible; shut up gcc */
5039 AssertFailed();
5040 break;
5041 }
5042 pState->ext.glStencilOpSeparate(GL_BACK, sfail, dpfail, dppass);
5043 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5044 break;
5045 }
5046
5047 case SVGA3D_RS_ZBIAS: /* float */
5048 /** @todo unknown meaning; depth bias is not identical
5049 renderState = D3DRS_DEPTHBIAS;
5050 val = pRenderState[i].uintValue;
5051 */
5052 Log(("vmsvga3dSetRenderState: WARNING unsupported SVGA3D_RS_ZBIAS\n"));
5053 break;
5054
5055 case SVGA3D_RS_DEPTHBIAS: /* float */
5056 {
5057 GLfloat factor;
5058
5059 /** @todo not sure if the d3d & ogl definitions are identical. */
5060
5061 /* Do not change the factor part. */
5062 glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &factor);
5063 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5064
5065 glPolygonOffset(factor, pRenderState[i].floatValue);
5066 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5067 break;
5068 }
5069
5070 case SVGA3D_RS_SLOPESCALEDEPTHBIAS: /* float */
5071 {
5072 GLfloat units;
5073
5074 /** @todo not sure if the d3d & ogl definitions are identical. */
5075
5076 /* Do not change the factor part. */
5077 glGetFloatv(GL_POLYGON_OFFSET_UNITS, &units);
5078 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5079
5080 glPolygonOffset(pRenderState[i].floatValue, units);
5081 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5082 break;
5083 }
5084
5085 case SVGA3D_RS_COLORWRITEENABLE: /* SVGA3dColorMask */
5086 {
5087 GLboolean red, green, blue, alpha;
5088 SVGA3dColorMask mask;
5089
5090 mask.uintValue = pRenderState[i].uintValue;
5091
5092 red = mask.red;
5093 green = mask.green;
5094 blue = mask.blue;
5095 alpha = mask.alpha;
5096
5097 glColorMask(red, green, blue, alpha);
5098 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5099 break;
5100 }
5101
5102 case SVGA3D_RS_COLORWRITEENABLE1: /* SVGA3dColorMask to D3DCOLORWRITEENABLE_* */
5103 case SVGA3D_RS_COLORWRITEENABLE2: /* SVGA3dColorMask to D3DCOLORWRITEENABLE_* */
5104 case SVGA3D_RS_COLORWRITEENABLE3: /* SVGA3dColorMask to D3DCOLORWRITEENABLE_* */
5105 Log(("vmsvga3dSetRenderState: WARNING SVGA3D_RS_COLORWRITEENABLEx not supported!!\n"));
5106 break;
5107
5108 case SVGA3D_RS_SCISSORTESTENABLE: /* SVGA3dBool */
5109 enableCap = GL_SCISSOR_TEST;
5110 val = pRenderState[i].uintValue;
5111 break;
5112
5113#if 0
5114 case SVGA3D_RS_DIFFUSEMATERIALSOURCE: /* SVGA3dVertexMaterial */
5115 AssertCompile(D3DMCS_COLOR2 == SVGA3D_VERTEXMATERIAL_SPECULAR);
5116 renderState = D3DRS_DIFFUSEMATERIALSOURCE;
5117 val = pRenderState[i].uintValue;
5118 break;
5119
5120 case SVGA3D_RS_SPECULARMATERIALSOURCE: /* SVGA3dVertexMaterial */
5121 renderState = D3DRS_SPECULARMATERIALSOURCE;
5122 val = pRenderState[i].uintValue;
5123 break;
5124
5125 case SVGA3D_RS_AMBIENTMATERIALSOURCE: /* SVGA3dVertexMaterial */
5126 renderState = D3DRS_AMBIENTMATERIALSOURCE;
5127 val = pRenderState[i].uintValue;
5128 break;
5129
5130 case SVGA3D_RS_EMISSIVEMATERIALSOURCE: /* SVGA3dVertexMaterial */
5131 renderState = D3DRS_EMISSIVEMATERIALSOURCE;
5132 val = pRenderState[i].uintValue;
5133 break;
5134#endif
5135
5136 case SVGA3D_RS_WRAP3: /* SVGA3dWrapFlags */
5137 case SVGA3D_RS_WRAP4: /* SVGA3dWrapFlags */
5138 case SVGA3D_RS_WRAP5: /* SVGA3dWrapFlags */
5139 case SVGA3D_RS_WRAP6: /* SVGA3dWrapFlags */
5140 case SVGA3D_RS_WRAP7: /* SVGA3dWrapFlags */
5141 case SVGA3D_RS_WRAP8: /* SVGA3dWrapFlags */
5142 case SVGA3D_RS_WRAP9: /* SVGA3dWrapFlags */
5143 case SVGA3D_RS_WRAP10: /* SVGA3dWrapFlags */
5144 case SVGA3D_RS_WRAP11: /* SVGA3dWrapFlags */
5145 case SVGA3D_RS_WRAP12: /* SVGA3dWrapFlags */
5146 case SVGA3D_RS_WRAP13: /* SVGA3dWrapFlags */
5147 case SVGA3D_RS_WRAP14: /* SVGA3dWrapFlags */
5148 case SVGA3D_RS_WRAP15: /* SVGA3dWrapFlags */
5149 Log(("vmsvga3dSetRenderState: WARNING unsupported SVGA3D_WRAPx (x >= 3)\n"));
5150 break;
5151
5152 case SVGA3D_RS_LASTPIXEL: /* SVGA3dBool */
5153 case SVGA3D_RS_TWEENFACTOR: /* float */
5154 case SVGA3D_RS_INDEXEDVERTEXBLENDENABLE: /* SVGA3dBool */
5155 case SVGA3D_RS_VERTEXBLEND: /* SVGA3dVertexBlendFlags */
5156 Log(("vmsvga3dSetRenderState: WARNING not applicable!!\n"));
5157 break;
5158
5159 case SVGA3D_RS_MULTISAMPLEANTIALIAS: /* SVGA3dBool */
5160 enableCap = GL_MULTISAMPLE;
5161 val = pRenderState[i].uintValue;
5162 break;
5163
5164 case SVGA3D_RS_MULTISAMPLEMASK: /* uint32_t */
5165 Log(("vmsvga3dSetRenderState: WARNING not applicable??!!\n"));
5166 break;
5167
5168 case SVGA3D_RS_COORDINATETYPE: /* SVGA3dCoordinateType */
5169 Assert(pRenderState[i].uintValue == SVGA3D_COORDINATE_LEFTHANDED);
5170 /** @todo setup a view matrix to scale the world space by -1 in the z-direction for right handed coordinates. */
5171 /*
5172 renderState = D3DRS_COORDINATETYPE;
5173 val = pRenderState[i].uintValue;
5174 */
5175 break;
5176
5177 case SVGA3D_RS_FRONTWINDING: /* SVGA3dFrontWinding */
5178 Assert(pRenderState[i].uintValue == SVGA3D_FRONTWINDING_CW);
5179 /* Invert the selected mode because of y-inversion (?) */
5180 glFrontFace((pRenderState[i].uintValue != SVGA3D_FRONTWINDING_CW) ? GL_CW : GL_CCW);
5181 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5182 break;
5183
5184 case SVGA3D_RS_OUTPUTGAMMA: /* float */
5185 //AssertFailed();
5186 /*
5187 D3DRS_SRGBWRITEENABLE ??
5188 renderState = D3DRS_OUTPUTGAMMA;
5189 val = pRenderState[i].uintValue;
5190 */
5191 break;
5192
5193#if 0
5194
5195 case SVGA3D_RS_VERTEXMATERIALENABLE: /* SVGA3dBool */
5196 //AssertFailed();
5197 renderState = D3DRS_INDEXEDVERTEXBLENDENABLE; /* correct?? */
5198 val = pRenderState[i].uintValue;
5199 break;
5200
5201 case SVGA3D_RS_TEXTUREFACTOR: /* SVGA3dColor */
5202 renderState = D3DRS_TEXTUREFACTOR;
5203 val = pRenderState[i].uintValue;
5204 break;
5205
5206 case SVGA3D_RS_LOCALVIEWER: /* SVGA3dBool */
5207 renderState = D3DRS_LOCALVIEWER;
5208 val = pRenderState[i].uintValue;
5209 break;
5210
5211 case SVGA3D_RS_ZVISIBLE: /* SVGA3dBool */
5212 AssertFailed();
5213 /*
5214 renderState = D3DRS_ZVISIBLE;
5215 val = pRenderState[i].uintValue;
5216 */
5217 break;
5218
5219 case SVGA3D_RS_CLIPPING: /* SVGA3dBool */
5220 renderState = D3DRS_CLIPPING;
5221 val = pRenderState[i].uintValue;
5222 break;
5223
5224 case SVGA3D_RS_WRAP0: /* SVGA3dWrapFlags */
5225 glTexParameter GL_TEXTURE_WRAP_S
5226 Assert(SVGA3D_WRAPCOORD_3 == D3DWRAPCOORD_3);
5227 renderState = D3DRS_WRAP0;
5228 val = pRenderState[i].uintValue;
5229 break;
5230
5231 case SVGA3D_RS_WRAP1: /* SVGA3dWrapFlags */
5232 glTexParameter GL_TEXTURE_WRAP_T
5233 renderState = D3DRS_WRAP1;
5234 val = pRenderState[i].uintValue;
5235 break;
5236
5237 case SVGA3D_RS_WRAP2: /* SVGA3dWrapFlags */
5238 glTexParameter GL_TEXTURE_WRAP_R
5239 renderState = D3DRS_WRAP2;
5240 val = pRenderState[i].uintValue;
5241 break;
5242
5243
5244 case SVGA3D_RS_SEPARATEALPHABLENDENABLE: /* SVGA3dBool */
5245 renderState = D3DRS_SEPARATEALPHABLENDENABLE;
5246 val = pRenderState[i].uintValue;
5247 break;
5248
5249
5250 case SVGA3D_RS_BLENDEQUATIONALPHA: /* SVGA3dBlendEquation */
5251 renderState = D3DRS_BLENDOPALPHA;
5252 val = pRenderState[i].uintValue;
5253 break;
5254
5255 case SVGA3D_RS_TRANSPARENCYANTIALIAS: /* SVGA3dTransparencyAntialiasType */
5256 AssertFailed();
5257 /*
5258 renderState = D3DRS_TRANSPARENCYANTIALIAS;
5259 val = pRenderState[i].uintValue;
5260 */
5261 break;
5262
5263#endif
5264 default:
5265 AssertFailed();
5266 break;
5267 }
5268
5269 if (enableCap != ~(GLenum)0)
5270 {
5271 if (val)
5272 glEnable(enableCap);
5273 else
5274 glDisable(enableCap);
5275 }
5276 }
5277
5278 return VINF_SUCCESS;
5279}
5280
5281static DECLCALLBACK(int) vmsvga3dBackSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
5282{
5283 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5284
5285 AssertReturn(pState, VERR_NO_MEMORY);
5286 AssertReturn((unsigned)type < SVGA3D_RT_MAX, VERR_INVALID_PARAMETER);
5287
5288 LogFunc(("cid=%u type=%x sid=%u\n", cid, type, target.sid));
5289
5290 PVMSVGA3DCONTEXT pContext;
5291 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5292 AssertRCReturn(rc, rc);
5293
5294 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
5295
5296 /* Save for vm state save/restore. */
5297 pContext->state.aRenderTargets[type] = target.sid;
5298
5299 if (target.sid == SVGA3D_INVALID_ID)
5300 {
5301 /* Disable render target. */
5302 switch (type)
5303 {
5304 case SVGA3D_RT_DEPTH:
5305 case SVGA3D_RT_STENCIL:
5306 pState->ext.glFramebufferRenderbuffer(GL_FRAMEBUFFER, (type == SVGA3D_RT_DEPTH) ? GL_DEPTH_ATTACHMENT : GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
5307 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5308 break;
5309
5310 case SVGA3D_RT_COLOR0:
5311 case SVGA3D_RT_COLOR1:
5312 case SVGA3D_RT_COLOR2:
5313 case SVGA3D_RT_COLOR3:
5314 case SVGA3D_RT_COLOR4:
5315 case SVGA3D_RT_COLOR5:
5316 case SVGA3D_RT_COLOR6:
5317 case SVGA3D_RT_COLOR7:
5318 pState->ext.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + type - SVGA3D_RT_COLOR0, 0, 0, 0);
5319 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5320 break;
5321
5322 default:
5323 AssertFailedReturn(VERR_INVALID_PARAMETER);
5324 }
5325 return VINF_SUCCESS;
5326 }
5327
5328 PVMSVGA3DSURFACE pRenderTarget;
5329 rc = vmsvga3dSurfaceFromSid(pState, target.sid, &pRenderTarget);
5330 AssertRCReturn(rc, rc);
5331
5332 switch (type)
5333 {
5334 case SVGA3D_RT_DEPTH:
5335 case SVGA3D_RT_STENCIL:
5336#if 1
5337 /* A texture surface can be used as a render target to fill it and later on used as a texture. */
5338 if (pRenderTarget->oglId.texture == OPENGL_INVALID_ID)
5339 {
5340 LogFunc(("create depth texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n",
5341 target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
5342 rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
5343 AssertRCReturn(rc, rc);
5344 }
5345
5346 AssertReturn(pRenderTarget->oglId.texture != OPENGL_INVALID_ID, VERR_INVALID_PARAMETER);
5347 Assert(!pRenderTarget->fDirty);
5348
5349 pRenderTarget->surfaceFlags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
5350
5351 pState->ext.glFramebufferTexture2D(GL_FRAMEBUFFER,
5352 (type == SVGA3D_RT_DEPTH) ? GL_DEPTH_ATTACHMENT : GL_STENCIL_ATTACHMENT,
5353 GL_TEXTURE_2D, pRenderTarget->oglId.texture, target.mipmap);
5354 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5355#else
5356 AssertReturn(target.mipmap == 0, VERR_INVALID_PARAMETER);
5357 if (pRenderTarget->oglId.texture == OPENGL_INVALID_ID)
5358 {
5359 Log(("vmsvga3dSetRenderTarget: create renderbuffer to be used as render target; surface id=%x type=%d format=%d\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->internalFormatGL));
5360 pContext = &pState->SharedCtx;
5361 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
5362
5363 pState->ext.glGenRenderbuffers(1, &pRenderTarget->oglId.renderbuffer);
5364 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5365 pSurface->enmOGLResType = VMSVGA3D_OGLRESTYPE_RENDERBUFFER;
5366
5367 pState->ext.glBindRenderbuffer(GL_RENDERBUFFER, pRenderTarget->oglId.renderbuffer);
5368 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5369
5370 pState->ext.glRenderbufferStorage(GL_RENDERBUFFER,
5371 pRenderTarget->internalFormatGL,
5372 pRenderTarget->paMipmapLevels[0].mipmapSize.width,
5373 pRenderTarget->paMipmapLevels[0].mipmapSize.height);
5374 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5375
5376 pState->ext.glBindRenderbuffer(GL_RENDERBUFFER, OPENGL_INVALID_ID);
5377 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5378
5379 pContext = pState->papContexts[cid];
5380 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
5381 }
5382
5383 pState->ext.glBindRenderbuffer(GL_RENDERBUFFER, pRenderTarget->oglId.renderbuffer);
5384 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5385 Assert(!pRenderTarget->fDirty);
5386 AssertReturn(pRenderTarget->oglId.texture != OPENGL_INVALID_ID, VERR_INVALID_PARAMETER);
5387
5388 pRenderTarget->surfaceFlags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
5389
5390 pState->ext.glFramebufferRenderbuffer(GL_FRAMEBUFFER,
5391 (type == SVGA3D_RT_DEPTH) ? GL_DEPTH_ATTACHMENT : GL_STENCIL_ATTACHMENT,
5392 GL_RENDERBUFFER, pRenderTarget->oglId.renderbuffer);
5393 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5394#endif
5395 break;
5396
5397 case SVGA3D_RT_COLOR0:
5398 case SVGA3D_RT_COLOR1:
5399 case SVGA3D_RT_COLOR2:
5400 case SVGA3D_RT_COLOR3:
5401 case SVGA3D_RT_COLOR4:
5402 case SVGA3D_RT_COLOR5:
5403 case SVGA3D_RT_COLOR6:
5404 case SVGA3D_RT_COLOR7:
5405 {
5406 /* A texture surface can be used as a render target to fill it and later on used as a texture. */
5407 if (pRenderTarget->oglId.texture == OPENGL_INVALID_ID)
5408 {
5409 Log(("vmsvga3dSetRenderTarget: create texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
5410 rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
5411 AssertRCReturn(rc, rc);
5412 }
5413
5414 AssertReturn(pRenderTarget->oglId.texture != OPENGL_INVALID_ID, VERR_INVALID_PARAMETER);
5415 Assert(!pRenderTarget->fDirty);
5416
5417 pRenderTarget->surfaceFlags |= SVGA3D_SURFACE_HINT_RENDERTARGET;
5418
5419 GLenum textarget;
5420 if (pRenderTarget->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
5421 textarget = vmsvga3dCubemapFaceFromIndex(target.face);
5422 else
5423 textarget = GL_TEXTURE_2D;
5424 pState->ext.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + type - SVGA3D_RT_COLOR0,
5425 textarget, pRenderTarget->oglId.texture, target.mipmap);
5426 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5427
5428#ifdef DEBUG
5429 GLenum status = pState->ext.glCheckFramebufferStatus(GL_FRAMEBUFFER);
5430 if (status != GL_FRAMEBUFFER_COMPLETE)
5431 Log(("vmsvga3dSetRenderTarget: WARNING: glCheckFramebufferStatus returned %x\n", status));
5432#endif
5433 /** @todo use glDrawBuffers too? */
5434 break;
5435 }
5436
5437 default:
5438 AssertFailedReturn(VERR_INVALID_PARAMETER);
5439 }
5440
5441 return VINF_SUCCESS;
5442}
5443
5444#if 0
5445/**
5446 * Convert SVGA texture combiner value to its D3D equivalent
5447 */
5448static DWORD vmsvga3dTextureCombiner2D3D(uint32_t value)
5449{
5450 switch (value)
5451 {
5452 case SVGA3D_TC_DISABLE:
5453 return D3DTOP_DISABLE;
5454 case SVGA3D_TC_SELECTARG1:
5455 return D3DTOP_SELECTARG1;
5456 case SVGA3D_TC_SELECTARG2:
5457 return D3DTOP_SELECTARG2;
5458 case SVGA3D_TC_MODULATE:
5459 return D3DTOP_MODULATE;
5460 case SVGA3D_TC_ADD:
5461 return D3DTOP_ADD;
5462 case SVGA3D_TC_ADDSIGNED:
5463 return D3DTOP_ADDSIGNED;
5464 case SVGA3D_TC_SUBTRACT:
5465 return D3DTOP_SUBTRACT;
5466 case SVGA3D_TC_BLENDTEXTUREALPHA:
5467 return D3DTOP_BLENDTEXTUREALPHA;
5468 case SVGA3D_TC_BLENDDIFFUSEALPHA:
5469 return D3DTOP_BLENDDIFFUSEALPHA;
5470 case SVGA3D_TC_BLENDCURRENTALPHA:
5471 return D3DTOP_BLENDCURRENTALPHA;
5472 case SVGA3D_TC_BLENDFACTORALPHA:
5473 return D3DTOP_BLENDFACTORALPHA;
5474 case SVGA3D_TC_MODULATE2X:
5475 return D3DTOP_MODULATE2X;
5476 case SVGA3D_TC_MODULATE4X:
5477 return D3DTOP_MODULATE4X;
5478 case SVGA3D_TC_DSDT:
5479 AssertFailed(); /** @todo ??? */
5480 return D3DTOP_DISABLE;
5481 case SVGA3D_TC_DOTPRODUCT3:
5482 return D3DTOP_DOTPRODUCT3;
5483 case SVGA3D_TC_BLENDTEXTUREALPHAPM:
5484 return D3DTOP_BLENDTEXTUREALPHAPM;
5485 case SVGA3D_TC_ADDSIGNED2X:
5486 return D3DTOP_ADDSIGNED2X;
5487 case SVGA3D_TC_ADDSMOOTH:
5488 return D3DTOP_ADDSMOOTH;
5489 case SVGA3D_TC_PREMODULATE:
5490 return D3DTOP_PREMODULATE;
5491 case SVGA3D_TC_MODULATEALPHA_ADDCOLOR:
5492 return D3DTOP_MODULATEALPHA_ADDCOLOR;
5493 case SVGA3D_TC_MODULATECOLOR_ADDALPHA:
5494 return D3DTOP_MODULATECOLOR_ADDALPHA;
5495 case SVGA3D_TC_MODULATEINVALPHA_ADDCOLOR:
5496 return D3DTOP_MODULATEINVALPHA_ADDCOLOR;
5497 case SVGA3D_TC_MODULATEINVCOLOR_ADDALPHA:
5498 return D3DTOP_MODULATEINVCOLOR_ADDALPHA;
5499 case SVGA3D_TC_BUMPENVMAPLUMINANCE:
5500 return D3DTOP_BUMPENVMAPLUMINANCE;
5501 case SVGA3D_TC_MULTIPLYADD:
5502 return D3DTOP_MULTIPLYADD;
5503 case SVGA3D_TC_LERP:
5504 return D3DTOP_LERP;
5505 default:
5506 AssertFailed();
5507 return D3DTOP_DISABLE;
5508 }
5509}
5510
5511/**
5512 * Convert SVGA texture arg data value to its D3D equivalent
5513 */
5514static DWORD vmsvga3dTextureArgData2D3D(uint32_t value)
5515{
5516 switch (value)
5517 {
5518 case SVGA3D_TA_CONSTANT:
5519 return D3DTA_CONSTANT;
5520 case SVGA3D_TA_PREVIOUS:
5521 return D3DTA_CURRENT; /* current = previous */
5522 case SVGA3D_TA_DIFFUSE:
5523 return D3DTA_DIFFUSE;
5524 case SVGA3D_TA_TEXTURE:
5525 return D3DTA_TEXTURE;
5526 case SVGA3D_TA_SPECULAR:
5527 return D3DTA_SPECULAR;
5528 default:
5529 AssertFailed();
5530 return 0;
5531 }
5532}
5533
5534/**
5535 * Convert SVGA texture transform flag value to its D3D equivalent
5536 */
5537static DWORD vmsvga3dTextTransformFlags2D3D(uint32_t value)
5538{
5539 switch (value)
5540 {
5541 case SVGA3D_TEX_TRANSFORM_OFF:
5542 return D3DTTFF_DISABLE;
5543 case SVGA3D_TEX_TRANSFORM_S:
5544 return D3DTTFF_COUNT1; /** @todo correct? */
5545 case SVGA3D_TEX_TRANSFORM_T:
5546 return D3DTTFF_COUNT2; /** @todo correct? */
5547 case SVGA3D_TEX_TRANSFORM_R:
5548 return D3DTTFF_COUNT3; /** @todo correct? */
5549 case SVGA3D_TEX_TRANSFORM_Q:
5550 return D3DTTFF_COUNT4; /** @todo correct? */
5551 case SVGA3D_TEX_PROJECTED:
5552 return D3DTTFF_PROJECTED;
5553 default:
5554 AssertFailed();
5555 return 0;
5556 }
5557}
5558#endif
5559
5560static GLenum vmsvga3dTextureAddress2OGL(SVGA3dTextureAddress value)
5561{
5562 switch (value)
5563 {
5564 case SVGA3D_TEX_ADDRESS_WRAP:
5565 return GL_REPEAT;
5566 case SVGA3D_TEX_ADDRESS_MIRROR:
5567 return GL_MIRRORED_REPEAT;
5568 case SVGA3D_TEX_ADDRESS_CLAMP:
5569 return GL_CLAMP_TO_EDGE;
5570 case SVGA3D_TEX_ADDRESS_BORDER:
5571 return GL_CLAMP_TO_BORDER;
5572 case SVGA3D_TEX_ADDRESS_MIRRORONCE:
5573 AssertFailed();
5574 return GL_CLAMP_TO_EDGE_SGIS; /** @todo correct? */
5575
5576 case SVGA3D_TEX_ADDRESS_EDGE:
5577 case SVGA3D_TEX_ADDRESS_INVALID:
5578 default:
5579 AssertFailed();
5580 return GL_REPEAT; /* default */
5581 }
5582}
5583
5584static GLenum vmsvga3dTextureFilter2OGL(SVGA3dTextureFilter value)
5585{
5586 switch (value)
5587 {
5588 case SVGA3D_TEX_FILTER_NONE:
5589 case SVGA3D_TEX_FILTER_LINEAR:
5590 case SVGA3D_TEX_FILTER_ANISOTROPIC: /* Anisotropic filtering is controlled by SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL */
5591 return GL_LINEAR;
5592 case SVGA3D_TEX_FILTER_NEAREST:
5593 return GL_NEAREST;
5594 case SVGA3D_TEX_FILTER_FLATCUBIC: // Deprecated, not implemented
5595 case SVGA3D_TEX_FILTER_GAUSSIANCUBIC: // Deprecated, not implemented
5596 case SVGA3D_TEX_FILTER_PYRAMIDALQUAD: // Not currently implemented
5597 case SVGA3D_TEX_FILTER_GAUSSIANQUAD: // Not currently implemented
5598 default:
5599 AssertFailed();
5600 return GL_LINEAR; /* default */
5601 }
5602}
5603
5604uint32_t vmsvga3dSVGA3dColor2RGBA(SVGA3dColor value)
5605{
5606 /* flip the red and blue bytes */
5607 uint8_t blue = value & 0xff;
5608 uint8_t red = (value >> 16) & 0xff;
5609 return (value & 0xff00ff00) | red | (blue << 16);
5610}
5611
5612static DECLCALLBACK(int) vmsvga3dBackSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
5613{
5614 GLenum val = ~(GLenum)0; /* Shut up MSC. */
5615 GLenum currentStage = ~(GLenum)0;
5616 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5617 AssertReturn(pState, VERR_NO_MEMORY);
5618
5619 Log(("vmsvga3dSetTextureState %x cTextureState=%d\n", cid, cTextureStates));
5620
5621 PVMSVGA3DCONTEXT pContext;
5622 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5623 AssertRCReturn(rc, rc);
5624
5625 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
5626
5627 /* Which texture is active for the current stage. Needed to use right OpenGL target when setting parameters. */
5628 PVMSVGA3DSURFACE pCurrentTextureSurface = NULL;
5629
5630 for (uint32_t i = 0; i < cTextureStates; ++i)
5631 {
5632 GLenum textureType = ~(GLenum)0;
5633#if 0
5634 GLenum samplerType = ~(GLenum)0;
5635#endif
5636
5637 LogFunc(("cid=%u stage=%d type=%s (%x) val=%x\n",
5638 cid, pTextureState[i].stage, vmsvga3dTextureStateToString(pTextureState[i].name), pTextureState[i].name, pTextureState[i].value));
5639
5640 /* Record the texture state for vm state saving. */
5641 if ( pTextureState[i].stage < RT_ELEMENTS(pContext->state.aTextureStates)
5642 && (unsigned)pTextureState[i].name < RT_ELEMENTS(pContext->state.aTextureStates[0]))
5643 {
5644 pContext->state.aTextureStates[pTextureState[i].stage][pTextureState[i].name] = pTextureState[i];
5645 }
5646
5647 /* Activate the right texture unit for subsequent texture state changes. */
5648 if (pTextureState[i].stage != currentStage || i == 0)
5649 {
5650 /** @todo Is this the appropriate limit for all kinds of textures? It is the
5651 * size of aSidActiveTextures and for binding/unbinding we cannot exceed it. */
5652 if (pTextureState[i].stage < RT_ELEMENTS(pContext->state.aTextureStates))
5653 {
5654 pState->ext.glActiveTexture(GL_TEXTURE0 + pTextureState[i].stage);
5655 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5656 currentStage = pTextureState[i].stage;
5657 }
5658 else
5659 {
5660 AssertMsgFailed(("pTextureState[%d].stage=%#x name=%#x\n", i, pTextureState[i].stage, pTextureState[i].name));
5661 continue;
5662 }
5663
5664 if (pContext->aSidActiveTextures[currentStage] != SVGA3D_INVALID_ID)
5665 {
5666 rc = vmsvga3dSurfaceFromSid(pState, pContext->aSidActiveTextures[currentStage], &pCurrentTextureSurface);
5667 AssertRCReturn(rc, rc);
5668 }
5669 else
5670 pCurrentTextureSurface = NULL; /* Make sure that no stale pointer is used. */
5671 }
5672
5673 switch (pTextureState[i].name)
5674 {
5675 case SVGA3D_TS_BUMPENVMAT00: /* float */
5676 case SVGA3D_TS_BUMPENVMAT01: /* float */
5677 case SVGA3D_TS_BUMPENVMAT10: /* float */
5678 case SVGA3D_TS_BUMPENVMAT11: /* float */
5679 case SVGA3D_TS_BUMPENVLSCALE: /* float */
5680 case SVGA3D_TS_BUMPENVLOFFSET: /* float */
5681 Log(("vmsvga3dSetTextureState: bump mapping texture options not supported!!\n"));
5682 break;
5683
5684 case SVGA3D_TS_COLOROP: /* SVGA3dTextureCombiner */
5685 case SVGA3D_TS_COLORARG0: /* SVGA3dTextureArgData */
5686 case SVGA3D_TS_COLORARG1: /* SVGA3dTextureArgData */
5687 case SVGA3D_TS_COLORARG2: /* SVGA3dTextureArgData */
5688 case SVGA3D_TS_ALPHAOP: /* SVGA3dTextureCombiner */
5689 case SVGA3D_TS_ALPHAARG0: /* SVGA3dTextureArgData */
5690 case SVGA3D_TS_ALPHAARG1: /* SVGA3dTextureArgData */
5691 case SVGA3D_TS_ALPHAARG2: /* SVGA3dTextureArgData */
5692 /** @todo not used by MesaGL */
5693 Log(("vmsvga3dSetTextureState: colorop/alphaop not yet supported!!\n"));
5694 break;
5695#if 0
5696
5697 case SVGA3D_TS_TEXCOORDINDEX: /* uint32_t */
5698 textureType = D3DTSS_TEXCOORDINDEX;
5699 val = pTextureState[i].value;
5700 break;
5701
5702 case SVGA3D_TS_TEXTURETRANSFORMFLAGS: /* SVGA3dTexTransformFlags */
5703 textureType = D3DTSS_TEXTURETRANSFORMFLAGS;
5704 val = vmsvga3dTextTransformFlags2D3D(pTextureState[i].value);
5705 break;
5706#endif
5707
5708 case SVGA3D_TS_BIND_TEXTURE: /* SVGA3dSurfaceId */
5709 {
5710 uint32_t const sid = pTextureState[i].value;
5711
5712 Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%u replacing sid=%u\n",
5713 currentStage, sid, pContext->aSidActiveTextures[currentStage]));
5714
5715 /* Only if texture actually changed. */ /// @todo needs testing.
5716 if (pContext->aSidActiveTextures[currentStage] != sid)
5717 {
5718 if (pCurrentTextureSurface)
5719 {
5720 /* Unselect the currently associated texture. */
5721 glBindTexture(pCurrentTextureSurface->targetGL, 0);
5722 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5723
5724 if (currentStage < 8)
5725 {
5726 /* Necessary for the fixed pipeline. */
5727 glDisable(pCurrentTextureSurface->targetGL);
5728 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5729 }
5730
5731 pCurrentTextureSurface = NULL;
5732 }
5733
5734 if (sid == SVGA3D_INVALID_ID)
5735 {
5736 Assert(pCurrentTextureSurface == NULL);
5737 }
5738 else
5739 {
5740 PVMSVGA3DSURFACE pSurface;
5741 rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
5742 AssertRCReturn(rc, rc);
5743
5744 Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%u (%d,%d) replacing sid=%u\n",
5745 currentStage, sid, pSurface->paMipmapLevels[0].mipmapSize.width,
5746 pSurface->paMipmapLevels[0].mipmapSize.height, pContext->aSidActiveTextures[currentStage]));
5747
5748 if (pSurface->oglId.texture == OPENGL_INVALID_ID)
5749 {
5750 Log(("CreateTexture (%d,%d) levels=%d\n",
5751 pSurface->paMipmapLevels[0].mipmapSize.width, pSurface->paMipmapLevels[0].mipmapSize.height, pSurface->cLevels));
5752 rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
5753 AssertRCReturn(rc, rc);
5754 }
5755
5756 glBindTexture(pSurface->targetGL, pSurface->oglId.texture);
5757 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5758
5759 if (currentStage < 8)
5760 {
5761 /* Necessary for the fixed pipeline. */
5762 glEnable(pSurface->targetGL);
5763 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5764 }
5765
5766 /* Remember the currently active texture. */
5767 pCurrentTextureSurface = pSurface;
5768
5769 /* Recreate the texture state as glBindTexture resets them all (sigh). */
5770 for (uint32_t iStage = 0; iStage < RT_ELEMENTS(pContext->state.aTextureStates); iStage++)
5771 {
5772 for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aTextureStates[0]); j++)
5773 {
5774 SVGA3dTextureState *pTextureStateIter = &pContext->state.aTextureStates[iStage][j];
5775
5776 if ( pTextureStateIter->name != SVGA3D_TS_INVALID
5777 && pTextureStateIter->name != SVGA3D_TS_BIND_TEXTURE)
5778 vmsvga3dBackSetTextureState(pThisCC, pContext->id, 1, pTextureStateIter);
5779 }
5780 }
5781 }
5782
5783 pContext->aSidActiveTextures[currentStage] = sid;
5784 }
5785
5786 /* Finished; continue with the next one. */
5787 continue;
5788 }
5789
5790 case SVGA3D_TS_ADDRESSW: /* SVGA3dTextureAddress */
5791 textureType = GL_TEXTURE_WRAP_R; /* R = W */
5792 val = vmsvga3dTextureAddress2OGL((SVGA3dTextureAddress)pTextureState[i].value);
5793 break;
5794
5795 case SVGA3D_TS_ADDRESSU: /* SVGA3dTextureAddress */
5796 textureType = GL_TEXTURE_WRAP_S; /* S = U */
5797 val = vmsvga3dTextureAddress2OGL((SVGA3dTextureAddress)pTextureState[i].value);
5798 break;
5799
5800 case SVGA3D_TS_ADDRESSV: /* SVGA3dTextureAddress */
5801 textureType = GL_TEXTURE_WRAP_T; /* T = V */
5802 val = vmsvga3dTextureAddress2OGL((SVGA3dTextureAddress)pTextureState[i].value);
5803 break;
5804
5805 case SVGA3D_TS_MIPFILTER: /* SVGA3dTextureFilter */
5806 case SVGA3D_TS_MINFILTER: /* SVGA3dTextureFilter */
5807 {
5808 uint32_t mipFilter = pContext->state.aTextureStates[currentStage][SVGA3D_TS_MIPFILTER].value;
5809 uint32_t minFilter = pContext->state.aTextureStates[currentStage][SVGA3D_TS_MINFILTER].value;
5810
5811 /* If SVGA3D_TS_MIPFILTER is set to NONE, then use SVGA3D_TS_MIPFILTER, otherwise SVGA3D_TS_MIPFILTER enables mipmap minification. */
5812 textureType = GL_TEXTURE_MIN_FILTER;
5813 if (mipFilter != SVGA3D_TEX_FILTER_NONE)
5814 {
5815 if (minFilter == SVGA3D_TEX_FILTER_NEAREST)
5816 {
5817 if (mipFilter == SVGA3D_TEX_FILTER_LINEAR)
5818 val = GL_NEAREST_MIPMAP_LINEAR;
5819 else
5820 val = GL_NEAREST_MIPMAP_NEAREST;
5821 }
5822 else
5823 {
5824 if (mipFilter == SVGA3D_TEX_FILTER_LINEAR)
5825 val = GL_LINEAR_MIPMAP_LINEAR;
5826 else
5827 val = GL_LINEAR_MIPMAP_NEAREST;
5828 }
5829 }
5830 else
5831 val = vmsvga3dTextureFilter2OGL((SVGA3dTextureFilter)minFilter);
5832 break;
5833 }
5834
5835 case SVGA3D_TS_MAGFILTER: /* SVGA3dTextureFilter */
5836 textureType = GL_TEXTURE_MAG_FILTER;
5837 val = vmsvga3dTextureFilter2OGL((SVGA3dTextureFilter)pTextureState[i].value);
5838 Assert(val == GL_NEAREST || val == GL_LINEAR);
5839 break;
5840
5841 case SVGA3D_TS_BORDERCOLOR: /* SVGA3dColor */
5842 {
5843 GLfloat color[4]; /* red, green, blue, alpha */
5844 vmsvgaColor2GLFloatArray(pTextureState[i].value, &color[0], &color[1], &color[2], &color[3]);
5845
5846 GLenum targetGL;
5847 if (pCurrentTextureSurface)
5848 targetGL = pCurrentTextureSurface->targetGL;
5849 else
5850 {
5851 /* No texture bound, assume 2D. */
5852 targetGL = GL_TEXTURE_2D;
5853 }
5854
5855 glTexParameterfv(targetGL, GL_TEXTURE_BORDER_COLOR, color); /* Identical; default 0.0 identical too */
5856 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5857 break;
5858 }
5859
5860 case SVGA3D_TS_TEXTURE_LOD_BIAS: /* float */
5861 {
5862 GLenum targetGL;
5863 if (pCurrentTextureSurface)
5864 targetGL = pCurrentTextureSurface->targetGL;
5865 else
5866 {
5867 /* No texture bound, assume 2D. */
5868 targetGL = GL_TEXTURE_2D;
5869 }
5870
5871 glTexParameterf(targetGL, GL_TEXTURE_LOD_BIAS, pTextureState[i].floatValue); /* Identical; default 0.0 identical too */
5872 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5873 break;
5874 }
5875
5876 case SVGA3D_TS_TEXTURE_MIPMAP_LEVEL: /* uint32_t */
5877 textureType = GL_TEXTURE_BASE_LEVEL;
5878 val = pTextureState[i].value;
5879 break;
5880
5881 case SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL: /* uint32_t */
5882 if (pState->caps.fTextureFilterAnisotropicSupported)
5883 {
5884 textureType = GL_TEXTURE_MAX_ANISOTROPY_EXT;
5885 val = RT_MIN((GLint)pTextureState[i].value, pState->caps.maxTextureAnisotropy);
5886 } /* otherwise ignore. */
5887 break;
5888
5889#if 0
5890 case SVGA3D_TS_GAMMA: /* float */
5891 samplerType = D3DSAMP_SRGBTEXTURE;
5892 /* Boolean in D3D */
5893 if (pTextureState[i].floatValue == 1.0f)
5894 val = FALSE;
5895 else
5896 val = TRUE;
5897 break;
5898#endif
5899 /* Internal commands, that don't map directly to the SetTextureStageState API. */
5900 case SVGA3D_TS_TEXCOORDGEN: /* SVGA3dTextureCoordGen */
5901 AssertFailed();
5902 break;
5903
5904 default:
5905 //AssertFailed();
5906 break;
5907 }
5908
5909 if (textureType != ~(GLenum)0)
5910 {
5911 GLenum targetGL;
5912 if (pCurrentTextureSurface)
5913 targetGL = pCurrentTextureSurface->targetGL;
5914 else
5915 {
5916 /* No texture bound, assume 2D. */
5917 targetGL = GL_TEXTURE_2D;
5918 }
5919
5920 switch (pTextureState[i].name)
5921 {
5922 case SVGA3D_TS_MINFILTER:
5923 case SVGA3D_TS_MAGFILTER:
5924 {
5925 if (pState->caps.fTextureFilterAnisotropicSupported)
5926 {
5927 uint32_t const anisotropyLevel = (SVGA3dTextureFilter)pTextureState[i].value == SVGA3D_TEX_FILTER_ANISOTROPIC
5928 ? RT_MAX(1, pContext->state.aTextureStates[currentStage][SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL].value)
5929 : 1;
5930 glTexParameteri(targetGL, GL_TEXTURE_MAX_ANISOTROPY_EXT, RT_MIN((GLint)anisotropyLevel, pState->caps.maxTextureAnisotropy));
5931 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5932 }
5933 } break;
5934
5935 default: break;
5936 }
5937
5938 glTexParameteri(targetGL, textureType, val);
5939 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5940 }
5941 }
5942
5943 return VINF_SUCCESS;
5944}
5945
5946static DECLCALLBACK(int) vmsvga3dBackSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
5947{
5948 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5949 AssertReturn(pState, VERR_NO_MEMORY);
5950
5951 LogFunc(("cid=%u face %d\n", cid, face));
5952
5953 PVMSVGA3DCONTEXT pContext;
5954 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5955 AssertRCReturn(rc, rc);
5956
5957 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
5958
5959 GLenum oglFace;
5960 switch (face)
5961 {
5962 case SVGA3D_FACE_NONE:
5963 case SVGA3D_FACE_FRONT:
5964 oglFace = GL_FRONT;
5965 break;
5966
5967 case SVGA3D_FACE_BACK:
5968 oglFace = GL_BACK;
5969 break;
5970
5971 case SVGA3D_FACE_FRONT_BACK:
5972 oglFace = GL_FRONT_AND_BACK;
5973 break;
5974
5975 default:
5976 AssertFailedReturn(VERR_INVALID_PARAMETER);
5977 }
5978
5979 /* Save for vm state save/restore. */
5980 pContext->state.aMaterial[face].fValid = true;
5981 pContext->state.aMaterial[face].material = *pMaterial;
5982 pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_MATERIAL;
5983
5984 glMaterialfv(oglFace, GL_DIFFUSE, pMaterial->diffuse);
5985 glMaterialfv(oglFace, GL_AMBIENT, pMaterial->ambient);
5986 glMaterialfv(oglFace, GL_SPECULAR, pMaterial->specular);
5987 glMaterialfv(oglFace, GL_EMISSION, pMaterial->emissive);
5988 glMaterialfv(oglFace, GL_SHININESS, &pMaterial->shininess);
5989 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
5990
5991 return VINF_SUCCESS;
5992}
5993
5994/** @todo Move into separate library as we are using logic from Wine here. */
5995static DECLCALLBACK(int) vmsvga3dBackSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
5996{
5997 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5998 AssertReturn(pState, VERR_NO_MEMORY);
5999
6000 LogFunc(("vmsvga3dSetLightData cid=%u index=%d type=%d\n", cid, index, pData->type));
6001 ASSERT_GUEST_RETURN(index < SVGA3D_MAX_LIGHTS, VERR_INVALID_PARAMETER);
6002
6003 PVMSVGA3DCONTEXT pContext;
6004 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
6005 AssertRCReturn(rc, rc);
6006
6007 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
6008
6009 /* Store for vm state save/restore */
6010 pContext->state.aLightData[index].fValidData = true;
6011 pContext->state.aLightData[index].data = *pData;
6012
6013 if ( pData->attenuation0 < 0.0f
6014 || pData->attenuation1 < 0.0f
6015 || pData->attenuation2 < 0.0f)
6016 {
6017 Log(("vmsvga3dSetLightData: invalid negative attenuation values!!\n"));
6018 return VINF_SUCCESS; /* ignore; could crash the GL driver */
6019 }
6020
6021 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d */
6022 glMatrixMode(GL_MODELVIEW);
6023 glPushMatrix();
6024 glLoadMatrixf(pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].matrix);
6025
6026 glLightfv(GL_LIGHT0 + index, GL_DIFFUSE, pData->diffuse);
6027 glLightfv(GL_LIGHT0 + index, GL_SPECULAR, pData->specular);
6028 glLightfv(GL_LIGHT0 + index, GL_AMBIENT, pData->ambient);
6029
6030 float QuadAttenuation;
6031 if (pData->range * pData->range >= FLT_MIN)
6032 QuadAttenuation = 1.4f / (pData->range * pData->range);
6033 else
6034 QuadAttenuation = 0.0f;
6035
6036 switch (pData->type)
6037 {
6038 case SVGA3D_LIGHTTYPE_POINT:
6039 {
6040 GLfloat position[4];
6041
6042 position[0] = pData->position[0];
6043 position[1] = pData->position[1];
6044 position[2] = pData->position[2];
6045 position[3] = 1.0f;
6046
6047 glLightfv(GL_LIGHT0 + index, GL_POSITION, position);
6048 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6049
6050 glLightf(GL_LIGHT0 + index, GL_SPOT_CUTOFF, 180.0f);
6051 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6052
6053 /* Attenuation - Are these right? guessing... */
6054 glLightf(GL_LIGHT0 + index, GL_CONSTANT_ATTENUATION, pData->attenuation0);
6055 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6056
6057 glLightf(GL_LIGHT0 + index, GL_LINEAR_ATTENUATION, pData->attenuation1);
6058 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6059
6060 glLightf(GL_LIGHT0 + index, GL_QUADRATIC_ATTENUATION, (QuadAttenuation < pData->attenuation2) ? pData->attenuation2 : QuadAttenuation);
6061 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6062
6063 /** @todo range */
6064 break;
6065 }
6066
6067 case SVGA3D_LIGHTTYPE_SPOT1:
6068 {
6069 GLfloat exponent;
6070 GLfloat position[4];
6071 const GLfloat pi = 4.0f * atanf(1.0f);
6072
6073 position[0] = pData->position[0];
6074 position[1] = pData->position[1];
6075 position[2] = pData->position[2];
6076 position[3] = 1.0f;
6077
6078 glLightfv(GL_LIGHT0 + index, GL_POSITION, position);
6079 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6080
6081 position[0] = pData->direction[0];
6082 position[1] = pData->direction[1];
6083 position[2] = pData->direction[2];
6084 position[3] = 1.0f;
6085
6086 glLightfv(GL_LIGHT0 + index, GL_SPOT_DIRECTION, position);
6087 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6088
6089 /*
6090 * opengl-ish and d3d-ish spot lights use too different models for the
6091 * light "intensity" as a function of the angle towards the main light direction,
6092 * so we only can approximate very roughly.
6093 * however spot lights are rather rarely used in games (if ever used at all).
6094 * furthermore if still used, probably nobody pays attention to such details.
6095 */
6096 if (pData->falloff == 0)
6097 {
6098 /* Falloff = 0 is easy, because d3d's and opengl's spot light equations have the
6099 * falloff resp. exponent parameter as an exponent, so the spot light lighting
6100 * will always be 1.0 for both of them, and we don't have to care for the
6101 * rest of the rather complex calculation
6102 */
6103 exponent = 0.0f;
6104 }
6105 else
6106 {
6107 float rho = pData->theta + (pData->phi - pData->theta) / (2 * pData->falloff);
6108 if (rho < 0.0001f)
6109 rho = 0.0001f;
6110 exponent = -0.3f/log(cos(rho/2));
6111 }
6112 if (exponent > 128.0f)
6113 exponent = 128.0f;
6114
6115 glLightf(GL_LIGHT0 + index, GL_SPOT_EXPONENT, exponent);
6116 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6117
6118 glLightf(GL_LIGHT0 + index, GL_SPOT_CUTOFF, pData->phi * 90.0 / pi);
6119 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6120
6121 /* Attenuation - Are these right? guessing... */
6122 glLightf(GL_LIGHT0 + index, GL_CONSTANT_ATTENUATION, pData->attenuation0);
6123 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6124
6125 glLightf(GL_LIGHT0 + index, GL_LINEAR_ATTENUATION, pData->attenuation1);
6126 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6127
6128 glLightf(GL_LIGHT0 + index, GL_QUADRATIC_ATTENUATION, (QuadAttenuation < pData->attenuation2) ? pData->attenuation2 : QuadAttenuation);
6129 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6130
6131 /** @todo range */
6132 break;
6133 }
6134
6135 case SVGA3D_LIGHTTYPE_DIRECTIONAL:
6136 {
6137 GLfloat position[4];
6138
6139 position[0] = -pData->direction[0];
6140 position[1] = -pData->direction[1];
6141 position[2] = -pData->direction[2];
6142 position[3] = 0.0f;
6143
6144 glLightfv(GL_LIGHT0 + index, GL_POSITION, position); /* Note gl uses w position of 0 for direction! */
6145 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6146
6147 glLightf(GL_LIGHT0 + index, GL_SPOT_CUTOFF, 180.0f);
6148 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6149
6150 glLightf(GL_LIGHT0 + index, GL_SPOT_EXPONENT, 0.0f);
6151 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6152 break;
6153 }
6154
6155 case SVGA3D_LIGHTTYPE_SPOT2:
6156 default:
6157 Log(("Unsupported light type!!\n"));
6158 rc = VERR_INVALID_PARAMETER;
6159 break;
6160 }
6161
6162 /* Restore the modelview matrix */
6163 glPopMatrix();
6164
6165 return rc;
6166}
6167
6168static DECLCALLBACK(int) vmsvga3dBackSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
6169{
6170 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
6171 AssertReturn(pState, VERR_NO_MEMORY);
6172
6173 LogFunc(("cid=%u %d -> %d\n", cid, index, enabled));
6174
6175 PVMSVGA3DCONTEXT pContext;
6176 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
6177 AssertRCReturn(rc, rc);
6178
6179 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
6180
6181 /* Store for vm state save/restore */
6182 if (index < SVGA3D_MAX_LIGHTS)
6183 pContext->state.aLightData[index].fEnabled = !!enabled;
6184 else
6185 AssertFailed();
6186
6187 if (enabled)
6188 {
6189 if (index < SVGA3D_MAX_LIGHTS)
6190 {
6191 /* Load the default settings if none have been set yet. */
6192 if (!pContext->state.aLightData[index].fValidData)
6193 vmsvga3dBackSetLightData(pThisCC, cid, index, (SVGA3dLightData *)&vmsvga3d_default_light);
6194 }
6195 glEnable(GL_LIGHT0 + index);
6196 }
6197 else
6198 glDisable(GL_LIGHT0 + index);
6199
6200 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6201 return VINF_SUCCESS;
6202}
6203
6204static DECLCALLBACK(int) vmsvga3dBackSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
6205{
6206 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
6207 AssertReturn(pState, VERR_NO_MEMORY);
6208
6209 Log(("vmsvga3dSetViewPort cid=%u (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
6210
6211 PVMSVGA3DCONTEXT pContext;
6212 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
6213 AssertRCReturn(rc, rc);
6214
6215 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
6216
6217 /* Save for vm state save/restore. */
6218 pContext->state.RectViewPort = *pRect;
6219 pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_VIEWPORT;
6220
6221 /** @todo y-inversion for partial viewport coordinates? */
6222 glViewport(pRect->x, pRect->y, pRect->w, pRect->h);
6223 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6224
6225 /* Reset the projection matrix as that relies on the viewport setting. */
6226 if (pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].fValid == true)
6227 vmsvga3dBackSetTransform(pThisCC, cid, SVGA3D_TRANSFORM_PROJECTION,
6228 pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
6229 else
6230 {
6231 float matrix[16];
6232
6233 /* identity matrix if no matrix set. */
6234 memset(matrix, 0, sizeof(matrix));
6235 matrix[0] = 1.0;
6236 matrix[5] = 1.0;
6237 matrix[10] = 1.0;
6238 matrix[15] = 1.0;
6239 vmsvga3dBackSetTransform(pThisCC, cid, SVGA3D_TRANSFORM_PROJECTION, matrix);
6240 }
6241
6242 return VINF_SUCCESS;
6243}
6244
6245static DECLCALLBACK(int) vmsvga3dBackSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4])
6246{
6247 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
6248 AssertReturn(pState, VERR_NO_MEMORY);
6249 double oglPlane[4];
6250
6251 Log(("vmsvga3dSetClipPlane cid=%u %d (%d,%d)(%d,%d)\n", cid, index, (unsigned)(plane[0] * 100.0), (unsigned)(plane[1] * 100.0), (unsigned)(plane[2] * 100.0), (unsigned)(plane[3] * 100.0)));
6252 AssertReturn(index < SVGA3D_NUM_CLIPPLANES, VERR_INVALID_PARAMETER);
6253
6254 PVMSVGA3DCONTEXT pContext;
6255 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
6256 AssertRCReturn(rc, rc);
6257
6258 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
6259
6260 /* Store for vm state save/restore. */
6261 pContext->state.aClipPlane[index].fValid = true;
6262 memcpy(pContext->state.aClipPlane[index].plane, plane, sizeof(pContext->state.aClipPlane[index].plane));
6263
6264 /** @todo clip plane affected by model view in OpenGL & view in D3D + vertex shader -> not transformed (see Wine; state.c clipplane) */
6265 oglPlane[0] = (double)plane[0];
6266 oglPlane[1] = (double)plane[1];
6267 oglPlane[2] = (double)plane[2];
6268 oglPlane[3] = (double)plane[3];
6269
6270 glClipPlane(GL_CLIP_PLANE0 + index, oglPlane);
6271 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6272
6273 return VINF_SUCCESS;
6274}
6275
6276static DECLCALLBACK(int) vmsvga3dBackSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
6277{
6278 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
6279 AssertReturn(pState, VERR_NO_MEMORY);
6280
6281 Log(("vmsvga3dSetScissorRect cid=%u (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
6282
6283 PVMSVGA3DCONTEXT pContext;
6284 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
6285 AssertRCReturn(rc, rc);
6286
6287 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
6288
6289 /* Store for vm state save/restore. */
6290 pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_SCISSORRECT;
6291 pContext->state.RectScissor = *pRect;
6292
6293 glScissor(pRect->x, pRect->y, pRect->w, pRect->h);
6294 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6295
6296 return VINF_SUCCESS;
6297}
6298
6299static void vmsvgaColor2GLFloatArray(uint32_t color, GLfloat *pRed, GLfloat *pGreen, GLfloat *pBlue, GLfloat *pAlpha)
6300{
6301 /* Convert byte color components to float (0-1.0) */
6302 *pAlpha = (GLfloat)(color >> 24) / 255.0;
6303 *pRed = (GLfloat)((color >> 16) & 0xff) / 255.0;
6304 *pGreen = (GLfloat)((color >> 8) & 0xff) / 255.0;
6305 *pBlue = (GLfloat)(color & 0xff) / 255.0;
6306}
6307
6308static DECLCALLBACK(int) vmsvga3dBackCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil,
6309 uint32_t cRects, SVGA3dRect *pRect)
6310{
6311 GLbitfield mask = 0;
6312 GLbitfield restoreMask = 0;
6313 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
6314 AssertReturn(pState, VERR_NO_MEMORY);
6315 GLboolean fDepthWriteEnabled = GL_FALSE;
6316 GLboolean afColorWriteEnabled[4] = { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE };
6317
6318 Log(("vmsvga3dCommandClear cid=%u clearFlag=%x color=%x depth=%d stencil=%x cRects=%d\n", cid, clearFlag, color, (uint32_t)(depth * 100.0), stencil, cRects));
6319
6320 PVMSVGA3DCONTEXT pContext;
6321 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
6322 AssertRCReturn(rc, rc);
6323
6324 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
6325
6326 if (clearFlag & SVGA3D_CLEAR_COLOR)
6327 {
6328 GLfloat red, green, blue, alpha;
6329 vmsvgaColor2GLFloatArray(color, &red, &green, &blue, &alpha);
6330
6331 /* Set the color clear value. */
6332 glClearColor(red, green, blue, alpha);
6333 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6334
6335 mask |= GL_COLOR_BUFFER_BIT;
6336
6337 /* glClear will not clear the color buffer if writing is disabled. */
6338 glGetBooleanv(GL_COLOR_WRITEMASK, afColorWriteEnabled);
6339 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6340 if ( afColorWriteEnabled[0] == GL_FALSE
6341 || afColorWriteEnabled[1] == GL_FALSE
6342 || afColorWriteEnabled[2] == GL_FALSE
6343 || afColorWriteEnabled[3] == GL_FALSE)
6344 {
6345 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
6346 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6347
6348 restoreMask |= GL_COLOR_BUFFER_BIT;
6349 }
6350
6351 }
6352
6353 if (clearFlag & SVGA3D_CLEAR_STENCIL)
6354 {
6355 /** @todo possibly the same problem as with glDepthMask */
6356 glClearStencil(stencil);
6357 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6358
6359 mask |= GL_STENCIL_BUFFER_BIT;
6360 }
6361
6362 if (clearFlag & SVGA3D_CLEAR_DEPTH)
6363 {
6364 glClearDepth((GLdouble)depth);
6365 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6366
6367 mask |= GL_DEPTH_BUFFER_BIT;
6368
6369 /* glClear will not clear the depth buffer if writing is disabled. */
6370 glGetBooleanv(GL_DEPTH_WRITEMASK, &fDepthWriteEnabled);
6371 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6372 if (fDepthWriteEnabled == GL_FALSE)
6373 {
6374 glDepthMask(GL_TRUE);
6375 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6376
6377 restoreMask |= GL_DEPTH_BUFFER_BIT;
6378 }
6379 }
6380
6381 /* Save the current scissor test bit and scissor box. */
6382 glPushAttrib(GL_SCISSOR_BIT);
6383 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6384
6385 if (cRects)
6386 {
6387 glEnable(GL_SCISSOR_TEST);
6388 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6389
6390 for (uint32_t i = 0; i < cRects; ++i)
6391 {
6392 LogFunc(("rect [%d] %d,%d %dx%d)\n", i, pRect[i].x, pRect[i].y, pRect[i].w, pRect[i].h));
6393 glScissor(pRect[i].x, pRect[i].y, pRect[i].w, pRect[i].h);
6394 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6395
6396 glClear(mask);
6397 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6398 }
6399 }
6400 else
6401 {
6402 glDisable(GL_SCISSOR_TEST);
6403 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6404
6405 glClear(mask);
6406 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6407 }
6408
6409 /* Restore the old scissor test bit and box */
6410 glPopAttrib();
6411 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6412
6413 /* Restore the write states. */
6414 if (restoreMask & GL_COLOR_BUFFER_BIT)
6415 {
6416 glColorMask(afColorWriteEnabled[0],
6417 afColorWriteEnabled[1],
6418 afColorWriteEnabled[2],
6419 afColorWriteEnabled[3]);
6420 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6421 }
6422
6423 if (restoreMask & GL_DEPTH_BUFFER_BIT)
6424 {
6425 glDepthMask(fDepthWriteEnabled);
6426 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6427 }
6428
6429 return VINF_SUCCESS;
6430}
6431
6432/* Convert VMWare vertex declaration to its OpenGL equivalent. */
6433int vmsvga3dVertexDecl2OGL(SVGA3dVertexArrayIdentity &identity, GLint &size, GLenum &type, GLboolean &normalized, uint32_t &cbAttrib)
6434{
6435 normalized = GL_FALSE;
6436 switch (identity.type)
6437 {
6438 case SVGA3D_DECLTYPE_FLOAT1:
6439 size = 1;
6440 type = GL_FLOAT;
6441 cbAttrib = sizeof(float);
6442 break;
6443 case SVGA3D_DECLTYPE_FLOAT2:
6444 size = 2;
6445 type = GL_FLOAT;
6446 cbAttrib = 2 * sizeof(float);
6447 break;
6448 case SVGA3D_DECLTYPE_FLOAT3:
6449 size = 3;
6450 type = GL_FLOAT;
6451 cbAttrib = 3 * sizeof(float);
6452 break;
6453 case SVGA3D_DECLTYPE_FLOAT4:
6454 size = 4;
6455 type = GL_FLOAT;
6456 cbAttrib = 4 * sizeof(float);
6457 break;
6458
6459 case SVGA3D_DECLTYPE_D3DCOLOR:
6460 size = GL_BGRA; /* @note requires GL_ARB_vertex_array_bgra */
6461 type = GL_UNSIGNED_BYTE;
6462 normalized = GL_TRUE; /* glVertexAttribPointer fails otherwise */
6463 cbAttrib = sizeof(uint32_t);
6464 break;
6465
6466 case SVGA3D_DECLTYPE_UBYTE4N:
6467 normalized = GL_TRUE;
6468 RT_FALL_THRU();
6469 case SVGA3D_DECLTYPE_UBYTE4:
6470 size = 4;
6471 type = GL_UNSIGNED_BYTE;
6472 cbAttrib = sizeof(uint32_t);
6473 break;
6474
6475 case SVGA3D_DECLTYPE_SHORT2N:
6476 normalized = GL_TRUE;
6477 RT_FALL_THRU();
6478 case SVGA3D_DECLTYPE_SHORT2:
6479 size = 2;
6480 type = GL_SHORT;
6481 cbAttrib = 2 * sizeof(uint16_t);
6482 break;
6483
6484 case SVGA3D_DECLTYPE_SHORT4N:
6485 normalized = GL_TRUE;
6486 RT_FALL_THRU();
6487 case SVGA3D_DECLTYPE_SHORT4:
6488 size = 4;
6489 type = GL_SHORT;
6490 cbAttrib = 4 * sizeof(uint16_t);
6491 break;
6492
6493 case SVGA3D_DECLTYPE_USHORT4N:
6494 normalized = GL_TRUE;
6495 size = 4;
6496 type = GL_UNSIGNED_SHORT;
6497 cbAttrib = 4 * sizeof(uint16_t);
6498 break;
6499
6500 case SVGA3D_DECLTYPE_USHORT2N:
6501 normalized = GL_TRUE;
6502 size = 2;
6503 type = GL_UNSIGNED_SHORT;
6504 cbAttrib = 2 * sizeof(uint16_t);
6505 break;
6506
6507 case SVGA3D_DECLTYPE_UDEC3:
6508 size = 3;
6509 type = GL_UNSIGNED_INT_2_10_10_10_REV; /** @todo correct? */
6510 cbAttrib = sizeof(uint32_t);
6511 break;
6512
6513 case SVGA3D_DECLTYPE_DEC3N:
6514 normalized = true;
6515 size = 3;
6516 type = GL_INT_2_10_10_10_REV; /** @todo correct? */
6517 cbAttrib = sizeof(uint32_t);
6518 break;
6519
6520 case SVGA3D_DECLTYPE_FLOAT16_2:
6521 size = 2;
6522 type = GL_HALF_FLOAT;
6523 cbAttrib = 2 * sizeof(uint16_t);
6524 break;
6525 case SVGA3D_DECLTYPE_FLOAT16_4:
6526 size = 4;
6527 type = GL_HALF_FLOAT;
6528 cbAttrib = 4 * sizeof(uint16_t);
6529 break;
6530 default:
6531 AssertFailedReturn(VERR_INVALID_PARAMETER);
6532 }
6533
6534 //pVertexElement->Method = identity.method;
6535 //pVertexElement->Usage = identity.usage;
6536
6537 return VINF_SUCCESS;
6538}
6539
6540static float vmsvga3dFloat16To32(uint16_t f16)
6541{
6542 /* From Wiki */
6543#ifndef INFINITY
6544 static uint32_t const sBitsINFINITY = UINT32_C(0x7f800000);
6545 #define INFINITY (*(float const *)&sBitsINFINITY)
6546#endif
6547#ifndef NAN
6548 static uint32_t const sBitsNAN = UINT32_C(0x7fc00000);
6549 #define NAN (*(float const *)&sBitsNAN)
6550#endif
6551
6552 uint16_t const s = (f16 >> UINT16_C(15)) & UINT16_C(0x1);
6553 uint16_t const e = (f16 >> UINT16_C(10)) & UINT16_C(0x1f);
6554 uint16_t const m = (f16 ) & UINT16_C(0x3ff);
6555
6556 float result = s ? 1.0f : -1.0f;
6557 if (e == 0)
6558 {
6559 if (m == 0)
6560 result *= 0.0f; /* zero, -0 */
6561 else
6562 result *= (float)m / 1024.0f / 16384.0f; /* subnormal numbers: sign * 2^-14 * 0.m */
6563 }
6564 else if (e == 0x1f)
6565 {
6566 if (m == 0)
6567 result *= INFINITY; /* +-infinity */
6568 else
6569 result = NAN; /* NAN */
6570 }
6571 else
6572 {
6573 result *= powf(2.0f, (float)e - 15.0f) * (1.0f + (float)m / 1024.0f); /* sign * 2^(e-15) * 1.m */
6574 }
6575
6576 return result;
6577}
6578
6579/* Set a vertex attribute according to VMSVGA vertex declaration. */
6580static int vmsvga3dSetVertexAttrib(PVMSVGA3DSTATE pState, GLuint index, SVGA3dVertexArrayIdentity const *pIdentity, GLvoid const *pv)
6581{
6582 switch (pIdentity->type)
6583 {
6584 case SVGA3D_DECLTYPE_FLOAT1:
6585 {
6586 /* "One-component float expanded to (float, 0, 0, 1)." */
6587 GLfloat const *p = (GLfloat *)pv;
6588 GLfloat const v[4] = { p[0], 0.0f, 0.0f, 1.0f };
6589 pState->ext.glVertexAttrib4fv(index, v);
6590 break;
6591 }
6592 case SVGA3D_DECLTYPE_FLOAT2:
6593 {
6594 /* "Two-component float expanded to (float, float, 0, 1)." */
6595 GLfloat const *p = (GLfloat *)pv;
6596 GLfloat const v[4] = { p[0], p[1], 0.0f, 1.0f };
6597 pState->ext.glVertexAttrib4fv(index, v);
6598 break;
6599 }
6600 case SVGA3D_DECLTYPE_FLOAT3:
6601 {
6602 /* "Three-component float expanded to (float, float, float, 1)." */
6603 GLfloat const *p = (GLfloat *)pv;
6604 GLfloat const v[4] = { p[0], p[1], p[2], 1.0f };
6605 pState->ext.glVertexAttrib4fv(index, v);
6606 break;
6607 }
6608 case SVGA3D_DECLTYPE_FLOAT4:
6609 pState->ext.glVertexAttrib4fv(index, (GLfloat const *)pv);
6610 break;
6611 case SVGA3D_DECLTYPE_D3DCOLOR:
6612 /** @todo Need to swap bytes? */
6613 pState->ext.glVertexAttrib4Nubv(index, (GLubyte const *)pv);
6614 break;
6615 case SVGA3D_DECLTYPE_UBYTE4:
6616 pState->ext.glVertexAttrib4ubv(index, (GLubyte const *)pv);
6617 break;
6618 case SVGA3D_DECLTYPE_SHORT2:
6619 {
6620 /* "Two-component, signed short expanded to (value, value, 0, 1)." */
6621 GLshort const *p = (GLshort const *)pv;
6622 GLshort const v[4] = { p[0], p[1], 0, 1 };
6623 pState->ext.glVertexAttrib4sv(index, v);
6624 break;
6625 }
6626 case SVGA3D_DECLTYPE_SHORT4:
6627 pState->ext.glVertexAttrib4sv(index, (GLshort const *)pv);
6628 break;
6629 case SVGA3D_DECLTYPE_UBYTE4N:
6630 pState->ext.glVertexAttrib4Nubv(index, (GLubyte const *)pv);
6631 break;
6632 case SVGA3D_DECLTYPE_SHORT2N:
6633 {
6634 /* "Normalized, two-component, signed short, expanded to (first short/32767.0, second short/32767.0, 0, 1)." */
6635 GLshort const *p = (GLshort const *)pv;
6636 GLshort const v[4] = { p[0], p[1], 0, 1 };
6637 pState->ext.glVertexAttrib4Nsv(index, v);
6638 break;
6639 }
6640 case SVGA3D_DECLTYPE_SHORT4N:
6641 pState->ext.glVertexAttrib4Nsv(index, (GLshort const *)pv);
6642 break;
6643 case SVGA3D_DECLTYPE_USHORT2N:
6644 {
6645 GLushort const *p = (GLushort const *)pv;
6646 GLushort const v[4] = { p[0], p[1], 0, 1 };
6647 pState->ext.glVertexAttrib4Nusv(index, v);
6648 break;
6649 }
6650 case SVGA3D_DECLTYPE_USHORT4N:
6651 pState->ext.glVertexAttrib4Nusv(index, (GLushort const *)pv);
6652 break;
6653 case SVGA3D_DECLTYPE_UDEC3:
6654 {
6655 /** @todo Test */
6656 /* "Three-component, unsigned, 10 10 10 format expanded to (value, value, value, 1)." */
6657 uint32_t const u32 = *(uint32_t *)pv;
6658 GLfloat const v[4] = { (float)(u32 & 0x3ff), (float)((u32 >> 10) & 0x3ff), (float)((u32 >> 20) & 0x3ff), 1.0f };
6659 pState->ext.glVertexAttrib4fv(index, v);
6660 break;
6661 }
6662 case SVGA3D_DECLTYPE_DEC3N:
6663 {
6664 /** @todo Test */
6665 /* "Three-component, signed, 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)." */
6666 uint32_t const u32 = *(uint32_t *)pv;
6667 GLfloat const v[4] = { (u32 & 0x3ff) / 511.0f, ((u32 >> 10) & 0x3ff) / 511.0f, ((u32 >> 20) & 0x3ff) / 511.0f, 1.0f };
6668 pState->ext.glVertexAttrib4fv(index, v);
6669 break;
6670 }
6671 case SVGA3D_DECLTYPE_FLOAT16_2:
6672 {
6673 /** @todo Test */
6674 /* "Two-component, 16-bit, floating point expanded to (value, value, 0, 1)." */
6675 uint16_t const *p = (uint16_t *)pv;
6676 GLfloat const v[4] = { vmsvga3dFloat16To32(p[0]), vmsvga3dFloat16To32(p[1]), 0.0f, 1.0f };
6677 pState->ext.glVertexAttrib4fv(index, v);
6678 break;
6679 }
6680 case SVGA3D_DECLTYPE_FLOAT16_4:
6681 {
6682 /** @todo Test */
6683 uint16_t const *p = (uint16_t *)pv;
6684 GLfloat const v[4] = { vmsvga3dFloat16To32(p[0]), vmsvga3dFloat16To32(p[1]),
6685 vmsvga3dFloat16To32(p[2]), vmsvga3dFloat16To32(p[3]) };
6686 pState->ext.glVertexAttrib4fv(index, v);
6687 break;
6688 }
6689 default:
6690 AssertFailedReturn(VERR_INVALID_PARAMETER);
6691 }
6692
6693 return VINF_SUCCESS;
6694}
6695
6696/* Convert VMWare primitive type to its OpenGL equivalent. */
6697/* Calculate the vertex count based on the primitive type and nr of primitives. */
6698int vmsvga3dPrimitiveType2OGL(SVGA3dPrimitiveType PrimitiveType, GLenum *pMode, uint32_t cPrimitiveCount, uint32_t *pcVertices)
6699{
6700 switch (PrimitiveType)
6701 {
6702 case SVGA3D_PRIMITIVE_TRIANGLELIST:
6703 *pMode = GL_TRIANGLES;
6704 *pcVertices = cPrimitiveCount * 3;
6705 break;
6706 case SVGA3D_PRIMITIVE_POINTLIST:
6707 *pMode = GL_POINTS;
6708 *pcVertices = cPrimitiveCount;
6709 break;
6710 case SVGA3D_PRIMITIVE_LINELIST:
6711 *pMode = GL_LINES;
6712 *pcVertices = cPrimitiveCount * 2;
6713 break;
6714 case SVGA3D_PRIMITIVE_LINESTRIP:
6715 *pMode = GL_LINE_STRIP;
6716 *pcVertices = cPrimitiveCount + 1;
6717 break;
6718 case SVGA3D_PRIMITIVE_TRIANGLESTRIP:
6719 *pMode = GL_TRIANGLE_STRIP;
6720 *pcVertices = cPrimitiveCount + 2;
6721 break;
6722 case SVGA3D_PRIMITIVE_TRIANGLEFAN:
6723 *pMode = GL_TRIANGLE_FAN;
6724 *pcVertices = cPrimitiveCount + 2;
6725 break;
6726 default:
6727 return VERR_INVALID_PARAMETER;
6728 }
6729 return VINF_SUCCESS;
6730}
6731
6732static int vmsvga3dResetTransformMatrices(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
6733{
6734 int rc;
6735
6736 /* Reset the view matrix (also takes the world matrix into account). */
6737 if (pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].fValid == true)
6738 rc = vmsvga3dBackSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_VIEW,
6739 pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].matrix);
6740 else
6741 {
6742 float matrix[16];
6743
6744 /* identity matrix if no matrix set. */
6745 memset(matrix, 0, sizeof(matrix));
6746 matrix[0] = 1.0;
6747 matrix[5] = 1.0;
6748 matrix[10] = 1.0;
6749 matrix[15] = 1.0;
6750 rc = vmsvga3dBackSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_VIEW, matrix);
6751 }
6752
6753 /* Reset the projection matrix. */
6754 if (pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].fValid == true)
6755 {
6756 rc = vmsvga3dBackSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_PROJECTION, pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
6757 }
6758 else
6759 {
6760 float matrix[16];
6761
6762 /* identity matrix if no matrix set. */
6763 memset(matrix, 0, sizeof(matrix));
6764 matrix[0] = 1.0;
6765 matrix[5] = 1.0;
6766 matrix[10] = 1.0;
6767 matrix[15] = 1.0;
6768 rc = vmsvga3dBackSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_PROJECTION, matrix);
6769 }
6770 AssertRC(rc);
6771 return rc;
6772}
6773
6774static int vmsvga3dDrawPrimitivesProcessVertexDecls(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext,
6775 uint32_t iVertexDeclBase, uint32_t numVertexDecls,
6776 SVGA3dVertexDecl *pVertexDecl,
6777 SVGA3dVertexDivisor const *paVertexDivisors)
6778{
6779 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
6780 unsigned const sidVertex = pVertexDecl[0].array.surfaceId;
6781
6782 PVMSVGA3DSURFACE pVertexSurface;
6783 int rc = vmsvga3dSurfaceFromSid(pState, sidVertex, &pVertexSurface);
6784 AssertRCReturn(rc, rc);
6785
6786 Log(("vmsvga3dDrawPrimitives: vertex surface sid=%u\n", sidVertex));
6787
6788 /* Create and/or bind the vertex buffer. */
6789 if (pVertexSurface->oglId.buffer == OPENGL_INVALID_ID)
6790 {
6791 Log(("vmsvga3dDrawPrimitives: create vertex buffer fDirty=%d size=%x bytes\n", pVertexSurface->fDirty, pVertexSurface->paMipmapLevels[0].cbSurface));
6792 PVMSVGA3DCONTEXT pSavedCtx = pContext;
6793 pContext = &pState->SharedCtx;
6794 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
6795
6796 pState->ext.glGenBuffers(1, &pVertexSurface->oglId.buffer);
6797 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6798 pVertexSurface->enmOGLResType = VMSVGA3D_OGLRESTYPE_BUFFER;
6799
6800 pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pVertexSurface->oglId.buffer);
6801 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6802
6803 Assert(pVertexSurface->fDirty);
6804 /** @todo rethink usage dynamic/static */
6805 pState->ext.glBufferData(GL_ARRAY_BUFFER, pVertexSurface->paMipmapLevels[0].cbSurface, pVertexSurface->paMipmapLevels[0].pSurfaceData, GL_DYNAMIC_DRAW);
6806 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6807
6808 pVertexSurface->paMipmapLevels[0].fDirty = false;
6809 pVertexSurface->fDirty = false;
6810
6811 pVertexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
6812
6813 pState->ext.glBindBuffer(GL_ARRAY_BUFFER, OPENGL_INVALID_ID);
6814 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6815
6816 pContext = pSavedCtx;
6817 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
6818 }
6819
6820 Assert(pVertexSurface->fDirty == false);
6821 pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pVertexSurface->oglId.buffer);
6822 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6823
6824 /* Setup the vertex declarations. */
6825 for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
6826 {
6827 GLint size;
6828 GLenum type;
6829 GLboolean normalized;
6830 uint32_t cbAttrib;
6831 GLuint index = iVertexDeclBase + iVertex;
6832
6833 Log(("vmsvga3dDrawPrimitives: array index %d type=%s (%d) method=%s (%d) usage=%s (%d) usageIndex=%d stride=%d offset=%d\n", index, vmsvgaDeclType2String(pVertexDecl[iVertex].identity.type), pVertexDecl[iVertex].identity.type, vmsvgaDeclMethod2String(pVertexDecl[iVertex].identity.method), pVertexDecl[iVertex].identity.method, vmsvgaDeclUsage2String(pVertexDecl[iVertex].identity.usage), pVertexDecl[iVertex].identity.usage, pVertexDecl[iVertex].identity.usageIndex, pVertexDecl[iVertex].array.stride, pVertexDecl[iVertex].array.offset));
6834
6835 rc = vmsvga3dVertexDecl2OGL(pVertexDecl[iVertex].identity, size, type, normalized, cbAttrib);
6836 AssertRCReturn(rc, rc);
6837
6838 ASSERT_GUEST_RETURN( pVertexSurface->paMipmapLevels[0].cbSurface >= pVertexDecl[iVertex].array.offset
6839 && pVertexSurface->paMipmapLevels[0].cbSurface - pVertexDecl[iVertex].array.offset >= cbAttrib,
6840 VERR_INVALID_PARAMETER);
6841 RT_UNTRUSTED_VALIDATED_FENCE();
6842
6843 if (pContext->state.shidVertex != SVGA_ID_INVALID)
6844 {
6845 /* Use numbered vertex arrays (or attributes) when shaders are active. */
6846 if (pVertexDecl[iVertex].array.stride)
6847 {
6848 pState->ext.glEnableVertexAttribArray(index);
6849 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6850 pState->ext.glVertexAttribPointer(index, size, type, normalized, pVertexDecl[iVertex].array.stride,
6851 (const GLvoid *)(uintptr_t)pVertexDecl[iVertex].array.offset);
6852 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6853
6854 GLuint divisor = paVertexDivisors && paVertexDivisors[index].instanceData ? 1 : 0;
6855 pState->ext.glVertexAttribDivisor(index, divisor);
6856 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6857
6858 /** @todo case SVGA3D_DECLUSAGE_COLOR: color component order not identical!! test GL_BGRA!! */
6859 }
6860 else
6861 {
6862 /*
6863 * D3D and OpenGL have a different meaning of value zero for the vertex array stride:
6864 * - D3D (VMSVGA): "use a zero stride to tell the runtime not to increment the vertex buffer offset."
6865 * - OpenGL: "If stride is 0, the generic vertex attributes are understood to be tightly packed in the array."
6866 * VMSVGA uses the D3D semantics.
6867 *
6868 * Use glVertexAttrib in order to tell OpenGL to reuse the zero stride attributes for each vertex.
6869 */
6870 pState->ext.glDisableVertexAttribArray(index);
6871 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6872
6873 const GLvoid *v = (uint8_t *)pVertexSurface->paMipmapLevels[0].pSurfaceData + pVertexDecl[iVertex].array.offset;
6874 vmsvga3dSetVertexAttrib(pState, index, &pVertexDecl[iVertex].identity, v);
6875 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
6876 }
6877 }
6878 else
6879 {
6880 if (pVertexDecl[iVertex].array.stride == 0)
6881 {
6882 /* Zero stride means that the attribute pointer must not be increased.
6883 * See comment about stride in vmsvga3dDrawPrimitives.
6884 */
6885 LogRelMax(8, ("VMSVGA: Warning: zero stride array in fixed function pipeline\n"));
6886 AssertFailed();
6887 }
6888
6889 /* Use the predefined selection of vertex streams for the fixed pipeline. */
6890 switch (pVertexDecl[iVertex].identity.usage)
6891 {
6892 case SVGA3D_DECLUSAGE_POSITIONT:
6893 case SVGA3D_DECLUSAGE_POSITION:
6894 {
6895 glEnableClientState(GL_VERTEX_ARRAY);
6896 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6897 glVertexPointer(size, type, pVertexDecl[iVertex].array.stride,
6898 (const GLvoid *)(uintptr_t)pVertexDecl[iVertex].array.offset);
6899 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6900 break;
6901 }
6902 case SVGA3D_DECLUSAGE_BLENDWEIGHT:
6903 AssertFailed();
6904 break;
6905 case SVGA3D_DECLUSAGE_BLENDINDICES:
6906 AssertFailed();
6907 break;
6908 case SVGA3D_DECLUSAGE_NORMAL:
6909 glEnableClientState(GL_NORMAL_ARRAY);
6910 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6911 glNormalPointer(type, pVertexDecl[iVertex].array.stride,
6912 (const GLvoid *)(uintptr_t)pVertexDecl[iVertex].array.offset);
6913 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6914 break;
6915 case SVGA3D_DECLUSAGE_PSIZE:
6916 AssertFailed();
6917 break;
6918 case SVGA3D_DECLUSAGE_TEXCOORD:
6919 /* Specify the affected texture unit. */
6920#if VBOX_VMSVGA3D_GL_HACK_LEVEL >= 0x103
6921 glClientActiveTexture(GL_TEXTURE0 + pVertexDecl[iVertex].identity.usageIndex);
6922#else
6923 pState->ext.glClientActiveTexture(GL_TEXTURE0 + pVertexDecl[iVertex].identity.usageIndex);
6924#endif
6925 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
6926 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6927 glTexCoordPointer(size, type, pVertexDecl[iVertex].array.stride,
6928 (const GLvoid *)(uintptr_t)pVertexDecl[iVertex].array.offset);
6929 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6930 break;
6931 case SVGA3D_DECLUSAGE_TANGENT:
6932 AssertFailed();
6933 break;
6934 case SVGA3D_DECLUSAGE_BINORMAL:
6935 AssertFailed();
6936 break;
6937 case SVGA3D_DECLUSAGE_TESSFACTOR:
6938 AssertFailed();
6939 break;
6940 case SVGA3D_DECLUSAGE_COLOR: /** @todo color component order not identical!! test GL_BGRA!! */
6941 glEnableClientState(GL_COLOR_ARRAY);
6942 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6943 glColorPointer(size, type, pVertexDecl[iVertex].array.stride,
6944 (const GLvoid *)(uintptr_t)pVertexDecl[iVertex].array.offset);
6945 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6946 break;
6947 case SVGA3D_DECLUSAGE_FOG:
6948 glEnableClientState(GL_FOG_COORD_ARRAY);
6949 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6950 pState->ext.glFogCoordPointer(type, pVertexDecl[iVertex].array.stride,
6951 (const GLvoid *)(uintptr_t)pVertexDecl[iVertex].array.offset);
6952 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6953 break;
6954 case SVGA3D_DECLUSAGE_DEPTH:
6955 AssertFailed();
6956 break;
6957 case SVGA3D_DECLUSAGE_SAMPLE:
6958 AssertFailed();
6959 break;
6960 case SVGA3D_DECLUSAGE_MAX: AssertFailed(); break; /* shut up gcc */
6961 }
6962 }
6963
6964#ifdef LOG_ENABLED
6965 if (pVertexDecl[iVertex].array.stride == 0)
6966 Log(("vmsvga3dDrawPrimitives: stride == 0! Can be valid\n"));
6967#endif
6968 }
6969
6970 return VINF_SUCCESS;
6971}
6972
6973static int vmsvga3dDrawPrimitivesCleanupVertexDecls(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t iVertexDeclBase,
6974 uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl)
6975{
6976 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
6977
6978 /* Clean up the vertex declarations. */
6979 for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
6980 {
6981 if (pVertexDecl[iVertex].identity.usage == SVGA3D_DECLUSAGE_POSITIONT)
6982 {
6983 /* Reset the transformation matrices in case of a switch back from pretransformed mode. */
6984 Log(("vmsvga3dDrawPrimitivesCleanupVertexDecls: reset world and projection matrices after transformation reset (pre-transformed -> transformed)\n"));
6985 vmsvga3dResetTransformMatrices(pThisCC, pContext);
6986 }
6987
6988 if (pContext->state.shidVertex != SVGA_ID_INVALID)
6989 {
6990 /* Use numbered vertex arrays when shaders are active. */
6991 pState->ext.glVertexAttribDivisor(iVertexDeclBase + iVertex, 0);
6992 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6993 pState->ext.glDisableVertexAttribArray(iVertexDeclBase + iVertex);
6994 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
6995 }
6996 else
6997 {
6998 /* Use the predefined selection of vertex streams for the fixed pipeline. */
6999 switch (pVertexDecl[iVertex].identity.usage)
7000 {
7001 case SVGA3D_DECLUSAGE_POSITION:
7002 case SVGA3D_DECLUSAGE_POSITIONT:
7003 glDisableClientState(GL_VERTEX_ARRAY);
7004 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7005 break;
7006 case SVGA3D_DECLUSAGE_BLENDWEIGHT:
7007 break;
7008 case SVGA3D_DECLUSAGE_BLENDINDICES:
7009 break;
7010 case SVGA3D_DECLUSAGE_NORMAL:
7011 glDisableClientState(GL_NORMAL_ARRAY);
7012 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7013 break;
7014 case SVGA3D_DECLUSAGE_PSIZE:
7015 break;
7016 case SVGA3D_DECLUSAGE_TEXCOORD:
7017 /* Specify the affected texture unit. */
7018#if VBOX_VMSVGA3D_GL_HACK_LEVEL >= 0x103
7019 glClientActiveTexture(GL_TEXTURE0 + pVertexDecl[iVertex].identity.usageIndex);
7020#else
7021 pState->ext.glClientActiveTexture(GL_TEXTURE0 + pVertexDecl[iVertex].identity.usageIndex);
7022#endif
7023 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
7024 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7025 break;
7026 case SVGA3D_DECLUSAGE_TANGENT:
7027 break;
7028 case SVGA3D_DECLUSAGE_BINORMAL:
7029 break;
7030 case SVGA3D_DECLUSAGE_TESSFACTOR:
7031 break;
7032 case SVGA3D_DECLUSAGE_COLOR: /** @todo color component order not identical!! */
7033 glDisableClientState(GL_COLOR_ARRAY);
7034 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7035 break;
7036 case SVGA3D_DECLUSAGE_FOG:
7037 glDisableClientState(GL_FOG_COORD_ARRAY);
7038 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7039 break;
7040 case SVGA3D_DECLUSAGE_DEPTH:
7041 break;
7042 case SVGA3D_DECLUSAGE_SAMPLE:
7043 break;
7044 case SVGA3D_DECLUSAGE_MAX: AssertFailed(); break; /* shut up gcc */
7045 }
7046 }
7047 }
7048 /* Unbind the vertex buffer after usage. */
7049 pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);
7050 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7051 return VINF_SUCCESS;
7052}
7053
7054static DECLCALLBACK(int) vmsvga3dBackDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
7055 uint32_t numRanges, SVGA3dPrimitiveRange *pRange, uint32_t cVertexDivisor,
7056 SVGA3dVertexDivisor *pVertexDivisor)
7057{
7058 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7059 AssertReturn(pState, VERR_INTERNAL_ERROR);
7060 uint32_t iCurrentVertex;
7061
7062 Log(("vmsvga3dDrawPrimitives cid=%u numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
7063
7064 /* Caller already check these, but it cannot hurt to check again... */
7065 AssertReturn(numVertexDecls && numVertexDecls <= SVGA3D_MAX_VERTEX_ARRAYS, VERR_INVALID_PARAMETER);
7066 AssertReturn(numRanges && numRanges <= SVGA3D_MAX_DRAW_PRIMITIVE_RANGES, VERR_INVALID_PARAMETER);
7067 AssertReturn(!cVertexDivisor || cVertexDivisor == numVertexDecls, VERR_INVALID_PARAMETER);
7068
7069 if (!cVertexDivisor)
7070 pVertexDivisor = NULL; /* Be sure. */
7071
7072 PVMSVGA3DCONTEXT pContext;
7073 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
7074 AssertRCReturn(rc, rc);
7075
7076 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7077
7078 /* Check for pretransformed vertex declarations. */
7079 for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
7080 {
7081 switch (pVertexDecl[iVertex].identity.usage)
7082 {
7083 case SVGA3D_DECLUSAGE_POSITIONT:
7084 Log(("ShaderSetPositionTransformed: (%d,%d)\n", pContext->state.RectViewPort.w, pContext->state.RectViewPort.h));
7085 RT_FALL_THRU();
7086 case SVGA3D_DECLUSAGE_POSITION:
7087 ShaderSetPositionTransformed(pContext->pShaderContext, pContext->state.RectViewPort.w,
7088 pContext->state.RectViewPort.h,
7089 pVertexDecl[iVertex].identity.usage == SVGA3D_DECLUSAGE_POSITIONT);
7090 break;
7091 default: /* Shut up MSC. */ break;
7092 }
7093 }
7094
7095 /* Flush any shader changes; after (!) checking the vertex declarations to deal with pre-transformed vertices. */
7096 if (pContext->pShaderContext)
7097 {
7098 uint32_t rtHeight = 0;
7099
7100 if (pContext->state.aRenderTargets[SVGA3D_RT_COLOR0] != SVGA_ID_INVALID)
7101 {
7102 PVMSVGA3DSURFACE pRenderTarget;
7103 rc = vmsvga3dSurfaceFromSid(pState, pContext->state.aRenderTargets[SVGA3D_RT_COLOR0], &pRenderTarget);
7104 AssertRCReturn(rc, rc);
7105
7106 rtHeight = pRenderTarget->paMipmapLevels[0].mipmapSize.height;
7107 }
7108
7109 ShaderUpdateState(pContext->pShaderContext, rtHeight);
7110 }
7111
7112 /* Try to figure out if instancing is used.
7113 * Support simple instancing case with one set of indexed data and one set per-instance data.
7114 */
7115 uint32_t cInstances = 0;
7116 for (uint32_t iVertexDivisor = 0; iVertexDivisor < cVertexDivisor; ++iVertexDivisor)
7117 {
7118 if (pVertexDivisor[iVertexDivisor].indexedData)
7119 {
7120 if (cInstances == 0)
7121 cInstances = pVertexDivisor[iVertexDivisor].count;
7122 else
7123 Assert(cInstances == pVertexDivisor[iVertexDivisor].count);
7124 }
7125 else if (pVertexDivisor[iVertexDivisor].instanceData)
7126 {
7127 Assert(pVertexDivisor[iVertexDivisor].count == 1);
7128 }
7129 }
7130
7131 /* Process all vertex declarations. Each vertex buffer is represented by one stream. */
7132 iCurrentVertex = 0;
7133 while (iCurrentVertex < numVertexDecls)
7134 {
7135 uint32_t sidVertex = SVGA_ID_INVALID;
7136 uint32_t iVertex;
7137
7138 for (iVertex = iCurrentVertex; iVertex < numVertexDecls; iVertex++)
7139 {
7140 if ( sidVertex != SVGA_ID_INVALID
7141 && pVertexDecl[iVertex].array.surfaceId != sidVertex
7142 )
7143 break;
7144 sidVertex = pVertexDecl[iVertex].array.surfaceId;
7145 }
7146
7147 rc = vmsvga3dDrawPrimitivesProcessVertexDecls(pThisCC, pContext, iCurrentVertex, iVertex - iCurrentVertex,
7148 &pVertexDecl[iCurrentVertex], pVertexDivisor);
7149 AssertRCReturn(rc, rc);
7150
7151 iCurrentVertex = iVertex;
7152 }
7153
7154 /* Now draw the primitives. */
7155 for (unsigned iPrimitive = 0; iPrimitive < numRanges; iPrimitive++)
7156 {
7157 GLenum modeDraw;
7158 unsigned const sidIndex = pRange[iPrimitive].indexArray.surfaceId;
7159 PVMSVGA3DSURFACE pIndexSurface = NULL;
7160 unsigned cVertices;
7161
7162 Log(("Primitive %d: type %s\n", iPrimitive, vmsvga3dPrimitiveType2String(pRange[iPrimitive].primType)));
7163 rc = vmsvga3dPrimitiveType2OGL(pRange[iPrimitive].primType, &modeDraw, pRange[iPrimitive].primitiveCount, &cVertices);
7164 if (RT_FAILURE(rc))
7165 {
7166 AssertRC(rc);
7167 goto internal_error;
7168 }
7169
7170 if (sidIndex != SVGA3D_INVALID_ID)
7171 {
7172 AssertMsg(pRange[iPrimitive].indexWidth == sizeof(uint32_t) || pRange[iPrimitive].indexWidth == sizeof(uint16_t), ("Unsupported primitive width %d\n", pRange[iPrimitive].indexWidth));
7173
7174 rc = vmsvga3dSurfaceFromSid(pState, sidIndex, &pIndexSurface);
7175 if (RT_FAILURE(rc))
7176 {
7177 AssertRC(rc);
7178 goto internal_error;
7179 }
7180
7181 Log(("vmsvga3dDrawPrimitives: index surface sid=%u\n", sidIndex));
7182
7183 if (pIndexSurface->oglId.buffer == OPENGL_INVALID_ID)
7184 {
7185 Log(("vmsvga3dDrawPrimitives: create index buffer fDirty=%d size=%x bytes\n", pIndexSurface->fDirty, pIndexSurface->paMipmapLevels[0].cbSurface));
7186 pContext = &pState->SharedCtx;
7187 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7188
7189 pState->ext.glGenBuffers(1, &pIndexSurface->oglId.buffer);
7190 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7191 pIndexSurface->enmOGLResType = VMSVGA3D_OGLRESTYPE_BUFFER;
7192
7193 pState->ext.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pIndexSurface->oglId.buffer);
7194 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7195
7196 Assert(pIndexSurface->fDirty);
7197
7198 /** @todo rethink usage dynamic/static */
7199 pState->ext.glBufferData(GL_ELEMENT_ARRAY_BUFFER, pIndexSurface->paMipmapLevels[0].cbSurface, pIndexSurface->paMipmapLevels[0].pSurfaceData, GL_DYNAMIC_DRAW);
7200 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7201
7202 pIndexSurface->paMipmapLevels[0].fDirty = false;
7203 pIndexSurface->fDirty = false;
7204
7205 pIndexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
7206
7207 pState->ext.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, OPENGL_INVALID_ID);
7208 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7209
7210 pContext = pState->papContexts[cid];
7211 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7212 }
7213 Assert(pIndexSurface->fDirty == false);
7214
7215 pState->ext.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pIndexSurface->oglId.buffer);
7216 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7217 }
7218
7219 if (!pIndexSurface)
7220 {
7221 /* Render without an index buffer */
7222 Log(("DrawPrimitive %d cPrimitives=%d cVertices=%d index index bias=%d cInstances=%d\n", modeDraw, pRange[iPrimitive].primitiveCount, cVertices, pRange[iPrimitive].indexBias, cInstances));
7223 if (cInstances == 0)
7224 {
7225 glDrawArrays(modeDraw, pRange[iPrimitive].indexBias, cVertices);
7226 }
7227 else
7228 {
7229 pState->ext.glDrawArraysInstanced(modeDraw, pRange[iPrimitive].indexBias, cVertices, cInstances);
7230 }
7231 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7232 }
7233 else
7234 {
7235 Assert(pRange[iPrimitive].indexWidth == pRange[iPrimitive].indexArray.stride);
7236
7237 GLenum indexType;
7238 switch (pRange[iPrimitive].indexWidth)
7239 {
7240 case 1: indexType = GL_UNSIGNED_BYTE; break;
7241 case 2: indexType = GL_UNSIGNED_SHORT; break;
7242 default: AssertMsgFailed(("indexWidth %d\n", pRange[iPrimitive].indexWidth));
7243 RT_FALL_THROUGH();
7244 case 4: indexType = GL_UNSIGNED_INT; break;
7245 }
7246
7247 Log(("DrawIndexedPrimitive %d cPrimitives=%d cVertices=%d hint.first=%d hint.last=%d index offset=%d primitivecount=%d index width=%d index bias=%d cInstances=%d\n", modeDraw, pRange[iPrimitive].primitiveCount, cVertices, pVertexDecl[0].rangeHint.first, pVertexDecl[0].rangeHint.last, pRange[iPrimitive].indexArray.offset, pRange[iPrimitive].primitiveCount, pRange[iPrimitive].indexWidth, pRange[iPrimitive].indexBias, cInstances));
7248 if (cInstances == 0)
7249 {
7250 /* Render with an index buffer */
7251 if (pRange[iPrimitive].indexBias == 0)
7252 glDrawElements(modeDraw,
7253 cVertices,
7254 indexType,
7255 (GLvoid *)(uintptr_t)pRange[iPrimitive].indexArray.offset); /* byte offset in indices buffer */
7256 else
7257 pState->ext.glDrawElementsBaseVertex(modeDraw,
7258 cVertices,
7259 indexType,
7260 (GLvoid *)(uintptr_t)pRange[iPrimitive].indexArray.offset, /* byte offset in indices buffer */
7261 pRange[iPrimitive].indexBias); /* basevertex */
7262 }
7263 else
7264 {
7265 /* Render with an index buffer */
7266 if (pRange[iPrimitive].indexBias == 0)
7267 pState->ext.glDrawElementsInstanced(modeDraw,
7268 cVertices,
7269 indexType,
7270 (GLvoid *)(uintptr_t)pRange[iPrimitive].indexArray.offset, /* byte offset in indices buffer */
7271 cInstances);
7272 else
7273 pState->ext.glDrawElementsInstancedBaseVertex(modeDraw,
7274 cVertices,
7275 indexType,
7276 (GLvoid *)(uintptr_t)pRange[iPrimitive].indexArray.offset, /* byte offset in indices buffer */
7277 cInstances,
7278 pRange[iPrimitive].indexBias); /* basevertex */
7279 }
7280 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7281
7282 /* Unbind the index buffer after usage. */
7283 pState->ext.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
7284 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7285 }
7286 }
7287
7288internal_error:
7289
7290 /* Deactivate the vertex declarations. */
7291 iCurrentVertex = 0;
7292 while (iCurrentVertex < numVertexDecls)
7293 {
7294 uint32_t sidVertex = SVGA_ID_INVALID;
7295 uint32_t iVertex;
7296
7297 for (iVertex = iCurrentVertex; iVertex < numVertexDecls; iVertex++)
7298 {
7299 if ( sidVertex != SVGA_ID_INVALID
7300 && pVertexDecl[iVertex].array.surfaceId != sidVertex
7301 )
7302 break;
7303 sidVertex = pVertexDecl[iVertex].array.surfaceId;
7304 }
7305
7306 rc = vmsvga3dDrawPrimitivesCleanupVertexDecls(pThisCC, pContext, iCurrentVertex,
7307 iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex]);
7308 AssertRCReturn(rc, rc);
7309
7310 iCurrentVertex = iVertex;
7311 }
7312
7313#ifdef DEBUG
7314 /* Check whether 'activeTexture' on texture unit 'i' matches what we expect. */
7315 for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTextures); ++i)
7316 {
7317 if (pContext->aSidActiveTextures[i] != SVGA3D_INVALID_ID)
7318 {
7319 PVMSVGA3DSURFACE pTexture;
7320 int rc2 = vmsvga3dSurfaceFromSid(pState, pContext->aSidActiveTextures[i], &pTexture);
7321 AssertContinue(RT_SUCCESS(rc2));
7322
7323 GLint activeTextureUnit = 0;
7324 glGetIntegerv(GL_ACTIVE_TEXTURE, &activeTextureUnit);
7325 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
7326
7327 pState->ext.glActiveTexture(GL_TEXTURE0 + i);
7328 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
7329
7330 GLint activeTexture = 0;
7331 glGetIntegerv(pTexture->bindingGL, &activeTexture);
7332 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
7333
7334 pState->ext.glActiveTexture(activeTextureUnit);
7335 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
7336
7337 AssertMsg(pTexture->oglId.texture == (GLuint)activeTexture,
7338 ("%d vs %d unit %d (active unit %d) sid=%u\n", pTexture->oglId.texture, activeTexture, i,
7339 activeTextureUnit - GL_TEXTURE0, pContext->aSidActiveTextures[i]));
7340 }
7341 }
7342#endif
7343
7344#if 0
7345 /* Dump render target to a bitmap. */
7346 if (pContext->state.aRenderTargets[SVGA3D_RT_COLOR0] != SVGA3D_INVALID_ID)
7347 {
7348 vmsvga3dUpdateHeapBuffersForSurfaces(pThisCC, pContext->state.aRenderTargets[SVGA3D_RT_COLOR0]);
7349 PVMSVGA3DSURFACE pSurface;
7350 int rc2 = vmsvga3dSurfaceFromSid(pState, pContext->state.aRenderTargets[SVGA3D_RT_COLOR0], &pSurface);
7351 if (RT_SUCCESS(rc2))
7352 vmsvga3dInfoSurfaceToBitmap(NULL, pSurface, "bmpgl", "rt", "-post");
7353# if 0
7354 /* Stage 0 texture. */
7355 if (pContext->aSidActiveTextures[0] != SVGA3D_INVALID_ID)
7356 {
7357 vmsvga3dUpdateHeapBuffersForSurfaces(pThisCC, pContext->aSidActiveTextures[0]);
7358 rc2 = vmsvga3dSurfaceFromSid(pState, pContext->aSidActiveTextures[0], &pSurface);
7359 if (RT_SUCCESS(rc2))
7360 vmsvga3dInfoSurfaceToBitmap(NULL, pSurface, "bmpgl", "rt", "-post-tx");
7361 }
7362# endif
7363 }
7364#endif
7365
7366 return rc;
7367}
7368
7369
7370static DECLCALLBACK(int) vmsvga3dBackShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
7371{
7372 PVMSVGA3DSHADER pShader;
7373 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7374 AssertReturn(pState, VERR_NO_MEMORY);
7375
7376 Log(("vmsvga3dShaderDefine cid=%u shid=%d type=%s cbData=0x%x\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cbData));
7377
7378 PVMSVGA3DCONTEXT pContext;
7379 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
7380 AssertRCReturn(rc, rc);
7381
7382 AssertReturn(shid < SVGA3D_MAX_SHADER_IDS, VERR_INVALID_PARAMETER);
7383
7384 rc = vmsvga3dShaderParse(type, cbData, pShaderData);
7385 if (RT_FAILURE(rc))
7386 {
7387 AssertRC(rc);
7388 vmsvga3dShaderLogRel("Failed to parse", type, cbData, pShaderData);
7389 return rc;
7390 }
7391
7392 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7393
7394 if (type == SVGA3D_SHADERTYPE_VS)
7395 {
7396 if (shid >= pContext->cVertexShaders)
7397 {
7398 void *pvNew = RTMemRealloc(pContext->paVertexShader, sizeof(VMSVGA3DSHADER) * (shid + 1));
7399 AssertReturn(pvNew, VERR_NO_MEMORY);
7400 pContext->paVertexShader = (PVMSVGA3DSHADER)pvNew;
7401 memset(&pContext->paVertexShader[pContext->cVertexShaders], 0, sizeof(VMSVGA3DSHADER) * (shid + 1 - pContext->cVertexShaders));
7402 for (uint32_t i = pContext->cVertexShaders; i < shid + 1; i++)
7403 pContext->paVertexShader[i].id = SVGA3D_INVALID_ID;
7404 pContext->cVertexShaders = shid + 1;
7405 }
7406 /* If one already exists with this id, then destroy it now. */
7407 if (pContext->paVertexShader[shid].id != SVGA3D_INVALID_ID)
7408 vmsvga3dBackShaderDestroy(pThisCC, cid, shid, pContext->paVertexShader[shid].type);
7409
7410 pShader = &pContext->paVertexShader[shid];
7411 }
7412 else
7413 {
7414 Assert(type == SVGA3D_SHADERTYPE_PS);
7415 if (shid >= pContext->cPixelShaders)
7416 {
7417 void *pvNew = RTMemRealloc(pContext->paPixelShader, sizeof(VMSVGA3DSHADER) * (shid + 1));
7418 AssertReturn(pvNew, VERR_NO_MEMORY);
7419 pContext->paPixelShader = (PVMSVGA3DSHADER)pvNew;
7420 memset(&pContext->paPixelShader[pContext->cPixelShaders], 0, sizeof(VMSVGA3DSHADER) * (shid + 1 - pContext->cPixelShaders));
7421 for (uint32_t i = pContext->cPixelShaders; i < shid + 1; i++)
7422 pContext->paPixelShader[i].id = SVGA3D_INVALID_ID;
7423 pContext->cPixelShaders = shid + 1;
7424 }
7425 /* If one already exists with this id, then destroy it now. */
7426 if (pContext->paPixelShader[shid].id != SVGA3D_INVALID_ID)
7427 vmsvga3dBackShaderDestroy(pThisCC, cid, shid, pContext->paPixelShader[shid].type);
7428
7429 pShader = &pContext->paPixelShader[shid];
7430 }
7431
7432 memset(pShader, 0, sizeof(*pShader));
7433 pShader->id = shid;
7434 pShader->cid = cid;
7435 pShader->type = type;
7436 pShader->cbData = cbData;
7437 pShader->pShaderProgram = RTMemAllocZ(cbData);
7438 AssertReturn(pShader->pShaderProgram, VERR_NO_MEMORY);
7439 memcpy(pShader->pShaderProgram, pShaderData, cbData);
7440
7441#ifdef DUMP_SHADER_DISASSEMBLY
7442 LPD3DXBUFFER pDisassembly;
7443 HRESULT hr = D3DXDisassembleShader((const DWORD *)pShaderData, FALSE, NULL, &pDisassembly);
7444 if (hr == D3D_OK)
7445 {
7446 Log(("Shader disassembly:\n%s\n", pDisassembly->GetBufferPointer()));
7447 pDisassembly->Release();
7448 }
7449#endif
7450
7451 switch (type)
7452 {
7453 case SVGA3D_SHADERTYPE_VS:
7454 rc = ShaderCreateVertexShader(pContext->pShaderContext, (const uint32_t *)pShaderData, cbData, &pShader->u.pVertexShader);
7455 AssertRC(rc);
7456 break;
7457
7458 case SVGA3D_SHADERTYPE_PS:
7459 rc = ShaderCreatePixelShader(pContext->pShaderContext, (const uint32_t *)pShaderData, cbData, &pShader->u.pPixelShader);
7460 AssertRC(rc);
7461 break;
7462
7463 default:
7464 AssertFailedReturn(VERR_INVALID_PARAMETER);
7465 }
7466 if (rc != VINF_SUCCESS)
7467 {
7468 vmsvga3dShaderLogRel("Failed to create", type, cbData, pShaderData);
7469
7470 RTMemFree(pShader->pShaderProgram);
7471 memset(pShader, 0, sizeof(*pShader));
7472 pShader->id = SVGA3D_INVALID_ID;
7473 }
7474
7475 return rc;
7476}
7477
7478static DECLCALLBACK(int) vmsvga3dBackShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
7479{
7480 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7481 AssertReturn(pState, VERR_NO_MEMORY);
7482 PVMSVGA3DSHADER pShader = NULL;
7483
7484 Log(("vmsvga3dShaderDestroy cid=%u shid=%d type=%s\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL"));
7485
7486 PVMSVGA3DCONTEXT pContext;
7487 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
7488 AssertRCReturn(rc, rc);
7489
7490 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7491
7492 if (type == SVGA3D_SHADERTYPE_VS)
7493 {
7494 if ( shid < pContext->cVertexShaders
7495 && pContext->paVertexShader[shid].id == shid)
7496 {
7497 pShader = &pContext->paVertexShader[shid];
7498 rc = ShaderDestroyVertexShader(pContext->pShaderContext, pShader->u.pVertexShader);
7499 AssertRC(rc);
7500 }
7501 }
7502 else
7503 {
7504 Assert(type == SVGA3D_SHADERTYPE_PS);
7505 if ( shid < pContext->cPixelShaders
7506 && pContext->paPixelShader[shid].id == shid)
7507 {
7508 pShader = &pContext->paPixelShader[shid];
7509 rc = ShaderDestroyPixelShader(pContext->pShaderContext, pShader->u.pPixelShader);
7510 AssertRC(rc);
7511 }
7512 }
7513
7514 if (pShader)
7515 {
7516 if (pShader->pShaderProgram)
7517 RTMemFree(pShader->pShaderProgram);
7518 memset(pShader, 0, sizeof(*pShader));
7519 pShader->id = SVGA3D_INVALID_ID;
7520 }
7521 else
7522 AssertFailedReturn(VERR_INVALID_PARAMETER);
7523
7524 return VINF_SUCCESS;
7525}
7526
7527static DECLCALLBACK(int) vmsvga3dBackShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
7528{
7529 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7530 AssertReturn(pState, VERR_NO_MEMORY);
7531 int rc;
7532
7533 Log(("vmsvga3dShaderSet cid=%u type=%s shid=%d\n", cid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", shid));
7534
7535 if (!pContext)
7536 {
7537 rc = vmsvga3dContextFromCid(pState, cid, &pContext);
7538 AssertRCReturn(rc, rc);
7539 }
7540
7541 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7542
7543 if (type == SVGA3D_SHADERTYPE_VS)
7544 {
7545 /* Save for vm state save/restore. */
7546 pContext->state.shidVertex = shid;
7547 pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_VERTEXSHADER;
7548
7549 if ( shid < pContext->cVertexShaders
7550 && pContext->paVertexShader[shid].id == shid)
7551 {
7552 PVMSVGA3DSHADER pShader = &pContext->paVertexShader[shid];
7553 Assert(type == pShader->type);
7554
7555 rc = ShaderSetVertexShader(pContext->pShaderContext, pShader->u.pVertexShader);
7556 AssertRCReturn(rc, rc);
7557 }
7558 else
7559 if (shid == SVGA_ID_INVALID)
7560 {
7561 /* Unselect shader. */
7562 rc = ShaderSetVertexShader(pContext->pShaderContext, NULL);
7563 AssertRCReturn(rc, rc);
7564 }
7565 else
7566 AssertFailedReturn(VERR_INVALID_PARAMETER);
7567 }
7568 else
7569 {
7570 /* Save for vm state save/restore. */
7571 pContext->state.shidPixel = shid;
7572 pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_PIXELSHADER;
7573
7574 Assert(type == SVGA3D_SHADERTYPE_PS);
7575 if ( shid < pContext->cPixelShaders
7576 && pContext->paPixelShader[shid].id == shid)
7577 {
7578 PVMSVGA3DSHADER pShader = &pContext->paPixelShader[shid];
7579 Assert(type == pShader->type);
7580
7581 rc = ShaderSetPixelShader(pContext->pShaderContext, pShader->u.pPixelShader);
7582 AssertRCReturn(rc, rc);
7583 }
7584 else
7585 if (shid == SVGA_ID_INVALID)
7586 {
7587 /* Unselect shader. */
7588 rc = ShaderSetPixelShader(pContext->pShaderContext, NULL);
7589 AssertRCReturn(rc, rc);
7590 }
7591 else
7592 AssertFailedReturn(VERR_INVALID_PARAMETER);
7593 }
7594
7595 return VINF_SUCCESS;
7596}
7597
7598static DECLCALLBACK(int) vmsvga3dBackShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
7599{
7600 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7601 AssertReturn(pState, VERR_NO_MEMORY);
7602
7603 Log(("vmsvga3dShaderSetConst cid=%u reg=%x type=%s cregs=%d ctype=%x\n", cid, reg, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cRegisters, ctype));
7604
7605 PVMSVGA3DCONTEXT pContext;
7606 int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
7607 AssertRCReturn(rc, rc);
7608
7609 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7610
7611 for (uint32_t i = 0; i < cRegisters; i++)
7612 {
7613#ifdef LOG_ENABLED
7614 switch (ctype)
7615 {
7616 case SVGA3D_CONST_TYPE_FLOAT:
7617 {
7618 float *pValuesF = (float *)pValues;
7619 Log(("ConstantF %d: value=" FLOAT_FMT_STR ", " FLOAT_FMT_STR ", " FLOAT_FMT_STR ", " FLOAT_FMT_STR "\n",
7620 reg + i, FLOAT_FMT_ARGS(pValuesF[i*4 + 0]), FLOAT_FMT_ARGS(pValuesF[i*4 + 1]), FLOAT_FMT_ARGS(pValuesF[i*4 + 2]), FLOAT_FMT_ARGS(pValuesF[i*4 + 3])));
7621 break;
7622 }
7623
7624 case SVGA3D_CONST_TYPE_INT:
7625 Log(("ConstantI %d: value=%d, %d, %d, %d\n", reg + i, pValues[i*4 + 0], pValues[i*4 + 1], pValues[i*4 + 2], pValues[i*4 + 3]));
7626 break;
7627
7628 case SVGA3D_CONST_TYPE_BOOL:
7629 Log(("ConstantB %d: value=%d, %d, %d, %d\n", reg + i, pValues[i*4 + 0], pValues[i*4 + 1], pValues[i*4 + 2], pValues[i*4 + 3]));
7630 break;
7631
7632 default:
7633 AssertFailedReturn(VERR_INVALID_PARAMETER);
7634 }
7635#endif
7636 vmsvga3dSaveShaderConst(pContext, reg + i, type, ctype, pValues[i*4 + 0], pValues[i*4 + 1], pValues[i*4 + 2], pValues[i*4 + 3]);
7637 }
7638
7639 switch (type)
7640 {
7641 case SVGA3D_SHADERTYPE_VS:
7642 switch (ctype)
7643 {
7644 case SVGA3D_CONST_TYPE_FLOAT:
7645 rc = ShaderSetVertexShaderConstantF(pContext->pShaderContext, reg, (const float *)pValues, cRegisters);
7646 break;
7647
7648 case SVGA3D_CONST_TYPE_INT:
7649 rc = ShaderSetVertexShaderConstantI(pContext->pShaderContext, reg, (const int32_t *)pValues, cRegisters);
7650 break;
7651
7652 case SVGA3D_CONST_TYPE_BOOL:
7653 rc = ShaderSetVertexShaderConstantB(pContext->pShaderContext, reg, (const uint8_t *)pValues, cRegisters);
7654 break;
7655
7656 default:
7657 AssertFailedReturn(VERR_INVALID_PARAMETER);
7658 }
7659 AssertRCReturn(rc, rc);
7660 break;
7661
7662 case SVGA3D_SHADERTYPE_PS:
7663 switch (ctype)
7664 {
7665 case SVGA3D_CONST_TYPE_FLOAT:
7666 rc = ShaderSetPixelShaderConstantF(pContext->pShaderContext, reg, (const float *)pValues, cRegisters);
7667 break;
7668
7669 case SVGA3D_CONST_TYPE_INT:
7670 rc = ShaderSetPixelShaderConstantI(pContext->pShaderContext, reg, (const int32_t *)pValues, cRegisters);
7671 break;
7672
7673 case SVGA3D_CONST_TYPE_BOOL:
7674 rc = ShaderSetPixelShaderConstantB(pContext->pShaderContext, reg, (const uint8_t *)pValues, cRegisters);
7675 break;
7676
7677 default:
7678 AssertFailedReturn(VERR_INVALID_PARAMETER);
7679 }
7680 AssertRCReturn(rc, rc);
7681 break;
7682
7683 default:
7684 AssertFailedReturn(VERR_INVALID_PARAMETER);
7685 }
7686
7687 return VINF_SUCCESS;
7688}
7689
7690static DECLCALLBACK(int) vmsvga3dBackOcclusionQueryCreate(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
7691{
7692 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7693 AssertReturn(pState->ext.glGenQueries, VERR_NOT_SUPPORTED);
7694 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7695
7696 GLuint idQuery = 0;
7697 pState->ext.glGenQueries(1, &idQuery);
7698 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7699 AssertReturn(idQuery, VERR_INTERNAL_ERROR);
7700 pContext->occlusion.idQuery = idQuery;
7701 return VINF_SUCCESS;
7702}
7703
7704static DECLCALLBACK(int) vmsvga3dBackOcclusionQueryDelete(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
7705{
7706 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7707 AssertReturn(pState->ext.glDeleteQueries, VERR_NOT_SUPPORTED);
7708 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7709
7710 if (pContext->occlusion.idQuery)
7711 {
7712 pState->ext.glDeleteQueries(1, &pContext->occlusion.idQuery);
7713 }
7714 return VINF_SUCCESS;
7715}
7716
7717static DECLCALLBACK(int) vmsvga3dBackOcclusionQueryBegin(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
7718{
7719 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7720 AssertReturn(pState->ext.glBeginQuery, VERR_NOT_SUPPORTED);
7721 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7722
7723 pState->ext.glBeginQuery(GL_ANY_SAMPLES_PASSED, pContext->occlusion.idQuery);
7724 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7725 return VINF_SUCCESS;
7726}
7727
7728static DECLCALLBACK(int) vmsvga3dBackOcclusionQueryEnd(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
7729{
7730 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7731 AssertReturn(pState->ext.glEndQuery, VERR_NOT_SUPPORTED);
7732 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7733
7734 pState->ext.glEndQuery(GL_ANY_SAMPLES_PASSED);
7735 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7736 return VINF_SUCCESS;
7737}
7738
7739static DECLCALLBACK(int) vmsvga3dBackOcclusionQueryGetData(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels)
7740{
7741 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7742 AssertReturn(pState->ext.glGetQueryObjectuiv, VERR_NOT_SUPPORTED);
7743 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7744
7745 GLuint pixels = 0;
7746 pState->ext.glGetQueryObjectuiv(pContext->occlusion.idQuery, GL_QUERY_RESULT, &pixels);
7747 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7748
7749 *pu32Pixels = (uint32_t)pixels;
7750 return VINF_SUCCESS;
7751}
7752
7753/**
7754 * Worker for vmsvga3dUpdateHeapBuffersForSurfaces.
7755 *
7756 * This will allocate heap buffers if necessary, thus increasing the memory
7757 * usage of the process.
7758 *
7759 * @todo Would be interesting to share this code with the saved state code.
7760 *
7761 * @returns VBox status code.
7762 * @param pThisCC The VGA/VMSVGA context.
7763 * @param pSurface The surface to refresh the heap buffers for.
7764 */
7765static DECLCALLBACK(int) vmsvga3dBackSurfaceUpdateHeapBuffers(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface)
7766{
7767 PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
7768 AssertReturn(pState, VERR_INVALID_STATE);
7769
7770 /*
7771 * Currently we've got trouble retreving bit for DEPTHSTENCIL
7772 * surfaces both for OpenGL and D3D, so skip these here (don't
7773 * wast memory on them).
7774 */
7775 uint32_t const fSwitchFlags = pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
7776 if ( fSwitchFlags != SVGA3D_SURFACE_HINT_DEPTHSTENCIL
7777 && fSwitchFlags != (SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE))
7778 {
7779 /*
7780 * Change OpenGL context to the one the surface is associated with.
7781 */
7782 PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
7783 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
7784
7785 /*
7786 * Work thru each mipmap level for each face.
7787 */
7788 for (uint32_t iFace = 0; iFace < pSurface->cFaces; iFace++)
7789 {
7790 PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[iFace * pSurface->cLevels];
7791 for (uint32_t i = 0; i < pSurface->cLevels; i++, pMipmapLevel++)
7792 {
7793 if (VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
7794 {
7795 Assert(pMipmapLevel->cbSurface);
7796 Assert(pMipmapLevel->cbSurface == pMipmapLevel->cbSurfacePlane * pMipmapLevel->mipmapSize.depth);
7797
7798 /*
7799 * Make sure we've got surface memory buffer.
7800 */
7801 uint8_t *pbDst = (uint8_t *)pMipmapLevel->pSurfaceData;
7802 if (!pbDst)
7803 {
7804 pMipmapLevel->pSurfaceData = pbDst = (uint8_t *)RTMemAllocZ(pMipmapLevel->cbSurface);
7805 AssertReturn(pbDst, VERR_NO_MEMORY);
7806 }
7807
7808 /*
7809 * OpenGL specifics.
7810 */
7811 switch (pSurface->enmOGLResType)
7812 {
7813 case VMSVGA3D_OGLRESTYPE_TEXTURE:
7814 {
7815 GLint activeTexture;
7816 glGetIntegerv(GL_TEXTURE_BINDING_2D, &activeTexture);
7817 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
7818
7819 glBindTexture(GL_TEXTURE_2D, pSurface->oglId.texture);
7820 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
7821
7822 /* Set row length and alignment of the output data. */
7823 VMSVGAPACKPARAMS SavedParams;
7824 vmsvga3dOglSetPackParams(pState, pContext, pSurface, &SavedParams);
7825
7826 glGetTexImage(GL_TEXTURE_2D,
7827 i,
7828 pSurface->formatGL,
7829 pSurface->typeGL,
7830 pbDst);
7831 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
7832
7833 vmsvga3dOglRestorePackParams(pState, pContext, pSurface, &SavedParams);
7834
7835 /* Restore the old active texture. */
7836 glBindTexture(GL_TEXTURE_2D, activeTexture);
7837 VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
7838 break;
7839 }
7840
7841 case VMSVGA3D_OGLRESTYPE_BUFFER:
7842 {
7843 pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pSurface->oglId.buffer);
7844 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7845
7846 void *pvSrc = pState->ext.glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
7847 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7848 if (RT_VALID_PTR(pvSrc))
7849 memcpy(pbDst, pvSrc, pMipmapLevel->cbSurface);
7850 else
7851 AssertPtr(pvSrc);
7852
7853 pState->ext.glUnmapBuffer(GL_ARRAY_BUFFER);
7854 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7855
7856 pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);
7857 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
7858 break;
7859 }
7860
7861 default:
7862 AssertMsgFailed(("%#x\n", fSwitchFlags));
7863 }
7864 }
7865 /* else: There is no data in hardware yet, so whatever we got is already current. */
7866 }
7867 }
7868 }
7869
7870 return VINF_SUCCESS;
7871}
7872
7873static DECLCALLBACK(int) vmsvga3dBackQueryInterface(PVGASTATECC pThisCC, char const *pszInterfaceName, void *pvInterfaceFuncs, size_t cbInterfaceFuncs)
7874{
7875 RT_NOREF(pThisCC);
7876
7877 int rc = VINF_SUCCESS;
7878 if (RTStrCmp(pszInterfaceName, VMSVGA3D_BACKEND_INTERFACE_NAME_3D) == 0)
7879 {
7880 if (cbInterfaceFuncs == sizeof(VMSVGA3DBACKENDFUNCS3D))
7881 {
7882 if (pvInterfaceFuncs)
7883 {
7884 VMSVGA3DBACKENDFUNCS3D *p = (VMSVGA3DBACKENDFUNCS3D *)pvInterfaceFuncs;
7885 p->pfnInit = vmsvga3dBackInit;
7886 p->pfnPowerOn = vmsvga3dBackPowerOn;
7887 p->pfnTerminate = vmsvga3dBackTerminate;
7888 p->pfnReset = vmsvga3dBackReset;
7889 p->pfnQueryCaps = vmsvga3dBackQueryCaps;
7890 p->pfnChangeMode = vmsvga3dBackChangeMode;
7891 p->pfnCreateTexture = vmsvga3dBackCreateTexture;
7892 p->pfnSurfaceDestroy = vmsvga3dBackSurfaceDestroy;
7893 p->pfnSurfaceCopy = vmsvga3dBackSurfaceCopy;
7894 p->pfnSurfaceDMACopyBox = vmsvga3dBackSurfaceDMACopyBox;
7895 p->pfnSurfaceStretchBlt = vmsvga3dBackSurfaceStretchBlt;
7896 p->pfnUpdateHostScreenViewport = vmsvga3dBackUpdateHostScreenViewport;
7897 p->pfnDefineScreen = vmsvga3dBackDefineScreen;
7898 p->pfnDestroyScreen = vmsvga3dBackDestroyScreen;
7899 p->pfnSurfaceBlitToScreen = vmsvga3dBackSurfaceBlitToScreen;
7900 p->pfnSurfaceUpdateHeapBuffers = vmsvga3dBackSurfaceUpdateHeapBuffers;
7901 }
7902 }
7903 else
7904 {
7905 AssertFailed();
7906 rc = VERR_INVALID_PARAMETER;
7907 }
7908 }
7909 else if (RTStrCmp(pszInterfaceName, VMSVGA3D_BACKEND_INTERFACE_NAME_VGPU9) == 0)
7910 {
7911 if (cbInterfaceFuncs == sizeof(VMSVGA3DBACKENDFUNCSVGPU9))
7912 {
7913 if (pvInterfaceFuncs)
7914 {
7915 VMSVGA3DBACKENDFUNCSVGPU9 *p = (VMSVGA3DBACKENDFUNCSVGPU9 *)pvInterfaceFuncs;
7916 p->pfnContextDefine = vmsvga3dBackContextDefine;
7917 p->pfnContextDestroy = vmsvga3dBackContextDestroy;
7918 p->pfnSetTransform = vmsvga3dBackSetTransform;
7919 p->pfnSetZRange = vmsvga3dBackSetZRange;
7920 p->pfnSetRenderState = vmsvga3dBackSetRenderState;
7921 p->pfnSetRenderTarget = vmsvga3dBackSetRenderTarget;
7922 p->pfnSetTextureState = vmsvga3dBackSetTextureState;
7923 p->pfnSetMaterial = vmsvga3dBackSetMaterial;
7924 p->pfnSetLightData = vmsvga3dBackSetLightData;
7925 p->pfnSetLightEnabled = vmsvga3dBackSetLightEnabled;
7926 p->pfnSetViewPort = vmsvga3dBackSetViewPort;
7927 p->pfnSetClipPlane = vmsvga3dBackSetClipPlane;
7928 p->pfnCommandClear = vmsvga3dBackCommandClear;
7929 p->pfnDrawPrimitives = vmsvga3dBackDrawPrimitives;
7930 p->pfnSetScissorRect = vmsvga3dBackSetScissorRect;
7931 p->pfnGenerateMipmaps = vmsvga3dBackGenerateMipmaps;
7932 p->pfnShaderDefine = vmsvga3dBackShaderDefine;
7933 p->pfnShaderDestroy = vmsvga3dBackShaderDestroy;
7934 p->pfnShaderSet = vmsvga3dBackShaderSet;
7935 p->pfnShaderSetConst = vmsvga3dBackShaderSetConst;
7936 p->pfnOcclusionQueryCreate = vmsvga3dBackOcclusionQueryCreate;
7937 p->pfnOcclusionQueryDelete = vmsvga3dBackOcclusionQueryDelete;
7938 p->pfnOcclusionQueryBegin = vmsvga3dBackOcclusionQueryBegin;
7939 p->pfnOcclusionQueryEnd = vmsvga3dBackOcclusionQueryEnd;
7940 p->pfnOcclusionQueryGetData = vmsvga3dBackOcclusionQueryGetData;
7941 }
7942 }
7943 else
7944 {
7945 AssertFailed();
7946 rc = VERR_INVALID_PARAMETER;
7947 }
7948 }
7949 else
7950 rc = VERR_NOT_IMPLEMENTED;
7951 return rc;
7952}
7953
7954
7955extern VMSVGA3DBACKENDDESC const g_BackendLegacy =
7956{
7957 "LEGACY",
7958 vmsvga3dBackQueryInterface
7959};
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette