VirtualBox

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

Last change on this file since 8155 was 8155, checked in by vboxsync, 16 years ago

The Big Sun Rebranding Header Change
  • Property svn:eol-style set to native
File size: 89.2 KB
Line 
1/** @file
2 * VirtualBox OpenGL command pack/unpack header
3 */
4
5/*
6 *
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 *
26 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27 * Clara, CA 95054 USA or visit http://www.sun.com if you need
28 * additional information or have any questions.
29 */
30
31#ifndef ___VBox_HostService_VBoxOGLOp_h
32#define ___VBox_HostService_VBoxOGLOp_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 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! */
1018typedef 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)
1303static 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. */
1586static 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
1871typedef 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
1888static PFNWGLSWAPINTERVALEXTPROC pfnwglSwapIntervalEXT = NULL;
1889static PFNWGLGETSWAPINTERVALEXTPROC pfnwglGetSwapIntervalEXT = NULL;
1890
1891#endif
1892
1893static 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
1901
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use