VBoxOGLOp.h@ 3341

Last change on this file since 3341 was 3341, checked in by vboxsync, 18 years ago
Export to OSE
File size: 88.7 KB

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

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

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

Download in other formats: