/** @file
* VirtualBox OpenGL command pack/unpack header
*/
/*
*
* Copyright (C) 2006-2010 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_HostService_VBoxOGLOp_h
#define ___VBox_HostService_VBoxOGLOp_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 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