VBoxOGLOp.h@ 52664

Last change on this file since 52664 was 44528, checked in by vboxsync, 12 years ago
header (C) fixes
Property svn:eol-style set to `native`
File size: 89.0 KB

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

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

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

Download in other formats: