VBoxOGLOp.h@ 80062

Last change on this file since 80062 was 76585, checked in by vboxsync, 6 years ago
*: scm --fix-header-guard-endif
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 89.2 KB

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

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

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

Download in other formats: