VBoxOGLOp.h@ 3641

Last change on this file since 3641 was 3633, checked in by vboxsync, 18 years ago
VBox_hdr_h -> _VBox_hdr_h
File size: 90.6 KB

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

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

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

Download in other formats: