← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/extras/Mesa/src/Trace/tr_wrapper.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unix/xc/extras/Mesa/src/Trace/tr_wrapper.c
 
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