summaryrefslogtreecommitdiffstats
path: root/include/VBox/HostServices/VBoxOGLOp.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-06 03:01:46 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-06 03:01:46 +0000
commitf8fe689a81f906d1b91bb3220acde2a4ecb14c5b (patch)
tree26484e9d7e2c67806c2d1760196ff01aaa858e8c /include/VBox/HostServices/VBoxOGLOp.h
parentInitial commit. (diff)
downloadvirtualbox-f8fe689a81f906d1b91bb3220acde2a4ecb14c5b.tar.xz
virtualbox-f8fe689a81f906d1b91bb3220acde2a4ecb14c5b.zip
Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'include/VBox/HostServices/VBoxOGLOp.h')
-rw-r--r--include/VBox/HostServices/VBoxOGLOp.h1901
1 files changed, 1901 insertions, 0 deletions
diff --git a/include/VBox/HostServices/VBoxOGLOp.h b/include/VBox/HostServices/VBoxOGLOp.h
new file mode 100644
index 00000000..1413f238
--- /dev/null
+++ b/include/VBox/HostServices/VBoxOGLOp.h
@@ -0,0 +1,1901 @@
+/** @file
+ * VirtualBox OpenGL command pack/unpack header
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef VBOX_INCLUDED_HostServices_VBoxOGLOp_h
+#define VBOX_INCLUDED_HostServices_VBoxOGLOp_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/types.h>
+
+#ifdef VBOX_OGL_GUEST_SIDE
+/************************************************************************************************************
+ * Guest side macro's for packing OpenGL function calls into the command buffer. *
+ * *
+ ************************************************************************************************************/
+
+#define VBOX_OGL_NAME_PREFIX(Function) gl##Function
+
+#define OGL_CMD(op, numpar, size) \
+ VBoxCmdStart(VBOX_OGL_OP_##op, numpar, size);
+
+#define OGL_PARAM(val, size) \
+ VBoxCmdSaveParameter((uint8_t *)&val, size);
+
+#define OGL_MEMPARAM(ptr, size) \
+ VBoxCmdSaveMemParameter((uint8_t *)ptr, size);
+
+#define OGL_CMD_END(op) \
+ VBoxCmdStop(VBOX_OGL_OP_##op);
+
+
+#define VBOX_OGL_GEN_OP(op) \
+ OGL_CMD(op, 0, 0); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP1(op, p1) \
+ OGL_CMD(op, 1, sizeof(p1)); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP2(op, p1, p2) \
+ OGL_CMD(op, 2, sizeof(p1)+sizeof(p2)); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP3(op, p1, p2, p3) \
+ OGL_CMD(op, 3, sizeof(p1)+sizeof(p2)+sizeof(p3)); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP4(op, p1, p2, p3, p4) \
+ OGL_CMD(op, 4, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP5(op, p1, p2, p3, p4, p5) \
+ OGL_CMD(op, 5, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP6(op, p1, p2, p3, p4, p5, p6) \
+ OGL_CMD(op, 6, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_PARAM(p6, sizeof(p6)); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP7(op, p1, p2, p3, p4, p5, p6, p7) \
+ OGL_CMD(op, 7, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_PARAM(p6, sizeof(p6)); \
+ OGL_PARAM(p7, sizeof(p7)); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP8(op, p1, p2, p3, p4, p5, p6, p7, p8) \
+ OGL_CMD(op, 8, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)+sizeof(p8)); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_PARAM(p6, sizeof(p6)); \
+ OGL_PARAM(p7, sizeof(p7)); \
+ OGL_PARAM(p8, sizeof(p8)); \
+ OGL_CMD_END(op);
+
+
+/* last parameter is a memory block */
+#define VBOX_OGL_GEN_OP1PTR(op, size, p1ptr) \
+ OGL_CMD(op, 1, size); \
+ OGL_MEMPARAM(p1ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP2PTR(op, p1, size, p2ptr) \
+ OGL_CMD(op, 2, sizeof(p1)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_MEMPARAM(p2ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP3PTR(op, p1, p2, size, p3ptr) \
+ OGL_CMD(op, 3, sizeof(p1)+sizeof(p2)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_MEMPARAM(p3ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP4PTR(op, p1, p2, p3, size, p4ptr) \
+ OGL_CMD(op, 4, sizeof(p1)+sizeof(p2)+sizeof(p3)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_MEMPARAM(p4ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP5PTR(op, p1, p2, p3, p4, size, p5ptr) \
+ OGL_CMD(op, 5, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_MEMPARAM(p5ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP6PTR(op, p1, p2, p3, p4, p5, size, p6ptr) \
+ OGL_CMD(op, 6, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_MEMPARAM(p6ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP7PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
+ OGL_CMD(op, 7, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_PARAM(p6, sizeof(p6)); \
+ OGL_MEMPARAM(p7ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP8PTR(op, p1, p2, p3, p4, p5, p6, p7, size, p8ptr) \
+ OGL_CMD(op, 8, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_PARAM(p6, sizeof(p6)); \
+ OGL_PARAM(p7, sizeof(p7)); \
+ OGL_MEMPARAM(p8ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP9PTR(op, p1, p2, p3, p4, p5, p6, p7, p8, size, p9ptr) \
+ OGL_CMD(op, 9, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)+sizeof(p8)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_PARAM(p6, sizeof(p6)); \
+ OGL_PARAM(p7, sizeof(p7)); \
+ OGL_PARAM(p8, sizeof(p8)); \
+ OGL_MEMPARAM(p9ptr, size); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP10PTR(op, p1, p2, p3, p4, p5, p6, p7, p8, p9, size, p10ptr) \
+ OGL_CMD(op, 10, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)+sizeof(p8)+sizeof(p9)+size); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_PARAM(p2, sizeof(p2)); \
+ OGL_PARAM(p3, sizeof(p3)); \
+ OGL_PARAM(p4, sizeof(p4)); \
+ OGL_PARAM(p5, sizeof(p5)); \
+ OGL_PARAM(p6, sizeof(p6)); \
+ OGL_PARAM(p7, sizeof(p7)); \
+ OGL_PARAM(p8, sizeof(p8)); \
+ OGL_PARAM(p9, sizeof(p9)); \
+ OGL_MEMPARAM(p10ptr, size); \
+ OGL_CMD_END(op);
+
+
+/* two memory blocks */
+#define VBOX_OGL_GEN_OP2PTRPTR(op, size1, p1ptr, size2, p2ptr) \
+ OGL_CMD(op, 2, size1+size2); \
+ OGL_MEMPARAM(p1ptr, size1); \
+ OGL_MEMPARAM(p2ptr, size2); \
+ OGL_CMD_END(op);
+
+#define VBOX_OGL_GEN_OP3PTRPTR(op, p1, size2, p2ptr, size3, p3ptr) \
+ OGL_CMD(op, 3, sizeof(p1)+size2+size3); \
+ OGL_PARAM(p1, sizeof(p1)); \
+ OGL_MEMPARAM(p2ptr, size2); \
+ OGL_MEMPARAM(p3ptr, size3); \
+ OGL_CMD_END(op);
+
+/* Note: sync operations always set the last error */
+/* sync operation that returns a value */
+#define VBOX_OGL_GEN_SYNC_OP_RET(rettype, op) \
+ VBOX_OGL_GEN_OP(op) \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP1_RET(rettype, op, p1) \
+ VBOX_OGL_GEN_OP1(op, p1) \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP2_RET(rettype, op, p1, p2) \
+ VBOX_OGL_GEN_OP2(op, p1, p2) \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP3_RET(rettype, op, p1, p2, p3) \
+ VBOX_OGL_GEN_OP3(op, p1, p2, p3) \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP4_RET(rettype, op, p1, p2, p3, p4) \
+ VBOX_OGL_GEN_OP4(op, p1, p2, p3, p4) \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP5_RET(rettype, op, p1, p2, p3, p4, p5) \
+ VBOX_OGL_GEN_OP5(op, p1, p2, p3, p4, p5) \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP6_RET(rettype, op, p1, p2, p3, p4, p5, p6) \
+ VBOX_OGL_GEN_OP6(op, p1, p2, p3, p4, p5, p6) \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP7_RET(rettype, op, p1, p2, p3, p4, p5, p6, p7) \
+ VBOX_OGL_GEN_OP7(op, p1, p2, p3, p4, p5, p6, p7) \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+
+#define VBOX_OGL_GEN_SYNC_OP(op) \
+ VBOX_OGL_GEN_OP(op) \
+ VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP1(op, p1) \
+ VBOX_OGL_GEN_OP1(op, p1) \
+ VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP2(op, p1, p2) \
+ VBOX_OGL_GEN_OP2(op, p1, p2) \
+ VBoxOGLFlush();
+
+
+/* Sync operation whose last parameter is a block of memory */
+#define VBOX_OGL_GEN_SYNC_OP2_PTR(op, p1, size, p2ptr) \
+ VBOX_OGL_GEN_OP2PTR(op, p1, size, p2ptr); \
+ VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP5_PTR(op, p1, p2, p3, p4, size, p5ptr) \
+ VBOX_OGL_GEN_OP2PTR(op, p1, p2, p3, p4, size, p5ptr); \
+ VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP6_PTR(op, p1, p2, p3, p4, p5, size, p6ptr) \
+ VBOX_OGL_GEN_OP6PTR(op, p1, p2, p3, p4, p5, size, p6ptr); \
+ VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP7_PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
+ VBOX_OGL_GEN_OP7PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr); \
+ VBoxOGLFlush();
+
+/* Sync operation whose last parameter is a block of memory in which results are returned */
+#define VBOX_OGL_GEN_SYNC_OP1_PASS_PTR(op, size, p1ptr) \
+ VBOX_OGL_GEN_OP(op); \
+ VBoxOGLFlushPtr(p1ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP2_PASS_PTR(op, p1, size, p2ptr) \
+ VBOX_OGL_GEN_OP1(op, p1); \
+ VBoxOGLFlushPtr(p2ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP3_PASS_PTR(op, p1, p2, size, p3ptr) \
+ VBOX_OGL_GEN_OP2(op, p1, p2); \
+ VBoxOGLFlushPtr(p3ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP4_PASS_PTR(op, p1, p2, p3, size, p4ptr) \
+ VBOX_OGL_GEN_OP3(op, p1, p2, p3); \
+ VBoxOGLFlushPtr(p4ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP5_PASS_PTR(op, p1, p2, p3, p4, size, p5ptr) \
+ VBOX_OGL_GEN_OP4(op, p1, p2, p3, p4); \
+ VBoxOGLFlushPtr(p5ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP6_PASS_PTR(op, p1, p2, p3, p4, p5, size, p6ptr) \
+ VBOX_OGL_GEN_OP5(op, p1, p2, p3, p4, p5); \
+ VBoxOGLFlushPtr(p6ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP7_PASS_PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
+ VBOX_OGL_GEN_OP6(op, p1, p2, p3, p4, p5, p6); \
+ VBoxOGLFlushPtr(p7ptr, size);
+
+
+/* Sync operation whose last parameter is a block of memory and return a value */
+#define VBOX_OGL_GEN_SYNC_OP2_PTR_RET(rettype, op, p1, size, p2ptr) \
+ VBOX_OGL_GEN_OP2PTR(op, p1, size, p2ptr); \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP4_PTR_RET(rettype, op, p1, p2, p3, size, p4ptr) \
+ VBOX_OGL_GEN_OP4PTR(op, p1, p2, p3, size, p4ptr); \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP5_PTR_RET(rettype, op, p1, p2, p3, p4, size, p5ptr) \
+ VBOX_OGL_GEN_OP5PTR(op, p1, p2, p3, p4, size, p5ptr); \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP6_PTR_RET(rettype, op, p1, p2, p3, p4, p5, size, p6ptr) \
+ VBOX_OGL_GEN_OP6PTR(op, p1, p2, p3, p4, p5, size, p6ptr); \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+#define VBOX_OGL_GEN_SYNC_OP7_PTR_RET(rettype, op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
+ VBOX_OGL_GEN_OP7PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr); \
+ rettype retval = (rettype)VBoxOGLFlush();
+
+
+/* Sync operation whose last parameter is a block of memory in which results are returned and return a value */
+#define VBOX_OGL_GEN_SYNC_OP2_PASS_PTR_RET(rettype, op, p1, size, p2ptr) \
+ VBOX_OGL_GEN_OP1(op, p1); \
+ rettype retval = (rettype)VBoxOGLFlushPtr(p2ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP4_PASS_PTR_RET(rettype, op, p1, p2, p3, size, p4ptr) \
+ VBOX_OGL_GEN_OP3(op, p1, p2, p3); \
+ rettype retval = (rettype)VBoxOGLFlushPtr(p4ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP5_PASS_PTR_RET(rettype, op, p1, p2, p3, p4, size, p5ptr) \
+ VBOX_OGL_GEN_OP4(op, p1, p2, p3, p4); \
+ rettype retval = (rettype)VBoxOGLFlushPtr(p5ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP6_PASS_PTR_RET(rettype, op, p1, p2, p3, p4, p5, size, p6ptr) \
+ VBOX_OGL_GEN_OP5(op, p1, p2, p3, p4, p5); \
+ rettype retval = (rettype)VBoxOGLFlushPtr(p6ptr, size);
+
+#define VBOX_OGL_GEN_SYNC_OP7_PASS_PTR_RET(rettype, op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
+ VBOX_OGL_GEN_OP6(op, p1, p2, p3, p4, p5, p6); \
+ rettype retval = (rettype)VBoxOGLFlushPtr(p7ptr, size);
+
+
+/* Generate async functions elements in the command queue */
+#define GL_GEN_FUNC(Function) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (void) \
+ { \
+ VBOX_OGL_GEN_OP(Function); \
+ }
+
+#define GL_GEN_FUNC1(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a) \
+ { \
+ VBOX_OGL_GEN_OP1(Function, a); \
+ }
+
+#define GL_GEN_FUNC1V(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a) \
+ { \
+ VBOX_OGL_GEN_OP1(Function, a); \
+ } \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (const Type *v) \
+ { \
+ VBOX_OGL_GEN_OP1(Function, v[0]); \
+ } \
+
+#define GL_GEN_FUNC2(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b) \
+ { \
+ VBOX_OGL_GEN_OP2(Function, a, b); \
+ }
+
+#define GL_GEN_FUNC2V(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b) \
+ { \
+ VBOX_OGL_GEN_OP2(Function, a, b); \
+ } \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (const Type *v) \
+ { \
+ VBOX_OGL_GEN_OP2(Function, v[0], v[1]); \
+ } \
+
+#define GL_GEN_FUNC3(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, a, b, c); \
+ }
+
+#define GL_GEN_FUNC3V(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, a, b, c); \
+ } \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (const Type *v) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, v[0], v[1], v[2]); \
+ } \
+
+#define GL_GEN_FUNC4(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c, Type d) \
+ { \
+ VBOX_OGL_GEN_OP4(Function, a, b, c, d); \
+ }
+
+#define GL_GEN_FUNC4V(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c, Type d) \
+ { \
+ VBOX_OGL_GEN_OP4(Function, a, b, c, d); \
+ } \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (const Type *v) \
+ { \
+ VBOX_OGL_GEN_OP4(Function, v[0], v[1], v[2], v[3]); \
+ } \
+
+#define GL_GEN_FUNC6(Function, Type) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c, Type d, Type e, Type f) \
+ { \
+ VBOX_OGL_GEN_OP6(Function, a, b, c, d, e, f); \
+ }
+
+#define GL_GEN_VPAR_FUNC2(Function, Type1, Type2) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b) \
+ { \
+ VBOX_OGL_GEN_OP2(Function, a, b); \
+ }
+
+#define GL_GEN_VPAR_FUNC2V(Function, Type1, Type2) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b) \
+ { \
+ VBOX_OGL_GEN_OP2(Function, a, b); \
+ } \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (Type1 a, const Type2 *v) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, a, v[0], v[1]); \
+ } \
+
+#define GL_GEN_VPAR_FUNC3(Function, Type1, Type2, Type3) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, a, b, c); \
+ }
+
+#define GL_GEN_VPAR_FUNC3V(Function, Type1, Type2, Type3) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, a, b, c); \
+ } \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (Type1 a, Type2 b, const Type3 *v) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, a, v[0], v[1]); \
+ } \
+
+#define GL_GEN_VPAR_FUNC4(Function, Type1, Type2, Type3, Type4) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d) \
+ { \
+ VBOX_OGL_GEN_OP4(Function, a, b, c, d); \
+ }
+
+#define GL_GEN_VPAR_FUNC5(Function, Type1, Type2, Type3, Type4, Type5) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e) \
+ { \
+ VBOX_OGL_GEN_OP5(Function, a, b, c, d, e); \
+ }
+
+#define GL_GEN_VPAR_FUNC6(Function, Type1, Type2, Type3, Type4, Type5, Type6) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e, Type6 f) \
+ { \
+ VBOX_OGL_GEN_OP6(Function, a, b, c, d, e, f); \
+ }
+
+#define GL_GEN_VPAR_FUNC7(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e, Type6 f, Type7 g) \
+ { \
+ VBOX_OGL_GEN_OP7(Function, a, b, c, d, e, f, g); \
+ }
+
+#define GL_GEN_VPAR_FUNC8(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e, Type6 f, Type7 g, Type8 h) \
+ { \
+ VBOX_OGL_GEN_OP8(Function, a, b, c, d, e, f, g, h); \
+ }
+
+#define GL_GEN_VPAR_FUNC9(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8 ,Type9) \
+ void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e, Type6 f, Type7 g, Type8 h, Type9 i) \
+ { \
+ VBOX_OGL_GEN_OP9(Function, a, b, c, d, e, f, g, h, i); \
+ }
+
+#elif defined(VBOX_OGL_HOST_SIDE)
+
+/************************************************************************************************************
+ * Host side macro's for generating OpenGL function calls from the packed commands in the command buffer. *
+ * *
+ ************************************************************************************************************/
+
+#include <iprt/assert.h>
+
+#define VBOX_OGL_NAME_PREFIX(Function) vboxgl##Function
+
+#ifdef VBOX_OGL_CMD_STRICT
+#define VBOX_OGL_CHECK_MAGIC(pParVal) Assert(pParVal->Magic == VBOX_OGL_CMD_MAGIC)
+#else
+#define VBOX_OGL_CHECK_MAGIC(pParVal)
+#endif
+
+#define OGL_CMD(op, numpar) \
+ PVBOX_OGL_CMD pCmd = (PVBOX_OGL_CMD)pCmdBuffer; \
+ Assert(pCmd->enmOp == VBOX_OGL_OP_##op); \
+ Assert(pCmd->cParams == numpar); \
+ uint8_t *pParam = (uint8_t *)(pCmd+1); \
+ NOREF(pParam)
+
+#define OGL_PARAM(Type, par) \
+ Type par; \
+ par = *(Type *)pParam; \
+ pParam += sizeof(par); \
+ pParam = RT_ALIGN_PT(pParam, VBOX_OGL_CMD_ALIGN, uint8_t *);
+
+#define OGL_MEMPARAM(Type, par) \
+ PVBOX_OGL_VAR_PARAM pParVal = (PVBOX_OGL_VAR_PARAM)pParam; \
+ Type *par; \
+ VBOX_OGL_CHECK_MAGIC(pParVal); \
+ if (pParVal->cbParam) \
+ par = (Type *)(pParVal+1); \
+ else \
+ par = NULL; \
+ pParam += sizeof(*pParVal) + pParVal->cbParam; \
+ pParam = RT_ALIGN_PT(pParam, VBOX_OGL_CMD_ALIGN, uint8_t *);
+
+#define OGL_MEMPARAM_NODEF(Type, par) \
+ pParVal = (PVBOX_OGL_VAR_PARAM)pParam; \
+ Type *par; \
+ VBOX_OGL_CHECK_MAGIC(pParVal); \
+ if (pParVal->cbParam) \
+ par = (Type *)(pParVal+1); \
+ else \
+ par = NULL; \
+ pParam += sizeof(*pParVal) + pParVal->cbParam; \
+ pParam = RT_ALIGN_PT(pParam, VBOX_OGL_CMD_ALIGN, uint8_t *);
+
+#define VBOX_OGL_GEN_OP(op) \
+ OGL_CMD(op, 0); \
+ gl##op();
+
+#define VBOX_OGL_GEN_OP1(op, Type1) \
+ OGL_CMD(op, 1); \
+ OGL_PARAM(Type1, p1); \
+ gl##op(p1);
+
+#define VBOX_OGL_GEN_OP2(op, Type1, Type2) \
+ OGL_CMD(op, 2); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ gl##op(p1, p2);
+
+#define VBOX_OGL_GEN_OP3(op, Type1, Type2, Type3) \
+ OGL_CMD(op, 3); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ gl##op(p1, p2, p3);
+
+#define VBOX_OGL_GEN_OP4(op, Type1, Type2, Type3, Type4) \
+ OGL_CMD(op, 4); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ gl##op(p1, p2, p3, p4);
+
+#define VBOX_OGL_GEN_OP5(op, Type1, Type2, Type3, Type4, Type5) \
+ OGL_CMD(op, 5); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ gl##op(p1, p2, p3, p4, p5);
+
+#define VBOX_OGL_GEN_OP6(op, Type1, Type2, Type3, Type4, Type5, Type6) \
+ OGL_CMD(op, 6); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ gl##op(p1, p2, p3, p4, p5, p6);
+
+#define VBOX_OGL_GEN_OP7(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
+ OGL_CMD(op, 7); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ OGL_PARAM(Type7, p7); \
+ gl##op(p1, p2, p3, p4, p5, p6, p7);
+
+#define VBOX_OGL_GEN_OP8(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8) \
+ OGL_CMD(op, 8); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ OGL_PARAM(Type7, p7); \
+ OGL_PARAM(Type8, p8); \
+ gl##op(p1, p2, p3, p4, p5, p6, p7, p8);
+
+
+/* last parameter is a memory block */
+#define VBOX_OGL_GEN_OP1PTR(op, Type1) \
+ OGL_CMD(op, 1); \
+ OGL_MEMPARAM(Type1, p1); \
+ gl##op(p1);
+
+#define VBOX_OGL_GEN_OP2PTR(op, Type1, Type2) \
+ OGL_CMD(op, 2); \
+ OGL_PARAM(Type1, p1); \
+ OGL_MEMPARAM(Type2, p2); \
+ gl##op(p1, p2);
+
+#define VBOX_OGL_GEN_OP3PTR(op, Type1, Type2, Type3) \
+ OGL_CMD(op, 3); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_MEMPARAM(Type3, p3); \
+ gl##op(p1, p2, p3);
+
+#define VBOX_OGL_GEN_OP4PTR(op, Type1, Type2, Type3, Type4) \
+ OGL_CMD(op, 4); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_MEMPARAM(Type4, p4); \
+ gl##op(p1, p2, p3, p4);
+
+#define VBOX_OGL_GEN_OP5PTR(op, Type1, Type2, Type3, Type4, Type5) \
+ OGL_CMD(op, 5); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_MEMPARAM(Type5, p5); \
+ gl##op(p1, p2, p3, p4, p5);
+
+#define VBOX_OGL_GEN_OP6PTR(op, Type1, Type2, Type3, Type4, Type5, Type6) \
+ OGL_CMD(op, 6); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_MEMPARAM(Type6, p6); \
+ gl##op(p1, p2, p3, p4, p5, p6);
+
+#define VBOX_OGL_GEN_OP7PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
+ OGL_CMD(op, 7); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ OGL_MEMPARAM(Type7, p7); \
+ gl##op(p1, p2, p3, p4, p5, p6, p7);
+
+#define VBOX_OGL_GEN_OP8PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8) \
+ OGL_CMD(op, 8); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ OGL_PARAM(Type7, p7); \
+ OGL_MEMPARAM(Type8, p8); \
+ gl##op(p1, p2, p3, p4, p5, p6, p7, p8);
+
+#define VBOX_OGL_GEN_OP9PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9) \
+ OGL_CMD(op, 9); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ OGL_PARAM(Type7, p7); \
+ OGL_PARAM(Type8, p8); \
+ OGL_MEMPARAM(Type9, p9); \
+ gl##op(p1, p2, p3, p4, p5, p6, p7, p8 ,p9);
+
+#define VBOX_OGL_GEN_OP10PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10) \
+ OGL_CMD(op, 10); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ OGL_PARAM(Type7, p7); \
+ OGL_PARAM(Type8, p8); \
+ OGL_PARAM(Type9, p9); \
+ OGL_MEMPARAM(Type10, p10); \
+ gl##op(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+
+
+/* two memory blocks */
+#define VBOX_OGL_GEN_OP2PTRPTR(op, Type1, Type2) \
+ OGL_CMD(op, 2); \
+ OGL_MEMPARAM(Type1, p1); \
+ OGL_MEMPARAM_NODEF(Type2, p2); \
+ gl##op(p1, p2);
+
+#define VBOX_OGL_GEN_OP3PTRPTR(op, Type1, Type2, Type3) \
+ OGL_CMD(op, 3); \
+ OGL_PARAM(Type1, p1); \
+ OGL_MEMPARAM(Type2, p2); \
+ OGL_MEMPARAM_NODEF(Type3, p3); \
+ gl##op(p1, p2, p3);
+
+/* Note: sync operations always set the last error */
+/* sync operation that returns a value */
+#define VBOX_OGL_GEN_SYNC_OP_RET(rettype, op) \
+ OGL_CMD(op, 0); \
+ pClient->lastretval = gl##op();
+
+#define VBOX_OGL_GEN_SYNC_OP1_RET(rettype, op, Type1) \
+ OGL_CMD(op, 1); \
+ OGL_PARAM(Type1, p1); \
+ pClient->lastretval = gl##op(p1);
+
+#define VBOX_OGL_GEN_SYNC_OP2_RET(rettype, op, Type1, Type2) \
+ OGL_CMD(op, 2); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ pClient->lastretval = gl##op(p1, p2);
+
+#define VBOX_OGL_GEN_SYNC_OP3_RET(rettype, op, Type1, Type2, Type3) \
+ OGL_CMD(op, 3); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_MEMPARAM(Type3, p3); \
+ pClient->lastretval = gl##op(p1, p2, p3);
+
+#define VBOX_OGL_GEN_SYNC_OP(op) \
+ VBOX_OGL_GEN_OP(op);
+
+#define VBOX_OGL_GEN_SYNC_OP1(op, p1) \
+ VBOX_OGL_GEN_OP1(op, p1);
+
+#define VBOX_OGL_GEN_SYNC_OP2(op, p1, p2) \
+ VBOX_OGL_GEN_OP2(op, p1, p2);
+
+
+/* Sync operation whose last parameter is a block of memory */
+#define VBOX_OGL_GEN_SYNC_OP2_PTR(op, p1, p2ptr) \
+ VBOX_OGL_GEN_OP2PTR(op, p1, p2ptr);
+
+#define VBOX_OGL_GEN_SYNC_OP5_PTR(op, p1, p2, p3, p4, p5ptr) \
+ VBOX_OGL_GEN_OP2PTR(op, p1, p2, p3, p4, size, p5ptr);
+
+#define VBOX_OGL_GEN_SYNC_OP6_PTR(op, p1, p2, p3, p4, p5, p6ptr) \
+ VBOX_OGL_GEN_OP6PTR(op, p1, p2, p3, p4, p5, size, p6ptr);
+
+#define VBOX_OGL_GEN_SYNC_OP7_PTR(op, p1, p2, p3, p4, p5, p6, p7ptr) \
+ VBOX_OGL_GEN_OP7PTR(op, p1, p2, p3, p4, p5, p6, p7ptr);
+
+
+/* Sync operation whose last parameter is a block of memory in which results are returned */
+#define VBOX_OGL_GEN_SYNC_OP1_PASS_PTR(op, Type1) \
+ OGL_CMD(op, 0); \
+ Assert(pClient->pLastParam && pClient->cbLastParam); \
+ gl##op((Type1 *)pClient->pLastParam);
+
+#define VBOX_OGL_GEN_SYNC_OP2_PASS_PTR(op, Type1, Type2) \
+ OGL_CMD(op, 1); \
+ OGL_PARAM(Type1, p1); \
+ Assert(pClient->pLastParam && pClient->cbLastParam); \
+ gl##op(p1, (Type2 *)pClient->pLastParam);
+
+#define VBOX_OGL_GEN_SYNC_OP3_PASS_PTR(op, Type1, Type2, Type3) \
+ OGL_CMD(op, 2); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ Assert(pClient->pLastParam && pClient->cbLastParam); \
+ gl##op(p1, p2, (Type3 *)pClient->pLastParam);
+
+#define VBOX_OGL_GEN_SYNC_OP4_PASS_PTR(op, Type1, Type2, Type3, Type4) \
+ OGL_CMD(op, 3); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ Assert(pClient->pLastParam && pClient->cbLastParam); \
+ gl##op(p1, p2, p3, (Type4 *)pClient->pLastParam);
+
+#define VBOX_OGL_GEN_SYNC_OP5_PASS_PTR(op, Type1, Type2, Type3, Type4, Type5) \
+ OGL_CMD(op, 4); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ Assert(pClient->pLastParam && pClient->cbLastParam); \
+ gl##op(p1, p2, p3, p4, (Type5 *)pClient->pLastParam);
+
+#define VBOX_OGL_GEN_SYNC_OP6_PASS_PTR(op, Type1, Type2, Type3, Type4, Type5, Type6) \
+ OGL_CMD(op, 5); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ Assert(pClient->pLastParam && pClient->cbLastParam); \
+ gl##op(p1, p2, p3, p4, p5, (Type6 *)pClient->pLastParam);
+
+#define VBOX_OGL_GEN_SYNC_OP7_PASS_PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
+ OGL_CMD(op, 6); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ Assert(pClient->pLastParam && pClient->cbLastParam); \
+ gl##op(p1, p2, p3, p4, p5, p6, (Type7 *)pClient->pLastParam);
+
+
+/* Sync operation whose last parameter is a block of memory and returns a value */
+#define VBOX_OGL_GEN_SYNC_OP2_PTR_RET(rettype, op, Type1, Type2) \
+ OGL_CMD(op, 2); \
+ OGL_PARAM(Type1, p1); \
+ OGL_MEMPARAM(Type2, p2); \
+ pClient->lastretval = gl##op(p1);
+
+#define VBOX_OGL_GEN_SYNC_OP4_PTR_RET(rettype, op, Type1, Type2, Type3, Type4) \
+ OGL_CMD(op, 4); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_MEMPARAM(Type4, p4); \
+ pClient->lastretval = gl##op(p1, p2, p3, p4);
+
+#define VBOX_OGL_GEN_SYNC_OP5_PTR_RET(rettype, op, Type1, Type2, Type3, Type4, Type5) \
+ OGL_CMD(op, 5); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_MEMPARAM(Type5, p5); \
+ pClient->lastretval = gl##op(p1, p2, p3, p4, p5);
+
+#define VBOX_OGL_GEN_SYNC_OP6_PTR_RET(rettype, op, Type1, Type2, Type3, Type4, Type5, Type6) \
+ OGL_CMD(op, 6); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_MEMPARAM(Type6, p6); \
+ pClient->lastretval = gl##op(p1, p2, p3, p4, p5, p6);
+
+#define VBOX_OGL_GEN_SYNC_OP7_PTR_RET(rettype, op, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
+ OGL_CMD(op, 7); \
+ OGL_PARAM(Type1, p1); \
+ OGL_PARAM(Type2, p2); \
+ OGL_PARAM(Type3, p3); \
+ OGL_PARAM(Type4, p4); \
+ OGL_PARAM(Type5, p5); \
+ OGL_PARAM(Type6, p6); \
+ OGL_MEMPARAM(Type7, p7); \
+ pClient->lastretval = gl##op(p1, p2, p3, p4, p5, p6, p7);
+
+
+
+
+
+/* Generate async functions elements in the command queue */
+#define GL_GEN_FUNC(Function) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP(Function); \
+ }
+
+#define GL_GEN_FUNC1(Function, Type) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP1(Function, Type); \
+ }
+
+#define GL_GEN_FUNC1V(Function, Type) GL_GEN_FUNC1(Function, Type)
+
+#define GL_GEN_FUNC2(Function, Type) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP2(Function, Type, Type); \
+ }
+
+#define GL_GEN_FUNC2V(Function, Type) GL_GEN_FUNC2(Function, Type)
+
+#define GL_GEN_FUNC3(Function, Type) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, Type, Type, Type); \
+ }
+
+#define GL_GEN_FUNC3V(Function, Type) GL_GEN_FUNC3(Function, Type)
+
+#define GL_GEN_FUNC4(Function, Type) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP4(Function, Type, Type, Type, Type); \
+ }
+
+#define GL_GEN_FUNC4V(Function, Type) GL_GEN_FUNC4(Function, Type)
+
+#define GL_GEN_FUNC6(Function, Type) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP6(Function, Type, Type, Type, Type, Type, Type); \
+ }
+
+#define GL_GEN_VPAR_FUNC2(Function, Type1, Type2) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP2(Function, Type1, Type2); \
+ }
+
+#define GL_GEN_VPAR_FUNC2V(Function, Type) GL_GEN_VPAR_FUNC2(Function, Type)
+
+#define GL_GEN_VPAR_FUNC3(Function, Type1, Type2, Type3) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP3(Function, Type1, Type2, Type3); \
+ }
+
+#define GL_GEN_VPAR_FUNC3V(Function, Type) GL_GEN_VPAR_FUNC3(Function, Type)
+
+#define GL_GEN_VPAR_FUNC4(Function, Type1, Type2, Type3, Type4) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP4(Function, Type1, Type2, Type3, Type4); \
+ }
+
+#define GL_GEN_VPAR_FUNC5(Function, Type1, Type2, Type3, Type4, Type5) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP5(Function, Type1, Type2, Type3, Type4 ,Type5); \
+ }
+
+#define GL_GEN_VPAR_FUNC6(Function, Type1, Type2, Type3, Type4, Type5, Type6) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP6(Function, Type1, Type2, Type3, Type4 ,Type5, Type6); \
+ }
+
+#define GL_GEN_VPAR_FUNC7(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP7(Function, Type1, Type2, Type3, Type4 ,Type5, Type6, Type7); \
+ }
+
+#define GL_GEN_VPAR_FUNC8(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP8(Function, Type1, Type2, Type3, Type4 ,Type5, Type6, Type7, Type8); \
+ }
+
+#define GL_GEN_VPAR_FUNC9(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8 ,Type9) \
+ void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) \
+ { \
+ VBOX_OGL_GEN_OP9(Function, Type1, Type2, Type3, Type4 ,Type5, Type6, Type7, Type8, Type9); \
+ }
+
+#endif /* VBOX_OGL_HOST_SIDE */
+
+
+
+
+/* OpenGL opcodes */
+/* Note: keep all three tables in sync! */
+typedef enum
+{
+ VBOX_OGL_OP_Illegal = 0,
+ VBOX_OGL_OP_ArrayElement,
+ VBOX_OGL_OP_Begin,
+ VBOX_OGL_OP_BindTexture,
+ VBOX_OGL_OP_BlendFunc,
+ VBOX_OGL_OP_CallList,
+ VBOX_OGL_OP_Color3b,
+ VBOX_OGL_OP_Color3d,
+ VBOX_OGL_OP_Color3f,
+ VBOX_OGL_OP_Color3i,
+ VBOX_OGL_OP_Color3s,
+ VBOX_OGL_OP_Color3ub,
+ VBOX_OGL_OP_Color3ui,
+ VBOX_OGL_OP_Color3us,
+ VBOX_OGL_OP_Color4b,
+ VBOX_OGL_OP_Color4d,
+ VBOX_OGL_OP_Color4f,
+ VBOX_OGL_OP_Color4i,
+ VBOX_OGL_OP_Color4s,
+ VBOX_OGL_OP_Color4ub,
+ VBOX_OGL_OP_Color4ui,
+ VBOX_OGL_OP_Color4us,
+ VBOX_OGL_OP_Clear,
+ VBOX_OGL_OP_ClearAccum,
+ VBOX_OGL_OP_ClearColor,
+ VBOX_OGL_OP_ClearDepth,
+ VBOX_OGL_OP_ClearIndex,
+ VBOX_OGL_OP_ClearStencil,
+ VBOX_OGL_OP_Accum,
+ VBOX_OGL_OP_AlphaFunc,
+ VBOX_OGL_OP_Vertex2d,
+ VBOX_OGL_OP_Vertex2f,
+ VBOX_OGL_OP_Vertex2i,
+ VBOX_OGL_OP_Vertex2s,
+ VBOX_OGL_OP_Vertex3d,
+ VBOX_OGL_OP_Vertex3f,
+ VBOX_OGL_OP_Vertex3i,
+ VBOX_OGL_OP_Vertex3s,
+ VBOX_OGL_OP_Vertex4d,
+ VBOX_OGL_OP_Vertex4f,
+ VBOX_OGL_OP_Vertex4i,
+ VBOX_OGL_OP_Vertex4s,
+ VBOX_OGL_OP_TexCoord1d,
+ VBOX_OGL_OP_TexCoord1f,
+ VBOX_OGL_OP_TexCoord1i,
+ VBOX_OGL_OP_TexCoord1s,
+ VBOX_OGL_OP_TexCoord2d,
+ VBOX_OGL_OP_TexCoord2f,
+ VBOX_OGL_OP_TexCoord2i,
+ VBOX_OGL_OP_TexCoord2s,
+ VBOX_OGL_OP_TexCoord3d,
+ VBOX_OGL_OP_TexCoord3f,
+ VBOX_OGL_OP_TexCoord3i,
+ VBOX_OGL_OP_TexCoord3s,
+ VBOX_OGL_OP_TexCoord4d,
+ VBOX_OGL_OP_TexCoord4f,
+ VBOX_OGL_OP_TexCoord4i,
+ VBOX_OGL_OP_TexCoord4s,
+ VBOX_OGL_OP_Normal3b,
+ VBOX_OGL_OP_Normal3d,
+ VBOX_OGL_OP_Normal3f,
+ VBOX_OGL_OP_Normal3i,
+ VBOX_OGL_OP_Normal3s,
+ VBOX_OGL_OP_RasterPos2d,
+ VBOX_OGL_OP_RasterPos2f,
+ VBOX_OGL_OP_RasterPos2i,
+ VBOX_OGL_OP_RasterPos2s,
+ VBOX_OGL_OP_RasterPos3d,
+ VBOX_OGL_OP_RasterPos3f,
+ VBOX_OGL_OP_RasterPos3i,
+ VBOX_OGL_OP_RasterPos3s,
+ VBOX_OGL_OP_RasterPos4d,
+ VBOX_OGL_OP_RasterPos4f,
+ VBOX_OGL_OP_RasterPos4i,
+ VBOX_OGL_OP_RasterPos4s,
+ VBOX_OGL_OP_EvalCoord1d,
+ VBOX_OGL_OP_EvalCoord1f,
+ VBOX_OGL_OP_EvalCoord2d,
+ VBOX_OGL_OP_EvalCoord2f,
+ VBOX_OGL_OP_EvalPoint1,
+ VBOX_OGL_OP_EvalPoint2,
+ VBOX_OGL_OP_Indexd,
+ VBOX_OGL_OP_Indexf,
+ VBOX_OGL_OP_Indexi,
+ VBOX_OGL_OP_Indexs,
+ VBOX_OGL_OP_Indexub,
+ VBOX_OGL_OP_Rotated,
+ VBOX_OGL_OP_Rotatef,
+ VBOX_OGL_OP_Scaled,
+ VBOX_OGL_OP_Scalef,
+ VBOX_OGL_OP_Translated,
+ VBOX_OGL_OP_Translatef,
+ VBOX_OGL_OP_DepthFunc,
+ VBOX_OGL_OP_DepthMask,
+ VBOX_OGL_OP_Finish,
+ VBOX_OGL_OP_Flush,
+ VBOX_OGL_OP_DeleteLists,
+ VBOX_OGL_OP_CullFace,
+ VBOX_OGL_OP_DeleteTextures,
+ VBOX_OGL_OP_DepthRange,
+ VBOX_OGL_OP_DisableClientState,
+ VBOX_OGL_OP_EnableClientState,
+ VBOX_OGL_OP_EvalMesh1,
+ VBOX_OGL_OP_EvalMesh2,
+ VBOX_OGL_OP_Fogf,
+ VBOX_OGL_OP_Fogfv,
+ VBOX_OGL_OP_Fogi,
+ VBOX_OGL_OP_Fogiv,
+ VBOX_OGL_OP_LightModelf,
+ VBOX_OGL_OP_LightModelfv,
+ VBOX_OGL_OP_LightModeli,
+ VBOX_OGL_OP_LightModeliv,
+ VBOX_OGL_OP_Lightf,
+ VBOX_OGL_OP_Lightfv,
+ VBOX_OGL_OP_Lighti,
+ VBOX_OGL_OP_Lightiv,
+ VBOX_OGL_OP_LineStipple,
+ VBOX_OGL_OP_LineWidth,
+ VBOX_OGL_OP_ListBase,
+ VBOX_OGL_OP_DrawArrays,
+ VBOX_OGL_OP_DrawBuffer,
+ VBOX_OGL_OP_EdgeFlag,
+ VBOX_OGL_OP_End,
+ VBOX_OGL_OP_EndList,
+ VBOX_OGL_OP_CopyTexImage1D,
+ VBOX_OGL_OP_CopyTexImage2D,
+ VBOX_OGL_OP_ColorMaterial,
+ VBOX_OGL_OP_Materiali,
+ VBOX_OGL_OP_Materialf,
+ VBOX_OGL_OP_Materialfv,
+ VBOX_OGL_OP_Materialiv,
+ VBOX_OGL_OP_PopAttrib,
+ VBOX_OGL_OP_PopClientAttrib,
+ VBOX_OGL_OP_PopMatrix,
+ VBOX_OGL_OP_PopName,
+ VBOX_OGL_OP_PushAttrib,
+ VBOX_OGL_OP_PushClientAttrib,
+ VBOX_OGL_OP_PushMatrix,
+ VBOX_OGL_OP_PushName,
+ VBOX_OGL_OP_ReadBuffer,
+ VBOX_OGL_OP_TexGendv,
+ VBOX_OGL_OP_TexGenf,
+ VBOX_OGL_OP_TexGend,
+ VBOX_OGL_OP_TexGeni,
+ VBOX_OGL_OP_TexEnvi,
+ VBOX_OGL_OP_TexEnvf,
+ VBOX_OGL_OP_TexEnviv,
+ VBOX_OGL_OP_TexEnvfv,
+ VBOX_OGL_OP_TexGeniv,
+ VBOX_OGL_OP_TexGenfv,
+ VBOX_OGL_OP_TexParameterf,
+ VBOX_OGL_OP_TexParameteri,
+ VBOX_OGL_OP_TexParameterfv,
+ VBOX_OGL_OP_TexParameteriv,
+ VBOX_OGL_OP_LoadIdentity,
+ VBOX_OGL_OP_LoadName,
+ VBOX_OGL_OP_LoadMatrixd,
+ VBOX_OGL_OP_LoadMatrixf,
+ VBOX_OGL_OP_StencilFunc,
+ VBOX_OGL_OP_ShadeModel,
+ VBOX_OGL_OP_StencilMask,
+ VBOX_OGL_OP_StencilOp,
+ VBOX_OGL_OP_Scissor,
+ VBOX_OGL_OP_Viewport,
+ VBOX_OGL_OP_Rectd,
+ VBOX_OGL_OP_Rectf,
+ VBOX_OGL_OP_Recti,
+ VBOX_OGL_OP_Rects,
+ VBOX_OGL_OP_Rectdv,
+ VBOX_OGL_OP_Rectfv,
+ VBOX_OGL_OP_Rectiv,
+ VBOX_OGL_OP_Rectsv,
+ VBOX_OGL_OP_MultMatrixd,
+ VBOX_OGL_OP_MultMatrixf,
+ VBOX_OGL_OP_NewList,
+ VBOX_OGL_OP_Hint,
+ VBOX_OGL_OP_IndexMask,
+ VBOX_OGL_OP_InitNames,
+ VBOX_OGL_OP_TexCoordPointer,
+ VBOX_OGL_OP_VertexPointer,
+ VBOX_OGL_OP_ColorPointer,
+ VBOX_OGL_OP_EdgeFlagPointer,
+ VBOX_OGL_OP_IndexPointer,
+ VBOX_OGL_OP_NormalPointer,
+ VBOX_OGL_OP_PolygonStipple,
+ VBOX_OGL_OP_CallLists,
+ VBOX_OGL_OP_ClipPlane,
+ VBOX_OGL_OP_Frustum,
+ VBOX_OGL_OP_GenTextures,
+ VBOX_OGL_OP_Map1d,
+ VBOX_OGL_OP_Map1f,
+ VBOX_OGL_OP_Map2d,
+ VBOX_OGL_OP_Map2f,
+ VBOX_OGL_OP_MapGrid1d,
+ VBOX_OGL_OP_MapGrid1f,
+ VBOX_OGL_OP_MapGrid2d,
+ VBOX_OGL_OP_MapGrid2f,
+ VBOX_OGL_OP_CopyPixels,
+ VBOX_OGL_OP_TexImage1D,
+ VBOX_OGL_OP_TexImage2D,
+ VBOX_OGL_OP_TexSubImage1D,
+ VBOX_OGL_OP_TexSubImage2D,
+ VBOX_OGL_OP_FeedbackBuffer,
+ VBOX_OGL_OP_SelectBuffer,
+ VBOX_OGL_OP_IsList,
+ VBOX_OGL_OP_IsTexture,
+ VBOX_OGL_OP_RenderMode,
+ VBOX_OGL_OP_ReadPixels,
+ VBOX_OGL_OP_IsEnabled,
+ VBOX_OGL_OP_GenLists,
+ VBOX_OGL_OP_PixelTransferf,
+ VBOX_OGL_OP_PixelTransferi,
+ VBOX_OGL_OP_PixelZoom,
+ VBOX_OGL_OP_PixelStorei,
+ VBOX_OGL_OP_PixelStoref,
+ VBOX_OGL_OP_PixelMapfv,
+ VBOX_OGL_OP_PixelMapuiv,
+ VBOX_OGL_OP_PixelMapusv,
+ VBOX_OGL_OP_PointSize,
+ VBOX_OGL_OP_PolygonMode,
+ VBOX_OGL_OP_PolygonOffset,
+ VBOX_OGL_OP_PassThrough,
+ VBOX_OGL_OP_Ortho,
+ VBOX_OGL_OP_MatrixMode,
+ VBOX_OGL_OP_LogicOp,
+ VBOX_OGL_OP_ColorMask,
+ VBOX_OGL_OP_CopyTexSubImage1D,
+ VBOX_OGL_OP_CopyTexSubImage2D,
+ VBOX_OGL_OP_FrontFace,
+ VBOX_OGL_OP_Disable,
+ VBOX_OGL_OP_Enable,
+ VBOX_OGL_OP_PrioritizeTextures,
+ VBOX_OGL_OP_GetBooleanv,
+ VBOX_OGL_OP_GetDoublev,
+ VBOX_OGL_OP_GetFloatv,
+ VBOX_OGL_OP_GetIntegerv,
+ VBOX_OGL_OP_GetLightfv,
+ VBOX_OGL_OP_GetLightiv,
+ VBOX_OGL_OP_GetMaterialfv,
+ VBOX_OGL_OP_GetMaterialiv,
+ VBOX_OGL_OP_GetPixelMapfv,
+ VBOX_OGL_OP_GetPixelMapuiv,
+ VBOX_OGL_OP_GetPixelMapusv,
+ VBOX_OGL_OP_GetTexEnviv,
+ VBOX_OGL_OP_GetTexEnvfv,
+ VBOX_OGL_OP_GetTexGendv,
+ VBOX_OGL_OP_GetTexGenfv,
+ VBOX_OGL_OP_GetTexGeniv,
+ VBOX_OGL_OP_GetTexParameterfv,
+ VBOX_OGL_OP_GetTexParameteriv,
+ VBOX_OGL_OP_GetClipPlane,
+ VBOX_OGL_OP_GetPolygonStipple,
+ VBOX_OGL_OP_GetTexLevelParameterfv,
+ VBOX_OGL_OP_GetTexLevelParameteriv,
+ VBOX_OGL_OP_GetTexImage,
+
+ /* Windows ICD exports */
+ VBOX_OGL_OP_DrvReleaseContext,
+ VBOX_OGL_OP_DrvCreateContext,
+ VBOX_OGL_OP_DrvDeleteContext,
+ VBOX_OGL_OP_DrvCopyContext,
+ VBOX_OGL_OP_DrvSetContext,
+ VBOX_OGL_OP_DrvCreateLayerContext,
+ VBOX_OGL_OP_DrvShareLists,
+ VBOX_OGL_OP_DrvDescribeLayerPlane,
+ VBOX_OGL_OP_DrvSetLayerPaletteEntries,
+ VBOX_OGL_OP_DrvGetLayerPaletteEntries,
+ VBOX_OGL_OP_DrvRealizeLayerPalette,
+ VBOX_OGL_OP_DrvSwapLayerBuffers,
+ VBOX_OGL_OP_DrvDescribePixelFormat,
+ VBOX_OGL_OP_DrvSetPixelFormat,
+ VBOX_OGL_OP_DrvSwapBuffers,
+
+ /* OpenGL Extensions */
+ VBOX_OGL_OP_wglSwapIntervalEXT,
+ VBOX_OGL_OP_wglGetSwapIntervalEXT,
+
+ VBOX_OGL_OP_Last,
+
+ VBOX_OGL_OP_SizeHack = 0x7fffffff
+} VBOX_OGL_OP;
+
+#if defined(DEBUG) && defined(VBOX_OGL_WITH_CMD_STRINGS)
+static const char *pszVBoxOGLCmd[VBOX_OGL_OP_Last] =
+{
+ "ILLEGAL",
+ "glArrayElement",
+ "glBegin",
+ "glBindTexture",
+ "glBlendFunc",
+ "glCallList",
+ "glColor3b",
+ "glColor3d",
+ "glColor3f",
+ "glColor3i",
+ "glColor3s",
+ "glColor3ub",
+ "glColor3ui",
+ "glColor3us",
+ "glColor4b",
+ "glColor4d",
+ "glColor4f",
+ "glColor4i",
+ "glColor4s",
+ "glColor4ub",
+ "glColor4ui",
+ "glColor4us",
+ "glClear",
+ "glClearAccum",
+ "glClearColor",
+ "glClearDepth",
+ "glClearIndex",
+ "glClearStencil",
+ "glAccum",
+ "glAlphaFunc",
+ "glVertex2d",
+ "glVertex2f",
+ "glVertex2i",
+ "glVertex2s",
+ "glVertex3d",
+ "glVertex3f",
+ "glVertex3i",
+ "glVertex3s",
+ "glVertex4d",
+ "glVertex4f",
+ "glVertex4i",
+ "glVertex4s",
+ "glTexCoord1d",
+ "glTexCoord1f",
+ "glTexCoord1i",
+ "glTexCoord1s",
+ "glTexCoord2d",
+ "glTexCoord2f",
+ "glTexCoord2i",
+ "glTexCoord2s",
+ "glTexCoord3d",
+ "glTexCoord3f",
+ "glTexCoord3i",
+ "glTexCoord3s",
+ "glTexCoord4d",
+ "glTexCoord4f",
+ "glTexCoord4i",
+ "glTexCoord4s",
+ "glNormal3b",
+ "glNormal3d",
+ "glNormal3f",
+ "glNormal3i",
+ "glNormal3s",
+ "glRasterPos2d",
+ "glRasterPos2f",
+ "glRasterPos2i",
+ "glRasterPos2s",
+ "glRasterPos3d",
+ "glRasterPos3f",
+ "glRasterPos3i",
+ "glRasterPos3s",
+ "glRasterPos4d",
+ "glRasterPos4f",
+ "glRasterPos4i",
+ "glRasterPos4s",
+ "glEvalCoord1d",
+ "glEvalCoord1f",
+ "glEvalCoord2d",
+ "glEvalCoord2f",
+ "glEvalPoint1",
+ "glEvalPoint2",
+ "glIndexd",
+ "glIndexf",
+ "glIndexi",
+ "glIndexs",
+ "glIndexub",
+ "glRotated",
+ "glRotatef",
+ "glScaled",
+ "glScalef",
+ "glTranslated",
+ "glTranslatef",
+ "glDepthFunc",
+ "glDepthMask",
+ "glFinish",
+ "glFlush",
+ "glDeleteLists",
+ "glCullFace",
+ "glDeleteTextures",
+ "glDepthRange",
+ "glDisableClientState",
+ "glEnableClientState",
+ "glEvalMesh1",
+ "glEvalMesh2",
+ "glFogf",
+ "glFogfv",
+ "glFogi",
+ "glFogiv",
+ "glLightModelf",
+ "glLightModelfv",
+ "glLightModeli",
+ "glLightModeliv",
+ "glLightf",
+ "glLightfv",
+ "glLighti",
+ "glLightiv",
+ "glLineStipple",
+ "glLineWidth",
+ "glListBase",
+ "glDrawArrays",
+ "glDrawBuffer",
+ "glEdgeFlag",
+ "glEnd",
+ "glEndList",
+ "glCopyTexImage1D",
+ "glCopyTexImage2D",
+ "glColorMaterial",
+ "glMateriali",
+ "glMaterialf",
+ "glMaterialfv",
+ "glMaterialiv",
+ "glPopAttrib",
+ "glPopClientAttrib",
+ "glPopMatrix",
+ "glPopName",
+ "glPushAttrib",
+ "glPushClientAttrib",
+ "glPushMatrix",
+ "glPushName",
+ "glReadBuffer",
+ "glTexGendv",
+ "glTexGenf",
+ "glTexGend",
+ "glTexGeni",
+ "glTexEnvi",
+ "glTexEnvf",
+ "glTexEnviv",
+ "glTexEnvfv",
+ "glTexGeniv",
+ "glTexGenfv",
+ "glTexParameterf",
+ "glTexParameteri",
+ "glTexParameterfv",
+ "glTexParameteriv",
+ "glLoadIdentity",
+ "glLoadName",
+ "glLoadMatrixd",
+ "glLoadMatrixf",
+ "glStencilFunc",
+ "glShadeModel",
+ "glStencilMask",
+ "glStencilOp",
+ "glScissor",
+ "glViewport",
+ "glRectd",
+ "glRectf",
+ "glRecti",
+ "glRects",
+ "glRectdv",
+ "glRectfv",
+ "glRectiv",
+ "glRectsv",
+ "glMultMatrixd",
+ "glMultMatrixf",
+ "glNewList",
+ "glHint",
+ "glIndexMask",
+ "glInitNames",
+ "glTexCoordPointer",
+ "glVertexPointer",
+ "glColorPointer",
+ "glEdgeFlagPointer",
+ "glIndexPointer",
+ "glNormalPointer",
+ "glPolygonStipple",
+ "glCallLists",
+ "glClipPlane",
+ "glFrustum",
+ "glGenTextures",
+ "glMap1d",
+ "glMap1f",
+ "glMap2d",
+ "glMap2f",
+ "glMapGrid1d",
+ "glMapGrid1f",
+ "glMapGrid2d",
+ "glMapGrid2f",
+ "glCopyPixels",
+ "glTexImage1D",
+ "glTexImage2D",
+ "glTexSubImage1D",
+ "glTexSubImage2D",
+ "glFeedbackBuffer",
+ "glSelectBuffer",
+ "glIsList",
+ "glIsTexture",
+ "glRenderMode",
+ "glReadPixels",
+ "glIsEnabled",
+ "glGenLists",
+ "glPixelTransferf",
+ "glPixelTransferi",
+ "glPixelZoom",
+ "glPixelStorei",
+ "glPixelStoref",
+ "glPixelMapfv",
+ "glPixelMapuiv",
+ "glPixelMapusv",
+ "glPointSize",
+ "glPolygonMode",
+ "glPolygonOffset",
+ "glPassThrough",
+ "glOrtho",
+ "glMatrixMode",
+ "glLogicOp",
+ "glColorMask",
+ "glCopyTexSubImage1D",
+ "glCopyTexSubImage2D",
+ "glFrontFace",
+ "glDisable",
+ "glEnable",
+ "glPrioritizeTextures",
+ "glGetBooleanv",
+ "glGetDoublev",
+ "glGetFloatv",
+ "glGetIntegerv",
+ "glGetLightfv",
+ "glGetLightiv",
+ "glGetMaterialfv",
+ "glGetMaterialiv",
+ "glGetPixelMapfv",
+ "glGetPixelMapuiv",
+ "glGetPixelMapusv",
+ "glGetTexEnviv",
+ "glGetTexEnvfv",
+ "glGetTexGendv",
+ "glGetTexGenfv",
+ "glGetTexGeniv",
+ "glGetTexParameterfv",
+ "glGetTexParameteriv",
+ "glGetClipPlane",
+ "glGetPolygonStipple",
+ "glGetTexLevelParameterfv",
+ "glGetTexLevelParameteriv",
+ "glGetTexImage",
+
+ /* Windows ICD exports */
+ "DrvReleaseContext",
+ "DrvCreateContext",
+ "DrvDeleteContext",
+ "DrvCopyContext",
+ "DrvSetContext",
+ "DrvCreateLayerContext",
+ "DrvShareLists",
+ "DrvDescribeLayerPlane",
+ "DrvSetLayerPaletteEntries",
+ "DrvGetLayerPaletteEntries",
+ "DrvRealizeLayerPalette",
+ "DrvSwapLayerBuffers",
+ "DrvDescribePixelFormat",
+ "DrvSetPixelFormat",
+ "DrvSwapBuffers",
+
+ /* OpenGL Extensions */
+ "wglSwapIntervalEXT",
+ "wglGetSwapIntervalEXT",
+};
+#endif
+
+#ifdef VBOX_OGL_WITH_FUNCTION_WRAPPERS
+/* OpenGL function wrappers. */
+static PFN_VBOXGLWRAPPER pfnOGLWrapper[VBOX_OGL_OP_Last] =
+{
+ NULL,
+ vboxglArrayElement,
+ vboxglBegin,
+ vboxglBindTexture,
+ vboxglBlendFunc,
+ vboxglCallList,
+ vboxglColor3b,
+ vboxglColor3d,
+ vboxglColor3f,
+ vboxglColor3i,
+ vboxglColor3s,
+ vboxglColor3ub,
+ vboxglColor3ui,
+ vboxglColor3us,
+ vboxglColor4b,
+ vboxglColor4d,
+ vboxglColor4f,
+ vboxglColor4i,
+ vboxglColor4s,
+ vboxglColor4ub,
+ vboxglColor4ui,
+ vboxglColor4us,
+ vboxglClear,
+ vboxglClearAccum,
+ vboxglClearColor,
+ vboxglClearDepth,
+ vboxglClearIndex,
+ vboxglClearStencil,
+ vboxglAccum,
+ vboxglAlphaFunc,
+ vboxglVertex2d,
+ vboxglVertex2f,
+ vboxglVertex2i,
+ vboxglVertex2s,
+ vboxglVertex3d,
+ vboxglVertex3f,
+ vboxglVertex3i,
+ vboxglVertex3s,
+ vboxglVertex4d,
+ vboxglVertex4f,
+ vboxglVertex4i,
+ vboxglVertex4s,
+ vboxglTexCoord1d,
+ vboxglTexCoord1f,
+ vboxglTexCoord1i,
+ vboxglTexCoord1s,
+ vboxglTexCoord2d,
+ vboxglTexCoord2f,
+ vboxglTexCoord2i,
+ vboxglTexCoord2s,
+ vboxglTexCoord3d,
+ vboxglTexCoord3f,
+ vboxglTexCoord3i,
+ vboxglTexCoord3s,
+ vboxglTexCoord4d,
+ vboxglTexCoord4f,
+ vboxglTexCoord4i,
+ vboxglTexCoord4s,
+ vboxglNormal3b,
+ vboxglNormal3d,
+ vboxglNormal3f,
+ vboxglNormal3i,
+ vboxglNormal3s,
+ vboxglRasterPos2d,
+ vboxglRasterPos2f,
+ vboxglRasterPos2i,
+ vboxglRasterPos2s,
+ vboxglRasterPos3d,
+ vboxglRasterPos3f,
+ vboxglRasterPos3i,
+ vboxglRasterPos3s,
+ vboxglRasterPos4d,
+ vboxglRasterPos4f,
+ vboxglRasterPos4i,
+ vboxglRasterPos4s,
+ vboxglEvalCoord1d,
+ vboxglEvalCoord1f,
+ vboxglEvalCoord2d,
+ vboxglEvalCoord2f,
+ vboxglEvalPoint1,
+ vboxglEvalPoint2,
+ vboxglIndexd,
+ vboxglIndexf,
+ vboxglIndexi,
+ vboxglIndexs,
+ vboxglIndexub,
+ vboxglRotated,
+ vboxglRotatef,
+ vboxglScaled,
+ vboxglScalef,
+ vboxglTranslated,
+ vboxglTranslatef,
+ vboxglDepthFunc,
+ vboxglDepthMask,
+ vboxglFinish,
+ vboxglFlush,
+ vboxglDeleteLists,
+ vboxglCullFace,
+ vboxglDeleteTextures,
+ vboxglDepthRange,
+ vboxglDisableClientState,
+ vboxglEnableClientState,
+ vboxglEvalMesh1,
+ vboxglEvalMesh2,
+ vboxglFogf,
+ vboxglFogfv,
+ vboxglFogi,
+ vboxglFogiv,
+ vboxglLightModelf,
+ vboxglLightModelfv,
+ vboxglLightModeli,
+ vboxglLightModeliv,
+ vboxglLightf,
+ vboxglLightfv,
+ vboxglLighti,
+ vboxglLightiv,
+ vboxglLineStipple,
+ vboxglLineWidth,
+ vboxglListBase,
+ vboxglDrawArrays,
+ vboxglDrawBuffer,
+ vboxglEdgeFlag,
+ vboxglEnd,
+ vboxglEndList,
+ vboxglCopyTexImage1D,
+ vboxglCopyTexImage2D,
+ vboxglColorMaterial,
+ vboxglMateriali,
+ vboxglMaterialf,
+ vboxglMaterialfv,
+ vboxglMaterialiv,
+ vboxglPopAttrib,
+ vboxglPopClientAttrib,
+ vboxglPopMatrix,
+ vboxglPopName,
+ vboxglPushAttrib,
+ vboxglPushClientAttrib,
+ vboxglPushMatrix,
+ vboxglPushName,
+ vboxglReadBuffer,
+ vboxglTexGendv,
+ vboxglTexGenf,
+ vboxglTexGend,
+ vboxglTexGeni,
+ vboxglTexEnvi,
+ vboxglTexEnvf,
+ vboxglTexEnviv,
+ vboxglTexEnvfv,
+ vboxglTexGeniv,
+ vboxglTexGenfv,
+ vboxglTexParameterf,
+ vboxglTexParameteri,
+ vboxglTexParameterfv,
+ vboxglTexParameteriv,
+ vboxglLoadIdentity,
+ vboxglLoadName,
+ vboxglLoadMatrixd,
+ vboxglLoadMatrixf,
+ vboxglStencilFunc,
+ vboxglShadeModel,
+ vboxglStencilMask,
+ vboxglStencilOp,
+ vboxglScissor,
+ vboxglViewport,
+ vboxglRectd,
+ vboxglRectf,
+ vboxglRecti,
+ vboxglRects,
+ vboxglRectdv,
+ vboxglRectfv,
+ vboxglRectiv,
+ vboxglRectsv,
+ vboxglMultMatrixd,
+ vboxglMultMatrixf,
+ vboxglNewList,
+ vboxglHint,
+ vboxglIndexMask,
+ vboxglInitNames,
+ vboxglTexCoordPointer,
+ vboxglVertexPointer,
+ vboxglColorPointer,
+ vboxglEdgeFlagPointer,
+ vboxglIndexPointer,
+ vboxglNormalPointer,
+ vboxglPolygonStipple,
+ vboxglCallLists,
+ vboxglClipPlane,
+ vboxglFrustum,
+ vboxglGenTextures,
+ vboxglMap1d,
+ vboxglMap1f,
+ vboxglMap2d,
+ vboxglMap2f,
+ vboxglMapGrid1d,
+ vboxglMapGrid1f,
+ vboxglMapGrid2d,
+ vboxglMapGrid2f,
+ vboxglCopyPixels,
+ vboxglTexImage1D,
+ vboxglTexImage2D,
+ vboxglTexSubImage1D,
+ vboxglTexSubImage2D,
+ vboxglFeedbackBuffer,
+ vboxglSelectBuffer,
+ vboxglIsList,
+ vboxglIsTexture,
+ vboxglRenderMode,
+ vboxglReadPixels,
+ vboxglIsEnabled,
+ vboxglGenLists,
+ vboxglPixelTransferf,
+ vboxglPixelTransferi,
+ vboxglPixelZoom,
+ vboxglPixelStorei,
+ vboxglPixelStoref,
+ vboxglPixelMapfv,
+ vboxglPixelMapuiv,
+ vboxglPixelMapusv,
+ vboxglPointSize,
+ vboxglPolygonMode,
+ vboxglPolygonOffset,
+ vboxglPassThrough,
+ vboxglOrtho,
+ vboxglMatrixMode,
+ vboxglLogicOp,
+ vboxglColorMask,
+ vboxglCopyTexSubImage1D,
+ vboxglCopyTexSubImage2D,
+ vboxglFrontFace,
+ vboxglDisable,
+ vboxglEnable,
+ vboxglPrioritizeTextures,
+ vboxglGetBooleanv,
+ vboxglGetDoublev,
+ vboxglGetFloatv,
+ vboxglGetIntegerv,
+ vboxglGetLightfv,
+ vboxglGetLightiv,
+ vboxglGetMaterialfv,
+ vboxglGetMaterialiv,
+ vboxglGetPixelMapfv,
+ vboxglGetPixelMapuiv,
+ vboxglGetPixelMapusv,
+ vboxglGetTexEnviv,
+ vboxglGetTexEnvfv,
+ vboxglGetTexGendv,
+ vboxglGetTexGenfv,
+ vboxglGetTexGeniv,
+ vboxglGetTexParameterfv,
+ vboxglGetTexParameteriv,
+ vboxglGetClipPlane,
+ vboxglGetPolygonStipple,
+ vboxglGetTexLevelParameterfv,
+ vboxglGetTexLevelParameteriv,
+ vboxglGetTexImage,
+
+ /* Windows ICD exports */
+ vboxglDrvReleaseContext,
+ vboxglDrvCreateContext,
+ vboxglDrvDeleteContext,
+ vboxglDrvCopyContext,
+ vboxglDrvSetContext,
+ vboxglDrvCreateLayerContext,
+ vboxglDrvShareLists,
+ vboxglDrvDescribeLayerPlane,
+ vboxglDrvSetLayerPaletteEntries,
+ vboxglDrvGetLayerPaletteEntries,
+ vboxglDrvRealizeLayerPalette,
+ vboxglDrvSwapLayerBuffers,
+ vboxglDrvDescribePixelFormat,
+ vboxglDrvSetPixelFormat,
+ vboxglDrvSwapBuffers,
+
+#ifdef RT_OS_WINDOWS
+ /* OpenGL Extensions */
+ vboxwglSwapIntervalEXT,
+ vboxwglGetSwapIntervalEXT,
+#endif
+};
+#endif
+
+
+#ifdef VBOX_OGL_WITH_EXTENSION_ARRAY
+typedef struct
+{
+ const char *pszExtName;
+ const char *pszExtFunctionName;
+#ifdef VBOX_OGL_GUEST_SIDE
+ RTUINTPTR pfnFunction;
+#else
+ RTUINTPTR *ppfnFunction;
+#endif
+ bool fAvailable;
+} OPENGL_EXT, *POPENGL_EXT;
+
+#ifdef VBOX_OGL_GUEST_SIDE
+#define VBOX_OGL_EXTENSION(a) (RTUINTPTR)a
+#else
+#define VBOX_OGL_EXTENSION(a) (RTUINTPTR *)&pfn##a
+
+static PFNWGLSWAPINTERVALEXTPROC pfnwglSwapIntervalEXT = NULL;
+static PFNWGLGETSWAPINTERVALEXTPROC pfnwglGetSwapIntervalEXT = NULL;
+
+#endif
+
+static OPENGL_EXT OpenGLExtensions[] =
+{
+ { "WGL_EXT_swap_control", "wglSwapIntervalEXT", VBOX_OGL_EXTENSION(wglSwapIntervalEXT), false },
+ { "WGL_EXT_swap_control", "wglGetSwapIntervalEXT", VBOX_OGL_EXTENSION(wglGetSwapIntervalEXT), false },
+};
+#endif /* VBOX_OGL_WITH_EXTENSION_ARRAY */
+
+#endif /* !VBOX_INCLUDED_HostServices_VBoxOGLOp_h */
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-26 07:07:12 +0000