Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
59 | pj | 1 | #ifdef MESA_TRACE |
2 | |||
3 | #include "glheader.h" |
||
4 | #include "glapitable.h" |
||
5 | #include "tr_write.h" |
||
6 | #include "tr_error.h" |
||
7 | #include "tr_context.h" |
||
8 | #include "tr_commands.h" |
||
9 | #include "tr_support.h" |
||
10 | #include "tr_wrapper.h" |
||
11 | |||
12 | |||
13 | #ifdef GLAPI |
||
14 | #undef GLAPI |
||
15 | #endif |
||
16 | #define GLAPI static |
||
17 | |||
18 | #ifdef GLAPIENTRY |
||
19 | #undef GLAPIENTRY |
||
20 | #endif |
||
21 | #define GLAPIENTRY |
||
22 | |||
23 | |||
24 | GLAPI void GLAPIENTRY trAccum( GLenum op, GLfloat value ) { |
||
25 | trWriteCMD( CMD_ACCUM ); |
||
26 | trWriteEnum( op ); |
||
27 | trWritef( value ); |
||
28 | |||
29 | if( trCtx()->doExec ) { |
||
30 | trGetDispatch()->Accum( op, value ); |
||
31 | trError(); |
||
32 | } |
||
33 | } |
||
34 | |||
35 | |||
36 | GLAPI void GLAPIENTRY trActiveTextureARB( GLenum texture) { |
||
37 | trWriteCMD( CMD_ACTIVETEXTUREARB ); |
||
38 | trWriteEnum( texture ); |
||
39 | |||
40 | if( trCtx()->doExec ) { |
||
41 | trGetDispatch()->ActiveTextureARB( texture ); |
||
42 | trError(); |
||
43 | } |
||
44 | } |
||
45 | |||
46 | |||
47 | GLAPI void GLAPIENTRY trAlphaFunc( GLenum func, GLclampf ref ) { |
||
48 | trWriteCMD( CMD_ALPHAFUNC ); |
||
49 | trWriteEnum( func ); |
||
50 | trWriteClampf( ref ); |
||
51 | |||
52 | if( trCtx()->doExec ) { |
||
53 | trGetDispatch()->AlphaFunc( func, ref ); |
||
54 | trError(); |
||
55 | } |
||
56 | } |
||
57 | |||
58 | |||
59 | GLAPI GLboolean GLAPIENTRY trAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences ) { |
||
60 | GLboolean retval; |
||
61 | |||
62 | trWriteCMD( CMD_ARETEXTURESRESIDENT ); |
||
63 | trWriteSizei( n ); |
||
64 | trWritePointer( (void *)textures ); |
||
65 | trFileFlush(); |
||
66 | trWriteArrayui( n, textures ); |
||
67 | trWritePointer( (void *)residences ); |
||
68 | trFileFlush(); |
||
69 | |||
70 | if( trCtx()->doExec ) { |
||
71 | retval = trGetDispatch()->AreTexturesResident( n, textures, residences ); |
||
72 | trError(); |
||
73 | } else { |
||
74 | memset( residences, 0, n * sizeof(GLboolean) ); |
||
75 | retval = GL_NO_ERROR; |
||
76 | } |
||
77 | |||
78 | trWriteBool( retval ); |
||
79 | trWriteArrayBool( n, residences ); |
||
80 | |||
81 | return retval; |
||
82 | } |
||
83 | |||
84 | |||
85 | GLAPI GLboolean GLAPIENTRY trAreTexturesResidentEXT( GLsizei n, const GLuint *textures, GLboolean *residences ) { |
||
86 | GLboolean retval; |
||
87 | |||
88 | trWriteCMD( CMD_ARETEXTURESRESIDENTEXT ); |
||
89 | trWriteSizei( n ); |
||
90 | trWritePointer( (void *)textures ); |
||
91 | trFileFlush(); |
||
92 | trWriteArrayui( n, textures ); |
||
93 | trWritePointer( (void *)residences ); |
||
94 | trFileFlush(); |
||
95 | |||
96 | if( trCtx()->doExec ) { |
||
97 | retval = trGetDispatch()->AreTexturesResidentEXT( n, textures, residences ); |
||
98 | trError(); |
||
99 | } else { |
||
100 | memset( residences, 0, n * sizeof(GLboolean) ); |
||
101 | retval = GL_NO_ERROR; |
||
102 | } |
||
103 | |||
104 | trWriteBool( retval ); |
||
105 | trWriteArrayBool( n, residences ); |
||
106 | |||
107 | return retval; |
||
108 | } |
||
109 | |||
110 | |||
111 | #if 0 |
||
112 | // Not in MESAs dispatch table |
||
113 | GLAPI void GLAPIENTRY trArrayElementEXT( GLint i ) { |
||
114 | trWriteCMD( CMD_ARRAYELEMENTEXT ); |
||
115 | trWritei( i ); |
||
116 | |||
117 | if( trCtx()->doExec ) { |
||
118 | trGetDispatch()->ArrayElementEXT( i ); |
||
119 | trError(); |
||
120 | } |
||
121 | } |
||
122 | #endif |
||
123 | |||
124 | |||
125 | GLAPI void GLAPIENTRY trArrayElement( GLint i ) { |
||
126 | trace_context_t * tctx; |
||
127 | |||
128 | trWriteCMD( CMD_ARRAYELEMENT ); |
||
129 | trWritei( i ); |
||
130 | |||
131 | tctx = trCtx(); |
||
132 | |||
133 | if( tctx->doExec ) { |
||
134 | trGetDispatch()->ArrayElement( i ); |
||
135 | trError(); |
||
136 | } |
||
137 | } |
||
138 | |||
139 | |||
140 | GLAPI void GLAPIENTRY trBegin( GLenum mode ) { |
||
141 | trWriteCMD( CMD_BEGIN ); |
||
142 | trWriteEnum( mode ); |
||
143 | |||
144 | if( trCtx()->doExec ) { |
||
145 | trGetDispatch()->Begin( mode ); |
||
146 | trError(); |
||
147 | } |
||
148 | } |
||
149 | |||
150 | |||
151 | #if 0 |
||
152 | // Not in MESAs dispatch table |
||
153 | GLAPI void GLAPIENTRY trBindTextureEXT( GLenum target, GLuint texture ) { |
||
154 | trWriteCMD( CMD_BINDTEXTUREEXT ); |
||
155 | trWriteEnum( target ); |
||
156 | trWriteui( texture ); |
||
157 | |||
158 | if( trCtx()->doExec ) { |
||
159 | trGetDispatch()->BindTextureEXT( target, texture ); |
||
160 | trError(); |
||
161 | } |
||
162 | } |
||
163 | #endif |
||
164 | |||
165 | |||
166 | GLAPI void GLAPIENTRY trBindTexture( GLenum target, GLuint texture ) { |
||
167 | trWriteCMD( CMD_BINDTEXTURE ); |
||
168 | trWriteEnum( target ); |
||
169 | trWriteui( texture ); |
||
170 | |||
171 | if( trCtx()->doExec ) { |
||
172 | trGetDispatch()->BindTexture( target, texture ); |
||
173 | trError(); |
||
174 | } |
||
175 | } |
||
176 | |||
177 | |||
178 | GLAPI void GLAPIENTRY trBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap ) { |
||
179 | trWriteCMD( CMD_BITMAP ); |
||
180 | trWriteSizei( width ); |
||
181 | trWriteSizei( height ); |
||
182 | trWritef( xorig ); |
||
183 | trWritef( yorig ); |
||
184 | trWritef( xmove ); |
||
185 | trWritef( ymove ); |
||
186 | trWritePointer( (void *)bitmap ); |
||
187 | trFileFlush(); |
||
188 | trWriteArrayub( width * height / 8, bitmap ); |
||
189 | |||
190 | if( trCtx()->doExec ) { |
||
191 | trGetDispatch()->Bitmap( width, height, xorig, yorig, xmove, ymove, bitmap ); |
||
192 | trError(); |
||
193 | } |
||
194 | } |
||
195 | |||
196 | |||
197 | #if 0 |
||
198 | // Not in MESAs dispatch table |
||
199 | GLAPI void GLAPIENTRY trBlendColorEXT( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) { |
||
200 | trWriteCMD( CMD_BLENDCOLOREXT ); |
||
201 | trWriteClampf( red ); |
||
202 | trWriteClampf( green ); |
||
203 | trWriteClampf( blue ); |
||
204 | trWriteClampf( alpha ); |
||
205 | |||
206 | if( trCtx()->doExec ) { |
||
207 | trGetDispatch()->BlendColorEXT( red, green, blue, alpha ); |
||
208 | trError(); |
||
209 | } |
||
210 | } |
||
211 | #endif |
||
212 | |||
213 | |||
214 | GLAPI void GLAPIENTRY trBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) { |
||
215 | trWriteCMD( CMD_BLENDCOLOR ); |
||
216 | trWriteClampf( red ); |
||
217 | trWriteClampf( green ); |
||
218 | trWriteClampf( blue ); |
||
219 | trWriteClampf( alpha ); |
||
220 | |||
221 | if( trCtx()->doExec ) { |
||
222 | trGetDispatch()->BlendColor( red, green, blue, alpha ); |
||
223 | trError(); |
||
224 | } |
||
225 | } |
||
226 | |||
227 | |||
228 | #if 0 |
||
229 | // Not in MESAs dispatch table |
||
230 | GLAPI void GLAPIENTRY trBlendEquationEXT( GLenum mode ) { |
||
231 | trWriteCMD( CMD_BLENDEQUATIONEXT ); |
||
232 | trWriteEnum( mode ); |
||
233 | |||
234 | if( trCtx()->doExec ) { |
||
235 | trGetDispatch()->BlendEquationEXT( mode ); |
||
236 | trError(); |
||
237 | } |
||
238 | } |
||
239 | #endif |
||
240 | |||
241 | |||
242 | GLAPI void GLAPIENTRY trBlendEquation( GLenum mode ) { |
||
243 | trWriteCMD( CMD_BLENDEQUATION ); |
||
244 | trWriteEnum( mode ); |
||
245 | |||
246 | if( trCtx()->doExec ) { |
||
247 | trGetDispatch()->BlendEquation( mode ); |
||
248 | trError(); |
||
249 | } |
||
250 | } |
||
251 | |||
252 | |||
253 | GLAPI void GLAPIENTRY trBlendFunc( GLenum sfactor, GLenum dfactor ) { |
||
254 | trWriteCMD( CMD_BLENDFUNC ); |
||
255 | trWriteEnum( sfactor ); |
||
256 | trWriteEnum( dfactor ); |
||
257 | |||
258 | if( trCtx()->doExec ) { |
||
259 | trGetDispatch()->BlendFunc( sfactor, dfactor ); |
||
260 | trError(); |
||
261 | } |
||
262 | } |
||
263 | |||
264 | |||
265 | GLAPI void GLAPIENTRY trCallList( GLuint list ) { |
||
266 | trWriteCMD( CMD_CALLLIST ); |
||
267 | trWriteui( list ); |
||
268 | |||
269 | if( trCtx()->doExec ) { |
||
270 | trSetOriginalDispatch(); |
||
271 | trGetDispatch()->CallList( list ); |
||
272 | trSetTraceDispatch(); |
||
273 | trError(); |
||
274 | } |
||
275 | } |
||
276 | |||
277 | |||
278 | GLAPI void GLAPIENTRY trCallLists( GLsizei n, GLenum type, const GLvoid *lists ) { |
||
279 | trWriteCMD( CMD_CALLLISTS ); |
||
280 | trWriteSizei( n ); |
||
281 | trWriteEnum( type ); |
||
282 | trWritePointer( (void *)lists ); |
||
283 | trFileFlush(); |
||
284 | |||
285 | switch( type ) { |
||
286 | case GL_2_BYTES: |
||
287 | trWriteTypeArray( GL_UNSIGNED_BYTE, n, 2, 0, lists ); |
||
288 | break; |
||
289 | case GL_3_BYTES: |
||
290 | trWriteTypeArray( GL_UNSIGNED_BYTE, n, 3, 0, lists ); |
||
291 | break; |
||
292 | case GL_4_BYTES: |
||
293 | trWriteTypeArray( GL_UNSIGNED_BYTE, n, 4, 0, lists ); |
||
294 | break; |
||
295 | default: |
||
296 | trWriteTypeArray( type, n, 1, 0, lists ); |
||
297 | break; |
||
298 | } |
||
299 | |||
300 | if( trCtx()->doExec ) { |
||
301 | trSetOriginalDispatch(); |
||
302 | trGetDispatch()->CallLists( n, type, lists ); |
||
303 | trSetTraceDispatch(); |
||
304 | trError(); |
||
305 | } |
||
306 | } |
||
307 | |||
308 | |||
309 | GLAPI void GLAPIENTRY trClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { |
||
310 | trWriteCMD( CMD_CLEARACCUM ); |
||
311 | trWritef( red ); |
||
312 | trWritef( green ); |
||
313 | trWritef( blue ); |
||
314 | trWritef( alpha ); |
||
315 | |||
316 | if( trCtx()->doExec ) { |
||
317 | trGetDispatch()->ClearAccum( red, green, blue, alpha ); |
||
318 | trError(); |
||
319 | } |
||
320 | } |
||
321 | |||
322 | |||
323 | GLAPI void GLAPIENTRY trClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) { |
||
324 | trWriteCMD( CMD_CLEARCOLOR ); |
||
325 | trWriteClampf( red ); |
||
326 | trWriteClampf( green ); |
||
327 | trWriteClampf( blue ); |
||
328 | trWriteClampf( alpha ); |
||
329 | |||
330 | if( trCtx()->doExec ) { |
||
331 | trGetDispatch()->ClearColor( red, green, blue, alpha ); |
||
332 | trError(); |
||
333 | } |
||
334 | } |
||
335 | |||
336 | |||
337 | GLAPI void GLAPIENTRY trClearDepth( GLclampd depth ) { |
||
338 | trWriteCMD( CMD_CLEARDEPTH ); |
||
339 | trWriteClampd( depth ); |
||
340 | |||
341 | if( trCtx()->doExec ) { |
||
342 | trGetDispatch()->ClearDepth( depth ); |
||
343 | trError(); |
||
344 | } |
||
345 | } |
||
346 | |||
347 | |||
348 | GLAPI void GLAPIENTRY trClear( GLbitfield mask ) { |
||
349 | trWriteCMD( CMD_CLEAR ); |
||
350 | trWriteBits( mask ); |
||
351 | |||
352 | if( trCtx()->doExec ) { |
||
353 | trGetDispatch()->Clear( mask ); |
||
354 | trError(); |
||
355 | } |
||
356 | } |
||
357 | |||
358 | |||
359 | GLAPI void GLAPIENTRY trClearIndex( GLfloat c ) { |
||
360 | trWriteCMD( CMD_CLEARINDEX ); |
||
361 | trWritef( c ); |
||
362 | |||
363 | if( trCtx()->doExec ) { |
||
364 | trGetDispatch()->ClearIndex( c ); |
||
365 | trError(); |
||
366 | } |
||
367 | } |
||
368 | |||
369 | |||
370 | GLAPI void GLAPIENTRY trClearStencil( GLint s ) { |
||
371 | trWriteCMD( CMD_CLEARSTENCIL ); |
||
372 | trWritei( s ); |
||
373 | |||
374 | if( trCtx()->doExec ) { |
||
375 | trGetDispatch()->ClearStencil( s ); |
||
376 | trError(); |
||
377 | } |
||
378 | } |
||
379 | |||
380 | |||
381 | GLAPI void GLAPIENTRY trClientActiveTextureARB( GLenum texture) { |
||
382 | trWriteCMD( CMD_CLIENTACTIVETEXTUREARB ); |
||
383 | trWriteEnum( texture ); |
||
384 | |||
385 | if( trCtx()->doExec ) { |
||
386 | trGetDispatch()->ClientActiveTextureARB( texture ); |
||
387 | trError(); |
||
388 | } |
||
389 | } |
||
390 | |||
391 | |||
392 | GLAPI void GLAPIENTRY trClipPlane( GLenum plane, const GLdouble *equation ) { |
||
393 | trWriteCMD( CMD_CLIPPLANE ); |
||
394 | trWriteEnum( plane ); |
||
395 | trWritePointer( (void *)equation ); |
||
396 | trFileFlush(); |
||
397 | trWriteArrayd( 4, equation ); |
||
398 | |||
399 | if( trCtx()->doExec ) { |
||
400 | trGetDispatch()->ClipPlane( plane, equation ); |
||
401 | trError(); |
||
402 | } |
||
403 | } |
||
404 | |||
405 | |||
406 | GLAPI void GLAPIENTRY trColor3b( GLbyte red, GLbyte green, GLbyte blue ) { |
||
407 | trWriteCMD( CMD_COLOR3B ); |
||
408 | trWriteb( red ); |
||
409 | trWriteb( green ); |
||
410 | trWriteb( blue ); |
||
411 | |||
412 | if( trCtx()->doExec ) { |
||
413 | trGetDispatch()->Color3b( red, green, blue ); |
||
414 | trError(); |
||
415 | } |
||
416 | } |
||
417 | |||
418 | |||
419 | GLAPI void GLAPIENTRY trColor3bv( const GLbyte *v ) { |
||
420 | trWriteCMD( CMD_COLOR3BV ); |
||
421 | trWritePointer( (void *)v ); |
||
422 | trFileFlush(); |
||
423 | trWriteArrayb( 3, v ); |
||
424 | |||
425 | if( trCtx()->doExec ) { |
||
426 | trGetDispatch()->Color3bv( v ); |
||
427 | trError(); |
||
428 | } |
||
429 | } |
||
430 | |||
431 | |||
432 | GLAPI void GLAPIENTRY trColor3d( GLdouble red, GLdouble green, GLdouble blue ) { |
||
433 | trWriteCMD( CMD_COLOR3D ); |
||
434 | trWrited( red ); |
||
435 | trWrited( green ); |
||
436 | trWrited( blue ); |
||
437 | |||
438 | if( trCtx()->doExec ) { |
||
439 | trGetDispatch()->Color3d( red, green, blue ); |
||
440 | trError(); |
||
441 | } |
||
442 | } |
||
443 | |||
444 | |||
445 | GLAPI void GLAPIENTRY trColor3dv( const GLdouble *v ) { |
||
446 | trWriteCMD( CMD_COLOR3DV ); |
||
447 | trWritePointer( (void *)v ); |
||
448 | trFileFlush(); |
||
449 | trWriteArrayd( 3, v ); |
||
450 | |||
451 | if( trCtx()->doExec ) { |
||
452 | trGetDispatch()->Color3dv( v ); |
||
453 | trError(); |
||
454 | } |
||
455 | } |
||
456 | |||
457 | |||
458 | GLAPI void GLAPIENTRY trColor3f( GLfloat red, GLfloat green, GLfloat blue ) { |
||
459 | trWriteCMD( CMD_COLOR3F ); |
||
460 | trWritef( red ); |
||
461 | trWritef( green ); |
||
462 | trWritef( blue ); |
||
463 | |||
464 | if( trCtx()->doExec ) { |
||
465 | trGetDispatch()->Color3f( red, green, blue ); |
||
466 | trError(); |
||
467 | } |
||
468 | } |
||
469 | |||
470 | |||
471 | GLAPI void GLAPIENTRY trColor3fv( const GLfloat *v ) { |
||
472 | trWriteCMD( CMD_COLOR3FV ); |
||
473 | trWritePointer( (void *)v ); |
||
474 | trFileFlush(); |
||
475 | trWriteArrayf( 3, v ); |
||
476 | |||
477 | if( trCtx()->doExec ) { |
||
478 | trGetDispatch()->Color3fv( v ); |
||
479 | trError(); |
||
480 | } |
||
481 | } |
||
482 | |||
483 | |||
484 | GLAPI void GLAPIENTRY trColor3i( GLint red, GLint green, GLint blue ) { |
||
485 | trWriteCMD( CMD_COLOR3I ); |
||
486 | trWritei( red ); |
||
487 | trWritei( green ); |
||
488 | trWritei( blue ); |
||
489 | |||
490 | if( trCtx()->doExec ) { |
||
491 | trGetDispatch()->Color3i( red, green, blue ); |
||
492 | trError(); |
||
493 | } |
||
494 | } |
||
495 | |||
496 | |||
497 | GLAPI void GLAPIENTRY trColor3iv( const GLint *v ) { |
||
498 | trWriteCMD( CMD_COLOR3IV ); |
||
499 | trWritePointer( (void *)v ); |
||
500 | trFileFlush(); |
||
501 | trWriteArrayi( 3, v ); |
||
502 | |||
503 | if( trCtx()->doExec ) { |
||
504 | trGetDispatch()->Color3iv( v ); |
||
505 | trError(); |
||
506 | } |
||
507 | } |
||
508 | |||
509 | |||
510 | GLAPI void GLAPIENTRY trColor3s( GLshort red, GLshort green, GLshort blue ) { |
||
511 | trWriteCMD( CMD_COLOR3S ); |
||
512 | trWrites( red ); |
||
513 | trWrites( green ); |
||
514 | trWrites( blue ); |
||
515 | |||
516 | if( trCtx()->doExec ) { |
||
517 | trGetDispatch()->Color3s( red, green, blue ); |
||
518 | trError(); |
||
519 | } |
||
520 | } |
||
521 | |||
522 | |||
523 | GLAPI void GLAPIENTRY trColor3sv( const GLshort *v ) { |
||
524 | trWriteCMD( CMD_COLOR3SV ); |
||
525 | trWritePointer( (void *)v ); |
||
526 | trFileFlush(); |
||
527 | trWriteArrays( 3, v ); |
||
528 | |||
529 | if( trCtx()->doExec ) { |
||
530 | trGetDispatch()->Color3sv( v ); |
||
531 | trError(); |
||
532 | } |
||
533 | } |
||
534 | |||
535 | |||
536 | GLAPI void GLAPIENTRY trColor3ub( GLubyte red, GLubyte green, GLubyte blue ) { |
||
537 | trWriteCMD( CMD_COLOR3UB ); |
||
538 | trWriteub( red ); |
||
539 | trWriteub( green ); |
||
540 | trWriteub( blue ); |
||
541 | |||
542 | if( trCtx()->doExec ) { |
||
543 | trGetDispatch()->Color3ub( red, green, blue ); |
||
544 | trError(); |
||
545 | } |
||
546 | } |
||
547 | |||
548 | |||
549 | GLAPI void GLAPIENTRY trColor3ubv( const GLubyte *v ) { |
||
550 | trWriteCMD( CMD_COLOR3UBV ); |
||
551 | trWritePointer( (void *)v ); |
||
552 | trFileFlush(); |
||
553 | trWriteArrayub( 3, v ); |
||
554 | |||
555 | if( trCtx()->doExec ) { |
||
556 | trGetDispatch()->Color3ubv( v ); |
||
557 | trError(); |
||
558 | } |
||
559 | } |
||
560 | |||
561 | |||
562 | GLAPI void GLAPIENTRY trColor3ui( GLuint red, GLuint green, GLuint blue ) { |
||
563 | trWriteCMD( CMD_COLOR3UI ); |
||
564 | trWriteui( red ); |
||
565 | trWriteui( green ); |
||
566 | trWriteui( blue ); |
||
567 | |||
568 | if( trCtx()->doExec ) { |
||
569 | trGetDispatch()->Color3ui( red, green, blue ); |
||
570 | trError(); |
||
571 | } |
||
572 | } |
||
573 | |||
574 | |||
575 | GLAPI void GLAPIENTRY trColor3uiv( const GLuint *v ) { |
||
576 | trWriteCMD( CMD_COLOR3UIV ); |
||
577 | trWritePointer( (void *)v ); |
||
578 | trFileFlush(); |
||
579 | trWriteArrayui( 3, v ); |
||
580 | |||
581 | if( trCtx()->doExec ) { |
||
582 | trGetDispatch()->Color3uiv( v ); |
||
583 | trError(); |
||
584 | } |
||
585 | } |
||
586 | |||
587 | |||
588 | GLAPI void GLAPIENTRY trColor3us( GLushort red, GLushort green, GLushort blue ) { |
||
589 | trWriteCMD( CMD_COLOR3US ); |
||
590 | trWriteus( red ); |
||
591 | trWriteus( green ); |
||
592 | trWriteus( blue ); |
||
593 | |||
594 | if( trCtx()->doExec ) { |
||
595 | trGetDispatch()->Color3us( red, green, blue ); |
||
596 | trError(); |
||
597 | } |
||
598 | } |
||
599 | |||
600 | |||
601 | GLAPI void GLAPIENTRY trColor3usv( const GLushort *v ) { |
||
602 | trWriteCMD( CMD_COLOR3USV ); |
||
603 | trWritePointer( (void *)v ); |
||
604 | trFileFlush(); |
||
605 | trWriteArrayus( 3, v ); |
||
606 | |||
607 | if( trCtx()->doExec ) { |
||
608 | trGetDispatch()->Color3usv( v ); |
||
609 | trError(); |
||
610 | } |
||
611 | } |
||
612 | |||
613 | |||
614 | GLAPI void GLAPIENTRY trColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) { |
||
615 | trWriteCMD( CMD_COLOR4B ); |
||
616 | trWriteb( red ); |
||
617 | trWriteb( green ); |
||
618 | trWriteb( blue ); |
||
619 | trWriteb( alpha ); |
||
620 | |||
621 | if( trCtx()->doExec ) { |
||
622 | trGetDispatch()->Color4b( red, green, blue, alpha ); |
||
623 | trError(); |
||
624 | } |
||
625 | } |
||
626 | |||
627 | |||
628 | GLAPI void GLAPIENTRY trColor4bv( const GLbyte *v ) { |
||
629 | trWriteCMD( CMD_COLOR4BV ); |
||
630 | trWritePointer( (void *)v ); |
||
631 | trFileFlush(); |
||
632 | trWriteArrayb( 4, v ); |
||
633 | |||
634 | if( trCtx()->doExec ) { |
||
635 | trGetDispatch()->Color4bv( v ); |
||
636 | trError(); |
||
637 | } |
||
638 | } |
||
639 | |||
640 | |||
641 | GLAPI void GLAPIENTRY trColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) { |
||
642 | trWriteCMD( CMD_COLOR4D ); |
||
643 | trWrited( red ); |
||
644 | trWrited( green ); |
||
645 | trWrited( blue ); |
||
646 | trWrited( alpha ); |
||
647 | |||
648 | if( trCtx()->doExec ) { |
||
649 | trGetDispatch()->Color4d( red, green, blue, alpha ); |
||
650 | trError(); |
||
651 | } |
||
652 | } |
||
653 | |||
654 | |||
655 | GLAPI void GLAPIENTRY trColor4dv( const GLdouble *v ) { |
||
656 | trWriteCMD( CMD_COLOR4DV ); |
||
657 | trWritePointer( (void *)v ); |
||
658 | trFileFlush(); |
||
659 | trWriteArrayd( 4, v ); |
||
660 | |||
661 | if( trCtx()->doExec ) { |
||
662 | trGetDispatch()->Color4dv( v ); |
||
663 | trError(); |
||
664 | } |
||
665 | } |
||
666 | |||
667 | |||
668 | GLAPI void GLAPIENTRY trColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { |
||
669 | trWriteCMD( CMD_COLOR4F ); |
||
670 | trWritef( red ); |
||
671 | trWritef( green ); |
||
672 | trWritef( blue ); |
||
673 | trWritef( alpha ); |
||
674 | |||
675 | if( trCtx()->doExec ) { |
||
676 | trGetDispatch()->Color4f( red, green, blue, alpha ); |
||
677 | trError(); |
||
678 | } |
||
679 | } |
||
680 | |||
681 | |||
682 | GLAPI void GLAPIENTRY trColor4fv( const GLfloat *v ) { |
||
683 | trWriteCMD( CMD_COLOR4FV ); |
||
684 | trWritePointer( (void *)v ); |
||
685 | trFileFlush(); |
||
686 | trWriteArrayf( 4, v ); |
||
687 | |||
688 | if( trCtx()->doExec ) { |
||
689 | trGetDispatch()->Color4fv( v ); |
||
690 | trError(); |
||
691 | } |
||
692 | } |
||
693 | |||
694 | |||
695 | GLAPI void GLAPIENTRY trColor4i( GLint red, GLint green, GLint blue, GLint alpha ) { |
||
696 | trWriteCMD( CMD_COLOR4I ); |
||
697 | trWritei( red ); |
||
698 | trWritei( green ); |
||
699 | trWritei( blue ); |
||
700 | trWritei( alpha ); |
||
701 | |||
702 | if( trCtx()->doExec ) { |
||
703 | trGetDispatch()->Color4i( red, green, blue, alpha ); |
||
704 | trError(); |
||
705 | } |
||
706 | } |
||
707 | |||
708 | |||
709 | GLAPI void GLAPIENTRY trColor4iv( const GLint *v ) { |
||
710 | trWriteCMD( CMD_COLOR4IV ); |
||
711 | trWritePointer( (void *)v ); |
||
712 | trFileFlush(); |
||
713 | trWriteArrayi( 4, v ); |
||
714 | |||
715 | if( trCtx()->doExec ) { |
||
716 | trGetDispatch()->Color4iv( v ); |
||
717 | trError(); |
||
718 | } |
||
719 | } |
||
720 | |||
721 | |||
722 | GLAPI void GLAPIENTRY trColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha ) { |
||
723 | trWriteCMD( CMD_COLOR4S ); |
||
724 | trWrites( red ); |
||
725 | trWrites( green ); |
||
726 | trWrites( blue ); |
||
727 | trWrites( alpha ); |
||
728 | |||
729 | if( trCtx()->doExec ) { |
||
730 | trGetDispatch()->Color4s( red, green, blue, alpha ); |
||
731 | trError(); |
||
732 | } |
||
733 | } |
||
734 | |||
735 | |||
736 | GLAPI void GLAPIENTRY trColor4sv( const GLshort *v ) { |
||
737 | trWriteCMD( CMD_COLOR4SV ); |
||
738 | trWritePointer( (void *)v ); |
||
739 | trFileFlush(); |
||
740 | trWriteArrays( 4, v ); |
||
741 | |||
742 | if( trCtx()->doExec ) { |
||
743 | trGetDispatch()->Color4sv( v ); |
||
744 | trError(); |
||
745 | } |
||
746 | } |
||
747 | |||
748 | |||
749 | GLAPI void GLAPIENTRY trColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) { |
||
750 | trWriteCMD( CMD_COLOR4UB ); |
||
751 | trWriteub( red ); |
||
752 | trWriteub( green ); |
||
753 | trWriteub( blue ); |
||
754 | trWriteub( alpha ); |
||
755 | |||
756 | if( trCtx()->doExec ) { |
||
757 | trGetDispatch()->Color4ub( red, green, blue, alpha ); |
||
758 | trError(); |
||
759 | } |
||
760 | } |
||
761 | |||
762 | |||
763 | GLAPI void GLAPIENTRY trColor4ubv( const GLubyte *v ) { |
||
764 | trWriteCMD( CMD_COLOR4UBV ); |
||
765 | trWritePointer( (void *)v ); |
||
766 | trFileFlush(); |
||
767 | trWriteArrayub( 4, v ); |
||
768 | |||
769 | if( trCtx()->doExec ) { |
||
770 | trGetDispatch()->Color4ubv( v ); |
||
771 | trError(); |
||
772 | } |
||
773 | } |
||
774 | |||
775 | |||
776 | GLAPI void GLAPIENTRY trColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha ) { |
||
777 | trWriteCMD( CMD_COLOR4UI ); |
||
778 | trWriteui( red ); |
||
779 | trWriteui( green ); |
||
780 | trWriteui( blue ); |
||
781 | trWriteui( alpha ); |
||
782 | |||
783 | if( trCtx()->doExec ) { |
||
784 | trGetDispatch()->Color4ui( red, green, blue, alpha ); |
||
785 | trError(); |
||
786 | } |
||
787 | } |
||
788 | |||
789 | |||
790 | GLAPI void GLAPIENTRY trColor4uiv( const GLuint *v ) { |
||
791 | trWriteCMD( CMD_COLOR4UIV ); |
||
792 | trWritePointer( (void *)v ); |
||
793 | trFileFlush(); |
||
794 | trWriteArrayui( 4, v ); |
||
795 | |||
796 | if( trCtx()->doExec ) { |
||
797 | trGetDispatch()->Color4uiv( v ); |
||
798 | trError(); |
||
799 | } |
||
800 | } |
||
801 | |||
802 | |||
803 | GLAPI void GLAPIENTRY trColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha ) { |
||
804 | trWriteCMD( CMD_COLOR4US ); |
||
805 | trWriteus( red ); |
||
806 | trWriteus( green ); |
||
807 | trWriteus( blue ); |
||
808 | trWriteus( alpha ); |
||
809 | |||
810 | if( trCtx()->doExec ) { |
||
811 | trGetDispatch()->Color4us( red, green, blue, alpha ); |
||
812 | trError(); |
||
813 | } |
||
814 | } |
||
815 | |||
816 | |||
817 | GLAPI void GLAPIENTRY trColor4usv( const GLushort *v ) { |
||
818 | trWriteCMD( CMD_COLOR4USV ); |
||
819 | trWritePointer( (void *)v ); |
||
820 | trFileFlush(); |
||
821 | trWriteArrayus( 4, v ); |
||
822 | |||
823 | if( trCtx()->doExec ) { |
||
824 | trGetDispatch()->Color4usv( v ); |
||
825 | trError(); |
||
826 | } |
||
827 | } |
||
828 | |||
829 | |||
830 | GLAPI void GLAPIENTRY trColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) { |
||
831 | trWriteCMD( CMD_COLORMASK ); |
||
832 | trWriteBool( red ); |
||
833 | trWriteBool( green ); |
||
834 | trWriteBool( blue ); |
||
835 | trWriteBool( alpha ); |
||
836 | |||
837 | if( trCtx()->doExec ) { |
||
838 | trGetDispatch()->ColorMask( red, green, blue, alpha ); |
||
839 | trError(); |
||
840 | } |
||
841 | } |
||
842 | |||
843 | |||
844 | GLAPI void GLAPIENTRY trColorMaterial( GLenum face, GLenum mode ) { |
||
845 | trWriteCMD( CMD_COLORMATERIAL ); |
||
846 | trWriteEnum( face ); |
||
847 | trWriteEnum( mode ); |
||
848 | |||
849 | if( trCtx()->doExec ) { |
||
850 | trGetDispatch()->ColorMaterial( face, mode ); |
||
851 | trError(); |
||
852 | } |
||
853 | } |
||
854 | |||
855 | |||
856 | GLAPI void GLAPIENTRY trColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */ |
||
857 | trWriteCMD( CMD_COLORPOINTEREXT ); |
||
858 | trWritei( size ); |
||
859 | trWriteEnum( type ); |
||
860 | trWriteSizei( stride ); |
||
861 | trWriteSizei( count ); |
||
862 | trWritePointer( (void *)ptr ); |
||
863 | trFileFlush(); |
||
864 | |||
865 | if( trCtx()->doExec ) { |
||
866 | trGetDispatch()->ColorPointerEXT( size, type, stride, count, ptr ); |
||
867 | trError(); |
||
868 | } |
||
869 | } |
||
870 | |||
871 | |||
872 | GLAPI void GLAPIENTRY trColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) { |
||
873 | trace_context_t * tctx; |
||
874 | |||
875 | trWriteCMD( CMD_COLORPOINTER ); |
||
876 | trWritei( size ); |
||
877 | trWriteEnum( type ); |
||
878 | trWriteSizei( stride ); |
||
879 | trWritePointer( (void *)ptr ); |
||
880 | trFileFlush(); |
||
881 | |||
882 | if( tctx->doExec ) { |
||
883 | trGetDispatch()->ColorPointer( size, type, stride, ptr ); |
||
884 | trError(); |
||
885 | } |
||
886 | } |
||
887 | |||
888 | |||
889 | #if 0 |
||
890 | // Not in MESAs dispatch table |
||
891 | GLAPI void GLAPIENTRY trColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data ) { |
||
892 | GLint pixelsize; |
||
893 | |||
894 | trWriteCMD( CMD_COLORSUBTABLEEXT ); |
||
895 | trWriteEnum( target ); |
||
896 | trWriteSizei( start ); |
||
897 | trWriteSizei( count ); |
||
898 | trWriteEnum( format ); |
||
899 | trWriteEnum( type ); |
||
900 | trWritePointer( (void *)data ); |
||
901 | trFileFlush(); |
||
902 | |||
903 | pixelsize = trGetPixelSize( format, type ); |
||
904 | trWriteTypeArray( type, count, pixelsize, start, data ); |
||
905 | |||
906 | if( trCtx()->doExec ) { |
||
907 | trGetDispatch()->ColorSubTableEXT( target, start, count, format, type, data ); |
||
908 | trError(); |
||
909 | } |
||
910 | } |
||
911 | #endif |
||
912 | |||
913 | |||
914 | GLAPI void GLAPIENTRY trColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data ) { |
||
915 | GLint pixelsize; |
||
916 | |||
917 | trWriteCMD( CMD_COLORSUBTABLE ); |
||
918 | trWriteEnum( target ); |
||
919 | trWriteSizei( start ); |
||
920 | trWriteSizei( count ); |
||
921 | trWriteEnum( format ); |
||
922 | trWriteEnum( type ); |
||
923 | trWritePointer( (void *)data ); |
||
924 | trFileFlush(); |
||
925 | |||
926 | pixelsize = trGetPixelSize( format, type ); |
||
927 | trWriteTypeArray( type, count, pixelsize, start, data ); |
||
928 | |||
929 | if( trCtx()->doExec ) { |
||
930 | trGetDispatch()->ColorSubTable( target, start, count, format, type, data ); |
||
931 | trError(); |
||
932 | } |
||
933 | } |
||
934 | |||
935 | |||
936 | #if 0 |
||
937 | // Not in MESAs dispatch table |
||
938 | GLAPI void GLAPIENTRY trColorTableEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table ) { |
||
939 | GLint pixelsize; |
||
940 | |||
941 | trWriteCMD( CMD_COLORTABLEEXT ); |
||
942 | trWriteEnum( target ); |
||
943 | trWriteEnum( internalformat ); |
||
944 | trWriteSizei( width ); |
||
945 | trWriteEnum( format ); |
||
946 | trWriteEnum( type ); |
||
947 | trWritePointer( (void *)table ); |
||
948 | trFileFlush(); |
||
949 | |||
950 | pixelsize = trGetPixelSize( format, type ); |
||
951 | trWriteTypeArray( type, width, pixelsize, 0, table ); |
||
952 | |||
953 | if( trCtx()->doExec ) { |
||
954 | trGetDispatch()->ColorTableEXT( target, internalformat, width, format, type, table ); |
||
955 | trError(); |
||
956 | } |
||
957 | } |
||
958 | #endif |
||
959 | |||
960 | |||
961 | GLAPI void GLAPIENTRY trColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table ) { /* TODO */ |
||
962 | GLint pixelsize; |
||
963 | |||
964 | trWriteCMD( CMD_COLORTABLE ); |
||
965 | trWriteEnum( target ); |
||
966 | trWriteEnum( internalformat ); |
||
967 | trWriteSizei( width ); |
||
968 | trWriteEnum( format ); |
||
969 | trWriteEnum( type ); |
||
970 | trWritePointer( (void *)table ); |
||
971 | trFileFlush(); |
||
972 | |||
973 | if( trCtx()->doExec ) { |
||
974 | trGetDispatch()->ColorTable( target, internalformat, width, format, type, table ); |
||
975 | trError(); |
||
976 | } |
||
977 | } |
||
978 | |||
979 | |||
980 | GLAPI void GLAPIENTRY trColorTableParameterfv( GLenum target, GLenum pname, const GLfloat *params) { |
||
981 | trWriteCMD( CMD_COLORTABLEPARAMETERFV ); |
||
982 | trWriteEnum( target ); |
||
983 | trWriteEnum( pname ); |
||
984 | trWritePointer( (void *)params ); |
||
985 | trFileFlush(); |
||
986 | trWriteArrayf( 4, params ); |
||
987 | |||
988 | if( trCtx()->doExec ) { |
||
989 | trGetDispatch()->ColorTableParameterfv( target, pname, params ); |
||
990 | trError(); |
||
991 | } |
||
992 | } |
||
993 | |||
994 | |||
995 | GLAPI void GLAPIENTRY trColorTableParameteriv( GLenum target, GLenum pname, const GLint *params) { |
||
996 | trWriteCMD( CMD_COLORTABLEPARAMETERIV ); |
||
997 | trWriteEnum( target ); |
||
998 | trWriteEnum( pname ); |
||
999 | trWritePointer( (void *)params ); |
||
1000 | trFileFlush(); |
||
1001 | trWriteArrayi( 4, params ); |
||
1002 | |||
1003 | if( trCtx()->doExec ) { |
||
1004 | trGetDispatch()->ColorTableParameteriv( target, pname, params ); |
||
1005 | trError(); |
||
1006 | } |
||
1007 | } |
||
1008 | |||
1009 | |||
1010 | GLAPI void GLAPIENTRY trConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image ) { |
||
1011 | GLint pixelsize; |
||
1012 | |||
1013 | trWriteCMD( CMD_CONVOLUTIONFILTER1D ); |
||
1014 | trWriteEnum( target ); |
||
1015 | trWriteEnum( internalformat ); |
||
1016 | trWriteSizei( width ); |
||
1017 | trWriteEnum( format ); |
||
1018 | trWriteEnum( type ); |
||
1019 | trWritePointer( (void *)image ); |
||
1020 | trFileFlush(); |
||
1021 | |||
1022 | pixelsize = trGetPixelSize( format, type ); |
||
1023 | trWriteTypeArray( type, width, pixelsize, 0, image ); |
||
1024 | |||
1025 | if( trCtx()->doExec ) { |
||
1026 | trGetDispatch()->ConvolutionFilter1D( target, internalformat, width, format, type, image ); |
||
1027 | trError(); |
||
1028 | } |
||
1029 | } |
||
1030 | |||
1031 | |||
1032 | GLAPI void GLAPIENTRY trConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image ) { |
||
1033 | GLint i; |
||
1034 | GLint pixelsize; |
||
1035 | |||
1036 | trWriteCMD( CMD_CONVOLUTIONFILTER2D ); |
||
1037 | trWriteEnum( target ); |
||
1038 | trWriteEnum( internalformat ); |
||
1039 | trWriteSizei( width ); |
||
1040 | trWriteSizei( height ); |
||
1041 | trWriteEnum( format ); |
||
1042 | trWriteEnum( type ); |
||
1043 | trWritePointer( (void *)image ); |
||
1044 | trFileFlush(); |
||
1045 | |||
1046 | /* p76 of GL spec says this isn't subject to unpack_row_width... */ |
||
1047 | pixelsize = trGetPixelSize( format, type ); |
||
1048 | for( i = 0; i < height; i++ ) { |
||
1049 | trWriteTypeArray( type, width, pixelsize, i * width, image ); |
||
1050 | } |
||
1051 | |||
1052 | if( trCtx()->doExec ) { |
||
1053 | trGetDispatch()->ConvolutionFilter2D( target, internalformat, width, height, format, type, image ); |
||
1054 | trError(); |
||
1055 | } |
||
1056 | } |
||
1057 | |||
1058 | |||
1059 | GLAPI void GLAPIENTRY trConvolutionParameterf( GLenum target, GLenum pname, GLfloat params ) { |
||
1060 | trWriteCMD( CMD_CONVOLUTIONPARAMETERF ); |
||
1061 | trWriteEnum( target ); |
||
1062 | trWriteEnum( pname ); |
||
1063 | trWritef( params ); |
||
1064 | |||
1065 | if( trCtx()->doExec ) { |
||
1066 | trGetDispatch()->ConvolutionParameterf( target, pname, params ); |
||
1067 | trError(); |
||
1068 | } |
||
1069 | } |
||
1070 | |||
1071 | |||
1072 | GLAPI void GLAPIENTRY trConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params ) { |
||
1073 | trWriteCMD( CMD_CONVOLUTIONPARAMETERFV ); |
||
1074 | trWriteEnum( target ); |
||
1075 | trWriteEnum( pname ); |
||
1076 | trWritePointer( (void *)params ); |
||
1077 | trFileFlush(); |
||
1078 | |||
1079 | switch( pname ) { |
||
1080 | case GL_CONVOLUTION_BORDER_MODE: |
||
1081 | trWritef( params[0] ); |
||
1082 | break; |
||
1083 | case GL_CONVOLUTION_BORDER_COLOR: |
||
1084 | trWriteArrayf( 4, params ); |
||
1085 | break; |
||
1086 | default: |
||
1087 | /* The 2nd pass should catch this */ |
||
1088 | break; |
||
1089 | } |
||
1090 | |||
1091 | if( trCtx()->doExec ) { |
||
1092 | trGetDispatch()->ConvolutionParameterfv( target, pname, params ); |
||
1093 | trError(); |
||
1094 | } |
||
1095 | } |
||
1096 | |||
1097 | |||
1098 | GLAPI void GLAPIENTRY trConvolutionParameteri( GLenum target, GLenum pname, GLint params ) { |
||
1099 | trWriteCMD( CMD_CONVOLUTIONPARAMETERI ); |
||
1100 | trWriteEnum( target ); |
||
1101 | trWriteEnum( pname ); |
||
1102 | trWritei( params ); |
||
1103 | |||
1104 | if( trCtx()->doExec ) { |
||
1105 | trGetDispatch()->ConvolutionParameteri( target, pname, params ); |
||
1106 | trError(); |
||
1107 | } |
||
1108 | } |
||
1109 | |||
1110 | |||
1111 | GLAPI void GLAPIENTRY trConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params ) { |
||
1112 | trWriteCMD( CMD_CONVOLUTIONPARAMETERIV ); |
||
1113 | trWriteEnum( target ); |
||
1114 | trWriteEnum( pname ); |
||
1115 | trWritePointer( (void *)params ); |
||
1116 | trFileFlush(); |
||
1117 | |||
1118 | switch( pname ) { |
||
1119 | case GL_CONVOLUTION_BORDER_MODE: |
||
1120 | trWritei( params[0] ); |
||
1121 | break; |
||
1122 | case GL_CONVOLUTION_BORDER_COLOR: |
||
1123 | trWriteArrayi( 4, params ); |
||
1124 | break; |
||
1125 | default: |
||
1126 | /* The 2nd pass should catch this */ |
||
1127 | break; |
||
1128 | } |
||
1129 | |||
1130 | if( trCtx()->doExec ) { |
||
1131 | trGetDispatch()->ConvolutionParameteriv( target, pname, params ); |
||
1132 | trError(); |
||
1133 | } |
||
1134 | } |
||
1135 | |||
1136 | |||
1137 | GLAPI void GLAPIENTRY trCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) { |
||
1138 | trWriteCMD( CMD_COPYCOLORSUBTABLE ); |
||
1139 | trWriteEnum( target ); |
||
1140 | trWriteSizei( start ); |
||
1141 | trWritei( x ); |
||
1142 | trWritei( y ); |
||
1143 | trWriteSizei( width ); |
||
1144 | |||
1145 | if( trCtx()->doExec ) { |
||
1146 | trGetDispatch()->CopyColorSubTable( target, start, x, y, width ); |
||
1147 | trError(); |
||
1148 | } |
||
1149 | } |
||
1150 | |||
1151 | |||
1152 | GLAPI void GLAPIENTRY trCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) { |
||
1153 | trWriteCMD( CMD_COPYCOLORTABLE ); |
||
1154 | trWriteEnum( target ); |
||
1155 | trWriteEnum( internalformat ); |
||
1156 | trWritei( x ); |
||
1157 | trWritei( y ); |
||
1158 | trWriteSizei( width ); |
||
1159 | |||
1160 | if( trCtx()->doExec ) { |
||
1161 | trGetDispatch()->CopyColorTable( target, internalformat, x, y, width ); |
||
1162 | trError(); |
||
1163 | } |
||
1164 | } |
||
1165 | |||
1166 | |||
1167 | GLAPI void GLAPIENTRY trCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) { |
||
1168 | trWriteCMD( CMD_COPYCONVOLUTIONFILTER1D ); |
||
1169 | trWriteEnum( target ); |
||
1170 | trWriteEnum( internalformat ); |
||
1171 | trWritei( x ); |
||
1172 | trWritei( y ); |
||
1173 | trWriteSizei( width ); |
||
1174 | |||
1175 | if( trCtx()->doExec ) { |
||
1176 | trGetDispatch()->CopyConvolutionFilter1D( target, internalformat, x, y, width ); |
||
1177 | trError(); |
||
1178 | } |
||
1179 | } |
||
1180 | |||
1181 | |||
1182 | GLAPI void GLAPIENTRY trCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) { |
||
1183 | trWriteCMD( CMD_COPYCONVOLUTIONFILTER2D ); |
||
1184 | trWriteEnum( target ); |
||
1185 | trWriteEnum( internalformat ); |
||
1186 | trWritei( x ); |
||
1187 | trWritei( y ); |
||
1188 | trWriteSizei( width ); |
||
1189 | trWriteSizei( height ); |
||
1190 | |||
1191 | if( trCtx()->doExec ) { |
||
1192 | trGetDispatch()->CopyConvolutionFilter2D( target, internalformat, x, y, width, height ); |
||
1193 | trError(); |
||
1194 | } |
||
1195 | } |
||
1196 | |||
1197 | |||
1198 | GLAPI void GLAPIENTRY trCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) { |
||
1199 | trWriteCMD( CMD_COPYPIXELS ); |
||
1200 | trWritei( x ); |
||
1201 | trWritei( y ); |
||
1202 | trWriteSizei( width ); |
||
1203 | trWriteSizei( height ); |
||
1204 | trWriteEnum( type ); |
||
1205 | |||
1206 | if( trCtx()->doExec ) { |
||
1207 | trGetDispatch()->CopyPixels( x, y, width, height, type ); |
||
1208 | trError(); |
||
1209 | } |
||
1210 | } |
||
1211 | |||
1212 | |||
1213 | GLAPI void GLAPIENTRY trCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) { |
||
1214 | trWriteCMD( CMD_COPYTEXIMAGE1D ); |
||
1215 | trWriteEnum( target ); |
||
1216 | trWritei( level ); |
||
1217 | trWriteEnum( internalformat ); |
||
1218 | trWritei( x ); |
||
1219 | trWritei( y ); |
||
1220 | trWriteSizei( width ); |
||
1221 | trWritei( border ); |
||
1222 | |||
1223 | if( trCtx()->doExec ) { |
||
1224 | trGetDispatch()->CopyTexImage1D( target, level, internalformat, x, y, width, border ); |
||
1225 | trError(); |
||
1226 | } |
||
1227 | } |
||
1228 | |||
1229 | |||
1230 | GLAPI void GLAPIENTRY trCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) { |
||
1231 | trWriteCMD( CMD_COPYTEXIMAGE2D ); |
||
1232 | trWriteEnum( target ); |
||
1233 | trWritei( level ); |
||
1234 | trWriteEnum( internalformat ); |
||
1235 | trWritei( x ); |
||
1236 | trWritei( y ); |
||
1237 | trWriteSizei( width ); |
||
1238 | trWriteSizei( height ); |
||
1239 | trWritei( border ); |
||
1240 | |||
1241 | if( trCtx()->doExec ) { |
||
1242 | trGetDispatch()->CopyTexImage2D( target, level, internalformat, x, y, width, height, border ); |
||
1243 | trError(); |
||
1244 | } |
||
1245 | } |
||
1246 | |||
1247 | |||
1248 | GLAPI void GLAPIENTRY trCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) { |
||
1249 | trWriteCMD( CMD_COPYTEXSUBIMAGE1D ); |
||
1250 | trWriteEnum( target ); |
||
1251 | trWritei( level ); |
||
1252 | trWritei( xoffset ); |
||
1253 | trWritei( x ); |
||
1254 | trWritei( y ); |
||
1255 | trWriteSizei( width ); |
||
1256 | |||
1257 | if( trCtx()->doExec ) { |
||
1258 | trGetDispatch()->CopyTexSubImage1D( target, level, xoffset, x, y, width ); |
||
1259 | trError(); |
||
1260 | } |
||
1261 | } |
||
1262 | |||
1263 | |||
1264 | GLAPI void GLAPIENTRY trCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { |
||
1265 | trWriteCMD( CMD_COPYTEXSUBIMAGE2D ); |
||
1266 | trWriteEnum( target ); |
||
1267 | trWritei( level ); |
||
1268 | trWritei( xoffset ); |
||
1269 | trWritei( yoffset ); |
||
1270 | trWritei( x ); |
||
1271 | trWritei( y ); |
||
1272 | trWriteSizei( width ); |
||
1273 | trWriteSizei( height ); |
||
1274 | |||
1275 | if( trCtx()->doExec ) { |
||
1276 | trGetDispatch()->CopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height ); |
||
1277 | trError(); |
||
1278 | } |
||
1279 | } |
||
1280 | |||
1281 | |||
1282 | #if 0 |
||
1283 | // Not in MESAs dispatch table |
||
1284 | GLAPI void GLAPIENTRY trCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { |
||
1285 | trWriteCMD( CMD_COPYTEXSUBIMAGE3DEXT ); |
||
1286 | trWriteEnum( target ); |
||
1287 | trWritei( level ); |
||
1288 | trWritei( xoffset ); |
||
1289 | trWritei( yoffset ); |
||
1290 | trWritei( zoffset ); |
||
1291 | trWritei( x ); |
||
1292 | trWritei( y ); |
||
1293 | trWriteSizei( width ); |
||
1294 | trWriteSizei( height ); |
||
1295 | |||
1296 | if( trCtx()->doExec ) { |
||
1297 | trGetDispatch()->CopyTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, x, y, width, height ); |
||
1298 | trError(); |
||
1299 | } |
||
1300 | } |
||
1301 | #endif |
||
1302 | |||
1303 | |||
1304 | GLAPI void GLAPIENTRY trCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { |
||
1305 | trWriteCMD( CMD_COPYTEXSUBIMAGE3D ); |
||
1306 | trWriteEnum( target ); |
||
1307 | trWritei( level ); |
||
1308 | trWritei( xoffset ); |
||
1309 | trWritei( yoffset ); |
||
1310 | trWritei( zoffset ); |
||
1311 | trWritei( x ); |
||
1312 | trWritei( y ); |
||
1313 | trWriteSizei( width ); |
||
1314 | trWriteSizei( height ); |
||
1315 | |||
1316 | if( trCtx()->doExec ) { |
||
1317 | trGetDispatch()->CopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height ); |
||
1318 | trError(); |
||
1319 | } |
||
1320 | } |
||
1321 | |||
1322 | |||
1323 | GLAPI void GLAPIENTRY trCullFace( GLenum mode ) { |
||
1324 | trWriteCMD( CMD_CULLFACE ); |
||
1325 | trWriteEnum( mode ); |
||
1326 | |||
1327 | if( trCtx()->doExec ) { |
||
1328 | trGetDispatch()->CullFace( mode ); |
||
1329 | trError(); |
||
1330 | } |
||
1331 | } |
||
1332 | |||
1333 | |||
1334 | GLAPI void GLAPIENTRY trDeleteLists( GLuint list, GLsizei range ) { |
||
1335 | trWriteCMD( CMD_DELETELISTS ); |
||
1336 | trWriteui( list ); |
||
1337 | trWriteSizei( range ); |
||
1338 | |||
1339 | if( trCtx()->doExec ) { |
||
1340 | trGetDispatch()->DeleteLists( list, range ); |
||
1341 | trError(); |
||
1342 | } |
||
1343 | } |
||
1344 | |||
1345 | |||
1346 | #if 0 |
||
1347 | // Not in MESAs dispatch table |
||
1348 | GLAPI void GLAPIENTRY trDeleteTexturesEXT( GLsizei n, const GLuint *textures) { |
||
1349 | trWriteCMD( CMD_DELETETEXTURESEXT ); |
||
1350 | trWriteSizei( n ); |
||
1351 | trWritePointer( (void *)textures ); |
||
1352 | trFileFlush(); |
||
1353 | trWriteArrayui( n, textures ); |
||
1354 | |||
1355 | if( trCtx()->doExec ) { |
||
1356 | trGetDispatch()->DeleteTexturesEXT( n, textures ); |
||
1357 | trError(); |
||
1358 | } |
||
1359 | } |
||
1360 | #endif |
||
1361 | |||
1362 | |||
1363 | GLAPI void GLAPIENTRY trDeleteTextures( GLsizei n, const GLuint *textures) { |
||
1364 | trWriteCMD( CMD_DELETETEXTURES ); |
||
1365 | trWriteSizei( n ); |
||
1366 | trWritePointer( (void *)textures ); |
||
1367 | trFileFlush(); |
||
1368 | trWriteArrayui( n, textures ); |
||
1369 | |||
1370 | if( trCtx()->doExec ) { |
||
1371 | trGetDispatch()->DeleteTextures( n, textures ); |
||
1372 | trError(); |
||
1373 | } |
||
1374 | } |
||
1375 | |||
1376 | |||
1377 | GLAPI void GLAPIENTRY trDepthFunc( GLenum func ) { |
||
1378 | trWriteCMD( CMD_DEPTHFUNC ); |
||
1379 | trWriteEnum( func ); |
||
1380 | |||
1381 | if( trCtx()->doExec ) { |
||
1382 | trGetDispatch()->DepthFunc( func ); |
||
1383 | trError(); |
||
1384 | } |
||
1385 | } |
||
1386 | |||
1387 | |||
1388 | GLAPI void GLAPIENTRY trDepthMask( GLboolean flag ) { |
||
1389 | trWriteCMD( CMD_DEPTHMASK ); |
||
1390 | trWriteBool( flag ); |
||
1391 | |||
1392 | if( trCtx()->doExec ) { |
||
1393 | trGetDispatch()->DepthMask( flag ); |
||
1394 | trError(); |
||
1395 | } |
||
1396 | } |
||
1397 | |||
1398 | |||
1399 | GLAPI void GLAPIENTRY trDepthRange( GLclampd near_val, GLclampd far_val ) { |
||
1400 | trWriteCMD( CMD_DEPTHRANGE ); |
||
1401 | trWriteClampd( near_val ); |
||
1402 | trWriteClampd( far_val ); |
||
1403 | |||
1404 | if( trCtx()->doExec ) { |
||
1405 | trGetDispatch()->DepthRange( near_val, far_val ); |
||
1406 | trError(); |
||
1407 | } |
||
1408 | } |
||
1409 | |||
1410 | |||
1411 | GLAPI void GLAPIENTRY trDisableClientState( GLenum cap ) { |
||
1412 | trace_context_t * tctx; |
||
1413 | |||
1414 | trWriteCMD( CMD_DISABLECLIENTSTATE ); |
||
1415 | trWriteEnum( cap ); |
||
1416 | |||
1417 | tctx = trCtx(); |
||
1418 | |||
1419 | if( tctx->doExec ) { |
||
1420 | trGetDispatch()->DisableClientState( cap ); |
||
1421 | trError(); |
||
1422 | } |
||
1423 | } |
||
1424 | |||
1425 | |||
1426 | GLAPI void GLAPIENTRY trDisable( GLenum cap ) { |
||
1427 | trWriteCMD( CMD_DISABLE ); |
||
1428 | trWriteEnum( cap ); |
||
1429 | |||
1430 | if( trCtx()->doExec ) { |
||
1431 | trGetDispatch()->Disable( cap ); |
||
1432 | trError(); |
||
1433 | } |
||
1434 | } |
||
1435 | |||
1436 | |||
1437 | #if 0 |
||
1438 | // Not in MESAs dispatch table |
||
1439 | GLAPI void GLAPIENTRY trDrawArraysEXT( GLenum mode, GLint first, GLsizei count ) { |
||
1440 | trWriteCMD( CMD_DRAWARRAYSEXT ); |
||
1441 | trWriteEnum( mode ); |
||
1442 | trWritei( first ); |
||
1443 | trWriteSizei( count ); |
||
1444 | |||
1445 | if( trCtx()->doExec ) { |
||
1446 | trGetDispatch()->DrawArraysEXT( mode, first, count ); |
||
1447 | trError(); |
||
1448 | } |
||
1449 | } |
||
1450 | #endif |
||
1451 | |||
1452 | |||
1453 | GLAPI void GLAPIENTRY trDrawArrays( GLenum mode, GLint first, GLsizei count ) { |
||
1454 | |||
1455 | trWriteCMD( CMD_DRAWARRAYS ); |
||
1456 | trWriteEnum( mode ); |
||
1457 | trWritei( first ); |
||
1458 | trWriteSizei( count ); |
||
1459 | |||
1460 | if( trCtx()->doExec ) { |
||
1461 | trGetDispatch()->DrawArrays( mode, first, count ); |
||
1462 | trError(); |
||
1463 | } |
||
1464 | } |
||
1465 | |||
1466 | |||
1467 | GLAPI void GLAPIENTRY trDrawBuffer( GLenum mode ) { |
||
1468 | trWriteCMD( CMD_DRAWBUFFER ); |
||
1469 | trWriteEnum( mode ); |
||
1470 | |||
1471 | if( trCtx()->doExec ) { |
||
1472 | trGetDispatch()->DrawBuffer( mode ); |
||
1473 | trError(); |
||
1474 | } |
||
1475 | } |
||
1476 | |||
1477 | |||
1478 | GLAPI void GLAPIENTRY trDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) { |
||
1479 | trace_context_t * tctx; |
||
1480 | |||
1481 | trWriteCMD( CMD_DRAWELEMENTS ); |
||
1482 | trWriteEnum( mode ); |
||
1483 | trWriteSizei( count ); |
||
1484 | trWriteEnum( type ); |
||
1485 | trWritePointer( (void *)indices ); |
||
1486 | trFileFlush(); |
||
1487 | /* Why isn't the indices a GLint * ? */ |
||
1488 | trWriteArrayi( count, (GLint *)indices ); |
||
1489 | |||
1490 | tctx = trCtx(); |
||
1491 | |||
1492 | if( tctx->doExec ) { |
||
1493 | trGetDispatch()->DrawElements( mode, count, type, indices ); |
||
1494 | trError(); |
||
1495 | } |
||
1496 | } |
||
1497 | |||
1498 | |||
1499 | GLAPI void GLAPIENTRY trDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */ |
||
1500 | GLint pixelsize; |
||
1501 | |||
1502 | trWriteCMD( CMD_DRAWPIXELS ); |
||
1503 | trWriteSizei( width ); |
||
1504 | trWriteSizei( height ); |
||
1505 | trWriteEnum( format ); |
||
1506 | trWriteEnum( type ); |
||
1507 | trWritePointer( (void *)pixels ); |
||
1508 | trFileFlush(); |
||
1509 | |||
1510 | if( trCtx()->doExec ) { |
||
1511 | trGetDispatch()->DrawPixels( width, height, format, type, pixels ); |
||
1512 | trError(); |
||
1513 | } |
||
1514 | } |
||
1515 | |||
1516 | |||
1517 | GLAPI void GLAPIENTRY trDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices ) { |
||
1518 | trace_context_t * tctx; |
||
1519 | |||
1520 | trWriteCMD( CMD_DRAWRANGEELEMENTS ); |
||
1521 | trWriteEnum( mode ); |
||
1522 | trWriteui( start ); |
||
1523 | trWriteui( end ); |
||
1524 | trWriteSizei( count ); |
||
1525 | trWriteEnum( type ); |
||
1526 | trWritePointer( (void *)indices ); |
||
1527 | trFileFlush(); |
||
1528 | switch( type ) { |
||
1529 | case GL_UNSIGNED_BYTE: |
||
1530 | trWriteArrayub( count, (GLubyte *)indices ); |
||
1531 | break; |
||
1532 | case GL_UNSIGNED_SHORT: |
||
1533 | trWriteArrayus( count, (GLushort *)indices ); |
||
1534 | break; |
||
1535 | case GL_UNSIGNED_INT: |
||
1536 | trWriteArrayui( count, (GLuint *)indices ); |
||
1537 | break; |
||
1538 | default: |
||
1539 | /* The 2nd pass should catch this. */ |
||
1540 | break; |
||
1541 | } |
||
1542 | |||
1543 | tctx = trCtx(); |
||
1544 | |||
1545 | if( trCtx()->doExec ) { |
||
1546 | trGetDispatch()->DrawRangeElements( mode, start, end, count, type, indices ); |
||
1547 | trError(); |
||
1548 | } |
||
1549 | } |
||
1550 | |||
1551 | |||
1552 | GLAPI void GLAPIENTRY trEdgeFlag( GLboolean flag ) { |
||
1553 | trWriteCMD( CMD_EDGEFLAG ); |
||
1554 | trWriteBool( flag ); |
||
1555 | |||
1556 | if( trCtx()->doExec ) { |
||
1557 | trGetDispatch()->EdgeFlag( flag ); |
||
1558 | trError(); |
||
1559 | } |
||
1560 | } |
||
1561 | |||
1562 | |||
1563 | GLAPI void GLAPIENTRY trEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean *ptr ) { /* TODO */ |
||
1564 | trWriteCMD( CMD_EDGEFLAGPOINTEREXT ); |
||
1565 | trWriteSizei( stride ); |
||
1566 | trWriteSizei( count ); |
||
1567 | trWritePointer( (void *)ptr ); |
||
1568 | trFileFlush(); |
||
1569 | |||
1570 | if( trCtx()->doExec ) { |
||
1571 | trGetDispatch()->EdgeFlagPointerEXT( stride, count, ptr ); |
||
1572 | trError(); |
||
1573 | } |
||
1574 | } |
||
1575 | |||
1576 | |||
1577 | GLAPI void GLAPIENTRY trEdgeFlagPointer( GLsizei stride, const GLvoid *ptr ) { /* TODO */ |
||
1578 | trace_context_t * tctx; |
||
1579 | |||
1580 | trWriteCMD( CMD_EDGEFLAGPOINTER ); |
||
1581 | trWriteSizei( stride ); |
||
1582 | trWritePointer( (void *)ptr ); |
||
1583 | trFileFlush(); |
||
1584 | |||
1585 | tctx = trCtx(); |
||
1586 | |||
1587 | if( tctx->doExec ) { |
||
1588 | trGetDispatch()->EdgeFlagPointer( stride, ptr ); |
||
1589 | trError(); |
||
1590 | } |
||
1591 | } |
||
1592 | |||
1593 | |||
1594 | GLAPI void GLAPIENTRY trEdgeFlagv( const GLboolean *flag ) { |
||
1595 | trWriteCMD( CMD_EDGEFLAGV ); |
||
1596 | trWritePointer( (void *)flag ); |
||
1597 | trFileFlush(); |
||
1598 | trWriteBool( flag[0] ); |
||
1599 | |||
1600 | if( trCtx()->doExec ) { |
||
1601 | trGetDispatch()->EdgeFlagv( flag ); |
||
1602 | trError(); |
||
1603 | } |
||
1604 | } |
||
1605 | |||
1606 | |||
1607 | GLAPI void GLAPIENTRY trEnableClientState( GLenum cap ) { |
||
1608 | trace_context_t * tctx; |
||
1609 | |||
1610 | trWriteCMD( CMD_ENABLECLIENTSTATE ); |
||
1611 | trWriteEnum( cap ); |
||
1612 | |||
1613 | tctx = trCtx(); |
||
1614 | |||
1615 | if( tctx->doExec ) { |
||
1616 | trGetDispatch()->EnableClientState( cap ); |
||
1617 | trError(); |
||
1618 | } |
||
1619 | } |
||
1620 | |||
1621 | |||
1622 | GLAPI void GLAPIENTRY trEnable( GLenum cap ) { |
||
1623 | trWriteCMD( CMD_ENABLE ); |
||
1624 | trWriteEnum( cap ); |
||
1625 | |||
1626 | if( trCtx()->doExec ) { |
||
1627 | trGetDispatch()->Enable( cap ); |
||
1628 | trError(); |
||
1629 | } |
||
1630 | } |
||
1631 | |||
1632 | |||
1633 | GLAPI void GLAPIENTRY trEndList( void ) { |
||
1634 | trWriteCMD( CMD_ENDLIST ); |
||
1635 | |||
1636 | if( trCtx()->doExec ) { |
||
1637 | trGetDispatch()->EndList( ); |
||
1638 | trError(); |
||
1639 | } |
||
1640 | } |
||
1641 | |||
1642 | |||
1643 | GLAPI void GLAPIENTRY trEnd( void ) { |
||
1644 | trWriteCMD( CMD_END ); |
||
1645 | |||
1646 | if( trCtx()->doExec ) { |
||
1647 | trGetDispatch()->End( ); |
||
1648 | trError(); |
||
1649 | } |
||
1650 | } |
||
1651 | |||
1652 | |||
1653 | GLAPI void GLAPIENTRY trEvalCoord1d( GLdouble u ) { |
||
1654 | trWriteCMD( CMD_EVALCOORD1D ); |
||
1655 | trWrited( u ); |
||
1656 | |||
1657 | if( trCtx()->doExec ) { |
||
1658 | trGetDispatch()->EvalCoord1d( u ); |
||
1659 | trError(); |
||
1660 | } |
||
1661 | } |
||
1662 | |||
1663 | |||
1664 | GLAPI void GLAPIENTRY trEvalCoord1dv( const GLdouble *u ) { |
||
1665 | trWriteCMD( CMD_EVALCOORD1DV ); |
||
1666 | trWritePointer( (void *)u ); |
||
1667 | trFileFlush(); |
||
1668 | trWrited( u[0] ); |
||
1669 | |||
1670 | if( trCtx()->doExec ) { |
||
1671 | trGetDispatch()->EvalCoord1dv( u ); |
||
1672 | trError(); |
||
1673 | } |
||
1674 | } |
||
1675 | |||
1676 | |||
1677 | GLAPI void GLAPIENTRY trEvalCoord1f( GLfloat u ) { |
||
1678 | trWriteCMD( CMD_EVALCOORD1F ); |
||
1679 | trWritef( u ); |
||
1680 | |||
1681 | if( trCtx()->doExec ) { |
||
1682 | trGetDispatch()->EvalCoord1f( u ); |
||
1683 | trError(); |
||
1684 | } |
||
1685 | } |
||
1686 | |||
1687 | |||
1688 | GLAPI void GLAPIENTRY trEvalCoord1fv( const GLfloat *u ) { |
||
1689 | trWriteCMD( CMD_EVALCOORD1FV ); |
||
1690 | trWritePointer( (void *)u ); |
||
1691 | trFileFlush(); |
||
1692 | trWritef( u[0] ); |
||
1693 | |||
1694 | if( trCtx()->doExec ) { |
||
1695 | trGetDispatch()->EvalCoord1fv( u ); |
||
1696 | trError(); |
||
1697 | } |
||
1698 | } |
||
1699 | |||
1700 | |||
1701 | GLAPI void GLAPIENTRY trEvalCoord2d( GLdouble u, GLdouble v ) { |
||
1702 | trWriteCMD( CMD_EVALCOORD2D ); |
||
1703 | trWrited( u ); |
||
1704 | trWrited( v ); |
||
1705 | |||
1706 | if( trCtx()->doExec ) { |
||
1707 | trGetDispatch()->EvalCoord2d( u, v ); |
||
1708 | trError(); |
||
1709 | } |
||
1710 | } |
||
1711 | |||
1712 | |||
1713 | GLAPI void GLAPIENTRY trEvalCoord2dv( const GLdouble *u ) { |
||
1714 | trWriteCMD( CMD_EVALCOORD2DV ); |
||
1715 | trWritePointer( (void *)u ); |
||
1716 | trFileFlush(); |
||
1717 | trWriteArrayd( 2, u ); |
||
1718 | |||
1719 | if( trCtx()->doExec ) { |
||
1720 | trGetDispatch()->EvalCoord2dv( u ); |
||
1721 | trError(); |
||
1722 | } |
||
1723 | } |
||
1724 | |||
1725 | |||
1726 | GLAPI void GLAPIENTRY trEvalCoord2f( GLfloat u, GLfloat v ) { |
||
1727 | trWriteCMD( CMD_EVALCOORD2F ); |
||
1728 | trWritef( u ); |
||
1729 | trWritef( v ); |
||
1730 | |||
1731 | if( trCtx()->doExec ) { |
||
1732 | trGetDispatch()->EvalCoord2f( u, v ); |
||
1733 | trError(); |
||
1734 | } |
||
1735 | } |
||
1736 | |||
1737 | |||
1738 | GLAPI void GLAPIENTRY trEvalCoord2fv( const GLfloat *u ) { |
||
1739 | trWriteCMD( CMD_EVALCOORD2FV ); |
||
1740 | trWritePointer( (void *)u ); |
||
1741 | trFileFlush(); |
||
1742 | trWriteArrayf( 2, u ); |
||
1743 | |||
1744 | if( trCtx()->doExec ) { |
||
1745 | trGetDispatch()->EvalCoord2fv( u ); |
||
1746 | trError(); |
||
1747 | } |
||
1748 | } |
||
1749 | |||
1750 | |||
1751 | GLAPI void GLAPIENTRY trEvalMesh1( GLenum mode, GLint i1, GLint i2 ) { |
||
1752 | trWriteCMD( CMD_EVALMESH1 ); |
||
1753 | trWriteEnum( mode ); |
||
1754 | trWritei( i1 ); |
||
1755 | trWritei( i2 ); |
||
1756 | |||
1757 | if( trCtx()->doExec ) { |
||
1758 | trGetDispatch()->EvalMesh1( mode, i1, i2 ); |
||
1759 | trError(); |
||
1760 | } |
||
1761 | } |
||
1762 | |||
1763 | |||
1764 | GLAPI void GLAPIENTRY trEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) { |
||
1765 | trWriteCMD( CMD_EVALMESH2 ); |
||
1766 | trWriteEnum( mode ); |
||
1767 | trWritei( i1 ); |
||
1768 | trWritei( i2 ); |
||
1769 | trWritei( j1 ); |
||
1770 | trWritei( j2 ); |
||
1771 | |||
1772 | if( trCtx()->doExec ) { |
||
1773 | trGetDispatch()->EvalMesh2( mode, i1, i2, j1, j2 ); |
||
1774 | trError(); |
||
1775 | } |
||
1776 | } |
||
1777 | |||
1778 | |||
1779 | GLAPI void GLAPIENTRY trEvalPoint1( GLint i ) { |
||
1780 | trWriteCMD( CMD_EVALPOINT1 ); |
||
1781 | trWritei( i ); |
||
1782 | |||
1783 | if( trCtx()->doExec ) { |
||
1784 | trGetDispatch()->EvalPoint1( i ); |
||
1785 | trError(); |
||
1786 | } |
||
1787 | } |
||
1788 | |||
1789 | |||
1790 | GLAPI void GLAPIENTRY trEvalPoint2( GLint i, GLint j ) { |
||
1791 | trWriteCMD( CMD_EVALPOINT2 ); |
||
1792 | trWritei( i ); |
||
1793 | trWritei( j ); |
||
1794 | |||
1795 | if( trCtx()->doExec ) { |
||
1796 | trGetDispatch()->EvalPoint2( i, j ); |
||
1797 | trError(); |
||
1798 | } |
||
1799 | } |
||
1800 | |||
1801 | |||
1802 | GLAPI void GLAPIENTRY trFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer ) { |
||
1803 | trWriteCMD( CMD_FEEDBACKBUFFER ); |
||
1804 | trWriteSizei( size ); |
||
1805 | trWriteEnum( type ); |
||
1806 | trWritePointer( (void *)buffer ); |
||
1807 | trFileFlush(); |
||
1808 | |||
1809 | if( trCtx()->doExec ) { |
||
1810 | trGetDispatch()->FeedbackBuffer( size, type, buffer ); |
||
1811 | trError(); |
||
1812 | } |
||
1813 | } |
||
1814 | |||
1815 | |||
1816 | GLAPI void GLAPIENTRY trFinish( void ) { |
||
1817 | trWriteCMD( CMD_FINISH ); |
||
1818 | |||
1819 | if( trCtx()->doExec ) { |
||
1820 | trGetDispatch()->Finish( ); |
||
1821 | trError(); |
||
1822 | } |
||
1823 | } |
||
1824 | |||
1825 | |||
1826 | GLAPI void GLAPIENTRY trFlush( void ) { |
||
1827 | trWriteCMD( CMD_FLUSH ); |
||
1828 | |||
1829 | if( trCtx()->doExec ) { |
||
1830 | trGetDispatch()->Flush( ); |
||
1831 | trError(); |
||
1832 | } |
||
1833 | } |
||
1834 | |||
1835 | |||
1836 | GLAPI void GLAPIENTRY trFogf( GLenum pname, GLfloat param ) { |
||
1837 | trWriteCMD( CMD_FOGF ); |
||
1838 | trWriteEnum( pname ); |
||
1839 | trWritef( param ); |
||
1840 | |||
1841 | if( trCtx()->doExec ) { |
||
1842 | trGetDispatch()->Fogf( pname, param ); |
||
1843 | trError(); |
||
1844 | } |
||
1845 | } |
||
1846 | |||
1847 | |||
1848 | GLAPI void GLAPIENTRY trFogfv( GLenum pname, const GLfloat *params ) { |
||
1849 | trWriteCMD( CMD_FOGFV ); |
||
1850 | trWriteEnum( pname ); |
||
1851 | trWritePointer( (void *)params ); |
||
1852 | trFileFlush(); |
||
1853 | |||
1854 | switch( pname ) { |
||
1855 | case GL_FOG_MODE: |
||
1856 | case GL_FOG_DENSITY: |
||
1857 | case GL_FOG_START: |
||
1858 | case GL_FOG_END: |
||
1859 | case GL_FOG_INDEX: |
||
1860 | trWritef( params[0] ); |
||
1861 | break; |
||
1862 | |||
1863 | case GL_FOG_COLOR: |
||
1864 | trWriteArrayf( 4, params ); |
||
1865 | break; |
||
1866 | |||
1867 | default: |
||
1868 | /* The 2nd pass should catch this */ |
||
1869 | break; |
||
1870 | } |
||
1871 | |||
1872 | if( trCtx()->doExec ) { |
||
1873 | trGetDispatch()->Fogfv( pname, params ); |
||
1874 | trError(); |
||
1875 | } |
||
1876 | } |
||
1877 | |||
1878 | |||
1879 | GLAPI void GLAPIENTRY trFogi( GLenum pname, GLint param ) { |
||
1880 | trWriteCMD( CMD_FOGI ); |
||
1881 | trWriteEnum( pname ); |
||
1882 | trWritei( param ); |
||
1883 | |||
1884 | if( trCtx()->doExec ) { |
||
1885 | trGetDispatch()->Fogi( pname, param ); |
||
1886 | trError(); |
||
1887 | } |
||
1888 | } |
||
1889 | |||
1890 | |||
1891 | GLAPI void GLAPIENTRY trFogiv( GLenum pname, const GLint *params ) { |
||
1892 | trWriteCMD( CMD_FOGIV ); |
||
1893 | trWriteEnum( pname ); |
||
1894 | trWritePointer( (void *)params ); |
||
1895 | trFileFlush(); |
||
1896 | |||
1897 | switch( pname ) { |
||
1898 | case GL_FOG_MODE: |
||
1899 | case GL_FOG_DENSITY: |
||
1900 | case GL_FOG_START: |
||
1901 | case GL_FOG_END: |
||
1902 | case GL_FOG_INDEX: |
||
1903 | trWritei( params[0] ); |
||
1904 | break; |
||
1905 | |||
1906 | case GL_FOG_COLOR: |
||
1907 | trWriteArrayi( 4, params ); |
||
1908 | break; |
||
1909 | |||
1910 | default: |
||
1911 | /* The 2nd pass should catch this */ |
||
1912 | break; |
||
1913 | } |
||
1914 | |||
1915 | if( trCtx()->doExec ) { |
||
1916 | trGetDispatch()->Fogiv( pname, params ); |
||
1917 | trError(); |
||
1918 | } |
||
1919 | } |
||
1920 | |||
1921 | |||
1922 | GLAPI void GLAPIENTRY trFrontFace( GLenum mode ) { |
||
1923 | trWriteCMD( CMD_FRONTFACE ); |
||
1924 | trWriteEnum( mode ); |
||
1925 | |||
1926 | if( trCtx()->doExec ) { |
||
1927 | trGetDispatch()->FrontFace( mode ); |
||
1928 | trError(); |
||
1929 | } |
||
1930 | } |
||
1931 | |||
1932 | |||
1933 | GLAPI void GLAPIENTRY trFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) { |
||
1934 | trWriteCMD( CMD_FRUSTUM ); |
||
1935 | trWrited( left ); |
||
1936 | trWrited( right ); |
||
1937 | trWrited( bottom ); |
||
1938 | trWrited( top ); |
||
1939 | trWrited( near_val ); |
||
1940 | trWrited( far_val ); |
||
1941 | |||
1942 | if( trCtx()->doExec ) { |
||
1943 | trGetDispatch()->Frustum( left, right, bottom, top, near_val, far_val ); |
||
1944 | trError(); |
||
1945 | } |
||
1946 | } |
||
1947 | |||
1948 | |||
1949 | GLAPI GLuint GLAPIENTRY trGenLists( GLsizei range ) { |
||
1950 | GLuint retval; |
||
1951 | |||
1952 | trWriteCMD( CMD_GENLISTS ); |
||
1953 | trWriteSizei( range ); |
||
1954 | |||
1955 | if( trCtx()->doExec ) { |
||
1956 | retval = trGetDispatch()->GenLists( range ); |
||
1957 | trError(); |
||
1958 | } else { |
||
1959 | retval = 0; |
||
1960 | } |
||
1961 | |||
1962 | trWriteui( retval ); |
||
1963 | return retval; |
||
1964 | } |
||
1965 | |||
1966 | |||
1967 | GLAPI void GLAPIENTRY trGenTexturesEXT( GLsizei n, GLuint *textures ) { |
||
1968 | trWriteCMD( CMD_GENTEXTURESEXT ); |
||
1969 | trWriteSizei( n ); |
||
1970 | trWritePointer( (void *)textures ); |
||
1971 | trFileFlush(); |
||
1972 | |||
1973 | if( trCtx()->doExec ) { |
||
1974 | trGetDispatch()->GenTexturesEXT( n, textures ); |
||
1975 | trError(); |
||
1976 | } |
||
1977 | |||
1978 | if( !(trCtx()->doExec) ) { |
||
1979 | memset( textures, 0, n * sizeof(GLuint) ); |
||
1980 | } |
||
1981 | |||
1982 | trWriteArrayui( n, textures ); |
||
1983 | } |
||
1984 | |||
1985 | |||
1986 | GLAPI void GLAPIENTRY trGenTextures( GLsizei n, GLuint *textures ) { |
||
1987 | trWriteCMD( CMD_GENTEXTURES ); |
||
1988 | trWriteSizei( n ); |
||
1989 | trWritePointer( (void *)textures ); |
||
1990 | trFileFlush(); |
||
1991 | |||
1992 | if( trCtx()->doExec ) { |
||
1993 | trGetDispatch()->GenTextures( n, textures ); |
||
1994 | trError(); |
||
1995 | } |
||
1996 | |||
1997 | if( !(trCtx()->doExec) ) { |
||
1998 | memset( textures, 0, n * sizeof(GLuint) ); |
||
1999 | } |
||
2000 | |||
2001 | trWriteArrayui( n, textures ); |
||
2002 | } |
||
2003 | |||
2004 | |||
2005 | GLAPI void GLAPIENTRY trGetBooleanv( GLenum pname, GLboolean *params ) { /* TODO */ |
||
2006 | trWriteCMD( CMD_GETBOOLEANV ); |
||
2007 | trWriteEnum( pname ); |
||
2008 | trWritePointer( (void *)params ); |
||
2009 | trFileFlush(); |
||
2010 | |||
2011 | switch( pname ) { |
||
2012 | case GL_COLOR_MATRIX: |
||
2013 | case GL_MODELVIEW_MATRIX: |
||
2014 | case GL_PROJECTION_MATRIX: |
||
2015 | case GL_TEXTURE_MATRIX: |
||
2016 | trWriteArrayBool( 16, params ); |
||
2017 | break; |
||
2018 | |||
2019 | case GL_ACCUM_CLEAR_VALUE: |
||
2020 | case GL_BLEND_COLOR: |
||
2021 | case GL_COLOR_CLEAR_VALUE: |
||
2022 | case GL_COLOR_WRITEMASK: |
||
2023 | case GL_CURRENT_COLOR: |
||
2024 | case GL_CURRENT_RASTER_COLOR: |
||
2025 | case GL_CURRENT_RASTER_POSITION: |
||
2026 | case GL_CURRENT_RASTER_TEXTURE_COORDS: |
||
2027 | case GL_CURRENT_TEXTURE_COORDS: |
||
2028 | case GL_LIGHT_MODEL_AMBIENT: |
||
2029 | case GL_MAP2_GRID_DOMAIN: |
||
2030 | case GL_SCISSOR_BOX: |
||
2031 | case GL_VIEWPORT: |
||
2032 | trWriteArrayBool( 4, params ); |
||
2033 | break; |
||
2034 | |||
2035 | case GL_CURRENT_NORMAL: |
||
2036 | trWriteArrayBool( 3, params ); |
||
2037 | break; |
||
2038 | |||
2039 | case GL_ALIASED_POINT_SIZE_RANGE: |
||
2040 | case GL_ALIASED_LINE_WIDTH_RANGE: |
||
2041 | case GL_DEPTH_RANGE: |
||
2042 | case GL_MAP1_GRID_DOMAIN: |
||
2043 | case GL_MAP2_GRID_SEGMENTS: |
||
2044 | case GL_MAX_VIEWPORT_DIMS: |
||
2045 | case GL_POLYGON_MODE: |
||
2046 | case GL_SMOOTH_LINE_WIDTH_RANGE: |
||
2047 | case GL_SMOOTH_POINT_SIZE_RANGE: |
||
2048 | trWriteArrayBool( 2, params ); |
||
2049 | break; |
||
2050 | |||
2051 | case GL_ACCUM_ALPHA_BITS: |
||
2052 | case GL_ACCUM_BLUE_BITS: |
||
2053 | case GL_ACCUM_GREEN_BITS: |
||
2054 | case GL_ACCUM_RED_BITS: |
||
2055 | case GL_ACTIVE_TEXTURE_ARB: |
||
2056 | case GL_ALPHA_BIAS: |
||
2057 | case GL_ALPHA_BITS: |
||
2058 | case GL_ALPHA_SCALE: |
||
2059 | case GL_ALPHA_TEST: |
||
2060 | case GL_ALPHA_TEST_FUNC: |
||
2061 | case GL_ALPHA_TEST_REF: |
||
2062 | case GL_ATTRIB_STACK_DEPTH: |
||
2063 | case GL_AUTO_NORMAL: |
||
2064 | case GL_AUX_BUFFERS: |
||
2065 | case GL_BLEND: |
||
2066 | case GL_BLEND_SRC: |
||
2067 | case GL_BLUE_BIAS: |
||
2068 | case GL_BLUE_BITS: |
||
2069 | case GL_BLUE_SCALE: |
||
2070 | case GL_CLIENT_ACTIVE_TEXTURE_ARB: |
||
2071 | case GL_CLIENT_ATTRIB_STACK_DEPTH: |
||
2072 | case GL_CLIP_PLANE0: |
||
2073 | case GL_CLIP_PLANE1: |
||
2074 | case GL_CLIP_PLANE2: |
||
2075 | case GL_CLIP_PLANE3: |
||
2076 | case GL_CLIP_PLANE4: |
||
2077 | case GL_CLIP_PLANE5: |
||
2078 | case GL_COLOR_ARRAY: |
||
2079 | case GL_COLOR_ARRAY_SIZE: |
||
2080 | case GL_COLOR_ARRAY_STRIDE: |
||
2081 | case GL_COLOR_ARRAY_TYPE: |
||
2082 | case GL_COLOR_LOGIC_OP: |
||
2083 | case GL_COLOR_MATERIAL: |
||
2084 | case GL_COLOR_MATERIAL_FACE: |
||
2085 | case GL_COLOR_MATERIAL_PARAMETER: |
||
2086 | case GL_COLOR_MATRIX_STACK_DEPTH: |
||
2087 | case GL_COLOR_TABLE: |
||
2088 | case GL_CONVOLUTION_1D: |
||
2089 | case GL_CONVOLUTION_2D: |
||
2090 | case GL_CULL_FACE: |
||
2091 | case GL_CULL_FACE_MODE: |
||
2092 | case GL_CURRENT_INDEX: |
||
2093 | case GL_CURRENT_RASTER_DISTANCE: |
||
2094 | case GL_CURRENT_RASTER_INDEX: |
||
2095 | case GL_CURRENT_RASTER_POSITION_VALID: |
||
2096 | case GL_DEPTH_BIAS: |
||
2097 | case GL_DEPTH_CLEAR_VALUE: |
||
2098 | case GL_DEPTH_FUNC: |
||
2099 | case GL_DEPTH_SCALE: |
||
2100 | case GL_DEPTH_TEST: |
||
2101 | case GL_DEPTH_WRITEMASK: |
||
2102 | case GL_DITHER: |
||
2103 | case GL_DOUBLEBUFFER: |
||
2104 | case GL_DRAW_BUFFER: |
||
2105 | case GL_EDGE_FLAG: |
||
2106 | case GL_EDGE_FLAG_ARRAY: |
||
2107 | case GL_EDGE_FLAG_ARRAY_STRIDE: |
||
2108 | case GL_FEEDBACK_BUFFER_SIZE: |
||
2109 | case GL_FEEDBACK_BUFFER_TYPE: |
||
2110 | case GL_FOG: |
||
2111 | case GL_FOG_DENSITY: |
||
2112 | case GL_FOG_END: |
||
2113 | case GL_FOG_HINT: |
||
2114 | case GL_FOG_INDEX: |
||
2115 | case GL_FOG_MODE: |
||
2116 | case GL_FOG_START: |
||
2117 | case GL_FRONT_FACE: |
||
2118 | case GL_GREEN_BIAS: |
||
2119 | case GL_GREEN_BITS: |
||
2120 | case GL_GREEN_SCALE: |
||
2121 | case GL_HISTOGRAM: |
||
2122 | case GL_INDEX_ARRAY: |
||
2123 | case GL_INDEX_ARRAY_STRIDE: |
||
2124 | case GL_INDEX_ARRAY_TYPE: |
||
2125 | case GL_INDEX_BITS: |
||
2126 | case GL_INDEX_CLEAR_VALUE: |
||
2127 | case GL_INDEX_LOGIC_OP: |
||
2128 | case GL_INDEX_MODE: |
||
2129 | case GL_INDEX_OFFSET: |
||
2130 | case GL_INDEX_SHIFT: |
||
2131 | case GL_INDEX_WRITEMASK: |
||
2132 | case GL_LIGHT0: |
||
2133 | case GL_LIGHT1: |
||
2134 | case GL_LIGHT2: |
||
2135 | case GL_LIGHT3: |
||
2136 | case GL_LIGHT4: |
||
2137 | case GL_LIGHT5: |
||
2138 | case GL_LIGHT6: |
||
2139 | case GL_LIGHT7: |
||
2140 | case GL_LIGHTING: |
||
2141 | case GL_LIGHT_MODEL_COLOR_CONTROL: |
||
2142 | case GL_LIGHT_MODEL_LOCAL_VIEWER: |
||
2143 | case GL_LIGHT_MODEL_TWO_SIDE: |
||
2144 | case GL_LINE_SMOOTH: |
||
2145 | case GL_LINE_SMOOTH_HINT: |
||
2146 | case GL_LINE_STIPPLE: |
||
2147 | case GL_LINE_STIPPLE_PATTERN: |
||
2148 | case GL_LINE_STIPPLE_REPEAT: |
||
2149 | case GL_LINE_WIDTH: |
||
2150 | case GL_LIST_BASE: |
||
2151 | case GL_LIST_INDEX: |
||
2152 | case GL_LIST_MODE: |
||
2153 | case GL_LOGIC_OP_MODE: |
||
2154 | case GL_MAP1_COLOR_4: |
||
2155 | case GL_MAP1_GRID_SEGMENTS: |
||
2156 | case GL_MAP1_INDEX: |
||
2157 | case GL_MAP1_NORMAL: |
||
2158 | case GL_MAP1_TEXTURE_COORD_1: |
||
2159 | case GL_MAP1_TEXTURE_COORD_2: |
||
2160 | case GL_MAP1_TEXTURE_COORD_3: |
||
2161 | case GL_MAP1_TEXTURE_COORD_4: |
||
2162 | case GL_MAP1_VERTEX_3: |
||
2163 | case GL_MAP1_VERTEX_4: |
||
2164 | case GL_MAP2_COLOR_4: |
||
2165 | case GL_MAP2_INDEX: |
||
2166 | case GL_MAP2_NORMAL: |
||
2167 | case GL_MAP2_TEXTURE_COORD_1: |
||
2168 | case GL_MAP2_TEXTURE_COORD_2: |
||
2169 | case GL_MAP2_TEXTURE_COORD_3: |
||
2170 | case GL_MAP2_TEXTURE_COORD_4: |
||
2171 | case GL_MAP2_VERTEX_3: |
||
2172 | case GL_MAP2_VERTEX_4: |
||
2173 | case GL_MAP_COLOR: |
||
2174 | case GL_MAP_STENCIL: |
||
2175 | case GL_MATRIX_MODE: |
||
2176 | case GL_MAX_3D_TEXTURE_SIZE: |
||
2177 | case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: |
||
2178 | case GL_MAX_ATTRIB_STACK_DEPTH: |
||
2179 | case GL_MAX_CLIP_PLANES: |
||
2180 | case GL_MAX_COLOR_MATRIX_STACK_DEPTH: |
||
2181 | case GL_MAX_ELEMENTS_VERTICES: |
||
2182 | case GL_MAX_EVAL_ORDER: |
||
2183 | case GL_MAX_LIGHTS: |
||
2184 | case GL_MAX_LIST_NESTING: |
||
2185 | case GL_MAX_MODELVIEW_STACK_DEPTH: |
||
2186 | case GL_MAX_NAME_STACK_DEPTH: |
||
2187 | case GL_MAX_PIXEL_MAP_TABLE: |
||
2188 | case GL_MAX_PROJECTION_STACK_DEPTH: |
||
2189 | case GL_MAX_TEXTURE_SIZE: |
||
2190 | case GL_MAX_TEXTURE_STACK_DEPTH: |
||
2191 | case GL_MAX_TEXTURE_UNITS_ARB: |
||
2192 | case GL_MINMAX: |
||
2193 | case GL_MODELVIEW_STACK_DEPTH: |
||
2194 | case GL_NAME_STACK_DEPTH: |
||
2195 | case GL_NORMAL_ARRAY: |
||
2196 | case GL_NORMAL_ARRAY_STRIDE: |
||
2197 | case GL_NORMAL_ARRAY_TYPE: |
||
2198 | case GL_NORMALIZE: |
||
2199 | case GL_PACK_ALIGNMENT: |
||
2200 | case GL_PACK_IMAGE_HEIGHT: |
||
2201 | case GL_PACK_LSB_FIRST: |
||
2202 | case GL_PACK_ROW_LENGTH: |
||
2203 | case GL_PACK_SKIP_IMAGES: |
||
2204 | case GL_PACK_SKIP_PIXELS: |
||
2205 | case GL_PACK_SKIP_ROWS: |
||
2206 | case GL_PACK_SWAP_BYTES: |
||
2207 | case GL_PERSPECTIVE_CORRECTION_HINT: |
||
2208 | case GL_PIXEL_MAP_A_TO_A_SIZE: |
||
2209 | case GL_PIXEL_MAP_B_TO_B_SIZE: |
||
2210 | case GL_PIXEL_MAP_G_TO_G_SIZE: |
||
2211 | case GL_PIXEL_MAP_I_TO_A_SIZE: |
||
2212 | case GL_PIXEL_MAP_I_TO_B_SIZE: |
||
2213 | case GL_PIXEL_MAP_I_TO_G_SIZE: |
||
2214 | case GL_PIXEL_MAP_I_TO_I_SIZE: |
||
2215 | case GL_PIXEL_MAP_I_TO_R_SIZE: |
||
2216 | case GL_PIXEL_MAP_R_TO_R_SIZE: |
||
2217 | case GL_PIXEL_MAP_S_TO_S_SIZE: |
||
2218 | case GL_POINT_SIZE: |
||
2219 | case GL_POINT_SMOOTH: |
||
2220 | case GL_POINT_SMOOTH_HINT: |
||
2221 | case GL_POLYGON_OFFSET_FACTOR: |
||
2222 | case GL_POLYGON_OFFSET_UNITS: |
||
2223 | case GL_POLYGON_OFFSET_FILL: |
||
2224 | case GL_POLYGON_OFFSET_LINE: |
||
2225 | case GL_POLYGON_OFFSET_POINT: |
||
2226 | case GL_POLYGON_SMOOTH: |
||
2227 | case GL_POLYGON_SMOOTH_HINT: |
||
2228 | case GL_POLYGON_STIPPLE: |
||
2229 | case GL_POST_COLOR_MATRIX_COLOR_TABLE: |
||
2230 | case GL_POST_COLOR_MATRIX_RED_BIAS: |
||
2231 | case GL_POST_COLOR_MATRIX_GREEN_BIAS: |
||
2232 | case GL_POST_COLOR_MATRIX_BLUE_BIAS: |
||
2233 | case GL_POST_COLOR_MATRIX_ALPHA_BIAS: |
||
2234 | case GL_POST_COLOR_MATRIX_RED_SCALE: |
||
2235 | case GL_POST_COLOR_MATRIX_GREEN_SCALE: |
||
2236 | case GL_POST_COLOR_MATRIX_BLUE_SCALE: |
||
2237 | case GL_POST_COLOR_MATRIX_ALPHA_SCALE: |
||
2238 | case GL_POST_CONVOLUTION_COLOR_TABLE: |
||
2239 | case GL_POST_CONVOLUTION_RED_BIAS: |
||
2240 | case GL_POST_CONVOLUTION_GREEN_BIAS: |
||
2241 | case GL_POST_CONVOLUTION_BLUE_BIAS: |
||
2242 | case GL_POST_CONVOLUTION_ALPHA_BIAS: |
||
2243 | case GL_POST_CONVOLUTION_RED_SCALE: |
||
2244 | case GL_POST_CONVOLUTION_GREEN_SCALE: |
||
2245 | case GL_POST_CONVOLUTION_BLUE_SCALE: |
||
2246 | case GL_POST_CONVOLUTION_ALPHA_SCALE: |
||
2247 | case GL_PROJECTION_STACK_DEPTH: |
||
2248 | case GL_READ_BUFFER: |
||
2249 | case GL_RED_BIAS: |
||
2250 | case GL_RED_BITS: |
||
2251 | case GL_RED_SCALE: |
||
2252 | case GL_RENDER_MODE: |
||
2253 | case GL_RESCALE_NORMAL: |
||
2254 | case GL_RGBA_MODE: |
||
2255 | case GL_SCISSOR_TEST: |
||
2256 | case GL_SELECTION_BUFFER_SIZE: |
||
2257 | case GL_SEPARABLE_2D: |
||
2258 | case GL_SHADE_MODEL: |
||
2259 | case GL_SMOOTH_LINE_WIDTH_GRANULARITY: |
||
2260 | case GL_SMOOTH_POINT_SIZE_GRANULARITY: |
||
2261 | case GL_STENCIL_BITS: |
||
2262 | case GL_STENCIL_CLEAR_VALUE: |
||
2263 | case GL_STENCIL_FAIL: |
||
2264 | case GL_STENCIL_FUNC: |
||
2265 | case GL_STENCIL_PASS_DEPTH_FAIL: |
||
2266 | case GL_STENCIL_PASS_DEPTH_PASS: |
||
2267 | case GL_STENCIL_REF: |
||
2268 | case GL_STENCIL_TEST: |
||
2269 | case GL_STENCIL_VALUE_MASK: |
||
2270 | case GL_STENCIL_WRITEMASK: |
||
2271 | case GL_STEREO: |
||
2272 | case GL_SUBPIXEL_BITS: |
||
2273 | case GL_TEXTURE_1D: |
||
2274 | case GL_TEXTURE_BINDING_1D: |
||
2275 | case GL_TEXTURE_2D: |
||
2276 | case GL_TEXTURE_BINDING_2D: |
||
2277 | case GL_TEXTURE_3D: |
||
2278 | case GL_TEXTURE_BINDING_3D: |
||
2279 | case GL_TEXTURE_COORD_ARRAY: |
||
2280 | case GL_TEXTURE_COORD_ARRAY_SIZE: |
||
2281 | case GL_TEXTURE_COORD_ARRAY_STRIDE: |
||
2282 | case GL_TEXTURE_COORD_ARRAY_TYPE: |
||
2283 | case GL_TEXTURE_GEN_Q: |
||
2284 | case GL_TEXTURE_GEN_R: |
||
2285 | case GL_TEXTURE_GEN_S: |
||
2286 | case GL_TEXTURE_GEN_T: |
||
2287 | case GL_TEXTURE_STACK_DEPTH: |
||
2288 | case GL_UNPACK_ALIGNMENT: |
||
2289 | case GL_UNPACK_IMAGE_HEIGHT: |
||
2290 | case GL_UNPACK_LSB_FIRST: |
||
2291 | case GL_UNPACK_ROW_LENGTH: |
||
2292 | case GL_UNPACK_SKIP_IMAGES: |
||
2293 | case GL_UNPACK_SKIP_PIXELS: |
||
2294 | case GL_UNPACK_SKIP_ROWS: |
||
2295 | case GL_UNPACK_SWAP_BYTES: |
||
2296 | case GL_VERTEX_ARRAY: |
||
2297 | case GL_VERTEX_ARRAY_SIZE: |
||
2298 | case GL_VERTEX_ARRAY_STRIDE: |
||
2299 | case GL_VERTEX_ARRAY_TYPE: |
||
2300 | case GL_ZOOM_X: |
||
2301 | case GL_ZOOM_Y: |
||
2302 | trWriteBool( params[0] ); |
||
2303 | break; |
||
2304 | |||
2305 | default: |
||
2306 | /* Bad enum. What should we do? */ |
||
2307 | break; |
||
2308 | } |
||
2309 | |||
2310 | if( trCtx()->doExec ) { |
||
2311 | trGetDispatch()->GetBooleanv( pname, params ); |
||
2312 | trError(); |
||
2313 | } |
||
2314 | } |
||
2315 | |||
2316 | |||
2317 | GLAPI void GLAPIENTRY trGetClipPlane( GLenum plane, GLdouble *equation ) { |
||
2318 | trWriteCMD( CMD_GETCLIPPLANE ); |
||
2319 | trWriteEnum( plane ); |
||
2320 | trWritePointer( (void *)equation ); |
||
2321 | trFileFlush(); |
||
2322 | |||
2323 | if( trCtx()->doExec ) { |
||
2324 | trGetDispatch()->GetClipPlane( plane, equation ); |
||
2325 | trError(); |
||
2326 | } |
||
2327 | |||
2328 | if( !(trCtx()->doExec) ) { |
||
2329 | memset( equation, 0, sizeof(GLdouble) ); |
||
2330 | } |
||
2331 | |||
2332 | trWriteArrayd( 4, equation ); |
||
2333 | } |
||
2334 | |||
2335 | |||
2336 | GLAPI void GLAPIENTRY trGetColorTableEXT( GLenum target, GLenum format, GLenum type, GLvoid *table ) { /* TODO */ |
||
2337 | |||
2338 | trWriteCMD( CMD_GETCOLORTABLEEXT ); |
||
2339 | trWriteEnum( target ); |
||
2340 | trWriteEnum( format ); |
||
2341 | trWriteEnum( type ); |
||
2342 | trWritePointer( (void *)table ); |
||
2343 | trFileFlush(); |
||
2344 | |||
2345 | if( trCtx()->doExec ) { |
||
2346 | trGetDispatch()->GetColorTableEXT( target, format, type, table ); |
||
2347 | trError(); |
||
2348 | } |
||
2349 | } |
||
2350 | |||
2351 | |||
2352 | GLAPI void GLAPIENTRY trGetColorTable( GLenum target, GLenum format, GLenum type, GLvoid *table ) { /* TODO */ |
||
2353 | trWriteCMD( CMD_GETCOLORTABLE ); |
||
2354 | trWriteEnum( target ); |
||
2355 | trWriteEnum( format ); |
||
2356 | trWriteEnum( type ); |
||
2357 | trWritePointer( (void *)table ); |
||
2358 | trFileFlush(); |
||
2359 | |||
2360 | if( trCtx()->doExec ) { |
||
2361 | trGetDispatch()->GetColorTable( target, format, type, table ); |
||
2362 | trError(); |
||
2363 | } |
||
2364 | } |
||
2365 | |||
2366 | |||
2367 | GLAPI void GLAPIENTRY trGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ) { |
||
2368 | trWriteCMD( CMD_GETCOLORTABLEPARAMETERFVEXT ); |
||
2369 | trWriteEnum( target ); |
||
2370 | trWriteEnum( pname ); |
||
2371 | trWritePointer( (void *)params ); |
||
2372 | trFileFlush(); |
||
2373 | |||
2374 | if( trCtx()->doExec ) { |
||
2375 | trGetDispatch()->GetColorTableParameterfvEXT( target, pname, params ); |
||
2376 | trError(); |
||
2377 | } else { |
||
2378 | if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) { |
||
2379 | memset( params, 0, sizeof(GLfloat) * 4 ); |
||
2380 | } else { |
||
2381 | params[0] = 0.0; |
||
2382 | } |
||
2383 | } |
||
2384 | |||
2385 | if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) { |
||
2386 | trWriteArrayf( 4, params ); |
||
2387 | } else { |
||
2388 | trWritef( params[0] ); |
||
2389 | } |
||
2390 | } |
||
2391 | |||
2392 | |||
2393 | GLAPI void GLAPIENTRY trGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) { |
||
2394 | trWriteCMD( CMD_GETCOLORTABLEPARAMETERFV ); |
||
2395 | trWriteEnum( target ); |
||
2396 | trWriteEnum( pname ); |
||
2397 | trWritePointer( (void *)params ); |
||
2398 | trFileFlush(); |
||
2399 | |||
2400 | if( trCtx()->doExec ) { |
||
2401 | trGetDispatch()->GetColorTableParameterfv( target, pname, params ); |
||
2402 | trError(); |
||
2403 | } else { |
||
2404 | if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) { |
||
2405 | memset( params, 0, sizeof(GLfloat) * 4 ); |
||
2406 | } else { |
||
2407 | params[0] = 0.0; |
||
2408 | } |
||
2409 | } |
||
2410 | |||
2411 | if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) { |
||
2412 | trWriteArrayf( 4, params ); |
||
2413 | } else { |
||
2414 | trWritef( params[0] ); |
||
2415 | } |
||
2416 | } |
||
2417 | |||
2418 | |||
2419 | GLAPI void GLAPIENTRY trGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params ) { |
||
2420 | trWriteCMD( CMD_GETCOLORTABLEPARAMETERIVEXT ); |
||
2421 | trWriteEnum( target ); |
||
2422 | trWriteEnum( pname ); |
||
2423 | trWritePointer( (void *)params ); |
||
2424 | trFileFlush(); |
||
2425 | |||
2426 | if( trCtx()->doExec ) { |
||
2427 | trGetDispatch()->GetColorTableParameterivEXT( target, pname, params ); |
||
2428 | trError(); |
||
2429 | } else { |
||
2430 | if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) { |
||
2431 | memset( params, 0, sizeof(GLint) * 4 ); |
||
2432 | } else { |
||
2433 | params[0] = 0; |
||
2434 | } |
||
2435 | } |
||
2436 | |||
2437 | if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) { |
||
2438 | trWriteArrayi( 4, params ); |
||
2439 | } else { |
||
2440 | trWritei( params[0] ); |
||
2441 | } |
||
2442 | } |
||
2443 | |||
2444 | |||
2445 | GLAPI void GLAPIENTRY trGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) { |
||
2446 | trWriteCMD( CMD_GETCOLORTABLEPARAMETERIV ); |
||
2447 | trWriteEnum( target ); |
||
2448 | trWriteEnum( pname ); |
||
2449 | trWritePointer( (void *)params ); |
||
2450 | trFileFlush(); |
||
2451 | |||
2452 | if( trCtx()->doExec ) { |
||
2453 | trGetDispatch()->GetColorTableParameteriv( target, pname, params ); |
||
2454 | trError(); |
||
2455 | } else { |
||
2456 | if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) { |
||
2457 | memset( params, 0, sizeof(GLint) * 4 ); |
||
2458 | } else { |
||
2459 | params[0] = 0; |
||
2460 | } |
||
2461 | } |
||
2462 | |||
2463 | if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) { |
||
2464 | trWriteArrayi( 4, params ); |
||
2465 | } else { |
||
2466 | trWritei( params[0] ); |
||
2467 | } |
||
2468 | } |
||
2469 | |||
2470 | |||
2471 | GLAPI void GLAPIENTRY trGetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid *image ) { |
||
2472 | trace_context_t * tctx; |
||
2473 | |||
2474 | trWriteCMD( CMD_GETCONVOLUTIONFILTER ); |
||
2475 | trWriteEnum( target ); |
||
2476 | trWriteEnum( format ); |
||
2477 | trWriteEnum( type ); |
||
2478 | trWritePointer( (void *)image ); |
||
2479 | trFileFlush(); |
||
2480 | |||
2481 | if( tctx->doExec ) { |
||
2482 | trGetDispatch()->GetConvolutionFilter( target, format, type, image ); |
||
2483 | trError(); |
||
2484 | } |
||
2485 | } |
||
2486 | |||
2487 | |||
2488 | GLAPI void GLAPIENTRY trGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params ) { |
||
2489 | trWriteCMD( CMD_GETCONVOLUTIONPARAMETERFV ); |
||
2490 | trWriteEnum( target ); |
||
2491 | trWriteEnum( pname ); |
||
2492 | trWritePointer( (void *)params ); |
||
2493 | trFileFlush(); |
||
2494 | |||
2495 | if( trCtx()->doExec ) { |
||
2496 | trGetDispatch()->GetConvolutionParameterfv( target, pname, params ); |
||
2497 | trError(); |
||
2498 | } else { |
||
2499 | switch( pname ) { |
||
2500 | case GL_CONVOLUTION_FILTER_SCALE: |
||
2501 | case GL_CONVOLUTION_FILTER_BIAS: |
||
2502 | memset( params, 0, 4 * sizeof(GLfloat) ); |
||
2503 | break; |
||
2504 | case GL_CONVOLUTION_BORDER_MODE: |
||
2505 | case GL_CONVOLUTION_BORDER_COLOR: |
||
2506 | case GL_CONVOLUTION_FORMAT: |
||
2507 | case GL_CONVOLUTION_WIDTH: |
||
2508 | case GL_CONVOLUTION_HEIGHT: |
||
2509 | case GL_MAX_CONVOLUTION_WIDTH: |
||
2510 | case GL_MAX_CONVOLUTION_HEIGHT: |
||
2511 | params[0] = 0; |
||
2512 | break; |
||
2513 | default: |
||
2514 | /* The 2nd pass should catch this */ |
||
2515 | break; |
||
2516 | } |
||
2517 | } |
||
2518 | |||
2519 | switch( pname ) { |
||
2520 | case GL_CONVOLUTION_FILTER_SCALE: |
||
2521 | case GL_CONVOLUTION_FILTER_BIAS: |
||
2522 | trWriteArrayf( 4, params ); |
||
2523 | break; |
||
2524 | case GL_CONVOLUTION_BORDER_MODE: |
||
2525 | case GL_CONVOLUTION_BORDER_COLOR: |
||
2526 | case GL_CONVOLUTION_FORMAT: |
||
2527 | case GL_CONVOLUTION_WIDTH: |
||
2528 | case GL_CONVOLUTION_HEIGHT: |
||
2529 | case GL_MAX_CONVOLUTION_WIDTH: |
||
2530 | case GL_MAX_CONVOLUTION_HEIGHT: |
||
2531 | trWritef( params[0] ); |
||
2532 | break; |
||
2533 | default: |
||
2534 | /* The 2nd pass should catch this */ |
||
2535 | break; |
||
2536 | } |
||
2537 | } |
||
2538 | |||
2539 | |||
2540 | GLAPI void GLAPIENTRY trGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params ) { |
||
2541 | trWriteCMD( CMD_GETCONVOLUTIONPARAMETERIV ); |
||
2542 | trWriteEnum( target ); |
||
2543 | trWriteEnum( pname ); |
||
2544 | trWritePointer( (void *)params ); |
||
2545 | trFileFlush(); |
||
2546 | |||
2547 | if( trCtx()->doExec ) { |
||
2548 | trGetDispatch()->GetConvolutionParameteriv( target, pname, params ); |
||
2549 | trError(); |
||
2550 | } else { |
||
2551 | switch( pname ) { |
||
2552 | case GL_CONVOLUTION_FILTER_SCALE: |
||
2553 | case GL_CONVOLUTION_FILTER_BIAS: |
||
2554 | memset( params, 0, 4 * sizeof(GLint) ); |
||
2555 | break; |
||
2556 | case GL_CONVOLUTION_BORDER_MODE: |
||
2557 | case GL_CONVOLUTION_BORDER_COLOR: |
||
2558 | case GL_CONVOLUTION_FORMAT: |
||
2559 | case GL_CONVOLUTION_WIDTH: |
||
2560 | case GL_CONVOLUTION_HEIGHT: |
||
2561 | case GL_MAX_CONVOLUTION_WIDTH: |
||
2562 | case GL_MAX_CONVOLUTION_HEIGHT: |
||
2563 | params[0] = 0; |
||
2564 | break; |
||
2565 | default: |
||
2566 | /* The 2nd pass should catch this */ |
||
2567 | break; |
||
2568 | } |
||
2569 | } |
||
2570 | |||
2571 | switch( pname ) { |
||
2572 | case GL_CONVOLUTION_FILTER_SCALE: |
||
2573 | case GL_CONVOLUTION_FILTER_BIAS: |
||
2574 | trWriteArrayi( 4, params ); |
||
2575 | break; |
||
2576 | case GL_CONVOLUTION_BORDER_MODE: |
||
2577 | case GL_CONVOLUTION_BORDER_COLOR: |
||
2578 | case GL_CONVOLUTION_FORMAT: |
||
2579 | case GL_CONVOLUTION_WIDTH: |
||
2580 | case GL_CONVOLUTION_HEIGHT: |
||
2581 | case GL_MAX_CONVOLUTION_WIDTH: |
||
2582 | case GL_MAX_CONVOLUTION_HEIGHT: |
||
2583 | trWritei( params[0] ); |
||
2584 | break; |
||
2585 | default: |
||
2586 | /* The 2nd pass should catch this */ |
||
2587 | break; |
||
2588 | } |
||
2589 | } |
||
2590 | |||
2591 | |||
2592 | GLAPI void GLAPIENTRY trGetDoublev( GLenum pname, GLdouble *params ) { |
||
2593 | trWriteCMD( CMD_GETDOUBLEV ); |
||
2594 | trWriteEnum( pname ); |
||
2595 | trWritePointer( (void *)params ); |
||
2596 | trFileFlush(); |
||
2597 | |||
2598 | if( trCtx()->doExec ) { |
||
2599 | trGetDispatch()->GetDoublev( pname, params ); |
||
2600 | trError(); |
||
2601 | } else { |
||
2602 | trZeroGetterData( pname, sizeof(GLdouble), params ); |
||
2603 | } |
||
2604 | |||
2605 | switch( pname ) { |
||
2606 | case GL_COLOR_MATRIX: |
||
2607 | case GL_MODELVIEW_MATRIX: |
||
2608 | case GL_PROJECTION_MATRIX: |
||
2609 | case GL_TEXTURE_MATRIX: |
||
2610 | trWriteArrayd( 16, params ); |
||
2611 | break; |
||
2612 | |||
2613 | case GL_ACCUM_CLEAR_VALUE: |
||
2614 | case GL_BLEND_COLOR: |
||
2615 | case GL_COLOR_CLEAR_VALUE: |
||
2616 | case GL_COLOR_WRITEMASK: |
||
2617 | case GL_CURRENT_COLOR: |
||
2618 | case GL_CURRENT_RASTER_COLOR: |
||
2619 | case GL_CURRENT_RASTER_POSITION: |
||
2620 | case GL_CURRENT_RASTER_TEXTURE_COORDS: |
||
2621 | case GL_CURRENT_TEXTURE_COORDS: |
||
2622 | case GL_LIGHT_MODEL_AMBIENT: |
||
2623 | case GL_MAP2_GRID_DOMAIN: |
||
2624 | case GL_SCISSOR_BOX: |
||
2625 | case GL_VIEWPORT: |
||
2626 | trWriteArrayd( 4, params ); |
||
2627 | break; |
||
2628 | |||
2629 | case GL_CURRENT_NORMAL: |
||
2630 | trWriteArrayd( 3, params ); |
||
2631 | break; |
||
2632 | |||
2633 | case GL_ALIASED_POINT_SIZE_RANGE: |
||
2634 | case GL_ALIASED_LINE_WIDTH_RANGE: |
||
2635 | case GL_DEPTH_RANGE: |
||
2636 | case GL_MAP1_GRID_DOMAIN: |
||
2637 | case GL_MAP2_GRID_SEGMENTS: |
||
2638 | case GL_MAX_VIEWPORT_DIMS: |
||
2639 | case GL_POLYGON_MODE: |
||
2640 | case GL_SMOOTH_LINE_WIDTH_RANGE: |
||
2641 | case GL_SMOOTH_POINT_SIZE_RANGE: |
||
2642 | trWriteArrayd( 2, params ); |
||
2643 | break; |
||
2644 | |||
2645 | case GL_ACCUM_ALPHA_BITS: |
||
2646 | case GL_ACCUM_BLUE_BITS: |
||
2647 | case GL_ACCUM_GREEN_BITS: |
||
2648 | case GL_ACCUM_RED_BITS: |
||
2649 | case GL_ACTIVE_TEXTURE_ARB: |
||
2650 | case GL_ALPHA_BIAS: |
||
2651 | case GL_ALPHA_BITS: |
||
2652 | case GL_ALPHA_SCALE: |
||
2653 | case GL_ALPHA_TEST: |
||
2654 | case GL_ALPHA_TEST_FUNC: |
||
2655 | case GL_ALPHA_TEST_REF: |
||
2656 | case GL_ATTRIB_STACK_DEPTH: |
||
2657 | case GL_AUTO_NORMAL: |
||
2658 | case GL_AUX_BUFFERS: |
||
2659 | case GL_BLEND: |
||
2660 | case GL_BLEND_SRC: |
||
2661 | case GL_BLUE_BIAS: |
||
2662 | case GL_BLUE_BITS: |
||
2663 | case GL_BLUE_SCALE: |
||
2664 | case GL_CLIENT_ACTIVE_TEXTURE_ARB: |
||
2665 | case GL_CLIENT_ATTRIB_STACK_DEPTH: |
||
2666 | case GL_CLIP_PLANE0: |
||
2667 | case GL_CLIP_PLANE1: |
||
2668 | case GL_CLIP_PLANE2: |
||
2669 | case GL_CLIP_PLANE3: |
||
2670 | case GL_CLIP_PLANE4: |
||
2671 | case GL_CLIP_PLANE5: |
||
2672 | case GL_COLOR_ARRAY: |
||
2673 | case GL_COLOR_ARRAY_SIZE: |
||
2674 | case GL_COLOR_ARRAY_STRIDE: |
||
2675 | case GL_COLOR_ARRAY_TYPE: |
||
2676 | case GL_COLOR_LOGIC_OP: |
||
2677 | case GL_COLOR_MATERIAL: |
||
2678 | case GL_COLOR_MATERIAL_FACE: |
||
2679 | case GL_COLOR_MATERIAL_PARAMETER: |
||
2680 | case GL_COLOR_MATRIX_STACK_DEPTH: |
||
2681 | case GL_COLOR_TABLE: |
||
2682 | case GL_CONVOLUTION_1D: |
||
2683 | case GL_CONVOLUTION_2D: |
||
2684 | case GL_CULL_FACE: |
||
2685 | case GL_CULL_FACE_MODE: |
||
2686 | case GL_CURRENT_INDEX: |
||
2687 | case GL_CURRENT_RASTER_DISTANCE: |
||
2688 | case GL_CURRENT_RASTER_INDEX: |
||
2689 | case GL_CURRENT_RASTER_POSITION_VALID: |
||
2690 | case GL_DEPTH_BIAS: |
||
2691 | case GL_DEPTH_CLEAR_VALUE: |
||
2692 | case GL_DEPTH_FUNC: |
||
2693 | case GL_DEPTH_SCALE: |
||
2694 | case GL_DEPTH_TEST: |
||
2695 | case GL_DEPTH_WRITEMASK: |
||
2696 | case GL_DITHER: |
||
2697 | case GL_DOUBLEBUFFER: |
||
2698 | case GL_DRAW_BUFFER: |
||
2699 | case GL_EDGE_FLAG: |
||
2700 | case GL_EDGE_FLAG_ARRAY: |
||
2701 | case GL_EDGE_FLAG_ARRAY_STRIDE: |
||
2702 | case GL_FEEDBACK_BUFFER_SIZE: |
||
2703 | case GL_FEEDBACK_BUFFER_TYPE: |
||
2704 | case GL_FOG: |
||
2705 | case GL_FOG_DENSITY: |
||
2706 | case GL_FOG_END: |
||
2707 | case GL_FOG_HINT: |
||
2708 | case GL_FOG_INDEX: |
||
2709 | case GL_FOG_MODE: |
||
2710 | case GL_FOG_START: |
||
2711 | case GL_FRONT_FACE: |
||
2712 | case GL_GREEN_BIAS: |
||
2713 | case GL_GREEN_BITS: |
||
2714 | case GL_GREEN_SCALE: |
||
2715 | case GL_HISTOGRAM: |
||
2716 | case GL_INDEX_ARRAY: |
||
2717 | case GL_INDEX_ARRAY_STRIDE: |
||
2718 | case GL_INDEX_ARRAY_TYPE: |
||
2719 | case GL_INDEX_BITS: |
||
2720 | case GL_INDEX_CLEAR_VALUE: |
||
2721 | case GL_INDEX_LOGIC_OP: |
||
2722 | case GL_INDEX_MODE: |
||
2723 | case GL_INDEX_OFFSET: |
||
2724 | case GL_INDEX_SHIFT: |
||
2725 | case GL_INDEX_WRITEMASK: |
||
2726 | case GL_LIGHT0: |
||
2727 | case GL_LIGHT1: |
||
2728 | case GL_LIGHT2: |
||
2729 | case GL_LIGHT3: |
||
2730 | case GL_LIGHT4: |
||
2731 | case GL_LIGHT5: |
||
2732 | case GL_LIGHT6: |
||
2733 | case GL_LIGHT7: |
||
2734 | case GL_LIGHTING: |
||
2735 | case GL_LIGHT_MODEL_COLOR_CONTROL: |
||
2736 | case GL_LIGHT_MODEL_LOCAL_VIEWER: |
||
2737 | case GL_LIGHT_MODEL_TWO_SIDE: |
||
2738 | case GL_LINE_SMOOTH: |
||
2739 | case GL_LINE_SMOOTH_HINT: |
||
2740 | case GL_LINE_STIPPLE: |
||
2741 | case GL_LINE_STIPPLE_PATTERN: |
||
2742 | case GL_LINE_STIPPLE_REPEAT: |
||
2743 | case GL_LINE_WIDTH: |
||
2744 | case GL_LIST_BASE: |
||
2745 | case GL_LIST_INDEX: |
||
2746 | case GL_LIST_MODE: |
||
2747 | case GL_LOGIC_OP_MODE: |
||
2748 | case GL_MAP1_COLOR_4: |
||
2749 | case GL_MAP1_GRID_SEGMENTS: |
||
2750 | case GL_MAP1_INDEX: |
||
2751 | case GL_MAP1_NORMAL: |
||
2752 | case GL_MAP1_TEXTURE_COORD_1: |
||
2753 | case GL_MAP1_TEXTURE_COORD_2: |
||
2754 | case GL_MAP1_TEXTURE_COORD_3: |
||
2755 | case GL_MAP1_TEXTURE_COORD_4: |
||
2756 | case GL_MAP1_VERTEX_3: |
||
2757 | case GL_MAP1_VERTEX_4: |
||
2758 | case GL_MAP2_COLOR_4: |
||
2759 | case GL_MAP2_INDEX: |
||
2760 | case GL_MAP2_NORMAL: |
||
2761 | case GL_MAP2_TEXTURE_COORD_1: |
||
2762 | case GL_MAP2_TEXTURE_COORD_2: |
||
2763 | case GL_MAP2_TEXTURE_COORD_3: |
||
2764 | case GL_MAP2_TEXTURE_COORD_4: |
||
2765 | case GL_MAP2_VERTEX_3: |
||
2766 | case GL_MAP2_VERTEX_4: |
||
2767 | case GL_MAP_COLOR: |
||
2768 | case GL_MAP_STENCIL: |
||
2769 | case GL_MATRIX_MODE: |
||
2770 | case GL_MAX_3D_TEXTURE_SIZE: |
||
2771 | case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: |
||
2772 | case GL_MAX_ATTRIB_STACK_DEPTH: |
||
2773 | case GL_MAX_CLIP_PLANES: |
||
2774 | case GL_MAX_COLOR_MATRIX_STACK_DEPTH: |
||
2775 | case GL_MAX_ELEMENTS_VERTICES: |
||
2776 | case GL_MAX_EVAL_ORDER: |
||
2777 | case GL_MAX_LIGHTS: |
||
2778 | case GL_MAX_LIST_NESTING: |
||
2779 | case GL_MAX_MODELVIEW_STACK_DEPTH: |
||
2780 | case GL_MAX_NAME_STACK_DEPTH: |
||
2781 | case GL_MAX_PIXEL_MAP_TABLE: |
||
2782 | case GL_MAX_PROJECTION_STACK_DEPTH: |
||
2783 | case GL_MAX_TEXTURE_SIZE: |
||
2784 | case GL_MAX_TEXTURE_STACK_DEPTH: |
||
2785 | case GL_MAX_TEXTURE_UNITS_ARB: |
||
2786 | case GL_MINMAX: |
||
2787 | case GL_MODELVIEW_STACK_DEPTH: |
||
2788 | case GL_NAME_STACK_DEPTH: |
||
2789 | case GL_NORMAL_ARRAY: |
||
2790 | case GL_NORMAL_ARRAY_STRIDE: |
||
2791 | case GL_NORMAL_ARRAY_TYPE: |
||
2792 | case GL_NORMALIZE: |
||
2793 | case GL_PACK_ALIGNMENT: |
||
2794 | case GL_PACK_IMAGE_HEIGHT: |
||
2795 | case GL_PACK_LSB_FIRST: |
||
2796 | case GL_PACK_ROW_LENGTH: |
||
2797 | case GL_PACK_SKIP_IMAGES: |
||
2798 | case GL_PACK_SKIP_PIXELS: |
||
2799 | case GL_PACK_SKIP_ROWS: |
||
2800 | case GL_PACK_SWAP_BYTES: |
||
2801 | case GL_PERSPECTIVE_CORRECTION_HINT: |
||
2802 | case GL_PIXEL_MAP_A_TO_A_SIZE: |
||
2803 | case GL_PIXEL_MAP_B_TO_B_SIZE: |
||
2804 | case GL_PIXEL_MAP_G_TO_G_SIZE: |
||
2805 | case GL_PIXEL_MAP_I_TO_A_SIZE: |
||
2806 | case GL_PIXEL_MAP_I_TO_B_SIZE: |
||
2807 | case GL_PIXEL_MAP_I_TO_G_SIZE: |
||
2808 | case GL_PIXEL_MAP_I_TO_I_SIZE: |
||
2809 | case GL_PIXEL_MAP_I_TO_R_SIZE: |
||
2810 | case GL_PIXEL_MAP_R_TO_R_SIZE: |
||
2811 | case GL_PIXEL_MAP_S_TO_S_SIZE: |
||
2812 | case GL_POINT_SIZE: |
||
2813 | case GL_POINT_SMOOTH: |
||
2814 | case GL_POINT_SMOOTH_HINT: |
||
2815 | case GL_POLYGON_OFFSET_FACTOR: |
||
2816 | case GL_POLYGON_OFFSET_UNITS: |
||
2817 | case GL_POLYGON_OFFSET_FILL: |
||
2818 | case GL_POLYGON_OFFSET_LINE: |
||
2819 | case GL_POLYGON_OFFSET_POINT: |
||
2820 | case GL_POLYGON_SMOOTH: |
||
2821 | case GL_POLYGON_SMOOTH_HINT: |
||
2822 | case GL_POLYGON_STIPPLE: |
||
2823 | case GL_POST_COLOR_MATRIX_COLOR_TABLE: |
||
2824 | case GL_POST_COLOR_MATRIX_RED_BIAS: |
||
2825 | case GL_POST_COLOR_MATRIX_GREEN_BIAS: |
||
2826 | case GL_POST_COLOR_MATRIX_BLUE_BIAS: |
||
2827 | case GL_POST_COLOR_MATRIX_ALPHA_BIAS: |
||
2828 | case GL_POST_COLOR_MATRIX_RED_SCALE: |
||
2829 | case GL_POST_COLOR_MATRIX_GREEN_SCALE: |
||
2830 | case GL_POST_COLOR_MATRIX_BLUE_SCALE: |
||
2831 | case GL_POST_COLOR_MATRIX_ALPHA_SCALE: |
||
2832 | case GL_POST_CONVOLUTION_COLOR_TABLE: |
||
2833 | case GL_POST_CONVOLUTION_RED_BIAS: |
||
2834 | case GL_POST_CONVOLUTION_GREEN_BIAS: |
||
2835 | case GL_POST_CONVOLUTION_BLUE_BIAS: |
||
2836 | case GL_POST_CONVOLUTION_ALPHA_BIAS: |
||
2837 | case GL_POST_CONVOLUTION_RED_SCALE: |
||
2838 | case GL_POST_CONVOLUTION_GREEN_SCALE: |
||
2839 | case GL_POST_CONVOLUTION_BLUE_SCALE: |
||
2840 | case GL_POST_CONVOLUTION_ALPHA_SCALE: |
||
2841 | case GL_PROJECTION_STACK_DEPTH: |
||
2842 | case GL_READ_BUFFER: |
||
2843 | case GL_RED_BIAS: |
||
2844 | case GL_RED_BITS: |
||
2845 | case GL_RED_SCALE: |
||
2846 | case GL_RENDER_MODE: |
||
2847 | case GL_RESCALE_NORMAL: |
||
2848 | case GL_RGBA_MODE: |
||
2849 | case GL_SCISSOR_TEST: |
||
2850 | case GL_SELECTION_BUFFER_SIZE: |
||
2851 | case GL_SEPARABLE_2D: |
||
2852 | case GL_SHADE_MODEL: |
||
2853 | case GL_SMOOTH_LINE_WIDTH_GRANULARITY: |
||
2854 | case GL_SMOOTH_POINT_SIZE_GRANULARITY: |
||
2855 | case GL_STENCIL_BITS: |
||
2856 | case GL_STENCIL_CLEAR_VALUE: |
||
2857 | case GL_STENCIL_FAIL: |
||
2858 | case GL_STENCIL_FUNC: |
||
2859 | case GL_STENCIL_PASS_DEPTH_FAIL: |
||
2860 | case GL_STENCIL_PASS_DEPTH_PASS: |
||
2861 | case GL_STENCIL_REF: |
||
2862 | case GL_STENCIL_TEST: |
||
2863 | case GL_STENCIL_VALUE_MASK: |
||
2864 | case GL_STENCIL_WRITEMASK: |
||
2865 | case GL_STEREO: |
||
2866 | case GL_SUBPIXEL_BITS: |
||
2867 | case GL_TEXTURE_1D: |
||
2868 | case GL_TEXTURE_BINDING_1D: |
||
2869 | case GL_TEXTURE_2D: |
||
2870 | case GL_TEXTURE_BINDING_2D: |
||
2871 | case GL_TEXTURE_3D: |
||
2872 | case GL_TEXTURE_BINDING_3D: |
||
2873 | case GL_TEXTURE_COORD_ARRAY: |
||
2874 | case GL_TEXTURE_COORD_ARRAY_SIZE: |
||
2875 | case GL_TEXTURE_COORD_ARRAY_STRIDE: |
||
2876 | case GL_TEXTURE_COORD_ARRAY_TYPE: |
||
2877 | case GL_TEXTURE_GEN_Q: |
||
2878 | case GL_TEXTURE_GEN_R: |
||
2879 | case GL_TEXTURE_GEN_S: |
||
2880 | case GL_TEXTURE_GEN_T: |
||
2881 | case GL_TEXTURE_STACK_DEPTH: |
||
2882 | case GL_UNPACK_ALIGNMENT: |
||
2883 | case GL_UNPACK_IMAGE_HEIGHT: |
||
2884 | case GL_UNPACK_LSB_FIRST: |
||
2885 | case GL_UNPACK_ROW_LENGTH: |
||
2886 | case GL_UNPACK_SKIP_IMAGES: |
||
2887 | case GL_UNPACK_SKIP_PIXELS: |
||
2888 | case GL_UNPACK_SKIP_ROWS: |
||
2889 | case GL_UNPACK_SWAP_BYTES: |
||
2890 | case GL_VERTEX_ARRAY: |
||
2891 | case GL_VERTEX_ARRAY_SIZE: |
||
2892 | case GL_VERTEX_ARRAY_STRIDE: |
||
2893 | case GL_VERTEX_ARRAY_TYPE: |
||
2894 | case GL_ZOOM_X: |
||
2895 | case GL_ZOOM_Y: |
||
2896 | trWrited( params[0] ); |
||
2897 | break; |
||
2898 | |||
2899 | default: |
||
2900 | /* Bad enum. What should we do? */ |
||
2901 | break; |
||
2902 | } |
||
2903 | |||
2904 | } |
||
2905 | |||
2906 | |||
2907 | GLAPI GLenum GLAPIENTRY trGetError( void ) { |
||
2908 | GLenum retval; |
||
2909 | trWriteCMD( CMD_GETERROR ); |
||
2910 | |||
2911 | if( trCtx()->doExec ) { |
||
2912 | retval = trGetDispatch()->GetError( ); |
||
2913 | trError(); |
||
2914 | } else { |
||
2915 | retval = GL_NO_ERROR; |
||
2916 | } |
||
2917 | |||
2918 | trWriteEnum( retval ); |
||
2919 | return retval; |
||
2920 | } |
||
2921 | |||
2922 | |||
2923 | GLAPI void GLAPIENTRY trGetFloatv( GLenum pname, GLfloat *params ) { |
||
2924 | trWriteCMD( CMD_GETFLOATV ); |
||
2925 | trWriteEnum( pname ); |
||
2926 | trWritePointer( (void *)params ); |
||
2927 | trFileFlush(); |
||
2928 | |||
2929 | if( trCtx()->doExec ) { |
||
2930 | trGetDispatch()->GetFloatv( pname, params ); |
||
2931 | trError(); |
||
2932 | } else { |
||
2933 | trZeroGetterData( pname, sizeof(GLfloat), params ); |
||
2934 | } |
||
2935 | |||
2936 | switch( pname ) { |
||
2937 | case GL_COLOR_MATRIX: |
||
2938 | case GL_MODELVIEW_MATRIX: |
||
2939 | case GL_PROJECTION_MATRIX: |
||
2940 | case GL_TEXTURE_MATRIX: |
||
2941 | trWriteArrayf( 16, params ); |
||
2942 | break; |
||
2943 | |||
2944 | case GL_ACCUM_CLEAR_VALUE: |
||
2945 | case GL_BLEND_COLOR: |
||
2946 | case GL_COLOR_CLEAR_VALUE: |
||
2947 | case GL_COLOR_WRITEMASK: |
||
2948 | case GL_CURRENT_COLOR: |
||
2949 | case GL_CURRENT_RASTER_COLOR: |
||
2950 | case GL_CURRENT_RASTER_POSITION: |
||
2951 | case GL_CURRENT_RASTER_TEXTURE_COORDS: |
||
2952 | case GL_CURRENT_TEXTURE_COORDS: |
||
2953 | case GL_LIGHT_MODEL_AMBIENT: |
||
2954 | case GL_MAP2_GRID_DOMAIN: |
||
2955 | case GL_SCISSOR_BOX: |
||
2956 | case GL_VIEWPORT: |
||
2957 | trWriteArrayf( 4, params ); |
||
2958 | break; |
||
2959 | |||
2960 | case GL_CURRENT_NORMAL: |
||
2961 | trWriteArrayf( 3, params ); |
||
2962 | break; |
||
2963 | |||
2964 | case GL_ALIASED_POINT_SIZE_RANGE: |
||
2965 | case GL_ALIASED_LINE_WIDTH_RANGE: |
||
2966 | case GL_DEPTH_RANGE: |
||
2967 | case GL_MAP1_GRID_DOMAIN: |
||
2968 | case GL_MAP2_GRID_SEGMENTS: |
||
2969 | case GL_MAX_VIEWPORT_DIMS: |
||
2970 | case GL_POLYGON_MODE: |
||
2971 | case GL_SMOOTH_LINE_WIDTH_RANGE: |
||
2972 | case GL_SMOOTH_POINT_SIZE_RANGE: |
||
2973 | trWriteArrayf( 2, params ); |
||
2974 | break; |
||
2975 | |||
2976 | case GL_ACCUM_ALPHA_BITS: |
||
2977 | case GL_ACCUM_BLUE_BITS: |
||
2978 | case GL_ACCUM_GREEN_BITS: |
||
2979 | case GL_ACCUM_RED_BITS: |
||
2980 | case GL_ACTIVE_TEXTURE_ARB: |
||
2981 | case GL_ALPHA_BIAS: |
||
2982 | case GL_ALPHA_BITS: |
||
2983 | case GL_ALPHA_SCALE: |
||
2984 | case GL_ALPHA_TEST: |
||
2985 | case GL_ALPHA_TEST_FUNC: |
||
2986 | case GL_ALPHA_TEST_REF: |
||
2987 | case GL_ATTRIB_STACK_DEPTH: |
||
2988 | case GL_AUTO_NORMAL: |
||
2989 | case GL_AUX_BUFFERS: |
||
2990 | case GL_BLEND: |
||
2991 | case GL_BLEND_SRC: |
||
2992 | case GL_BLUE_BIAS: |
||
2993 | case GL_BLUE_BITS: |
||
2994 | case GL_BLUE_SCALE: |
||
2995 | case GL_CLIENT_ACTIVE_TEXTURE_ARB: |
||
2996 | case GL_CLIENT_ATTRIB_STACK_DEPTH: |
||
2997 | case GL_CLIP_PLANE0: |
||
2998 | case GL_CLIP_PLANE1: |
||
2999 | case GL_CLIP_PLANE2: |
||
3000 | case GL_CLIP_PLANE3: |
||
3001 | case GL_CLIP_PLANE4: |
||
3002 | case GL_CLIP_PLANE5: |
||
3003 | case GL_COLOR_ARRAY: |
||
3004 | case GL_COLOR_ARRAY_SIZE: |
||
3005 | case GL_COLOR_ARRAY_STRIDE: |
||
3006 | case GL_COLOR_ARRAY_TYPE: |
||
3007 | case GL_COLOR_LOGIC_OP: |
||
3008 | case GL_COLOR_MATERIAL: |
||
3009 | case GL_COLOR_MATERIAL_FACE: |
||
3010 | case GL_COLOR_MATERIAL_PARAMETER: |
||
3011 | case GL_COLOR_MATRIX_STACK_DEPTH: |
||
3012 | case GL_COLOR_TABLE: |
||
3013 | case GL_CONVOLUTION_1D: |
||
3014 | case GL_CONVOLUTION_2D: |
||
3015 | case GL_CULL_FACE: |
||
3016 | case GL_CULL_FACE_MODE: |
||
3017 | case GL_CURRENT_INDEX: |
||
3018 | case GL_CURRENT_RASTER_DISTANCE: |
||
3019 | case GL_CURRENT_RASTER_INDEX: |
||
3020 | case GL_CURRENT_RASTER_POSITION_VALID: |
||
3021 | case GL_DEPTH_BIAS: |
||
3022 | case GL_DEPTH_CLEAR_VALUE: |
||
3023 | case GL_DEPTH_FUNC: |
||
3024 | case GL_DEPTH_SCALE: |
||
3025 | case GL_DEPTH_TEST: |
||
3026 | case GL_DEPTH_WRITEMASK: |
||
3027 | case GL_DITHER: |
||
3028 | case GL_DOUBLEBUFFER: |
||
3029 | case GL_DRAW_BUFFER: |
||
3030 | case GL_EDGE_FLAG: |
||
3031 | case GL_EDGE_FLAG_ARRAY: |
||
3032 | case GL_EDGE_FLAG_ARRAY_STRIDE: |
||
3033 | case GL_FEEDBACK_BUFFER_SIZE: |
||
3034 | case GL_FEEDBACK_BUFFER_TYPE: |
||
3035 | case GL_FOG: |
||
3036 | case GL_FOG_DENSITY: |
||
3037 | case GL_FOG_END: |
||
3038 | case GL_FOG_HINT: |
||
3039 | case GL_FOG_INDEX: |
||
3040 | case GL_FOG_MODE: |
||
3041 | case GL_FOG_START: |
||
3042 | case GL_FRONT_FACE: |
||
3043 | case GL_GREEN_BIAS: |
||
3044 | case GL_GREEN_BITS: |
||
3045 | case GL_GREEN_SCALE: |
||
3046 | case GL_HISTOGRAM: |
||
3047 | case GL_INDEX_ARRAY: |
||
3048 | case GL_INDEX_ARRAY_STRIDE: |
||
3049 | case GL_INDEX_ARRAY_TYPE: |
||
3050 | case GL_INDEX_BITS: |
||
3051 | case GL_INDEX_CLEAR_VALUE: |
||
3052 | case GL_INDEX_LOGIC_OP: |
||
3053 | case GL_INDEX_MODE: |
||
3054 | case GL_INDEX_OFFSET: |
||
3055 | case GL_INDEX_SHIFT: |
||
3056 | case GL_INDEX_WRITEMASK: |
||
3057 | case GL_LIGHT0: |
||
3058 | case GL_LIGHT1: |
||
3059 | case GL_LIGHT2: |
||
3060 | case GL_LIGHT3: |
||
3061 | case GL_LIGHT4: |
||
3062 | case GL_LIGHT5: |
||
3063 | case GL_LIGHT6: |
||
3064 | case GL_LIGHT7: |
||
3065 | case GL_LIGHTING: |
||
3066 | case GL_LIGHT_MODEL_COLOR_CONTROL: |
||
3067 | case GL_LIGHT_MODEL_LOCAL_VIEWER: |
||
3068 | case GL_LIGHT_MODEL_TWO_SIDE: |
||
3069 | case GL_LINE_SMOOTH: |
||
3070 | case GL_LINE_SMOOTH_HINT: |
||
3071 | case GL_LINE_STIPPLE: |
||
3072 | case GL_LINE_STIPPLE_PATTERN: |
||
3073 | case GL_LINE_STIPPLE_REPEAT: |
||
3074 | case GL_LINE_WIDTH: |
||
3075 | case GL_LIST_BASE: |
||
3076 | case GL_LIST_INDEX: |
||
3077 | case GL_LIST_MODE: |
||
3078 | case GL_LOGIC_OP_MODE: |
||
3079 | case GL_MAP1_COLOR_4: |
||
3080 | case GL_MAP1_GRID_SEGMENTS: |
||
3081 | case GL_MAP1_INDEX: |
||
3082 | case GL_MAP1_NORMAL: |
||
3083 | case GL_MAP1_TEXTURE_COORD_1: |
||
3084 | case GL_MAP1_TEXTURE_COORD_2: |
||
3085 | case GL_MAP1_TEXTURE_COORD_3: |
||
3086 | case GL_MAP1_TEXTURE_COORD_4: |
||
3087 | case GL_MAP1_VERTEX_3: |
||
3088 | case GL_MAP1_VERTEX_4: |
||
3089 | case GL_MAP2_COLOR_4: |
||
3090 | case GL_MAP2_INDEX: |
||
3091 | case GL_MAP2_NORMAL: |
||
3092 | case GL_MAP2_TEXTURE_COORD_1: |
||
3093 | case GL_MAP2_TEXTURE_COORD_2: |
||
3094 | case GL_MAP2_TEXTURE_COORD_3: |
||
3095 | case GL_MAP2_TEXTURE_COORD_4: |
||
3096 | case GL_MAP2_VERTEX_3: |
||
3097 | case GL_MAP2_VERTEX_4: |
||
3098 | case GL_MAP_COLOR: |
||
3099 | case GL_MAP_STENCIL: |
||
3100 | case GL_MATRIX_MODE: |
||
3101 | case GL_MAX_3D_TEXTURE_SIZE: |
||
3102 | case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: |
||
3103 | case GL_MAX_ATTRIB_STACK_DEPTH: |
||
3104 | case GL_MAX_CLIP_PLANES: |
||
3105 | case GL_MAX_COLOR_MATRIX_STACK_DEPTH: |
||
3106 | case GL_MAX_ELEMENTS_VERTICES: |
||
3107 | case GL_MAX_EVAL_ORDER: |
||
3108 | case GL_MAX_LIGHTS: |
||
3109 | case GL_MAX_LIST_NESTING: |
||
3110 | case GL_MAX_MODELVIEW_STACK_DEPTH: |
||
3111 | case GL_MAX_NAME_STACK_DEPTH: |
||
3112 | case GL_MAX_PIXEL_MAP_TABLE: |
||
3113 | case GL_MAX_PROJECTION_STACK_DEPTH: |
||
3114 | case GL_MAX_TEXTURE_SIZE: |
||
3115 | case GL_MAX_TEXTURE_STACK_DEPTH: |
||
3116 | case GL_MAX_TEXTURE_UNITS_ARB: |
||
3117 | case GL_MINMAX: |
||
3118 | case GL_MODELVIEW_STACK_DEPTH: |
||
3119 | case GL_NAME_STACK_DEPTH: |
||
3120 | case GL_NORMAL_ARRAY: |
||
3121 | case GL_NORMAL_ARRAY_STRIDE: |
||
3122 | case GL_NORMAL_ARRAY_TYPE: |
||
3123 | case GL_NORMALIZE: |
||
3124 | case GL_PACK_ALIGNMENT: |
||
3125 | case GL_PACK_IMAGE_HEIGHT: |
||
3126 | case GL_PACK_LSB_FIRST: |
||
3127 | case GL_PACK_ROW_LENGTH: |
||
3128 | case GL_PACK_SKIP_IMAGES: |
||
3129 | case GL_PACK_SKIP_PIXELS: |
||
3130 | case GL_PACK_SKIP_ROWS: |
||
3131 | case GL_PACK_SWAP_BYTES: |
||
3132 | case GL_PERSPECTIVE_CORRECTION_HINT: |
||
3133 | case GL_PIXEL_MAP_A_TO_A_SIZE: |
||
3134 | case GL_PIXEL_MAP_B_TO_B_SIZE: |
||
3135 | case GL_PIXEL_MAP_G_TO_G_SIZE: |
||
3136 | case GL_PIXEL_MAP_I_TO_A_SIZE: |
||
3137 | case GL_PIXEL_MAP_I_TO_B_SIZE: |
||
3138 | case GL_PIXEL_MAP_I_TO_G_SIZE: |
||
3139 | case GL_PIXEL_MAP_I_TO_I_SIZE: |
||
3140 | case GL_PIXEL_MAP_I_TO_R_SIZE: |
||
3141 | case GL_PIXEL_MAP_R_TO_R_SIZE: |
||
3142 | case GL_PIXEL_MAP_S_TO_S_SIZE: |
||
3143 | case GL_POINT_SIZE: |
||
3144 | case GL_POINT_SMOOTH: |
||
3145 | case GL_POINT_SMOOTH_HINT: |
||
3146 | case GL_POLYGON_OFFSET_FACTOR: |
||
3147 | case GL_POLYGON_OFFSET_UNITS: |
||
3148 | case GL_POLYGON_OFFSET_FILL: |
||
3149 | case GL_POLYGON_OFFSET_LINE: |
||
3150 | case GL_POLYGON_OFFSET_POINT: |
||
3151 | case GL_POLYGON_SMOOTH: |
||
3152 | case GL_POLYGON_SMOOTH_HINT: |
||
3153 | case GL_POLYGON_STIPPLE: |
||
3154 | case GL_POST_COLOR_MATRIX_COLOR_TABLE: |
||
3155 | case GL_POST_COLOR_MATRIX_RED_BIAS: |
||
3156 | case GL_POST_COLOR_MATRIX_GREEN_BIAS: |
||
3157 | case GL_POST_COLOR_MATRIX_BLUE_BIAS: |
||
3158 | case GL_POST_COLOR_MATRIX_ALPHA_BIAS: |
||
3159 | case GL_POST_COLOR_MATRIX_RED_SCALE: |
||
3160 | case GL_POST_COLOR_MATRIX_GREEN_SCALE: |
||
3161 | case GL_POST_COLOR_MATRIX_BLUE_SCALE: |
||
3162 | case GL_POST_COLOR_MATRIX_ALPHA_SCALE: |
||
3163 | case GL_POST_CONVOLUTION_COLOR_TABLE: |
||
3164 | case GL_POST_CONVOLUTION_RED_BIAS: |
||
3165 | case GL_POST_CONVOLUTION_GREEN_BIAS: |
||
3166 | case GL_POST_CONVOLUTION_BLUE_BIAS: |
||
3167 | case GL_POST_CONVOLUTION_ALPHA_BIAS: |
||
3168 | case GL_POST_CONVOLUTION_RED_SCALE: |
||
3169 | case GL_POST_CONVOLUTION_GREEN_SCALE: |
||
3170 | case GL_POST_CONVOLUTION_BLUE_SCALE: |
||
3171 | case GL_POST_CONVOLUTION_ALPHA_SCALE: |
||
3172 | case GL_PROJECTION_STACK_DEPTH: |
||
3173 | case GL_READ_BUFFER: |
||
3174 | case GL_RED_BIAS: |
||
3175 | case GL_RED_BITS: |
||
3176 | case GL_RED_SCALE: |
||
3177 | case GL_RENDER_MODE: |
||
3178 | case GL_RESCALE_NORMAL: |
||
3179 | case GL_RGBA_MODE: |
||
3180 | case GL_SCISSOR_TEST: |
||
3181 | case GL_SELECTION_BUFFER_SIZE: |
||
3182 | case GL_SEPARABLE_2D: |
||
3183 | case GL_SHADE_MODEL: |
||
3184 | case GL_SMOOTH_LINE_WIDTH_GRANULARITY: |
||
3185 | case GL_SMOOTH_POINT_SIZE_GRANULARITY: |
||
3186 | case GL_STENCIL_BITS: |
||
3187 | case GL_STENCIL_CLEAR_VALUE: |
||
3188 | case GL_STENCIL_FAIL: |
||
3189 | case GL_STENCIL_FUNC: |
||
3190 | case GL_STENCIL_PASS_DEPTH_FAIL: |
||
3191 | case GL_STENCIL_PASS_DEPTH_PASS: |
||
3192 | case GL_STENCIL_REF: |
||
3193 | case GL_STENCIL_TEST: |
||
3194 | case GL_STENCIL_VALUE_MASK: |
||
3195 | case GL_STENCIL_WRITEMASK: |
||
3196 | case GL_STEREO: |
||
3197 | case GL_SUBPIXEL_BITS: |
||
3198 | case GL_TEXTURE_1D: |
||
3199 | case GL_TEXTURE_BINDING_1D: |
||
3200 | case GL_TEXTURE_2D: |
||
3201 | case GL_TEXTURE_BINDING_2D: |
||
3202 | case GL_TEXTURE_3D: |
||
3203 | case GL_TEXTURE_BINDING_3D: |
||
3204 | case GL_TEXTURE_COORD_ARRAY: |
||
3205 | case GL_TEXTURE_COORD_ARRAY_SIZE: |
||
3206 | case GL_TEXTURE_COORD_ARRAY_STRIDE: |
||
3207 | case GL_TEXTURE_COORD_ARRAY_TYPE: |
||
3208 | case GL_TEXTURE_GEN_Q: |
||
3209 | case GL_TEXTURE_GEN_R: |
||
3210 | case GL_TEXTURE_GEN_S: |
||
3211 | case GL_TEXTURE_GEN_T: |
||
3212 | case GL_TEXTURE_STACK_DEPTH: |
||
3213 | case GL_UNPACK_ALIGNMENT: |
||
3214 | case GL_UNPACK_IMAGE_HEIGHT: |
||
3215 | case GL_UNPACK_LSB_FIRST: |
||
3216 | case GL_UNPACK_ROW_LENGTH: |
||
3217 | case GL_UNPACK_SKIP_IMAGES: |
||
3218 | case GL_UNPACK_SKIP_PIXELS: |
||
3219 | case GL_UNPACK_SKIP_ROWS: |
||
3220 | case GL_UNPACK_SWAP_BYTES: |
||
3221 | case GL_VERTEX_ARRAY: |
||
3222 | case GL_VERTEX_ARRAY_SIZE: |
||
3223 | case GL_VERTEX_ARRAY_STRIDE: |
||
3224 | case GL_VERTEX_ARRAY_TYPE: |
||
3225 | case GL_ZOOM_X: |
||
3226 | case GL_ZOOM_Y: |
||
3227 | trWritef( params[0] ); |
||
3228 | break; |
||
3229 | |||
3230 | default: |
||
3231 | /* Bad enum. What should we do? */ |
||
3232 | break; |
||
3233 | } |
||
3234 | } |
||
3235 | |||
3236 | |||
3237 | GLAPI void GLAPIENTRY trGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values ) { /* TODO */ |
||
3238 | trWriteCMD( CMD_GETHISTOGRAM ); |
||
3239 | trWriteEnum( target ); |
||
3240 | trWriteBool( reset ); |
||
3241 | trWriteEnum( format ); |
||
3242 | trWriteEnum( type ); |
||
3243 | trWritePointer( (void *)values ); |
||
3244 | trFileFlush(); |
||
3245 | |||
3246 | if( trCtx()->doExec ) { |
||
3247 | trGetDispatch()->GetHistogram( target, reset, format, type, values ); |
||
3248 | trError(); |
||
3249 | } |
||
3250 | } |
||
3251 | |||
3252 | |||
3253 | GLAPI void GLAPIENTRY trGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params ) { |
||
3254 | trWriteCMD( CMD_GETHISTOGRAMPARAMETERFV ); |
||
3255 | trWriteEnum( target ); |
||
3256 | trWriteEnum( pname ); |
||
3257 | trWritePointer( (void *)params ); |
||
3258 | trFileFlush(); |
||
3259 | |||
3260 | if( trCtx()->doExec ) { |
||
3261 | trGetDispatch()->GetHistogramParameterfv( target, pname, params ); |
||
3262 | trError(); |
||
3263 | } else { |
||
3264 | params[0] = 0; |
||
3265 | } |
||
3266 | |||
3267 | trWritef( params[0] ); |
||
3268 | } |
||
3269 | |||
3270 | |||
3271 | GLAPI void GLAPIENTRY trGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params ) { |
||
3272 | trWriteCMD( CMD_GETHISTOGRAMPARAMETERIV ); |
||
3273 | trWriteEnum( target ); |
||
3274 | trWriteEnum( pname ); |
||
3275 | trWritePointer( (void *)params ); |
||
3276 | trFileFlush(); |
||
3277 | |||
3278 | if( trCtx()->doExec ) { |
||
3279 | trGetDispatch()->GetHistogramParameteriv( target, pname, params ); |
||
3280 | trError(); |
||
3281 | } else { |
||
3282 | params[0] = 0; |
||
3283 | } |
||
3284 | |||
3285 | trWritei( params[0] ); |
||
3286 | } |
||
3287 | |||
3288 | |||
3289 | GLAPI void GLAPIENTRY trGetIntegerv( GLenum pname, GLint *params ) { |
||
3290 | trWriteCMD( CMD_GETINTEGERV ); |
||
3291 | trWriteEnum( pname ); |
||
3292 | trWritePointer( (void *)params ); |
||
3293 | trFileFlush(); |
||
3294 | |||
3295 | if( trCtx()->doExec ) { |
||
3296 | trGetDispatch()->GetIntegerv( pname, params ); |
||
3297 | trError(); |
||
3298 | } else { |
||
3299 | trZeroGetterData( pname, sizeof(GLint), params ); |
||
3300 | } |
||
3301 | |||
3302 | switch( pname ) { |
||
3303 | case GL_COLOR_MATRIX: |
||
3304 | case GL_MODELVIEW_MATRIX: |
||
3305 | case GL_PROJECTION_MATRIX: |
||
3306 | case GL_TEXTURE_MATRIX: |
||
3307 | trWriteArrayi( 16, params ); |
||
3308 | break; |
||
3309 | |||
3310 | case GL_ACCUM_CLEAR_VALUE: |
||
3311 | case GL_BLEND_COLOR: |
||
3312 | case GL_COLOR_CLEAR_VALUE: |
||
3313 | case GL_COLOR_WRITEMASK: |
||
3314 | case GL_CURRENT_COLOR: |
||
3315 | case GL_CURRENT_RASTER_COLOR: |
||
3316 | case GL_CURRENT_RASTER_POSITION: |
||
3317 | case GL_CURRENT_RASTER_TEXTURE_COORDS: |
||
3318 | case GL_CURRENT_TEXTURE_COORDS: |
||
3319 | case GL_LIGHT_MODEL_AMBIENT: |
||
3320 | case GL_MAP2_GRID_DOMAIN: |
||
3321 | case GL_SCISSOR_BOX: |
||
3322 | case GL_VIEWPORT: |
||
3323 | trWriteArrayi( 4, params ); |
||
3324 | break; |
||
3325 | |||
3326 | case GL_CURRENT_NORMAL: |
||
3327 | trWriteArrayi( 3, params ); |
||
3328 | break; |
||
3329 | |||
3330 | case GL_ALIASED_POINT_SIZE_RANGE: |
||
3331 | case GL_ALIASED_LINE_WIDTH_RANGE: |
||
3332 | case GL_DEPTH_RANGE: |
||
3333 | case GL_MAP1_GRID_DOMAIN: |
||
3334 | case GL_MAP2_GRID_SEGMENTS: |
||
3335 | case GL_MAX_VIEWPORT_DIMS: |
||
3336 | case GL_POLYGON_MODE: |
||
3337 | case GL_SMOOTH_LINE_WIDTH_RANGE: |
||
3338 | case GL_SMOOTH_POINT_SIZE_RANGE: |
||
3339 | trWriteArrayi( 2, params ); |
||
3340 | break; |
||
3341 | |||
3342 | case GL_ACCUM_ALPHA_BITS: |
||
3343 | case GL_ACCUM_BLUE_BITS: |
||
3344 | case GL_ACCUM_GREEN_BITS: |
||
3345 | case GL_ACCUM_RED_BITS: |
||
3346 | case GL_ACTIVE_TEXTURE_ARB: |
||
3347 | case GL_ALPHA_BIAS: |
||
3348 | case GL_ALPHA_BITS: |
||
3349 | case GL_ALPHA_SCALE: |
||
3350 | case GL_ALPHA_TEST: |
||
3351 | case GL_ALPHA_TEST_FUNC: |
||
3352 | case GL_ALPHA_TEST_REF: |
||
3353 | case GL_ATTRIB_STACK_DEPTH: |
||
3354 | case GL_AUTO_NORMAL: |
||
3355 | case GL_AUX_BUFFERS: |
||
3356 | case GL_BLEND: |
||
3357 | case GL_BLEND_SRC: |
||
3358 | case GL_BLUE_BIAS: |
||
3359 | case GL_BLUE_BITS: |
||
3360 | case GL_BLUE_SCALE: |
||
3361 | case GL_CLIENT_ACTIVE_TEXTURE_ARB: |
||
3362 | case GL_CLIENT_ATTRIB_STACK_DEPTH: |
||
3363 | case GL_CLIP_PLANE0: |
||
3364 | case GL_CLIP_PLANE1: |
||
3365 | case GL_CLIP_PLANE2: |
||
3366 | case GL_CLIP_PLANE3: |
||
3367 | case GL_CLIP_PLANE4: |
||
3368 | case GL_CLIP_PLANE5: |
||
3369 | case GL_COLOR_ARRAY: |
||
3370 | case GL_COLOR_ARRAY_SIZE: |
||
3371 | case GL_COLOR_ARRAY_STRIDE: |
||
3372 | case GL_COLOR_ARRAY_TYPE: |
||
3373 | case GL_COLOR_LOGIC_OP: |
||
3374 | case GL_COLOR_MATERIAL: |
||
3375 | case GL_COLOR_MATERIAL_FACE: |
||
3376 | case GL_COLOR_MATERIAL_PARAMETER: |
||
3377 | case GL_COLOR_MATRIX_STACK_DEPTH: |
||
3378 | case GL_COLOR_TABLE: |
||
3379 | case GL_CONVOLUTION_1D: |
||
3380 | case GL_CONVOLUTION_2D: |
||
3381 | case GL_CULL_FACE: |
||
3382 | case GL_CULL_FACE_MODE: |
||
3383 | case GL_CURRENT_INDEX: |
||
3384 | case GL_CURRENT_RASTER_DISTANCE: |
||
3385 | case GL_CURRENT_RASTER_INDEX: |
||
3386 | case GL_CURRENT_RASTER_POSITION_VALID: |
||
3387 | case GL_DEPTH_BIAS: |
||
3388 | case GL_DEPTH_CLEAR_VALUE: |
||
3389 | case GL_DEPTH_FUNC: |
||
3390 | case GL_DEPTH_SCALE: |
||
3391 | case GL_DEPTH_TEST: |
||
3392 | case GL_DEPTH_WRITEMASK: |
||
3393 | case GL_DITHER: |
||
3394 | case GL_DOUBLEBUFFER: |
||
3395 | case GL_DRAW_BUFFER: |
||
3396 | case GL_EDGE_FLAG: |
||
3397 | case GL_EDGE_FLAG_ARRAY: |
||
3398 | case GL_EDGE_FLAG_ARRAY_STRIDE: |
||
3399 | case GL_FEEDBACK_BUFFER_SIZE: |
||
3400 | case GL_FEEDBACK_BUFFER_TYPE: |
||
3401 | case GL_FOG: |
||
3402 | case GL_FOG_DENSITY: |
||
3403 | case GL_FOG_END: |
||
3404 | case GL_FOG_HINT: |
||
3405 | case GL_FOG_INDEX: |
||
3406 | case GL_FOG_MODE: |
||
3407 | case GL_FOG_START: |
||
3408 | case GL_FRONT_FACE: |
||
3409 | case GL_GREEN_BIAS: |
||
3410 | case GL_GREEN_BITS: |
||
3411 | case GL_GREEN_SCALE: |
||
3412 | case GL_HISTOGRAM: |
||
3413 | case GL_INDEX_ARRAY: |
||
3414 | case GL_INDEX_ARRAY_STRIDE: |
||
3415 | case GL_INDEX_ARRAY_TYPE: |
||
3416 | case GL_INDEX_BITS: |
||
3417 | case GL_INDEX_CLEAR_VALUE: |
||
3418 | case GL_INDEX_LOGIC_OP: |
||
3419 | case GL_INDEX_MODE: |
||
3420 | case GL_INDEX_OFFSET: |
||
3421 | case GL_INDEX_SHIFT: |
||
3422 | case GL_INDEX_WRITEMASK: |
||
3423 | case GL_LIGHT0: |
||
3424 | case GL_LIGHT1: |
||
3425 | case GL_LIGHT2: |
||
3426 | case GL_LIGHT3: |
||
3427 | case GL_LIGHT4: |
||
3428 | case GL_LIGHT5: |
||
3429 | case GL_LIGHT6: |
||
3430 | case GL_LIGHT7: |
||
3431 | case GL_LIGHTING: |
||
3432 | case GL_LIGHT_MODEL_COLOR_CONTROL: |
||
3433 | case GL_LIGHT_MODEL_LOCAL_VIEWER: |
||
3434 | case GL_LIGHT_MODEL_TWO_SIDE: |
||
3435 | case GL_LINE_SMOOTH: |
||
3436 | case GL_LINE_SMOOTH_HINT: |
||
3437 | case GL_LINE_STIPPLE: |
||
3438 | case GL_LINE_STIPPLE_PATTERN: |
||
3439 | case GL_LINE_STIPPLE_REPEAT: |
||
3440 | case GL_LINE_WIDTH: |
||
3441 | case GL_LIST_BASE: |
||
3442 | case GL_LIST_INDEX: |
||
3443 | case GL_LIST_MODE: |
||
3444 | case GL_LOGIC_OP_MODE: |
||
3445 | case GL_MAP1_COLOR_4: |
||
3446 | case GL_MAP1_GRID_SEGMENTS: |
||
3447 | case GL_MAP1_INDEX: |
||
3448 | case GL_MAP1_NORMAL: |
||
3449 | case GL_MAP1_TEXTURE_COORD_1: |
||
3450 | case GL_MAP1_TEXTURE_COORD_2: |
||
3451 | case GL_MAP1_TEXTURE_COORD_3: |
||
3452 | case GL_MAP1_TEXTURE_COORD_4: |
||
3453 | case GL_MAP1_VERTEX_3: |
||
3454 | case GL_MAP1_VERTEX_4: |
||
3455 | case GL_MAP2_COLOR_4: |
||
3456 | case GL_MAP2_INDEX: |
||
3457 | case GL_MAP2_NORMAL: |
||
3458 | case GL_MAP2_TEXTURE_COORD_1: |
||
3459 | case GL_MAP2_TEXTURE_COORD_2: |
||
3460 | case GL_MAP2_TEXTURE_COORD_3: |
||
3461 | case GL_MAP2_TEXTURE_COORD_4: |
||
3462 | case GL_MAP2_VERTEX_3: |
||
3463 | case GL_MAP2_VERTEX_4: |
||
3464 | case GL_MAP_COLOR: |
||
3465 | case GL_MAP_STENCIL: |
||
3466 | case GL_MATRIX_MODE: |
||
3467 | case GL_MAX_3D_TEXTURE_SIZE: |
||
3468 | case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: |
||
3469 | case GL_MAX_ATTRIB_STACK_DEPTH: |
||
3470 | case GL_MAX_CLIP_PLANES: |
||
3471 | case GL_MAX_COLOR_MATRIX_STACK_DEPTH: |
||
3472 | case GL_MAX_ELEMENTS_VERTICES: |
||
3473 | case GL_MAX_EVAL_ORDER: |
||
3474 | case GL_MAX_LIGHTS: |
||
3475 | case GL_MAX_LIST_NESTING: |
||
3476 | case GL_MAX_MODELVIEW_STACK_DEPTH: |
||
3477 | case GL_MAX_NAME_STACK_DEPTH: |
||
3478 | case GL_MAX_PIXEL_MAP_TABLE: |
||
3479 | case GL_MAX_PROJECTION_STACK_DEPTH: |
||
3480 | case GL_MAX_TEXTURE_SIZE: |
||
3481 | case GL_MAX_TEXTURE_STACK_DEPTH: |
||
3482 | case GL_MAX_TEXTURE_UNITS_ARB: |
||
3483 | case GL_MINMAX: |
||
3484 | case GL_MODELVIEW_STACK_DEPTH: |
||
3485 | case GL_NAME_STACK_DEPTH: |
||
3486 | case GL_NORMAL_ARRAY: |
||
3487 | case GL_NORMAL_ARRAY_STRIDE: |
||
3488 | case GL_NORMAL_ARRAY_TYPE: |
||
3489 | case GL_NORMALIZE: |
||
3490 | case GL_PACK_ALIGNMENT: |
||
3491 | case GL_PACK_IMAGE_HEIGHT: |
||
3492 | case GL_PACK_LSB_FIRST: |
||
3493 | case GL_PACK_ROW_LENGTH: |
||
3494 | case GL_PACK_SKIP_IMAGES: |
||
3495 | case GL_PACK_SKIP_PIXELS: |
||
3496 | case GL_PACK_SKIP_ROWS: |
||
3497 | case GL_PACK_SWAP_BYTES: |
||
3498 | case GL_PERSPECTIVE_CORRECTION_HINT: |
||
3499 | case GL_PIXEL_MAP_A_TO_A_SIZE: |
||
3500 | case GL_PIXEL_MAP_B_TO_B_SIZE: |
||
3501 | case GL_PIXEL_MAP_G_TO_G_SIZE: |
||
3502 | case GL_PIXEL_MAP_I_TO_A_SIZE: |
||
3503 | case GL_PIXEL_MAP_I_TO_B_SIZE: |
||
3504 | case GL_PIXEL_MAP_I_TO_G_SIZE: |
||
3505 | case GL_PIXEL_MAP_I_TO_I_SIZE: |
||
3506 | case GL_PIXEL_MAP_I_TO_R_SIZE: |
||
3507 | case GL_PIXEL_MAP_R_TO_R_SIZE: |
||
3508 | case GL_PIXEL_MAP_S_TO_S_SIZE: |
||
3509 | case GL_POINT_SIZE: |
||
3510 | case GL_POINT_SMOOTH: |
||
3511 | case GL_POINT_SMOOTH_HINT: |
||
3512 | case GL_POLYGON_OFFSET_FACTOR: |
||
3513 | case GL_POLYGON_OFFSET_UNITS: |
||
3514 | case GL_POLYGON_OFFSET_FILL: |
||
3515 | case GL_POLYGON_OFFSET_LINE: |
||
3516 | case GL_POLYGON_OFFSET_POINT: |
||
3517 | case GL_POLYGON_SMOOTH: |
||
3518 | case GL_POLYGON_SMOOTH_HINT: |
||
3519 | case GL_POLYGON_STIPPLE: |
||
3520 | case GL_POST_COLOR_MATRIX_COLOR_TABLE: |
||
3521 | case GL_POST_COLOR_MATRIX_RED_BIAS: |
||
3522 | case GL_POST_COLOR_MATRIX_GREEN_BIAS: |
||
3523 | case GL_POST_COLOR_MATRIX_BLUE_BIAS: |
||
3524 | case GL_POST_COLOR_MATRIX_ALPHA_BIAS: |
||
3525 | case GL_POST_COLOR_MATRIX_RED_SCALE: |
||
3526 | case GL_POST_COLOR_MATRIX_GREEN_SCALE: |
||
3527 | case GL_POST_COLOR_MATRIX_BLUE_SCALE: |
||
3528 | case GL_POST_COLOR_MATRIX_ALPHA_SCALE: |
||
3529 | case GL_POST_CONVOLUTION_COLOR_TABLE: |
||
3530 | case GL_POST_CONVOLUTION_RED_BIAS: |
||
3531 | case GL_POST_CONVOLUTION_GREEN_BIAS: |
||
3532 | case GL_POST_CONVOLUTION_BLUE_BIAS: |
||
3533 | case GL_POST_CONVOLUTION_ALPHA_BIAS: |
||
3534 | case GL_POST_CONVOLUTION_RED_SCALE: |
||
3535 | case GL_POST_CONVOLUTION_GREEN_SCALE: |
||
3536 | case GL_POST_CONVOLUTION_BLUE_SCALE: |
||
3537 | case GL_POST_CONVOLUTION_ALPHA_SCALE: |
||
3538 | case GL_PROJECTION_STACK_DEPTH: |
||
3539 | case GL_READ_BUFFER: |
||
3540 | case GL_RED_BIAS: |
||
3541 | case GL_RED_BITS: |
||
3542 | case GL_RED_SCALE: |
||
3543 | case GL_RENDER_MODE: |
||
3544 | case GL_RESCALE_NORMAL: |
||
3545 | case GL_RGBA_MODE: |
||
3546 | case GL_SCISSOR_TEST: |
||
3547 | case GL_SELECTION_BUFFER_SIZE: |
||
3548 | case GL_SEPARABLE_2D: |
||
3549 | case GL_SHADE_MODEL: |
||
3550 | case GL_SMOOTH_LINE_WIDTH_GRANULARITY: |
||
3551 | case GL_SMOOTH_POINT_SIZE_GRANULARITY: |
||
3552 | case GL_STENCIL_BITS: |
||
3553 | case GL_STENCIL_CLEAR_VALUE: |
||
3554 | case GL_STENCIL_FAIL: |
||
3555 | case GL_STENCIL_FUNC: |
||
3556 | case GL_STENCIL_PASS_DEPTH_FAIL: |
||
3557 | case GL_STENCIL_PASS_DEPTH_PASS: |
||
3558 | case GL_STENCIL_REF: |
||
3559 | case GL_STENCIL_TEST: |
||
3560 | case GL_STENCIL_VALUE_MASK: |
||
3561 | case GL_STENCIL_WRITEMASK: |
||
3562 | case GL_STEREO: |
||
3563 | case GL_SUBPIXEL_BITS: |
||
3564 | case GL_TEXTURE_1D: |
||
3565 | case GL_TEXTURE_BINDING_1D: |
||
3566 | case GL_TEXTURE_2D: |
||
3567 | case GL_TEXTURE_BINDING_2D: |
||
3568 | case GL_TEXTURE_3D: |
||
3569 | case GL_TEXTURE_BINDING_3D: |
||
3570 | case GL_TEXTURE_COORD_ARRAY: |
||
3571 | case GL_TEXTURE_COORD_ARRAY_SIZE: |
||
3572 | case GL_TEXTURE_COORD_ARRAY_STRIDE: |
||
3573 | case GL_TEXTURE_COORD_ARRAY_TYPE: |
||
3574 | case GL_TEXTURE_GEN_Q: |
||
3575 | case GL_TEXTURE_GEN_R: |
||
3576 | case GL_TEXTURE_GEN_S: |
||
3577 | case GL_TEXTURE_GEN_T: |
||
3578 | case GL_TEXTURE_STACK_DEPTH: |
||
3579 | case GL_UNPACK_ALIGNMENT: |
||
3580 | case GL_UNPACK_IMAGE_HEIGHT: |
||
3581 | case GL_UNPACK_LSB_FIRST: |
||
3582 | case GL_UNPACK_ROW_LENGTH: |
||
3583 | case GL_UNPACK_SKIP_IMAGES: |
||
3584 | case GL_UNPACK_SKIP_PIXELS: |
||
3585 | case GL_UNPACK_SKIP_ROWS: |
||
3586 | case GL_UNPACK_SWAP_BYTES: |
||
3587 | case GL_VERTEX_ARRAY: |
||
3588 | case GL_VERTEX_ARRAY_SIZE: |
||
3589 | case GL_VERTEX_ARRAY_STRIDE: |
||
3590 | case GL_VERTEX_ARRAY_TYPE: |
||
3591 | case GL_ZOOM_X: |
||
3592 | case GL_ZOOM_Y: |
||
3593 | trWritei( params[0] ); |
||
3594 | break; |
||
3595 | |||
3596 | default: |
||
3597 | /* Bad enum. What should we do? */ |
||
3598 | break; |
||
3599 | } |
||
3600 | } |
||
3601 | |||
3602 | |||
3603 | GLAPI void GLAPIENTRY trGetLightfv( GLenum light, GLenum pname, GLfloat *params ) { |
||
3604 | trWriteCMD( CMD_GETLIGHTFV ); |
||
3605 | trWriteEnum( light ); |
||
3606 | trWriteEnum( pname ); |
||
3607 | trWritePointer( (void *)params ); |
||
3608 | trFileFlush(); |
||
3609 | |||
3610 | if( trCtx()->doExec ) { |
||
3611 | trGetDispatch()->GetLightfv( light, pname, params ); |
||
3612 | trError(); |
||
3613 | } else { |
||
3614 | switch( pname ) { |
||
3615 | case GL_AMBIENT: |
||
3616 | case GL_DIFFUSE: |
||
3617 | case GL_SPECULAR: |
||
3618 | case GL_POSITION: |
||
3619 | memset( params, 0, 4 * sizeof(GLfloat) ); |
||
3620 | break; |
||
3621 | case GL_SPOT_DIRECTION: |
||
3622 | memset( params, 0, 3 * sizeof(GLfloat) ); |
||
3623 | break; |
||
3624 | case GL_SPOT_EXPONENT: |
||
3625 | case GL_SPOT_CUTOFF: |
||
3626 | case GL_CONSTANT_ATTENUATION: |
||
3627 | case GL_LINEAR_ATTENUATION: |
||
3628 | case GL_QUADRATIC_ATTENUATION: |
||
3629 | params[0] = 0; |
||
3630 | break; |
||
3631 | default: |
||
3632 | /* The 2nd pass should catch this */ |
||
3633 | break; |
||
3634 | } |
||
3635 | } |
||
3636 | switch( pname ) { |
||
3637 | case GL_AMBIENT: |
||
3638 | case GL_DIFFUSE: |
||
3639 | case GL_SPECULAR: |
||
3640 | case GL_POSITION: |
||
3641 | trWriteArrayf( 4, params ); |
||
3642 | break; |
||
3643 | case GL_SPOT_DIRECTION: |
||
3644 | trWriteArrayf( 3, params ); |
||
3645 | break; |
||
3646 | case GL_SPOT_EXPONENT: |
||
3647 | case GL_SPOT_CUTOFF: |
||
3648 | case GL_CONSTANT_ATTENUATION: |
||
3649 | case GL_LINEAR_ATTENUATION: |
||
3650 | case GL_QUADRATIC_ATTENUATION: |
||
3651 | trWritef( params[0] ); |
||
3652 | break; |
||
3653 | default: |
||
3654 | /* The 2nd pass should catch this */ |
||
3655 | break; |
||
3656 | } |
||
3657 | } |
||
3658 | |||
3659 | |||
3660 | GLAPI void GLAPIENTRY trGetLightiv( GLenum light, GLenum pname, GLint *params ) { |
||
3661 | trWriteCMD( CMD_GETLIGHTIV ); |
||
3662 | trWriteEnum( light ); |
||
3663 | trWriteEnum( pname ); |
||
3664 | trWritePointer( (void *)params ); |
||
3665 | trFileFlush(); |
||
3666 | |||
3667 | if( trCtx()->doExec ) { |
||
3668 | trGetDispatch()->GetLightiv( light, pname, params ); |
||
3669 | trError(); |
||
3670 | } else { |
||
3671 | switch( pname ) { |
||
3672 | case GL_AMBIENT: |
||
3673 | case GL_DIFFUSE: |
||
3674 | case GL_SPECULAR: |
||
3675 | case GL_POSITION: |
||
3676 | memset( params, 0, 4 * sizeof(GLint) ); |
||
3677 | break; |
||
3678 | case GL_SPOT_DIRECTION: |
||
3679 | memset( params, 0, 3 * sizeof(GLint) ); |
||
3680 | break; |
||
3681 | case GL_SPOT_EXPONENT: |
||
3682 | case GL_SPOT_CUTOFF: |
||
3683 | case GL_CONSTANT_ATTENUATION: |
||
3684 | case GL_LINEAR_ATTENUATION: |
||
3685 | case GL_QUADRATIC_ATTENUATION: |
||
3686 | params[0] = 0; |
||
3687 | break; |
||
3688 | default: |
||
3689 | /* The 2nd pass should catch this */ |
||
3690 | break; |
||
3691 | } |
||
3692 | } |
||
3693 | switch( pname ) { |
||
3694 | case GL_AMBIENT: |
||
3695 | case GL_DIFFUSE: |
||
3696 | case GL_SPECULAR: |
||
3697 | case GL_POSITION: |
||
3698 | trWriteArrayi( 4, params ); |
||
3699 | break; |
||
3700 | case GL_SPOT_DIRECTION: |
||
3701 | trWriteArrayi( 3, params ); |
||
3702 | break; |
||
3703 | case GL_SPOT_EXPONENT: |
||
3704 | case GL_SPOT_CUTOFF: |
||
3705 | case GL_CONSTANT_ATTENUATION: |
||
3706 | case GL_LINEAR_ATTENUATION: |
||
3707 | case GL_QUADRATIC_ATTENUATION: |
||
3708 | trWritei( params[0] ); |
||
3709 | break; |
||
3710 | default: |
||
3711 | /* The 2nd pass should catch this */ |
||
3712 | break; |
||
3713 | } |
||
3714 | } |
||
3715 | |||
3716 | |||
3717 | GLAPI void GLAPIENTRY trGetMapdv( GLenum target, GLenum query, GLdouble *v ) { /* TODO */ |
||
3718 | trWriteCMD( CMD_GETMAPDV ); |
||
3719 | trWriteEnum( target ); |
||
3720 | trWriteEnum( query ); |
||
3721 | trWritePointer( (void *)v ); |
||
3722 | trFileFlush(); |
||
3723 | |||
3724 | if( trCtx()->doExec ) { |
||
3725 | trGetDispatch()->GetMapdv( target, query, v ); |
||
3726 | trError(); |
||
3727 | } |
||
3728 | } |
||
3729 | |||
3730 | |||
3731 | GLAPI void GLAPIENTRY trGetMapfv( GLenum target, GLenum query, GLfloat *v ) { /* TODO */ |
||
3732 | trWriteCMD( CMD_GETMAPFV ); |
||
3733 | trWriteEnum( target ); |
||
3734 | trWriteEnum( query ); |
||
3735 | trWritePointer( (void *)v ); |
||
3736 | trFileFlush(); |
||
3737 | |||
3738 | if( trCtx()->doExec ) { |
||
3739 | trGetDispatch()->GetMapfv( target, query, v ); |
||
3740 | trError(); |
||
3741 | } |
||
3742 | } |
||
3743 | |||
3744 | |||
3745 | GLAPI void GLAPIENTRY trGetMapiv( GLenum target, GLenum query, GLint *v ) { /* TODO */ |
||
3746 | trWriteCMD( CMD_GETMAPIV ); |
||
3747 | trWriteEnum( target ); |
||
3748 | trWriteEnum( query ); |
||
3749 | trWritePointer( (void *)v ); |
||
3750 | trFileFlush(); |
||
3751 | |||
3752 | if( trCtx()->doExec ) { |
||
3753 | trGetDispatch()->GetMapiv( target, query, v ); |
||
3754 | trError(); |
||
3755 | } |
||
3756 | } |
||
3757 | |||
3758 | |||
3759 | GLAPI void GLAPIENTRY trGetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) { |
||
3760 | trWriteCMD( CMD_GETMATERIALFV ); |
||
3761 | trWriteEnum( face ); |
||
3762 | trWriteEnum( pname ); |
||
3763 | trWritePointer( (void *)params ); |
||
3764 | trFileFlush(); |
||
3765 | |||
3766 | if( trCtx()->doExec ) { |
||
3767 | trGetDispatch()->GetMaterialfv( face, pname, params ); |
||
3768 | trError(); |
||
3769 | } else { |
||
3770 | switch( pname ) { |
||
3771 | case GL_AMBIENT: |
||
3772 | case GL_DIFFUSE: |
||
3773 | case GL_SPECULAR: |
||
3774 | case GL_EMISSION: |
||
3775 | memset( params, 0, 4 * sizeof(GLfloat) ); |
||
3776 | break; |
||
3777 | case GL_COLOR_INDEXES: |
||
3778 | memset( params, 0, 3 * sizeof(GLfloat) ); |
||
3779 | break; |
||
3780 | case GL_SHININESS: |
||
3781 | params[0] = 0; |
||
3782 | break; |
||
3783 | default: |
||
3784 | /* The 2nd pass will pick this up. */ |
||
3785 | break; |
||
3786 | } |
||
3787 | } |
||
3788 | switch( pname ) { |
||
3789 | case GL_AMBIENT: |
||
3790 | case GL_DIFFUSE: |
||
3791 | case GL_SPECULAR: |
||
3792 | case GL_EMISSION: |
||
3793 | trWriteArrayf( 4, params ); |
||
3794 | break; |
||
3795 | case GL_COLOR_INDEXES: |
||
3796 | trWriteArrayf( 3, params ); |
||
3797 | break; |
||
3798 | case GL_SHININESS: |
||
3799 | trWritef( params[0] ); |
||
3800 | break; |
||
3801 | default: |
||
3802 | /* The 2nd pass will pick this up. */ |
||
3803 | break; |
||
3804 | } |
||
3805 | } |
||
3806 | |||
3807 | |||
3808 | GLAPI void GLAPIENTRY trGetMaterialiv( GLenum face, GLenum pname, GLint *params ) { |
||
3809 | trWriteCMD( CMD_GETMATERIALIV ); |
||
3810 | trWriteEnum( face ); |
||
3811 | trWriteEnum( pname ); |
||
3812 | trWritePointer( (void *)params ); |
||
3813 | trFileFlush(); |
||
3814 | |||
3815 | if( trCtx()->doExec ) { |
||
3816 | trGetDispatch()->GetMaterialiv( face, pname, params ); |
||
3817 | trError(); |
||
3818 | } else { |
||
3819 | switch( pname ) { |
||
3820 | case GL_AMBIENT: |
||
3821 | case GL_DIFFUSE: |
||
3822 | case GL_SPECULAR: |
||
3823 | case GL_EMISSION: |
||
3824 | memset( params, 0, 4 * sizeof(GLint) ); |
||
3825 | break; |
||
3826 | case GL_COLOR_INDEXES: |
||
3827 | memset( params, 0, 3 * sizeof(GLint) ); |
||
3828 | break; |
||
3829 | case GL_SHININESS: |
||
3830 | params[0] = 0; |
||
3831 | break; |
||
3832 | default: |
||
3833 | /* The 2nd pass will pick this up. */ |
||
3834 | break; |
||
3835 | } |
||
3836 | } |
||
3837 | switch( pname ) { |
||
3838 | case GL_AMBIENT: |
||
3839 | case GL_DIFFUSE: |
||
3840 | case GL_SPECULAR: |
||
3841 | case GL_EMISSION: |
||
3842 | trWriteArrayi( 4, params ); |
||
3843 | break; |
||
3844 | case GL_COLOR_INDEXES: |
||
3845 | trWriteArrayi( 3, params ); |
||
3846 | break; |
||
3847 | case GL_SHININESS: |
||
3848 | trWritei( params[0] ); |
||
3849 | break; |
||
3850 | default: |
||
3851 | /* The 2nd pass will pick this up. */ |
||
3852 | break; |
||
3853 | } |
||
3854 | } |
||
3855 | |||
3856 | |||
3857 | GLAPI void GLAPIENTRY trGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values ) { |
||
3858 | GLint pixelsize; |
||
3859 | |||
3860 | trWriteCMD( CMD_GETMINMAX ); |
||
3861 | trWriteEnum( target ); |
||
3862 | trWriteBool( reset ); |
||
3863 | trWriteEnum( format ); |
||
3864 | trWriteEnum( types ); |
||
3865 | trWritePointer( (void *)values ); |
||
3866 | trFileFlush(); |
||
3867 | |||
3868 | if( trCtx()->doExec ) { |
||
3869 | trGetDispatch()->GetMinmax( target, reset, format, types, values ); |
||
3870 | trError(); |
||
3871 | } else { |
||
3872 | switch( types ) { |
||
3873 | case GL_BYTE: |
||
3874 | ((GLbyte *)values)[0] = 0; |
||
3875 | ((GLbyte *)values)[1] = 0; |
||
3876 | break; |
||
3877 | |||
3878 | case GL_UNSIGNED_BYTE: |
||
3879 | case GL_UNSIGNED_BYTE_3_3_2: |
||
3880 | case GL_UNSIGNED_BYTE_2_3_3_REV: |
||
3881 | ((GLubyte *)values)[0] = 0; |
||
3882 | ((GLubyte *)values)[1] = 0; |
||
3883 | break; |
||
3884 | |||
3885 | case GL_SHORT: |
||
3886 | ((GLshort *)values)[0] = 0; |
||
3887 | ((GLshort *)values)[1] = 0; |
||
3888 | break; |
||
3889 | |||
3890 | case GL_UNSIGNED_SHORT: |
||
3891 | case GL_UNSIGNED_SHORT_5_6_5: |
||
3892 | case GL_UNSIGNED_SHORT_5_6_5_REV: |
||
3893 | case GL_UNSIGNED_SHORT_4_4_4_4: |
||
3894 | case GL_UNSIGNED_SHORT_4_4_4_4_REV: |
||
3895 | case GL_UNSIGNED_SHORT_5_5_5_1: |
||
3896 | case GL_UNSIGNED_SHORT_1_5_5_5_REV: |
||
3897 | ((GLshort *)values)[0] = 0; |
||
3898 | ((GLshort *)values)[1] = 0; |
||
3899 | break; |
||
3900 | |||
3901 | case GL_INT: |
||
3902 | ((GLint *)values)[0] = 0; |
||
3903 | ((GLint *)values)[1] = 0; |
||
3904 | break; |
||
3905 | |||
3906 | case GL_UNSIGNED_INT: |
||
3907 | case GL_UNSIGNED_INT_8_8_8_8: |
||
3908 | case GL_UNSIGNED_INT_8_8_8_8_REV: |
||
3909 | case GL_UNSIGNED_INT_10_10_10_2: |
||
3910 | case GL_UNSIGNED_INT_2_10_10_10_REV: |
||
3911 | ((GLuint *)values)[0] = 0; |
||
3912 | ((GLuint *)values)[1] = 0; |
||
3913 | break; |
||
3914 | |||
3915 | case GL_FLOAT: |
||
3916 | ((GLfloat *)values)[0] = 0.0; |
||
3917 | ((GLfloat *)values)[1] = 0.0; |
||
3918 | break; |
||
3919 | |||
3920 | default: |
||
3921 | /* The 2nd pass should catch this. */ |
||
3922 | break; |
||
3923 | } |
||
3924 | } |
||
3925 | |||
3926 | pixelsize = trGetPixelSize( format, types ); |
||
3927 | trWriteTypeArray( types, 2, pixelsize, 0, values ); |
||
3928 | } |
||
3929 | |||
3930 | |||
3931 | GLAPI void GLAPIENTRY trGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params ) { /* TODO */ |
||
3932 | trWriteCMD( CMD_GETMINMAXPARAMETERFV ); |
||
3933 | trWriteEnum( target ); |
||
3934 | trWriteEnum( pname ); |
||
3935 | trWritePointer( (void *)params ); |
||
3936 | trFileFlush(); |
||
3937 | |||
3938 | if( trCtx()->doExec ) { |
||
3939 | trGetDispatch()->GetMinmaxParameterfv( target, pname, params ); |
||
3940 | trError(); |
||
3941 | } else { |
||
3942 | params[0] = 0.0; |
||
3943 | } |
||
3944 | |||
3945 | trWritef( params[0] ); |
||
3946 | } |
||
3947 | |||
3948 | |||
3949 | GLAPI void GLAPIENTRY trGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params ) { /* TODO */ |
||
3950 | trWriteCMD( CMD_GETMINMAXPARAMETERIV ); |
||
3951 | trWriteEnum( target ); |
||
3952 | trWriteEnum( pname ); |
||
3953 | trWritePointer( (void *)params ); |
||
3954 | trFileFlush(); |
||
3955 | |||
3956 | if( trCtx()->doExec ) { |
||
3957 | trGetDispatch()->GetMinmaxParameteriv( target, pname, params ); |
||
3958 | trError(); |
||
3959 | } else { |
||
3960 | params[0] = 0; |
||
3961 | } |
||
3962 | |||
3963 | trWritei( params[0] ); |
||
3964 | } |
||
3965 | |||
3966 | |||
3967 | GLAPI void GLAPIENTRY trGetPixelMapfv( GLenum map, GLfloat *values ) { /* TODO */ |
||
3968 | trWriteCMD( CMD_GETPIXELMAPFV ); |
||
3969 | trWriteEnum( map ); |
||
3970 | trWritePointer( (void *)values ); |
||
3971 | trFileFlush(); |
||
3972 | |||
3973 | if( trCtx()->doExec ) { |
||
3974 | trGetDispatch()->GetPixelMapfv( map, values ); |
||
3975 | trError(); |
||
3976 | } |
||
3977 | } |
||
3978 | |||
3979 | |||
3980 | GLAPI void GLAPIENTRY trGetPixelMapuiv( GLenum map, GLuint *values ) { /* TODO */ |
||
3981 | trWriteCMD( CMD_GETPIXELMAPUIV ); |
||
3982 | trWriteEnum( map ); |
||
3983 | trWritePointer( (void *)values ); |
||
3984 | trFileFlush(); |
||
3985 | |||
3986 | if( trCtx()->doExec ) { |
||
3987 | trGetDispatch()->GetPixelMapuiv( map, values ); |
||
3988 | trError(); |
||
3989 | } |
||
3990 | } |
||
3991 | |||
3992 | |||
3993 | GLAPI void GLAPIENTRY trGetPixelMapusv( GLenum map, GLushort *values ) { /* TODO */ |
||
3994 | trWriteCMD( CMD_GETPIXELMAPUSV ); |
||
3995 | trWriteEnum( map ); |
||
3996 | trWritePointer( (void *)values ); |
||
3997 | trFileFlush(); |
||
3998 | |||
3999 | if( trCtx()->doExec ) { |
||
4000 | trGetDispatch()->GetPixelMapusv( map, values ); |
||
4001 | trError(); |
||
4002 | } |
||
4003 | } |
||
4004 | |||
4005 | |||
4006 | #if 0 |
||
4007 | // Not in MESAs dispatch table |
||
4008 | GLAPI void GLAPIENTRY trGetPointervEXT( GLenum pname, void **params ) { |
||
4009 | trWriteCMD( CMD_GETPOINTERVEXT ); |
||
4010 | trWriteEnum( pname ); |
||
4011 | |||
4012 | if( trCtx()->doExec ) { |
||
4013 | trGetDispatch()->GetPointervEXT( pname, params ); |
||
4014 | trError(); |
||
4015 | } else { |
||
4016 | *params = NULL; |
||
4017 | } |
||
4018 | trWritePointer( (void *)(*params) ); |
||
4019 | } |
||
4020 | #endif |
||
4021 | |||
4022 | |||
4023 | GLAPI void GLAPIENTRY trGetPointerv( GLenum pname, void **params ) { |
||
4024 | trWriteCMD( CMD_GETPOINTERV ); |
||
4025 | trWriteEnum( pname ); |
||
4026 | |||
4027 | if( trCtx()->doExec ) { |
||
4028 | trGetDispatch()->GetPointerv( pname, params ); |
||
4029 | trError(); |
||
4030 | } else { |
||
4031 | *params = NULL; |
||
4032 | } |
||
4033 | trWritePointer( (void *)(*params) ); |
||
4034 | } |
||
4035 | |||
4036 | |||
4037 | GLAPI void GLAPIENTRY trGetPolygonStipple( GLubyte *mask ) { |
||
4038 | GLint i; |
||
4039 | |||
4040 | trWriteCMD( CMD_GETPOLYGONSTIPPLE ); |
||
4041 | trWritePointer( (void *)mask ); |
||
4042 | trFileFlush(); |
||
4043 | |||
4044 | if( trCtx()->doExec ) { |
||
4045 | trGetDispatch()->GetPolygonStipple( mask ); |
||
4046 | trError(); |
||
4047 | } else { |
||
4048 | for( i = 0; i < 8 * 8; i++ ) { |
||
4049 | mask[i] = 0x0; |
||
4050 | } |
||
4051 | } |
||
4052 | for( i = 0; i < 8 * 8; i++ ) { |
||
4053 | trWriteub( mask[i] ); |
||
4054 | } |
||
4055 | } |
||
4056 | |||
4057 | |||
4058 | GLAPI void GLAPIENTRY trGetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span ) { |
||
4059 | |||
4060 | trWriteCMD( CMD_GETSEPARABLEFILTER ); |
||
4061 | trWriteEnum( target ); |
||
4062 | trWriteEnum( format ); |
||
4063 | trWriteEnum( type ); |
||
4064 | trWritePointer( (void *)row ); |
||
4065 | trFileFlush(); |
||
4066 | trWritePointer( (void *)column ); |
||
4067 | trFileFlush(); |
||
4068 | trWritePointer( (void *)span ); |
||
4069 | trFileFlush(); |
||
4070 | |||
4071 | if( trCtx()->doExec ) { |
||
4072 | trGetDispatch()->GetSeparableFilter( target, format, type, row, column, span ); |
||
4073 | trError(); |
||
4074 | } |
||
4075 | } |
||
4076 | |||
4077 | |||
4078 | GLAPI const GLubyte* GLAPIENTRY trGetString( GLenum name ) { |
||
4079 | const GLubyte * tmpstring; |
||
4080 | |||
4081 | trWriteCMD( CMD_GETSTRING ); |
||
4082 | trWriteEnum( name ); |
||
4083 | |||
4084 | if( trCtx()->doExec ) { |
||
4085 | tmpstring = trGetDispatch()->GetString( name ); |
||
4086 | trError(); |
||
4087 | } else { |
||
4088 | tmpstring = NULL; |
||
4089 | } |
||
4090 | |||
4091 | trWriteString( (char *)tmpstring ); |
||
4092 | return tmpstring; |
||
4093 | } |
||
4094 | |||
4095 | |||
4096 | GLAPI void GLAPIENTRY trGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) { |
||
4097 | trWriteCMD( CMD_GETTEXENVFV ); |
||
4098 | trWriteEnum( target ); |
||
4099 | trWriteEnum( pname ); |
||
4100 | trWritePointer( (void *)params ); |
||
4101 | trFileFlush(); |
||
4102 | |||
4103 | if( trCtx()->doExec ) { |
||
4104 | trGetDispatch()->GetTexEnvfv( target, pname, params ); |
||
4105 | trError(); |
||
4106 | } else { |
||
4107 | switch( pname ) { |
||
4108 | case GL_TEXTURE_ENV_MODE: |
||
4109 | params[0] = 0.0; |
||
4110 | break; |
||
4111 | case GL_TEXTURE_ENV_COLOR: |
||
4112 | memset( params, 0, 4 * sizeof(GLfloat) ); |
||
4113 | break; |
||
4114 | default: |
||
4115 | /* The 2nd pass should pick this up. */ |
||
4116 | break; |
||
4117 | } |
||
4118 | } |
||
4119 | switch( pname ) { |
||
4120 | case GL_TEXTURE_ENV_MODE: |
||
4121 | trWritef( params[0] ); |
||
4122 | break; |
||
4123 | case GL_TEXTURE_ENV_COLOR: |
||
4124 | trWriteArrayf( 4, params ); |
||
4125 | break; |
||
4126 | default: |
||
4127 | /* The 2nd pass should pick this up. */ |
||
4128 | break; |
||
4129 | } |
||
4130 | } |
||
4131 | |||
4132 | |||
4133 | GLAPI void GLAPIENTRY trGetTexEnviv( GLenum target, GLenum pname, GLint *params ) { |
||
4134 | trWriteCMD( CMD_GETTEXENVIV ); |
||
4135 | trWriteEnum( target ); |
||
4136 | trWriteEnum( pname ); |
||
4137 | trWritePointer( (void *)params ); |
||
4138 | trFileFlush(); |
||
4139 | |||
4140 | if( trCtx()->doExec ) { |
||
4141 | trGetDispatch()->GetTexEnviv( target, pname, params ); |
||
4142 | trError(); |
||
4143 | } else { |
||
4144 | switch( pname ) { |
||
4145 | case GL_TEXTURE_ENV_MODE: |
||
4146 | params[0] = 0; |
||
4147 | break; |
||
4148 | case GL_TEXTURE_ENV_COLOR: |
||
4149 | memset( params, 0, 4 * sizeof(GLint) ); |
||
4150 | break; |
||
4151 | default: |
||
4152 | /* The 2nd pass should pick this up. */ |
||
4153 | break; |
||
4154 | } |
||
4155 | } |
||
4156 | switch( pname ) { |
||
4157 | case GL_TEXTURE_ENV_MODE: |
||
4158 | trWritei( params[0] ); |
||
4159 | break; |
||
4160 | case GL_TEXTURE_ENV_COLOR: |
||
4161 | trWriteArrayi( 4, params ); |
||
4162 | break; |
||
4163 | default: |
||
4164 | /* The 2nd pass should pick this up. */ |
||
4165 | break; |
||
4166 | } |
||
4167 | } |
||
4168 | |||
4169 | |||
4170 | GLAPI void GLAPIENTRY trGetTexGendv( GLenum coord, GLenum pname, GLdouble *params ) { |
||
4171 | trWriteCMD( CMD_GETTEXGENDV ); |
||
4172 | trWriteEnum( coord ); |
||
4173 | trWriteEnum( pname ); |
||
4174 | trWritePointer( (void *)params ); |
||
4175 | trFileFlush(); |
||
4176 | |||
4177 | if( trCtx()->doExec ) { |
||
4178 | trGetDispatch()->GetTexGendv( coord, pname, params ); |
||
4179 | trError(); |
||
4180 | } else { |
||
4181 | switch( pname ) { |
||
4182 | case GL_TEXTURE_GEN_MODE: |
||
4183 | params[0] = 0.0; |
||
4184 | break; |
||
4185 | case GL_OBJECT_PLANE: |
||
4186 | case GL_EYE_PLANE: |
||
4187 | memset( params, 0, 4 * sizeof(GLdouble) ); |
||
4188 | break; |
||
4189 | default: |
||
4190 | /* The 2nd pass should pick this up. */ |
||
4191 | break; |
||
4192 | } |
||
4193 | } |
||
4194 | switch( pname ) { |
||
4195 | case GL_TEXTURE_GEN_MODE: |
||
4196 | trWrited( params[0] ); |
||
4197 | break; |
||
4198 | case GL_OBJECT_PLANE: |
||
4199 | case GL_EYE_PLANE: |
||
4200 | trWriteArrayd( 4, params ); |
||
4201 | break; |
||
4202 | default: |
||
4203 | /* The 2nd pass should pick this up. */ |
||
4204 | break; |
||
4205 | } |
||
4206 | } |
||
4207 | |||
4208 | |||
4209 | GLAPI void GLAPIENTRY trGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params ) { |
||
4210 | trWriteCMD( CMD_GETTEXGENFV ); |
||
4211 | trWriteEnum( coord ); |
||
4212 | trWriteEnum( pname ); |
||
4213 | trWritePointer( (void *)params ); |
||
4214 | trFileFlush(); |
||
4215 | |||
4216 | if( trCtx()->doExec ) { |
||
4217 | trGetDispatch()->GetTexGenfv( coord, pname, params ); |
||
4218 | trError(); |
||
4219 | } else { |
||
4220 | switch( pname ) { |
||
4221 | case GL_TEXTURE_GEN_MODE: |
||
4222 | params[0] = 0.0; |
||
4223 | break; |
||
4224 | case GL_OBJECT_PLANE: |
||
4225 | case GL_EYE_PLANE: |
||
4226 | memset( params, 0, 4 * sizeof(GLfloat) ); |
||
4227 | break; |
||
4228 | default: |
||
4229 | /* The 2nd pass should pick this up. */ |
||
4230 | break; |
||
4231 | } |
||
4232 | } |
||
4233 | switch( pname ) { |
||
4234 | case GL_TEXTURE_GEN_MODE: |
||
4235 | trWritef( params[0] ); |
||
4236 | break; |
||
4237 | case GL_OBJECT_PLANE: |
||
4238 | case GL_EYE_PLANE: |
||
4239 | trWriteArrayf( 4, params ); |
||
4240 | break; |
||
4241 | default: |
||
4242 | /* The 2nd pass should pick this up. */ |
||
4243 | break; |
||
4244 | } |
||
4245 | } |
||
4246 | |||
4247 | |||
4248 | GLAPI void GLAPIENTRY trGetTexGeniv( GLenum coord, GLenum pname, GLint *params ) { |
||
4249 | trWriteCMD( CMD_GETTEXGENIV ); |
||
4250 | trWriteEnum( coord ); |
||
4251 | trWriteEnum( pname ); |
||
4252 | trWritePointer( (void *)params ); |
||
4253 | trFileFlush(); |
||
4254 | |||
4255 | if( trCtx()->doExec ) { |
||
4256 | trGetDispatch()->GetTexGeniv( coord, pname, params ); |
||
4257 | trError(); |
||
4258 | } else { |
||
4259 | switch( pname ) { |
||
4260 | case GL_TEXTURE_GEN_MODE: |
||
4261 | params[0] = 0; |
||
4262 | break; |
||
4263 | case GL_OBJECT_PLANE: |
||
4264 | case GL_EYE_PLANE: |
||
4265 | memset( params, 0, 4 * sizeof(GLint) ); |
||
4266 | break; |
||
4267 | default: |
||
4268 | /* The 2nd pass should pick this up. */ |
||
4269 | break; |
||
4270 | } |
||
4271 | } |
||
4272 | switch( pname ) { |
||
4273 | case GL_TEXTURE_GEN_MODE: |
||
4274 | trWritei( params[0] ); |
||
4275 | break; |
||
4276 | case GL_OBJECT_PLANE: |
||
4277 | case GL_EYE_PLANE: |
||
4278 | trWriteArrayi( 4, params ); |
||
4279 | break; |
||
4280 | default: |
||
4281 | /* The 2nd pass should pick this up. */ |
||
4282 | break; |
||
4283 | } |
||
4284 | } |
||
4285 | |||
4286 | |||
4287 | GLAPI void GLAPIENTRY trGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels ) { /* TODO */ |
||
4288 | |||
4289 | trWriteCMD( CMD_GETTEXIMAGE ); |
||
4290 | trWriteEnum( target ); |
||
4291 | trWritei( level ); |
||
4292 | trWriteEnum( format ); |
||
4293 | trWriteEnum( type ); |
||
4294 | trWritePointer( (void *)pixels ); |
||
4295 | trFileFlush(); |
||
4296 | |||
4297 | if( trCtx()->doExec ) { |
||
4298 | trGetDispatch()->GetTexImage( target, level, format, type, pixels ); |
||
4299 | trError(); |
||
4300 | } |
||
4301 | } |
||
4302 | |||
4303 | |||
4304 | GLAPI void GLAPIENTRY trGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params ) { |
||
4305 | trWriteCMD( CMD_GETTEXLEVELPARAMETERFV ); |
||
4306 | trWriteEnum( target ); |
||
4307 | trWritei( level ); |
||
4308 | trWriteEnum( pname ); |
||
4309 | trWritePointer( (void *)params ); |
||
4310 | trFileFlush(); |
||
4311 | |||
4312 | if( trCtx()->doExec ) { |
||
4313 | trGetDispatch()->GetTexLevelParameterfv( target, level, pname, params ); |
||
4314 | trError(); |
||
4315 | } else { |
||
4316 | params[0] = 0.0; |
||
4317 | } |
||
4318 | trWritef( params[0] ); |
||
4319 | } |
||
4320 | |||
4321 | |||
4322 | GLAPI void GLAPIENTRY trGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params ) { |
||
4323 | trWriteCMD( CMD_GETTEXLEVELPARAMETERIV ); |
||
4324 | trWriteEnum( target ); |
||
4325 | trWritei( level ); |
||
4326 | trWriteEnum( pname ); |
||
4327 | trWritePointer( (void *)params ); |
||
4328 | trFileFlush(); |
||
4329 | |||
4330 | if( trCtx()->doExec ) { |
||
4331 | trGetDispatch()->GetTexLevelParameteriv( target, level, pname, params ); |
||
4332 | trError(); |
||
4333 | } else { |
||
4334 | params[0] = 0; |
||
4335 | } |
||
4336 | trWritei( params[0] ); |
||
4337 | } |
||
4338 | |||
4339 | |||
4340 | GLAPI void GLAPIENTRY trGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params) { |
||
4341 | trWriteCMD( CMD_GETTEXPARAMETERFV ); |
||
4342 | trWriteEnum( target ); |
||
4343 | trWriteEnum( pname ); |
||
4344 | trWritePointer( (void *)params ); |
||
4345 | trFileFlush(); |
||
4346 | |||
4347 | if( trCtx()->doExec ) { |
||
4348 | trGetDispatch()->GetTexParameterfv( target, pname, params ); |
||
4349 | trError(); |
||
4350 | } else { |
||
4351 | switch( pname ) { |
||
4352 | case GL_TEXTURE_MAG_FILTER: |
||
4353 | case GL_TEXTURE_MIN_FILTER: |
||
4354 | case GL_TEXTURE_MIN_LOD: |
||
4355 | case GL_TEXTURE_MAX_LOD: |
||
4356 | case GL_TEXTURE_BASE_LEVEL: |
||
4357 | case GL_TEXTURE_MAX_LEVEL: |
||
4358 | case GL_TEXTURE_WRAP_S: |
||
4359 | case GL_TEXTURE_WRAP_T: |
||
4360 | case GL_TEXTURE_WRAP_R: |
||
4361 | case GL_TEXTURE_PRIORITY: |
||
4362 | case GL_TEXTURE_RESIDENT: |
||
4363 | params[0] = 0.0; |
||
4364 | break; |
||
4365 | case GL_TEXTURE_BORDER_COLOR: |
||
4366 | memset( params, 0, 4 * sizeof(GLfloat) ); |
||
4367 | default: |
||
4368 | /* The 2nd pass should pick this up. */ |
||
4369 | break; |
||
4370 | } |
||
4371 | } |
||
4372 | switch( pname ) { |
||
4373 | case GL_TEXTURE_MAG_FILTER: |
||
4374 | case GL_TEXTURE_MIN_FILTER: |
||
4375 | case GL_TEXTURE_MIN_LOD: |
||
4376 | case GL_TEXTURE_MAX_LOD: |
||
4377 | case GL_TEXTURE_BASE_LEVEL: |
||
4378 | case GL_TEXTURE_MAX_LEVEL: |
||
4379 | case GL_TEXTURE_WRAP_S: |
||
4380 | case GL_TEXTURE_WRAP_T: |
||
4381 | case GL_TEXTURE_WRAP_R: |
||
4382 | case GL_TEXTURE_PRIORITY: |
||
4383 | case GL_TEXTURE_RESIDENT: |
||
4384 | trWritef( params[0] ); |
||
4385 | break; |
||
4386 | case GL_TEXTURE_BORDER_COLOR: |
||
4387 | trWriteArrayf( 4, params ); |
||
4388 | break; |
||
4389 | default: |
||
4390 | /* The 2nd pass should pick this up. */ |
||
4391 | break; |
||
4392 | } |
||
4393 | } |
||
4394 | |||
4395 | |||
4396 | GLAPI void GLAPIENTRY trGetTexParameteriv( GLenum target, GLenum pname, GLint *params ) { |
||
4397 | trWriteCMD( CMD_GETTEXPARAMETERIV ); |
||
4398 | trWriteEnum( target ); |
||
4399 | trWriteEnum( pname ); |
||
4400 | trWritePointer( (void *)params ); |
||
4401 | trFileFlush(); |
||
4402 | |||
4403 | if( trCtx()->doExec ) { |
||
4404 | trGetDispatch()->GetTexParameteriv( target, pname, params ); |
||
4405 | trError(); |
||
4406 | } else { |
||
4407 | switch( pname ) { |
||
4408 | case GL_TEXTURE_MAG_FILTER: |
||
4409 | case GL_TEXTURE_MIN_FILTER: |
||
4410 | case GL_TEXTURE_MIN_LOD: |
||
4411 | case GL_TEXTURE_MAX_LOD: |
||
4412 | case GL_TEXTURE_BASE_LEVEL: |
||
4413 | case GL_TEXTURE_MAX_LEVEL: |
||
4414 | case GL_TEXTURE_WRAP_S: |
||
4415 | case GL_TEXTURE_WRAP_T: |
||
4416 | case GL_TEXTURE_WRAP_R: |
||
4417 | case GL_TEXTURE_PRIORITY: |
||
4418 | case GL_TEXTURE_RESIDENT: |
||
4419 | params[0] = 0; |
||
4420 | break; |
||
4421 | case GL_TEXTURE_BORDER_COLOR: |
||
4422 | memset( params, 0, 4 * sizeof(GLint) ); |
||
4423 | default: |
||
4424 | /* The 2nd pass should pick this up. */ |
||
4425 | break; |
||
4426 | } |
||
4427 | } |
||
4428 | switch( pname ) { |
||
4429 | case GL_TEXTURE_MAG_FILTER: |
||
4430 | case GL_TEXTURE_MIN_FILTER: |
||
4431 | case GL_TEXTURE_MIN_LOD: |
||
4432 | case GL_TEXTURE_MAX_LOD: |
||
4433 | case GL_TEXTURE_BASE_LEVEL: |
||
4434 | case GL_TEXTURE_MAX_LEVEL: |
||
4435 | case GL_TEXTURE_WRAP_S: |
||
4436 | case GL_TEXTURE_WRAP_T: |
||
4437 | case GL_TEXTURE_WRAP_R: |
||
4438 | case GL_TEXTURE_PRIORITY: |
||
4439 | case GL_TEXTURE_RESIDENT: |
||
4440 | trWritei( params[0] ); |
||
4441 | break; |
||
4442 | case GL_TEXTURE_BORDER_COLOR: |
||
4443 | trWriteArrayi( 4, params ); |
||
4444 | break; |
||
4445 | default: |
||
4446 | /* The 2nd pass should pick this up. */ |
||
4447 | break; |
||
4448 | } |
||
4449 | } |
||
4450 | |||
4451 | |||
4452 | GLAPI void GLAPIENTRY trHint( GLenum target, GLenum mode ) { |
||
4453 | trWriteCMD( CMD_HINT ); |
||
4454 | trWriteEnum( target ); |
||
4455 | trWriteEnum( mode ); |
||
4456 | |||
4457 | if( trCtx()->doExec ) { |
||
4458 | trGetDispatch()->Hint( target, mode ); |
||
4459 | trError(); |
||
4460 | } |
||
4461 | } |
||
4462 | |||
4463 | |||
4464 | GLAPI void GLAPIENTRY trHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) { |
||
4465 | trWriteCMD( CMD_HISTOGRAM ); |
||
4466 | trWriteEnum( target ); |
||
4467 | trWriteSizei( width ); |
||
4468 | trWriteEnum( internalformat ); |
||
4469 | trWriteBool( sink ); |
||
4470 | |||
4471 | if( trCtx()->doExec ) { |
||
4472 | trGetDispatch()->Histogram( target, width, internalformat, sink ); |
||
4473 | trError(); |
||
4474 | } |
||
4475 | } |
||
4476 | |||
4477 | |||
4478 | GLAPI void GLAPIENTRY trIndexd( GLdouble c ) { |
||
4479 | trWriteCMD( CMD_INDEXD ); |
||
4480 | trWrited( c ); |
||
4481 | |||
4482 | if( trCtx()->doExec ) { |
||
4483 | trGetDispatch()->Indexd( c ); |
||
4484 | trError(); |
||
4485 | } |
||
4486 | } |
||
4487 | |||
4488 | |||
4489 | GLAPI void GLAPIENTRY trIndexdv( const GLdouble *c ) { |
||
4490 | trWriteCMD( CMD_INDEXDV ); |
||
4491 | trWritePointer( (void *)c ); |
||
4492 | trFileFlush(); |
||
4493 | trWrited( c[0] ); |
||
4494 | |||
4495 | if( trCtx()->doExec ) { |
||
4496 | trGetDispatch()->Indexdv( c ); |
||
4497 | trError(); |
||
4498 | } |
||
4499 | } |
||
4500 | |||
4501 | |||
4502 | GLAPI void GLAPIENTRY trIndexf( GLfloat c ) { |
||
4503 | trWriteCMD( CMD_INDEXF ); |
||
4504 | trWritef( c ); |
||
4505 | |||
4506 | if( trCtx()->doExec ) { |
||
4507 | trGetDispatch()->Indexf( c ); |
||
4508 | trError(); |
||
4509 | } |
||
4510 | } |
||
4511 | |||
4512 | |||
4513 | GLAPI void GLAPIENTRY trIndexfv( const GLfloat *c ) { |
||
4514 | trWriteCMD( CMD_INDEXFV ); |
||
4515 | trWritePointer( (void *)c ); |
||
4516 | trFileFlush(); |
||
4517 | trWritef( c[0] ); |
||
4518 | |||
4519 | if( trCtx()->doExec ) { |
||
4520 | trGetDispatch()->Indexfv( c ); |
||
4521 | trError(); |
||
4522 | } |
||
4523 | } |
||
4524 | |||
4525 | |||
4526 | GLAPI void GLAPIENTRY trIndexi( GLint c ) { |
||
4527 | trWriteCMD( CMD_INDEXI ); |
||
4528 | trWritei( c ); |
||
4529 | |||
4530 | if( trCtx()->doExec ) { |
||
4531 | trGetDispatch()->Indexi( c ); |
||
4532 | trError(); |
||
4533 | } |
||
4534 | } |
||
4535 | |||
4536 | |||
4537 | GLAPI void GLAPIENTRY trIndexiv( const GLint *c ) { |
||
4538 | trWriteCMD( CMD_INDEXIV ); |
||
4539 | trWritePointer( (void *)c ); |
||
4540 | trFileFlush(); |
||
4541 | trWritei( c[0] ); |
||
4542 | |||
4543 | if( trCtx()->doExec ) { |
||
4544 | trGetDispatch()->Indexiv( c ); |
||
4545 | trError(); |
||
4546 | } |
||
4547 | } |
||
4548 | |||
4549 | |||
4550 | GLAPI void GLAPIENTRY trIndexMask( GLuint mask ) { |
||
4551 | trWriteCMD( CMD_INDEXMASK ); |
||
4552 | trWriteui( mask ); |
||
4553 | |||
4554 | if( trCtx()->doExec ) { |
||
4555 | trGetDispatch()->IndexMask( mask ); |
||
4556 | trError(); |
||
4557 | } |
||
4558 | } |
||
4559 | |||
4560 | |||
4561 | GLAPI void GLAPIENTRY trIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */ |
||
4562 | trWriteCMD( CMD_INDEXPOINTEREXT ); |
||
4563 | trWriteEnum( type ); |
||
4564 | trWriteSizei( stride ); |
||
4565 | trWriteSizei( count ); |
||
4566 | trWritePointer( (void *)ptr ); |
||
4567 | trFileFlush(); |
||
4568 | |||
4569 | if( trCtx()->doExec ) { |
||
4570 | trGetDispatch()->IndexPointerEXT( type, stride, count, ptr ); |
||
4571 | trError(); |
||
4572 | } |
||
4573 | } |
||
4574 | |||
4575 | |||
4576 | GLAPI void GLAPIENTRY trIndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr ) { /* TODO */ |
||
4577 | trace_context_t * tctx; |
||
4578 | |||
4579 | trWriteCMD( CMD_INDEXPOINTER ); |
||
4580 | trWriteEnum( type ); |
||
4581 | trWriteSizei( stride ); |
||
4582 | trWritePointer( (void *)ptr ); |
||
4583 | trFileFlush(); |
||
4584 | |||
4585 | tctx = trCtx(); |
||
4586 | |||
4587 | if( tctx->doExec ) { |
||
4588 | trGetDispatch()->IndexPointer( type, stride, ptr ); |
||
4589 | trError(); |
||
4590 | } |
||
4591 | } |
||
4592 | |||
4593 | |||
4594 | GLAPI void GLAPIENTRY trIndexs( GLshort c ) { |
||
4595 | trWriteCMD( CMD_INDEXS ); |
||
4596 | trWrites( c ); |
||
4597 | |||
4598 | if( trCtx()->doExec ) { |
||
4599 | trGetDispatch()->Indexs( c ); |
||
4600 | trError(); |
||
4601 | } |
||
4602 | } |
||
4603 | |||
4604 | |||
4605 | GLAPI void GLAPIENTRY trIndexsv( const GLshort *c ) { |
||
4606 | trWriteCMD( CMD_INDEXSV ); |
||
4607 | trWritePointer( (void *)c ); |
||
4608 | trFileFlush(); |
||
4609 | trWrites( c[0] ); |
||
4610 | |||
4611 | if( trCtx()->doExec ) { |
||
4612 | trGetDispatch()->Indexsv( c ); |
||
4613 | trError(); |
||
4614 | } |
||
4615 | } |
||
4616 | |||
4617 | |||
4618 | GLAPI void GLAPIENTRY trIndexub( GLubyte c ) { |
||
4619 | trWriteCMD( CMD_INDEXUB ); |
||
4620 | trWriteub( c ); |
||
4621 | |||
4622 | if( trCtx()->doExec ) { |
||
4623 | trGetDispatch()->Indexub( c ); |
||
4624 | trError(); |
||
4625 | } |
||
4626 | } |
||
4627 | |||
4628 | |||
4629 | GLAPI void GLAPIENTRY trIndexubv( const GLubyte *c ) { |
||
4630 | trWriteCMD( CMD_INDEXUBV ); |
||
4631 | trWritePointer( (void *)c ); |
||
4632 | trFileFlush(); |
||
4633 | trWriteub( c[0] ); |
||
4634 | |||
4635 | if( trCtx()->doExec ) { |
||
4636 | trGetDispatch()->Indexubv( c ); |
||
4637 | trError(); |
||
4638 | } |
||
4639 | } |
||
4640 | |||
4641 | |||
4642 | GLAPI void GLAPIENTRY trInitNames( void ) { |
||
4643 | trWriteCMD( CMD_INITNAMES ); |
||
4644 | |||
4645 | if( trCtx()->doExec ) { |
||
4646 | trGetDispatch()->InitNames( ); |
||
4647 | trError(); |
||
4648 | } |
||
4649 | } |
||
4650 | |||
4651 | |||
4652 | GLAPI void GLAPIENTRY trInterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer ) { /* TODO */ |
||
4653 | trace_context_t * tctx = trCtx(); |
||
4654 | |||
4655 | trWriteCMD( CMD_INTERLEAVEDARRAYS ); |
||
4656 | trWriteEnum( format ); |
||
4657 | trWriteSizei( stride ); |
||
4658 | trWritePointer( (void *)pointer ); |
||
4659 | trFileFlush(); |
||
4660 | |||
4661 | if( tctx->doExec ) { |
||
4662 | trSetOriginalDispatch(); |
||
4663 | trGetDispatch()->InterleavedArrays( format, stride, pointer ); |
||
4664 | trSetTraceDispatch(); |
||
4665 | trError(); |
||
4666 | } |
||
4667 | } |
||
4668 | |||
4669 | |||
4670 | GLAPI GLboolean GLAPIENTRY trIsEnabled( GLenum cap ) { |
||
4671 | GLboolean retval; |
||
4672 | |||
4673 | trWriteCMD( CMD_ISENABLED ); |
||
4674 | trWriteEnum( cap ); |
||
4675 | |||
4676 | if( trCtx()->doExec ) { |
||
4677 | retval = trGetDispatch()->IsEnabled( cap ); |
||
4678 | trError(); |
||
4679 | } else { |
||
4680 | retval = GL_FALSE; |
||
4681 | } |
||
4682 | trWriteBool( retval ); |
||
4683 | return retval; |
||
4684 | } |
||
4685 | |||
4686 | |||
4687 | GLAPI GLboolean GLAPIENTRY trIsList( GLuint list ) { |
||
4688 | GLboolean retval; |
||
4689 | |||
4690 | trWriteCMD( CMD_ISLIST ); |
||
4691 | trWriteui( list ); |
||
4692 | |||
4693 | if( trCtx()->doExec ) { |
||
4694 | retval = trGetDispatch()->IsList( list ); |
||
4695 | trError(); |
||
4696 | } else { |
||
4697 | retval = GL_FALSE; |
||
4698 | } |
||
4699 | trWriteBool( retval ); |
||
4700 | return retval; |
||
4701 | } |
||
4702 | |||
4703 | |||
4704 | GLAPI GLboolean GLAPIENTRY trIsTexture( GLuint texture ) { |
||
4705 | GLboolean retval; |
||
4706 | |||
4707 | trWriteCMD( CMD_ISTEXTURE ); |
||
4708 | trWriteui( texture ); |
||
4709 | |||
4710 | if( trCtx()->doExec ) { |
||
4711 | retval = trGetDispatch()->IsTexture( texture ); |
||
4712 | trError(); |
||
4713 | } else { |
||
4714 | retval = GL_FALSE; |
||
4715 | } |
||
4716 | trWriteBool( retval ); |
||
4717 | return retval; |
||
4718 | } |
||
4719 | |||
4720 | |||
4721 | GLAPI GLboolean GLAPIENTRY trIsTextureEXT( GLuint texture ) { |
||
4722 | GLboolean retval; |
||
4723 | |||
4724 | trWriteCMD( CMD_ISTEXTUREEXT ); |
||
4725 | trWriteui( texture ); |
||
4726 | |||
4727 | if( trCtx()->doExec ) { |
||
4728 | retval = trGetDispatch()->IsTextureEXT( texture ); |
||
4729 | trError(); |
||
4730 | } else { |
||
4731 | retval = GL_FALSE; |
||
4732 | } |
||
4733 | trWriteBool( retval ); |
||
4734 | return retval; |
||
4735 | } |
||
4736 | |||
4737 | |||
4738 | GLAPI void GLAPIENTRY trLightf( GLenum light, GLenum pname, GLfloat param ) { |
||
4739 | trWriteCMD( CMD_LIGHTF ); |
||
4740 | trWriteEnum( light ); |
||
4741 | trWriteEnum( pname ); |
||
4742 | trWritef( param ); |
||
4743 | |||
4744 | if( trCtx()->doExec ) { |
||
4745 | trGetDispatch()->Lightf( light, pname, param ); |
||
4746 | trError(); |
||
4747 | } |
||
4748 | } |
||
4749 | |||
4750 | |||
4751 | GLAPI void GLAPIENTRY trLightfv( GLenum light, GLenum pname, const GLfloat *params ) { |
||
4752 | trWriteCMD( CMD_LIGHTFV ); |
||
4753 | trWriteEnum( light ); |
||
4754 | trWriteEnum( pname ); |
||
4755 | trWritePointer( (void *)params ); |
||
4756 | trFileFlush(); |
||
4757 | |||
4758 | switch( pname ) { |
||
4759 | case GL_AMBIENT: |
||
4760 | case GL_DIFFUSE: |
||
4761 | case GL_SPECULAR: |
||
4762 | case GL_POSITION: |
||
4763 | trWriteArrayf( 4, params ); |
||
4764 | break; |
||
4765 | case GL_SPOT_DIRECTION: |
||
4766 | trWriteArrayf( 3, params ); |
||
4767 | break; |
||
4768 | case GL_SPOT_EXPONENT: |
||
4769 | case GL_SPOT_CUTOFF: |
||
4770 | case GL_CONSTANT_ATTENUATION: |
||
4771 | case GL_LINEAR_ATTENUATION: |
||
4772 | case GL_QUADRATIC_ATTENUATION: |
||
4773 | trWritef( params[0] ); |
||
4774 | break; |
||
4775 | default: |
||
4776 | /* The 2nd pass should pick this up. */ |
||
4777 | break; |
||
4778 | } |
||
4779 | |||
4780 | if( trCtx()->doExec ) { |
||
4781 | trGetDispatch()->Lightfv( light, pname, params ); |
||
4782 | trError(); |
||
4783 | } |
||
4784 | } |
||
4785 | |||
4786 | |||
4787 | GLAPI void GLAPIENTRY trLighti( GLenum light, GLenum pname, GLint param ) { |
||
4788 | trWriteCMD( CMD_LIGHTI ); |
||
4789 | trWriteEnum( light ); |
||
4790 | trWriteEnum( pname ); |
||
4791 | trWritei( param ); |
||
4792 | |||
4793 | if( trCtx()->doExec ) { |
||
4794 | trGetDispatch()->Lighti( light, pname, param ); |
||
4795 | trError(); |
||
4796 | } |
||
4797 | } |
||
4798 | |||
4799 | |||
4800 | GLAPI void GLAPIENTRY trLightiv( GLenum light, GLenum pname, const GLint *params ) { |
||
4801 | trWriteCMD( CMD_LIGHTIV ); |
||
4802 | trWriteEnum( light ); |
||
4803 | trWriteEnum( pname ); |
||
4804 | trWritePointer( (void *)params ); |
||
4805 | trFileFlush(); |
||
4806 | |||
4807 | switch( pname ) { |
||
4808 | case GL_AMBIENT: |
||
4809 | case GL_DIFFUSE: |
||
4810 | case GL_SPECULAR: |
||
4811 | case GL_POSITION: |
||
4812 | trWriteArrayi( 4, params ); |
||
4813 | break; |
||
4814 | case GL_SPOT_DIRECTION: |
||
4815 | trWriteArrayi( 3, params ); |
||
4816 | break; |
||
4817 | case GL_SPOT_EXPONENT: |
||
4818 | case GL_SPOT_CUTOFF: |
||
4819 | case GL_CONSTANT_ATTENUATION: |
||
4820 | case GL_LINEAR_ATTENUATION: |
||
4821 | case GL_QUADRATIC_ATTENUATION: |
||
4822 | trWritei( params[0] ); |
||
4823 | break; |
||
4824 | default: |
||
4825 | /* The 2nd pass should pick this up. */ |
||
4826 | break; |
||
4827 | } |
||
4828 | |||
4829 | if( trCtx()->doExec ) { |
||
4830 | trGetDispatch()->Lightiv( light, pname, params ); |
||
4831 | trError(); |
||
4832 | } |
||
4833 | } |
||
4834 | |||
4835 | |||
4836 | GLAPI void GLAPIENTRY trLightModelf( GLenum pname, GLfloat param ) { |
||
4837 | trWriteCMD( CMD_LIGHTMODELF ); |
||
4838 | trWriteEnum( pname ); |
||
4839 | trWritef( param ); |
||
4840 | |||
4841 | if( trCtx()->doExec ) { |
||
4842 | trGetDispatch()->LightModelf( pname, param ); |
||
4843 | trError(); |
||
4844 | } |
||
4845 | } |
||
4846 | |||
4847 | |||
4848 | GLAPI void GLAPIENTRY trLightModelfv( GLenum pname, const GLfloat *params ) { |
||
4849 | trWriteCMD( CMD_LIGHTMODELFV ); |
||
4850 | trWriteEnum( pname ); |
||
4851 | trWritePointer( (void *)params ); |
||
4852 | trFileFlush(); |
||
4853 | |||
4854 | switch( pname ) { |
||
4855 | case GL_LIGHT_MODEL_AMBIENT: |
||
4856 | trWriteArrayf( 4, params ); |
||
4857 | break; |
||
4858 | case GL_LIGHT_MODEL_COLOR_CONTROL: |
||
4859 | case GL_LIGHT_MODEL_LOCAL_VIEWER: |
||
4860 | case GL_LIGHT_MODEL_TWO_SIDE: |
||
4861 | trWritef( params[0] ); |
||
4862 | break; |
||
4863 | default: |
||
4864 | /* The 2nd pass should catch this. */ |
||
4865 | break; |
||
4866 | } |
||
4867 | |||
4868 | if( trCtx()->doExec ) { |
||
4869 | trGetDispatch()->LightModelfv( pname, params ); |
||
4870 | trError(); |
||
4871 | } |
||
4872 | } |
||
4873 | |||
4874 | |||
4875 | GLAPI void GLAPIENTRY trLightModeli( GLenum pname, GLint param ) { |
||
4876 | trWriteCMD( CMD_LIGHTMODELI ); |
||
4877 | trWriteEnum( pname ); |
||
4878 | trWritei( param ); |
||
4879 | |||
4880 | if( trCtx()->doExec ) { |
||
4881 | trGetDispatch()->LightModeli( pname, param ); |
||
4882 | trError(); |
||
4883 | } |
||
4884 | } |
||
4885 | |||
4886 | |||
4887 | GLAPI void GLAPIENTRY trLightModeliv( GLenum pname, const GLint *params ) { |
||
4888 | trWriteCMD( CMD_LIGHTMODELIV ); |
||
4889 | trWriteEnum( pname ); |
||
4890 | trWritePointer( (void *)params ); |
||
4891 | trFileFlush(); |
||
4892 | |||
4893 | switch( pname ) { |
||
4894 | case GL_LIGHT_MODEL_AMBIENT: |
||
4895 | trWriteArrayi( 4, params ); |
||
4896 | break; |
||
4897 | case GL_LIGHT_MODEL_COLOR_CONTROL: |
||
4898 | case GL_LIGHT_MODEL_LOCAL_VIEWER: |
||
4899 | case GL_LIGHT_MODEL_TWO_SIDE: |
||
4900 | trWritei( params[0] ); |
||
4901 | break; |
||
4902 | default: |
||
4903 | /* The 2nd pass should catch this. */ |
||
4904 | break; |
||
4905 | } |
||
4906 | |||
4907 | if( trCtx()->doExec ) { |
||
4908 | trGetDispatch()->LightModeliv( pname, params ); |
||
4909 | trError(); |
||
4910 | } |
||
4911 | } |
||
4912 | |||
4913 | |||
4914 | GLAPI void GLAPIENTRY trLineStipple( GLint factor, GLushort pattern ) { |
||
4915 | trWriteCMD( CMD_LINESTIPPLE ); |
||
4916 | trWritei( factor ); |
||
4917 | trWriteus( pattern ); |
||
4918 | |||
4919 | if( trCtx()->doExec ) { |
||
4920 | trGetDispatch()->LineStipple( factor, pattern ); |
||
4921 | trError(); |
||
4922 | } |
||
4923 | } |
||
4924 | |||
4925 | |||
4926 | GLAPI void GLAPIENTRY trLineWidth( GLfloat width ) { |
||
4927 | trWriteCMD( CMD_LINEWIDTH ); |
||
4928 | trWritef( width ); |
||
4929 | |||
4930 | if( trCtx()->doExec ) { |
||
4931 | trGetDispatch()->LineWidth( width ); |
||
4932 | trError(); |
||
4933 | } |
||
4934 | } |
||
4935 | |||
4936 | |||
4937 | GLAPI void GLAPIENTRY trListBase( GLuint base ) { |
||
4938 | trWriteCMD( CMD_LISTBASE ); |
||
4939 | trWriteui( base ); |
||
4940 | |||
4941 | if( trCtx()->doExec ) { |
||
4942 | trGetDispatch()->ListBase( base ); |
||
4943 | trError(); |
||
4944 | } |
||
4945 | } |
||
4946 | |||
4947 | |||
4948 | GLAPI void GLAPIENTRY trLoadIdentity( void ) { |
||
4949 | trWriteCMD( CMD_LOADIDENTITY ); |
||
4950 | |||
4951 | if( trCtx()->doExec ) { |
||
4952 | trGetDispatch()->LoadIdentity( ); |
||
4953 | trError(); |
||
4954 | } |
||
4955 | } |
||
4956 | |||
4957 | |||
4958 | GLAPI void GLAPIENTRY trLoadMatrixd( const GLdouble *m ) { |
||
4959 | trWriteCMD( CMD_LOADMATRIXD ); |
||
4960 | trWritePointer( (void *)m ); |
||
4961 | trFileFlush(); |
||
4962 | trWriteArrayd( 16, m ); |
||
4963 | |||
4964 | if( trCtx()->doExec ) { |
||
4965 | trGetDispatch()->LoadMatrixd( m ); |
||
4966 | trError(); |
||
4967 | } |
||
4968 | } |
||
4969 | |||
4970 | |||
4971 | GLAPI void GLAPIENTRY trLoadMatrixf( const GLfloat *m ) { |
||
4972 | trWriteCMD( CMD_LOADMATRIXF ); |
||
4973 | trWritePointer( (void *)m ); |
||
4974 | trFileFlush(); |
||
4975 | trWriteArrayf( 16, m ); |
||
4976 | |||
4977 | if( trCtx()->doExec ) { |
||
4978 | trGetDispatch()->LoadMatrixf( m ); |
||
4979 | trError(); |
||
4980 | } |
||
4981 | } |
||
4982 | |||
4983 | |||
4984 | GLAPI void GLAPIENTRY trLoadName( GLuint name ) { |
||
4985 | trWriteCMD( CMD_LOADNAME ); |
||
4986 | trWriteui( name ); |
||
4987 | |||
4988 | if( trCtx()->doExec ) { |
||
4989 | trGetDispatch()->LoadName( name ); |
||
4990 | trError(); |
||
4991 | } |
||
4992 | } |
||
4993 | |||
4994 | |||
4995 | GLAPI void GLAPIENTRY trLockArraysEXT( GLint first, GLsizei count ) { |
||
4996 | trWriteCMD( CMD_LOCKARRAYSEXT ); |
||
4997 | trWritei( first ); |
||
4998 | trWriteSizei( count ); |
||
4999 | |||
5000 | if( trCtx()->doExec ) { |
||
5001 | trGetDispatch()->LockArraysEXT( first, count ); |
||
5002 | trError(); |
||
5003 | } |
||
5004 | } |
||
5005 | |||
5006 | |||
5007 | GLAPI void GLAPIENTRY trLogicOp( GLenum opcode ) { |
||
5008 | trWriteCMD( CMD_LOGICOP ); |
||
5009 | trWriteEnum( opcode ); |
||
5010 | |||
5011 | if( trCtx()->doExec ) { |
||
5012 | trGetDispatch()->LogicOp( opcode ); |
||
5013 | trError(); |
||
5014 | } |
||
5015 | } |
||
5016 | |||
5017 | |||
5018 | GLAPI void GLAPIENTRY trMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points ) { |
||
5019 | GLint i; |
||
5020 | |||
5021 | trWriteCMD( CMD_MAP1D ); |
||
5022 | trWriteEnum( target ); |
||
5023 | trWrited( u1 ); |
||
5024 | trWrited( u2 ); |
||
5025 | trWritei( stride ); |
||
5026 | trWritei( order ); |
||
5027 | trWritePointer( (void *)points ); |
||
5028 | trFileFlush(); |
||
5029 | |||
5030 | switch( target ) { |
||
5031 | case GL_MAP1_INDEX: |
||
5032 | case GL_MAP1_TEXTURE_COORD_1: |
||
5033 | for( i = 0; i < stride * order; i += stride ) { |
||
5034 | trWrited( points[i] ); |
||
5035 | } |
||
5036 | break; |
||
5037 | case GL_MAP1_TEXTURE_COORD_2: |
||
5038 | for( i = 0; i < stride * order; i += stride ) { |
||
5039 | trWrited( points[i] ); |
||
5040 | trWrited( points[i + 1] ); |
||
5041 | } |
||
5042 | break; |
||
5043 | case GL_MAP1_VERTEX_3: |
||
5044 | case GL_MAP1_NORMAL: |
||
5045 | case GL_MAP1_TEXTURE_COORD_3: |
||
5046 | for( i = 0; i < stride * order; i += stride ) { |
||
5047 | trWrited( points[i] ); |
||
5048 | trWrited( points[i + 1] ); |
||
5049 | trWrited( points[i + 2] ); |
||
5050 | } |
||
5051 | break; |
||
5052 | case GL_MAP1_VERTEX_4: |
||
5053 | case GL_MAP1_TEXTURE_COORD_4: |
||
5054 | for( i = 0; i < stride * order; i += stride ) { |
||
5055 | trWrited( points[i] ); |
||
5056 | trWrited( points[i + 1] ); |
||
5057 | trWrited( points[i + 2] ); |
||
5058 | trWrited( points[i + 3] ); |
||
5059 | } |
||
5060 | break; |
||
5061 | default: |
||
5062 | /* The 2nd pass should catch this. */ |
||
5063 | break; |
||
5064 | } |
||
5065 | |||
5066 | if( trCtx()->doExec ) { |
||
5067 | trGetDispatch()->Map1d( target, u1, u2, stride, order, points ); |
||
5068 | trError(); |
||
5069 | } |
||
5070 | } |
||
5071 | |||
5072 | |||
5073 | GLAPI void GLAPIENTRY trMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points ) { |
||
5074 | GLint i; |
||
5075 | |||
5076 | trWriteCMD( CMD_MAP1F ); |
||
5077 | trWriteEnum( target ); |
||
5078 | trWritef( u1 ); |
||
5079 | trWritef( u2 ); |
||
5080 | trWritei( stride ); |
||
5081 | trWritei( order ); |
||
5082 | trWritePointer( (void *)points ); |
||
5083 | trFileFlush(); |
||
5084 | |||
5085 | switch( target ) { |
||
5086 | case GL_MAP1_INDEX: |
||
5087 | case GL_MAP1_TEXTURE_COORD_1: |
||
5088 | for( i = 0; i < stride * order; i += stride ) { |
||
5089 | trWritef( points[i] ); |
||
5090 | } |
||
5091 | break; |
||
5092 | case GL_MAP1_TEXTURE_COORD_2: |
||
5093 | for( i = 0; i < stride * order; i += stride ) { |
||
5094 | trWritef( points[i] ); |
||
5095 | trWritef( points[i + 1] ); |
||
5096 | } |
||
5097 | break; |
||
5098 | case GL_MAP1_VERTEX_3: |
||
5099 | case GL_MAP1_NORMAL: |
||
5100 | case GL_MAP1_TEXTURE_COORD_3: |
||
5101 | for( i = 0; i < stride * order; i += stride ) { |
||
5102 | trWritef( points[i] ); |
||
5103 | trWritef( points[i + 1] ); |
||
5104 | trWritef( points[i + 2] ); |
||
5105 | } |
||
5106 | break; |
||
5107 | case GL_MAP1_VERTEX_4: |
||
5108 | case GL_MAP1_TEXTURE_COORD_4: |
||
5109 | for( i = 0; i < stride * order; i += stride ) { |
||
5110 | trWritef( points[i] ); |
||
5111 | trWritef( points[i + 1] ); |
||
5112 | trWritef( points[i + 2] ); |
||
5113 | trWritef( points[i + 3] ); |
||
5114 | } |
||
5115 | break; |
||
5116 | default: |
||
5117 | /* The 2nd pass should catch this. */ |
||
5118 | break; |
||
5119 | } |
||
5120 | |||
5121 | if( trCtx()->doExec ) { |
||
5122 | trGetDispatch()->Map1f( target, u1, u2, stride, order, points ); |
||
5123 | trError(); |
||
5124 | } |
||
5125 | } |
||
5126 | |||
5127 | |||
5128 | GLAPI void GLAPIENTRY trMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points ) { |
||
5129 | GLint i; |
||
5130 | GLint j; |
||
5131 | |||
5132 | trWriteCMD( CMD_MAP2D ); |
||
5133 | trWriteEnum( target ); |
||
5134 | trWrited( u1 ); |
||
5135 | trWrited( u2 ); |
||
5136 | trWritei( ustride ); |
||
5137 | trWritei( uorder ); |
||
5138 | trWrited( v1 ); |
||
5139 | trWrited( v2 ); |
||
5140 | trWritei( vstride ); |
||
5141 | trWritei( vorder ); |
||
5142 | trWritePointer( (void *)points ); |
||
5143 | trFileFlush(); |
||
5144 | |||
5145 | switch( target ) { |
||
5146 | case GL_MAP1_INDEX: |
||
5147 | case GL_MAP1_TEXTURE_COORD_1: |
||
5148 | for( j = 0; j < vstride * vorder; j += vstride ) { |
||
5149 | for( i = 0; i < ustride * uorder; i += ustride ) { |
||
5150 | trWrited( points[i + j] ); |
||
5151 | } |
||
5152 | } |
||
5153 | break; |
||
5154 | case GL_MAP1_TEXTURE_COORD_2: |
||
5155 | for( j = 0; j < vstride * vorder; j += vstride ) { |
||
5156 | for( i = 0; i < ustride * uorder; i += ustride ) { |
||
5157 | trWrited( points[i + j] ); |
||
5158 | trWrited( points[i + j + 1] ); |
||
5159 | } |
||
5160 | } |
||
5161 | break; |
||
5162 | case GL_MAP1_VERTEX_3: |
||
5163 | case GL_MAP1_NORMAL: |
||
5164 | case GL_MAP1_TEXTURE_COORD_3: |
||
5165 | for( j = 0; j < vstride * vorder; j += vstride ) { |
||
5166 | for( i = 0; i < ustride * uorder; i += ustride ) { |
||
5167 | trWrited( points[i + j] ); |
||
5168 | trWrited( points[i + j + 1] ); |
||
5169 | trWrited( points[i + j + 2] ); |
||
5170 | } |
||
5171 | } |
||
5172 | break; |
||
5173 | case GL_MAP1_VERTEX_4: |
||
5174 | case GL_MAP1_TEXTURE_COORD_4: |
||
5175 | for( j = 0; j < vstride * vorder; j += vstride ) { |
||
5176 | for( i = 0; i < ustride * uorder; i += ustride ) { |
||
5177 | trWrited( points[i + j] ); |
||
5178 | trWrited( points[i + j + 1] ); |
||
5179 | trWrited( points[i + j + 2] ); |
||
5180 | trWrited( points[i + j + 3] ); |
||
5181 | } |
||
5182 | } |
||
5183 | break; |
||
5184 | default: |
||
5185 | /* The 2nd pass should catch this. */ |
||
5186 | break; |
||
5187 | } |
||
5188 | |||
5189 | if( trCtx()->doExec ) { |
||
5190 | trGetDispatch()->Map2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); |
||
5191 | trError(); |
||
5192 | } |
||
5193 | } |
||
5194 | |||
5195 | |||
5196 | GLAPI void GLAPIENTRY trMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points ) { |
||
5197 | GLint i; |
||
5198 | GLint j; |
||
5199 | |||
5200 | trWriteCMD( CMD_MAP2F ); |
||
5201 | trWriteEnum( target ); |
||
5202 | trWritef( u1 ); |
||
5203 | trWritef( u2 ); |
||
5204 | trWritei( ustride ); |
||
5205 | trWritei( uorder ); |
||
5206 | trWritef( v1 ); |
||
5207 | trWritef( v2 ); |
||
5208 | trWritei( vstride ); |
||
5209 | trWritei( vorder ); |
||
5210 | trWritePointer( (void *)points ); |
||
5211 | trFileFlush(); |
||
5212 | |||
5213 | switch( target ) { |
||
5214 | case GL_MAP1_INDEX: |
||
5215 | case GL_MAP1_TEXTURE_COORD_1: |
||
5216 | for( j = 0; j < vstride * vorder; j += vstride ) { |
||
5217 | for( i = 0; i < ustride * uorder; i += ustride ) { |
||
5218 | trWritef( points[i + j] ); |
||
5219 | } |
||
5220 | } |
||
5221 | break; |
||
5222 | case GL_MAP1_TEXTURE_COORD_2: |
||
5223 | for( j = 0; j < vstride * vorder; j += vstride ) { |
||
5224 | for( i = 0; i < ustride * uorder; i += ustride ) { |
||
5225 | trWritef( points[i + j] ); |
||
5226 | trWritef( points[i + j + 1] ); |
||
5227 | } |
||
5228 | } |
||
5229 | break; |
||
5230 | case GL_MAP1_VERTEX_3: |
||
5231 | case GL_MAP1_NORMAL: |
||
5232 | case GL_MAP1_TEXTURE_COORD_3: |
||
5233 | for( j = 0; j < vstride * vorder; j += vstride ) { |
||
5234 | for( i = 0; i < ustride * uorder; i += ustride ) { |
||
5235 | trWritef( points[i + j] ); |
||
5236 | trWritef( points[i + j + 1] ); |
||
5237 | trWritef( points[i + j + 2] ); |
||
5238 | } |
||
5239 | } |
||
5240 | break; |
||
5241 | case GL_MAP1_VERTEX_4: |
||
5242 | case GL_MAP1_TEXTURE_COORD_4: |
||
5243 | for( j = 0; j < vstride * vorder; j += vstride ) { |
||
5244 | for( i = 0; i < ustride * uorder; i += ustride ) { |
||
5245 | trWritef( points[i + j] ); |
||
5246 | trWritef( points[i + j + 1] ); |
||
5247 | trWritef( points[i + j + 2] ); |
||
5248 | trWritef( points[i + j + 3] ); |
||
5249 | } |
||
5250 | } |
||
5251 | break; |
||
5252 | default: |
||
5253 | /* The 2nd pass should catch this. */ |
||
5254 | break; |
||
5255 | } |
||
5256 | |||
5257 | if( trCtx()->doExec ) { |
||
5258 | trGetDispatch()->Map2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); |
||
5259 | trError(); |
||
5260 | } |
||
5261 | } |
||
5262 | |||
5263 | |||
5264 | GLAPI void GLAPIENTRY trMapGrid1d( GLint un, GLdouble u1, GLdouble u2 ) { |
||
5265 | trWriteCMD( CMD_MAPGRID1D ); |
||
5266 | trWritei( un ); |
||
5267 | trWrited( u1 ); |
||
5268 | trWrited( u2 ); |
||
5269 | |||
5270 | if( trCtx()->doExec ) { |
||
5271 | trGetDispatch()->MapGrid1d( un, u1, u2 ); |
||
5272 | trError(); |
||
5273 | } |
||
5274 | } |
||
5275 | |||
5276 | |||
5277 | GLAPI void GLAPIENTRY trMapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) { |
||
5278 | trWriteCMD( CMD_MAPGRID1F ); |
||
5279 | trWritei( un ); |
||
5280 | trWritef( u1 ); |
||
5281 | trWritef( u2 ); |
||
5282 | |||
5283 | if( trCtx()->doExec ) { |
||
5284 | trGetDispatch()->MapGrid1f( un, u1, u2 ); |
||
5285 | trError(); |
||
5286 | } |
||
5287 | } |
||
5288 | |||
5289 | |||
5290 | GLAPI void GLAPIENTRY trMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) { |
||
5291 | trWriteCMD( CMD_MAPGRID2D ); |
||
5292 | trWritei( un ); |
||
5293 | trWrited( u1 ); |
||
5294 | trWrited( u2 ); |
||
5295 | trWritei( vn ); |
||
5296 | trWrited( v1 ); |
||
5297 | trWrited( v2 ); |
||
5298 | |||
5299 | if( trCtx()->doExec ) { |
||
5300 | trGetDispatch()->MapGrid2d( un, u1, u2, vn, v1, v2 ); |
||
5301 | trError(); |
||
5302 | } |
||
5303 | } |
||
5304 | |||
5305 | |||
5306 | GLAPI void GLAPIENTRY trMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) { |
||
5307 | trWriteCMD( CMD_MAPGRID2F ); |
||
5308 | trWritei( un ); |
||
5309 | trWritef( u1 ); |
||
5310 | trWritef( u2 ); |
||
5311 | trWritei( vn ); |
||
5312 | trWritef( v1 ); |
||
5313 | trWritef( v2 ); |
||
5314 | |||
5315 | if( trCtx()->doExec ) { |
||
5316 | trGetDispatch()->MapGrid2f( un, u1, u2, vn, v1, v2 ); |
||
5317 | trError(); |
||
5318 | } |
||
5319 | } |
||
5320 | |||
5321 | |||
5322 | GLAPI void GLAPIENTRY trMaterialf( GLenum face, GLenum pname, GLfloat param ) { |
||
5323 | trWriteCMD( CMD_MATERIALF ); |
||
5324 | trWriteEnum( face ); |
||
5325 | trWriteEnum( pname ); |
||
5326 | trWritef( param ); |
||
5327 | |||
5328 | if( trCtx()->doExec ) { |
||
5329 | trGetDispatch()->Materialf( face, pname, param ); |
||
5330 | trError(); |
||
5331 | } |
||
5332 | } |
||
5333 | |||
5334 | |||
5335 | GLAPI void GLAPIENTRY trMaterialfv( GLenum face, GLenum pname, const GLfloat *params ) { |
||
5336 | trWriteCMD( CMD_MATERIALFV ); |
||
5337 | trWriteEnum( face ); |
||
5338 | trWriteEnum( pname ); |
||
5339 | trWritePointer( (void *)params ); |
||
5340 | trFileFlush(); |
||
5341 | |||
5342 | switch( pname ) { |
||
5343 | case GL_AMBIENT: |
||
5344 | case GL_DIFFUSE: |
||
5345 | case GL_AMBIENT_AND_DIFFUSE: |
||
5346 | case GL_SPECULAR: |
||
5347 | case GL_EMISSION: |
||
5348 | trWriteArrayf( 4, params ); |
||
5349 | break; |
||
5350 | case GL_SHININESS: |
||
5351 | trWritef( params[0] ); |
||
5352 | break; |
||
5353 | case GL_COLOR_INDEXES: |
||
5354 | trWriteArrayf( 3, params ); |
||
5355 | break; |
||
5356 | default: |
||
5357 | /* The 2nd pass should catch this. */ |
||
5358 | break; |
||
5359 | } |
||
5360 | |||
5361 | if( trCtx()->doExec ) { |
||
5362 | trGetDispatch()->Materialfv( face, pname, params ); |
||
5363 | trError(); |
||
5364 | } |
||
5365 | } |
||
5366 | |||
5367 | |||
5368 | GLAPI void GLAPIENTRY trMateriali( GLenum face, GLenum pname, GLint param ) { |
||
5369 | trWriteCMD( CMD_MATERIALI ); |
||
5370 | trWriteEnum( face ); |
||
5371 | trWriteEnum( pname ); |
||
5372 | trWritei( param ); |
||
5373 | |||
5374 | if( trCtx()->doExec ) { |
||
5375 | trGetDispatch()->Materiali( face, pname, param ); |
||
5376 | trError(); |
||
5377 | } |
||
5378 | } |
||
5379 | |||
5380 | |||
5381 | GLAPI void GLAPIENTRY trMaterialiv( GLenum face, GLenum pname, const GLint *params ) { |
||
5382 | trWriteCMD( CMD_MATERIALIV ); |
||
5383 | trWriteEnum( face ); |
||
5384 | trWriteEnum( pname ); |
||
5385 | trWritePointer( (void *)params ); |
||
5386 | trFileFlush(); |
||
5387 | |||
5388 | switch( pname ) { |
||
5389 | case GL_AMBIENT: |
||
5390 | case GL_DIFFUSE: |
||
5391 | case GL_AMBIENT_AND_DIFFUSE: |
||
5392 | case GL_SPECULAR: |
||
5393 | case GL_EMISSION: |
||
5394 | trWriteArrayi( 4, params ); |
||
5395 | break; |
||
5396 | case GL_SHININESS: |
||
5397 | trWritei( params[0] ); |
||
5398 | break; |
||
5399 | case GL_COLOR_INDEXES: |
||
5400 | trWriteArrayi( 3, params ); |
||
5401 | break; |
||
5402 | default: |
||
5403 | /* The 2nd pass should catch this. */ |
||
5404 | break; |
||
5405 | } |
||
5406 | |||
5407 | if( trCtx()->doExec ) { |
||
5408 | trGetDispatch()->Materialiv( face, pname, params ); |
||
5409 | trError(); |
||
5410 | } |
||
5411 | } |
||
5412 | |||
5413 | |||
5414 | GLAPI void GLAPIENTRY trMatrixMode( GLenum mode ) { |
||
5415 | trWriteCMD( CMD_MATRIXMODE ); |
||
5416 | trWriteEnum( mode ); |
||
5417 | |||
5418 | if( trCtx()->doExec ) { |
||
5419 | trGetDispatch()->MatrixMode( mode ); |
||
5420 | trError(); |
||
5421 | } |
||
5422 | } |
||
5423 | |||
5424 | |||
5425 | GLAPI void GLAPIENTRY trMinmax( GLenum target, GLenum internalformat, GLboolean sink ) { |
||
5426 | trWriteCMD( CMD_MINMAX ); |
||
5427 | trWriteEnum( target ); |
||
5428 | trWriteEnum( internalformat ); |
||
5429 | trWriteBool( sink ); |
||
5430 | |||
5431 | if( trCtx()->doExec ) { |
||
5432 | trGetDispatch()->Minmax( target, internalformat, sink ); |
||
5433 | trError(); |
||
5434 | } |
||
5435 | } |
||
5436 | |||
5437 | |||
5438 | GLAPI void GLAPIENTRY trMultiTexCoord1dARB( GLenum target, GLdouble s) { |
||
5439 | trWriteCMD( CMD_MULTITEXCOORD1DARB ); |
||
5440 | trWriteEnum( target ); |
||
5441 | trWrited( s ); |
||
5442 | |||
5443 | if( trCtx()->doExec ) { |
||
5444 | trGetDispatch()->MultiTexCoord1dARB( target, s ); |
||
5445 | trError(); |
||
5446 | } |
||
5447 | } |
||
5448 | |||
5449 | |||
5450 | GLAPI void GLAPIENTRY trMultiTexCoord1dvARB( GLenum target, const GLdouble *v) { |
||
5451 | trWriteCMD( CMD_MULTITEXCOORD1DVARB ); |
||
5452 | trWriteEnum( target ); |
||
5453 | trWritePointer( (void *)v ); |
||
5454 | trFileFlush(); |
||
5455 | trWrited( v[0] ); |
||
5456 | |||
5457 | if( trCtx()->doExec ) { |
||
5458 | trGetDispatch()->MultiTexCoord1dvARB( target, v ); |
||
5459 | trError(); |
||
5460 | } |
||
5461 | } |
||
5462 | |||
5463 | |||
5464 | GLAPI void GLAPIENTRY trMultiTexCoord1fARB( GLenum target, GLfloat s) { |
||
5465 | trWriteCMD( CMD_MULTITEXCOORD1FARB ); |
||
5466 | trWriteEnum( target ); |
||
5467 | trWritef( s ); |
||
5468 | |||
5469 | if( trCtx()->doExec ) { |
||
5470 | trGetDispatch()->MultiTexCoord1fARB( target, s ); |
||
5471 | trError(); |
||
5472 | } |
||
5473 | } |
||
5474 | |||
5475 | |||
5476 | GLAPI void GLAPIENTRY trMultiTexCoord1fvARB( GLenum target, const GLfloat *v) { |
||
5477 | trWriteCMD( CMD_MULTITEXCOORD1FVARB ); |
||
5478 | trWriteEnum( target ); |
||
5479 | trWritePointer( (void *)v ); |
||
5480 | trFileFlush(); |
||
5481 | trWritef( v[0] ); |
||
5482 | |||
5483 | if( trCtx()->doExec ) { |
||
5484 | trGetDispatch()->MultiTexCoord1fvARB( target, v ); |
||
5485 | trError(); |
||
5486 | } |
||
5487 | } |
||
5488 | |||
5489 | |||
5490 | GLAPI void GLAPIENTRY trMultiTexCoord1iARB( GLenum target, GLint s) { |
||
5491 | trWriteCMD( CMD_MULTITEXCOORD1IARB ); |
||
5492 | trWriteEnum( target ); |
||
5493 | trWritei( s ); |
||
5494 | |||
5495 | if( trCtx()->doExec ) { |
||
5496 | trGetDispatch()->MultiTexCoord1iARB( target, s ); |
||
5497 | trError(); |
||
5498 | } |
||
5499 | } |
||
5500 | |||
5501 | |||
5502 | GLAPI void GLAPIENTRY trMultiTexCoord1ivARB( GLenum target, const GLint *v) { |
||
5503 | trWriteCMD( CMD_MULTITEXCOORD1IVARB ); |
||
5504 | trWriteEnum( target ); |
||
5505 | trWritePointer( (void *)v ); |
||
5506 | trFileFlush(); |
||
5507 | trWritei( v[0] ); |
||
5508 | |||
5509 | if( trCtx()->doExec ) { |
||
5510 | trGetDispatch()->MultiTexCoord1ivARB( target, v ); |
||
5511 | trError(); |
||
5512 | } |
||
5513 | } |
||
5514 | |||
5515 | |||
5516 | GLAPI void GLAPIENTRY trMultiTexCoord1sARB( GLenum target, GLshort s) { |
||
5517 | trWriteCMD( CMD_MULTITEXCOORD1SARB ); |
||
5518 | trWriteEnum( target ); |
||
5519 | trWrites( s ); |
||
5520 | |||
5521 | if( trCtx()->doExec ) { |
||
5522 | trGetDispatch()->MultiTexCoord1sARB( target, s ); |
||
5523 | trError(); |
||
5524 | } |
||
5525 | } |
||
5526 | |||
5527 | |||
5528 | GLAPI void GLAPIENTRY trMultiTexCoord1svARB( GLenum target, const GLshort *v) { |
||
5529 | trWriteCMD( CMD_MULTITEXCOORD1SVARB ); |
||
5530 | trWriteEnum( target ); |
||
5531 | trWritePointer( (void *)v ); |
||
5532 | trFileFlush(); |
||
5533 | trWrites( v[0] ); |
||
5534 | |||
5535 | if( trCtx()->doExec ) { |
||
5536 | trGetDispatch()->MultiTexCoord1svARB( target, v ); |
||
5537 | trError(); |
||
5538 | } |
||
5539 | } |
||
5540 | |||
5541 | |||
5542 | GLAPI void GLAPIENTRY trMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t) { |
||
5543 | trWriteCMD( CMD_MULTITEXCOORD2DARB ); |
||
5544 | trWriteEnum( target ); |
||
5545 | trWrited( s ); |
||
5546 | trWrited( t ); |
||
5547 | |||
5548 | if( trCtx()->doExec ) { |
||
5549 | trGetDispatch()->MultiTexCoord2dARB( target, s, t ); |
||
5550 | trError(); |
||
5551 | } |
||
5552 | } |
||
5553 | |||
5554 | |||
5555 | GLAPI void GLAPIENTRY trMultiTexCoord2dvARB( GLenum target, const GLdouble *v) { |
||
5556 | trWriteCMD( CMD_MULTITEXCOORD2DVARB ); |
||
5557 | trWriteEnum( target ); |
||
5558 | trWritePointer( (void *)v ); |
||
5559 | trFileFlush(); |
||
5560 | trWriteArrayd( 2, v ); |
||
5561 | |||
5562 | if( trCtx()->doExec ) { |
||
5563 | trGetDispatch()->MultiTexCoord2dvARB( target, v ); |
||
5564 | trError(); |
||
5565 | } |
||
5566 | } |
||
5567 | |||
5568 | |||
5569 | GLAPI void GLAPIENTRY trMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t) { |
||
5570 | trWriteCMD( CMD_MULTITEXCOORD2FARB ); |
||
5571 | trWriteEnum( target ); |
||
5572 | trWritef( s ); |
||
5573 | trWritef( t ); |
||
5574 | |||
5575 | if( trCtx()->doExec ) { |
||
5576 | trGetDispatch()->MultiTexCoord2fARB( target, s, t ); |
||
5577 | trError(); |
||
5578 | } |
||
5579 | } |
||
5580 | |||
5581 | |||
5582 | GLAPI void GLAPIENTRY trMultiTexCoord2fvARB( GLenum target, const GLfloat *v) { |
||
5583 | trWriteCMD( CMD_MULTITEXCOORD2FVARB ); |
||
5584 | trWriteEnum( target ); |
||
5585 | trWritePointer( (void *)v ); |
||
5586 | trFileFlush(); |
||
5587 | trWriteArrayf( 2, v ); |
||
5588 | |||
5589 | if( trCtx()->doExec ) { |
||
5590 | trGetDispatch()->MultiTexCoord2fvARB( target, v ); |
||
5591 | trError(); |
||
5592 | } |
||
5593 | } |
||
5594 | |||
5595 | |||
5596 | GLAPI void GLAPIENTRY trMultiTexCoord2iARB( GLenum target, GLint s, GLint t) { |
||
5597 | trWriteCMD( CMD_MULTITEXCOORD2IARB ); |
||
5598 | trWriteEnum( target ); |
||
5599 | trWritei( s ); |
||
5600 | trWritei( t ); |
||
5601 | |||
5602 | if( trCtx()->doExec ) { |
||
5603 | trGetDispatch()->MultiTexCoord2iARB( target, s, t ); |
||
5604 | trError(); |
||
5605 | } |
||
5606 | } |
||
5607 | |||
5608 | |||
5609 | GLAPI void GLAPIENTRY trMultiTexCoord2ivARB( GLenum target, const GLint *v) { |
||
5610 | trWriteCMD( CMD_MULTITEXCOORD2IVARB ); |
||
5611 | trWriteEnum( target ); |
||
5612 | trWritePointer( (void *)v ); |
||
5613 | trFileFlush(); |
||
5614 | trWriteArrayi( 2, v ); |
||
5615 | |||
5616 | if( trCtx()->doExec ) { |
||
5617 | trGetDispatch()->MultiTexCoord2ivARB( target, v ); |
||
5618 | trError(); |
||
5619 | } |
||
5620 | } |
||
5621 | |||
5622 | |||
5623 | GLAPI void GLAPIENTRY trMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t) { |
||
5624 | trWriteCMD( CMD_MULTITEXCOORD2SARB ); |
||
5625 | trWriteEnum( target ); |
||
5626 | trWrites( s ); |
||
5627 | trWrites( t ); |
||
5628 | |||
5629 | if( trCtx()->doExec ) { |
||
5630 | trGetDispatch()->MultiTexCoord2sARB( target, s, t ); |
||
5631 | trError(); |
||
5632 | } |
||
5633 | } |
||
5634 | |||
5635 | |||
5636 | GLAPI void GLAPIENTRY trMultiTexCoord2svARB( GLenum target, const GLshort *v) { |
||
5637 | trWriteCMD( CMD_MULTITEXCOORD2SVARB ); |
||
5638 | trWriteEnum( target ); |
||
5639 | trWritePointer( (void *)v ); |
||
5640 | trFileFlush(); |
||
5641 | trWriteArrays( 2, v ); |
||
5642 | |||
5643 | if( trCtx()->doExec ) { |
||
5644 | trGetDispatch()->MultiTexCoord2svARB( target, v ); |
||
5645 | trError(); |
||
5646 | } |
||
5647 | } |
||
5648 | |||
5649 | |||
5650 | GLAPI void GLAPIENTRY trMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r) { |
||
5651 | trWriteCMD( CMD_MULTITEXCOORD3DARB ); |
||
5652 | trWriteEnum( target ); |
||
5653 | trWrited( s ); |
||
5654 | trWrited( t ); |
||
5655 | trWrited( r ); |
||
5656 | |||
5657 | if( trCtx()->doExec ) { |
||
5658 | trGetDispatch()->MultiTexCoord3dARB( target, s, t, r ); |
||
5659 | trError(); |
||
5660 | } |
||
5661 | } |
||
5662 | |||
5663 | |||
5664 | GLAPI void GLAPIENTRY trMultiTexCoord3dvARB( GLenum target, const GLdouble *v) { |
||
5665 | trWriteCMD( CMD_MULTITEXCOORD3DVARB ); |
||
5666 | trWriteEnum( target ); |
||
5667 | trWritePointer( (void *)v ); |
||
5668 | trFileFlush(); |
||
5669 | trWriteArrayd( 3, v ); |
||
5670 | |||
5671 | if( trCtx()->doExec ) { |
||
5672 | trGetDispatch()->MultiTexCoord3dvARB( target, v ); |
||
5673 | trError(); |
||
5674 | } |
||
5675 | } |
||
5676 | |||
5677 | |||
5678 | GLAPI void GLAPIENTRY trMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r) { |
||
5679 | trWriteCMD( CMD_MULTITEXCOORD3FARB ); |
||
5680 | trWriteEnum( target ); |
||
5681 | trWritef( s ); |
||
5682 | trWritef( t ); |
||
5683 | trWritef( r ); |
||
5684 | |||
5685 | if( trCtx()->doExec ) { |
||
5686 | trGetDispatch()->MultiTexCoord3fARB( target, s, t, r ); |
||
5687 | trError(); |
||
5688 | } |
||
5689 | } |
||
5690 | |||
5691 | |||
5692 | GLAPI void GLAPIENTRY trMultiTexCoord3fvARB( GLenum target, const GLfloat *v) { |
||
5693 | trWriteCMD( CMD_MULTITEXCOORD3FVARB ); |
||
5694 | trWriteEnum( target ); |
||
5695 | trWritePointer( (void *)v ); |
||
5696 | trFileFlush(); |
||
5697 | trWriteArrayf( 3, v ); |
||
5698 | |||
5699 | if( trCtx()->doExec ) { |
||
5700 | trGetDispatch()->MultiTexCoord3fvARB( target, v ); |
||
5701 | trError(); |
||
5702 | } |
||
5703 | } |
||
5704 | |||
5705 | |||
5706 | GLAPI void GLAPIENTRY trMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r) { |
||
5707 | trWriteCMD( CMD_MULTITEXCOORD3IARB ); |
||
5708 | trWriteEnum( target ); |
||
5709 | trWritei( s ); |
||
5710 | trWritei( t ); |
||
5711 | trWritei( r ); |
||
5712 | |||
5713 | if( trCtx()->doExec ) { |
||
5714 | trGetDispatch()->MultiTexCoord3iARB( target, s, t, r ); |
||
5715 | trError(); |
||
5716 | } |
||
5717 | } |
||
5718 | |||
5719 | |||
5720 | GLAPI void GLAPIENTRY trMultiTexCoord3ivARB( GLenum target, const GLint *v) { |
||
5721 | trWriteCMD( CMD_MULTITEXCOORD3IVARB ); |
||
5722 | trWriteEnum( target ); |
||
5723 | trWritePointer( (void *)v ); |
||
5724 | trFileFlush(); |
||
5725 | trWriteArrayi( 3, v ); |
||
5726 | |||
5727 | if( trCtx()->doExec ) { |
||
5728 | trGetDispatch()->MultiTexCoord3ivARB( target, v ); |
||
5729 | trError(); |
||
5730 | } |
||
5731 | } |
||
5732 | |||
5733 | |||
5734 | GLAPI void GLAPIENTRY trMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r) { |
||
5735 | trWriteCMD( CMD_MULTITEXCOORD3SARB ); |
||
5736 | trWriteEnum( target ); |
||
5737 | trWrites( s ); |
||
5738 | trWrites( t ); |
||
5739 | trWrites( r ); |
||
5740 | |||
5741 | if( trCtx()->doExec ) { |
||
5742 | trGetDispatch()->MultiTexCoord3sARB( target, s, t, r ); |
||
5743 | trError(); |
||
5744 | } |
||
5745 | } |
||
5746 | |||
5747 | |||
5748 | GLAPI void GLAPIENTRY trMultiTexCoord3svARB( GLenum target, const GLshort *v) { |
||
5749 | trWriteCMD( CMD_MULTITEXCOORD3SVARB ); |
||
5750 | trWriteEnum( target ); |
||
5751 | trWritePointer( (void *)v ); |
||
5752 | trFileFlush(); |
||
5753 | trWriteArrays( 3, v ); |
||
5754 | |||
5755 | if( trCtx()->doExec ) { |
||
5756 | trGetDispatch()->MultiTexCoord3svARB( target, v ); |
||
5757 | trError(); |
||
5758 | } |
||
5759 | } |
||
5760 | |||
5761 | |||
5762 | GLAPI void GLAPIENTRY trMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) { |
||
5763 | trWriteCMD( CMD_MULTITEXCOORD4DARB ); |
||
5764 | trWriteEnum( target ); |
||
5765 | trWrited( s ); |
||
5766 | trWrited( t ); |
||
5767 | trWrited( r ); |
||
5768 | trWrited( q ); |
||
5769 | |||
5770 | if( trCtx()->doExec ) { |
||
5771 | trGetDispatch()->MultiTexCoord4dARB( target, s, t, r, q ); |
||
5772 | trError(); |
||
5773 | } |
||
5774 | } |
||
5775 | |||
5776 | |||
5777 | GLAPI void GLAPIENTRY trMultiTexCoord4dvARB( GLenum target, const GLdouble *v) { |
||
5778 | trWriteCMD( CMD_MULTITEXCOORD4DVARB ); |
||
5779 | trWriteEnum( target ); |
||
5780 | trWritePointer( (void *)v ); |
||
5781 | trFileFlush(); |
||
5782 | trWriteArrayd( 4, v ); |
||
5783 | |||
5784 | if( trCtx()->doExec ) { |
||
5785 | trGetDispatch()->MultiTexCoord4dvARB( target, v ); |
||
5786 | trError(); |
||
5787 | } |
||
5788 | } |
||
5789 | |||
5790 | |||
5791 | GLAPI void GLAPIENTRY trMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { |
||
5792 | trWriteCMD( CMD_MULTITEXCOORD4FARB ); |
||
5793 | trWriteEnum( target ); |
||
5794 | trWritef( s ); |
||
5795 | trWritef( t ); |
||
5796 | trWritef( r ); |
||
5797 | trWritef( q ); |
||
5798 | |||
5799 | if( trCtx()->doExec ) { |
||
5800 | trGetDispatch()->MultiTexCoord4fARB( target, s, t, r, q ); |
||
5801 | trError(); |
||
5802 | } |
||
5803 | } |
||
5804 | |||
5805 | |||
5806 | GLAPI void GLAPIENTRY trMultiTexCoord4fvARB( GLenum target, const GLfloat *v) { |
||
5807 | trWriteCMD( CMD_MULTITEXCOORD4FVARB ); |
||
5808 | trWriteEnum( target ); |
||
5809 | trWritePointer( (void *)v ); |
||
5810 | trFileFlush(); |
||
5811 | trWriteArrayf( 3, v ); |
||
5812 | |||
5813 | if( trCtx()->doExec ) { |
||
5814 | trGetDispatch()->MultiTexCoord4fvARB( target, v ); |
||
5815 | trError(); |
||
5816 | } |
||
5817 | } |
||
5818 | |||
5819 | |||
5820 | GLAPI void GLAPIENTRY trMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q) { |
||
5821 | trWriteCMD( CMD_MULTITEXCOORD4IARB ); |
||
5822 | trWriteEnum( target ); |
||
5823 | trWritei( s ); |
||
5824 | trWritei( t ); |
||
5825 | trWritei( r ); |
||
5826 | trWritei( q ); |
||
5827 | |||
5828 | if( trCtx()->doExec ) { |
||
5829 | trGetDispatch()->MultiTexCoord4iARB( target, s, t, r, q ); |
||
5830 | trError(); |
||
5831 | } |
||
5832 | } |
||
5833 | |||
5834 | |||
5835 | GLAPI void GLAPIENTRY trMultiTexCoord4ivARB( GLenum target, const GLint *v) { |
||
5836 | trWriteCMD( CMD_MULTITEXCOORD4IVARB ); |
||
5837 | trWriteEnum( target ); |
||
5838 | trWritePointer( (void *)v ); |
||
5839 | trFileFlush(); |
||
5840 | trWriteArrayi( 4, v ); |
||
5841 | |||
5842 | if( trCtx()->doExec ) { |
||
5843 | trGetDispatch()->MultiTexCoord4ivARB( target, v ); |
||
5844 | trError(); |
||
5845 | } |
||
5846 | } |
||
5847 | |||
5848 | |||
5849 | GLAPI void GLAPIENTRY trMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) { |
||
5850 | trWriteCMD( CMD_MULTITEXCOORD4SARB ); |
||
5851 | trWriteEnum( target ); |
||
5852 | trWrites( s ); |
||
5853 | trWrites( t ); |
||
5854 | trWrites( r ); |
||
5855 | trWrites( q ); |
||
5856 | |||
5857 | if( trCtx()->doExec ) { |
||
5858 | trGetDispatch()->MultiTexCoord4sARB( target, s, t, r, q ); |
||
5859 | trError(); |
||
5860 | } |
||
5861 | } |
||
5862 | |||
5863 | |||
5864 | GLAPI void GLAPIENTRY trMultiTexCoord4svARB( GLenum target, const GLshort *v) { |
||
5865 | trWriteCMD( CMD_MULTITEXCOORD4SVARB ); |
||
5866 | trWriteEnum( target ); |
||
5867 | trWritePointer( (void *)v ); |
||
5868 | trFileFlush(); |
||
5869 | trWriteArrays( 4, v ); |
||
5870 | |||
5871 | if( trCtx()->doExec ) { |
||
5872 | trGetDispatch()->MultiTexCoord4svARB( target, v ); |
||
5873 | trError(); |
||
5874 | } |
||
5875 | } |
||
5876 | |||
5877 | |||
5878 | GLAPI void GLAPIENTRY trMultMatrixd( const GLdouble *m ) { |
||
5879 | trWriteCMD( CMD_MULTMATRIXD ); |
||
5880 | trWritePointer( (void *)m ); |
||
5881 | trFileFlush(); |
||
5882 | trWriteArrayd( 16, m ); |
||
5883 | |||
5884 | if( trCtx()->doExec ) { |
||
5885 | trGetDispatch()->MultMatrixd( m ); |
||
5886 | trError(); |
||
5887 | } |
||
5888 | } |
||
5889 | |||
5890 | |||
5891 | GLAPI void GLAPIENTRY trMultMatrixf( const GLfloat *m ) { |
||
5892 | trWriteCMD( CMD_MULTMATRIXF ); |
||
5893 | trWritePointer( (void *)m ); |
||
5894 | trFileFlush(); |
||
5895 | trWriteArrayf( 16, m ); |
||
5896 | |||
5897 | if( trCtx()->doExec ) { |
||
5898 | trGetDispatch()->MultMatrixf( m ); |
||
5899 | trError(); |
||
5900 | } |
||
5901 | } |
||
5902 | |||
5903 | |||
5904 | GLAPI void GLAPIENTRY trNewList( GLuint list, GLenum mode ) { |
||
5905 | trWriteCMD( CMD_NEWLIST ); |
||
5906 | trWriteui( list ); |
||
5907 | trWriteEnum( mode ); |
||
5908 | |||
5909 | if( trCtx()->doExec ) { |
||
5910 | trGetDispatch()->NewList( list, mode ); |
||
5911 | trError(); |
||
5912 | } |
||
5913 | } |
||
5914 | |||
5915 | |||
5916 | GLAPI void GLAPIENTRY trNormal3b( GLbyte nx, GLbyte ny, GLbyte nz ) { |
||
5917 | trWriteCMD( CMD_NORMAL3B ); |
||
5918 | trWriteb( nx ); |
||
5919 | trWriteb( ny ); |
||
5920 | trWriteb( nz ); |
||
5921 | |||
5922 | if( trCtx()->doExec ) { |
||
5923 | trGetDispatch()->Normal3b( nx, ny, nz ); |
||
5924 | trError(); |
||
5925 | } |
||
5926 | } |
||
5927 | |||
5928 | |||
5929 | GLAPI void GLAPIENTRY trNormal3bv( const GLbyte *v ) { |
||
5930 | trWriteCMD( CMD_NORMAL3BV ); |
||
5931 | trWritePointer( (void *)v ); |
||
5932 | trFileFlush(); |
||
5933 | trWriteArrayb( 3, v ); |
||
5934 | |||
5935 | if( trCtx()->doExec ) { |
||
5936 | trGetDispatch()->Normal3bv( v ); |
||
5937 | trError(); |
||
5938 | } |
||
5939 | } |
||
5940 | |||
5941 | |||
5942 | GLAPI void GLAPIENTRY trNormal3d( GLdouble nx, GLdouble ny, GLdouble nz ) { |
||
5943 | trWriteCMD( CMD_NORMAL3D ); |
||
5944 | trWrited( nx ); |
||
5945 | trWrited( ny ); |
||
5946 | trWrited( nz ); |
||
5947 | |||
5948 | if( trCtx()->doExec ) { |
||
5949 | trGetDispatch()->Normal3d( nx, ny, nz ); |
||
5950 | trError(); |
||
5951 | } |
||
5952 | } |
||
5953 | |||
5954 | |||
5955 | GLAPI void GLAPIENTRY trNormal3dv( const GLdouble *v ) { |
||
5956 | trWriteCMD( CMD_NORMAL3DV ); |
||
5957 | trWritePointer( (void *)v ); |
||
5958 | trFileFlush(); |
||
5959 | trWriteArrayd( 3, v ); |
||
5960 | |||
5961 | if( trCtx()->doExec ) { |
||
5962 | trGetDispatch()->Normal3dv( v ); |
||
5963 | trError(); |
||
5964 | } |
||
5965 | } |
||
5966 | |||
5967 | |||
5968 | GLAPI void GLAPIENTRY trNormal3f( GLfloat nx, GLfloat ny, GLfloat nz ) { |
||
5969 | trWriteCMD( CMD_NORMAL3F ); |
||
5970 | trWritef( nx ); |
||
5971 | trWritef( ny ); |
||
5972 | trWritef( nz ); |
||
5973 | |||
5974 | if( trCtx()->doExec ) { |
||
5975 | trGetDispatch()->Normal3f( nx, ny, nz ); |
||
5976 | trError(); |
||
5977 | } |
||
5978 | } |
||
5979 | |||
5980 | |||
5981 | GLAPI void GLAPIENTRY trNormal3fv( const GLfloat *v ) { |
||
5982 | trWriteCMD( CMD_NORMAL3FV ); |
||
5983 | trWritePointer( (void *)v ); |
||
5984 | trFileFlush(); |
||
5985 | trWriteArrayf( 3, v ); |
||
5986 | |||
5987 | if( trCtx()->doExec ) { |
||
5988 | trGetDispatch()->Normal3fv( v ); |
||
5989 | trError(); |
||
5990 | } |
||
5991 | } |
||
5992 | |||
5993 | |||
5994 | GLAPI void GLAPIENTRY trNormal3i( GLint nx, GLint ny, GLint nz ) { |
||
5995 | trWriteCMD( CMD_NORMAL3I ); |
||
5996 | trWritei( nx ); |
||
5997 | trWritei( ny ); |
||
5998 | trWritei( nz ); |
||
5999 | |||
6000 | if( trCtx()->doExec ) { |
||
6001 | trGetDispatch()->Normal3i( nx, ny, nz ); |
||
6002 | trError(); |
||
6003 | } |
||
6004 | } |
||
6005 | |||
6006 | |||
6007 | GLAPI void GLAPIENTRY trNormal3iv( const GLint *v ) { |
||
6008 | trWriteCMD( CMD_NORMAL3IV ); |
||
6009 | trWritePointer( (void *)v ); |
||
6010 | trFileFlush(); |
||
6011 | trWriteArrayi( 3, v ); |
||
6012 | |||
6013 | if( trCtx()->doExec ) { |
||
6014 | trGetDispatch()->Normal3iv( v ); |
||
6015 | trError(); |
||
6016 | } |
||
6017 | } |
||
6018 | |||
6019 | |||
6020 | GLAPI void GLAPIENTRY trNormal3s( GLshort nx, GLshort ny, GLshort nz ) { |
||
6021 | trWriteCMD( CMD_NORMAL3S ); |
||
6022 | trWrites( nx ); |
||
6023 | trWrites( ny ); |
||
6024 | trWrites( nz ); |
||
6025 | |||
6026 | if( trCtx()->doExec ) { |
||
6027 | trGetDispatch()->Normal3s( nx, ny, nz ); |
||
6028 | trError(); |
||
6029 | } |
||
6030 | } |
||
6031 | |||
6032 | |||
6033 | GLAPI void GLAPIENTRY trNormal3sv( const GLshort *v ) { |
||
6034 | trWriteCMD( CMD_NORMAL3SV ); |
||
6035 | trWritePointer( (void *)v ); |
||
6036 | trFileFlush(); |
||
6037 | trWriteArrays( 3, v ); |
||
6038 | |||
6039 | if( trCtx()->doExec ) { |
||
6040 | trGetDispatch()->Normal3sv( v ); |
||
6041 | trError(); |
||
6042 | } |
||
6043 | } |
||
6044 | |||
6045 | |||
6046 | GLAPI void GLAPIENTRY trNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */ |
||
6047 | trWriteCMD( CMD_NORMALPOINTEREXT ); |
||
6048 | trWriteEnum( type ); |
||
6049 | trWriteSizei( stride ); |
||
6050 | trWriteSizei( count ); |
||
6051 | trWritePointer( (void *)ptr ); |
||
6052 | trFileFlush(); |
||
6053 | |||
6054 | if( trCtx()->doExec ) { |
||
6055 | trGetDispatch()->NormalPointerEXT( type, stride, count, ptr ); |
||
6056 | trError(); |
||
6057 | } |
||
6058 | } |
||
6059 | |||
6060 | |||
6061 | GLAPI void GLAPIENTRY trNormalPointer( GLenum type, GLsizei stride, const GLvoid *ptr ) { /* TODO */ |
||
6062 | trWriteCMD( CMD_NORMALPOINTER ); |
||
6063 | trWriteEnum( type ); |
||
6064 | trWriteSizei( stride ); |
||
6065 | trWritePointer( (void *)ptr ); |
||
6066 | trFileFlush(); |
||
6067 | |||
6068 | if( trCtx()->doExec ) { |
||
6069 | trGetDispatch()->NormalPointer( type, stride, ptr ); |
||
6070 | trError(); |
||
6071 | } |
||
6072 | } |
||
6073 | |||
6074 | |||
6075 | GLAPI void GLAPIENTRY trOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) { |
||
6076 | trWriteCMD( CMD_ORTHO ); |
||
6077 | trWrited( left ); |
||
6078 | trWrited( right ); |
||
6079 | trWrited( bottom ); |
||
6080 | trWrited( top ); |
||
6081 | trWrited( near_val ); |
||
6082 | trWrited( far_val ); |
||
6083 | |||
6084 | if( trCtx()->doExec ) { |
||
6085 | trGetDispatch()->Ortho( left, right, bottom, top, near_val, far_val ); |
||
6086 | trError(); |
||
6087 | } |
||
6088 | } |
||
6089 | |||
6090 | |||
6091 | GLAPI void GLAPIENTRY trPassThrough( GLfloat token ) { |
||
6092 | trWriteCMD( CMD_PASSTHROUGH ); |
||
6093 | trWritef( token ); |
||
6094 | |||
6095 | if( trCtx()->doExec ) { |
||
6096 | trGetDispatch()->PassThrough( token ); |
||
6097 | trError(); |
||
6098 | } |
||
6099 | } |
||
6100 | |||
6101 | |||
6102 | GLAPI void GLAPIENTRY trPixelMapfv( GLenum map, GLint mapsize, const GLfloat *values ) { |
||
6103 | trWriteCMD( CMD_PIXELMAPFV ); |
||
6104 | trWriteEnum( map ); |
||
6105 | trWritei( mapsize ); |
||
6106 | trWritePointer( (void *)values ); |
||
6107 | trFileFlush(); |
||
6108 | trWriteArrayf( mapsize, values ); |
||
6109 | |||
6110 | if( trCtx()->doExec ) { |
||
6111 | trGetDispatch()->PixelMapfv( map, mapsize, values ); |
||
6112 | trError(); |
||
6113 | } |
||
6114 | } |
||
6115 | |||
6116 | |||
6117 | GLAPI void GLAPIENTRY trPixelMapuiv( GLenum map, GLint mapsize, const GLuint *values ) { |
||
6118 | trWriteCMD( CMD_PIXELMAPUIV ); |
||
6119 | trWriteEnum( map ); |
||
6120 | trWritei( mapsize ); |
||
6121 | trWritePointer( (void *)values ); |
||
6122 | trFileFlush(); |
||
6123 | trWriteArrayui( mapsize, values ); |
||
6124 | |||
6125 | if( trCtx()->doExec ) { |
||
6126 | trGetDispatch()->PixelMapuiv( map, mapsize, values ); |
||
6127 | trError(); |
||
6128 | } |
||
6129 | } |
||
6130 | |||
6131 | |||
6132 | GLAPI void GLAPIENTRY trPixelMapusv( GLenum map, GLint mapsize, const GLushort *values ) { |
||
6133 | trWriteCMD( CMD_PIXELMAPUSV ); |
||
6134 | trWriteEnum( map ); |
||
6135 | trWritei( mapsize ); |
||
6136 | trWritePointer( (void *)values ); |
||
6137 | trFileFlush(); |
||
6138 | trWriteArrayus( mapsize, values ); |
||
6139 | |||
6140 | if( trCtx()->doExec ) { |
||
6141 | trGetDispatch()->PixelMapusv( map, mapsize, values ); |
||
6142 | trError(); |
||
6143 | } |
||
6144 | } |
||
6145 | |||
6146 | |||
6147 | GLAPI void GLAPIENTRY trPixelStoref( GLenum pname, GLfloat param ) { |
||
6148 | trWriteCMD( CMD_PIXELSTOREF ); |
||
6149 | trWriteEnum( pname ); |
||
6150 | trWritef( param ); |
||
6151 | |||
6152 | if( trCtx()->doExec ) { |
||
6153 | trGetDispatch()->PixelStoref( pname, param ); |
||
6154 | trError(); |
||
6155 | } |
||
6156 | } |
||
6157 | |||
6158 | |||
6159 | GLAPI void GLAPIENTRY trPixelStorei( GLenum pname, GLint param ) { |
||
6160 | trWriteCMD( CMD_PIXELSTOREI ); |
||
6161 | trWriteEnum( pname ); |
||
6162 | trWritei( param ); |
||
6163 | |||
6164 | if( trCtx()->doExec ) { |
||
6165 | trGetDispatch()->PixelStorei( pname, param ); |
||
6166 | trError(); |
||
6167 | } |
||
6168 | } |
||
6169 | |||
6170 | |||
6171 | GLAPI void GLAPIENTRY trPixelTransferf( GLenum pname, GLfloat param ) { |
||
6172 | trWriteCMD( CMD_PIXELTRANSFERF ); |
||
6173 | trWriteEnum( pname ); |
||
6174 | trWritef( param ); |
||
6175 | |||
6176 | if( trCtx()->doExec ) { |
||
6177 | trGetDispatch()->PixelTransferf( pname, param ); |
||
6178 | trError(); |
||
6179 | } |
||
6180 | } |
||
6181 | |||
6182 | |||
6183 | GLAPI void GLAPIENTRY trPixelTransferi( GLenum pname, GLint param ) { |
||
6184 | trWriteCMD( CMD_PIXELTRANSFERI ); |
||
6185 | trWriteEnum( pname ); |
||
6186 | trWritei( param ); |
||
6187 | |||
6188 | if( trCtx()->doExec ) { |
||
6189 | trGetDispatch()->PixelTransferi( pname, param ); |
||
6190 | trError(); |
||
6191 | } |
||
6192 | } |
||
6193 | |||
6194 | |||
6195 | GLAPI void GLAPIENTRY trPixelZoom( GLfloat xfactor, GLfloat yfactor ) { |
||
6196 | trWriteCMD( CMD_PIXELZOOM ); |
||
6197 | trWritef( xfactor ); |
||
6198 | trWritef( yfactor ); |
||
6199 | |||
6200 | if( trCtx()->doExec ) { |
||
6201 | trGetDispatch()->PixelZoom( xfactor, yfactor ); |
||
6202 | trError(); |
||
6203 | } |
||
6204 | } |
||
6205 | |||
6206 | |||
6207 | GLAPI void GLAPIENTRY trPointParameterfEXT( GLenum pname, GLfloat param ) { |
||
6208 | trWriteCMD( CMD_POINTPARAMETERFEXT ); |
||
6209 | trWriteEnum( pname ); |
||
6210 | trWritef( param ); |
||
6211 | |||
6212 | if( trCtx()->doExec ) { |
||
6213 | trGetDispatch()->PointParameterfEXT( pname, param ); |
||
6214 | trError(); |
||
6215 | } |
||
6216 | } |
||
6217 | |||
6218 | |||
6219 | #if 0 |
||
6220 | // Not in MESAs dispatch table |
||
6221 | GLAPI void GLAPIENTRY trPointParameterfSGIS( GLenum pname, GLfloat param) { |
||
6222 | trWriteCMD( CMD_POINTPARAMETERFSGIS ); |
||
6223 | trWriteEnum( pname ); |
||
6224 | trWritef( param ); |
||
6225 | |||
6226 | if( trCtx()->doExec ) { |
||
6227 | trGetDispatch()->PointParameterfSGIS( pname, param ); |
||
6228 | trError(); |
||
6229 | } |
||
6230 | } |
||
6231 | #endif |
||
6232 | |||
6233 | |||
6234 | GLAPI void GLAPIENTRY trPointParameterfvEXT( GLenum pname, const GLfloat *params ) { |
||
6235 | trWriteCMD( CMD_POINTPARAMETERFVEXT ); |
||
6236 | trWriteEnum( pname ); |
||
6237 | trWritePointer( (void *)params ); |
||
6238 | trFileFlush(); |
||
6239 | |||
6240 | switch( pname ) { |
||
6241 | case GL_POINT_SIZE_MIN_EXT: |
||
6242 | case GL_POINT_SIZE_MAX_EXT: |
||
6243 | case GL_POINT_FADE_THRESHOLD_SIZE_EXT: |
||
6244 | trWritef( params[0] ); |
||
6245 | break; |
||
6246 | |||
6247 | case GL_DISTANCE_ATTENUATION_EXT: |
||
6248 | trWriteArrayf( 3, params ); |
||
6249 | break; |
||
6250 | |||
6251 | default: |
||
6252 | /* The 2nd pass should handle this. */ |
||
6253 | break; |
||
6254 | } |
||
6255 | |||
6256 | if( trCtx()->doExec ) { |
||
6257 | trGetDispatch()->PointParameterfvEXT( pname, params ); |
||
6258 | trError(); |
||
6259 | } |
||
6260 | } |
||
6261 | |||
6262 | |||
6263 | #if 0 |
||
6264 | // Not in MESAs dispatch table |
||
6265 | GLAPI void GLAPIENTRY trPointParameterfvSGIS( GLenum pname, const GLfloat *params) { /* TODO */ |
||
6266 | trWriteCMD( CMD_POINTPARAMETERFVSGIS ); |
||
6267 | trWriteEnum( pname ); |
||
6268 | trWritePointer( (void *)params ); |
||
6269 | trFileFlush(); |
||
6270 | |||
6271 | if( trCtx()->doExec ) { |
||
6272 | trGetDispatch()->PointParameterfvSGIS( pname, params ); |
||
6273 | trError(); |
||
6274 | } |
||
6275 | } |
||
6276 | #endif |
||
6277 | |||
6278 | |||
6279 | GLAPI void GLAPIENTRY trPointSize( GLfloat size ) { |
||
6280 | trWriteCMD( CMD_POINTSIZE ); |
||
6281 | trWritef( size ); |
||
6282 | |||
6283 | if( trCtx()->doExec ) { |
||
6284 | trGetDispatch()->PointSize( size ); |
||
6285 | trError(); |
||
6286 | } |
||
6287 | } |
||
6288 | |||
6289 | |||
6290 | GLAPI void GLAPIENTRY trPolygonMode( GLenum face, GLenum mode ) { |
||
6291 | trWriteCMD( CMD_POLYGONMODE ); |
||
6292 | trWriteEnum( face ); |
||
6293 | trWriteEnum( mode ); |
||
6294 | |||
6295 | if( trCtx()->doExec ) { |
||
6296 | trGetDispatch()->PolygonMode( face, mode ); |
||
6297 | trError(); |
||
6298 | } |
||
6299 | } |
||
6300 | |||
6301 | |||
6302 | GLAPI void GLAPIENTRY trPolygonOffsetEXT( GLfloat factor, GLfloat bias ) { |
||
6303 | trWriteCMD( CMD_POLYGONOFFSETEXT ); |
||
6304 | trWritef( factor ); |
||
6305 | trWritef( bias ); |
||
6306 | |||
6307 | if( trCtx()->doExec ) { |
||
6308 | trGetDispatch()->PolygonOffsetEXT( factor, bias ); |
||
6309 | trError(); |
||
6310 | } |
||
6311 | } |
||
6312 | |||
6313 | |||
6314 | GLAPI void GLAPIENTRY trPolygonOffset( GLfloat factor, GLfloat units ) { |
||
6315 | trWriteCMD( CMD_POLYGONOFFSET ); |
||
6316 | trWritef( factor ); |
||
6317 | trWritef( units ); |
||
6318 | |||
6319 | if( trCtx()->doExec ) { |
||
6320 | trGetDispatch()->PolygonOffset( factor, units ); |
||
6321 | trError(); |
||
6322 | } |
||
6323 | } |
||
6324 | |||
6325 | |||
6326 | GLAPI void GLAPIENTRY trPolygonStipple( const GLubyte *mask ) { |
||
6327 | trWriteCMD( CMD_POLYGONSTIPPLE ); |
||
6328 | trWritePointer( (void *)mask ); |
||
6329 | trFileFlush(); |
||
6330 | trWriteArrayub( 64, mask ); |
||
6331 | |||
6332 | if( trCtx()->doExec ) { |
||
6333 | trGetDispatch()->PolygonStipple( mask ); |
||
6334 | trError(); |
||
6335 | } |
||
6336 | } |
||
6337 | |||
6338 | |||
6339 | GLAPI void GLAPIENTRY trPopAttrib( void ) { |
||
6340 | trWriteCMD( CMD_POPATTRIB ); |
||
6341 | |||
6342 | if( trCtx()->doExec ) { |
||
6343 | trGetDispatch()->PopAttrib( ); |
||
6344 | trError(); |
||
6345 | } |
||
6346 | } |
||
6347 | |||
6348 | |||
6349 | GLAPI void GLAPIENTRY trPopClientAttrib( void ) { |
||
6350 | trWriteCMD( CMD_POPCLIENTATTRIB ); |
||
6351 | |||
6352 | if( trCtx()->doExec ) { |
||
6353 | trGetDispatch()->PopClientAttrib( ); |
||
6354 | trError(); |
||
6355 | } |
||
6356 | } |
||
6357 | |||
6358 | |||
6359 | GLAPI void GLAPIENTRY trPopMatrix( void ) { |
||
6360 | trWriteCMD( CMD_POPMATRIX ); |
||
6361 | |||
6362 | if( trCtx()->doExec ) { |
||
6363 | trGetDispatch()->PopMatrix( ); |
||
6364 | trError(); |
||
6365 | } |
||
6366 | } |
||
6367 | |||
6368 | |||
6369 | GLAPI void GLAPIENTRY trPopName( void ) { |
||
6370 | trWriteCMD( CMD_POPNAME ); |
||
6371 | |||
6372 | if( trCtx()->doExec ) { |
||
6373 | trGetDispatch()->PopName( ); |
||
6374 | trError(); |
||
6375 | } |
||
6376 | } |
||
6377 | |||
6378 | |||
6379 | #if 0 |
||
6380 | // Not in MESAs dispatch table |
||
6381 | GLAPI void GLAPIENTRY trPrioritizeTexturesEXT( GLsizei n, const GLuint *textures, const GLclampf *priorities ) { |
||
6382 | trWriteCMD( CMD_PRIORITIZETEXTURESEXT ); |
||
6383 | trWriteSizei( n ); |
||
6384 | trWritePointer( (void *)textures ); |
||
6385 | trFileFlush(); |
||
6386 | trWriteArrayui( n, textures ); |
||
6387 | |||
6388 | trWritePointer( (void *)priorities ); |
||
6389 | trFileFlush(); |
||
6390 | /* FIXME!!! */ |
||
6391 | trWriteArrayf( n, priorities ); |
||
6392 | |||
6393 | if( trCtx()->doExec ) { |
||
6394 | trGetDispatch()->PrioritizeTexturesEXT( n, textures, priorities ); |
||
6395 | trError(); |
||
6396 | } |
||
6397 | } |
||
6398 | #endif |
||
6399 | |||
6400 | |||
6401 | GLAPI void GLAPIENTRY trPrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities ) { |
||
6402 | trWriteCMD( CMD_PRIORITIZETEXTURES ); |
||
6403 | trWriteSizei( n ); |
||
6404 | trWritePointer( (void *)textures ); |
||
6405 | trFileFlush(); |
||
6406 | trWriteArrayui( n, textures ); |
||
6407 | |||
6408 | trWritePointer( (void *)priorities ); |
||
6409 | trFileFlush(); |
||
6410 | /* FIXME!!! */ |
||
6411 | trWriteArrayf( n, priorities ); |
||
6412 | |||
6413 | if( trCtx()->doExec ) { |
||
6414 | trGetDispatch()->PrioritizeTextures( n, textures, priorities ); |
||
6415 | trError(); |
||
6416 | } |
||
6417 | } |
||
6418 | |||
6419 | |||
6420 | GLAPI void GLAPIENTRY trPushAttrib( GLbitfield mask ) { |
||
6421 | trWriteCMD( CMD_PUSHATTRIB ); |
||
6422 | trWriteBits( mask ); |
||
6423 | |||
6424 | if( trCtx()->doExec ) { |
||
6425 | trGetDispatch()->PushAttrib( mask ); |
||
6426 | trError(); |
||
6427 | } |
||
6428 | } |
||
6429 | |||
6430 | |||
6431 | GLAPI void GLAPIENTRY trPushClientAttrib( GLbitfield mask ) { |
||
6432 | trWriteCMD( CMD_PUSHCLIENTATTRIB ); |
||
6433 | trWriteBits( mask ); |
||
6434 | |||
6435 | if( trCtx()->doExec ) { |
||
6436 | trGetDispatch()->PushClientAttrib( mask ); |
||
6437 | trError(); |
||
6438 | } |
||
6439 | } |
||
6440 | |||
6441 | |||
6442 | GLAPI void GLAPIENTRY trPushMatrix( void ) { |
||
6443 | trWriteCMD( CMD_PUSHMATRIX ); |
||
6444 | |||
6445 | if( trCtx()->doExec ) { |
||
6446 | trGetDispatch()->PushMatrix( ); |
||
6447 | trError(); |
||
6448 | } |
||
6449 | } |
||
6450 | |||
6451 | |||
6452 | GLAPI void GLAPIENTRY trPushName( GLuint name ) { |
||
6453 | trWriteCMD( CMD_PUSHNAME ); |
||
6454 | trWriteui( name ); |
||
6455 | |||
6456 | if( trCtx()->doExec ) { |
||
6457 | trGetDispatch()->PushName( name ); |
||
6458 | trError(); |
||
6459 | } |
||
6460 | } |
||
6461 | |||
6462 | |||
6463 | GLAPI void GLAPIENTRY trRasterPos2d( GLdouble x, GLdouble y ) { |
||
6464 | trWriteCMD( CMD_RASTERPOS2D ); |
||
6465 | trWrited( x ); |
||
6466 | trWrited( y ); |
||
6467 | |||
6468 | if( trCtx()->doExec ) { |
||
6469 | trGetDispatch()->RasterPos2d( x, y ); |
||
6470 | trError(); |
||
6471 | } |
||
6472 | } |
||
6473 | |||
6474 | |||
6475 | GLAPI void GLAPIENTRY trRasterPos2dv( const GLdouble *v ) { |
||
6476 | trWriteCMD( CMD_RASTERPOS2DV ); |
||
6477 | trWritePointer( (void *)v ); |
||
6478 | trFileFlush(); |
||
6479 | trWriteArrayd( 2, v ); |
||
6480 | |||
6481 | if( trCtx()->doExec ) { |
||
6482 | trGetDispatch()->RasterPos2dv( v ); |
||
6483 | trError(); |
||
6484 | } |
||
6485 | } |
||
6486 | |||
6487 | |||
6488 | GLAPI void GLAPIENTRY trRasterPos2f( GLfloat x, GLfloat y ) { |
||
6489 | trWriteCMD( CMD_RASTERPOS2F ); |
||
6490 | trWritef( x ); |
||
6491 | trWritef( y ); |
||
6492 | |||
6493 | if( trCtx()->doExec ) { |
||
6494 | trGetDispatch()->RasterPos2f( x, y ); |
||
6495 | trError(); |
||
6496 | } |
||
6497 | } |
||
6498 | |||
6499 | |||
6500 | GLAPI void GLAPIENTRY trRasterPos2fv( const GLfloat *v ) { |
||
6501 | trWriteCMD( CMD_RASTERPOS2FV ); |
||
6502 | trWritePointer( (void *)v ); |
||
6503 | trFileFlush(); |
||
6504 | trWriteArrayf( 2, v ); |
||
6505 | |||
6506 | if( trCtx()->doExec ) { |
||
6507 | trGetDispatch()->RasterPos2fv( v ); |
||
6508 | trError(); |
||
6509 | } |
||
6510 | } |
||
6511 | |||
6512 | |||
6513 | GLAPI void GLAPIENTRY trRasterPos2i( GLint x, GLint y ) { |
||
6514 | trWriteCMD( CMD_RASTERPOS2I ); |
||
6515 | trWritei( x ); |
||
6516 | trWritei( y ); |
||
6517 | |||
6518 | if( trCtx()->doExec ) { |
||
6519 | trGetDispatch()->RasterPos2i( x, y ); |
||
6520 | trError(); |
||
6521 | } |
||
6522 | } |
||
6523 | |||
6524 | |||
6525 | GLAPI void GLAPIENTRY trRasterPos2iv( const GLint *v ) { |
||
6526 | trWriteCMD( CMD_RASTERPOS2IV ); |
||
6527 | trWritePointer( (void *)v ); |
||
6528 | trFileFlush(); |
||
6529 | trWriteArrayi( 2, v ); |
||
6530 | |||
6531 | if( trCtx()->doExec ) { |
||
6532 | trGetDispatch()->RasterPos2iv( v ); |
||
6533 | trError(); |
||
6534 | } |
||
6535 | } |
||
6536 | |||
6537 | |||
6538 | GLAPI void GLAPIENTRY trRasterPos2s( GLshort x, GLshort y ) { |
||
6539 | trWriteCMD( CMD_RASTERPOS2S ); |
||
6540 | trWrites( x ); |
||
6541 | trWrites( y ); |
||
6542 | |||
6543 | if( trCtx()->doExec ) { |
||
6544 | trGetDispatch()->RasterPos2s( x, y ); |
||
6545 | trError(); |
||
6546 | } |
||
6547 | } |
||
6548 | |||
6549 | |||
6550 | GLAPI void GLAPIENTRY trRasterPos2sv( const GLshort *v ) { |
||
6551 | trWriteCMD( CMD_RASTERPOS2SV ); |
||
6552 | trWritePointer( (void *)v ); |
||
6553 | trFileFlush(); |
||
6554 | trWriteArrays( 2, v ); |
||
6555 | |||
6556 | if( trCtx()->doExec ) { |
||
6557 | trGetDispatch()->RasterPos2sv( v ); |
||
6558 | trError(); |
||
6559 | } |
||
6560 | } |
||
6561 | |||
6562 | |||
6563 | GLAPI void GLAPIENTRY trRasterPos3d( GLdouble x, GLdouble y, GLdouble z ) { |
||
6564 | trWriteCMD( CMD_RASTERPOS3D ); |
||
6565 | trWrited( x ); |
||
6566 | trWrited( y ); |
||
6567 | trWrited( z ); |
||
6568 | |||
6569 | if( trCtx()->doExec ) { |
||
6570 | trGetDispatch()->RasterPos3d( x, y, z ); |
||
6571 | trError(); |
||
6572 | } |
||
6573 | } |
||
6574 | |||
6575 | |||
6576 | GLAPI void GLAPIENTRY trRasterPos3dv( const GLdouble *v ) { |
||
6577 | trWriteCMD( CMD_RASTERPOS3DV ); |
||
6578 | trWritePointer( (void *)v ); |
||
6579 | trFileFlush(); |
||
6580 | trWriteArrayd( 3, v ); |
||
6581 | |||
6582 | if( trCtx()->doExec ) { |
||
6583 | trGetDispatch()->RasterPos3dv( v ); |
||
6584 | trError(); |
||
6585 | } |
||
6586 | } |
||
6587 | |||
6588 | |||
6589 | GLAPI void GLAPIENTRY trRasterPos3f( GLfloat x, GLfloat y, GLfloat z ) { |
||
6590 | trWriteCMD( CMD_RASTERPOS3F ); |
||
6591 | trWritef( x ); |
||
6592 | trWritef( y ); |
||
6593 | trWritef( z ); |
||
6594 | |||
6595 | if( trCtx()->doExec ) { |
||
6596 | trGetDispatch()->RasterPos3f( x, y, z ); |
||
6597 | trError(); |
||
6598 | } |
||
6599 | } |
||
6600 | |||
6601 | |||
6602 | GLAPI void GLAPIENTRY trRasterPos3fv( const GLfloat *v ) { |
||
6603 | trWriteCMD( CMD_RASTERPOS3FV ); |
||
6604 | trWritePointer( (void *)v ); |
||
6605 | trFileFlush(); |
||
6606 | trWriteArrayf( 3, v ); |
||
6607 | |||
6608 | if( trCtx()->doExec ) { |
||
6609 | trGetDispatch()->RasterPos3fv( v ); |
||
6610 | trError(); |
||
6611 | } |
||
6612 | } |
||
6613 | |||
6614 | |||
6615 | GLAPI void GLAPIENTRY trRasterPos3i( GLint x, GLint y, GLint z ) { |
||
6616 | trWriteCMD( CMD_RASTERPOS3I ); |
||
6617 | trWritei( x ); |
||
6618 | trWritei( y ); |
||
6619 | trWritei( z ); |
||
6620 | |||
6621 | if( trCtx()->doExec ) { |
||
6622 | trGetDispatch()->RasterPos3i( x, y, z ); |
||
6623 | trError(); |
||
6624 | } |
||
6625 | } |
||
6626 | |||
6627 | |||
6628 | GLAPI void GLAPIENTRY trRasterPos3iv( const GLint *v ) { |
||
6629 | trWriteCMD( CMD_RASTERPOS3IV ); |
||
6630 | trWritePointer( (void *)v ); |
||
6631 | trFileFlush(); |
||
6632 | trWriteArrayi( 3, v ); |
||
6633 | |||
6634 | if( trCtx()->doExec ) { |
||
6635 | trGetDispatch()->RasterPos3iv( v ); |
||
6636 | trError(); |
||
6637 | } |
||
6638 | } |
||
6639 | |||
6640 | |||
6641 | GLAPI void GLAPIENTRY trRasterPos3s( GLshort x, GLshort y, GLshort z ) { |
||
6642 | trWriteCMD( CMD_RASTERPOS3S ); |
||
6643 | trWrites( x ); |
||
6644 | trWrites( y ); |
||
6645 | trWrites( z ); |
||
6646 | |||
6647 | if( trCtx()->doExec ) { |
||
6648 | trGetDispatch()->RasterPos3s( x, y, z ); |
||
6649 | trError(); |
||
6650 | } |
||
6651 | } |
||
6652 | |||
6653 | |||
6654 | GLAPI void GLAPIENTRY trRasterPos3sv( const GLshort *v ) { |
||
6655 | trWriteCMD( CMD_RASTERPOS3SV ); |
||
6656 | trWritePointer( (void *)v ); |
||
6657 | trFileFlush(); |
||
6658 | trWriteArrays( 3, v ); |
||
6659 | |||
6660 | if( trCtx()->doExec ) { |
||
6661 | trGetDispatch()->RasterPos3sv( v ); |
||
6662 | trError(); |
||
6663 | } |
||
6664 | } |
||
6665 | |||
6666 | |||
6667 | GLAPI void GLAPIENTRY trRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { |
||
6668 | trWriteCMD( CMD_RASTERPOS4D ); |
||
6669 | trWrited( x ); |
||
6670 | trWrited( y ); |
||
6671 | trWrited( z ); |
||
6672 | trWrited( w ); |
||
6673 | |||
6674 | if( trCtx()->doExec ) { |
||
6675 | trGetDispatch()->RasterPos4d( x, y, z, w ); |
||
6676 | trError(); |
||
6677 | } |
||
6678 | } |
||
6679 | |||
6680 | |||
6681 | GLAPI void GLAPIENTRY trRasterPos4dv( const GLdouble *v ) { |
||
6682 | trWriteCMD( CMD_RASTERPOS4DV ); |
||
6683 | trWritePointer( (void *)v ); |
||
6684 | trFileFlush(); |
||
6685 | trWriteArrayd( 4, v ); |
||
6686 | |||
6687 | if( trCtx()->doExec ) { |
||
6688 | trGetDispatch()->RasterPos4dv( v ); |
||
6689 | trError(); |
||
6690 | } |
||
6691 | } |
||
6692 | |||
6693 | |||
6694 | GLAPI void GLAPIENTRY trRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { |
||
6695 | trWriteCMD( CMD_RASTERPOS4F ); |
||
6696 | trWritef( x ); |
||
6697 | trWritef( y ); |
||
6698 | trWritef( z ); |
||
6699 | trWritef( w ); |
||
6700 | |||
6701 | if( trCtx()->doExec ) { |
||
6702 | trGetDispatch()->RasterPos4f( x, y, z, w ); |
||
6703 | trError(); |
||
6704 | } |
||
6705 | } |
||
6706 | |||
6707 | |||
6708 | GLAPI void GLAPIENTRY trRasterPos4fv( const GLfloat *v ) { |
||
6709 | trWriteCMD( CMD_RASTERPOS4FV ); |
||
6710 | trWritePointer( (void *)v ); |
||
6711 | trFileFlush(); |
||
6712 | trWriteArrayf( 4, v ); |
||
6713 | |||
6714 | if( trCtx()->doExec ) { |
||
6715 | trGetDispatch()->RasterPos4fv( v ); |
||
6716 | trError(); |
||
6717 | } |
||
6718 | } |
||
6719 | |||
6720 | |||
6721 | GLAPI void GLAPIENTRY trRasterPos4i( GLint x, GLint y, GLint z, GLint w ) { |
||
6722 | trWriteCMD( CMD_RASTERPOS4I ); |
||
6723 | trWritei( x ); |
||
6724 | trWritei( y ); |
||
6725 | trWritei( z ); |
||
6726 | trWritei( w ); |
||
6727 | |||
6728 | if( trCtx()->doExec ) { |
||
6729 | trGetDispatch()->RasterPos4i( x, y, z, w ); |
||
6730 | trError(); |
||
6731 | } |
||
6732 | } |
||
6733 | |||
6734 | |||
6735 | GLAPI void GLAPIENTRY trRasterPos4iv( const GLint *v ) { |
||
6736 | trWriteCMD( CMD_RASTERPOS4IV ); |
||
6737 | trWritePointer( (void *)v ); |
||
6738 | trFileFlush(); |
||
6739 | trWriteArrayi( 4, v ); |
||
6740 | |||
6741 | if( trCtx()->doExec ) { |
||
6742 | trGetDispatch()->RasterPos4iv( v ); |
||
6743 | trError(); |
||
6744 | } |
||
6745 | } |
||
6746 | |||
6747 | |||
6748 | GLAPI void GLAPIENTRY trRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w ) { |
||
6749 | trWriteCMD( CMD_RASTERPOS4S ); |
||
6750 | trWrites( x ); |
||
6751 | trWrites( y ); |
||
6752 | trWrites( z ); |
||
6753 | trWrites( w ); |
||
6754 | |||
6755 | if( trCtx()->doExec ) { |
||
6756 | trGetDispatch()->RasterPos4s( x, y, z, w ); |
||
6757 | trError(); |
||
6758 | } |
||
6759 | } |
||
6760 | |||
6761 | |||
6762 | GLAPI void GLAPIENTRY trRasterPos4sv( const GLshort *v ) { |
||
6763 | trWriteCMD( CMD_RASTERPOS4SV ); |
||
6764 | trWritePointer( (void *)v ); |
||
6765 | trFileFlush(); |
||
6766 | trWriteArrays( 4, v ); |
||
6767 | |||
6768 | if( trCtx()->doExec ) { |
||
6769 | trGetDispatch()->RasterPos4sv( v ); |
||
6770 | trError(); |
||
6771 | } |
||
6772 | } |
||
6773 | |||
6774 | |||
6775 | GLAPI void GLAPIENTRY trReadBuffer( GLenum mode ) { |
||
6776 | trWriteCMD( CMD_READBUFFER ); |
||
6777 | trWriteEnum( mode ); |
||
6778 | |||
6779 | if( trCtx()->doExec ) { |
||
6780 | trGetDispatch()->ReadBuffer( mode ); |
||
6781 | trError(); |
||
6782 | } |
||
6783 | } |
||
6784 | |||
6785 | |||
6786 | GLAPI void GLAPIENTRY trReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) { |
||
6787 | GLint pixelsize; |
||
6788 | |||
6789 | trWriteCMD( CMD_READPIXELS ); |
||
6790 | trWritei( x ); |
||
6791 | trWritei( y ); |
||
6792 | trWriteSizei( width ); |
||
6793 | trWriteSizei( height ); |
||
6794 | trWriteEnum( format ); |
||
6795 | trWriteEnum( type ); |
||
6796 | trWritePointer( (void *)pixels ); |
||
6797 | trFileFlush(); |
||
6798 | |||
6799 | pixelsize = trGetPixelSize( format, type ); |
||
6800 | if( trCtx()->doExec ) { |
||
6801 | trGetDispatch()->ReadPixels( x, y, width, height, format, type, pixels ); |
||
6802 | trError(); |
||
6803 | } |
||
6804 | } |
||
6805 | |||
6806 | |||
6807 | GLAPI void GLAPIENTRY trRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) { |
||
6808 | trWriteCMD( CMD_RECTD ); |
||
6809 | trWrited( x1 ); |
||
6810 | trWrited( y1 ); |
||
6811 | trWrited( x2 ); |
||
6812 | trWrited( y2 ); |
||
6813 | |||
6814 | if( trCtx()->doExec ) { |
||
6815 | trGetDispatch()->Rectd( x1, y1, x2, y2 ); |
||
6816 | trError(); |
||
6817 | } |
||
6818 | } |
||
6819 | |||
6820 | |||
6821 | GLAPI void GLAPIENTRY trRectdv( const GLdouble *v1, const GLdouble *v2 ) { |
||
6822 | trWriteCMD( CMD_RECTDV ); |
||
6823 | trWritePointer( (void *)v1 ); |
||
6824 | trFileFlush(); |
||
6825 | trWriteArrayd( 2, v1 ); |
||
6826 | |||
6827 | trWritePointer( (void *)v2 ); |
||
6828 | trFileFlush(); |
||
6829 | trWriteArrayd( 2, v2 ); |
||
6830 | |||
6831 | if( trCtx()->doExec ) { |
||
6832 | trGetDispatch()->Rectdv( v1, v2 ); |
||
6833 | trError(); |
||
6834 | } |
||
6835 | } |
||
6836 | |||
6837 | |||
6838 | GLAPI void GLAPIENTRY trRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) { |
||
6839 | trWriteCMD( CMD_RECTF ); |
||
6840 | trWritef( x1 ); |
||
6841 | trWritef( y1 ); |
||
6842 | trWritef( x2 ); |
||
6843 | trWritef( y2 ); |
||
6844 | |||
6845 | if( trCtx()->doExec ) { |
||
6846 | trGetDispatch()->Rectf( x1, y1, x2, y2 ); |
||
6847 | trError(); |
||
6848 | } |
||
6849 | } |
||
6850 | |||
6851 | |||
6852 | GLAPI void GLAPIENTRY trRectfv( const GLfloat *v1, const GLfloat *v2 ) { |
||
6853 | trWriteCMD( CMD_RECTFV ); |
||
6854 | trWritePointer( (void *)v1 ); |
||
6855 | trFileFlush(); |
||
6856 | trWriteArrayf( 2, v1 ); |
||
6857 | |||
6858 | trWritePointer( (void *)v2 ); |
||
6859 | trFileFlush(); |
||
6860 | trWriteArrayf( 2, v2 ); |
||
6861 | |||
6862 | if( trCtx()->doExec ) { |
||
6863 | trGetDispatch()->Rectfv( v1, v2 ); |
||
6864 | trError(); |
||
6865 | } |
||
6866 | } |
||
6867 | |||
6868 | |||
6869 | GLAPI void GLAPIENTRY trRecti( GLint x1, GLint y1, GLint x2, GLint y2 ) { |
||
6870 | trWriteCMD( CMD_RECTI ); |
||
6871 | trWritei( x1 ); |
||
6872 | trWritei( y1 ); |
||
6873 | trWritei( x2 ); |
||
6874 | trWritei( y2 ); |
||
6875 | |||
6876 | if( trCtx()->doExec ) { |
||
6877 | trGetDispatch()->Recti( x1, y1, x2, y2 ); |
||
6878 | trError(); |
||
6879 | } |
||
6880 | } |
||
6881 | |||
6882 | |||
6883 | GLAPI void GLAPIENTRY trRectiv( const GLint *v1, const GLint *v2 ) { |
||
6884 | trWriteCMD( CMD_RECTIV ); |
||
6885 | trWritePointer( (void *)v1 ); |
||
6886 | trFileFlush(); |
||
6887 | trWriteArrayi( 2, v1 ); |
||
6888 | |||
6889 | trWritePointer( (void *)v2 ); |
||
6890 | trFileFlush(); |
||
6891 | trWriteArrayi( 2, v2 ); |
||
6892 | |||
6893 | if( trCtx()->doExec ) { |
||
6894 | trGetDispatch()->Rectiv( v1, v2 ); |
||
6895 | trError(); |
||
6896 | } |
||
6897 | } |
||
6898 | |||
6899 | |||
6900 | GLAPI void GLAPIENTRY trRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) { |
||
6901 | trWriteCMD( CMD_RECTS ); |
||
6902 | trWrites( x1 ); |
||
6903 | trWrites( y1 ); |
||
6904 | trWrites( x2 ); |
||
6905 | trWrites( y2 ); |
||
6906 | |||
6907 | if( trCtx()->doExec ) { |
||
6908 | trGetDispatch()->Rects( x1, y1, x2, y2 ); |
||
6909 | trError(); |
||
6910 | } |
||
6911 | } |
||
6912 | |||
6913 | |||
6914 | GLAPI void GLAPIENTRY trRectsv( const GLshort *v1, const GLshort *v2 ) { |
||
6915 | trWriteCMD( CMD_RECTSV ); |
||
6916 | trWritePointer( (void *)v1 ); |
||
6917 | trFileFlush(); |
||
6918 | trWriteArrays( 2, v1 ); |
||
6919 | |||
6920 | trWritePointer( (void *)v2 ); |
||
6921 | trFileFlush(); |
||
6922 | trWriteArrays( 2, v2 ); |
||
6923 | |||
6924 | if( trCtx()->doExec ) { |
||
6925 | trGetDispatch()->Rectsv( v1, v2 ); |
||
6926 | trError(); |
||
6927 | } |
||
6928 | } |
||
6929 | |||
6930 | |||
6931 | GLAPI GLint GLAPIENTRY trRenderMode( GLenum mode ) { |
||
6932 | GLint retval; |
||
6933 | |||
6934 | trWriteCMD( CMD_RENDERMODE ); |
||
6935 | trWriteEnum( mode ); |
||
6936 | |||
6937 | if( trCtx()->doExec ) { |
||
6938 | retval = trGetDispatch()->RenderMode( mode ); |
||
6939 | trError(); |
||
6940 | } else { |
||
6941 | retval = 0; |
||
6942 | } |
||
6943 | |||
6944 | trWritei( retval ); |
||
6945 | return retval; |
||
6946 | } |
||
6947 | |||
6948 | |||
6949 | GLAPI void GLAPIENTRY trResetHistogram( GLenum target ) { |
||
6950 | trWriteCMD( CMD_RESETHISTOGRAM ); |
||
6951 | trWriteEnum( target ); |
||
6952 | |||
6953 | if( trCtx()->doExec ) { |
||
6954 | trGetDispatch()->ResetHistogram( target ); |
||
6955 | trError(); |
||
6956 | } |
||
6957 | } |
||
6958 | |||
6959 | |||
6960 | GLAPI void GLAPIENTRY trResetMinmax( GLenum target ) { |
||
6961 | trWriteCMD( CMD_RESETMINMAX ); |
||
6962 | trWriteEnum( target ); |
||
6963 | |||
6964 | if( trCtx()->doExec ) { |
||
6965 | trGetDispatch()->ResetMinmax( target ); |
||
6966 | trError(); |
||
6967 | } |
||
6968 | } |
||
6969 | |||
6970 | |||
6971 | GLAPI void GLAPIENTRY trResizeBuffersMESA( void ) { |
||
6972 | trWriteCMD( CMD_RESIZEBUFFERSMESA ); |
||
6973 | |||
6974 | if( trCtx()->doExec ) { |
||
6975 | trGetDispatch()->ResizeBuffersMESA( ); |
||
6976 | trError(); |
||
6977 | } |
||
6978 | } |
||
6979 | |||
6980 | |||
6981 | GLAPI void GLAPIENTRY trRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) { |
||
6982 | trWriteCMD( CMD_ROTATED ); |
||
6983 | trWrited( angle ); |
||
6984 | trWrited( x ); |
||
6985 | trWrited( y ); |
||
6986 | trWrited( z ); |
||
6987 | |||
6988 | if( trCtx()->doExec ) { |
||
6989 | trGetDispatch()->Rotated( angle, x, y, z ); |
||
6990 | trError(); |
||
6991 | } |
||
6992 | } |
||
6993 | |||
6994 | |||
6995 | GLAPI void GLAPIENTRY trRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) { |
||
6996 | trWriteCMD( CMD_ROTATEF ); |
||
6997 | trWritef( angle ); |
||
6998 | trWritef( x ); |
||
6999 | trWritef( y ); |
||
7000 | trWritef( z ); |
||
7001 | |||
7002 | if( trCtx()->doExec ) { |
||
7003 | trGetDispatch()->Rotatef( angle, x, y, z ); |
||
7004 | trError(); |
||
7005 | } |
||
7006 | } |
||
7007 | |||
7008 | |||
7009 | GLAPI void GLAPIENTRY trScaled( GLdouble x, GLdouble y, GLdouble z ) { |
||
7010 | trWriteCMD( CMD_SCALED ); |
||
7011 | trWrited( x ); |
||
7012 | trWrited( y ); |
||
7013 | trWrited( z ); |
||
7014 | |||
7015 | if( trCtx()->doExec ) { |
||
7016 | trGetDispatch()->Scaled( x, y, z ); |
||
7017 | trError(); |
||
7018 | } |
||
7019 | } |
||
7020 | |||
7021 | |||
7022 | GLAPI void GLAPIENTRY trScalef( GLfloat x, GLfloat y, GLfloat z ) { |
||
7023 | trWriteCMD( CMD_SCALEF ); |
||
7024 | trWritef( x ); |
||
7025 | trWritef( y ); |
||
7026 | trWritef( z ); |
||
7027 | |||
7028 | if( trCtx()->doExec ) { |
||
7029 | trGetDispatch()->Scalef( x, y, z ); |
||
7030 | trError(); |
||
7031 | } |
||
7032 | } |
||
7033 | |||
7034 | |||
7035 | GLAPI void GLAPIENTRY trScissor( GLint x, GLint y, GLsizei width, GLsizei height) { |
||
7036 | trWriteCMD( CMD_SCISSOR ); |
||
7037 | trWritei( x ); |
||
7038 | trWritei( y ); |
||
7039 | trWriteSizei( width ); |
||
7040 | trWriteSizei( height ); |
||
7041 | |||
7042 | if( trCtx()->doExec ) { |
||
7043 | trGetDispatch()->Scissor( x, y, width, height ); |
||
7044 | trError(); |
||
7045 | } |
||
7046 | } |
||
7047 | |||
7048 | |||
7049 | GLAPI void GLAPIENTRY trSelectBuffer( GLsizei size, GLuint *buffer ) { |
||
7050 | trWriteCMD( CMD_SELECTBUFFER ); |
||
7051 | trWriteSizei( size ); |
||
7052 | trWritePointer( (void *)buffer ); |
||
7053 | trFileFlush(); |
||
7054 | |||
7055 | if( trCtx()->doExec ) { |
||
7056 | trGetDispatch()->SelectBuffer( size, buffer ); |
||
7057 | trError(); |
||
7058 | } |
||
7059 | } |
||
7060 | |||
7061 | |||
7062 | GLAPI void GLAPIENTRY trSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column ) { |
||
7063 | GLint pixelsize; |
||
7064 | |||
7065 | trWriteCMD( CMD_SEPARABLEFILTER2D ); |
||
7066 | trWriteEnum( target ); |
||
7067 | trWriteEnum( internalformat ); |
||
7068 | trWriteSizei( width ); |
||
7069 | trWriteSizei( height ); |
||
7070 | trWriteEnum( format ); |
||
7071 | trWriteEnum( type ); |
||
7072 | trWritePointer( (void *)row ); |
||
7073 | trFileFlush(); |
||
7074 | trWritePointer( (void *)column ); |
||
7075 | trFileFlush(); |
||
7076 | |||
7077 | pixelsize = trGetPixelSize( format, type ); |
||
7078 | trWriteTypeArray( type, width, pixelsize, 0, row ); |
||
7079 | trWriteTypeArray( type, height, pixelsize, 0, column ); |
||
7080 | |||
7081 | if( trCtx()->doExec ) { |
||
7082 | trGetDispatch()->SeparableFilter2D( target, internalformat, width, height, format, type, row, column ); |
||
7083 | trError(); |
||
7084 | } |
||
7085 | } |
||
7086 | |||
7087 | |||
7088 | GLAPI void GLAPIENTRY trShadeModel( GLenum mode ) { |
||
7089 | trWriteCMD( CMD_SHADEMODEL ); |
||
7090 | trWriteEnum( mode ); |
||
7091 | |||
7092 | if( trCtx()->doExec ) { |
||
7093 | trGetDispatch()->ShadeModel( mode ); |
||
7094 | trError(); |
||
7095 | } |
||
7096 | } |
||
7097 | |||
7098 | |||
7099 | GLAPI void GLAPIENTRY trStencilFunc( GLenum func, GLint ref, GLuint mask ) { |
||
7100 | trWriteCMD( CMD_STENCILFUNC ); |
||
7101 | trWriteEnum( func ); |
||
7102 | trWritei( ref ); |
||
7103 | trWriteui( mask ); |
||
7104 | |||
7105 | if( trCtx()->doExec ) { |
||
7106 | trGetDispatch()->StencilFunc( func, ref, mask ); |
||
7107 | trError(); |
||
7108 | } |
||
7109 | } |
||
7110 | |||
7111 | |||
7112 | GLAPI void GLAPIENTRY trStencilMask( GLuint mask ) { |
||
7113 | trWriteCMD( CMD_STENCILMASK ); |
||
7114 | trWriteui( mask ); |
||
7115 | |||
7116 | if( trCtx()->doExec ) { |
||
7117 | trGetDispatch()->StencilMask( mask ); |
||
7118 | trError(); |
||
7119 | } |
||
7120 | } |
||
7121 | |||
7122 | |||
7123 | GLAPI void GLAPIENTRY trStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) { |
||
7124 | trWriteCMD( CMD_STENCILOP ); |
||
7125 | trWriteEnum( fail ); |
||
7126 | trWriteEnum( zfail ); |
||
7127 | trWriteEnum( zpass ); |
||
7128 | |||
7129 | if( trCtx()->doExec ) { |
||
7130 | trGetDispatch()->StencilOp( fail, zfail, zpass ); |
||
7131 | trError(); |
||
7132 | } |
||
7133 | } |
||
7134 | |||
7135 | |||
7136 | GLAPI void GLAPIENTRY trTexCoord1d( GLdouble s ) { |
||
7137 | trWriteCMD( CMD_TEXCOORD1D ); |
||
7138 | trWrited( s ); |
||
7139 | |||
7140 | if( trCtx()->doExec ) { |
||
7141 | trGetDispatch()->TexCoord1d( s ); |
||
7142 | trError(); |
||
7143 | } |
||
7144 | } |
||
7145 | |||
7146 | |||
7147 | GLAPI void GLAPIENTRY trTexCoord1dv( const GLdouble *v ) { |
||
7148 | trWriteCMD( CMD_TEXCOORD1DV ); |
||
7149 | trWritePointer( (void *)v ); |
||
7150 | trFileFlush(); |
||
7151 | trWrited( v[0] ); |
||
7152 | |||
7153 | if( trCtx()->doExec ) { |
||
7154 | trGetDispatch()->TexCoord1dv( v ); |
||
7155 | trError(); |
||
7156 | } |
||
7157 | } |
||
7158 | |||
7159 | |||
7160 | GLAPI void GLAPIENTRY trTexCoord1f( GLfloat s ) { |
||
7161 | trWriteCMD( CMD_TEXCOORD1F ); |
||
7162 | trWritef( s ); |
||
7163 | |||
7164 | if( trCtx()->doExec ) { |
||
7165 | trGetDispatch()->TexCoord1f( s ); |
||
7166 | trError(); |
||
7167 | } |
||
7168 | } |
||
7169 | |||
7170 | |||
7171 | GLAPI void GLAPIENTRY trTexCoord1fv( const GLfloat *v ) { |
||
7172 | trWriteCMD( CMD_TEXCOORD1FV ); |
||
7173 | trWritePointer( (void *)v ); |
||
7174 | trFileFlush(); |
||
7175 | trWritef( v[0] ); |
||
7176 | |||
7177 | if( trCtx()->doExec ) { |
||
7178 | trGetDispatch()->TexCoord1fv( v ); |
||
7179 | trError(); |
||
7180 | } |
||
7181 | } |
||
7182 | |||
7183 | |||
7184 | GLAPI void GLAPIENTRY trTexCoord1i( GLint s ) { |
||
7185 | trWriteCMD( CMD_TEXCOORD1I ); |
||
7186 | trWritei( s ); |
||
7187 | |||
7188 | if( trCtx()->doExec ) { |
||
7189 | trGetDispatch()->TexCoord1i( s ); |
||
7190 | trError(); |
||
7191 | } |
||
7192 | } |
||
7193 | |||
7194 | |||
7195 | GLAPI void GLAPIENTRY trTexCoord1iv( const GLint *v ) { |
||
7196 | trWriteCMD( CMD_TEXCOORD1IV ); |
||
7197 | trWritePointer( (void *)v ); |
||
7198 | trFileFlush(); |
||
7199 | trWritei( v[0] ); |
||
7200 | |||
7201 | if( trCtx()->doExec ) { |
||
7202 | trGetDispatch()->TexCoord1iv( v ); |
||
7203 | trError(); |
||
7204 | } |
||
7205 | } |
||
7206 | |||
7207 | |||
7208 | GLAPI void GLAPIENTRY trTexCoord1s( GLshort s ) { |
||
7209 | trWriteCMD( CMD_TEXCOORD1S ); |
||
7210 | trWrites( s ); |
||
7211 | |||
7212 | if( trCtx()->doExec ) { |
||
7213 | trGetDispatch()->TexCoord1s( s ); |
||
7214 | trError(); |
||
7215 | } |
||
7216 | } |
||
7217 | |||
7218 | |||
7219 | GLAPI void GLAPIENTRY trTexCoord1sv( const GLshort *v ) { |
||
7220 | trWriteCMD( CMD_TEXCOORD1SV ); |
||
7221 | trWritePointer( (void *)v ); |
||
7222 | trFileFlush(); |
||
7223 | trWrites( v[0] ); |
||
7224 | |||
7225 | if( trCtx()->doExec ) { |
||
7226 | trGetDispatch()->TexCoord1sv( v ); |
||
7227 | trError(); |
||
7228 | } |
||
7229 | } |
||
7230 | |||
7231 | |||
7232 | GLAPI void GLAPIENTRY trTexCoord2d( GLdouble s, GLdouble t ) { |
||
7233 | trWriteCMD( CMD_TEXCOORD2D ); |
||
7234 | trWrited( s ); |
||
7235 | trWrited( t ); |
||
7236 | |||
7237 | if( trCtx()->doExec ) { |
||
7238 | trGetDispatch()->TexCoord2d( s, t ); |
||
7239 | trError(); |
||
7240 | } |
||
7241 | } |
||
7242 | |||
7243 | |||
7244 | GLAPI void GLAPIENTRY trTexCoord2dv( const GLdouble *v ) { |
||
7245 | trWriteCMD( CMD_TEXCOORD2DV ); |
||
7246 | trWritePointer( (void *)v ); |
||
7247 | trFileFlush(); |
||
7248 | trWriteArrayd( 2, v ); |
||
7249 | |||
7250 | if( trCtx()->doExec ) { |
||
7251 | trGetDispatch()->TexCoord2dv( v ); |
||
7252 | trError(); |
||
7253 | } |
||
7254 | } |
||
7255 | |||
7256 | |||
7257 | GLAPI void GLAPIENTRY trTexCoord2f( GLfloat s, GLfloat t ) { |
||
7258 | trWriteCMD( CMD_TEXCOORD2F ); |
||
7259 | trWritef( s ); |
||
7260 | trWritef( t ); |
||
7261 | |||
7262 | if( trCtx()->doExec ) { |
||
7263 | trGetDispatch()->TexCoord2f( s, t ); |
||
7264 | trError(); |
||
7265 | } |
||
7266 | } |
||
7267 | |||
7268 | |||
7269 | GLAPI void GLAPIENTRY trTexCoord2fv( const GLfloat *v ) { |
||
7270 | trWriteCMD( CMD_TEXCOORD2FV ); |
||
7271 | trWritePointer( (void *)v ); |
||
7272 | trFileFlush(); |
||
7273 | trWriteArrayf( 2, v ); |
||
7274 | |||
7275 | if( trCtx()->doExec ) { |
||
7276 | trGetDispatch()->TexCoord2fv( v ); |
||
7277 | trError(); |
||
7278 | } |
||
7279 | } |
||
7280 | |||
7281 | |||
7282 | GLAPI void GLAPIENTRY trTexCoord2i( GLint s, GLint t ) { |
||
7283 | trWriteCMD( CMD_TEXCOORD2I ); |
||
7284 | trWritei( s ); |
||
7285 | trWritei( t ); |
||
7286 | |||
7287 | if( trCtx()->doExec ) { |
||
7288 | trGetDispatch()->TexCoord2i( s, t ); |
||
7289 | trError(); |
||
7290 | } |
||
7291 | } |
||
7292 | |||
7293 | |||
7294 | GLAPI void GLAPIENTRY trTexCoord2iv( const GLint *v ) { |
||
7295 | trWriteCMD( CMD_TEXCOORD2IV ); |
||
7296 | trWritePointer( (void *)v ); |
||
7297 | trFileFlush(); |
||
7298 | trWriteArrayi( 2, v ); |
||
7299 | |||
7300 | if( trCtx()->doExec ) { |
||
7301 | trGetDispatch()->TexCoord2iv( v ); |
||
7302 | trError(); |
||
7303 | } |
||
7304 | } |
||
7305 | |||
7306 | |||
7307 | GLAPI void GLAPIENTRY trTexCoord2s( GLshort s, GLshort t ) { |
||
7308 | trWriteCMD( CMD_TEXCOORD2S ); |
||
7309 | trWrites( s ); |
||
7310 | trWrites( t ); |
||
7311 | |||
7312 | if( trCtx()->doExec ) { |
||
7313 | trGetDispatch()->TexCoord2s( s, t ); |
||
7314 | trError(); |
||
7315 | } |
||
7316 | } |
||
7317 | |||
7318 | |||
7319 | GLAPI void GLAPIENTRY trTexCoord2sv( const GLshort *v ) { |
||
7320 | trWriteCMD( CMD_TEXCOORD2SV ); |
||
7321 | trWritePointer( (void *)v ); |
||
7322 | trFileFlush(); |
||
7323 | trWriteArrays( 2, v ); |
||
7324 | |||
7325 | if( trCtx()->doExec ) { |
||
7326 | trGetDispatch()->TexCoord2sv( v ); |
||
7327 | trError(); |
||
7328 | } |
||
7329 | } |
||
7330 | |||
7331 | |||
7332 | GLAPI void GLAPIENTRY trTexCoord3d( GLdouble s, GLdouble t, GLdouble r ) { |
||
7333 | trWriteCMD( CMD_TEXCOORD3D ); |
||
7334 | trWrited( s ); |
||
7335 | trWrited( t ); |
||
7336 | trWrited( r ); |
||
7337 | |||
7338 | if( trCtx()->doExec ) { |
||
7339 | trGetDispatch()->TexCoord3d( s, t, r ); |
||
7340 | trError(); |
||
7341 | } |
||
7342 | } |
||
7343 | |||
7344 | |||
7345 | GLAPI void GLAPIENTRY trTexCoord3dv( const GLdouble *v ) { |
||
7346 | trWriteCMD( CMD_TEXCOORD3DV ); |
||
7347 | trWritePointer( (void *)v ); |
||
7348 | trFileFlush(); |
||
7349 | trWriteArrayd( 3, v ); |
||
7350 | |||
7351 | if( trCtx()->doExec ) { |
||
7352 | trGetDispatch()->TexCoord3dv( v ); |
||
7353 | trError(); |
||
7354 | } |
||
7355 | } |
||
7356 | |||
7357 | |||
7358 | GLAPI void GLAPIENTRY trTexCoord3f( GLfloat s, GLfloat t, GLfloat r ) { |
||
7359 | trWriteCMD( CMD_TEXCOORD3F ); |
||
7360 | trWritef( s ); |
||
7361 | trWritef( t ); |
||
7362 | trWritef( r ); |
||
7363 | |||
7364 | if( trCtx()->doExec ) { |
||
7365 | trGetDispatch()->TexCoord3f( s, t, r ); |
||
7366 | trError(); |
||
7367 | } |
||
7368 | } |
||
7369 | |||
7370 | |||
7371 | GLAPI void GLAPIENTRY trTexCoord3fv( const GLfloat *v ) { |
||
7372 | trWriteCMD( CMD_TEXCOORD3FV ); |
||
7373 | trWritePointer( (void *)v ); |
||
7374 | trFileFlush(); |
||
7375 | trWriteArrayf( 3, v ); |
||
7376 | |||
7377 | if( trCtx()->doExec ) { |
||
7378 | trGetDispatch()->TexCoord3fv( v ); |
||
7379 | trError(); |
||
7380 | } |
||
7381 | } |
||
7382 | |||
7383 | |||
7384 | GLAPI void GLAPIENTRY trTexCoord3i( GLint s, GLint t, GLint r ) { |
||
7385 | trWriteCMD( CMD_TEXCOORD3I ); |
||
7386 | trWritei( s ); |
||
7387 | trWritei( t ); |
||
7388 | trWritei( r ); |
||
7389 | |||
7390 | if( trCtx()->doExec ) { |
||
7391 | trGetDispatch()->TexCoord3i( s, t, r ); |
||
7392 | trError(); |
||
7393 | } |
||
7394 | } |
||
7395 | |||
7396 | |||
7397 | GLAPI void GLAPIENTRY trTexCoord3iv( const GLint *v ) { |
||
7398 | trWriteCMD( CMD_TEXCOORD3IV ); |
||
7399 | trWritePointer( (void *)v ); |
||
7400 | trFileFlush(); |
||
7401 | trWriteArrayi( 3, v ); |
||
7402 | |||
7403 | if( trCtx()->doExec ) { |
||
7404 | trGetDispatch()->TexCoord3iv( v ); |
||
7405 | trError(); |
||
7406 | } |
||
7407 | } |
||
7408 | |||
7409 | |||
7410 | GLAPI void GLAPIENTRY trTexCoord3s( GLshort s, GLshort t, GLshort r ) { |
||
7411 | trWriteCMD( CMD_TEXCOORD3S ); |
||
7412 | trWrites( s ); |
||
7413 | trWrites( t ); |
||
7414 | trWrites( r ); |
||
7415 | |||
7416 | if( trCtx()->doExec ) { |
||
7417 | trGetDispatch()->TexCoord3s( s, t, r ); |
||
7418 | trError(); |
||
7419 | } |
||
7420 | } |
||
7421 | |||
7422 | |||
7423 | GLAPI void GLAPIENTRY trTexCoord3sv( const GLshort *v ) { |
||
7424 | trWriteCMD( CMD_TEXCOORD3SV ); |
||
7425 | trWritePointer( (void *)v ); |
||
7426 | trFileFlush(); |
||
7427 | trWriteArrays( 3, v ); |
||
7428 | |||
7429 | if( trCtx()->doExec ) { |
||
7430 | trGetDispatch()->TexCoord3sv( v ); |
||
7431 | trError(); |
||
7432 | } |
||
7433 | } |
||
7434 | |||
7435 | |||
7436 | GLAPI void GLAPIENTRY trTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { |
||
7437 | trWriteCMD( CMD_TEXCOORD4D ); |
||
7438 | trWrited( s ); |
||
7439 | trWrited( t ); |
||
7440 | trWrited( r ); |
||
7441 | trWrited( q ); |
||
7442 | |||
7443 | if( trCtx()->doExec ) { |
||
7444 | trGetDispatch()->TexCoord4d( s, t, r, q ); |
||
7445 | trError(); |
||
7446 | } |
||
7447 | } |
||
7448 | |||
7449 | |||
7450 | GLAPI void GLAPIENTRY trTexCoord4dv( const GLdouble *v ) { |
||
7451 | trWriteCMD( CMD_TEXCOORD4DV ); |
||
7452 | trWritePointer( (void *)v ); |
||
7453 | trFileFlush(); |
||
7454 | trWriteArrayd( 4, v ); |
||
7455 | |||
7456 | if( trCtx()->doExec ) { |
||
7457 | trGetDispatch()->TexCoord4dv( v ); |
||
7458 | trError(); |
||
7459 | } |
||
7460 | } |
||
7461 | |||
7462 | |||
7463 | GLAPI void GLAPIENTRY trTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { |
||
7464 | trWriteCMD( CMD_TEXCOORD4F ); |
||
7465 | trWritef( s ); |
||
7466 | trWritef( t ); |
||
7467 | trWritef( r ); |
||
7468 | trWritef( q ); |
||
7469 | |||
7470 | if( trCtx()->doExec ) { |
||
7471 | trGetDispatch()->TexCoord4f( s, t, r, q ); |
||
7472 | trError(); |
||
7473 | } |
||
7474 | } |
||
7475 | |||
7476 | |||
7477 | GLAPI void GLAPIENTRY trTexCoord4fv( const GLfloat *v ) { |
||
7478 | trWriteCMD( CMD_TEXCOORD4FV ); |
||
7479 | trWritePointer( (void *)v ); |
||
7480 | trFileFlush(); |
||
7481 | trWriteArrayf( 4, v ); |
||
7482 | |||
7483 | if( trCtx()->doExec ) { |
||
7484 | trGetDispatch()->TexCoord4fv( v ); |
||
7485 | trError(); |
||
7486 | } |
||
7487 | } |
||
7488 | |||
7489 | |||
7490 | GLAPI void GLAPIENTRY trTexCoord4i( GLint s, GLint t, GLint r, GLint q ) { |
||
7491 | trWriteCMD( CMD_TEXCOORD4I ); |
||
7492 | trWritei( s ); |
||
7493 | trWritei( t ); |
||
7494 | trWritei( r ); |
||
7495 | trWritei( q ); |
||
7496 | |||
7497 | if( trCtx()->doExec ) { |
||
7498 | trGetDispatch()->TexCoord4i( s, t, r, q ); |
||
7499 | trError(); |
||
7500 | } |
||
7501 | } |
||
7502 | |||
7503 | |||
7504 | GLAPI void GLAPIENTRY trTexCoord4iv( const GLint *v ) { |
||
7505 | trWriteCMD( CMD_TEXCOORD4IV ); |
||
7506 | trWritePointer( (void *)v ); |
||
7507 | trFileFlush(); |
||
7508 | trWriteArrayi( 4, v ); |
||
7509 | |||
7510 | if( trCtx()->doExec ) { |
||
7511 | trGetDispatch()->TexCoord4iv( v ); |
||
7512 | trError(); |
||
7513 | } |
||
7514 | } |
||
7515 | |||
7516 | |||
7517 | GLAPI void GLAPIENTRY trTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q ) { |
||
7518 | trWriteCMD( CMD_TEXCOORD4S ); |
||
7519 | trWrites( s ); |
||
7520 | trWrites( t ); |
||
7521 | trWrites( r ); |
||
7522 | trWrites( q ); |
||
7523 | |||
7524 | if( trCtx()->doExec ) { |
||
7525 | trGetDispatch()->TexCoord4s( s, t, r, q ); |
||
7526 | trError(); |
||
7527 | } |
||
7528 | } |
||
7529 | |||
7530 | |||
7531 | GLAPI void GLAPIENTRY trTexCoord4sv( const GLshort *v ) { |
||
7532 | trWriteCMD( CMD_TEXCOORD4SV ); |
||
7533 | trWritePointer( (void *)v ); |
||
7534 | trFileFlush(); |
||
7535 | trWriteArrays( 4, v ); |
||
7536 | |||
7537 | if( trCtx()->doExec ) { |
||
7538 | trGetDispatch()->TexCoord4sv( v ); |
||
7539 | trError(); |
||
7540 | } |
||
7541 | } |
||
7542 | |||
7543 | |||
7544 | GLAPI void GLAPIENTRY trTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */ |
||
7545 | trWriteCMD( CMD_TEXCOORDPOINTEREXT ); |
||
7546 | trWritei( size ); |
||
7547 | trWriteEnum( type ); |
||
7548 | trWriteSizei( stride ); |
||
7549 | trWriteSizei( count ); |
||
7550 | trWritePointer( (void *)ptr ); |
||
7551 | trFileFlush(); |
||
7552 | |||
7553 | if( trCtx()->doExec ) { |
||
7554 | trGetDispatch()->TexCoordPointerEXT( size, type, stride, count, ptr ); |
||
7555 | trError(); |
||
7556 | } |
||
7557 | } |
||
7558 | |||
7559 | |||
7560 | GLAPI void GLAPIENTRY trTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) { /* TODO */ |
||
7561 | trace_context_t * tctx; |
||
7562 | |||
7563 | trWriteCMD( CMD_TEXCOORDPOINTER ); |
||
7564 | trWritei( size ); |
||
7565 | trWriteEnum( type ); |
||
7566 | trWriteSizei( stride ); |
||
7567 | trWritePointer( (void *)ptr ); |
||
7568 | trFileFlush(); |
||
7569 | |||
7570 | if( tctx->doExec ) { |
||
7571 | trGetDispatch()->TexCoordPointer( size, type, stride, ptr ); |
||
7572 | trError(); |
||
7573 | } |
||
7574 | } |
||
7575 | |||
7576 | |||
7577 | GLAPI void GLAPIENTRY trTexEnvf( GLenum target, GLenum pname, GLfloat param ) { |
||
7578 | trWriteCMD( CMD_TEXENVF ); |
||
7579 | trWriteEnum( target ); |
||
7580 | trWriteEnum( pname ); |
||
7581 | trWritef( param ); |
||
7582 | |||
7583 | if( trCtx()->doExec ) { |
||
7584 | trGetDispatch()->TexEnvf( target, pname, param ); |
||
7585 | trError(); |
||
7586 | } |
||
7587 | } |
||
7588 | |||
7589 | |||
7590 | GLAPI void GLAPIENTRY trTexEnvfv( GLenum target, GLenum pname, const GLfloat *params ) { |
||
7591 | trWriteCMD( CMD_TEXENVFV ); |
||
7592 | trWriteEnum( target ); |
||
7593 | trWriteEnum( pname ); |
||
7594 | trWritePointer( (void *)params ); |
||
7595 | trFileFlush(); |
||
7596 | |||
7597 | switch( pname ) { |
||
7598 | case GL_TEXTURE_ENV_MODE: |
||
7599 | trWritef( params[0] ); |
||
7600 | break; |
||
7601 | case GL_TEXTURE_ENV_COLOR: |
||
7602 | trWriteArrayf( 4, params ); |
||
7603 | break; |
||
7604 | default: |
||
7605 | /* The 2nd pass should catch this */ |
||
7606 | break; |
||
7607 | } |
||
7608 | |||
7609 | if( trCtx()->doExec ) { |
||
7610 | trGetDispatch()->TexEnvfv( target, pname, params ); |
||
7611 | trError(); |
||
7612 | } |
||
7613 | } |
||
7614 | |||
7615 | |||
7616 | GLAPI void GLAPIENTRY trTexEnvi( GLenum target, GLenum pname, GLint param ) { |
||
7617 | trWriteCMD( CMD_TEXENVI ); |
||
7618 | trWriteEnum( target ); |
||
7619 | trWriteEnum( pname ); |
||
7620 | trWritei( param ); |
||
7621 | |||
7622 | if( trCtx()->doExec ) { |
||
7623 | trGetDispatch()->TexEnvi( target, pname, param ); |
||
7624 | trError(); |
||
7625 | } |
||
7626 | } |
||
7627 | |||
7628 | |||
7629 | GLAPI void GLAPIENTRY trTexEnviv( GLenum target, GLenum pname, const GLint *params ) { |
||
7630 | trWriteCMD( CMD_TEXENVIV ); |
||
7631 | trWriteEnum( target ); |
||
7632 | trWriteEnum( pname ); |
||
7633 | trWritePointer( (void *)params ); |
||
7634 | trFileFlush(); |
||
7635 | |||
7636 | switch( pname ) { |
||
7637 | case GL_TEXTURE_ENV_MODE: |
||
7638 | trWritei( params[0] ); |
||
7639 | break; |
||
7640 | case GL_TEXTURE_ENV_COLOR: |
||
7641 | trWriteArrayi( 4, params ); |
||
7642 | break; |
||
7643 | default: |
||
7644 | /* The 2nd pass should catch this */ |
||
7645 | break; |
||
7646 | } |
||
7647 | |||
7648 | if( trCtx()->doExec ) { |
||
7649 | trGetDispatch()->TexEnviv( target, pname, params ); |
||
7650 | trError(); |
||
7651 | } |
||
7652 | } |
||
7653 | |||
7654 | |||
7655 | GLAPI void GLAPIENTRY trTexGend( GLenum coord, GLenum pname, GLdouble param ) { |
||
7656 | trWriteCMD( CMD_TEXGEND ); |
||
7657 | trWriteEnum( coord ); |
||
7658 | trWriteEnum( pname ); |
||
7659 | trWrited( param ); |
||
7660 | |||
7661 | if( trCtx()->doExec ) { |
||
7662 | trGetDispatch()->TexGend( coord, pname, param ); |
||
7663 | trError(); |
||
7664 | } |
||
7665 | } |
||
7666 | |||
7667 | |||
7668 | GLAPI void GLAPIENTRY trTexGendv( GLenum coord, GLenum pname, const GLdouble *params ) { |
||
7669 | trWriteCMD( CMD_TEXGENDV ); |
||
7670 | trWriteEnum( coord ); |
||
7671 | trWriteEnum( pname ); |
||
7672 | trWritePointer( (void *)params ); |
||
7673 | trFileFlush(); |
||
7674 | |||
7675 | switch( pname ) { |
||
7676 | case GL_TEXTURE_GEN_MODE: |
||
7677 | trWrited( params[0] ); |
||
7678 | break; |
||
7679 | |||
7680 | case GL_OBJECT_PLANE: |
||
7681 | case GL_EYE_PLANE: |
||
7682 | trWriteArrayd( 4, params ); |
||
7683 | break; |
||
7684 | |||
7685 | default: |
||
7686 | /* The 2nd pass should catch this. */ |
||
7687 | break; |
||
7688 | } |
||
7689 | |||
7690 | if( trCtx()->doExec ) { |
||
7691 | trGetDispatch()->TexGendv( coord, pname, params ); |
||
7692 | trError(); |
||
7693 | } |
||
7694 | } |
||
7695 | |||
7696 | |||
7697 | GLAPI void GLAPIENTRY trTexGenf( GLenum coord, GLenum pname, GLfloat param ) { |
||
7698 | trWriteCMD( CMD_TEXGENF ); |
||
7699 | trWriteEnum( coord ); |
||
7700 | trWriteEnum( pname ); |
||
7701 | trWritef( param ); |
||
7702 | |||
7703 | if( trCtx()->doExec ) { |
||
7704 | trGetDispatch()->TexGenf( coord, pname, param ); |
||
7705 | trError(); |
||
7706 | } |
||
7707 | } |
||
7708 | |||
7709 | |||
7710 | GLAPI void GLAPIENTRY trTexGenfv( GLenum coord, GLenum pname, const GLfloat *params ) { |
||
7711 | trWriteCMD( CMD_TEXGENFV ); |
||
7712 | trWriteEnum( coord ); |
||
7713 | trWriteEnum( pname ); |
||
7714 | trWritePointer( (void *)params ); |
||
7715 | trFileFlush(); |
||
7716 | |||
7717 | switch( pname ) { |
||
7718 | case GL_TEXTURE_GEN_MODE: |
||
7719 | trWritef( params[0] ); |
||
7720 | break; |
||
7721 | |||
7722 | case GL_OBJECT_PLANE: |
||
7723 | case GL_EYE_PLANE: |
||
7724 | trWriteArrayf( 4, params ); |
||
7725 | break; |
||
7726 | |||
7727 | default: |
||
7728 | /* The 2nd pass should catch this. */ |
||
7729 | break; |
||
7730 | } |
||
7731 | |||
7732 | if( trCtx()->doExec ) { |
||
7733 | trGetDispatch()->TexGenfv( coord, pname, params ); |
||
7734 | trError(); |
||
7735 | } |
||
7736 | } |
||
7737 | |||
7738 | |||
7739 | GLAPI void GLAPIENTRY trTexGeni( GLenum coord, GLenum pname, GLint param ) { |
||
7740 | trWriteCMD( CMD_TEXGENI ); |
||
7741 | trWriteEnum( coord ); |
||
7742 | trWriteEnum( pname ); |
||
7743 | trWritei( param ); |
||
7744 | |||
7745 | if( trCtx()->doExec ) { |
||
7746 | trGetDispatch()->TexGeni( coord, pname, param ); |
||
7747 | trError(); |
||
7748 | } |
||
7749 | } |
||
7750 | |||
7751 | |||
7752 | GLAPI void GLAPIENTRY trTexGeniv( GLenum coord, GLenum pname, const GLint *params ) { |
||
7753 | trWriteCMD( CMD_TEXGENIV ); |
||
7754 | trWriteEnum( coord ); |
||
7755 | trWriteEnum( pname ); |
||
7756 | trWritePointer( (void *)params ); |
||
7757 | trFileFlush(); |
||
7758 | |||
7759 | switch( pname ) { |
||
7760 | case GL_TEXTURE_GEN_MODE: |
||
7761 | trWritei( params[0] ); |
||
7762 | break; |
||
7763 | |||
7764 | case GL_OBJECT_PLANE: |
||
7765 | case GL_EYE_PLANE: |
||
7766 | trWriteArrayi( 4, params ); |
||
7767 | break; |
||
7768 | |||
7769 | default: |
||
7770 | /* The 2nd pass should catch this. */ |
||
7771 | break; |
||
7772 | } |
||
7773 | |||
7774 | if( trCtx()->doExec ) { |
||
7775 | trGetDispatch()->TexGeniv( coord, pname, params ); |
||
7776 | trError(); |
||
7777 | } |
||
7778 | } |
||
7779 | |||
7780 | |||
7781 | GLAPI void GLAPIENTRY trTexImage1D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */ |
||
7782 | GLint pixelsize; |
||
7783 | |||
7784 | trWriteCMD( CMD_TEXIMAGE1D ); |
||
7785 | trWriteEnum( target ); |
||
7786 | trWritei( level ); |
||
7787 | trWritei( internalFormat ); |
||
7788 | trWriteSizei( width ); |
||
7789 | trWritei( border ); |
||
7790 | trWriteEnum( format ); |
||
7791 | trWriteEnum( type ); |
||
7792 | trWritePointer( (void *)pixels ); |
||
7793 | trFileFlush(); |
||
7794 | |||
7795 | if( trCtx()->doExec ) { |
||
7796 | trGetDispatch()->TexImage1D( target, level, internalFormat, width, border, format, type, pixels ); |
||
7797 | trError(); |
||
7798 | } |
||
7799 | } |
||
7800 | |||
7801 | |||
7802 | GLAPI void GLAPIENTRY trTexImage2D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */ |
||
7803 | GLint pixelsize; |
||
7804 | |||
7805 | trWriteCMD( CMD_TEXIMAGE2D ); |
||
7806 | trWriteEnum( target ); |
||
7807 | trWritei( level ); |
||
7808 | trWritei( internalFormat ); |
||
7809 | trWriteSizei( width ); |
||
7810 | trWriteSizei( height ); |
||
7811 | trWritei( border ); |
||
7812 | trWriteEnum( format ); |
||
7813 | trWriteEnum( type ); |
||
7814 | trWritePointer( (void *)pixels ); |
||
7815 | trFileFlush(); |
||
7816 | |||
7817 | if( trCtx()->doExec ) { |
||
7818 | trGetDispatch()->TexImage2D( target, level, internalFormat, width, height, border, format, type, pixels ); |
||
7819 | trError(); |
||
7820 | } |
||
7821 | } |
||
7822 | |||
7823 | |||
7824 | #if 0 |
||
7825 | // Not in MESAs dispatch table |
||
7826 | GLAPI void GLAPIENTRY trTexImage3DEXT( GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */ |
||
7827 | |||
7828 | trWriteCMD( CMD_TEXIMAGE3DEXT ); |
||
7829 | trWriteEnum( target ); |
||
7830 | trWritei( level ); |
||
7831 | trWriteEnum( internalFormat ); |
||
7832 | trWriteSizei( width ); |
||
7833 | trWriteSizei( height ); |
||
7834 | trWriteSizei( depth ); |
||
7835 | trWritei( border ); |
||
7836 | trWriteEnum( format ); |
||
7837 | trWriteEnum( type ); |
||
7838 | trWritePointer( (void *)pixels ); |
||
7839 | trFileFlush(); |
||
7840 | |||
7841 | /* Pixels isn't touched if target is GL_PROXY_TEXTURE_3D */ |
||
7842 | if( target != GL_PROXY_TEXTURE_3D ) { |
||
7843 | pixelsize = trGetPixelSize( format, type ); |
||
7844 | trWritePixelArray( GL_FALSE, type, width, height, depth, pixelsize, pixels ); |
||
7845 | } |
||
7846 | |||
7847 | if( trCtx()->doExec ) { |
||
7848 | trGetDispatch()->TexImage3DEXT( target, level, internalFormat, width, height, depth, border, format, type, pixels ); |
||
7849 | trError(); |
||
7850 | } |
||
7851 | } |
||
7852 | #endif |
||
7853 | |||
7854 | |||
7855 | GLAPI void GLAPIENTRY trTexImage3D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */ |
||
7856 | GLint pixelsize; |
||
7857 | |||
7858 | trWriteCMD( CMD_TEXIMAGE3D ); |
||
7859 | trWriteEnum( target ); |
||
7860 | trWritei( level ); |
||
7861 | trWritei( internalFormat ); |
||
7862 | trWriteSizei( width ); |
||
7863 | trWriteSizei( height ); |
||
7864 | trWriteSizei( depth ); |
||
7865 | trWritei( border ); |
||
7866 | trWriteEnum( format ); |
||
7867 | trWriteEnum( type ); |
||
7868 | trWritePointer( (void *)pixels ); |
||
7869 | trFileFlush(); |
||
7870 | |||
7871 | if( trCtx()->doExec ) { |
||
7872 | trGetDispatch()->TexImage3D( target, level, internalFormat, width, height, depth, border, format, type, pixels ); |
||
7873 | trError(); |
||
7874 | } |
||
7875 | } |
||
7876 | |||
7877 | |||
7878 | GLAPI void GLAPIENTRY trTexParameterf( GLenum target, GLenum pname, GLfloat param ) { |
||
7879 | trWriteCMD( CMD_TEXPARAMETERF ); |
||
7880 | trWriteEnum( target ); |
||
7881 | trWriteEnum( pname ); |
||
7882 | trWritef( param ); |
||
7883 | |||
7884 | if( trCtx()->doExec ) { |
||
7885 | trGetDispatch()->TexParameterf( target, pname, param ); |
||
7886 | trError(); |
||
7887 | } |
||
7888 | } |
||
7889 | |||
7890 | |||
7891 | GLAPI void GLAPIENTRY trTexParameterfv( GLenum target, GLenum pname, const GLfloat *params ) { |
||
7892 | trWriteCMD( CMD_TEXPARAMETERFV ); |
||
7893 | trWriteEnum( target ); |
||
7894 | trWriteEnum( pname ); |
||
7895 | trWritePointer( (void *)params ); |
||
7896 | trFileFlush(); |
||
7897 | trWritef( params[0] ); |
||
7898 | |||
7899 | if( trCtx()->doExec ) { |
||
7900 | trGetDispatch()->TexParameterfv( target, pname, params ); |
||
7901 | trError(); |
||
7902 | } |
||
7903 | } |
||
7904 | |||
7905 | |||
7906 | GLAPI void GLAPIENTRY trTexParameteri( GLenum target, GLenum pname, GLint param ) { |
||
7907 | trWriteCMD( CMD_TEXPARAMETERI ); |
||
7908 | trWriteEnum( target ); |
||
7909 | trWriteEnum( pname ); |
||
7910 | trWritei( param ); |
||
7911 | |||
7912 | if( trCtx()->doExec ) { |
||
7913 | trGetDispatch()->TexParameteri( target, pname, param ); |
||
7914 | trError(); |
||
7915 | } |
||
7916 | } |
||
7917 | |||
7918 | |||
7919 | GLAPI void GLAPIENTRY trTexParameteriv( GLenum target, GLenum pname, const GLint *params ) { |
||
7920 | trWriteCMD( CMD_TEXPARAMETERIV ); |
||
7921 | trWriteEnum( target ); |
||
7922 | trWriteEnum( pname ); |
||
7923 | trWritePointer( (void *)params ); |
||
7924 | trFileFlush(); |
||
7925 | trWritei( params[0] ); |
||
7926 | |||
7927 | if( trCtx()->doExec ) { |
||
7928 | trGetDispatch()->TexParameteriv( target, pname, params ); |
||
7929 | trError(); |
||
7930 | } |
||
7931 | } |
||
7932 | |||
7933 | |||
7934 | GLAPI void GLAPIENTRY trTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */ |
||
7935 | GLint pixelsize; |
||
7936 | |||
7937 | trWriteCMD( CMD_TEXSUBIMAGE1D ); |
||
7938 | trWriteEnum( target ); |
||
7939 | trWritei( level ); |
||
7940 | trWritei( xoffset ); |
||
7941 | trWriteSizei( width ); |
||
7942 | trWriteEnum( format ); |
||
7943 | trWriteEnum( type ); |
||
7944 | trWritePointer( (void *)pixels ); |
||
7945 | trFileFlush(); |
||
7946 | |||
7947 | if( trCtx()->doExec ) { |
||
7948 | trGetDispatch()->TexSubImage1D( target, level, xoffset, width, format, type, pixels ); |
||
7949 | trError(); |
||
7950 | } |
||
7951 | } |
||
7952 | |||
7953 | |||
7954 | GLAPI void GLAPIENTRY trTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */ |
||
7955 | GLint pixelsize; |
||
7956 | |||
7957 | trWriteCMD( CMD_TEXSUBIMAGE2D ); |
||
7958 | trWriteEnum( target ); |
||
7959 | trWritei( level ); |
||
7960 | trWritei( xoffset ); |
||
7961 | trWritei( yoffset ); |
||
7962 | trWriteSizei( width ); |
||
7963 | trWriteSizei( height ); |
||
7964 | trWriteEnum( format ); |
||
7965 | trWriteEnum( type ); |
||
7966 | trWritePointer( (void *)pixels ); |
||
7967 | trFileFlush(); |
||
7968 | |||
7969 | if( trCtx()->doExec ) { |
||
7970 | trGetDispatch()->TexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels ); |
||
7971 | trError(); |
||
7972 | } |
||
7973 | } |
||
7974 | |||
7975 | |||
7976 | #if 0 |
||
7977 | // Not in MESAs dispatch table |
||
7978 | GLAPI void GLAPIENTRY trTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { /* TODO */ |
||
7979 | GLint pixelsize; |
||
7980 | |||
7981 | trWriteCMD( CMD_TEXSUBIMAGE3DEXT ); |
||
7982 | trWriteEnum( target ); |
||
7983 | trWritei( level ); |
||
7984 | trWritei( xoffset ); |
||
7985 | trWritei( yoffset ); |
||
7986 | trWritei( zoffset ); |
||
7987 | trWriteSizei( width ); |
||
7988 | trWriteSizei( height ); |
||
7989 | trWriteSizei( depth ); |
||
7990 | trWriteEnum( format ); |
||
7991 | trWriteEnum( type ); |
||
7992 | trWritePointer( (void *)pixels ); |
||
7993 | trFileFlush(); |
||
7994 | |||
7995 | /* Pixels isn't touched if target is GL_PROXY_TEXTURE_3D */ |
||
7996 | if( target != GL_PROXY_TEXTURE_3D ) { |
||
7997 | pixelsize = trGetPixelSize( format, type ); |
||
7998 | trWritePixelArray( GL_FALSE, type, width, height, depth, pixelsize, pixels ); |
||
7999 | } |
||
8000 | |||
8001 | if( trCtx()->doExec ) { |
||
8002 | trGetDispatch()->TexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); |
||
8003 | trError(); |
||
8004 | } |
||
8005 | } |
||
8006 | #endif |
||
8007 | |||
8008 | |||
8009 | GLAPI void GLAPIENTRY trTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { /* TODO */ |
||
8010 | GLint pixelsize; |
||
8011 | |||
8012 | trWriteCMD( CMD_TEXSUBIMAGE3D ); |
||
8013 | trWriteEnum( target ); |
||
8014 | trWritei( level ); |
||
8015 | trWritei( xoffset ); |
||
8016 | trWritei( yoffset ); |
||
8017 | trWritei( zoffset ); |
||
8018 | trWriteSizei( width ); |
||
8019 | trWriteSizei( height ); |
||
8020 | trWriteSizei( depth ); |
||
8021 | trWriteEnum( format ); |
||
8022 | trWriteEnum( type ); |
||
8023 | trWritePointer( (void *)pixels ); |
||
8024 | trFileFlush(); |
||
8025 | |||
8026 | if( trCtx()->doExec ) { |
||
8027 | trGetDispatch()->TexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); |
||
8028 | trError(); |
||
8029 | } |
||
8030 | } |
||
8031 | |||
8032 | |||
8033 | GLAPI void GLAPIENTRY trTranslated( GLdouble x, GLdouble y, GLdouble z ) { |
||
8034 | trWriteCMD( CMD_TRANSLATED ); |
||
8035 | trWrited( x ); |
||
8036 | trWrited( y ); |
||
8037 | trWrited( z ); |
||
8038 | |||
8039 | if( trCtx()->doExec ) { |
||
8040 | trGetDispatch()->Translated( x, y, z ); |
||
8041 | trError(); |
||
8042 | } |
||
8043 | } |
||
8044 | |||
8045 | |||
8046 | GLAPI void GLAPIENTRY trTranslatef( GLfloat x, GLfloat y, GLfloat z ) { |
||
8047 | trWriteCMD( CMD_TRANSLATEF ); |
||
8048 | trWritef( x ); |
||
8049 | trWritef( y ); |
||
8050 | trWritef( z ); |
||
8051 | |||
8052 | if( trCtx()->doExec ) { |
||
8053 | trGetDispatch()->Translatef( x, y, z ); |
||
8054 | trError(); |
||
8055 | } |
||
8056 | } |
||
8057 | |||
8058 | |||
8059 | GLAPI void GLAPIENTRY trUnlockArraysEXT( void ) { |
||
8060 | trWriteCMD( CMD_UNLOCKARRAYSEXT ); |
||
8061 | |||
8062 | if( trCtx()->doExec ) { |
||
8063 | trGetDispatch()->UnlockArraysEXT( ); |
||
8064 | trError(); |
||
8065 | } |
||
8066 | } |
||
8067 | |||
8068 | |||
8069 | GLAPI void GLAPIENTRY trVertex2d( GLdouble x, GLdouble y ) { |
||
8070 | trWriteCMD( CMD_VERTEX2D ); |
||
8071 | trWrited( x ); |
||
8072 | trWrited( y ); |
||
8073 | |||
8074 | if( trCtx()->doExec ) { |
||
8075 | trGetDispatch()->Vertex2d( x, y ); |
||
8076 | trError(); |
||
8077 | } |
||
8078 | } |
||
8079 | |||
8080 | |||
8081 | GLAPI void GLAPIENTRY trVertex2dv( const GLdouble *v ) { |
||
8082 | trWriteCMD( CMD_VERTEX2DV ); |
||
8083 | trWritePointer( (void *)v ); |
||
8084 | trFileFlush(); |
||
8085 | trWriteArrayd( 2, v ); |
||
8086 | |||
8087 | if( trCtx()->doExec ) { |
||
8088 | trGetDispatch()->Vertex2dv( v ); |
||
8089 | trError(); |
||
8090 | } |
||
8091 | } |
||
8092 | |||
8093 | |||
8094 | GLAPI void GLAPIENTRY trVertex2f( GLfloat x, GLfloat y ) { |
||
8095 | trWriteCMD( CMD_VERTEX2F ); |
||
8096 | trWritef( x ); |
||
8097 | trWritef( y ); |
||
8098 | |||
8099 | if( trCtx()->doExec ) { |
||
8100 | trGetDispatch()->Vertex2f( x, y ); |
||
8101 | trError(); |
||
8102 | } |
||
8103 | } |
||
8104 | |||
8105 | |||
8106 | GLAPI void GLAPIENTRY trVertex2fv( const GLfloat *v ) { |
||
8107 | trWriteCMD( CMD_VERTEX2FV ); |
||
8108 | trWritePointer( (void *)v ); |
||
8109 | trFileFlush(); |
||
8110 | trWriteArrayf( 2, v ); |
||
8111 | |||
8112 | if( trCtx()->doExec ) { |
||
8113 | trGetDispatch()->Vertex2fv( v ); |
||
8114 | trError(); |
||
8115 | } |
||
8116 | } |
||
8117 | |||
8118 | |||
8119 | GLAPI void GLAPIENTRY trVertex2i( GLint x, GLint y ) { |
||
8120 | trWriteCMD( CMD_VERTEX2I ); |
||
8121 | trWritei( x ); |
||
8122 | trWritei( y ); |
||
8123 | |||
8124 | if( trCtx()->doExec ) { |
||
8125 | trGetDispatch()->Vertex2i( x, y ); |
||
8126 | trError(); |
||
8127 | } |
||
8128 | } |
||
8129 | |||
8130 | |||
8131 | GLAPI void GLAPIENTRY trVertex2iv( const GLint *v ) { |
||
8132 | trWriteCMD( CMD_VERTEX2IV ); |
||
8133 | trWritePointer( (void *)v ); |
||
8134 | trFileFlush(); |
||
8135 | trWriteArrayi( 2, v ); |
||
8136 | |||
8137 | if( trCtx()->doExec ) { |
||
8138 | trGetDispatch()->Vertex2iv( v ); |
||
8139 | trError(); |
||
8140 | } |
||
8141 | } |
||
8142 | |||
8143 | |||
8144 | GLAPI void GLAPIENTRY trVertex2s( GLshort x, GLshort y ) { |
||
8145 | trWriteCMD( CMD_VERTEX2S ); |
||
8146 | trWrites( x ); |
||
8147 | trWrites( y ); |
||
8148 | |||
8149 | if( trCtx()->doExec ) { |
||
8150 | trGetDispatch()->Vertex2s( x, y ); |
||
8151 | trError(); |
||
8152 | } |
||
8153 | } |
||
8154 | |||
8155 | |||
8156 | GLAPI void GLAPIENTRY trVertex2sv( const GLshort *v ) { |
||
8157 | trWriteCMD( CMD_VERTEX2SV ); |
||
8158 | trWritePointer( (void *)v ); |
||
8159 | trFileFlush(); |
||
8160 | trWriteArrays( 2, v ); |
||
8161 | |||
8162 | if( trCtx()->doExec ) { |
||
8163 | trGetDispatch()->Vertex2sv( v ); |
||
8164 | trError(); |
||
8165 | } |
||
8166 | } |
||
8167 | |||
8168 | |||
8169 | GLAPI void GLAPIENTRY trVertex3d( GLdouble x, GLdouble y, GLdouble z ) { |
||
8170 | trWriteCMD( CMD_VERTEX3D ); |
||
8171 | trWrited( x ); |
||
8172 | trWrited( y ); |
||
8173 | trWrited( z ); |
||
8174 | |||
8175 | if( trCtx()->doExec ) { |
||
8176 | trGetDispatch()->Vertex3d( x, y, z ); |
||
8177 | trError(); |
||
8178 | } |
||
8179 | } |
||
8180 | |||
8181 | |||
8182 | GLAPI void GLAPIENTRY trVertex3dv( const GLdouble *v ) { |
||
8183 | trWriteCMD( CMD_VERTEX3DV ); |
||
8184 | trWritePointer( (void *)v ); |
||
8185 | trFileFlush(); |
||
8186 | trWriteArrayd( 3, v ); |
||
8187 | |||
8188 | if( trCtx()->doExec ) { |
||
8189 | trGetDispatch()->Vertex3dv( v ); |
||
8190 | trError(); |
||
8191 | } |
||
8192 | } |
||
8193 | |||
8194 | |||
8195 | GLAPI void GLAPIENTRY trVertex3f( GLfloat x, GLfloat y, GLfloat z ) { |
||
8196 | trWriteCMD( CMD_VERTEX3F ); |
||
8197 | trWritef( x ); |
||
8198 | trWritef( y ); |
||
8199 | trWritef( z ); |
||
8200 | |||
8201 | if( trCtx()->doExec ) { |
||
8202 | trGetDispatch()->Vertex3f( x, y, z ); |
||
8203 | trError(); |
||
8204 | } |
||
8205 | } |
||
8206 | |||
8207 | |||
8208 | GLAPI void GLAPIENTRY trVertex3fv( const GLfloat *v ) { |
||
8209 | trWriteCMD( CMD_VERTEX3FV ); |
||
8210 | trWritePointer( (void *)v ); |
||
8211 | trFileFlush(); |
||
8212 | trWriteArrayf( 3, v ); |
||
8213 | |||
8214 | if( trCtx()->doExec ) { |
||
8215 | trGetDispatch()->Vertex3fv( v ); |
||
8216 | trError(); |
||
8217 | } |
||
8218 | } |
||
8219 | |||
8220 | |||
8221 | GLAPI void GLAPIENTRY trVertex3i( GLint x, GLint y, GLint z ) { |
||
8222 | trWriteCMD( CMD_VERTEX3I ); |
||
8223 | trWritei( x ); |
||
8224 | trWritei( y ); |
||
8225 | trWritei( z ); |
||
8226 | |||
8227 | if( trCtx()->doExec ) { |
||
8228 | trGetDispatch()->Vertex3i( x, y, z ); |
||
8229 | trError(); |
||
8230 | } |
||
8231 | } |
||
8232 | |||
8233 | |||
8234 | GLAPI void GLAPIENTRY trVertex3iv( const GLint *v ) { |
||
8235 | trWriteCMD( CMD_VERTEX3IV ); |
||
8236 | trWritePointer( (void *)v ); |
||
8237 | trFileFlush(); |
||
8238 | trWriteArrayi( 3, v ); |
||
8239 | |||
8240 | if( trCtx()->doExec ) { |
||
8241 | trGetDispatch()->Vertex3iv( v ); |
||
8242 | trError(); |
||
8243 | } |
||
8244 | } |
||
8245 | |||
8246 | |||
8247 | GLAPI void GLAPIENTRY trVertex3s( GLshort x, GLshort y, GLshort z ) { |
||
8248 | trWriteCMD( CMD_VERTEX3S ); |
||
8249 | trWrites( x ); |
||
8250 | trWrites( y ); |
||
8251 | trWrites( z ); |
||
8252 | |||
8253 | if( trCtx()->doExec ) { |
||
8254 | trGetDispatch()->Vertex3s( x, y, z ); |
||
8255 | trError(); |
||
8256 | } |
||
8257 | } |
||
8258 | |||
8259 | |||
8260 | GLAPI void GLAPIENTRY trVertex3sv( const GLshort *v ) { |
||
8261 | trWriteCMD( CMD_VERTEX3SV ); |
||
8262 | trWritePointer( (void *)v ); |
||
8263 | trFileFlush(); |
||
8264 | trWriteArrays( 3, v ); |
||
8265 | |||
8266 | if( trCtx()->doExec ) { |
||
8267 | trGetDispatch()->Vertex3sv( v ); |
||
8268 | trError(); |
||
8269 | } |
||
8270 | } |
||
8271 | |||
8272 | |||
8273 | GLAPI void GLAPIENTRY trVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { |
||
8274 | trWriteCMD( CMD_VERTEX4D ); |
||
8275 | trWrited( x ); |
||
8276 | trWrited( y ); |
||
8277 | trWrited( z ); |
||
8278 | trWrited( w ); |
||
8279 | |||
8280 | if( trCtx()->doExec ) { |
||
8281 | trGetDispatch()->Vertex4d( x, y, z, w ); |
||
8282 | trError(); |
||
8283 | } |
||
8284 | } |
||
8285 | |||
8286 | |||
8287 | GLAPI void GLAPIENTRY trVertex4dv( const GLdouble *v ) { |
||
8288 | trWriteCMD( CMD_VERTEX4DV ); |
||
8289 | trWritePointer( (void *)v ); |
||
8290 | trFileFlush(); |
||
8291 | trWriteArrayd( 4, v ); |
||
8292 | |||
8293 | if( trCtx()->doExec ) { |
||
8294 | trGetDispatch()->Vertex4dv( v ); |
||
8295 | trError(); |
||
8296 | } |
||
8297 | } |
||
8298 | |||
8299 | |||
8300 | GLAPI void GLAPIENTRY trVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { |
||
8301 | trWriteCMD( CMD_VERTEX4F ); |
||
8302 | trWritef( x ); |
||
8303 | trWritef( y ); |
||
8304 | trWritef( z ); |
||
8305 | trWritef( w ); |
||
8306 | |||
8307 | if( trCtx()->doExec ) { |
||
8308 | trGetDispatch()->Vertex4f( x, y, z, w ); |
||
8309 | trError(); |
||
8310 | } |
||
8311 | } |
||
8312 | |||
8313 | |||
8314 | GLAPI void GLAPIENTRY trVertex4fv( const GLfloat *v ) { |
||
8315 | trWriteCMD( CMD_VERTEX4FV ); |
||
8316 | trWritePointer( (void *)v ); |
||
8317 | trFileFlush(); |
||
8318 | trWriteArrayf( 4, v ); |
||
8319 | |||
8320 | if( trCtx()->doExec ) { |
||
8321 | trGetDispatch()->Vertex4fv( v ); |
||
8322 | trError(); |
||
8323 | } |
||
8324 | } |
||
8325 | |||
8326 | |||
8327 | GLAPI void GLAPIENTRY trVertex4i( GLint x, GLint y, GLint z, GLint w ) { |
||
8328 | trWriteCMD( CMD_VERTEX4I ); |
||
8329 | trWritei( x ); |
||
8330 | trWritei( y ); |
||
8331 | trWritei( z ); |
||
8332 | trWritei( w ); |
||
8333 | |||
8334 | if( trCtx()->doExec ) { |
||
8335 | trGetDispatch()->Vertex4i( x, y, z, w ); |
||
8336 | trError(); |
||
8337 | } |
||
8338 | } |
||
8339 | |||
8340 | |||
8341 | GLAPI void GLAPIENTRY trVertex4iv( const GLint *v ) { |
||
8342 | trWriteCMD( CMD_VERTEX4IV ); |
||
8343 | trWritePointer( (void *)v ); |
||
8344 | trFileFlush(); |
||
8345 | trWriteArrayi( 4, v ); |
||
8346 | |||
8347 | if( trCtx()->doExec ) { |
||
8348 | trGetDispatch()->Vertex4iv( v ); |
||
8349 | trError(); |
||
8350 | } |
||
8351 | } |
||
8352 | |||
8353 | |||
8354 | GLAPI void GLAPIENTRY trVertex4s( GLshort x, GLshort y, GLshort z, GLshort w ) { |
||
8355 | trWriteCMD( CMD_VERTEX4S ); |
||
8356 | trWrites( x ); |
||
8357 | trWrites( y ); |
||
8358 | trWrites( z ); |
||
8359 | trWrites( w ); |
||
8360 | |||
8361 | if( trCtx()->doExec ) { |
||
8362 | trGetDispatch()->Vertex4s( x, y, z, w ); |
||
8363 | trError(); |
||
8364 | } |
||
8365 | } |
||
8366 | |||
8367 | |||
8368 | GLAPI void GLAPIENTRY trVertex4sv( const GLshort *v ) { |
||
8369 | trWriteCMD( CMD_VERTEX4SV ); |
||
8370 | trWritePointer( (void *)v ); |
||
8371 | trFileFlush(); |
||
8372 | trWriteArrays( 4, v ); |
||
8373 | |||
8374 | if( trCtx()->doExec ) { |
||
8375 | trGetDispatch()->Vertex4sv( v ); |
||
8376 | trError(); |
||
8377 | } |
||
8378 | } |
||
8379 | |||
8380 | |||
8381 | GLAPI void GLAPIENTRY trVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */ |
||
8382 | trWriteCMD( CMD_VERTEXPOINTEREXT ); |
||
8383 | trWritei( size ); |
||
8384 | trWriteEnum( type ); |
||
8385 | trWriteSizei( stride ); |
||
8386 | trWriteSizei( count ); |
||
8387 | trWritePointer( (void *)ptr ); |
||
8388 | trFileFlush(); |
||
8389 | |||
8390 | if( trCtx()->doExec ) { |
||
8391 | trGetDispatch()->VertexPointerEXT( size, type, stride, count, ptr ); |
||
8392 | trError(); |
||
8393 | } |
||
8394 | } |
||
8395 | |||
8396 | |||
8397 | GLAPI void GLAPIENTRY trVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) { /* TODO */ |
||
8398 | trWriteCMD( CMD_VERTEXPOINTER ); |
||
8399 | trWritei( size ); |
||
8400 | trWriteEnum( type ); |
||
8401 | trWriteSizei( stride ); |
||
8402 | trWritePointer( (void *)ptr ); |
||
8403 | trFileFlush(); |
||
8404 | |||
8405 | if( trCtx()->doExec ) { |
||
8406 | trGetDispatch()->VertexPointer( size, type, stride, ptr ); |
||
8407 | trError(); |
||
8408 | } |
||
8409 | } |
||
8410 | |||
8411 | |||
8412 | GLAPI void GLAPIENTRY trViewport( GLint x, GLint y, GLsizei width, GLsizei height ) { |
||
8413 | trWriteCMD( CMD_VIEWPORT ); |
||
8414 | trWritei( x ); |
||
8415 | trWritei( y ); |
||
8416 | trWriteSizei( width ); |
||
8417 | trWriteSizei( height ); |
||
8418 | |||
8419 | if( trCtx()->doExec ) { |
||
8420 | trGetDispatch()->Viewport( x, y, width, height ); |
||
8421 | trError(); |
||
8422 | } |
||
8423 | } |
||
8424 | |||
8425 | |||
8426 | GLAPI void GLAPIENTRY trWindowPos2dMESA( GLdouble x, GLdouble y ) { |
||
8427 | trWriteCMD( CMD_WINDOWPOS2DMESA ); |
||
8428 | trWrited( x ); |
||
8429 | trWrited( y ); |
||
8430 | |||
8431 | if( trCtx()->doExec ) { |
||
8432 | trGetDispatch()->WindowPos2dMESA( x, y ); |
||
8433 | trError(); |
||
8434 | } |
||
8435 | } |
||
8436 | |||
8437 | |||
8438 | GLAPI void GLAPIENTRY trWindowPos2dvMESA( const GLdouble *p ) { |
||
8439 | trWriteCMD( CMD_WINDOWPOS2DVMESA ); |
||
8440 | trWritePointer( (void *)p ); |
||
8441 | trFileFlush(); |
||
8442 | trWriteArrayd( 2, p ); |
||
8443 | |||
8444 | if( trCtx()->doExec ) { |
||
8445 | trGetDispatch()->WindowPos2dvMESA( p ); |
||
8446 | trError(); |
||
8447 | } |
||
8448 | } |
||
8449 | |||
8450 | |||
8451 | GLAPI void GLAPIENTRY trWindowPos2fMESA( GLfloat x, GLfloat y ) { |
||
8452 | trWriteCMD( CMD_WINDOWPOS2FMESA ); |
||
8453 | trWritef( x ); |
||
8454 | trWritef( y ); |
||
8455 | |||
8456 | if( trCtx()->doExec ) { |
||
8457 | trGetDispatch()->WindowPos2fMESA( x, y ); |
||
8458 | trError(); |
||
8459 | } |
||
8460 | } |
||
8461 | |||
8462 | |||
8463 | GLAPI void GLAPIENTRY trWindowPos2fvMESA( const GLfloat *p ) { |
||
8464 | trWriteCMD( CMD_WINDOWPOS2FVMESA ); |
||
8465 | trWritePointer( (void *)p ); |
||
8466 | trFileFlush(); |
||
8467 | trWriteArrayf( 2, p ); |
||
8468 | |||
8469 | if( trCtx()->doExec ) { |
||
8470 | trGetDispatch()->WindowPos2fvMESA( p ); |
||
8471 | trError(); |
||
8472 | } |
||
8473 | } |
||
8474 | |||
8475 | |||
8476 | GLAPI void GLAPIENTRY trWindowPos2iMESA( GLint x, GLint y ) { |
||
8477 | trWriteCMD( CMD_WINDOWPOS2IMESA ); |
||
8478 | trWritei( x ); |
||
8479 | trWritei( y ); |
||
8480 | |||
8481 | if( trCtx()->doExec ) { |
||
8482 | trGetDispatch()->WindowPos2iMESA( x, y ); |
||
8483 | trError(); |
||
8484 | } |
||
8485 | } |
||
8486 | |||
8487 | |||
8488 | GLAPI void GLAPIENTRY trWindowPos2ivMESA( const GLint *p ) { |
||
8489 | trWriteCMD( CMD_WINDOWPOS2IVMESA ); |
||
8490 | trWritePointer( (void *)p ); |
||
8491 | trFileFlush(); |
||
8492 | trWriteArrayi( 2, p ); |
||
8493 | |||
8494 | if( trCtx()->doExec ) { |
||
8495 | trGetDispatch()->WindowPos2ivMESA( p ); |
||
8496 | trError(); |
||
8497 | } |
||
8498 | } |
||
8499 | |||
8500 | |||
8501 | GLAPI void GLAPIENTRY trWindowPos2sMESA( GLshort x, GLshort y ) { |
||
8502 | trWriteCMD( CMD_WINDOWPOS2SMESA ); |
||
8503 | trWrites( x ); |
||
8504 | trWrites( y ); |
||
8505 | |||
8506 | if( trCtx()->doExec ) { |
||
8507 | trGetDispatch()->WindowPos2sMESA( x, y ); |
||
8508 | trError(); |
||
8509 | } |
||
8510 | } |
||
8511 | |||
8512 | |||
8513 | GLAPI void GLAPIENTRY trWindowPos2svMESA( const GLshort *p ) { |
||
8514 | trWriteCMD( CMD_WINDOWPOS2SVMESA ); |
||
8515 | trWritePointer( (void *)p ); |
||
8516 | trFileFlush(); |
||
8517 | trWriteArrays( 2, p ); |
||
8518 | |||
8519 | if( trCtx()->doExec ) { |
||
8520 | trGetDispatch()->WindowPos2svMESA( p ); |
||
8521 | trError(); |
||
8522 | } |
||
8523 | } |
||
8524 | |||
8525 | |||
8526 | GLAPI void GLAPIENTRY trWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z ) { |
||
8527 | trWriteCMD( CMD_WINDOWPOS3DMESA ); |
||
8528 | trWrited( x ); |
||
8529 | trWrited( y ); |
||
8530 | trWrited( z ); |
||
8531 | |||
8532 | if( trCtx()->doExec ) { |
||
8533 | trGetDispatch()->WindowPos3dMESA( x, y, z ); |
||
8534 | trError(); |
||
8535 | } |
||
8536 | } |
||
8537 | |||
8538 | |||
8539 | GLAPI void GLAPIENTRY trWindowPos3dvMESA( const GLdouble *p ) { |
||
8540 | trWriteCMD( CMD_WINDOWPOS3DVMESA ); |
||
8541 | trWritePointer( (void *)p ); |
||
8542 | trFileFlush(); |
||
8543 | trWriteArrayd( 3, p ); |
||
8544 | |||
8545 | if( trCtx()->doExec ) { |
||
8546 | trGetDispatch()->WindowPos3dvMESA( p ); |
||
8547 | trError(); |
||
8548 | } |
||
8549 | } |
||
8550 | |||
8551 | |||
8552 | GLAPI void GLAPIENTRY trWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z ) { |
||
8553 | trWriteCMD( CMD_WINDOWPOS3FMESA ); |
||
8554 | trWritef( x ); |
||
8555 | trWritef( y ); |
||
8556 | trWritef( z ); |
||
8557 | |||
8558 | if( trCtx()->doExec ) { |
||
8559 | trGetDispatch()->WindowPos3fMESA( x, y, z ); |
||
8560 | trError(); |
||
8561 | } |
||
8562 | } |
||
8563 | |||
8564 | |||
8565 | GLAPI void GLAPIENTRY trWindowPos3fvMESA( const GLfloat *p ) { |
||
8566 | trWriteCMD( CMD_WINDOWPOS3FVMESA ); |
||
8567 | trWritePointer( (void *)p ); |
||
8568 | trFileFlush(); |
||
8569 | trWriteArrayf( 3, p ); |
||
8570 | |||
8571 | if( trCtx()->doExec ) { |
||
8572 | trGetDispatch()->WindowPos3fvMESA( p ); |
||
8573 | trError(); |
||
8574 | } |
||
8575 | } |
||
8576 | |||
8577 | |||
8578 | GLAPI void GLAPIENTRY trWindowPos3iMESA( GLint x, GLint y, GLint z ) { |
||
8579 | trWriteCMD( CMD_WINDOWPOS3IMESA ); |
||
8580 | trWritei( x ); |
||
8581 | trWritei( y ); |
||
8582 | trWritei( z ); |
||
8583 | |||
8584 | if( trCtx()->doExec ) { |
||
8585 | trGetDispatch()->WindowPos3iMESA( x, y, z ); |
||
8586 | trError(); |
||
8587 | } |
||
8588 | } |
||
8589 | |||
8590 | |||
8591 | GLAPI void GLAPIENTRY trWindowPos3ivMESA( const GLint *p ) { |
||
8592 | trWriteCMD( CMD_WINDOWPOS3IVMESA ); |
||
8593 | trWritePointer( (void *)p ); |
||
8594 | trFileFlush(); |
||
8595 | trWriteArrayi( 3, p ); |
||
8596 | |||
8597 | if( trCtx()->doExec ) { |
||
8598 | trGetDispatch()->WindowPos3ivMESA( p ); |
||
8599 | trError(); |
||
8600 | } |
||
8601 | } |
||
8602 | |||
8603 | |||
8604 | GLAPI void GLAPIENTRY trWindowPos3sMESA( GLshort x, GLshort y, GLshort z ) { |
||
8605 | trWriteCMD( CMD_WINDOWPOS3SMESA ); |
||
8606 | trWrites( x ); |
||
8607 | trWrites( y ); |
||
8608 | trWrites( z ); |
||
8609 | |||
8610 | if( trCtx()->doExec ) { |
||
8611 | trGetDispatch()->WindowPos3sMESA( x, y, z ); |
||
8612 | trError(); |
||
8613 | } |
||
8614 | } |
||
8615 | |||
8616 | |||
8617 | GLAPI void GLAPIENTRY trWindowPos3svMESA( const GLshort *p ) { |
||
8618 | trWriteCMD( CMD_WINDOWPOS3SVMESA ); |
||
8619 | trWritePointer( (void *)p ); |
||
8620 | trFileFlush(); |
||
8621 | trWriteArrays( 3, p ); |
||
8622 | |||
8623 | if( trCtx()->doExec ) { |
||
8624 | trGetDispatch()->WindowPos3svMESA( p ); |
||
8625 | trError(); |
||
8626 | } |
||
8627 | } |
||
8628 | |||
8629 | |||
8630 | GLAPI void GLAPIENTRY trWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w) { |
||
8631 | trWriteCMD( CMD_WINDOWPOS4DMESA ); |
||
8632 | trWrited( x ); |
||
8633 | trWrited( y ); |
||
8634 | trWrited( z ); |
||
8635 | trWrited( w ); |
||
8636 | |||
8637 | if( trCtx()->doExec ) { |
||
8638 | trGetDispatch()->WindowPos4dMESA( x, y, z, w ); |
||
8639 | trError(); |
||
8640 | } |
||
8641 | } |
||
8642 | |||
8643 | |||
8644 | GLAPI void GLAPIENTRY trWindowPos4dvMESA( const GLdouble *p ) { |
||
8645 | trWriteCMD( CMD_WINDOWPOS4DVMESA ); |
||
8646 | trWritePointer( (void *)p ); |
||
8647 | trFileFlush(); |
||
8648 | trWriteArrayd( 4, p ); |
||
8649 | |||
8650 | if( trCtx()->doExec ) { |
||
8651 | trGetDispatch()->WindowPos4dvMESA( p ); |
||
8652 | trError(); |
||
8653 | } |
||
8654 | } |
||
8655 | |||
8656 | |||
8657 | GLAPI void GLAPIENTRY trWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { |
||
8658 | trWriteCMD( CMD_WINDOWPOS4FMESA ); |
||
8659 | trWritef( x ); |
||
8660 | trWritef( y ); |
||
8661 | trWritef( z ); |
||
8662 | trWritef( w ); |
||
8663 | |||
8664 | if( trCtx()->doExec ) { |
||
8665 | trGetDispatch()->WindowPos4fMESA( x, y, z, w ); |
||
8666 | trError(); |
||
8667 | } |
||
8668 | } |
||
8669 | |||
8670 | |||
8671 | GLAPI void GLAPIENTRY trWindowPos4fvMESA( const GLfloat *p ) { |
||
8672 | trWriteCMD( CMD_WINDOWPOS4FVMESA ); |
||
8673 | trWritePointer( (void *)p ); |
||
8674 | trFileFlush(); |
||
8675 | trWriteArrayf( 4, p ); |
||
8676 | |||
8677 | if( trCtx()->doExec ) { |
||
8678 | trGetDispatch()->WindowPos4fvMESA( p ); |
||
8679 | trError(); |
||
8680 | } |
||
8681 | } |
||
8682 | |||
8683 | |||
8684 | GLAPI void GLAPIENTRY trWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w ) { |
||
8685 | trWriteCMD( CMD_WINDOWPOS4IMESA ); |
||
8686 | trWritei( x ); |
||
8687 | trWritei( y ); |
||
8688 | trWritei( z ); |
||
8689 | trWritei( w ); |
||
8690 | |||
8691 | if( trCtx()->doExec ) { |
||
8692 | trGetDispatch()->WindowPos4iMESA( x, y, z, w ); |
||
8693 | trError(); |
||
8694 | } |
||
8695 | } |
||
8696 | |||
8697 | |||
8698 | GLAPI void GLAPIENTRY trWindowPos4ivMESA( const GLint *p ) { |
||
8699 | trWriteCMD( CMD_WINDOWPOS4IVMESA ); |
||
8700 | trWritePointer( (void *)p ); |
||
8701 | trFileFlush(); |
||
8702 | trWriteArrayi( 4, p ); |
||
8703 | |||
8704 | if( trCtx()->doExec ) { |
||
8705 | trGetDispatch()->WindowPos4ivMESA( p ); |
||
8706 | trError(); |
||
8707 | } |
||
8708 | } |
||
8709 | |||
8710 | |||
8711 | GLAPI void GLAPIENTRY trWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w ) { |
||
8712 | trWriteCMD( CMD_WINDOWPOS4SMESA ); |
||
8713 | trWrites( x ); |
||
8714 | trWrites( y ); |
||
8715 | trWrites( z ); |
||
8716 | trWrites( w ); |
||
8717 | |||
8718 | if( trCtx()->doExec ) { |
||
8719 | trGetDispatch()->WindowPos4sMESA( x, y, z, w ); |
||
8720 | trError(); |
||
8721 | } |
||
8722 | } |
||
8723 | |||
8724 | |||
8725 | GLAPI void GLAPIENTRY trWindowPos4svMESA( const GLshort *p ) { |
||
8726 | trWriteCMD( CMD_WINDOWPOS4SVMESA ); |
||
8727 | trWritePointer( (void *)p ); |
||
8728 | trFileFlush(); |
||
8729 | trWriteArrays( 4, p ); |
||
8730 | |||
8731 | if( trCtx()->doExec ) { |
||
8732 | trGetDispatch()->WindowPos4svMESA( p ); |
||
8733 | trError(); |
||
8734 | } |
||
8735 | } |
||
8736 | |||
8737 | |||
8738 | void trInitDispatch( struct _glapi_table* dispatch ) { |
||
8739 | |||
8740 | /* assert(dispatch); */ |
||
8741 | if (!dispatch) |
||
8742 | return; |
||
8743 | |||
8744 | memset(dispatch,0,sizeof(struct _glapi_table)); |
||
8745 | |||
8746 | dispatch->NewList = trNewList; /* 0 */ |
||
8747 | dispatch->EndList = trEndList; /* 1 */ |
||
8748 | dispatch->CallList = trCallList; /* 2 */ |
||
8749 | dispatch->CallLists = trCallLists; /* 3 */ |
||
8750 | dispatch->DeleteLists = trDeleteLists; /* 4 */ |
||
8751 | dispatch->GenLists = trGenLists; /* 5 */ |
||
8752 | dispatch->ListBase = trListBase; /* 6 */ |
||
8753 | dispatch->Begin = trBegin; /* 7 */ |
||
8754 | dispatch->Bitmap = trBitmap; /* 8 */ |
||
8755 | dispatch->Color3b = trColor3b; /* 9 */ |
||
8756 | dispatch->Color3bv = trColor3bv; /* 10 */ |
||
8757 | dispatch->Color3d = trColor3d; /* 11 */ |
||
8758 | dispatch->Color3dv = trColor3dv; /* 12 */ |
||
8759 | dispatch->Color3f = trColor3f; /* 13 */ |
||
8760 | dispatch->Color3fv = trColor3fv; /* 14 */ |
||
8761 | dispatch->Color3i = trColor3i; /* 15 */ |
||
8762 | dispatch->Color3iv = trColor3iv; /* 16 */ |
||
8763 | dispatch->Color3s = trColor3s; /* 17 */ |
||
8764 | dispatch->Color3sv = trColor3sv; /* 18 */ |
||
8765 | dispatch->Color3ub = trColor3ub; /* 19 */ |
||
8766 | dispatch->Color3ubv = trColor3ubv; /* 20 */ |
||
8767 | dispatch->Color3ui = trColor3ui; /* 21 */ |
||
8768 | dispatch->Color3uiv = trColor3uiv; /* 22 */ |
||
8769 | dispatch->Color3us = trColor3us; /* 23 */ |
||
8770 | dispatch->Color3usv = trColor3usv; /* 24 */ |
||
8771 | dispatch->Color4b = trColor4b; /* 25 */ |
||
8772 | dispatch->Color4bv = trColor4bv; /* 26 */ |
||
8773 | dispatch->Color4d = trColor4d; /* 27 */ |
||
8774 | dispatch->Color4dv = trColor4dv; /* 28 */ |
||
8775 | dispatch->Color4f = trColor4f; /* 29 */ |
||
8776 | dispatch->Color4fv = trColor4fv; /* 30 */ |
||
8777 | dispatch->Color4i = trColor4i; /* 31 */ |
||
8778 | dispatch->Color4iv = trColor4iv; /* 32 */ |
||
8779 | dispatch->Color4s = trColor4s; /* 33 */ |
||
8780 | dispatch->Color4sv = trColor4sv; /* 34 */ |
||
8781 | dispatch->Color4ub = trColor4ub; /* 35 */ |
||
8782 | dispatch->Color4ubv = trColor4ubv; /* 36 */ |
||
8783 | dispatch->Color4ui = trColor4ui; /* 37 */ |
||
8784 | dispatch->Color4uiv = trColor4uiv; /* 38 */ |
||
8785 | dispatch->Color4us = trColor4us; /* 39 */ |
||
8786 | dispatch->Color4usv = trColor4usv; /* 40 */ |
||
8787 | dispatch->EdgeFlag = trEdgeFlag; /* 41 */ |
||
8788 | dispatch->EdgeFlagv = trEdgeFlagv; /* 42 */ |
||
8789 | dispatch->End = trEnd; /* 43 */ |
||
8790 | dispatch->Indexd = trIndexd; /* 44 */ |
||
8791 | dispatch->Indexdv = trIndexdv; /* 45 */ |
||
8792 | dispatch->Indexf = trIndexf; /* 46 */ |
||
8793 | dispatch->Indexfv = trIndexfv; /* 47 */ |
||
8794 | dispatch->Indexi = trIndexi; /* 48 */ |
||
8795 | dispatch->Indexiv = trIndexiv; /* 49 */ |
||
8796 | dispatch->Indexs = trIndexs; /* 50 */ |
||
8797 | dispatch->Indexsv = trIndexsv; /* 51 */ |
||
8798 | dispatch->Normal3b = trNormal3b; /* 52 */ |
||
8799 | dispatch->Normal3bv = trNormal3bv; /* 53 */ |
||
8800 | dispatch->Normal3d = trNormal3d; /* 54 */ |
||
8801 | dispatch->Normal3dv = trNormal3dv; /* 55 */ |
||
8802 | dispatch->Normal3f = trNormal3f; /* 56 */ |
||
8803 | dispatch->Normal3fv = trNormal3fv; /* 57 */ |
||
8804 | dispatch->Normal3i = trNormal3i; /* 58 */ |
||
8805 | dispatch->Normal3iv = trNormal3iv; /* 59 */ |
||
8806 | dispatch->Normal3s = trNormal3s; /* 60 */ |
||
8807 | dispatch->Normal3sv = trNormal3sv; /* 61 */ |
||
8808 | dispatch->RasterPos2d = trRasterPos2d; /* 62 */ |
||
8809 | dispatch->RasterPos2dv = trRasterPos2dv; /* 63 */ |
||
8810 | dispatch->RasterPos2f = trRasterPos2f; /* 64 */ |
||
8811 | dispatch->RasterPos2fv = trRasterPos2fv; /* 65 */ |
||
8812 | dispatch->RasterPos2i = trRasterPos2i; /* 66 */ |
||
8813 | dispatch->RasterPos2iv = trRasterPos2iv; /* 67 */ |
||
8814 | dispatch->RasterPos2s = trRasterPos2s; /* 68 */ |
||
8815 | dispatch->RasterPos2sv = trRasterPos2sv; /* 69 */ |
||
8816 | dispatch->RasterPos3d = trRasterPos3d; /* 70 */ |
||
8817 | dispatch->RasterPos3dv = trRasterPos3dv; /* 71 */ |
||
8818 | dispatch->RasterPos3f = trRasterPos3f; /* 72 */ |
||
8819 | dispatch->RasterPos3fv = trRasterPos3fv; /* 73 */ |
||
8820 | dispatch->RasterPos3i = trRasterPos3i; /* 74 */ |
||
8821 | dispatch->RasterPos3iv = trRasterPos3iv; /* 75 */ |
||
8822 | dispatch->RasterPos3s = trRasterPos3s; /* 76 */ |
||
8823 | dispatch->RasterPos3sv = trRasterPos3sv; /* 77 */ |
||
8824 | dispatch->RasterPos4d = trRasterPos4d; /* 78 */ |
||
8825 | dispatch->RasterPos4dv = trRasterPos4dv; /* 79 */ |
||
8826 | dispatch->RasterPos4f = trRasterPos4f; /* 80 */ |
||
8827 | dispatch->RasterPos4fv = trRasterPos4fv; /* 81 */ |
||
8828 | dispatch->RasterPos4i = trRasterPos4i; /* 82 */ |
||
8829 | dispatch->RasterPos4iv = trRasterPos4iv; /* 83 */ |
||
8830 | dispatch->RasterPos4s = trRasterPos4s; /* 84 */ |
||
8831 | dispatch->RasterPos4sv = trRasterPos4sv; /* 85 */ |
||
8832 | dispatch->Rectd = trRectd; /* 86 */ |
||
8833 | dispatch->Rectdv = trRectdv; /* 87 */ |
||
8834 | dispatch->Rectf = trRectf; /* 88 */ |
||
8835 | dispatch->Rectfv = trRectfv; /* 89 */ |
||
8836 | dispatch->Recti = trRecti; /* 90 */ |
||
8837 | dispatch->Rectiv = trRectiv; /* 91 */ |
||
8838 | dispatch->Rects = trRects; /* 92 */ |
||
8839 | dispatch->Rectsv = trRectsv; /* 93 */ |
||
8840 | dispatch->TexCoord1d = trTexCoord1d; /* 94 */ |
||
8841 | dispatch->TexCoord1dv = trTexCoord1dv; /* 95 */ |
||
8842 | dispatch->TexCoord1f = trTexCoord1f; /* 96 */ |
||
8843 | dispatch->TexCoord1fv = trTexCoord1fv; /* 97 */ |
||
8844 | dispatch->TexCoord1i = trTexCoord1i; /* 98 */ |
||
8845 | dispatch->TexCoord1iv = trTexCoord1iv; /* 99 */ |
||
8846 | dispatch->TexCoord1s = trTexCoord1s; /* 100 */ |
||
8847 | dispatch->TexCoord1sv = trTexCoord1sv; /* 101 */ |
||
8848 | dispatch->TexCoord2d = trTexCoord2d; /* 102 */ |
||
8849 | dispatch->TexCoord2dv = trTexCoord2dv; /* 103 */ |
||
8850 | dispatch->TexCoord2f = trTexCoord2f; /* 104 */ |
||
8851 | dispatch->TexCoord2fv = trTexCoord2fv; /* 105 */ |
||
8852 | dispatch->TexCoord2i = trTexCoord2i; /* 106 */ |
||
8853 | dispatch->TexCoord2iv = trTexCoord2iv; /* 107 */ |
||
8854 | dispatch->TexCoord2s = trTexCoord2s; /* 108 */ |
||
8855 | dispatch->TexCoord2sv = trTexCoord2sv; /* 109 */ |
||
8856 | dispatch->TexCoord3d = trTexCoord3d; /* 110 */ |
||
8857 | dispatch->TexCoord3dv = trTexCoord3dv; /* 111 */ |
||
8858 | dispatch->TexCoord3f = trTexCoord3f; /* 112 */ |
||
8859 | dispatch->TexCoord3fv = trTexCoord3fv; /* 113 */ |
||
8860 | dispatch->TexCoord3i = trTexCoord3i; /* 114 */ |
||
8861 | dispatch->TexCoord3iv = trTexCoord3iv; /* 115 */ |
||
8862 | dispatch->TexCoord3s = trTexCoord3s; /* 116 */ |
||
8863 | dispatch->TexCoord3sv = trTexCoord3sv; /* 117 */ |
||
8864 | dispatch->TexCoord4d = trTexCoord4d; /* 118 */ |
||
8865 | dispatch->TexCoord4dv = trTexCoord4dv; /* 119 */ |
||
8866 | dispatch->TexCoord4f = trTexCoord4f; /* 120 */ |
||
8867 | dispatch->TexCoord4fv = trTexCoord4fv; /* 121 */ |
||
8868 | dispatch->TexCoord4i = trTexCoord4i; /* 122 */ |
||
8869 | dispatch->TexCoord4iv = trTexCoord4iv; /* 123 */ |
||
8870 | dispatch->TexCoord4s = trTexCoord4s; /* 124 */ |
||
8871 | dispatch->TexCoord4sv = trTexCoord4sv; /* 125 */ |
||
8872 | dispatch->Vertex2d = trVertex2d; /* 126 */ |
||
8873 | dispatch->Vertex2dv = trVertex2dv; /* 127 */ |
||
8874 | dispatch->Vertex2f = trVertex2f; /* 128 */ |
||
8875 | dispatch->Vertex2fv = trVertex2fv; /* 129 */ |
||
8876 | dispatch->Vertex2i = trVertex2i; /* 130 */ |
||
8877 | dispatch->Vertex2iv = trVertex2iv; /* 131 */ |
||
8878 | dispatch->Vertex2s = trVertex2s; /* 132 */ |
||
8879 | dispatch->Vertex2sv = trVertex2sv; /* 133 */ |
||
8880 | dispatch->Vertex3d = trVertex3d; /* 134 */ |
||
8881 | dispatch->Vertex3dv = trVertex3dv; /* 135 */ |
||
8882 | dispatch->Vertex3f = trVertex3f; /* 136 */ |
||
8883 | dispatch->Vertex3fv = trVertex3fv; /* 137 */ |
||
8884 | dispatch->Vertex3i = trVertex3i; /* 138 */ |
||
8885 | dispatch->Vertex3iv = trVertex3iv; /* 139 */ |
||
8886 | dispatch->Vertex3s = trVertex3s; /* 140 */ |
||
8887 | dispatch->Vertex3sv = trVertex3sv; /* 141 */ |
||
8888 | dispatch->Vertex4d = trVertex4d; /* 142 */ |
||
8889 | dispatch->Vertex4dv = trVertex4dv; /* 143 */ |
||
8890 | dispatch->Vertex4f = trVertex4f; /* 144 */ |
||
8891 | dispatch->Vertex4fv = trVertex4fv; /* 145 */ |
||
8892 | dispatch->Vertex4i = trVertex4i; /* 146 */ |
||
8893 | dispatch->Vertex4iv = trVertex4iv; /* 147 */ |
||
8894 | dispatch->Vertex4s = trVertex4s; /* 148 */ |
||
8895 | dispatch->Vertex4sv = trVertex4sv; /* 149 */ |
||
8896 | dispatch->ClipPlane = trClipPlane; /* 150 */ |
||
8897 | dispatch->ColorMaterial = trColorMaterial; /* 151 */ |
||
8898 | dispatch->CullFace = trCullFace; /* 152 */ |
||
8899 | dispatch->Fogf = trFogf; /* 153 */ |
||
8900 | dispatch->Fogfv = trFogfv; /* 154 */ |
||
8901 | dispatch->Fogi = trFogi; /* 155 */ |
||
8902 | dispatch->Fogiv = trFogiv; /* 156 */ |
||
8903 | dispatch->FrontFace = trFrontFace; /* 157 */ |
||
8904 | dispatch->Hint = trHint; /* 158 */ |
||
8905 | dispatch->Lightf = trLightf; /* 159 */ |
||
8906 | dispatch->Lightfv = trLightfv; /* 160 */ |
||
8907 | dispatch->Lighti = trLighti; /* 161 */ |
||
8908 | dispatch->Lightiv = trLightiv; /* 162 */ |
||
8909 | dispatch->LightModelf = trLightModelf; /* 163 */ |
||
8910 | dispatch->LightModelfv = trLightModelfv; /* 164 */ |
||
8911 | dispatch->LightModeli = trLightModeli; /* 165 */ |
||
8912 | dispatch->LightModeliv = trLightModeliv; /* 166 */ |
||
8913 | dispatch->LineStipple = trLineStipple; /* 167 */ |
||
8914 | dispatch->LineWidth = trLineWidth; /* 168 */ |
||
8915 | dispatch->Materialf = trMaterialf; /* 169 */ |
||
8916 | dispatch->Materialfv = trMaterialfv; /* 170 */ |
||
8917 | dispatch->Materiali = trMateriali; /* 171 */ |
||
8918 | dispatch->Materialiv = trMaterialiv; /* 172 */ |
||
8919 | dispatch->PointSize = trPointSize; /* 173 */ |
||
8920 | dispatch->PolygonMode = trPolygonMode; /* 174 */ |
||
8921 | dispatch->PolygonStipple = trPolygonStipple; /* 175 */ |
||
8922 | dispatch->Scissor = trScissor; /* 176 */ |
||
8923 | dispatch->ShadeModel = trShadeModel; /* 177 */ |
||
8924 | dispatch->TexParameterf = trTexParameterf; /* 178 */ |
||
8925 | dispatch->TexParameterfv = trTexParameterfv; /* 179 */ |
||
8926 | dispatch->TexParameteri = trTexParameteri; /* 180 */ |
||
8927 | dispatch->TexParameteriv = trTexParameteriv; /* 181 */ |
||
8928 | dispatch->TexImage1D = trTexImage1D; /* 182 */ |
||
8929 | dispatch->TexImage2D = trTexImage2D; /* 183 */ |
||
8930 | dispatch->TexEnvf = trTexEnvf; /* 184 */ |
||
8931 | dispatch->TexEnvfv = trTexEnvfv; /* 185 */ |
||
8932 | dispatch->TexEnvi = trTexEnvi; /* 186 */ |
||
8933 | dispatch->TexEnviv = trTexEnviv; /* 187 */ |
||
8934 | dispatch->TexGend = trTexGend; /* 188 */ |
||
8935 | dispatch->TexGendv = trTexGendv; /* 189 */ |
||
8936 | dispatch->TexGenf = trTexGenf; /* 190 */ |
||
8937 | dispatch->TexGenfv = trTexGenfv; /* 191 */ |
||
8938 | dispatch->TexGeni = trTexGeni; /* 192 */ |
||
8939 | dispatch->TexGeniv = trTexGeniv; /* 193 */ |
||
8940 | dispatch->FeedbackBuffer = trFeedbackBuffer; /* 194 */ |
||
8941 | dispatch->SelectBuffer = trSelectBuffer; /* 195 */ |
||
8942 | dispatch->RenderMode = trRenderMode; /* 196 */ |
||
8943 | dispatch->InitNames = trInitNames; /* 197 */ |
||
8944 | dispatch->LoadName = trLoadName; /* 198 */ |
||
8945 | dispatch->PassThrough = trPassThrough; /* 199 */ |
||
8946 | dispatch->PopName = trPopName; /* 200 */ |
||
8947 | dispatch->PushName = trPushName; /* 201 */ |
||
8948 | dispatch->DrawBuffer = trDrawBuffer; /* 202 */ |
||
8949 | dispatch->Clear = trClear; /* 203 */ |
||
8950 | dispatch->ClearAccum = trClearAccum; /* 204 */ |
||
8951 | dispatch->ClearIndex = trClearIndex; /* 205 */ |
||
8952 | dispatch->ClearColor = trClearColor; /* 206 */ |
||
8953 | dispatch->ClearStencil = trClearStencil; /* 207 */ |
||
8954 | dispatch->ClearDepth = trClearDepth; /* 208 */ |
||
8955 | dispatch->StencilMask = trStencilMask; /* 209 */ |
||
8956 | dispatch->ColorMask = trColorMask; /* 210 */ |
||
8957 | dispatch->DepthMask = trDepthMask; /* 211 */ |
||
8958 | dispatch->IndexMask = trIndexMask; /* 212 */ |
||
8959 | dispatch->Accum = trAccum; /* 213 */ |
||
8960 | dispatch->Disable = trDisable; /* 214 */ |
||
8961 | dispatch->Enable = trEnable; /* 215 */ |
||
8962 | dispatch->Finish = trFinish; /* 216 */ |
||
8963 | dispatch->Flush = trFlush; /* 217 */ |
||
8964 | dispatch->PopAttrib = trPopAttrib; /* 218 */ |
||
8965 | dispatch->PushAttrib = trPushAttrib; /* 219 */ |
||
8966 | dispatch->Map1d = trMap1d; /* 220 */ |
||
8967 | dispatch->Map1f = trMap1f; /* 221 */ |
||
8968 | dispatch->Map2d = trMap2d; /* 222 */ |
||
8969 | dispatch->Map2f = trMap2f; /* 223 */ |
||
8970 | dispatch->MapGrid1d = trMapGrid1d; /* 224 */ |
||
8971 | dispatch->MapGrid1f = trMapGrid1f; /* 225 */ |
||
8972 | dispatch->MapGrid2d = trMapGrid2d; /* 226 */ |
||
8973 | dispatch->MapGrid2f = trMapGrid2f; /* 227 */ |
||
8974 | dispatch->EvalCoord1d = trEvalCoord1d; /* 228 */ |
||
8975 | dispatch->EvalCoord1dv = trEvalCoord1dv; /* 229 */ |
||
8976 | dispatch->EvalCoord1f = trEvalCoord1f; /* 230 */ |
||
8977 | dispatch->EvalCoord1fv = trEvalCoord1fv; /* 231 */ |
||
8978 | dispatch->EvalCoord2d = trEvalCoord2d; /* 232 */ |
||
8979 | dispatch->EvalCoord2dv = trEvalCoord2dv; /* 233 */ |
||
8980 | dispatch->EvalCoord2f = trEvalCoord2f; /* 234 */ |
||
8981 | dispatch->EvalCoord2fv = trEvalCoord2fv; /* 235 */ |
||
8982 | dispatch->EvalMesh1 = trEvalMesh1; /* 236 */ |
||
8983 | dispatch->EvalPoint1 = trEvalPoint1; /* 237 */ |
||
8984 | dispatch->EvalMesh2 = trEvalMesh2; /* 238 */ |
||
8985 | dispatch->EvalPoint2 = trEvalPoint2; /* 239 */ |
||
8986 | dispatch->AlphaFunc = trAlphaFunc; /* 240 */ |
||
8987 | dispatch->BlendFunc = trBlendFunc; /* 241 */ |
||
8988 | dispatch->LogicOp = trLogicOp; /* 242 */ |
||
8989 | dispatch->StencilFunc = trStencilFunc; /* 243 */ |
||
8990 | dispatch->StencilOp = trStencilOp; /* 244 */ |
||
8991 | dispatch->DepthFunc = trDepthFunc; /* 245 */ |
||
8992 | dispatch->PixelZoom = trPixelZoom; /* 246 */ |
||
8993 | dispatch->PixelTransferf = trPixelTransferf; /* 247 */ |
||
8994 | dispatch->PixelTransferi = trPixelTransferi; /* 248 */ |
||
8995 | dispatch->PixelStoref = trPixelStoref; /* 249 */ |
||
8996 | dispatch->PixelStorei = trPixelStorei; /* 250 */ |
||
8997 | dispatch->PixelMapfv = trPixelMapfv; /* 251 */ |
||
8998 | dispatch->PixelMapuiv = trPixelMapuiv; /* 252 */ |
||
8999 | dispatch->PixelMapusv = trPixelMapusv; /* 253 */ |
||
9000 | dispatch->ReadBuffer = trReadBuffer; /* 254 */ |
||
9001 | dispatch->CopyPixels = trCopyPixels; /* 255 */ |
||
9002 | dispatch->ReadPixels = trReadPixels; /* 256 */ |
||
9003 | dispatch->DrawPixels = trDrawPixels; /* 257 */ |
||
9004 | dispatch->GetBooleanv = trGetBooleanv; /* 258 */ |
||
9005 | dispatch->GetClipPlane = trGetClipPlane; /* 259 */ |
||
9006 | dispatch->GetDoublev = trGetDoublev; /* 260 */ |
||
9007 | dispatch->GetError = trGetError; /* 261 */ |
||
9008 | dispatch->GetFloatv = trGetFloatv; /* 262 */ |
||
9009 | dispatch->GetIntegerv = trGetIntegerv; /* 263 */ |
||
9010 | dispatch->GetLightfv = trGetLightfv; /* 264 */ |
||
9011 | dispatch->GetLightiv = trGetLightiv; /* 265 */ |
||
9012 | dispatch->GetMapdv = trGetMapdv; /* 266 */ |
||
9013 | dispatch->GetMapfv = trGetMapfv; /* 267 */ |
||
9014 | dispatch->GetMapiv = trGetMapiv; /* 268 */ |
||
9015 | dispatch->GetMaterialfv = trGetMaterialfv; /* 269 */ |
||
9016 | dispatch->GetMaterialiv = trGetMaterialiv; /* 270 */ |
||
9017 | dispatch->GetPixelMapfv = trGetPixelMapfv; /* 271 */ |
||
9018 | dispatch->GetPixelMapuiv = trGetPixelMapuiv; /* 272 */ |
||
9019 | dispatch->GetPixelMapusv = trGetPixelMapusv; /* 273 */ |
||
9020 | dispatch->GetPolygonStipple = trGetPolygonStipple; /* 274 */ |
||
9021 | dispatch->GetString = trGetString; /* 275 */ |
||
9022 | dispatch->GetTexEnvfv = trGetTexEnvfv; /* 276 */ |
||
9023 | dispatch->GetTexEnviv = trGetTexEnviv; /* 277 */ |
||
9024 | dispatch->GetTexGendv = trGetTexGendv; /* 278 */ |
||
9025 | dispatch->GetTexGenfv = trGetTexGenfv; /* 279 */ |
||
9026 | dispatch->GetTexGeniv = trGetTexGeniv; /* 280 */ |
||
9027 | dispatch->GetTexImage = trGetTexImage; /* 281 */ |
||
9028 | dispatch->GetTexParameterfv = trGetTexParameterfv; /* 282 */ |
||
9029 | dispatch->GetTexParameteriv = trGetTexParameteriv; /* 283 */ |
||
9030 | dispatch->GetTexLevelParameterfv = trGetTexLevelParameterfv; /* 284 */ |
||
9031 | dispatch->GetTexLevelParameteriv = trGetTexLevelParameteriv; /* 285 */ |
||
9032 | dispatch->IsEnabled = trIsEnabled; /* 286 */ |
||
9033 | dispatch->IsList = trIsList; /* 287 */ |
||
9034 | dispatch->DepthRange = trDepthRange; /* 288 */ |
||
9035 | dispatch->Frustum = trFrustum; /* 289 */ |
||
9036 | dispatch->LoadIdentity = trLoadIdentity; /* 290 */ |
||
9037 | dispatch->LoadMatrixf = trLoadMatrixf; /* 291 */ |
||
9038 | dispatch->LoadMatrixd = trLoadMatrixd; /* 292 */ |
||
9039 | dispatch->MatrixMode = trMatrixMode; /* 293 */ |
||
9040 | dispatch->MultMatrixf = trMultMatrixf; /* 294 */ |
||
9041 | dispatch->MultMatrixd = trMultMatrixd; /* 295 */ |
||
9042 | dispatch->Ortho = trOrtho; /* 296 */ |
||
9043 | dispatch->PopMatrix = trPopMatrix; /* 297 */ |
||
9044 | dispatch->PushMatrix = trPushMatrix; /* 298 */ |
||
9045 | dispatch->Rotated = trRotated; /* 299 */ |
||
9046 | dispatch->Rotatef = trRotatef; /* 300 */ |
||
9047 | dispatch->Scaled = trScaled; /* 301 */ |
||
9048 | dispatch->Scalef = trScalef; /* 302 */ |
||
9049 | dispatch->Translated = trTranslated; /* 303 */ |
||
9050 | dispatch->Translatef = trTranslatef; /* 304 */ |
||
9051 | dispatch->Viewport = trViewport; /* 305 */ |
||
9052 | dispatch->ArrayElement = trArrayElement; /* 306 */ |
||
9053 | dispatch->BindTexture = trBindTexture; /* 307 */ |
||
9054 | dispatch->ColorPointer = trColorPointer; /* 308 */ |
||
9055 | dispatch->DisableClientState = trDisableClientState; /* 309 */ |
||
9056 | dispatch->DrawArrays = trDrawArrays; /* 310 */ |
||
9057 | dispatch->DrawElements = trDrawElements; /* 311 */ |
||
9058 | dispatch->EdgeFlagPointer = trEdgeFlagPointer; /* 312 */ |
||
9059 | dispatch->EnableClientState = trEnableClientState; /* 313 */ |
||
9060 | dispatch->IndexPointer = trIndexPointer; /* 314 */ |
||
9061 | dispatch->Indexub = trIndexub; /* 315 */ |
||
9062 | dispatch->Indexubv = trIndexubv; /* 316 */ |
||
9063 | dispatch->InterleavedArrays = trInterleavedArrays; /* 317 */ |
||
9064 | dispatch->NormalPointer = trNormalPointer; /* 318 */ |
||
9065 | dispatch->PolygonOffset = trPolygonOffset; /* 319 */ |
||
9066 | dispatch->TexCoordPointer = trTexCoordPointer; /* 320 */ |
||
9067 | dispatch->VertexPointer = trVertexPointer; /* 321 */ |
||
9068 | dispatch->AreTexturesResident = trAreTexturesResident; /* 322 */ |
||
9069 | dispatch->CopyTexImage1D = trCopyTexImage1D; /* 323 */ |
||
9070 | dispatch->CopyTexImage2D = trCopyTexImage2D; /* 324 */ |
||
9071 | dispatch->CopyTexSubImage1D = trCopyTexSubImage1D; /* 325 */ |
||
9072 | dispatch->CopyTexSubImage2D = trCopyTexSubImage2D; /* 326 */ |
||
9073 | dispatch->DeleteTextures = trDeleteTextures; /* 327 */ |
||
9074 | dispatch->GenTextures = trGenTextures; /* 328 */ |
||
9075 | dispatch->GetPointerv = trGetPointerv; /* 329 */ |
||
9076 | dispatch->IsTexture = trIsTexture; /* 330 */ |
||
9077 | dispatch->PrioritizeTextures = trPrioritizeTextures; /* 331 */ |
||
9078 | dispatch->TexSubImage1D = trTexSubImage1D; /* 332 */ |
||
9079 | dispatch->TexSubImage2D = trTexSubImage2D; /* 333 */ |
||
9080 | dispatch->PopClientAttrib = trPopClientAttrib; /* 334 */ |
||
9081 | dispatch->PushClientAttrib = trPushClientAttrib; /* 335 */ |
||
9082 | #if 1 |
||
9083 | dispatch->BlendColor = trBlendColor; /* 336 */ |
||
9084 | dispatch->BlendEquation = trBlendEquation; /* 337 */ |
||
9085 | dispatch->DrawRangeElements = trDrawRangeElements; /* 338 */ |
||
9086 | dispatch->ColorTable = trColorTable; /* 339 */ |
||
9087 | dispatch->ColorTableParameterfv = trColorTableParameterfv; /* 340 */ |
||
9088 | dispatch->ColorTableParameteriv = trColorTableParameteriv; /* 341 */ |
||
9089 | dispatch->CopyColorTable = trCopyColorTable; /* 342 */ |
||
9090 | dispatch->GetColorTable = trGetColorTable; /* 343 */ |
||
9091 | dispatch->GetColorTableParameterfv = trGetColorTableParameterfv; /* 344 */ |
||
9092 | dispatch->GetColorTableParameteriv = trGetColorTableParameteriv; /* 345 */ |
||
9093 | dispatch->ColorSubTable = trColorSubTable; /* 346 */ |
||
9094 | dispatch->CopyColorSubTable = trCopyColorSubTable; /* 347 */ |
||
9095 | dispatch->ConvolutionFilter1D = trConvolutionFilter1D; /* 348 */ |
||
9096 | dispatch->ConvolutionFilter2D = trConvolutionFilter2D; /* 349 */ |
||
9097 | dispatch->ConvolutionParameterf = trConvolutionParameterf; /* 350 */ |
||
9098 | dispatch->ConvolutionParameterfv = trConvolutionParameterfv; /* 351 */ |
||
9099 | dispatch->ConvolutionParameteri = trConvolutionParameteri; /* 352 */ |
||
9100 | dispatch->ConvolutionParameteriv = trConvolutionParameteriv; /* 353 */ |
||
9101 | dispatch->CopyConvolutionFilter1D = trCopyConvolutionFilter1D; /* 354 */ |
||
9102 | dispatch->CopyConvolutionFilter2D = trCopyConvolutionFilter2D; /* 355 */ |
||
9103 | dispatch->GetConvolutionFilter = trGetConvolutionFilter; /* 356 */ |
||
9104 | dispatch->GetConvolutionParameterfv = trGetConvolutionParameterfv;/* 357 */ |
||
9105 | dispatch->GetConvolutionParameteriv = trGetConvolutionParameteriv;/* 358 */ |
||
9106 | dispatch->GetSeparableFilter = trGetSeparableFilter; /* 359 */ |
||
9107 | dispatch->SeparableFilter2D = trSeparableFilter2D; /* 360 */ |
||
9108 | dispatch->GetHistogram = trGetHistogram; /* 361 */ |
||
9109 | dispatch->GetHistogramParameterfv = trGetHistogramParameterfv; /* 362 */ |
||
9110 | dispatch->GetHistogramParameteriv = trGetHistogramParameteriv; /* 363 */ |
||
9111 | dispatch->GetMinmax = trGetMinmax; /* 364 */ |
||
9112 | dispatch->GetMinmaxParameterfv = trGetMinmaxParameterfv; /* 365 */ |
||
9113 | dispatch->GetMinmaxParameteriv = trGetMinmaxParameteriv; /* 366 */ |
||
9114 | #endif |
||
9115 | #if 0 |
||
9116 | dispatch->Histogram = trHistogram /* 367 */ |
||
9117 | dispatch->Minmax = trMinmax /* 368 */ |
||
9118 | dispatch->ResetHistogram = trResetHistogram /* 369 */ |
||
9119 | dispatch->ResetMinmax = trResetMinmax /* 370 */ |
||
9120 | dispatch->TexImage3D = trTexImage3D /* 371 */ |
||
9121 | dispatch->TexSubImage3D = trTexSubImage3D /* 372 */ |
||
9122 | dispatch->CopyTexSubImage3D = trCopyTexSubImage3D /* 373 */ |
||
9123 | dispatch->ActiveTextureARB = trActiveTextureARB /* 374 */ |
||
9124 | dispatch->ClientActiveTextureARB = trClientActiveTextureARB /* 375 */ |
||
9125 | dispatch->MultiTexCoord1dARB = trMultiTexCoord1dARB /* 376 */ |
||
9126 | dispatch->MultiTexCoord1dvARB = trMultiTexCoord1dvARB /* 377 */ |
||
9127 | dispatch->MultiTexCoord1fARB = trMultiTexCoord1fARB /* 378 */ |
||
9128 | dispatch->MultiTexCoord1fvARB = trMultiTexCoord1fvARB /* 379 */ |
||
9129 | dispatch->MultiTexCoord1iARB = trMultiTexCoord1iARB /* 380 */ |
||
9130 | dispatch->MultiTexCoord1ivARB = trMultiTexCoord1ivARB /* 381 */ |
||
9131 | dispatch->MultiTexCoord1sARB = trMultiTexCoord1sARB /* 382 */ |
||
9132 | dispatch->MultiTexCoord1svARB = trMultiTexCoord1svARB /* 383 */ |
||
9133 | dispatch->MultiTexCoord2dARB = trMultiTexCoord2dARB /* 384 */ |
||
9134 | dispatch->MultiTexCoord2dvARB = trMultiTexCoord2dvARB /* 385 */ |
||
9135 | dispatch->MultiTexCoord2fARB = trMultiTexCoord2fARB /* 386 */ |
||
9136 | dispatch->MultiTexCoord2fvARB = trMultiTexCoord2fvARB /* 387 */ |
||
9137 | dispatch->MultiTexCoord2iARB = trMultiTexCoord2iARB /* 388 */ |
||
9138 | dispatch->MultiTexCoord2ivARB = trMultiTexCoord2ivARB /* 389 */ |
||
9139 | dispatch->MultiTexCoord2sARB = trMultiTexCoord2sARB /* 390 */ |
||
9140 | dispatch->MultiTexCoord2svARB = trMultiTexCoord2svARB /* 391 */ |
||
9141 | dispatch->MultiTexCoord3dARB = trMultiTexCoord3dARB /* 392 */ |
||
9142 | dispatch->MultiTexCoord3dvARB = trMultiTexCoord3dvARB /* 393 */ |
||
9143 | dispatch->MultiTexCoord3fARB = trMultiTexCoord3fARB /* 394 */ |
||
9144 | dispatch->MultiTexCoord3fvARB = trMultiTexCoord3fvARB /* 395 */ |
||
9145 | dispatch->MultiTexCoord3iARB = trMultiTexCoord3iARB /* 396 */ |
||
9146 | dispatch->MultiTexCoord3ivARB = trMultiTexCoord3ivARB /* 397 */ |
||
9147 | dispatch->MultiTexCoord3sARB = trMultiTexCoord3sARB /* 398 */ |
||
9148 | dispatch->MultiTexCoord3svARB = trMultiTexCoord3svARB /* 399 */ |
||
9149 | dispatch->MultiTexCoord4dARB = trMultiTexCoord4dARB /* 400 */ |
||
9150 | dispatch->MultiTexCoord4dvARB = trMultiTexCoord4dvARB /* 401 */ |
||
9151 | dispatch->MultiTexCoord4fARB = trMultiTexCoord4fARB /* 402 */ |
||
9152 | dispatch->MultiTexCoord4fvARB = trMultiTexCoord4fvARB /* 403 */ |
||
9153 | dispatch->MultiTexCoord4iARB = trMultiTexCoord4iARB /* 404 */ |
||
9154 | dispatch->MultiTexCoord4ivARB = trMultiTexCoord4ivARB /* 405 */ |
||
9155 | dispatch->MultiTexCoord4sARB = trMultiTexCoord4sARB /* 406 */ |
||
9156 | dispatch->MultiTexCoord4svARB = trMultiTexCoord4svARB /* 407 */ |
||
9157 | dispatch->LoadTransposeMatrixfARB = trLoadTransposeMatrixfARB /* 408 */ |
||
9158 | dispatch->LoadTransposeMatrixdARB = trLoadTransposeMatrixdARB /* 409 */ |
||
9159 | dispatch->MultTransposeMatrixfARB = trMultTransposeMatrixfARB /* 410 */ |
||
9160 | dispatch->MultTransposeMatrixdARB = trMultTransposeMatrixdARB /* 411 */ |
||
9161 | dispatch->SampleCoverageARB = trSampleCoverageARB /* 412 */ |
||
9162 | dispatch->SamplePassARB = trSamplePassARB /* 413 */ |
||
9163 | dispatch->PolygonOffsetEXT = trPolygonOffsetEXT /* 414 */ |
||
9164 | dispatch->GetTexFilterFuncSGIS = trGetTexFilterFuncSGIS /* 415 */ |
||
9165 | dispatch->TexFilterFuncSGIS = trTexFilterFuncSGIS /* 416 */ |
||
9166 | dispatch->GetHistogramEXT = trGetHistogramEXT /* 417 */ |
||
9167 | dispatch->GetHistogramParameterfvEXT = trGetHistogramParameterfvEXT /* 418 */ |
||
9168 | dispatch->GetHistogramParameterivEXT = trGetHistogramParameterivEXT /* 419 */ |
||
9169 | dispatch->GetMinmaxEXT = trGetMinmaxEXT /* 420 */ |
||
9170 | dispatch->GetMinmaxParameterfvEXT = trGetMinmaxParameterfvEXT /* 421 */ |
||
9171 | dispatch->GetMinmaxParameterivEXT = trGetMinmaxParameterivEXT /* 422 */ |
||
9172 | dispatch->GetConvolutionFilterEXT = trGetConvolutionFilterEXT /* 423 */ |
||
9173 | dispatch->GetConvolutionParameterfvEXT = trGetConvolutionParameterfvEXT /* 424 */ |
||
9174 | dispatch->GetConvolutionParameterivEXT = trGetConvolutionParameterivEXT /* 425 */ |
||
9175 | dispatch->GetSeparableFilterEXT = trGetSeparableFilterEXT /* 426 */ |
||
9176 | dispatch->GetColorTableSGI = trGetColorTableSGI /* 427 */ |
||
9177 | dispatch->GetColorTableParameterfvSGI = trGetColorTableParameterfvSGI /* 428 */ |
||
9178 | dispatch->GetColorTableParameterivSGI = trGetColorTableParameterivSGI /* 429 */ |
||
9179 | dispatch->PixelTexGenSGIX = trPixelTexGenSGIX /* 430 */ |
||
9180 | dispatch->PixelTexGenParameteriSGIS = trPixelTexGenParameteriSGIS /* 431 */ |
||
9181 | dispatch->PixelTexGenParameterivSGIS = trPixelTexGenParameterivSGIS /* 432 */ |
||
9182 | dispatch->PixelTexGenParameterfSGIS = trPixelTexGenParameterfSGIS /* 433 */ |
||
9183 | dispatch->PixelTexGenParameterfvSGIS = trPixelTexGenParameterfvSGIS /* 434 */ |
||
9184 | dispatch->GetPixelTexGenParameterivSGIS = trGetPixelTexGenParameterivSGIS /* 435 */ |
||
9185 | dispatch->GetPixelTexGenParameterfvSGIS = trGetPixelTexGenParameterfvSGIS /* 436 */ |
||
9186 | dispatch->TexImage4DSGIS = trTexImage4DSGIS /* 437 */ |
||
9187 | dispatch->TexSubImage4DSGIS = trTexSubImage4DSGIS /* 438 */ |
||
9188 | dispatch->AreTexturesResidentEXT = trAreTexturesResidentEXT /* 439 */ |
||
9189 | dispatch->GenTexturesEXT = trGenTexturesEXT /* 440 */ |
||
9190 | dispatch->IsTextureEXT = trIsTextureEXT /* 441 */ |
||
9191 | dispatch->DetailTexFuncSGIS = trDetailTexFuncSGIS /* 442 */ |
||
9192 | dispatch->GetDetailTexFuncSGIS = trGetDetailTexFuncSGIS /* 443 */ |
||
9193 | dispatch->SharpenTexFuncSGIS = trSharpenTexFuncSGIS /* 444 */ |
||
9194 | dispatch->GetSharpenTexFuncSGIS = trGetSharpenTexFuncSGIS /* 445 */ |
||
9195 | dispatch->SampleMaskSGIS = trSampleMaskSGIS /* 446 */ |
||
9196 | dispatch->SamplePatternSGIS = trSamplePatternSGIS /* 447 */ |
||
9197 | dispatch->ColorPointerEXT = trColorPointerEXT /* 448 */ |
||
9198 | dispatch->EdgeFlagPointerEXT = trEdgeFlagPointerEXT /* 449 */ |
||
9199 | dispatch->IndexPointerEXT = trIndexPointerEXT /* 450 */ |
||
9200 | dispatch->NormalPointerEXT = trNormalPointerEXT /* 451 */ |
||
9201 | dispatch->TexCoordPointerEXT = trTexCoordPointerEXT /* 452 */ |
||
9202 | dispatch->VertexPointerEXT = trVertexPointerEXT /* 453 */ |
||
9203 | dispatch->SpriteParameterfSGIX = trSpriteParameterfSGIX /* 454 */ |
||
9204 | dispatch->SpriteParameterfvSGIX = trSpriteParameterfvSGIX /* 455 */ |
||
9205 | dispatch->SpriteParameteriSGIX = trSpriteParameteriSGIX /* 456 */ |
||
9206 | dispatch->SpriteParameterivSGIX = trSpriteParameterivSGIX /* 457 */ |
||
9207 | dispatch->PointParameterfEXT = trPointParameterfEXT /* 458 */ |
||
9208 | dispatch->PointParameterfvEXT = trPointParameterfvEXT /* 459 */ |
||
9209 | dispatch->GetInstrumentsSGIX = trGetInstrumentsSGIX /* 460 */ |
||
9210 | dispatch->InstrumentsBufferSGIX = trInstrumentsBufferSGIX /* 461 */ |
||
9211 | dispatch->PollInstrumentsSGIX = trPollInstrumentsSGIX /* 462 */ |
||
9212 | dispatch->ReadInstrumentsSGIX = trReadInstrumentsSGIX /* 463 */ |
||
9213 | dispatch->StartInstrumentsSGIX = trStartInstrumentsSGIX /* 464 */ |
||
9214 | dispatch->StopInstrumentsSGIX = trStopInstrumentsSGIX /* 465 */ |
||
9215 | dispatch->FrameZoomSGIX = trFrameZoomSGIX /* 466 */ |
||
9216 | dispatch->TagSampleBufferSGIX = trTagSampleBufferSGIX /* 467 */ |
||
9217 | dispatch->ReferencePlaneSGIX = trReferencePlaneSGIX /* 468 */ |
||
9218 | dispatch->FlushRasterSGIX = trFlushRasterSGIX /* 469 */ |
||
9219 | dispatch->GetListParameterfvSGIX = trGetListParameterfvSGIX /* 470 */ |
||
9220 | dispatch->GetListParameterivSGIX = trGetListParameterivSGIX /* 471 */ |
||
9221 | dispatch->ListParameterfSGIX = trListParameterfSGIX /* 472 */ |
||
9222 | dispatch->ListParameterfvSGIX = trListParameterfvSGIX /* 473 */ |
||
9223 | dispatch->ListParameteriSGIX = trListParameteriSGIX /* 474 */ |
||
9224 | dispatch->ListParameterivSGIX = trListParameterivSGIX /* 475 */ |
||
9225 | dispatch->FragmentColorMaterialSGIX = trFragmentColorMaterialSGIX /* 476 */ |
||
9226 | dispatch->FragmentLightfSGIX = trFragmentLightfSGIX /* 477 */ |
||
9227 | dispatch->FragmentLightfvSGIX = trFragmentLightfvSGIX /* 478 */ |
||
9228 | dispatch->FragmentLightiSGIX = trFragmentLightiSGIX /* 479 */ |
||
9229 | dispatch->FragmentLightivSGIX = trFragmentLightivSGIX /* 480 */ |
||
9230 | dispatch->FragmentLightModelfSGIX = trFragmentLightModelfSGIX /* 481 */ |
||
9231 | dispatch->FragmentLightModelfvSGIX = trFragmentLightModelfvSGIX /* 482 */ |
||
9232 | dispatch->FragmentLightModeliSGIX = trFragmentLightModeliSGIX /* 483 */ |
||
9233 | dispatch->FragmentLightModelivSGIX = trFragmentLightModelivSGIX /* 484 */ |
||
9234 | dispatch->FragmentMaterialfSGIX = trFragmentMaterialfSGIX /* 485 */ |
||
9235 | dispatch->FragmentMaterialfvSGIX = trFragmentMaterialfvSGIX /* 486 */ |
||
9236 | dispatch->FragmentMaterialiSGIX = trFragmentMaterialiSGIX /* 487 */ |
||
9237 | dispatch->FragmentMaterialivSGIX = trFragmentMaterialivSGIX /* 488 */ |
||
9238 | dispatch->GetFragmentLightfvSGIX = trGetFragmentLightfvSGIX /* 489 */ |
||
9239 | dispatch->GetFragmentLightivSGIX = trGetFragmentLightivSGIX /* 490 */ |
||
9240 | dispatch->GetFragmentMaterialfvSGIX = trGetFragmentMaterialfvSGIX /* 491 */ |
||
9241 | dispatch->GetFragmentMaterialivSGIX = trGetFragmentMaterialivSGIX /* 492 */ |
||
9242 | dispatch->LightEnviSGIX = trLightEnviSGIX /* 493 */ |
||
9243 | dispatch->VertexWeightfEXT = trVertexWeightfEXT /* 494 */ |
||
9244 | dispatch->VertexWeightfvEXT = trVertexWeightfvEXT /* 495 */ |
||
9245 | dispatch->VertexWeightPointerEXT = trVertexWeightPointerEXT /* 496 */ |
||
9246 | dispatch->FlushVertexArrayRangeNV = trFlushVertexArrayRangeNV /* 497 */ |
||
9247 | dispatch->VertexArrayRangeNV = trVertexArrayRangeNV /* 498 */ |
||
9248 | dispatch->CombinerParameterfvNV = trCombinerParameterfvNV /* 499 */ |
||
9249 | dispatch->CombinerParameterfNV = trCombinerParameterfNV /* 500 */ |
||
9250 | dispatch->CombinerParameterivNV = trCombinerParameterivNV /* 501 */ |
||
9251 | dispatch->CombinerParameteriNV = trCombinerParameteriNV /* 502 */ |
||
9252 | dispatch->CombinerInputNV = trCombinerInputNV /* 503 */ |
||
9253 | dispatch->CombinerOutputNV = trCombinerOutputNV /* 504 */ |
||
9254 | dispatch->FinalCombinerInputNV = trFinalCombinerInputNV /* 505 */ |
||
9255 | dispatch->GetCombinerInputParameterfvNV = trGetCombinerInputParameterfvNV /* 506 */ |
||
9256 | dispatch->GetCombinerInputParameterivNV = trGetCombinerInputParameterivNV /* 507 */ |
||
9257 | dispatch->GetCombinerOutputParameterfvNV = trGetCombinerOutputParameterfvNV /* 508 */ |
||
9258 | dispatch->GetCombinerOutputParameterivNV = trGetCombinerOutputParameterivNV /* 509 */ |
||
9259 | dispatch->GetFinalCombinerInputParameterfvNV = trGetFinalCombinerInputParameterfvNV /* 510 */ |
||
9260 | dispatch->GetFinalCombinerInputParameterivNV = trGetFinalCombinerInputParameterivNV /* 511 */ |
||
9261 | dispatch->ResizeBuffersMESA = trResizeBuffersMESA /* 512 */ |
||
9262 | dispatch->WindowPos2dMESA = trWindowPos2dMESA /* 513 */ |
||
9263 | dispatch->WindowPos2dvMESA = trWindowPos2dvMESA /* 514 */ |
||
9264 | dispatch->WindowPos2fMESA = trWindowPos2fMESA /* 515 */ |
||
9265 | dispatch->WindowPos2fvMESA = trWindowPos2fvMESA /* 516 */ |
||
9266 | dispatch->WindowPos2iMESA = trWindowPos2iMESA /* 517 */ |
||
9267 | dispatch->WindowPos2ivMESA = trWindowPos2ivMESA /* 518 */ |
||
9268 | dispatch->WindowPos2sMESA = trWindowPos2sMESA /* 519 */ |
||
9269 | dispatch->WindowPos2svMESA = trWindowPos2svMESA /* 520 */ |
||
9270 | dispatch->WindowPos3dMESA = trWindowPos3dMESA /* 521 */ |
||
9271 | dispatch->WindowPos3dvMESA = trWindowPos3dvMESA /* 522 */ |
||
9272 | dispatch->WindowPos3fMESA = trWindowPos3fMESA /* 523 */ |
||
9273 | dispatch->WindowPos3fvMESA = trWindowPos3fvMESA /* 524 */ |
||
9274 | dispatch->WindowPos3iMESA = trWindowPos3iMESA /* 525 */ |
||
9275 | dispatch->WindowPos3ivMESA = trWindowPos3ivMESA /* 526 */ |
||
9276 | dispatch->WindowPos3sMESA = trWindowPos3sMESA /* 527 */ |
||
9277 | dispatch->WindowPos3svMESA = trWindowPos3svMESA /* 528 */ |
||
9278 | dispatch->WindowPos4dMESA = trWindowPos4dMESA /* 529 */ |
||
9279 | dispatch->WindowPos4dvMESA = trWindowPos4dvMESA /* 530 */ |
||
9280 | dispatch->WindowPos4fMESA = trWindowPos4fMESA /* 531 */ |
||
9281 | dispatch->WindowPos4fvMESA = trWindowPos4fvMESA /* 532 */ |
||
9282 | dispatch->WindowPos4iMESA = trWindowPos4iMESA /* 533 */ |
||
9283 | dispatch->WindowPos4ivMESA = trWindowPos4ivMESA /* 534 */ |
||
9284 | dispatch->WindowPos4sMESA = trWindowPos4sMESA /* 535 */ |
||
9285 | dispatch->WindowPos4svMESA = trWindowPos4svMESA /* 536 */ |
||
9286 | dispatch->BlendFuncSeparateEXT = trBlendFuncSeparateEXT /* 537 */ |
||
9287 | dispatch->IndexMaterialEXT = trIndexMaterialEXT /* 538 */ |
||
9288 | dispatch->IndexFuncEXT = trIndexFuncEXT /* 539 */ |
||
9289 | dispatch->LockArraysEXT = trLockArraysEXT /* 540 */ |
||
9290 | dispatch->UnlockArraysEXT = trUnlockArraysEXT /* 541 */ |
||
9291 | dispatch->CullParameterdvEXT = trCullParameterdvEXT /* 542 */ |
||
9292 | dispatch->CullParameterfvEXT = trCullParameterfvEXT /* 543 */ |
||
9293 | dispatch->HintPGI = trHintPGI /* 544 */ |
||
9294 | dispatch->FogCoordfEXT = trFogCoordfEXT /* 545 */ |
||
9295 | dispatch->FogCoordfvEXT = trFogCoordfvEXT /* 546 */ |
||
9296 | dispatch->FogCoorddEXT = trFogCoorddEXT /* 547 */ |
||
9297 | dispatch->FogCoorddvEXT = trFogCoorddvEXT /* 548 */ |
||
9298 | dispatch->FogCoordPointerEXT = trFogCoordPointerEXT /* 549 */ |
||
9299 | dispatch->GetColorTableEXT = trGetColorTableEXT /* 550 */ |
||
9300 | dispatch->GetColorTableParameterivEXT = trGetColorTableParameterivEXT /* 551 */ |
||
9301 | dispatch->GetColorTableParameterfvEXT = trGetColorTableParameterfvEXT /* 552 */ |
||
9302 | #endif |
||
9303 | } |
||
9304 | |||
9305 | |||
9306 | #else |
||
9307 | extern void tr_wrapper_dummy_func(void); |
||
9308 | void tr_wrapper_dummy_func(void) |
||
9309 | { |
||
9310 | } |
||
9311 | #endif |