VBoxOGLOp.h@ 68788

Last change on this file since 68788 was 68675, checked in by vboxsync, 8 years ago
include file build fixes (kmk -C include)
Property svn:eol-style set to `native`
File size: 89.1 KB

Line
1	/** @file
2	* VirtualBox OpenGL command pack/unpack header
3	*/
4
5	/*
6	*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	#ifndef ___VBox_HostService_VBoxOGLOp_h
28	#define ___VBox_HostService_VBoxOGLOp_h
29
30	#include <iprt/types.h>
31
32	#ifdef VBOX_OGL_GUEST_SIDE
33	/************************************************************************************************************
34	* Guest side macro's for packing OpenGL function calls into the command buffer. *
35	* *
36	************************************************************************************************************/
37
38	#define VBOX_OGL_NAME_PREFIX(Function) gl##Function
39
40	#define OGL_CMD(op, numpar, size) \
41	VBoxCmdStart(VBOX_OGL_OP_##op, numpar, size);
42
43	#define OGL_PARAM(val, size) \
44	VBoxCmdSaveParameter((uint8_t *)&val, size);
45
46	#define OGL_MEMPARAM(ptr, size) \
47	VBoxCmdSaveMemParameter((uint8_t *)ptr, size);
48
49	#define OGL_CMD_END(op) \
50	VBoxCmdStop(VBOX_OGL_OP_##op);
51
52
53	#define VBOX_OGL_GEN_OP(op) \
54	OGL_CMD(op, 0, 0); \
55	OGL_CMD_END(op);
56
57	#define VBOX_OGL_GEN_OP1(op, p1) \
58	OGL_CMD(op, 1, sizeof(p1)); \
59	OGL_PARAM(p1, sizeof(p1)); \
60	OGL_CMD_END(op);
61
62	#define VBOX_OGL_GEN_OP2(op, p1, p2) \
63	OGL_CMD(op, 2, sizeof(p1)+sizeof(p2)); \
64	OGL_PARAM(p1, sizeof(p1)); \
65	OGL_PARAM(p2, sizeof(p2)); \
66	OGL_CMD_END(op);
67
68	#define VBOX_OGL_GEN_OP3(op, p1, p2, p3) \
69	OGL_CMD(op, 3, sizeof(p1)+sizeof(p2)+sizeof(p3)); \
70	OGL_PARAM(p1, sizeof(p1)); \
71	OGL_PARAM(p2, sizeof(p2)); \
72	OGL_PARAM(p3, sizeof(p3)); \
73	OGL_CMD_END(op);
74
75	#define VBOX_OGL_GEN_OP4(op, p1, p2, p3, p4) \
76	OGL_CMD(op, 4, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)); \
77	OGL_PARAM(p1, sizeof(p1)); \
78	OGL_PARAM(p2, sizeof(p2)); \
79	OGL_PARAM(p3, sizeof(p3)); \
80	OGL_PARAM(p4, sizeof(p4)); \
81	OGL_CMD_END(op);
82
83	#define VBOX_OGL_GEN_OP5(op, p1, p2, p3, p4, p5) \
84	OGL_CMD(op, 5, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)); \
85	OGL_PARAM(p1, sizeof(p1)); \
86	OGL_PARAM(p2, sizeof(p2)); \
87	OGL_PARAM(p3, sizeof(p3)); \
88	OGL_PARAM(p4, sizeof(p4)); \
89	OGL_PARAM(p5, sizeof(p5)); \
90	OGL_CMD_END(op);
91
92	#define VBOX_OGL_GEN_OP6(op, p1, p2, p3, p4, p5, p6) \
93	OGL_CMD(op, 6, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)); \
94	OGL_PARAM(p1, sizeof(p1)); \
95	OGL_PARAM(p2, sizeof(p2)); \
96	OGL_PARAM(p3, sizeof(p3)); \
97	OGL_PARAM(p4, sizeof(p4)); \
98	OGL_PARAM(p5, sizeof(p5)); \
99	OGL_PARAM(p6, sizeof(p6)); \
100	OGL_CMD_END(op);
101
102	#define VBOX_OGL_GEN_OP7(op, p1, p2, p3, p4, p5, p6, p7) \
103	OGL_CMD(op, 7, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)); \
104	OGL_PARAM(p1, sizeof(p1)); \
105	OGL_PARAM(p2, sizeof(p2)); \
106	OGL_PARAM(p3, sizeof(p3)); \
107	OGL_PARAM(p4, sizeof(p4)); \
108	OGL_PARAM(p5, sizeof(p5)); \
109	OGL_PARAM(p6, sizeof(p6)); \
110	OGL_PARAM(p7, sizeof(p7)); \
111	OGL_CMD_END(op);
112
113	#define VBOX_OGL_GEN_OP8(op, p1, p2, p3, p4, p5, p6, p7, p8) \
114	OGL_CMD(op, 8, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)+sizeof(p8)); \
115	OGL_PARAM(p1, sizeof(p1)); \
116	OGL_PARAM(p2, sizeof(p2)); \
117	OGL_PARAM(p3, sizeof(p3)); \
118	OGL_PARAM(p4, sizeof(p4)); \
119	OGL_PARAM(p5, sizeof(p5)); \
120	OGL_PARAM(p6, sizeof(p6)); \
121	OGL_PARAM(p7, sizeof(p7)); \
122	OGL_PARAM(p8, sizeof(p8)); \
123	OGL_CMD_END(op);
124
125
126	/* last parameter is a memory block */
127	#define VBOX_OGL_GEN_OP1PTR(op, size, p1ptr) \
128	OGL_CMD(op, 1, size); \
129	OGL_MEMPARAM(p1ptr, size); \
130	OGL_CMD_END(op);
131
132	#define VBOX_OGL_GEN_OP2PTR(op, p1, size, p2ptr) \
133	OGL_CMD(op, 2, sizeof(p1)+size); \
134	OGL_PARAM(p1, sizeof(p1)); \
135	OGL_MEMPARAM(p2ptr, size); \
136	OGL_CMD_END(op);
137
138	#define VBOX_OGL_GEN_OP3PTR(op, p1, p2, size, p3ptr) \
139	OGL_CMD(op, 3, sizeof(p1)+sizeof(p2)+size); \
140	OGL_PARAM(p1, sizeof(p1)); \
141	OGL_PARAM(p2, sizeof(p2)); \
142	OGL_MEMPARAM(p3ptr, size); \
143	OGL_CMD_END(op);
144
145	#define VBOX_OGL_GEN_OP4PTR(op, p1, p2, p3, size, p4ptr) \
146	OGL_CMD(op, 4, sizeof(p1)+sizeof(p2)+sizeof(p3)+size); \
147	OGL_PARAM(p1, sizeof(p1)); \
148	OGL_PARAM(p2, sizeof(p2)); \
149	OGL_PARAM(p3, sizeof(p3)); \
150	OGL_MEMPARAM(p4ptr, size); \
151	OGL_CMD_END(op);
152
153	#define VBOX_OGL_GEN_OP5PTR(op, p1, p2, p3, p4, size, p5ptr) \
154	OGL_CMD(op, 5, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+size); \
155	OGL_PARAM(p1, sizeof(p1)); \
156	OGL_PARAM(p2, sizeof(p2)); \
157	OGL_PARAM(p3, sizeof(p3)); \
158	OGL_PARAM(p4, sizeof(p4)); \
159	OGL_MEMPARAM(p5ptr, size); \
160	OGL_CMD_END(op);
161
162	#define VBOX_OGL_GEN_OP6PTR(op, p1, p2, p3, p4, p5, size, p6ptr) \
163	OGL_CMD(op, 6, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+size); \
164	OGL_PARAM(p1, sizeof(p1)); \
165	OGL_PARAM(p2, sizeof(p2)); \
166	OGL_PARAM(p3, sizeof(p3)); \
167	OGL_PARAM(p4, sizeof(p4)); \
168	OGL_PARAM(p5, sizeof(p5)); \
169	OGL_MEMPARAM(p6ptr, size); \
170	OGL_CMD_END(op);
171
172	#define VBOX_OGL_GEN_OP7PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
173	OGL_CMD(op, 7, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+size); \
174	OGL_PARAM(p1, sizeof(p1)); \
175	OGL_PARAM(p2, sizeof(p2)); \
176	OGL_PARAM(p3, sizeof(p3)); \
177	OGL_PARAM(p4, sizeof(p4)); \
178	OGL_PARAM(p5, sizeof(p5)); \
179	OGL_PARAM(p6, sizeof(p6)); \
180	OGL_MEMPARAM(p7ptr, size); \
181	OGL_CMD_END(op);
182
183	#define VBOX_OGL_GEN_OP8PTR(op, p1, p2, p3, p4, p5, p6, p7, size, p8ptr) \
184	OGL_CMD(op, 8, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)+size); \
185	OGL_PARAM(p1, sizeof(p1)); \
186	OGL_PARAM(p2, sizeof(p2)); \
187	OGL_PARAM(p3, sizeof(p3)); \
188	OGL_PARAM(p4, sizeof(p4)); \
189	OGL_PARAM(p5, sizeof(p5)); \
190	OGL_PARAM(p6, sizeof(p6)); \
191	OGL_PARAM(p7, sizeof(p7)); \
192	OGL_MEMPARAM(p8ptr, size); \
193	OGL_CMD_END(op);
194
195	#define VBOX_OGL_GEN_OP9PTR(op, p1, p2, p3, p4, p5, p6, p7, p8, size, p9ptr) \
196	OGL_CMD(op, 9, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)+sizeof(p8)+size); \
197	OGL_PARAM(p1, sizeof(p1)); \
198	OGL_PARAM(p2, sizeof(p2)); \
199	OGL_PARAM(p3, sizeof(p3)); \
200	OGL_PARAM(p4, sizeof(p4)); \
201	OGL_PARAM(p5, sizeof(p5)); \
202	OGL_PARAM(p6, sizeof(p6)); \
203	OGL_PARAM(p7, sizeof(p7)); \
204	OGL_PARAM(p8, sizeof(p8)); \
205	OGL_MEMPARAM(p9ptr, size); \
206	OGL_CMD_END(op);
207
208	#define VBOX_OGL_GEN_OP10PTR(op, p1, p2, p3, p4, p5, p6, p7, p8, p9, size, p10ptr) \
209	OGL_CMD(op, 10, sizeof(p1)+sizeof(p2)+sizeof(p3)+sizeof(p4)+sizeof(p5)+sizeof(p6)+sizeof(p7)+sizeof(p8)+sizeof(p9)+size); \
210	OGL_PARAM(p1, sizeof(p1)); \
211	OGL_PARAM(p2, sizeof(p2)); \
212	OGL_PARAM(p3, sizeof(p3)); \
213	OGL_PARAM(p4, sizeof(p4)); \
214	OGL_PARAM(p5, sizeof(p5)); \
215	OGL_PARAM(p6, sizeof(p6)); \
216	OGL_PARAM(p7, sizeof(p7)); \
217	OGL_PARAM(p8, sizeof(p8)); \
218	OGL_PARAM(p9, sizeof(p9)); \
219	OGL_MEMPARAM(p10ptr, size); \
220	OGL_CMD_END(op);
221
222
223	/* two memory blocks */
224	#define VBOX_OGL_GEN_OP2PTRPTR(op, size1, p1ptr, size2, p2ptr) \
225	OGL_CMD(op, 2, size1+size2); \
226	OGL_MEMPARAM(p1ptr, size1); \
227	OGL_MEMPARAM(p2ptr, size2); \
228	OGL_CMD_END(op);
229
230	#define VBOX_OGL_GEN_OP3PTRPTR(op, p1, size2, p2ptr, size3, p3ptr) \
231	OGL_CMD(op, 3, sizeof(p1)+size2+size3); \
232	OGL_PARAM(p1, sizeof(p1)); \
233	OGL_MEMPARAM(p2ptr, size2); \
234	OGL_MEMPARAM(p3ptr, size3); \
235	OGL_CMD_END(op);
236
237	/* Note: sync operations always set the last error */
238	/* sync operation that returns a value */
239	#define VBOX_OGL_GEN_SYNC_OP_RET(rettype, op) \
240	VBOX_OGL_GEN_OP(op) \
241	rettype retval = (rettype)VBoxOGLFlush();
242
243	#define VBOX_OGL_GEN_SYNC_OP1_RET(rettype, op, p1) \
244	VBOX_OGL_GEN_OP1(op, p1) \
245	rettype retval = (rettype)VBoxOGLFlush();
246
247	#define VBOX_OGL_GEN_SYNC_OP2_RET(rettype, op, p1, p2) \
248	VBOX_OGL_GEN_OP2(op, p1, p2) \
249	rettype retval = (rettype)VBoxOGLFlush();
250
251	#define VBOX_OGL_GEN_SYNC_OP3_RET(rettype, op, p1, p2, p3) \
252	VBOX_OGL_GEN_OP3(op, p1, p2, p3) \
253	rettype retval = (rettype)VBoxOGLFlush();
254
255	#define VBOX_OGL_GEN_SYNC_OP4_RET(rettype, op, p1, p2, p3, p4) \
256	VBOX_OGL_GEN_OP4(op, p1, p2, p3, p4) \
257	rettype retval = (rettype)VBoxOGLFlush();
258
259	#define VBOX_OGL_GEN_SYNC_OP5_RET(rettype, op, p1, p2, p3, p4, p5) \
260	VBOX_OGL_GEN_OP5(op, p1, p2, p3, p4, p5) \
261	rettype retval = (rettype)VBoxOGLFlush();
262
263	#define VBOX_OGL_GEN_SYNC_OP6_RET(rettype, op, p1, p2, p3, p4, p5, p6) \
264	VBOX_OGL_GEN_OP6(op, p1, p2, p3, p4, p5, p6) \
265	rettype retval = (rettype)VBoxOGLFlush();
266
267	#define VBOX_OGL_GEN_SYNC_OP7_RET(rettype, op, p1, p2, p3, p4, p5, p6, p7) \
268	VBOX_OGL_GEN_OP7(op, p1, p2, p3, p4, p5, p6, p7) \
269	rettype retval = (rettype)VBoxOGLFlush();
270
271
272	#define VBOX_OGL_GEN_SYNC_OP(op) \
273	VBOX_OGL_GEN_OP(op) \
274	VBoxOGLFlush();
275
276	#define VBOX_OGL_GEN_SYNC_OP1(op, p1) \
277	VBOX_OGL_GEN_OP1(op, p1) \
278	VBoxOGLFlush();
279
280	#define VBOX_OGL_GEN_SYNC_OP2(op, p1, p2) \
281	VBOX_OGL_GEN_OP2(op, p1, p2) \
282	VBoxOGLFlush();
283
284
285	/* Sync operation whose last parameter is a block of memory */
286	#define VBOX_OGL_GEN_SYNC_OP2_PTR(op, p1, size, p2ptr) \
287	VBOX_OGL_GEN_OP2PTR(op, p1, size, p2ptr); \
288	VBoxOGLFlush();
289
290	#define VBOX_OGL_GEN_SYNC_OP5_PTR(op, p1, p2, p3, p4, size, p5ptr) \
291	VBOX_OGL_GEN_OP2PTR(op, p1, p2, p3, p4, size, p5ptr); \
292	VBoxOGLFlush();
293
294	#define VBOX_OGL_GEN_SYNC_OP6_PTR(op, p1, p2, p3, p4, p5, size, p6ptr) \
295	VBOX_OGL_GEN_OP6PTR(op, p1, p2, p3, p4, p5, size, p6ptr); \
296	VBoxOGLFlush();
297
298	#define VBOX_OGL_GEN_SYNC_OP7_PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
299	VBOX_OGL_GEN_OP7PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr); \
300	VBoxOGLFlush();
301
302	/* Sync operation whose last parameter is a block of memory in which results are returned */
303	#define VBOX_OGL_GEN_SYNC_OP1_PASS_PTR(op, size, p1ptr) \
304	VBOX_OGL_GEN_OP(op); \
305	VBoxOGLFlushPtr(p1ptr, size);
306
307	#define VBOX_OGL_GEN_SYNC_OP2_PASS_PTR(op, p1, size, p2ptr) \
308	VBOX_OGL_GEN_OP1(op, p1); \
309	VBoxOGLFlushPtr(p2ptr, size);
310
311	#define VBOX_OGL_GEN_SYNC_OP3_PASS_PTR(op, p1, p2, size, p3ptr) \
312	VBOX_OGL_GEN_OP2(op, p1, p2); \
313	VBoxOGLFlushPtr(p3ptr, size);
314
315	#define VBOX_OGL_GEN_SYNC_OP4_PASS_PTR(op, p1, p2, p3, size, p4ptr) \
316	VBOX_OGL_GEN_OP3(op, p1, p2, p3); \
317	VBoxOGLFlushPtr(p4ptr, size);
318
319	#define VBOX_OGL_GEN_SYNC_OP5_PASS_PTR(op, p1, p2, p3, p4, size, p5ptr) \
320	VBOX_OGL_GEN_OP4(op, p1, p2, p3, p4); \
321	VBoxOGLFlushPtr(p5ptr, size);
322
323	#define VBOX_OGL_GEN_SYNC_OP6_PASS_PTR(op, p1, p2, p3, p4, p5, size, p6ptr) \
324	VBOX_OGL_GEN_OP5(op, p1, p2, p3, p4, p5); \
325	VBoxOGLFlushPtr(p6ptr, size);
326
327	#define VBOX_OGL_GEN_SYNC_OP7_PASS_PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
328	VBOX_OGL_GEN_OP6(op, p1, p2, p3, p4, p5, p6); \
329	VBoxOGLFlushPtr(p7ptr, size);
330
331
332	/* Sync operation whose last parameter is a block of memory and return a value */
333	#define VBOX_OGL_GEN_SYNC_OP2_PTR_RET(rettype, op, p1, size, p2ptr) \
334	VBOX_OGL_GEN_OP2PTR(op, p1, size, p2ptr); \
335	rettype retval = (rettype)VBoxOGLFlush();
336
337	#define VBOX_OGL_GEN_SYNC_OP4_PTR_RET(rettype, op, p1, p2, p3, size, p4ptr) \
338	VBOX_OGL_GEN_OP4PTR(op, p1, p2, p3, size, p4ptr); \
339	rettype retval = (rettype)VBoxOGLFlush();
340
341	#define VBOX_OGL_GEN_SYNC_OP5_PTR_RET(rettype, op, p1, p2, p3, p4, size, p5ptr) \
342	VBOX_OGL_GEN_OP5PTR(op, p1, p2, p3, p4, size, p5ptr); \
343	rettype retval = (rettype)VBoxOGLFlush();
344
345	#define VBOX_OGL_GEN_SYNC_OP6_PTR_RET(rettype, op, p1, p2, p3, p4, p5, size, p6ptr) \
346	VBOX_OGL_GEN_OP6PTR(op, p1, p2, p3, p4, p5, size, p6ptr); \
347	rettype retval = (rettype)VBoxOGLFlush();
348
349	#define VBOX_OGL_GEN_SYNC_OP7_PTR_RET(rettype, op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
350	VBOX_OGL_GEN_OP7PTR(op, p1, p2, p3, p4, p5, p6, size, p7ptr); \
351	rettype retval = (rettype)VBoxOGLFlush();
352
353
354	/* Sync operation whose last parameter is a block of memory in which results are returned and return a value */
355	#define VBOX_OGL_GEN_SYNC_OP2_PASS_PTR_RET(rettype, op, p1, size, p2ptr) \
356	VBOX_OGL_GEN_OP1(op, p1); \
357	rettype retval = (rettype)VBoxOGLFlushPtr(p2ptr, size);
358
359	#define VBOX_OGL_GEN_SYNC_OP4_PASS_PTR_RET(rettype, op, p1, p2, p3, size, p4ptr) \
360	VBOX_OGL_GEN_OP3(op, p1, p2, p3); \
361	rettype retval = (rettype)VBoxOGLFlushPtr(p4ptr, size);
362
363	#define VBOX_OGL_GEN_SYNC_OP5_PASS_PTR_RET(rettype, op, p1, p2, p3, p4, size, p5ptr) \
364	VBOX_OGL_GEN_OP4(op, p1, p2, p3, p4); \
365	rettype retval = (rettype)VBoxOGLFlushPtr(p5ptr, size);
366
367	#define VBOX_OGL_GEN_SYNC_OP6_PASS_PTR_RET(rettype, op, p1, p2, p3, p4, p5, size, p6ptr) \
368	VBOX_OGL_GEN_OP5(op, p1, p2, p3, p4, p5); \
369	rettype retval = (rettype)VBoxOGLFlushPtr(p6ptr, size);
370
371	#define VBOX_OGL_GEN_SYNC_OP7_PASS_PTR_RET(rettype, op, p1, p2, p3, p4, p5, p6, size, p7ptr) \
372	VBOX_OGL_GEN_OP6(op, p1, p2, p3, p4, p5, p6); \
373	rettype retval = (rettype)VBoxOGLFlushPtr(p7ptr, size);
374
375
376	/* Generate async functions elements in the command queue */
377	#define GL_GEN_FUNC(Function) \
378	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (void) \
379	{ \
380	VBOX_OGL_GEN_OP(Function); \
381	}
382
383	#define GL_GEN_FUNC1(Function, Type) \
384	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a) \
385	{ \
386	VBOX_OGL_GEN_OP1(Function, a); \
387	}
388
389	#define GL_GEN_FUNC1V(Function, Type) \
390	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a) \
391	{ \
392	VBOX_OGL_GEN_OP1(Function, a); \
393	} \
394	void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (const Type *v) \
395	{ \
396	VBOX_OGL_GEN_OP1(Function, v[0]); \
397	} \
398
399	#define GL_GEN_FUNC2(Function, Type) \
400	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b) \
401	{ \
402	VBOX_OGL_GEN_OP2(Function, a, b); \
403	}
404
405	#define GL_GEN_FUNC2V(Function, Type) \
406	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b) \
407	{ \
408	VBOX_OGL_GEN_OP2(Function, a, b); \
409	} \
410	void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (const Type *v) \
411	{ \
412	VBOX_OGL_GEN_OP2(Function, v[0], v[1]); \
413	} \
414
415	#define GL_GEN_FUNC3(Function, Type) \
416	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c) \
417	{ \
418	VBOX_OGL_GEN_OP3(Function, a, b, c); \
419	}
420
421	#define GL_GEN_FUNC3V(Function, Type) \
422	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c) \
423	{ \
424	VBOX_OGL_GEN_OP3(Function, a, b, c); \
425	} \
426	void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (const Type *v) \
427	{ \
428	VBOX_OGL_GEN_OP3(Function, v[0], v[1], v[2]); \
429	} \
430
431	#define GL_GEN_FUNC4(Function, Type) \
432	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c, Type d) \
433	{ \
434	VBOX_OGL_GEN_OP4(Function, a, b, c, d); \
435	}
436
437	#define GL_GEN_FUNC4V(Function, Type) \
438	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c, Type d) \
439	{ \
440	VBOX_OGL_GEN_OP4(Function, a, b, c, d); \
441	} \
442	void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (const Type *v) \
443	{ \
444	VBOX_OGL_GEN_OP4(Function, v[0], v[1], v[2], v[3]); \
445	} \
446
447	#define GL_GEN_FUNC6(Function, Type) \
448	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type a, Type b, Type c, Type d, Type e, Type f) \
449	{ \
450	VBOX_OGL_GEN_OP6(Function, a, b, c, d, e, f); \
451	}
452
453	#define GL_GEN_VPAR_FUNC2(Function, Type1, Type2) \
454	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b) \
455	{ \
456	VBOX_OGL_GEN_OP2(Function, a, b); \
457	}
458
459	#define GL_GEN_VPAR_FUNC2V(Function, Type1, Type2) \
460	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b) \
461	{ \
462	VBOX_OGL_GEN_OP2(Function, a, b); \
463	} \
464	void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (Type1 a, const Type2 *v) \
465	{ \
466	VBOX_OGL_GEN_OP3(Function, a, v[0], v[1]); \
467	} \
468
469	#define GL_GEN_VPAR_FUNC3(Function, Type1, Type2, Type3) \
470	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c) \
471	{ \
472	VBOX_OGL_GEN_OP3(Function, a, b, c); \
473	}
474
475	#define GL_GEN_VPAR_FUNC3V(Function, Type1, Type2, Type3) \
476	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c) \
477	{ \
478	VBOX_OGL_GEN_OP3(Function, a, b, c); \
479	} \
480	void APIENTRY VBOX_OGL_NAME_PREFIX(Function)##v (Type1 a, Type2 b, const Type3 *v) \
481	{ \
482	VBOX_OGL_GEN_OP3(Function, a, v[0], v[1]); \
483	} \
484
485	#define GL_GEN_VPAR_FUNC4(Function, Type1, Type2, Type3, Type4) \
486	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d) \
487	{ \
488	VBOX_OGL_GEN_OP4(Function, a, b, c, d); \
489	}
490
491	#define GL_GEN_VPAR_FUNC5(Function, Type1, Type2, Type3, Type4, Type5) \
492	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e) \
493	{ \
494	VBOX_OGL_GEN_OP5(Function, a, b, c, d, e); \
495	}
496
497	#define GL_GEN_VPAR_FUNC6(Function, Type1, Type2, Type3, Type4, Type5, Type6) \
498	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e, Type6 f) \
499	{ \
500	VBOX_OGL_GEN_OP6(Function, a, b, c, d, e, f); \
501	}
502
503	#define GL_GEN_VPAR_FUNC7(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
504	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e, Type6 f, Type7 g) \
505	{ \
506	VBOX_OGL_GEN_OP7(Function, a, b, c, d, e, f, g); \
507	}
508
509	#define GL_GEN_VPAR_FUNC8(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8) \
510	void APIENTRY VBOX_OGL_NAME_PREFIX(Function) (Type1 a, Type2 b, Type3 c, Type4 d, Type5 e, Type6 f, Type7 g, Type8 h) \
511	{ \
512	VBOX_OGL_GEN_OP8(Function, a, b, c, d, e, f, g, h); \
513	}
514
515	#define GL_GEN_VPAR_FUNC9(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8 ,Type9) \
516	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) \
517	{ \
518	VBOX_OGL_GEN_OP9(Function, a, b, c, d, e, f, g, h, i); \
519	}
520
521	#elif defined(VBOX_OGL_HOST_SIDE)
522
523	/************************************************************************************************************
524	* Host side macro's for generating OpenGL function calls from the packed commands in the command buffer. *
525	* *
526	************************************************************************************************************/
527
528	#include <iprt/assert.h>
529
530	#define VBOX_OGL_NAME_PREFIX(Function) vboxgl##Function
531
532	#ifdef VBOX_OGL_CMD_STRICT
533	#define VBOX_OGL_CHECK_MAGIC(pParVal) Assert(pParVal->Magic == VBOX_OGL_CMD_MAGIC)
534	#else
535	#define VBOX_OGL_CHECK_MAGIC(pParVal)
536	#endif
537
538	#define OGL_CMD(op, numpar) \
539	PVBOX_OGL_CMD pCmd = (PVBOX_OGL_CMD)pCmdBuffer; \
540	Assert(pCmd->enmOp == VBOX_OGL_OP_##op); \
541	Assert(pCmd->cParams == numpar); \
542	uint8_t pParam = (uint8_t )(pCmd+1); \
543	NOREF(pParam)
544
545	#define OGL_PARAM(Type, par) \
546	Type par; \
547	par = (Type )pParam; \
548	pParam += sizeof(par); \
549	pParam = RT_ALIGN_PT(pParam, VBOX_OGL_CMD_ALIGN, uint8_t *);
550
551	#define OGL_MEMPARAM(Type, par) \
552	PVBOX_OGL_VAR_PARAM pParVal = (PVBOX_OGL_VAR_PARAM)pParam; \
553	Type *par; \
554	VBOX_OGL_CHECK_MAGIC(pParVal); \
555	if (pParVal->cbParam) \
556	par = (Type *)(pParVal+1); \
557	else \
558	par = NULL; \
559	pParam += sizeof(*pParVal) + pParVal->cbParam; \
560	pParam = RT_ALIGN_PT(pParam, VBOX_OGL_CMD_ALIGN, uint8_t *);
561
562	#define OGL_MEMPARAM_NODEF(Type, par) \
563	pParVal = (PVBOX_OGL_VAR_PARAM)pParam; \
564	Type *par; \
565	VBOX_OGL_CHECK_MAGIC(pParVal); \
566	if (pParVal->cbParam) \
567	par = (Type *)(pParVal+1); \
568	else \
569	par = NULL; \
570	pParam += sizeof(*pParVal) + pParVal->cbParam; \
571	pParam = RT_ALIGN_PT(pParam, VBOX_OGL_CMD_ALIGN, uint8_t *);
572
573	#define VBOX_OGL_GEN_OP(op) \
574	OGL_CMD(op, 0); \
575	gl##op();
576
577	#define VBOX_OGL_GEN_OP1(op, Type1) \
578	OGL_CMD(op, 1); \
579	OGL_PARAM(Type1, p1); \
580	gl##op(p1);
581
582	#define VBOX_OGL_GEN_OP2(op, Type1, Type2) \
583	OGL_CMD(op, 2); \
584	OGL_PARAM(Type1, p1); \
585	OGL_PARAM(Type2, p2); \
586	gl##op(p1, p2);
587
588	#define VBOX_OGL_GEN_OP3(op, Type1, Type2, Type3) \
589	OGL_CMD(op, 3); \
590	OGL_PARAM(Type1, p1); \
591	OGL_PARAM(Type2, p2); \
592	OGL_PARAM(Type3, p3); \
593	gl##op(p1, p2, p3);
594
595	#define VBOX_OGL_GEN_OP4(op, Type1, Type2, Type3, Type4) \
596	OGL_CMD(op, 4); \
597	OGL_PARAM(Type1, p1); \
598	OGL_PARAM(Type2, p2); \
599	OGL_PARAM(Type3, p3); \
600	OGL_PARAM(Type4, p4); \
601	gl##op(p1, p2, p3, p4);
602
603	#define VBOX_OGL_GEN_OP5(op, Type1, Type2, Type3, Type4, Type5) \
604	OGL_CMD(op, 5); \
605	OGL_PARAM(Type1, p1); \
606	OGL_PARAM(Type2, p2); \
607	OGL_PARAM(Type3, p3); \
608	OGL_PARAM(Type4, p4); \
609	OGL_PARAM(Type5, p5); \
610	gl##op(p1, p2, p3, p4, p5);
611
612	#define VBOX_OGL_GEN_OP6(op, Type1, Type2, Type3, Type4, Type5, Type6) \
613	OGL_CMD(op, 6); \
614	OGL_PARAM(Type1, p1); \
615	OGL_PARAM(Type2, p2); \
616	OGL_PARAM(Type3, p3); \
617	OGL_PARAM(Type4, p4); \
618	OGL_PARAM(Type5, p5); \
619	OGL_PARAM(Type6, p6); \
620	gl##op(p1, p2, p3, p4, p5, p6);
621
622	#define VBOX_OGL_GEN_OP7(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
623	OGL_CMD(op, 7); \
624	OGL_PARAM(Type1, p1); \
625	OGL_PARAM(Type2, p2); \
626	OGL_PARAM(Type3, p3); \
627	OGL_PARAM(Type4, p4); \
628	OGL_PARAM(Type5, p5); \
629	OGL_PARAM(Type6, p6); \
630	OGL_PARAM(Type7, p7); \
631	gl##op(p1, p2, p3, p4, p5, p6, p7);
632
633	#define VBOX_OGL_GEN_OP8(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8) \
634	OGL_CMD(op, 8); \
635	OGL_PARAM(Type1, p1); \
636	OGL_PARAM(Type2, p2); \
637	OGL_PARAM(Type3, p3); \
638	OGL_PARAM(Type4, p4); \
639	OGL_PARAM(Type5, p5); \
640	OGL_PARAM(Type6, p6); \
641	OGL_PARAM(Type7, p7); \
642	OGL_PARAM(Type8, p8); \
643	gl##op(p1, p2, p3, p4, p5, p6, p7, p8);
644
645
646	/* last parameter is a memory block */
647	#define VBOX_OGL_GEN_OP1PTR(op, Type1) \
648	OGL_CMD(op, 1); \
649	OGL_MEMPARAM(Type1, p1); \
650	gl##op(p1);
651
652	#define VBOX_OGL_GEN_OP2PTR(op, Type1, Type2) \
653	OGL_CMD(op, 2); \
654	OGL_PARAM(Type1, p1); \
655	OGL_MEMPARAM(Type2, p2); \
656	gl##op(p1, p2);
657
658	#define VBOX_OGL_GEN_OP3PTR(op, Type1, Type2, Type3) \
659	OGL_CMD(op, 3); \
660	OGL_PARAM(Type1, p1); \
661	OGL_PARAM(Type2, p2); \
662	OGL_MEMPARAM(Type3, p3); \
663	gl##op(p1, p2, p3);
664
665	#define VBOX_OGL_GEN_OP4PTR(op, Type1, Type2, Type3, Type4) \
666	OGL_CMD(op, 4); \
667	OGL_PARAM(Type1, p1); \
668	OGL_PARAM(Type2, p2); \
669	OGL_PARAM(Type3, p3); \
670	OGL_MEMPARAM(Type4, p4); \
671	gl##op(p1, p2, p3, p4);
672
673	#define VBOX_OGL_GEN_OP5PTR(op, Type1, Type2, Type3, Type4, Type5) \
674	OGL_CMD(op, 5); \
675	OGL_PARAM(Type1, p1); \
676	OGL_PARAM(Type2, p2); \
677	OGL_PARAM(Type3, p3); \
678	OGL_PARAM(Type4, p4); \
679	OGL_MEMPARAM(Type5, p5); \
680	gl##op(p1, p2, p3, p4, p5);
681
682	#define VBOX_OGL_GEN_OP6PTR(op, Type1, Type2, Type3, Type4, Type5, Type6) \
683	OGL_CMD(op, 6); \
684	OGL_PARAM(Type1, p1); \
685	OGL_PARAM(Type2, p2); \
686	OGL_PARAM(Type3, p3); \
687	OGL_PARAM(Type4, p4); \
688	OGL_PARAM(Type5, p5); \
689	OGL_MEMPARAM(Type6, p6); \
690	gl##op(p1, p2, p3, p4, p5, p6);
691
692	#define VBOX_OGL_GEN_OP7PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
693	OGL_CMD(op, 7); \
694	OGL_PARAM(Type1, p1); \
695	OGL_PARAM(Type2, p2); \
696	OGL_PARAM(Type3, p3); \
697	OGL_PARAM(Type4, p4); \
698	OGL_PARAM(Type5, p5); \
699	OGL_PARAM(Type6, p6); \
700	OGL_MEMPARAM(Type7, p7); \
701	gl##op(p1, p2, p3, p4, p5, p6, p7);
702
703	#define VBOX_OGL_GEN_OP8PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8) \
704	OGL_CMD(op, 8); \
705	OGL_PARAM(Type1, p1); \
706	OGL_PARAM(Type2, p2); \
707	OGL_PARAM(Type3, p3); \
708	OGL_PARAM(Type4, p4); \
709	OGL_PARAM(Type5, p5); \
710	OGL_PARAM(Type6, p6); \
711	OGL_PARAM(Type7, p7); \
712	OGL_MEMPARAM(Type8, p8); \
713	gl##op(p1, p2, p3, p4, p5, p6, p7, p8);
714
715	#define VBOX_OGL_GEN_OP9PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9) \
716	OGL_CMD(op, 9); \
717	OGL_PARAM(Type1, p1); \
718	OGL_PARAM(Type2, p2); \
719	OGL_PARAM(Type3, p3); \
720	OGL_PARAM(Type4, p4); \
721	OGL_PARAM(Type5, p5); \
722	OGL_PARAM(Type6, p6); \
723	OGL_PARAM(Type7, p7); \
724	OGL_PARAM(Type8, p8); \
725	OGL_MEMPARAM(Type9, p9); \
726	gl##op(p1, p2, p3, p4, p5, p6, p7, p8 ,p9);
727
728	#define VBOX_OGL_GEN_OP10PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10) \
729	OGL_CMD(op, 10); \
730	OGL_PARAM(Type1, p1); \
731	OGL_PARAM(Type2, p2); \
732	OGL_PARAM(Type3, p3); \
733	OGL_PARAM(Type4, p4); \
734	OGL_PARAM(Type5, p5); \
735	OGL_PARAM(Type6, p6); \
736	OGL_PARAM(Type7, p7); \
737	OGL_PARAM(Type8, p8); \
738	OGL_PARAM(Type9, p9); \
739	OGL_MEMPARAM(Type10, p10); \
740	gl##op(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
741
742
743	/* two memory blocks */
744	#define VBOX_OGL_GEN_OP2PTRPTR(op, Type1, Type2) \
745	OGL_CMD(op, 2); \
746	OGL_MEMPARAM(Type1, p1); \
747	OGL_MEMPARAM_NODEF(Type2, p2); \
748	gl##op(p1, p2);
749
750	#define VBOX_OGL_GEN_OP3PTRPTR(op, Type1, Type2, Type3) \
751	OGL_CMD(op, 3); \
752	OGL_PARAM(Type1, p1); \
753	OGL_MEMPARAM(Type2, p2); \
754	OGL_MEMPARAM_NODEF(Type3, p3); \
755	gl##op(p1, p2, p3);
756
757	/* Note: sync operations always set the last error */
758	/* sync operation that returns a value */
759	#define VBOX_OGL_GEN_SYNC_OP_RET(rettype, op) \
760	OGL_CMD(op, 0); \
761	pClient->lastretval = gl##op();
762
763	#define VBOX_OGL_GEN_SYNC_OP1_RET(rettype, op, Type1) \
764	OGL_CMD(op, 1); \
765	OGL_PARAM(Type1, p1); \
766	pClient->lastretval = gl##op(p1);
767
768	#define VBOX_OGL_GEN_SYNC_OP2_RET(rettype, op, Type1, Type2) \
769	OGL_CMD(op, 2); \
770	OGL_PARAM(Type1, p1); \
771	OGL_PARAM(Type2, p2); \
772	pClient->lastretval = gl##op(p1, p2);
773
774	#define VBOX_OGL_GEN_SYNC_OP3_RET(rettype, op, Type1, Type2, Type3) \
775	OGL_CMD(op, 3); \
776	OGL_PARAM(Type1, p1); \
777	OGL_PARAM(Type2, p2); \
778	OGL_MEMPARAM(Type3, p3); \
779	pClient->lastretval = gl##op(p1, p2, p3);
780
781	#define VBOX_OGL_GEN_SYNC_OP(op) \
782	VBOX_OGL_GEN_OP(op);
783
784	#define VBOX_OGL_GEN_SYNC_OP1(op, p1) \
785	VBOX_OGL_GEN_OP1(op, p1);
786
787	#define VBOX_OGL_GEN_SYNC_OP2(op, p1, p2) \
788	VBOX_OGL_GEN_OP2(op, p1, p2);
789
790
791	/* Sync operation whose last parameter is a block of memory */
792	#define VBOX_OGL_GEN_SYNC_OP2_PTR(op, p1, p2ptr) \
793	VBOX_OGL_GEN_OP2PTR(op, p1, p2ptr);
794
795	#define VBOX_OGL_GEN_SYNC_OP5_PTR(op, p1, p2, p3, p4, p5ptr) \
796	VBOX_OGL_GEN_OP2PTR(op, p1, p2, p3, p4, size, p5ptr);
797
798	#define VBOX_OGL_GEN_SYNC_OP6_PTR(op, p1, p2, p3, p4, p5, p6ptr) \
799	VBOX_OGL_GEN_OP6PTR(op, p1, p2, p3, p4, p5, size, p6ptr);
800
801	#define VBOX_OGL_GEN_SYNC_OP7_PTR(op, p1, p2, p3, p4, p5, p6, p7ptr) \
802	VBOX_OGL_GEN_OP7PTR(op, p1, p2, p3, p4, p5, p6, p7ptr);
803
804
805	/* Sync operation whose last parameter is a block of memory in which results are returned */
806	#define VBOX_OGL_GEN_SYNC_OP1_PASS_PTR(op, Type1) \
807	OGL_CMD(op, 0); \
808	Assert(pClient->pLastParam && pClient->cbLastParam); \
809	gl##op((Type1 *)pClient->pLastParam);
810
811	#define VBOX_OGL_GEN_SYNC_OP2_PASS_PTR(op, Type1, Type2) \
812	OGL_CMD(op, 1); \
813	OGL_PARAM(Type1, p1); \
814	Assert(pClient->pLastParam && pClient->cbLastParam); \
815	gl##op(p1, (Type2 *)pClient->pLastParam);
816
817	#define VBOX_OGL_GEN_SYNC_OP3_PASS_PTR(op, Type1, Type2, Type3) \
818	OGL_CMD(op, 2); \
819	OGL_PARAM(Type1, p1); \
820	OGL_PARAM(Type2, p2); \
821	Assert(pClient->pLastParam && pClient->cbLastParam); \
822	gl##op(p1, p2, (Type3 *)pClient->pLastParam);
823
824	#define VBOX_OGL_GEN_SYNC_OP4_PASS_PTR(op, Type1, Type2, Type3, Type4) \
825	OGL_CMD(op, 3); \
826	OGL_PARAM(Type1, p1); \
827	OGL_PARAM(Type2, p2); \
828	OGL_PARAM(Type3, p3); \
829	Assert(pClient->pLastParam && pClient->cbLastParam); \
830	gl##op(p1, p2, p3, (Type4 *)pClient->pLastParam);
831
832	#define VBOX_OGL_GEN_SYNC_OP5_PASS_PTR(op, Type1, Type2, Type3, Type4, Type5) \
833	OGL_CMD(op, 4); \
834	OGL_PARAM(Type1, p1); \
835	OGL_PARAM(Type2, p2); \
836	OGL_PARAM(Type3, p3); \
837	OGL_PARAM(Type4, p4); \
838	Assert(pClient->pLastParam && pClient->cbLastParam); \
839	gl##op(p1, p2, p3, p4, (Type5 *)pClient->pLastParam);
840
841	#define VBOX_OGL_GEN_SYNC_OP6_PASS_PTR(op, Type1, Type2, Type3, Type4, Type5, Type6) \
842	OGL_CMD(op, 5); \
843	OGL_PARAM(Type1, p1); \
844	OGL_PARAM(Type2, p2); \
845	OGL_PARAM(Type3, p3); \
846	OGL_PARAM(Type4, p4); \
847	OGL_PARAM(Type5, p5); \
848	Assert(pClient->pLastParam && pClient->cbLastParam); \
849	gl##op(p1, p2, p3, p4, p5, (Type6 *)pClient->pLastParam);
850
851	#define VBOX_OGL_GEN_SYNC_OP7_PASS_PTR(op, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
852	OGL_CMD(op, 6); \
853	OGL_PARAM(Type1, p1); \
854	OGL_PARAM(Type2, p2); \
855	OGL_PARAM(Type3, p3); \
856	OGL_PARAM(Type4, p4); \
857	OGL_PARAM(Type5, p5); \
858	OGL_PARAM(Type6, p6); \
859	Assert(pClient->pLastParam && pClient->cbLastParam); \
860	gl##op(p1, p2, p3, p4, p5, p6, (Type7 *)pClient->pLastParam);
861
862
863	/* Sync operation whose last parameter is a block of memory and returns a value */
864	#define VBOX_OGL_GEN_SYNC_OP2_PTR_RET(rettype, op, Type1, Type2) \
865	OGL_CMD(op, 2); \
866	OGL_PARAM(Type1, p1); \
867	OGL_MEMPARAM(Type2, p2); \
868	pClient->lastretval = gl##op(p1);
869
870	#define VBOX_OGL_GEN_SYNC_OP4_PTR_RET(rettype, op, Type1, Type2, Type3, Type4) \
871	OGL_CMD(op, 4); \
872	OGL_PARAM(Type1, p1); \
873	OGL_PARAM(Type2, p2); \
874	OGL_PARAM(Type3, p3); \
875	OGL_MEMPARAM(Type4, p4); \
876	pClient->lastretval = gl##op(p1, p2, p3, p4);
877
878	#define VBOX_OGL_GEN_SYNC_OP5_PTR_RET(rettype, op, Type1, Type2, Type3, Type4, Type5) \
879	OGL_CMD(op, 5); \
880	OGL_PARAM(Type1, p1); \
881	OGL_PARAM(Type2, p2); \
882	OGL_PARAM(Type3, p3); \
883	OGL_PARAM(Type4, p4); \
884	OGL_MEMPARAM(Type5, p5); \
885	pClient->lastretval = gl##op(p1, p2, p3, p4, p5);
886
887	#define VBOX_OGL_GEN_SYNC_OP6_PTR_RET(rettype, op, Type1, Type2, Type3, Type4, Type5, Type6) \
888	OGL_CMD(op, 6); \
889	OGL_PARAM(Type1, p1); \
890	OGL_PARAM(Type2, p2); \
891	OGL_PARAM(Type3, p3); \
892	OGL_PARAM(Type4, p4); \
893	OGL_PARAM(Type5, p5); \
894	OGL_MEMPARAM(Type6, p6); \
895	pClient->lastretval = gl##op(p1, p2, p3, p4, p5, p6);
896
897	#define VBOX_OGL_GEN_SYNC_OP7_PTR_RET(rettype, op, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
898	OGL_CMD(op, 7); \
899	OGL_PARAM(Type1, p1); \
900	OGL_PARAM(Type2, p2); \
901	OGL_PARAM(Type3, p3); \
902	OGL_PARAM(Type4, p4); \
903	OGL_PARAM(Type5, p5); \
904	OGL_PARAM(Type6, p6); \
905	OGL_MEMPARAM(Type7, p7); \
906	pClient->lastretval = gl##op(p1, p2, p3, p4, p5, p6, p7);
907
908
909
910
911
912	/* Generate async functions elements in the command queue */
913	#define GL_GEN_FUNC(Function) \
914	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
915	{ \
916	VBOX_OGL_GEN_OP(Function); \
917	}
918
919	#define GL_GEN_FUNC1(Function, Type) \
920	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
921	{ \
922	VBOX_OGL_GEN_OP1(Function, Type); \
923	}
924
925	#define GL_GEN_FUNC1V(Function, Type) GL_GEN_FUNC1(Function, Type)
926
927	#define GL_GEN_FUNC2(Function, Type) \
928	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
929	{ \
930	VBOX_OGL_GEN_OP2(Function, Type, Type); \
931	}
932
933	#define GL_GEN_FUNC2V(Function, Type) GL_GEN_FUNC2(Function, Type)
934
935	#define GL_GEN_FUNC3(Function, Type) \
936	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
937	{ \
938	VBOX_OGL_GEN_OP3(Function, Type, Type, Type); \
939	}
940
941	#define GL_GEN_FUNC3V(Function, Type) GL_GEN_FUNC3(Function, Type)
942
943	#define GL_GEN_FUNC4(Function, Type) \
944	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
945	{ \
946	VBOX_OGL_GEN_OP4(Function, Type, Type, Type, Type); \
947	}
948
949	#define GL_GEN_FUNC4V(Function, Type) GL_GEN_FUNC4(Function, Type)
950
951	#define GL_GEN_FUNC6(Function, Type) \
952	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
953	{ \
954	VBOX_OGL_GEN_OP6(Function, Type, Type, Type, Type, Type, Type); \
955	}
956
957	#define GL_GEN_VPAR_FUNC2(Function, Type1, Type2) \
958	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
959	{ \
960	VBOX_OGL_GEN_OP2(Function, Type1, Type2); \
961	}
962
963	#define GL_GEN_VPAR_FUNC2V(Function, Type) GL_GEN_VPAR_FUNC2(Function, Type)
964
965	#define GL_GEN_VPAR_FUNC3(Function, Type1, Type2, Type3) \
966	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
967	{ \
968	VBOX_OGL_GEN_OP3(Function, Type1, Type2, Type3); \
969	}
970
971	#define GL_GEN_VPAR_FUNC3V(Function, Type) GL_GEN_VPAR_FUNC3(Function, Type)
972
973	#define GL_GEN_VPAR_FUNC4(Function, Type1, Type2, Type3, Type4) \
974	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
975	{ \
976	VBOX_OGL_GEN_OP4(Function, Type1, Type2, Type3, Type4); \
977	}
978
979	#define GL_GEN_VPAR_FUNC5(Function, Type1, Type2, Type3, Type4, Type5) \
980	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
981	{ \
982	VBOX_OGL_GEN_OP5(Function, Type1, Type2, Type3, Type4 ,Type5); \
983	}
984
985	#define GL_GEN_VPAR_FUNC6(Function, Type1, Type2, Type3, Type4, Type5, Type6) \
986	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
987	{ \
988	VBOX_OGL_GEN_OP6(Function, Type1, Type2, Type3, Type4 ,Type5, Type6); \
989	}
990
991	#define GL_GEN_VPAR_FUNC7(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7) \
992	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
993	{ \
994	VBOX_OGL_GEN_OP7(Function, Type1, Type2, Type3, Type4 ,Type5, Type6, Type7); \
995	}
996
997	#define GL_GEN_VPAR_FUNC8(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8) \
998	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
999	{ \
1000	VBOX_OGL_GEN_OP8(Function, Type1, Type2, Type3, Type4 ,Type5, Type6, Type7, Type8); \
1001	}
1002
1003	#define GL_GEN_VPAR_FUNC9(Function, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8 ,Type9) \
1004	void VBOX_OGL_NAME_PREFIX(Function) (VBOXOGLCTX pClient, uint8_t pCmdBuffer) \
1005	{ \
1006	VBOX_OGL_GEN_OP9(Function, Type1, Type2, Type3, Type4 ,Type5, Type6, Type7, Type8, Type9); \
1007	}
1008
1009	#endif /* VBOX_OGL_HOST_SIDE */
1010
1011
1012
1013
1014	/* OpenGL opcodes */
1015	/* Note: keep all three tables in sync! */
1016	typedef enum
1017	{
1018	VBOX_OGL_OP_Illegal = 0,
1019	VBOX_OGL_OP_ArrayElement,
1020	VBOX_OGL_OP_Begin,
1021	VBOX_OGL_OP_BindTexture,
1022	VBOX_OGL_OP_BlendFunc,
1023	VBOX_OGL_OP_CallList,
1024	VBOX_OGL_OP_Color3b,
1025	VBOX_OGL_OP_Color3d,
1026	VBOX_OGL_OP_Color3f,
1027	VBOX_OGL_OP_Color3i,
1028	VBOX_OGL_OP_Color3s,
1029	VBOX_OGL_OP_Color3ub,
1030	VBOX_OGL_OP_Color3ui,
1031	VBOX_OGL_OP_Color3us,
1032	VBOX_OGL_OP_Color4b,
1033	VBOX_OGL_OP_Color4d,
1034	VBOX_OGL_OP_Color4f,
1035	VBOX_OGL_OP_Color4i,
1036	VBOX_OGL_OP_Color4s,
1037	VBOX_OGL_OP_Color4ub,
1038	VBOX_OGL_OP_Color4ui,
1039	VBOX_OGL_OP_Color4us,
1040	VBOX_OGL_OP_Clear,
1041	VBOX_OGL_OP_ClearAccum,
1042	VBOX_OGL_OP_ClearColor,
1043	VBOX_OGL_OP_ClearDepth,
1044	VBOX_OGL_OP_ClearIndex,
1045	VBOX_OGL_OP_ClearStencil,
1046	VBOX_OGL_OP_Accum,
1047	VBOX_OGL_OP_AlphaFunc,
1048	VBOX_OGL_OP_Vertex2d,
1049	VBOX_OGL_OP_Vertex2f,
1050	VBOX_OGL_OP_Vertex2i,
1051	VBOX_OGL_OP_Vertex2s,
1052	VBOX_OGL_OP_Vertex3d,
1053	VBOX_OGL_OP_Vertex3f,
1054	VBOX_OGL_OP_Vertex3i,
1055	VBOX_OGL_OP_Vertex3s,
1056	VBOX_OGL_OP_Vertex4d,
1057	VBOX_OGL_OP_Vertex4f,
1058	VBOX_OGL_OP_Vertex4i,
1059	VBOX_OGL_OP_Vertex4s,
1060	VBOX_OGL_OP_TexCoord1d,
1061	VBOX_OGL_OP_TexCoord1f,
1062	VBOX_OGL_OP_TexCoord1i,
1063	VBOX_OGL_OP_TexCoord1s,
1064	VBOX_OGL_OP_TexCoord2d,
1065	VBOX_OGL_OP_TexCoord2f,
1066	VBOX_OGL_OP_TexCoord2i,
1067	VBOX_OGL_OP_TexCoord2s,
1068	VBOX_OGL_OP_TexCoord3d,
1069	VBOX_OGL_OP_TexCoord3f,
1070	VBOX_OGL_OP_TexCoord3i,
1071	VBOX_OGL_OP_TexCoord3s,
1072	VBOX_OGL_OP_TexCoord4d,
1073	VBOX_OGL_OP_TexCoord4f,
1074	VBOX_OGL_OP_TexCoord4i,
1075	VBOX_OGL_OP_TexCoord4s,
1076	VBOX_OGL_OP_Normal3b,
1077	VBOX_OGL_OP_Normal3d,
1078	VBOX_OGL_OP_Normal3f,
1079	VBOX_OGL_OP_Normal3i,
1080	VBOX_OGL_OP_Normal3s,
1081	VBOX_OGL_OP_RasterPos2d,
1082	VBOX_OGL_OP_RasterPos2f,
1083	VBOX_OGL_OP_RasterPos2i,
1084	VBOX_OGL_OP_RasterPos2s,
1085	VBOX_OGL_OP_RasterPos3d,
1086	VBOX_OGL_OP_RasterPos3f,
1087	VBOX_OGL_OP_RasterPos3i,
1088	VBOX_OGL_OP_RasterPos3s,
1089	VBOX_OGL_OP_RasterPos4d,
1090	VBOX_OGL_OP_RasterPos4f,
1091	VBOX_OGL_OP_RasterPos4i,
1092	VBOX_OGL_OP_RasterPos4s,
1093	VBOX_OGL_OP_EvalCoord1d,
1094	VBOX_OGL_OP_EvalCoord1f,
1095	VBOX_OGL_OP_EvalCoord2d,
1096	VBOX_OGL_OP_EvalCoord2f,
1097	VBOX_OGL_OP_EvalPoint1,
1098	VBOX_OGL_OP_EvalPoint2,
1099	VBOX_OGL_OP_Indexd,
1100	VBOX_OGL_OP_Indexf,
1101	VBOX_OGL_OP_Indexi,
1102	VBOX_OGL_OP_Indexs,
1103	VBOX_OGL_OP_Indexub,
1104	VBOX_OGL_OP_Rotated,
1105	VBOX_OGL_OP_Rotatef,
1106	VBOX_OGL_OP_Scaled,
1107	VBOX_OGL_OP_Scalef,
1108	VBOX_OGL_OP_Translated,
1109	VBOX_OGL_OP_Translatef,
1110	VBOX_OGL_OP_DepthFunc,
1111	VBOX_OGL_OP_DepthMask,
1112	VBOX_OGL_OP_Finish,
1113	VBOX_OGL_OP_Flush,
1114	VBOX_OGL_OP_DeleteLists,
1115	VBOX_OGL_OP_CullFace,
1116	VBOX_OGL_OP_DeleteTextures,
1117	VBOX_OGL_OP_DepthRange,
1118	VBOX_OGL_OP_DisableClientState,
1119	VBOX_OGL_OP_EnableClientState,
1120	VBOX_OGL_OP_EvalMesh1,
1121	VBOX_OGL_OP_EvalMesh2,
1122	VBOX_OGL_OP_Fogf,
1123	VBOX_OGL_OP_Fogfv,
1124	VBOX_OGL_OP_Fogi,
1125	VBOX_OGL_OP_Fogiv,
1126	VBOX_OGL_OP_LightModelf,
1127	VBOX_OGL_OP_LightModelfv,
1128	VBOX_OGL_OP_LightModeli,
1129	VBOX_OGL_OP_LightModeliv,
1130	VBOX_OGL_OP_Lightf,
1131	VBOX_OGL_OP_Lightfv,
1132	VBOX_OGL_OP_Lighti,
1133	VBOX_OGL_OP_Lightiv,
1134	VBOX_OGL_OP_LineStipple,
1135	VBOX_OGL_OP_LineWidth,
1136	VBOX_OGL_OP_ListBase,
1137	VBOX_OGL_OP_DrawArrays,
1138	VBOX_OGL_OP_DrawBuffer,
1139	VBOX_OGL_OP_EdgeFlag,
1140	VBOX_OGL_OP_End,
1141	VBOX_OGL_OP_EndList,
1142	VBOX_OGL_OP_CopyTexImage1D,
1143	VBOX_OGL_OP_CopyTexImage2D,
1144	VBOX_OGL_OP_ColorMaterial,
1145	VBOX_OGL_OP_Materiali,
1146	VBOX_OGL_OP_Materialf,
1147	VBOX_OGL_OP_Materialfv,
1148	VBOX_OGL_OP_Materialiv,
1149	VBOX_OGL_OP_PopAttrib,
1150	VBOX_OGL_OP_PopClientAttrib,
1151	VBOX_OGL_OP_PopMatrix,
1152	VBOX_OGL_OP_PopName,
1153	VBOX_OGL_OP_PushAttrib,
1154	VBOX_OGL_OP_PushClientAttrib,
1155	VBOX_OGL_OP_PushMatrix,
1156	VBOX_OGL_OP_PushName,
1157	VBOX_OGL_OP_ReadBuffer,
1158	VBOX_OGL_OP_TexGendv,
1159	VBOX_OGL_OP_TexGenf,
1160	VBOX_OGL_OP_TexGend,
1161	VBOX_OGL_OP_TexGeni,
1162	VBOX_OGL_OP_TexEnvi,
1163	VBOX_OGL_OP_TexEnvf,
1164	VBOX_OGL_OP_TexEnviv,
1165	VBOX_OGL_OP_TexEnvfv,
1166	VBOX_OGL_OP_TexGeniv,
1167	VBOX_OGL_OP_TexGenfv,
1168	VBOX_OGL_OP_TexParameterf,
1169	VBOX_OGL_OP_TexParameteri,
1170	VBOX_OGL_OP_TexParameterfv,
1171	VBOX_OGL_OP_TexParameteriv,
1172	VBOX_OGL_OP_LoadIdentity,
1173	VBOX_OGL_OP_LoadName,
1174	VBOX_OGL_OP_LoadMatrixd,
1175	VBOX_OGL_OP_LoadMatrixf,
1176	VBOX_OGL_OP_StencilFunc,
1177	VBOX_OGL_OP_ShadeModel,
1178	VBOX_OGL_OP_StencilMask,
1179	VBOX_OGL_OP_StencilOp,
1180	VBOX_OGL_OP_Scissor,
1181	VBOX_OGL_OP_Viewport,
1182	VBOX_OGL_OP_Rectd,
1183	VBOX_OGL_OP_Rectf,
1184	VBOX_OGL_OP_Recti,
1185	VBOX_OGL_OP_Rects,
1186	VBOX_OGL_OP_Rectdv,
1187	VBOX_OGL_OP_Rectfv,
1188	VBOX_OGL_OP_Rectiv,
1189	VBOX_OGL_OP_Rectsv,
1190	VBOX_OGL_OP_MultMatrixd,
1191	VBOX_OGL_OP_MultMatrixf,
1192	VBOX_OGL_OP_NewList,
1193	VBOX_OGL_OP_Hint,
1194	VBOX_OGL_OP_IndexMask,
1195	VBOX_OGL_OP_InitNames,
1196	VBOX_OGL_OP_TexCoordPointer,
1197	VBOX_OGL_OP_VertexPointer,
1198	VBOX_OGL_OP_ColorPointer,
1199	VBOX_OGL_OP_EdgeFlagPointer,
1200	VBOX_OGL_OP_IndexPointer,
1201	VBOX_OGL_OP_NormalPointer,
1202	VBOX_OGL_OP_PolygonStipple,
1203	VBOX_OGL_OP_CallLists,
1204	VBOX_OGL_OP_ClipPlane,
1205	VBOX_OGL_OP_Frustum,
1206	VBOX_OGL_OP_GenTextures,
1207	VBOX_OGL_OP_Map1d,
1208	VBOX_OGL_OP_Map1f,
1209	VBOX_OGL_OP_Map2d,
1210	VBOX_OGL_OP_Map2f,
1211	VBOX_OGL_OP_MapGrid1d,
1212	VBOX_OGL_OP_MapGrid1f,
1213	VBOX_OGL_OP_MapGrid2d,
1214	VBOX_OGL_OP_MapGrid2f,
1215	VBOX_OGL_OP_CopyPixels,
1216	VBOX_OGL_OP_TexImage1D,
1217	VBOX_OGL_OP_TexImage2D,
1218	VBOX_OGL_OP_TexSubImage1D,
1219	VBOX_OGL_OP_TexSubImage2D,
1220	VBOX_OGL_OP_FeedbackBuffer,
1221	VBOX_OGL_OP_SelectBuffer,
1222	VBOX_OGL_OP_IsList,
1223	VBOX_OGL_OP_IsTexture,
1224	VBOX_OGL_OP_RenderMode,
1225	VBOX_OGL_OP_ReadPixels,
1226	VBOX_OGL_OP_IsEnabled,
1227	VBOX_OGL_OP_GenLists,
1228	VBOX_OGL_OP_PixelTransferf,
1229	VBOX_OGL_OP_PixelTransferi,
1230	VBOX_OGL_OP_PixelZoom,
1231	VBOX_OGL_OP_PixelStorei,
1232	VBOX_OGL_OP_PixelStoref,
1233	VBOX_OGL_OP_PixelMapfv,
1234	VBOX_OGL_OP_PixelMapuiv,
1235	VBOX_OGL_OP_PixelMapusv,
1236	VBOX_OGL_OP_PointSize,
1237	VBOX_OGL_OP_PolygonMode,
1238	VBOX_OGL_OP_PolygonOffset,
1239	VBOX_OGL_OP_PassThrough,
1240	VBOX_OGL_OP_Ortho,
1241	VBOX_OGL_OP_MatrixMode,
1242	VBOX_OGL_OP_LogicOp,
1243	VBOX_OGL_OP_ColorMask,
1244	VBOX_OGL_OP_CopyTexSubImage1D,
1245	VBOX_OGL_OP_CopyTexSubImage2D,
1246	VBOX_OGL_OP_FrontFace,
1247	VBOX_OGL_OP_Disable,
1248	VBOX_OGL_OP_Enable,
1249	VBOX_OGL_OP_PrioritizeTextures,
1250	VBOX_OGL_OP_GetBooleanv,
1251	VBOX_OGL_OP_GetDoublev,
1252	VBOX_OGL_OP_GetFloatv,
1253	VBOX_OGL_OP_GetIntegerv,
1254	VBOX_OGL_OP_GetLightfv,
1255	VBOX_OGL_OP_GetLightiv,
1256	VBOX_OGL_OP_GetMaterialfv,
1257	VBOX_OGL_OP_GetMaterialiv,
1258	VBOX_OGL_OP_GetPixelMapfv,
1259	VBOX_OGL_OP_GetPixelMapuiv,
1260	VBOX_OGL_OP_GetPixelMapusv,
1261	VBOX_OGL_OP_GetTexEnviv,
1262	VBOX_OGL_OP_GetTexEnvfv,
1263	VBOX_OGL_OP_GetTexGendv,
1264	VBOX_OGL_OP_GetTexGenfv,
1265	VBOX_OGL_OP_GetTexGeniv,
1266	VBOX_OGL_OP_GetTexParameterfv,
1267	VBOX_OGL_OP_GetTexParameteriv,
1268	VBOX_OGL_OP_GetClipPlane,
1269	VBOX_OGL_OP_GetPolygonStipple,
1270	VBOX_OGL_OP_GetTexLevelParameterfv,
1271	VBOX_OGL_OP_GetTexLevelParameteriv,
1272	VBOX_OGL_OP_GetTexImage,
1273
1274	/* Windows ICD exports */
1275	VBOX_OGL_OP_DrvReleaseContext,
1276	VBOX_OGL_OP_DrvCreateContext,
1277	VBOX_OGL_OP_DrvDeleteContext,
1278	VBOX_OGL_OP_DrvCopyContext,
1279	VBOX_OGL_OP_DrvSetContext,
1280	VBOX_OGL_OP_DrvCreateLayerContext,
1281	VBOX_OGL_OP_DrvShareLists,
1282	VBOX_OGL_OP_DrvDescribeLayerPlane,
1283	VBOX_OGL_OP_DrvSetLayerPaletteEntries,
1284	VBOX_OGL_OP_DrvGetLayerPaletteEntries,
1285	VBOX_OGL_OP_DrvRealizeLayerPalette,
1286	VBOX_OGL_OP_DrvSwapLayerBuffers,
1287	VBOX_OGL_OP_DrvDescribePixelFormat,
1288	VBOX_OGL_OP_DrvSetPixelFormat,
1289	VBOX_OGL_OP_DrvSwapBuffers,
1290
1291	/* OpenGL Extensions */
1292	VBOX_OGL_OP_wglSwapIntervalEXT,
1293	VBOX_OGL_OP_wglGetSwapIntervalEXT,
1294
1295	VBOX_OGL_OP_Last,
1296
1297	VBOX_OGL_OP_SizeHack = 0x7fffffff
1298	} VBOX_OGL_OP;
1299
1300	#if defined(DEBUG) && defined(VBOX_OGL_WITH_CMD_STRINGS)
1301	static const char *pszVBoxOGLCmd[VBOX_OGL_OP_Last] =
1302	{
1303	"ILLEGAL",
1304	"glArrayElement",
1305	"glBegin",
1306	"glBindTexture",
1307	"glBlendFunc",
1308	"glCallList",
1309	"glColor3b",
1310	"glColor3d",
1311	"glColor3f",
1312	"glColor3i",
1313	"glColor3s",
1314	"glColor3ub",
1315	"glColor3ui",
1316	"glColor3us",
1317	"glColor4b",
1318	"glColor4d",
1319	"glColor4f",
1320	"glColor4i",
1321	"glColor4s",
1322	"glColor4ub",
1323	"glColor4ui",
1324	"glColor4us",
1325	"glClear",
1326	"glClearAccum",
1327	"glClearColor",
1328	"glClearDepth",
1329	"glClearIndex",
1330	"glClearStencil",
1331	"glAccum",
1332	"glAlphaFunc",
1333	"glVertex2d",
1334	"glVertex2f",
1335	"glVertex2i",
1336	"glVertex2s",
1337	"glVertex3d",
1338	"glVertex3f",
1339	"glVertex3i",
1340	"glVertex3s",
1341	"glVertex4d",
1342	"glVertex4f",
1343	"glVertex4i",
1344	"glVertex4s",
1345	"glTexCoord1d",
1346	"glTexCoord1f",
1347	"glTexCoord1i",
1348	"glTexCoord1s",
1349	"glTexCoord2d",
1350	"glTexCoord2f",
1351	"glTexCoord2i",
1352	"glTexCoord2s",
1353	"glTexCoord3d",
1354	"glTexCoord3f",
1355	"glTexCoord3i",
1356	"glTexCoord3s",
1357	"glTexCoord4d",
1358	"glTexCoord4f",
1359	"glTexCoord4i",
1360	"glTexCoord4s",
1361	"glNormal3b",
1362	"glNormal3d",
1363	"glNormal3f",
1364	"glNormal3i",
1365	"glNormal3s",
1366	"glRasterPos2d",
1367	"glRasterPos2f",
1368	"glRasterPos2i",
1369	"glRasterPos2s",
1370	"glRasterPos3d",
1371	"glRasterPos3f",
1372	"glRasterPos3i",
1373	"glRasterPos3s",
1374	"glRasterPos4d",
1375	"glRasterPos4f",
1376	"glRasterPos4i",
1377	"glRasterPos4s",
1378	"glEvalCoord1d",
1379	"glEvalCoord1f",
1380	"glEvalCoord2d",
1381	"glEvalCoord2f",
1382	"glEvalPoint1",
1383	"glEvalPoint2",
1384	"glIndexd",
1385	"glIndexf",
1386	"glIndexi",
1387	"glIndexs",
1388	"glIndexub",
1389	"glRotated",
1390	"glRotatef",
1391	"glScaled",
1392	"glScalef",
1393	"glTranslated",
1394	"glTranslatef",
1395	"glDepthFunc",
1396	"glDepthMask",
1397	"glFinish",
1398	"glFlush",
1399	"glDeleteLists",
1400	"glCullFace",
1401	"glDeleteTextures",
1402	"glDepthRange",
1403	"glDisableClientState",
1404	"glEnableClientState",
1405	"glEvalMesh1",
1406	"glEvalMesh2",
1407	"glFogf",
1408	"glFogfv",
1409	"glFogi",
1410	"glFogiv",
1411	"glLightModelf",
1412	"glLightModelfv",
1413	"glLightModeli",
1414	"glLightModeliv",
1415	"glLightf",
1416	"glLightfv",
1417	"glLighti",
1418	"glLightiv",
1419	"glLineStipple",
1420	"glLineWidth",
1421	"glListBase",
1422	"glDrawArrays",
1423	"glDrawBuffer",
1424	"glEdgeFlag",
1425	"glEnd",
1426	"glEndList",
1427	"glCopyTexImage1D",
1428	"glCopyTexImage2D",
1429	"glColorMaterial",
1430	"glMateriali",
1431	"glMaterialf",
1432	"glMaterialfv",
1433	"glMaterialiv",
1434	"glPopAttrib",
1435	"glPopClientAttrib",
1436	"glPopMatrix",
1437	"glPopName",
1438	"glPushAttrib",
1439	"glPushClientAttrib",
1440	"glPushMatrix",
1441	"glPushName",
1442	"glReadBuffer",
1443	"glTexGendv",
1444	"glTexGenf",
1445	"glTexGend",
1446	"glTexGeni",
1447	"glTexEnvi",
1448	"glTexEnvf",
1449	"glTexEnviv",
1450	"glTexEnvfv",
1451	"glTexGeniv",
1452	"glTexGenfv",
1453	"glTexParameterf",
1454	"glTexParameteri",
1455	"glTexParameterfv",
1456	"glTexParameteriv",
1457	"glLoadIdentity",
1458	"glLoadName",
1459	"glLoadMatrixd",
1460	"glLoadMatrixf",
1461	"glStencilFunc",
1462	"glShadeModel",
1463	"glStencilMask",
1464	"glStencilOp",
1465	"glScissor",
1466	"glViewport",
1467	"glRectd",
1468	"glRectf",
1469	"glRecti",
1470	"glRects",
1471	"glRectdv",
1472	"glRectfv",
1473	"glRectiv",
1474	"glRectsv",
1475	"glMultMatrixd",
1476	"glMultMatrixf",
1477	"glNewList",
1478	"glHint",
1479	"glIndexMask",
1480	"glInitNames",
1481	"glTexCoordPointer",
1482	"glVertexPointer",
1483	"glColorPointer",
1484	"glEdgeFlagPointer",
1485	"glIndexPointer",
1486	"glNormalPointer",
1487	"glPolygonStipple",
1488	"glCallLists",
1489	"glClipPlane",
1490	"glFrustum",
1491	"glGenTextures",
1492	"glMap1d",
1493	"glMap1f",
1494	"glMap2d",
1495	"glMap2f",
1496	"glMapGrid1d",
1497	"glMapGrid1f",
1498	"glMapGrid2d",
1499	"glMapGrid2f",
1500	"glCopyPixels",
1501	"glTexImage1D",
1502	"glTexImage2D",
1503	"glTexSubImage1D",
1504	"glTexSubImage2D",
1505	"glFeedbackBuffer",
1506	"glSelectBuffer",
1507	"glIsList",
1508	"glIsTexture",
1509	"glRenderMode",
1510	"glReadPixels",
1511	"glIsEnabled",
1512	"glGenLists",
1513	"glPixelTransferf",
1514	"glPixelTransferi",
1515	"glPixelZoom",
1516	"glPixelStorei",
1517	"glPixelStoref",
1518	"glPixelMapfv",
1519	"glPixelMapuiv",
1520	"glPixelMapusv",
1521	"glPointSize",
1522	"glPolygonMode",
1523	"glPolygonOffset",
1524	"glPassThrough",
1525	"glOrtho",
1526	"glMatrixMode",
1527	"glLogicOp",
1528	"glColorMask",
1529	"glCopyTexSubImage1D",
1530	"glCopyTexSubImage2D",
1531	"glFrontFace",
1532	"glDisable",
1533	"glEnable",
1534	"glPrioritizeTextures",
1535	"glGetBooleanv",
1536	"glGetDoublev",
1537	"glGetFloatv",
1538	"glGetIntegerv",
1539	"glGetLightfv",
1540	"glGetLightiv",
1541	"glGetMaterialfv",
1542	"glGetMaterialiv",
1543	"glGetPixelMapfv",
1544	"glGetPixelMapuiv",
1545	"glGetPixelMapusv",
1546	"glGetTexEnviv",
1547	"glGetTexEnvfv",
1548	"glGetTexGendv",
1549	"glGetTexGenfv",
1550	"glGetTexGeniv",
1551	"glGetTexParameterfv",
1552	"glGetTexParameteriv",
1553	"glGetClipPlane",
1554	"glGetPolygonStipple",
1555	"glGetTexLevelParameterfv",
1556	"glGetTexLevelParameteriv",
1557	"glGetTexImage",
1558
1559	/* Windows ICD exports */
1560	"DrvReleaseContext",
1561	"DrvCreateContext",
1562	"DrvDeleteContext",
1563	"DrvCopyContext",
1564	"DrvSetContext",
1565	"DrvCreateLayerContext",
1566	"DrvShareLists",
1567	"DrvDescribeLayerPlane",
1568	"DrvSetLayerPaletteEntries",
1569	"DrvGetLayerPaletteEntries",
1570	"DrvRealizeLayerPalette",
1571	"DrvSwapLayerBuffers",
1572	"DrvDescribePixelFormat",
1573	"DrvSetPixelFormat",
1574	"DrvSwapBuffers",
1575
1576	/* OpenGL Extensions */
1577	"wglSwapIntervalEXT",
1578	"wglGetSwapIntervalEXT",
1579	};
1580	#endif
1581
1582	#ifdef VBOX_OGL_WITH_FUNCTION_WRAPPERS
1583	/* OpenGL function wrappers. */
1584	static PFN_VBOXGLWRAPPER pfnOGLWrapper[VBOX_OGL_OP_Last] =
1585	{
1586	NULL,
1587	vboxglArrayElement,
1588	vboxglBegin,
1589	vboxglBindTexture,
1590	vboxglBlendFunc,
1591	vboxglCallList,
1592	vboxglColor3b,
1593	vboxglColor3d,
1594	vboxglColor3f,
1595	vboxglColor3i,
1596	vboxglColor3s,
1597	vboxglColor3ub,
1598	vboxglColor3ui,
1599	vboxglColor3us,
1600	vboxglColor4b,
1601	vboxglColor4d,
1602	vboxglColor4f,
1603	vboxglColor4i,
1604	vboxglColor4s,
1605	vboxglColor4ub,
1606	vboxglColor4ui,
1607	vboxglColor4us,
1608	vboxglClear,
1609	vboxglClearAccum,
1610	vboxglClearColor,
1611	vboxglClearDepth,
1612	vboxglClearIndex,
1613	vboxglClearStencil,
1614	vboxglAccum,
1615	vboxglAlphaFunc,
1616	vboxglVertex2d,
1617	vboxglVertex2f,
1618	vboxglVertex2i,
1619	vboxglVertex2s,
1620	vboxglVertex3d,
1621	vboxglVertex3f,
1622	vboxglVertex3i,
1623	vboxglVertex3s,
1624	vboxglVertex4d,
1625	vboxglVertex4f,
1626	vboxglVertex4i,
1627	vboxglVertex4s,
1628	vboxglTexCoord1d,
1629	vboxglTexCoord1f,
1630	vboxglTexCoord1i,
1631	vboxglTexCoord1s,
1632	vboxglTexCoord2d,
1633	vboxglTexCoord2f,
1634	vboxglTexCoord2i,
1635	vboxglTexCoord2s,
1636	vboxglTexCoord3d,
1637	vboxglTexCoord3f,
1638	vboxglTexCoord3i,
1639	vboxglTexCoord3s,
1640	vboxglTexCoord4d,
1641	vboxglTexCoord4f,
1642	vboxglTexCoord4i,
1643	vboxglTexCoord4s,
1644	vboxglNormal3b,
1645	vboxglNormal3d,
1646	vboxglNormal3f,
1647	vboxglNormal3i,
1648	vboxglNormal3s,
1649	vboxglRasterPos2d,
1650	vboxglRasterPos2f,
1651	vboxglRasterPos2i,
1652	vboxglRasterPos2s,
1653	vboxglRasterPos3d,
1654	vboxglRasterPos3f,
1655	vboxglRasterPos3i,
1656	vboxglRasterPos3s,
1657	vboxglRasterPos4d,
1658	vboxglRasterPos4f,
1659	vboxglRasterPos4i,
1660	vboxglRasterPos4s,
1661	vboxglEvalCoord1d,
1662	vboxglEvalCoord1f,
1663	vboxglEvalCoord2d,
1664	vboxglEvalCoord2f,
1665	vboxglEvalPoint1,
1666	vboxglEvalPoint2,
1667	vboxglIndexd,
1668	vboxglIndexf,
1669	vboxglIndexi,
1670	vboxglIndexs,
1671	vboxglIndexub,
1672	vboxglRotated,
1673	vboxglRotatef,
1674	vboxglScaled,
1675	vboxglScalef,
1676	vboxglTranslated,
1677	vboxglTranslatef,
1678	vboxglDepthFunc,
1679	vboxglDepthMask,
1680	vboxglFinish,
1681	vboxglFlush,
1682	vboxglDeleteLists,
1683	vboxglCullFace,
1684	vboxglDeleteTextures,
1685	vboxglDepthRange,
1686	vboxglDisableClientState,
1687	vboxglEnableClientState,
1688	vboxglEvalMesh1,
1689	vboxglEvalMesh2,
1690	vboxglFogf,
1691	vboxglFogfv,
1692	vboxglFogi,
1693	vboxglFogiv,
1694	vboxglLightModelf,
1695	vboxglLightModelfv,
1696	vboxglLightModeli,
1697	vboxglLightModeliv,
1698	vboxglLightf,
1699	vboxglLightfv,
1700	vboxglLighti,
1701	vboxglLightiv,
1702	vboxglLineStipple,
1703	vboxglLineWidth,
1704	vboxglListBase,
1705	vboxglDrawArrays,
1706	vboxglDrawBuffer,
1707	vboxglEdgeFlag,
1708	vboxglEnd,
1709	vboxglEndList,
1710	vboxglCopyTexImage1D,
1711	vboxglCopyTexImage2D,
1712	vboxglColorMaterial,
1713	vboxglMateriali,
1714	vboxglMaterialf,
1715	vboxglMaterialfv,
1716	vboxglMaterialiv,
1717	vboxglPopAttrib,
1718	vboxglPopClientAttrib,
1719	vboxglPopMatrix,
1720	vboxglPopName,
1721	vboxglPushAttrib,
1722	vboxglPushClientAttrib,
1723	vboxglPushMatrix,
1724	vboxglPushName,
1725	vboxglReadBuffer,
1726	vboxglTexGendv,
1727	vboxglTexGenf,
1728	vboxglTexGend,
1729	vboxglTexGeni,
1730	vboxglTexEnvi,
1731	vboxglTexEnvf,
1732	vboxglTexEnviv,
1733	vboxglTexEnvfv,
1734	vboxglTexGeniv,
1735	vboxglTexGenfv,
1736	vboxglTexParameterf,
1737	vboxglTexParameteri,
1738	vboxglTexParameterfv,
1739	vboxglTexParameteriv,
1740	vboxglLoadIdentity,
1741	vboxglLoadName,
1742	vboxglLoadMatrixd,
1743	vboxglLoadMatrixf,
1744	vboxglStencilFunc,
1745	vboxglShadeModel,
1746	vboxglStencilMask,
1747	vboxglStencilOp,
1748	vboxglScissor,
1749	vboxglViewport,
1750	vboxglRectd,
1751	vboxglRectf,
1752	vboxglRecti,
1753	vboxglRects,
1754	vboxglRectdv,
1755	vboxglRectfv,
1756	vboxglRectiv,
1757	vboxglRectsv,
1758	vboxglMultMatrixd,
1759	vboxglMultMatrixf,
1760	vboxglNewList,
1761	vboxglHint,
1762	vboxglIndexMask,
1763	vboxglInitNames,
1764	vboxglTexCoordPointer,
1765	vboxglVertexPointer,
1766	vboxglColorPointer,
1767	vboxglEdgeFlagPointer,
1768	vboxglIndexPointer,
1769	vboxglNormalPointer,
1770	vboxglPolygonStipple,
1771	vboxglCallLists,
1772	vboxglClipPlane,
1773	vboxglFrustum,
1774	vboxglGenTextures,
1775	vboxglMap1d,
1776	vboxglMap1f,
1777	vboxglMap2d,
1778	vboxglMap2f,
1779	vboxglMapGrid1d,
1780	vboxglMapGrid1f,
1781	vboxglMapGrid2d,
1782	vboxglMapGrid2f,
1783	vboxglCopyPixels,
1784	vboxglTexImage1D,
1785	vboxglTexImage2D,
1786	vboxglTexSubImage1D,
1787	vboxglTexSubImage2D,
1788	vboxglFeedbackBuffer,
1789	vboxglSelectBuffer,
1790	vboxglIsList,
1791	vboxglIsTexture,
1792	vboxglRenderMode,
1793	vboxglReadPixels,
1794	vboxglIsEnabled,
1795	vboxglGenLists,
1796	vboxglPixelTransferf,
1797	vboxglPixelTransferi,
1798	vboxglPixelZoom,
1799	vboxglPixelStorei,
1800	vboxglPixelStoref,
1801	vboxglPixelMapfv,
1802	vboxglPixelMapuiv,
1803	vboxglPixelMapusv,
1804	vboxglPointSize,
1805	vboxglPolygonMode,
1806	vboxglPolygonOffset,
1807	vboxglPassThrough,
1808	vboxglOrtho,
1809	vboxglMatrixMode,
1810	vboxglLogicOp,
1811	vboxglColorMask,
1812	vboxglCopyTexSubImage1D,
1813	vboxglCopyTexSubImage2D,
1814	vboxglFrontFace,
1815	vboxglDisable,
1816	vboxglEnable,
1817	vboxglPrioritizeTextures,
1818	vboxglGetBooleanv,
1819	vboxglGetDoublev,
1820	vboxglGetFloatv,
1821	vboxglGetIntegerv,
1822	vboxglGetLightfv,
1823	vboxglGetLightiv,
1824	vboxglGetMaterialfv,
1825	vboxglGetMaterialiv,
1826	vboxglGetPixelMapfv,
1827	vboxglGetPixelMapuiv,
1828	vboxglGetPixelMapusv,
1829	vboxglGetTexEnviv,
1830	vboxglGetTexEnvfv,
1831	vboxglGetTexGendv,
1832	vboxglGetTexGenfv,
1833	vboxglGetTexGeniv,
1834	vboxglGetTexParameterfv,
1835	vboxglGetTexParameteriv,
1836	vboxglGetClipPlane,
1837	vboxglGetPolygonStipple,
1838	vboxglGetTexLevelParameterfv,
1839	vboxglGetTexLevelParameteriv,
1840	vboxglGetTexImage,
1841
1842	/* Windows ICD exports */
1843	vboxglDrvReleaseContext,
1844	vboxglDrvCreateContext,
1845	vboxglDrvDeleteContext,
1846	vboxglDrvCopyContext,
1847	vboxglDrvSetContext,
1848	vboxglDrvCreateLayerContext,
1849	vboxglDrvShareLists,
1850	vboxglDrvDescribeLayerPlane,
1851	vboxglDrvSetLayerPaletteEntries,
1852	vboxglDrvGetLayerPaletteEntries,
1853	vboxglDrvRealizeLayerPalette,
1854	vboxglDrvSwapLayerBuffers,
1855	vboxglDrvDescribePixelFormat,
1856	vboxglDrvSetPixelFormat,
1857	vboxglDrvSwapBuffers,
1858
1859	#ifdef RT_OS_WINDOWS
1860	/* OpenGL Extensions */
1861	vboxwglSwapIntervalEXT,
1862	vboxwglGetSwapIntervalEXT,
1863	#endif
1864	};
1865	#endif
1866
1867
1868	#ifdef VBOX_OGL_WITH_EXTENSION_ARRAY
1869	typedef struct
1870	{
1871	const char *pszExtName;
1872	const char *pszExtFunctionName;
1873	#ifdef VBOX_OGL_GUEST_SIDE
1874	RTUINTPTR pfnFunction;
1875	#else
1876	RTUINTPTR *ppfnFunction;
1877	#endif
1878	bool fAvailable;
1879	} OPENGL_EXT, *POPENGL_EXT;
1880
1881	#ifdef VBOX_OGL_GUEST_SIDE
1882	#define VBOX_OGL_EXTENSION(a) (RTUINTPTR)a
1883	#else
1884	#define VBOX_OGL_EXTENSION(a) (RTUINTPTR *)&pfn##a
1885
1886	static PFNWGLSWAPINTERVALEXTPROC pfnwglSwapIntervalEXT = NULL;
1887	static PFNWGLGETSWAPINTERVALEXTPROC pfnwglGetSwapIntervalEXT = NULL;
1888
1889	#endif
1890
1891	static OPENGL_EXT OpenGLExtensions[] =
1892	{
1893	{ "WGL_EXT_swap_control", "wglSwapIntervalEXT", VBOX_OGL_EXTENSION(wglSwapIntervalEXT), false },
1894	{ "WGL_EXT_swap_control", "wglGetSwapIntervalEXT", VBOX_OGL_EXTENSION(wglGetSwapIntervalEXT), false },
1895	};
1896	#endif /* VBOX_OGL_WITH_EXTENSION_ARRAY */
1897
1898	#endif
1899

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

source: vbox/trunk/include/VBox/HostServices/VBoxOGLOp.h@ 68788

Download in other formats: