target-i386/opengl_exec.c

   1 /*
   2  *  Host-side implementation of GL/GLX API
   3  *
   4  *  Copyright (c) 2006,2007 Even Rouault
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <assert.h>
  29 #include <string.h>
  30
  31 void init_process_tab(void);
  32
  33 #ifdef _WIN32
  34
  35 #include <windows.h>
  36
  37 //#define _MK_DBG_
  38
  39 #define IsViewable 2
  40 #define False 0
  41 #define True 1
  42
  43
  44 #define GL_GLEXT_PROTOTYPES
  45 #include "opengl_func.h"
  46 #include "opengl_utils.h"
  47 #include "mesa_glx.h"
  48 #include "mesa_glxext.h"
  49 #include "mesa_glu.h"
  50 #include "mesa_mipmap.c"
  51
  52 typedef struct
  53 {
  54         HGLRC context;
  55         void *backBuffer;
  56         int width;
  57         int height;
  58         int colorFormat;
  59         unsigned int colorBits;
  60 } PbufferInfo;
  61
  62 typedef struct
  63 {
  64         void* key;
  65         void* value;
  66         void* hWnd; /* Surface?? À§?? Window Handle*/
  67         void* cDC; /*Context?? À§?? Dummy Window Handle*/
  68 } Assoc;
  69
  70 #define MAX_HANDLED_PROCESS 100
  71 #define MAX_ASSOC_SIZE 100
  72 #define MAX_FBCONFIG 10
  73 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
  74
  75 typedef struct
  76 {
  77         int x;
  78         int y;
  79         int width;
  80         int height;
  81         int map_state;
  82 } WindowPosStruct;
  83
  84 typedef struct
  85 {
  86         GLbitfield     mask;
  87         int            activeTextureIndex;
  88 } ClientState;
  89
  90 #define MAX_CLIENT_STATE_STACK_SIZE 16
  91 #define NB_MAX_TEXTURES 16
  92 #define MY_GL_MAX_VERTEX_ATTRIBS_ARB 16
  93 #define MY_GL_MAX_VERTEX_ATTRIBS_NV 16
  94 #define MY_GL_MAX_VARIANT_POINTER_EXT 16
  95
  96 typedef struct
  97 {
  98         int ref;
  99         int fake_ctxt;
 100         int fake_shareList;
 101         HGLRC context;
 102         HDC drawable;
 103
 104         void* vertexPointer;
 105         void* normalPointer;
 106         void* colorPointer;
 107         void* secondaryColorPointer;
 108         void* indexPointer;
 109         void* texCoordPointer[NB_MAX_TEXTURES];
 110         void* edgeFlagPointer;
 111         void* vertexAttribPointer[MY_GL_MAX_VERTEX_ATTRIBS_ARB];
 112         void* vertexAttribPointerNV[MY_GL_MAX_VERTEX_ATTRIBS_NV];
 113         void* weightPointer;
 114         void* matrixIndexPointer;
 115         void* fogCoordPointer;
 116         void* variantPointerEXT[MY_GL_MAX_VARIANT_POINTER_EXT];
 117         void* interleavedArrays;
 118         void* elementPointerATI;
 119
 120         int vertexPointerSize;
 121         int normalPointerSize;
 122         int colorPointerSize;
 123         int secondaryColorPointerSize;
 124         int indexPointerSize;
 125         int texCoordPointerSize[NB_MAX_TEXTURES];
 126         int edgeFlagPointerSize;
 127         int vertexAttribPointerSize[MY_GL_MAX_VERTEX_ATTRIBS_ARB];
 128         int vertexAttribPointerNVSize[MY_GL_MAX_VERTEX_ATTRIBS_NV];
 129         int weightPointerSize;
 130         int matrixIndexPointerSize;
 131         int fogCoordPointerSize;
 132         int variantPointerEXTSize[MY_GL_MAX_VARIANT_POINTER_EXT];
 133         int interleavedArraysSize;
 134         int elementPointerATISize;
 135
 136         int selectBufferSize;
 137         void* selectBufferPtr;
 138         int feedbackBufferSize;
 139         void* feedbackBufferPtr;
 140
 141         ClientState clientStateStack[MAX_CLIENT_STATE_STACK_SIZE];
 142         int clientStateSp;
 143         int activeTextureIndex;
 144
 145         unsigned int ownTabTextures[32768];
 146         unsigned int* tabTextures;
 147         RangeAllocator ownTextureAllocator;
 148         RangeAllocator* textureAllocator;
 149
 150         unsigned int ownTabBuffers[32768];
 151         unsigned int* tabBuffers;
 152         RangeAllocator ownBufferAllocator;
 153         RangeAllocator* bufferAllocator;
 154
 155         unsigned int ownTabLists[32768];
 156         unsigned int* tabLists;
 157         RangeAllocator ownListAllocator;
 158         RangeAllocator* listAllocator;
 159
 160 #ifdef SYSTEMATIC_ERROR_CHECK
 161         int last_error;
 162 #endif
 163 } GLState;
 164
 165 typedef struct
 166 {
 167         PIXELFORMATDESCRIPTOR pfd;
 168         unsigned int visualID;
 169 } WGLFBConfig;
 170
 171 typedef struct
 172 {
 173         int internal_num;
 174         int process_id;
 175         int instr_counter;
 176
 177         int x, y, width, height;
 178         WindowPosStruct currentDrawablePos;
 179
 180         int next_available_context_number;
 181         int next_available_pbuffer_number;
 182
 183         int nbGLStates;
 184         GLState default_state;
 185         GLState** glstates;
 186         GLState* current_state;
 187
 188         int nfbconfig;
 189         WGLFBConfig* fbconfigs[MAX_FBCONFIG];
 190         int fbconfigs_max[MAX_FBCONFIG];
 191         int nfbconfig_total;
 192
 193         Assoc association_fakecontext_glxcontext[MAX_ASSOC_SIZE];
 194         Assoc association_fakepbuffer_pbuffer[MAX_ASSOC_SIZE];
 195         Assoc association_clientdrawable_serverdrawable[MAX_ASSOC_SIZE];
 196         Assoc association_fakecontext_visual[MAX_ASSOC_SIZE];
 197 } ProcessStruct;
 198
 199 int last_process_id = 0;
 200
 201
 202 typedef struct
 203 {
 204         int attribListLength;
 205         int* attribList;
 206         unsigned int visualID;
 207         /*PIXELFORMATDESCRIPTOR* visInfo;*/
 208 } AssocAttribListVisual;
 209
 210 #define ARG_TO_CHAR(x)                (char)(x)
 211 #define ARG_TO_UNSIGNED_CHAR(x)       (unsigned char)(x)
 212 #define ARG_TO_SHORT(x)               (short)(x)
 213 #define ARG_TO_UNSIGNED_SHORT(x)      (unsigned short)(x)
 214 #define ARG_TO_INT(x)                 (int)(x)
 215 #define ARG_TO_UNSIGNED_INT(x)        (unsigned int)(x)
 216 #define ARG_TO_FLOAT(x)               (*(float*)&(x))
 217 #define ARG_TO_DOUBLE(x)              (*(double*)(x))
 218
 219 #define GET_EXT_PTR(type, funcname, args_decl) \
 220         static int detect_##funcname = 0; \
 221 static type(*ptr_func_##funcname)args_decl = NULL; \
 222 if (detect_##funcname == 0) \
 223 { \
 224         detect_##funcname = 1; \
 225         ptr_func_##funcname = (type(*)args_decl)wglGetProcAddress((const GLubyte*)#funcname); \
 226         assert (ptr_func_##funcname); \
 227 }
 228
 229 #define GET_EXT_PTR_NO_FAIL(type, funcname, args_decl) \
 230         static int detect_##funcname = 0; \
 231 static type(*ptr_func_##funcname)args_decl = NULL; \
 232 if (detect_##funcname == 0) \
 233 { \
 234         detect_##funcname = 1; \
 235         ptr_func_##funcname = (type(*)args_decl)wglGetProcAddress((const GLubyte*)#funcname); \
 236 }
 237
 238
 239 #include "server_stub.c"
 240
 241 static void* get_glu_ptr(const char* name)
 242 {
 243         static void* handle = (void*)-1;
 244         if (handle == (void*)-1)
 245         {
 246 #ifndef WIN32
 247                 handle = dlopen("libGLU.so" ,RTLD_LAZY);
 248                 if (!handle) {
 249                         fprintf (stderr, "can't load libGLU.so : %s\n", dlerror());
 250                 }
 251 #else
 252                 handle = (void *)LoadLibrary("glu32.dll");
 253                 if (!handle) {
 254                         fprintf (stderr, "can't load glu32.dll\n");
 255                 }
 256 #endif
 257         }
 258         if (handle)
 259         {
 260 #ifndef WIN32
 261                 return dlsym(handle, name);
 262 #else
 263                 return GetProcAddress(handle, name);
 264 #endif
 265         }
 266         return NULL;
 267 }
 268
 269
 270
 271 #define GET_GLU_PTR(type, funcname, args_decl) \
 272         static int detect_##funcname = 0; \
 273 static type(*ptr_func_##funcname)args_decl = NULL; \
 274 if (detect_##funcname == 0) \
 275 { \
 276         detect_##funcname = 1; \
 277         ptr_func_##funcname = (type(*)args_decl)get_glu_ptr(#funcname); \
 278 }
 279
 280
 281 static void _get_window_pos(HWND hWnd, WindowPosStruct* pos)
 282 {
 283         RECT rcWindow;
 284
 285         GetWindowRect(hWnd, &rcWindow);
 286
 287         pos->x = rcWindow.left;
 288         pos->y = rcWindow.top;
 289
 290         pos->width = rcWindow.right - rcWindow.left;
 291         pos->height = rcWindow.bottom - rcWindow.top;
 292
 293         pos->map_state = IsViewable;
 294 }
 295
 296
 297 int display_function_call = 0;
 298
 299 static void init_gl_state(GLState* state)
 300 {
 301         state->textureAllocator = &state->ownTextureAllocator;
 302         state->tabTextures = state->ownTabTextures;
 303         state->bufferAllocator = &state->ownBufferAllocator;
 304         state->tabBuffers = state->ownTabBuffers;
 305         state->listAllocator = &state->ownListAllocator;
 306         state->tabLists = state->ownTabLists;
 307 }
 308
 309
 310 static void destroy_gl_state(GLState* state)
 311 {
 312         int i;
 313         if (state->vertexPointer) free(state->vertexPointer);
 314         if (state->normalPointer) free(state->normalPointer);
 315         if (state->indexPointer) free(state->indexPointer);
 316         if (state->colorPointer) free(state->colorPointer);
 317         if (state->secondaryColorPointer) free(state->secondaryColorPointer);
 318         for(i=0;i<NB_MAX_TEXTURES;i++)
 319         {
 320                 if (state->texCoordPointer[i]) free(state->texCoordPointer[i]);
 321         }
 322         for(i=0;i<MY_GL_MAX_VERTEX_ATTRIBS_ARB;i++)
 323         {
 324                 if (state->vertexAttribPointer[i]) free(state->vertexAttribPointer[i]);
 325         }
 326         for(i=0;i<MY_GL_MAX_VERTEX_ATTRIBS_NV;i++)
 327         {
 328                 if (state->vertexAttribPointerNV[i]) free(state->vertexAttribPointerNV[i]);
 329         }
 330         if (state->weightPointer) free(state->weightPointer);
 331         if (state->matrixIndexPointer) free(state->matrixIndexPointer);
 332         if (state->fogCoordPointer) free(state->fogCoordPointer);
 333         for(i=0;i<MY_GL_MAX_VARIANT_POINTER_EXT;i++)
 334         {
 335                 if (state->variantPointerEXT[i]) free(state->variantPointerEXT[i]);
 336         }
 337         if (state->interleavedArrays) free(state->interleavedArrays);
 338         if (state->elementPointerATI) free(state->elementPointerATI);
 339 }
 340
 341 static void _create_context(ProcessStruct* process, HGLRC ctxt, int fake_ctxt, HGLRC shareList, int fake_shareList)
 342 {
 343         process->glstates = realloc(process->glstates, (process->nbGLStates+1)*sizeof(GLState*));
 344         process->glstates[process->nbGLStates] = malloc(sizeof(GLState));
 345         memset(process->glstates[process->nbGLStates], 0, sizeof(GLState));
 346         process->glstates[process->nbGLStates]->ref = 1;
 347         process->glstates[process->nbGLStates]->context = ctxt;
 348         process->glstates[process->nbGLStates]->fake_ctxt = fake_ctxt;
 349         process->glstates[process->nbGLStates]->fake_shareList = fake_shareList;
 350         init_gl_state(process->glstates[process->nbGLStates]);
 351         if (shareList && fake_shareList)
 352         {
 353                 int i;
 354                 for(i=0;i<process->nbGLStates;i++)
 355                 {
 356                         if (process->glstates[i]->fake_ctxt == fake_shareList)
 357                         {
 358                                 process->glstates[i]->ref ++;
 359                                 process->glstates[process->nbGLStates]->textureAllocator =
 360                                         process->glstates[i]->textureAllocator;
 361                                 process->glstates[process->nbGLStates]->tabTextures =
 362                                         process->glstates[i]->tabTextures;
 363                                 process->glstates[process->nbGLStates]->bufferAllocator =
 364                                         process->glstates[i]->bufferAllocator;
 365                                 process->glstates[process->nbGLStates]->tabBuffers =
 366                                         process->glstates[i]->tabBuffers;
 367                                 process->glstates[process->nbGLStates]->listAllocator =
 368                                         process->glstates[i]->listAllocator;
 369                                 process->glstates[process->nbGLStates]->tabLists =
 370                                         process->glstates[i]->tabLists;
 371                                 break;
 372                         }
 373                 }
 374         }
 375         process->nbGLStates++;
 376 }
 377
 378 WGLFBConfig* get_pfDescriptor(ProcessStruct* process, int client_pfd)
 379 {
 380         int i;
 381         int nbtotal = 0;
 382         for(i=0;i<process->nfbconfig;i++)
 383         {
 384                 assert(client_pfd >= 1 + nbtotal);
 385                 if (client_pfd <= nbtotal + process->fbconfigs_max[i])
 386                 {
 387                         return (WGLFBConfig*) (&process->fbconfigs[i][client_pfd-1 - nbtotal]);
 388                 }
 389                 nbtotal += process->fbconfigs_max[i];
 390         }
 391         return 0;
 392 }
 393
 394 int get_pfdAttrib(PIXELFORMATDESCRIPTOR *ppfd, int attrib, int *value)
 395 {
 396         int answer = 0;
 397
 398         switch(attrib)
 399         {
 400                 case GLX_FBCONFIG_ID:
 401                         answer = (int) ppfd;
 402                         break;
 403
 404                 case GLX_AUX_BUFFERS:
 405                         answer = ppfd->cAuxBuffers;
 406                         break;
 407
 408                 case GLX_STEREO:
 409                         answer = (int)False;
 410                         break;
 411
 412                 case GLX_ACCUM_RED_SIZE:
 413                         answer = ppfd->cAccumRedBits;
 414                         break;
 415
 416                 case GLX_ACCUM_GREEN_SIZE:
 417                         answer = ppfd->cAccumGreenBits;
 418                         break;
 419
 420                 case GLX_ACCUM_BLUE_SIZE:
 421                         answer = ppfd->cAccumBlueBits;
 422                         break;
 423
 424                 case GLX_ACCUM_ALPHA_SIZE:
 425                         answer = ppfd->cAccumAlphaBits;
 426                         break;
 427
 428                 case GLX_RENDER_TYPE:
 429                         answer = (ppfd->iPixelType == PFD_TYPE_RGBA) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
 430                         break;
 431
 432                 case GLX_RGBA:
 433                 case GLX_RGBA_TYPE:
 434                         answer = (ppfd->iPixelType == PFD_TYPE_RGBA) ? (int)True : (int)False;
 435                         break;
 436
 437                 case GLX_COLOR_INDEX_TYPE:
 438                         answer = (ppfd->iPixelType == PFD_TYPE_COLORINDEX) ? (int)True : (int)False;
 439                         break;
 440
 441                 case GLX_USE_GL:
 442                         answer = ((ppfd->dwFlags & PFD_SUPPORT_OPENGL) != 0) ? (int)True : (int)False;
 443                         break;
 444
 445                 case GLX_DOUBLEBUFFER:
 446                         answer = ((ppfd->dwFlags & PFD_DOUBLEBUFFER) != 0) ? (int)True : (int)False;
 447                         break;
 448
 449                 case GLX_DRAWABLE_TYPE:
 450                         answer =  GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
 451                         break;
 452
 453 #ifdef GLX_CONFIG_CAVEAT
 454                 case GLX_CONFIG_CAVEAT:
 455                         answer = GLX_NONE;
 456                         break;
 457
 458                 case GLX_SLOW_CONFIG:
 459                 case GLX_NON_CONFORMANT_CONFIG:
 460                         answer = (int)False;
 461                         break;
 462 #endif /*GLX_CONFIG_CAVEAT not support*/
 463
 464                 case GLX_X_RENDERABLE:
 465                         answer = 1;
 466                         break;
 467
 468                 case GLX_BUFFER_SIZE:
 469                         answer = ppfd->cColorBits;
 470                         break;
 471
 472                 case GLX_RED_SIZE:
 473                         answer = ppfd->cRedBits;
 474                         break;
 475
 476                 case GLX_GREEN_SIZE:
 477                         answer = ppfd->cGreenBits;
 478                         break;
 479
 480                 case GLX_BLUE_SIZE:
 481                         answer = ppfd->cBlueBits;
 482                         break;
 483
 484                 case GLX_ALPHA_SIZE:
 485                         answer = ppfd->cAlphaBits;
 486                         break;
 487
 488                 case GLX_DEPTH_SIZE:
 489                         answer = ppfd->cDepthBits;
 490                         break;
 491
 492                 case GLX_STENCIL_SIZE:
 493                         answer = ppfd->cStencilBits;
 494                         break;
 495
 496                 case GLX_LEVEL:
 497                         answer = 0;
 498                         break;
 499
 500                 case GLX_MAX_PBUFFER_WIDTH:
 501                         answer = 480;
 502                         break;
 503
 504                 case GLX_MAX_PBUFFER_HEIGHT:
 505                         answer = 800;
 506                         break;
 507
 508                 case GLX_MAX_PBUFFER_PIXELS:
 509                         answer = 384000;
 510                         break;
 511
 512                 case GLX_VISUAL_ID:
 513                         answer = 0;
 514                         break;
 515
 516 #ifdef GLX_X_VISUAL_TYPE
 517                 case GLX_X_VISUAL_TYPE:
 518                         answer = GLX_NONE;
 519                         break;
 520
 521                 case GLX_TRUE_COLOR:
 522                 case GLX_DIRECT_COLOR:
 523                 case GLX_PSEUDO_COLOR:
 524                 case GLX_STATIC_COLOR:
 525                 case GLX_GRAY_SCALE:
 526                 case GLX_STATIC_GRAY:
 527                         answer = False;
 528                         break;
 529 #endif /*GLX_X_VISUAL_TYPE not support*/
 530
 531                 case GLX_SAMPLE_BUFFERS:
 532                 case GLX_SAMPLES:
 533                         answer = 0;
 534                         break;
 535
 536 #ifdef GLX_TRANSPARENT_TYPE
 537                 case GLX_TRANSPARENT_TYPE:
 538                         answer = GLX_NONE;
 539                         break;
 540
 541                 case GLX_TRANSPARENT_INDEX_VALUE:
 542                 case GLX_TRANSPARENT_RED_VALUE:
 543                 case GLX_TRANSPARENT_GREEN_VALUE:
 544                 case GLX_TRANSPARENT_ALPHA_VALUE:
 545                 case GLX_TRANSPARENT_BLUE_VALUE:
 546                         answer = GLX_DONT_CARE;
 547                         break;
 548
 549                 case GLX_TRANSPARENT_RGB:
 550                 case GLX_TRANSPARENT_INDEX:
 551                         answer = (int)False;
 552                         break;
 553 #endif  /*GLX_X_VISUAL_TYPE not support*/
 554
 555                 case GLX_FLOAT_COMPONENTS_NV:
 556                 case GLX_PRESERVED_CONTENTS:
 557                         answer = (int)False;
 558                         break;
 559
 560                 default:
 561                         answer = GLX_BAD_ATTRIBUTE;
 562
 563         }
 564
 565         *value = answer;
 566
 567         return 0;
 568 }
 569
 570 void* get_association_fakecontext_glxcontext(ProcessStruct* process, void* fakecontext)
 571 {
 572         int i;
 573         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
 574         {
 575                 if (process->association_fakecontext_glxcontext[i].key == fakecontext)
 576                         return process->association_fakecontext_glxcontext[i].value;
 577         }
 578         return NULL;
 579 }
 580
 581 void set_association_fakecontext_glxcontext(ProcessStruct* process, void* fakecontext, void* glxcontext)
 582 {
 583         int i;
 584         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
 585         {
 586                 if (process->association_fakecontext_glxcontext[i].key == fakecontext)
 587                 {
 588                         break;
 589                 }
 590         }
 591         if (i < MAX_ASSOC_SIZE)
 592         {
 593                 process->association_fakecontext_glxcontext[i].key = fakecontext;
 594                 process->association_fakecontext_glxcontext[i].value = glxcontext;
 595         }
 596         else
 597         {
 598                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
 599         }
 600 }
 601
 602 void get_association_fakecontext_glxwnd(ProcessStruct* process, void* fakecontext, HWND rWnd, HDC rDC)
 603 {
 604         int i;
 605         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
 606         {
 607                 if (process->association_fakecontext_glxcontext[i].key == fakecontext)
 608                 {
 609                         rWnd = (HWND)process->association_fakecontext_glxcontext[i].hWnd;
 610                         rDC = (HDC)process->association_fakecontext_glxcontext[i].cDC;
 611                         return;
 612                 }
 613         }
 614
 615         rWnd = NULL;
 616         rDC = NULL;
 617 }
 618
 619 void set_association_fakecontext_glxwnd(ProcessStruct* process, void* fakecontext, void* glxwnd, void *glxhdc)
 620 {
 621         int i;
 622         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
 623         {
 624                 if (process->association_fakecontext_glxcontext[i].key == fakecontext)
 625                 {
 626                         break;
 627                 }
 628         }
 629         if (i < MAX_ASSOC_SIZE)
 630         {
 631                 process->association_fakecontext_glxcontext[i].key = fakecontext;
 632                 process->association_fakecontext_glxcontext[i].hWnd = glxwnd;
 633                 process->association_fakecontext_glxcontext[i].cDC = glxhdc;
 634         }
 635         else
 636         {
 637                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
 638         }
 639 }
 640
 641 void unset_association_fakecontext_glxcontext(ProcessStruct* process, void* fakecontext)
 642 {
 643         int i;
 644         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
 645         {
 646                 if (process->association_fakecontext_glxcontext[i].key == fakecontext)
 647                 {
 648                         memmove(&process->association_fakecontext_glxcontext[i],
 649                                         &process->association_fakecontext_glxcontext[i+1],
 650                                         sizeof(Assoc) * (MAX_ASSOC_SIZE - 1 - i));
 651                         return;
 652                 }
 653         }
 654 }
 655
 656 unsigned int get_association_fakecontext_visualid(ProcessStruct* process, void* fakecontext)
 657 {
 658         int i;
 659         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_visual[i].key != NULL;i++)
 660         {
 661                 if (process->association_fakecontext_visual[i].key == fakecontext)
 662                         return (unsigned int)process->association_fakecontext_visual[i].value;
 663         }
 664         return 0;
 665 }
 666
 667 void set_association_fakecontext_visualid(ProcessStruct* process, void* fakecontext, unsigned int visualid)
 668 {
 669         int i;
 670         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_visual[i].key != NULL;i++)
 671         {
 672                 if (process->association_fakecontext_visual[i].key == fakecontext)
 673                 {
 674                         break;
 675                 }
 676         }
 677         if (i < MAX_ASSOC_SIZE)
 678         {
 679                 process->association_fakecontext_visual[i].key = fakecontext;
 680                 process->association_fakecontext_visual[i].value = (void *)(long)visualid;
 681         }
 682         else
 683         {
 684                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
 685         }
 686 }
 687
 688 void unset_association_fakecontext_visualid(ProcessStruct* process, void* fakecontext)
 689 {
 690         int i;
 691         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_visual[i].key != NULL;i++)
 692         {
 693                 if (process->association_fakecontext_visual[i].key == fakecontext)
 694                 {
 695                         memmove(&process->association_fakecontext_visual[i],
 696                                         &process->association_fakecontext_visual[i+1],
 697                                         sizeof(Assoc) * (MAX_ASSOC_SIZE - 1 - i));
 698                         return;
 699                 }
 700         }
 701 }
 702
 703 HWND get_association_clientdrawable_serverwnd(ProcessStruct* process, HDC clientdrawable)
 704 {
 705         int i;
 706         for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL; i++)
 707         {
 708                 if (process->association_clientdrawable_serverdrawable[i].key == (void*)clientdrawable)
 709                         return (HWND)process->association_clientdrawable_serverdrawable[i].hWnd;
 710         }
 711         return (HWND)0;
 712 }
 713
 714 HDC get_association_clientdrawable_serverdrawable(ProcessStruct* process, HDC clientdrawable)
 715 {
 716         int i;
 717         for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
 718         {
 719                 if (process->association_clientdrawable_serverdrawable[i].key == (void*)clientdrawable)
 720                         return (HDC)process->association_clientdrawable_serverdrawable[i].value;
 721         }
 722         return (HDC)0;
 723 }
 724
 725 void set_association_clientdrawable_serverwnd(ProcessStruct* process, void* clientdrawable, void* serverwnd)
 726 {
 727         int i;
 728         for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
 729         {
 730                 if (process->association_clientdrawable_serverdrawable[i].key == clientdrawable)
 731                 {
 732                         break;
 733                 }
 734         }
 735         if (i < MAX_ASSOC_SIZE)
 736         {
 737                 process->association_clientdrawable_serverdrawable[i].key = clientdrawable;
 738                 process->association_clientdrawable_serverdrawable[i].hWnd = serverwnd;
 739         }
 740         else
 741         {
 742                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
 743         }
 744 }
 745
 746 void set_association_clientdrawable_serverdrawable(ProcessStruct* process, void* clientdrawable, void* serverdrawable)
 747 {
 748         int i;
 749         for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
 750         {
 751                 if (process->association_clientdrawable_serverdrawable[i].key == clientdrawable)
 752                 {
 753                         break;
 754                 }
 755         }
 756         if (i < MAX_ASSOC_SIZE)
 757         {
 758                 process->association_clientdrawable_serverdrawable[i].key = clientdrawable;
 759                 process->association_clientdrawable_serverdrawable[i].value = serverdrawable;
 760         }
 761         else
 762         {
 763                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
 764         }
 765 }
 766
 767 void unset_association_clientdrawable_serverdrawable(ProcessStruct* process, void* clientdrawable)
 768 {
 769         int i;
 770         for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
 771         {
 772                 if (process->association_clientdrawable_serverdrawable[i].key == clientdrawable)
 773                 {
 774                         memmove(&process->association_clientdrawable_serverdrawable[i],
 775                                         &process->association_clientdrawable_serverdrawable[i+1],
 776                                         sizeof(Assoc) * (MAX_ASSOC_SIZE - 1 - i));
 777                         return;
 778                 }
 779         }
 780 }
 781
 782 HWND get_association_fakepbuffer_pbufferwnd(ProcessStruct* process, void* fakepbuffer)
 783 {
 784         int i;
 785         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL; i++)
 786         {
 787                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
 788                         return (HWND)process->association_fakepbuffer_pbuffer[i].hWnd;
 789         }
 790         return (HWND)0;
 791 }
 792
 793 void set_association_fakepbuffer_pbufferwnd(ProcessStruct* process, void* fakepbuffer, void* pbufferwnd)
 794 {
 795         int i;
 796         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
 797         {
 798                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
 799                 {
 800                         break;
 801                 }
 802         }
 803         if (i < MAX_ASSOC_SIZE)
 804         {
 805                 process->association_fakepbuffer_pbuffer[i].key = fakepbuffer;
 806                 process->association_fakepbuffer_pbuffer[i].hWnd = pbufferwnd;
 807         }
 808         else
 809         {
 810                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
 811         }
 812 }
 813
 814 PbufferInfo *get_association_fakepbuffer_pbinfo(ProcessStruct* process, void* fakepbuffer)
 815 {
 816         int i;
 817         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL; i++)
 818         {
 819                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
 820                         return (PbufferInfo *)process->association_fakepbuffer_pbuffer[i].cDC;
 821         }
 822         return (PbufferInfo *)0;
 823 }
 824
 825 void set_association_fakepbuffer_pbinfo(ProcessStruct* process, void* fakepbuffer, void* pbuffer_info)
 826 {
 827         int i;
 828         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
 829         {
 830                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
 831                 {
 832                         break;
 833                 }
 834         }
 835         if (i < MAX_ASSOC_SIZE)
 836         {
 837                 process->association_fakepbuffer_pbuffer[i].key = fakepbuffer;
 838                 process->association_fakepbuffer_pbuffer[i].cDC= pbuffer_info;
 839         }
 840         else
 841         {
 842                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
 843         }
 844 }
 845
 846 HDC get_association_fakepbuffer_pbuffer(ProcessStruct* process, void* fakepbuffer)
 847 {
 848         int i;
 849         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
 850         {
 851                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
 852                         return (HDC)process->association_fakepbuffer_pbuffer[i].value;
 853         }
 854         return (HDC)NULL;
 855 }
 856
 857 void set_association_fakepbuffer_pbuffer(ProcessStruct* process, void* fakepbuffer, void* pbuffer)
 858 {
 859         int i;
 860         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
 861         {
 862                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
 863                 {
 864                         break;
 865                 }
 866         }
 867         if (i < MAX_ASSOC_SIZE)
 868         {
 869                 process->association_fakepbuffer_pbuffer[i].key = fakepbuffer;
 870                 process->association_fakepbuffer_pbuffer[i].value = pbuffer;
 871         }
 872         else
 873         {
 874                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
 875         }
 876 }
 877
 878 void unset_association_fakepbuffer_pbuffer(ProcessStruct* process, void* fakepbuffer)
 879 {
 880         int i;
 881         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
 882         {
 883                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
 884                 {
 885                         memmove(&process->association_fakepbuffer_pbuffer[i],
 886                                         &process->association_fakepbuffer_pbuffer[i+1],
 887                                         sizeof(Assoc) * (MAX_ASSOC_SIZE - 1 - i));
 888                         return;
 889                 }
 890         }
 891 }
 892
 893 static int get_visual_info_from_visual_id( OGLS_Conn *pConn, int visualid, PIXELFORMATDESCRIPTOR* rpfd)
 894 {
 895         int i;
 896         if( 0 < visualid )
 897         {
 898                 AssocAttribListVisual *tabAssocAttribListVisual = (AssocAttribListVisual *)pConn->tabAssocAttribListVisual ;
 899                 for(i=0;i<pConn->nTabAssocAttribListVisual;i++)
 900                 {
 901                         if ( tabAssocAttribListVisual[i].visualID == visualid)
 902                         {
 903                                 DescribePixelFormat((HDC)pConn->Display, (visualid -1), sizeof( PIXELFORMATDESCRIPTOR), rpfd);
 904                                 return 1;
 905                         }
 906                 }
 907         }
 908
 909         return 0;
 910 }
 911
 912 static int get_default_visual(Display dpy, PIXELFORMATDESCRIPTOR* rpfd)
 913 {
 914         HDC hdc;
 915         hdc = (HDC)dpy;
 916         int n;
 917
 918         if ((n = DescribePixelFormat(hdc, 0, 0, NULL)) > 0)
 919         {
 920                 int i;
 921                 for (i = 0; i < n; i++)
 922                 {
 923                         DescribePixelFormat(hdc, i, sizeof( PIXELFORMATDESCRIPTOR), rpfd);
 924                         if (!(rpfd->dwFlags & PFD_SUPPORT_OPENGL)) continue;
 925                         if (!(rpfd->dwFlags & PFD_DRAW_TO_WINDOW)) continue;
 926                         if (!(rpfd->dwFlags & PFD_DOUBLEBUFFER)) continue;
 927                         if (rpfd->iPixelType != PFD_TYPE_RGBA) continue;
 928                         if (rpfd->cRedBits < 8) continue;
 929                         if (rpfd->cGreenBits < 8) continue;
 930                         if (rpfd->cBlueBits < 8) continue;
 931                         if (rpfd->cAlphaBits < 8) continue;
 932                         if (rpfd->cDepthBits < 16) continue;
 933                         if (rpfd->cStencilBits < 8) continue;
 934
 935                         break;
 936                 }
 937
 938                 if( i < n ) return i + 1;
 939         }
 940
 941         return 0;
 942 }
 943
 944 /* Surface?? 위?? Window ????*/
 945 static HDC create_swindow(OGLS_Conn *pConn, HDC clientdrawable, ProcessStruct* process, int x, int y, int width, int height)
 946 {
 947         RECT rect;
 948         HWND hWnd;
 949         HDC hDC;
 950         WNDCLASS    wc;
 951         LPSTR lpszClassWindowSurface ="WindowSurface";
 952
 953         wc.style                = CS_HREDRAW | CS_VREDRAW;
 954         wc.lpfnWndProc  = (WNDPROC)DefWindowProc;
 955         wc.cbClsExtra   = 0;
 956         wc.cbWndExtra   = 0;
 957         wc.hIcon                = LoadIcon(NULL,IDI_APPLICATION);
 958         wc.hCursor              = LoadCursor(NULL, IDC_ARROW);
 959         wc.hbrBackground        = NULL;
 960         wc.lpszMenuName = NULL;
 961         wc.lpszClassName        = lpszClassWindowSurface;
 962
 963         RegisterClass(&wc);
 964
 965         rect.left   = x;
 966         rect.top    = y;
 967         rect.right  = width;
 968         rect.bottom = height;
 969         AdjustWindowRect(&rect, (WS_OVERLAPPED |WS_POPUP |WS_SYSMENU), False);
 970
 971         hWnd = CreateWindow(lpszClassWindowSurface, lpszClassWindowSurface,
 972                         (WS_OVERLAPPED |WS_POPUP |WS_SYSMENU  ),
 973                         rect.left, rect.top,  rect.right-rect.left, rect.bottom-rect.top,
 974                         NULL, (HMENU)NULL, NULL, NULL);
 975
 976         hDC = GetDC(hWnd);
 977         if(hDC)
 978         {
 979                 pConn->active_win = hDC;
 980                 ShowWindow(hWnd,SW_HIDE);
 981                 set_association_clientdrawable_serverwnd(process, (void *) clientdrawable, (void *) hWnd);
 982         }
 983
 984         return hDC;
 985 }
 986
 987 /* pbuffer?? 위?? Window ????*/
 988 static HDC create_pbwindow(void *fakepbuffer, ProcessStruct* process, int x, int y, int width, int height)
 989 {
 990         RECT rect;
 991         HWND hWnd;
 992         HDC hDC;
 993         WNDCLASS    wc;
 994         LPSTR lpszClassWindowSurface ="PBuffer";
 995
 996         wc.style                = CS_HREDRAW | CS_VREDRAW;
 997         wc.lpfnWndProc  = (WNDPROC)DefWindowProc;
 998         wc.cbClsExtra   = 0;
 999         wc.cbWndExtra   = 0;
1000         wc.hIcon                = LoadIcon(NULL,IDI_APPLICATION);
1001         wc.hCursor              = LoadCursor(NULL, IDC_ARROW);
1002         wc.hbrBackground        = NULL;
1003         wc.lpszMenuName = NULL;
1004         wc.lpszClassName        = lpszClassWindowSurface;
1005
1006         RegisterClass(&wc);
1007
1008         rect.left   = x;
1009         rect.top    = y;
1010         rect.right  = width;
1011         rect.bottom = height;
1012         AdjustWindowRect(&rect, (WS_OVERLAPPED |WS_POPUP |WS_SYSMENU), False);
1013
1014         hWnd = CreateWindow(lpszClassWindowSurface, lpszClassWindowSurface,
1015                         (WS_OVERLAPPED |WS_POPUP |WS_SYSMENU  ),
1016                         rect.left, rect.top,  rect.right-rect.left, rect.bottom-rect.top,
1017                         NULL, (HMENU)NULL, NULL, NULL);
1018
1019         hDC = GetDC(hWnd);
1020         if(hDC)
1021         {
1022                 ShowWindow(hWnd,SW_HIDE);
1023                 set_association_fakepbuffer_pbufferwnd(process, fakepbuffer, (void *) hWnd);
1024         }
1025
1026         return hDC;
1027 }
1028
1029 /* context?? À§?? Dummy Window ????*/
1030 static HDC create_cwindow(int fake_ctx, ProcessStruct* process, int x, int y, int width, int height)
1031 {
1032         RECT rect;
1033         HWND hWnd;
1034         HDC hDC;
1035         WNDCLASS    wc;
1036         LPSTR lpszClassWindowSurface ="Context";
1037
1038         wc.style                = CS_HREDRAW | CS_VREDRAW;
1039         wc.lpfnWndProc  = (WNDPROC)DefWindowProc;
1040         wc.cbClsExtra   = 0;
1041         wc.cbWndExtra   = 0;
1042         wc.hIcon                = LoadIcon(NULL,IDI_APPLICATION);
1043         wc.hCursor              = LoadCursor(NULL, IDC_ARROW);
1044         wc.hbrBackground        = NULL;
1045         wc.lpszMenuName = NULL;
1046         wc.lpszClassName        = lpszClassWindowSurface;
1047
1048         RegisterClass(&wc);
1049
1050         rect.left   = x;
1051         rect.top    = y;
1052         rect.right  = width;
1053         rect.bottom = height;
1054         AdjustWindowRect(&rect, (WS_OVERLAPPED |WS_POPUP |WS_SYSMENU), False);
1055
1056         hWnd = CreateWindow(lpszClassWindowSurface, lpszClassWindowSurface,
1057                         (WS_OVERLAPPED |WS_POPUP |WS_SYSMENU  ),
1058                         rect.left, rect.top,  rect.right-rect.left, rect.bottom-rect.top,
1059                         NULL, (HMENU)NULL, NULL, NULL);
1060
1061         hDC = GetDC(hWnd);
1062         if(hDC)
1063         {
1064                 ShowWindow(hWnd,SW_HIDE);
1065                 set_association_fakecontext_glxwnd(process, (void *) (long)fake_ctx, (void *)hWnd, (void *)hDC);
1066         }
1067
1068         return hDC;
1069 }
1070
1071 static void destroy_glwindow(OGLS_Conn *pConn, HWND hWnd, HDC hDC )
1072 {
1073         ReleaseDC( hWnd, hDC );
1074         DestroyWindow(hWnd);
1075
1076         /*PostQuitMessage(0);*/
1077
1078         if( pConn->active_win == hDC)
1079                 pConn->active_win = 0;
1080 }
1081
1082 static int get_server_texture(ProcessStruct* process, unsigned int client_texture)
1083 {
1084         unsigned int server_texture = 0;
1085         if (client_texture < 32768)
1086         {
1087                 server_texture = process->current_state->tabTextures[client_texture];
1088         }
1089         else
1090         {
1091                 fprintf(stderr, "invalid texture name %d\n", client_texture);
1092         }
1093         return server_texture;
1094 }
1095
1096 static int get_server_list(ProcessStruct* process, unsigned int client_list)
1097 {
1098         unsigned int server_list = 0;
1099         if (client_list < 32768)
1100         {
1101                 server_list = process->current_state->tabLists[client_list];
1102         }
1103         else
1104         {
1105                 fprintf(stderr, "invalid list name %d\n", client_list);
1106         }
1107         return server_list;
1108 }
1109
1110 static int get_server_buffer(ProcessStruct* process, unsigned int client_buffer)
1111 {
1112         unsigned int server_buffer = 0;
1113         if (client_buffer < 32768)
1114         {
1115                 server_buffer = process->current_state->tabBuffers[client_buffer];
1116         }
1117         else
1118         {
1119                 fprintf(stderr, "invalid buffer name %d\n", client_buffer);
1120         }
1121         return server_buffer;
1122 }
1123
1124
1125 static void do_glClientActiveTextureARB(int texture)
1126 {
1127         GET_EXT_PTR_NO_FAIL(void, glClientActiveTextureARB, (int));
1128         if (ptr_func_glClientActiveTextureARB)
1129         {
1130                 ptr_func_glClientActiveTextureARB(texture);
1131         }
1132 }
1133
1134
1135 /*
1136  * Translate the nth element of list from type to GLuint.
1137  */
1138         static GLuint
1139 translate_id(GLsizei n, GLenum type, const GLvoid * list)
1140 {
1141         GLbyte *bptr;
1142         GLubyte *ubptr;
1143         GLshort *sptr;
1144         GLushort *usptr;
1145         GLint *iptr;
1146         GLuint *uiptr;
1147         GLfloat *fptr;
1148
1149         switch (type) {
1150                 case GL_BYTE:
1151                         bptr = (GLbyte *) list;
1152                         return (GLuint) *(bptr + n);
1153                 case GL_UNSIGNED_BYTE:
1154                         ubptr = (GLubyte *) list;
1155                         return (GLuint) *(ubptr + n);
1156                 case GL_SHORT:
1157                         sptr = (GLshort *) list;
1158                         return (GLuint) *(sptr + n);
1159                 case GL_UNSIGNED_SHORT:
1160                         usptr = (GLushort *) list;
1161                         return (GLuint) *(usptr + n);
1162                 case GL_INT:
1163                         iptr = (GLint *) list;
1164                         return (GLuint) *(iptr + n);
1165                 case GL_UNSIGNED_INT:
1166                         uiptr = (GLuint *) list;
1167                         return (GLuint) *(uiptr + n);
1168                 case GL_FLOAT:
1169                         fptr = (GLfloat *) list;
1170                         return (GLuint) *(fptr + n);
1171                 case GL_2_BYTES:
1172                         ubptr = ((GLubyte *) list) + 2 * n;
1173                         return (GLuint) *ubptr * 256 + (GLuint) * (ubptr + 1);
1174                 case GL_3_BYTES:
1175                         ubptr = ((GLubyte *) list) + 3 * n;
1176                         return (GLuint) * ubptr * 65536
1177                                 + (GLuint) *(ubptr + 1) * 256 + (GLuint) * (ubptr + 2);
1178                 case GL_4_BYTES:
1179                         ubptr = ((GLubyte *) list) + 4 * n;
1180                         return (GLuint) *ubptr * 16777216
1181                                 + (GLuint) *(ubptr + 1) * 65536
1182                                 + (GLuint) *(ubptr + 2) * 256 + (GLuint) * (ubptr + 3);
1183                 default:
1184                         return 0;
1185         }
1186 }
1187
1188
1189 static const char *opengl_strtok(const char *s, int *n, char **saveptr, char *prevbuf)
1190 {
1191         char *start;
1192         char *ret;
1193         char *p;
1194         int retlen;
1195     static const char *delim = " \t\n\r/";
1196
1197         if (prevbuf)
1198                 free(prevbuf);
1199
1200     if (s) {
1201         *saveptr = s;
1202     } else {
1203         if (!(*saveptr) || !(*n))
1204             return NULL;
1205         s = *saveptr;
1206     }
1207
1208     for (; *n && strchr(delim, *s); s++, (*n)--) {
1209         if (*s == '/' && *n > 1) {
1210             if (s[1] == '/') {
1211                 do {
1212                     s++, (*n)--;
1213                 } while (*n > 1 && s[1] != '\n' && s[1] != '\r');
1214             } else if (s[1] == '*') {
1215                 do {
1216                     s++, (*n)--;
1217                 } while (*n > 2 && (s[1] != '*' || s[2] != '/'));
1218                 s++, (*n)--;
1219             }
1220         }
1221     }
1222
1223         start = s;
1224     for (; *n && *s && !strchr(delim, *s); s++, (*n)--);
1225         if (*n > 0)
1226                 s++, (*n)--;
1227
1228         *saveptr = s;
1229
1230         retlen = s - start;
1231         ret = malloc(retlen + 1);
1232         p = ret;
1233
1234         while (retlen > 0) {
1235         if (*start == '/' && retlen > 1) {
1236             if (start[1] == '/') {
1237                 do {
1238                     start++, retlen--;
1239                 } while (retlen > 1 && start[1] != '\n' && start[1] != '\r');
1240                                 start++, retlen--;
1241                                 continue;
1242             } else if (start[1] == '*') {
1243                 do {
1244                     start++, retlen--;
1245                 } while (retlen > 2 && (start[1] != '*' || start[2] != '/'));
1246                 start += 3, retlen -= 3;
1247                                 continue;
1248             }
1249         }
1250                 *(p++) = *(start++), retlen--;
1251         }
1252
1253         *p = 0;
1254         return ret;
1255 }
1256
1257 static char *do_eglShaderPatch(const char *source, int length, int *patched_len)
1258 {
1259         char *saveptr = NULL;
1260         char *sp;
1261         char *p = NULL;
1262
1263     if (!length)
1264         length = strlen(source);
1265
1266     *patched_len = 0;
1267     int patched_size = length;
1268     char *patched = malloc(patched_size + 1);
1269
1270     if (!patched)
1271         return NULL;
1272
1273     p = opengl_strtok(source, &length, &saveptr, NULL);
1274     for (; p; p = opengl_strtok(0, &length, &saveptr, p)) {
1275         if (!strncmp(p, "lowp", 4) || !strncmp(p, "mediump", 7) || !strncmp(p, "highp", 5)) {
1276             continue;
1277         } else if (!strncmp(p, "precision", 9)) {
1278             while ((p = opengl_strtok(0, &length, &saveptr, p)) && !strchr(p, ';'));
1279         } else {
1280             if (!strncmp(p, "gl_MaxVertexUniformVectors", 26)) {
1281                 p = "(gl_MaxVertexUniformComponents / 4)";
1282             } else if (!strncmp(p, "gl_MaxFragmentUniformVectors", 28)) {
1283                 p = "(gl_MaxFragmentUniformComponents / 4)";
1284             } else if (!strncmp(p, "gl_MaxVaryingVectors", 20)) {
1285                 p = "(gl_MaxVaryingFloats / 4)";
1286             }
1287
1288             int new_len = strlen(p);
1289             if (*patched_len + new_len > patched_size) {
1290                 patched_size *= 2;
1291                 patched = realloc(patched, patched_size + 1);
1292
1293                 if (!patched)
1294                     return NULL;
1295             }
1296
1297             memcpy(patched + *patched_len, p, new_len);
1298             *patched_len += new_len;
1299         }
1300     }
1301
1302     patched[*patched_len] = 0;
1303     /* check that we don't leave dummy preprocessor lines */
1304     for (sp = patched; *sp;) {
1305         for (; *sp == ' ' || *sp == '\t'; sp++);
1306         if (!strncmp(sp, "#define", 7)) {
1307             for (p = sp + 7; *p == ' ' || *p == '\t'; p++);
1308             if (*p == '\n' || *p == '\r' || *p == '/') {
1309                 memset(sp, 0x20, 7);
1310             }
1311         }
1312         for (; *sp && *sp != '\n' && *sp != '\r'; sp++);
1313         for (; *sp == '\n' || *sp == '\r'; sp++);
1314     }
1315     return patched;
1316 }
1317
1318 static int
1319 shadersrc_gles_to_gl(GLsizei count, const char** string, char **s, const GLint* length, GLint *l)
1320 {
1321         int i;
1322
1323         for(i = 0; i < count; ++i) {
1324                 GLint len;
1325                 if(length) {
1326                         len = length[i];
1327                         if (len < 0)
1328                                 len = string[i] ? strlen(string[i]) : 0;
1329                 } else
1330                         len = string[i] ? strlen(string[i]) : 0;
1331
1332                 if(string[i]) {
1333                         s[i] = do_eglShaderPatch(string[i], len, &l[i]);
1334                         if(!s[i]) {
1335                                 while(i)
1336                                         free(s[--i]);
1337
1338                                 free(l);
1339                                 free(s);
1340                                 return -1;
1341                         }
1342                 } else {
1343                         s[i] = NULL;
1344                         l[i] = 0;
1345                 }
1346         }
1347
1348         return 0;
1349 }
1350
1351
1352 int do_function_call(OGLS_Conn *pConn, int func_number, int pid, long* args, char* ret_string)
1353 {
1354         char ret_char = 0;
1355         int ret_int = 0;
1356         const char* ret_str = NULL;
1357         int iProcess;
1358         ProcessStruct* process = NULL;
1359         ProcessStruct *processTab = (ProcessStruct *) pConn->processTab;
1360
1361         for(iProcess=0;iProcess<MAX_HANDLED_PROCESS;iProcess++)
1362         {
1363                 ProcessStruct *processTab = (ProcessStruct *) pConn->processTab;
1364                 if (processTab[iProcess].process_id == pid)
1365                 {
1366                         process = &processTab[iProcess];
1367                         break;
1368                 }
1369                 else if (processTab[iProcess].process_id == 0)
1370                 {
1371                         process = &processTab[iProcess];
1372                         memset(process, 0, sizeof(ProcessStruct));
1373                         process->process_id = pid;
1374                         process->internal_num = pConn->last_assigned_internal_num++;
1375                         init_gl_state(&process->default_state);
1376                         process->current_state = &process->default_state;
1377                         break;
1378                 }
1379         }
1380         if (process == NULL)
1381         {
1382                 fprintf(stderr, "Too many processes !\n");
1383                 return 0;
1384         }
1385
1386         if (process->internal_num != pConn->last_active_internal_num)
1387         {
1388                 wglMakeCurrent(process->current_state->drawable, process->current_state->context);
1389                 pConn->last_active_internal_num = process->internal_num;
1390         }
1391
1392         process->instr_counter++;
1393         if (display_function_call) fprintf(stderr, "[%d]> %s\n", process->instr_counter, tab_opengl_calls_name[func_number]);
1394
1395 #if defined( _MK_DBG_ )
1396         //printf(" %s Function(%d) \n", tab_opengl_calls_name[func_number], func_number);
1397 #endif
1398
1399         switch (func_number)
1400         {
1401                 case _init_func:
1402                         {
1403                                 *(int*)args[1] = 1;
1404                                 break;
1405                         }
1406
1407                 case _synchronize_func:
1408                         {
1409                                 ret_int = 1;
1410                                 break;
1411                         }
1412
1413                 case _exit_process_func:
1414                         {
1415                                 int i;
1416                                 HWND hWnd;
1417                                 HDC hDC;
1418                                 HGLRC hRC;
1419                                 PbufferInfo *pb_info;
1420
1421                                 for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
1422                                 {
1423                                         hRC = process->association_fakecontext_glxcontext[i].value;
1424                                         hWnd = (HWND) process->association_fakecontext_glxcontext[i].hWnd;
1425                                         hDC = (HDC) process->association_fakecontext_glxcontext[i].cDC;
1426
1427                                         fprintf(stderr, "Destroy context corresponding to fake_context = %ld\n",
1428                                                         (long)process->association_fakecontext_glxcontext[i].key);
1429
1430                                         wglDeleteContext(hRC);
1431                                         ReleaseDC(hWnd, hDC);
1432                                         DestroyWindow(hWnd);
1433                                 }
1434
1435                                 for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
1436                                 {
1437                                         hWnd = (HWND) process->association_fakepbuffer_pbuffer[i].hWnd;
1438                                         hDC = (HDC)process->association_fakepbuffer_pbuffer[i].value;
1439                                         pb_info = (PbufferInfo *) process->association_fakepbuffer_pbuffer[i].cDC;
1440
1441                                         fprintf(stderr, "Destroy pbuffer corresponding to client_drawable = %p\n",
1442                                                         process->association_fakepbuffer_pbuffer[i].key);
1443
1444                                         free(pb_info->backBuffer);
1445                                         free(pb_info);
1446
1447                                         ReleaseDC(hWnd, hDC);
1448                                         DestroyWindow(hWnd);
1449                                 }
1450
1451                                 for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL; i++)
1452                                 {
1453                                         hWnd = (HWND) process->association_clientdrawable_serverdrawable[i].hWnd;
1454                                         hDC = (HDC)process->association_clientdrawable_serverdrawable[i].value;
1455
1456                                         fprintf(stderr, "Destroy window corresponding to client_drawable = %p\n",
1457                                                         process->association_clientdrawable_serverdrawable[i].key);
1458
1459                                         ReleaseDC(hWnd, hDC);
1460                                         DestroyWindow(hWnd);
1461                                 }
1462
1463                                 for(i=0;i<process->nfbconfig;i++)
1464                                 {
1465                                         free(process->fbconfigs[i]);
1466                                 }
1467
1468                                 for(i=0;i<process->nbGLStates;i++)
1469                                 {
1470                                         destroy_gl_state(process->glstates[i]);
1471                                         free(process->glstates[i]);
1472                                 }
1473
1474                                 destroy_gl_state(&process->default_state);
1475                                 free(process->glstates);
1476
1477                                 pConn->active_win = 0;
1478
1479                                 memmove(&processTab[iProcess], &processTab[iProcess+1], (MAX_HANDLED_PROCESS - 1 - iProcess) * sizeof(ProcessStruct));
1480
1481                                 last_process_id = 0;
1482
1483                                 break;
1484                         }
1485
1486                 case _changeWindowState_func:
1487                         {
1488                                 HDC client_drawable = (HDC) args[0];
1489                                 if (display_function_call) fprintf(stderr, "client_drawable=%p\n", (void*)client_drawable);
1490
1491                                 HWND hWnd = get_association_clientdrawable_serverwnd(process, client_drawable);
1492                                 if (hWnd && (args[1] == IsViewable))
1493                                 {
1494                                         ShowWindow(hWnd, SW_SHOW);
1495                                 }
1496
1497                                 break;
1498                         }
1499
1500                 case _moveResizeWindow_func:
1501                         {
1502                                 int* params = (int*)args[1];
1503                                 HDC client_drawable = (HDC)args[0];
1504                                 if (display_function_call) fprintf(stderr, "client_drawable=%p\n", (void*)client_drawable);
1505
1506                                 HWND hWnd = get_association_clientdrawable_serverwnd(process, client_drawable);
1507                                 if (hWnd)
1508                                 {
1509                                         WindowPosStruct pos;
1510                                         _get_window_pos(hWnd, &pos);
1511                                         if (!(params[0] == pos.x && params[1] == pos.y && params[2] == pos.width && params[3] == pos.height))
1512                                         {
1513                                                 int redim = !(params[2] == pos.width && params[3] == pos.height);
1514                                                 pConn->active_win_x = params[0];
1515                                                 pConn->active_win_y = params[1];
1516
1517                                                 //fprintf(stderr, "old x=%d y=%d width=%d height=%d\n", pos.x, pos.y, pos.width, pos.height);
1518                                                 //fprintf(stderr, "new x=%d y=%d width=%d height=%d\n", params[0], params[1], params[2], params[3]);
1519
1520                                                 if (redim)
1521                                                 {
1522                                                         MoveWindow(hWnd, params[0], params[1], params[2], params[3], False);
1523                                                         _get_window_pos(hWnd, &pos);
1524                                                         process->currentDrawablePos = pos;
1525
1526                                                         glViewport(0, 0, pos.width, pos.height);
1527                                                 }
1528                                         }
1529                                 }
1530                                 break;
1531                         }
1532
1533                 case _send_cursor_func:
1534                         {
1535                                 fprintf(stderr, "_send_cursor_func not support \n");
1536                                 break;
1537                         }
1538
1539                 case glXWaitGL_func:
1540                         {
1541                                 ret_int = 0;
1542                                 break;
1543                         }
1544
1545                 case glXWaitX_func:
1546                         {
1547                                 ret_int = 0;
1548                                 break;
1549                         }
1550
1551                 case glXGetFBConfigs_func:
1552                         {
1553                                 ret_int = 0;
1554
1555                                 fprintf(stderr, "glXGetFBConfigs not support \n");
1556
1557                                 /*TODO*/
1558                                 /*TODO*/
1559                                 break;
1560                         }
1561
1562
1563                 case glXChooseFBConfig_func:
1564                 case glXChooseFBConfigSGIX_func:
1565                         {
1566                                 HDC         hdc;
1567                                 WGLFBConfig *fbConfigs, *c;
1568                                 int n;
1569
1570                                 if (process->nfbconfig == MAX_FBCONFIG)
1571                                 {
1572                                         *(int*)args[3] = 0;
1573                                         ret_int = 0;
1574                                 }
1575                                 else
1576                                 {
1577                                         hdc = (HDC) pConn->Display;
1578
1579                                         if ((n = DescribePixelFormat(hdc, 0, 0, NULL)) > 0)
1580                                         {
1581                                                 int i, j;
1582                                                 PIXELFORMATDESCRIPTOR pfd;
1583                                                 for (j = i = 0; i < n; i++)
1584                                                 {
1585                                                         DescribePixelFormat(hdc, i, sizeof pfd, &pfd);
1586                                                         if (!(pfd.dwFlags & PFD_SUPPORT_OPENGL)) continue;
1587                                                         if (!(pfd.dwFlags & PFD_DRAW_TO_WINDOW)) continue;
1588                                                         if (!(pfd.dwFlags & PFD_DOUBLEBUFFER)) continue;
1589                                                         if (pfd.iPixelType != PFD_TYPE_RGBA) continue;
1590                                                         j++;
1591                                                 }
1592
1593                                                 c = fbConfigs = (WGLFBConfig *)malloc(sizeof(WGLFBConfig) * j);
1594
1595                                                 for (i = 0; i < n; i++) {
1596                                                         DescribePixelFormat(hdc, i, sizeof pfd, &pfd);
1597                                                         if (!(pfd.dwFlags & PFD_SUPPORT_OPENGL)) continue;
1598                                                         if (!(pfd.dwFlags & PFD_DRAW_TO_WINDOW)) continue;
1599                                                         if (!(pfd.dwFlags & PFD_DOUBLEBUFFER)) continue;
1600                                                         if (pfd.iPixelType != PFD_TYPE_RGBA) continue;
1601
1602                                                         c->visualID = i + 1;
1603                                                         memcpy(&c->pfd, &pfd, sizeof(PIXELFORMATDESCRIPTOR));
1604 #if defined( _MK_DBG_ )   /* by    19.Nov.2009 */
1605                                                         printf("Choose Config:0x%p VisualID : %d\n ",c, c->visualID);
1606 #endif
1607                                                         c++;
1608                                                 }
1609
1610                                                 *(int*)args[3] = j;
1611
1612                                                 if (fbConfigs)
1613                                                 {
1614                                                         process->fbconfigs[process->nfbconfig] = fbConfigs;
1615                                                         process->fbconfigs_max[process->nfbconfig] = *(int*)args[3];
1616                                                         process->nfbconfig++;
1617                                                         ret_int = 1 + process->nfbconfig_total;
1618                                                         process->nfbconfig_total += process->fbconfigs_max[process->nfbconfig];
1619
1620 #if defined( _MK_DBG_ )
1621                                                         printf(" DescribePixelFormat Num : %d \n", j);
1622 #endif
1623                                                 }
1624                                                 else
1625                                                 {
1626                                                         ret_int = 0;
1627                                                         *(int*)args[3] = 0;
1628                                                 }
1629                                         }
1630                                         else
1631                                         {
1632                                                 ret_int = 0;
1633                                                 *(int*)args[3] = 0;
1634                                                 printf(" DescribePixelFormat - NULL \n");
1635                                         }
1636
1637                                 }
1638
1639                                 break;
1640                         }
1641
1642                 case glXGetFBConfigAttrib_func:
1643                 case glXGetFBConfigAttribSGIX_func:
1644                         {
1645                                 int client_pfd = args[1];
1646                                 WGLFBConfig *fbConfig = get_pfDescriptor(process, client_pfd);
1647
1648                                 ret_int = 0;
1649
1650                                 if (fbConfig)
1651                                         ret_int = get_pfdAttrib(&fbConfig->pfd, args[2], (int*)args[3]);
1652
1653                                 break;
1654                         }
1655
1656                 case glXGetFBConfigAttrib_extended_func:
1657                         {
1658                                 int client_pfd = args[1];
1659                                 int n = args[2];
1660                                 int i;
1661                                 int* attribs = (int*)args[3];
1662                                 int* values = (int*)args[4];
1663                                 int* res = (int*)args[5];
1664                                 WGLFBConfig *fbConfig = get_pfDescriptor(process, client_pfd);
1665
1666                                 for(i=0;i<n;i++)
1667                                 {
1668                                         if (fbConfig)
1669                                         {
1670                                                 res[i] = get_pfdAttrib(&fbConfig->pfd, attribs[i], &values[i]);
1671                                         }
1672                                         else
1673                                         {
1674                                                 res[i] = 0;
1675                                         }
1676                                 }
1677                                 break;
1678                         }
1679
1680                 case glXGetVisualFromFBConfig_func:
1681                         {
1682                                 int client_pfd = args[1];
1683                                 int i;
1684                                 unsigned int visualid;
1685                                 WGLFBConfig *fbConfig = get_pfDescriptor(process, client_pfd);
1686
1687                                 ret_int = 0;
1688
1689                                 if (fbConfig)
1690                                 {
1691                                         visualid = fbConfig->visualID;
1692                                         ret_int = visualid;
1693
1694                                         AssocAttribListVisual *tabAssocAttribListVisual = (AssocAttribListVisual *)pConn->tabAssocAttribListVisual ;
1695                                         for( i = 0; i < pConn->nTabAssocAttribListVisual && (tabAssocAttribListVisual[i].visualID != visualid); i++ );
1696
1697                                         if( i >= pConn->nTabAssocAttribListVisual )
1698                                         {
1699                                                 pConn->tabAssocAttribListVisual = tabAssocAttribListVisual =
1700                                                         realloc(tabAssocAttribListVisual, sizeof(AssocAttribListVisual) * (pConn->nTabAssocAttribListVisual+1));
1701
1702                                                 tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribListLength = 0;
1703                                                 tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribList = NULL;
1704                                                 tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].visualID = visualid;
1705                                                 pConn->nTabAssocAttribListVisual++;
1706                                         }
1707
1708                                         if (display_function_call) fprintf(stderr, "visualid = %d\n", ret_int);
1709                                 }
1710
1711                                 break;
1712                         }
1713
1714                 case glXCreateNewContext_func:
1715                         {
1716                                 int client_pfd = args[1];
1717                                 WGLFBConfig *fbConfig = get_pfDescriptor(process, client_pfd);
1718                                 ret_int = 0;
1719
1720 #if defined( _MK_DBG_ )
1721                                 printf(" Config 0x%p - client_pfd %d \n", fbConfig, client_pfd);
1722 #endif
1723
1724                                 if (fbConfig)
1725                                 {
1726                                         int fake_shareList = args[3];
1727                                         HGLRC ctxt;
1728                                         HGLRC shareList = get_association_fakecontext_glxcontext(process, (void*)(long)fake_shareList);
1729                                         int fake_ctxt = process->next_available_context_number + 1;
1730                                         HDC hdc = create_cwindow(fake_ctxt, process, 0, 0, 10, 10);
1731
1732                                         if(SetPixelFormat(hdc, fbConfig->visualID - 1, NULL))
1733                                         {
1734                                                 ctxt = wglCreateContext (hdc);
1735 #if defined( _MK_DBG_ )
1736                                                 printf("HGLRC 0x%p = wglCreateNewContext(HDC 0x%p) visualID:%d fake_ctx:%d\n", ctxt, hdc, fbConfig->visualID, fake_ctxt);
1737 #endif
1738
1739                                                 if(ctxt)
1740                                                 {
1741                                                         process->next_available_context_number ++;
1742                                                         set_association_fakecontext_visualid(process, (void*)(long)fake_ctxt, fbConfig->visualID);
1743                                                         set_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt, ctxt);
1744                                                         _create_context(process, ctxt, fake_ctxt, shareList, fake_shareList);
1745                                                         ret_int = fake_ctxt;
1746                                                 }
1747                                         }
1748
1749                                         if( 0 == ret_int )
1750                                         {
1751                                                 int i;
1752
1753                                                 for(i=0; i < MAX_ASSOC_SIZE; i++)
1754                                                 {
1755                                                         if (process->association_fakecontext_glxcontext[i].key == (void *) (long)fake_ctxt)
1756                                                         {
1757                                                                 process->association_fakecontext_glxcontext[i].key = NULL;
1758                                                                 process->association_fakecontext_glxcontext[i].value = NULL;
1759                                                                 process->association_fakecontext_glxcontext[i].hWnd = NULL;
1760                                                                 process->association_fakecontext_glxcontext[i].cDC= NULL;
1761                                                                 break;
1762                                                         }
1763                                                 }
1764                                                 printf("wglCreateContext Fail - HDC: 0x%p, visual ID: %d,  Error : %d \n", hdc, fbConfig->visualID, (unsigned int)GetLastError());
1765                                         }
1766                                 }
1767
1768                                 break;
1769                         }
1770
1771                 case glXCreateContext_func:
1772                         {
1773                                 int visualid = (int)args[1];
1774                                 int fake_shareList = (int)args[2];
1775                                 PIXELFORMATDESCRIPTOR pfd;
1776                                 HGLRC shareList = get_association_fakecontext_glxcontext(process, (void*)(long)fake_shareList);
1777                                 HGLRC ctxt = 0;
1778                                 int fake_ctxt = process->next_available_context_number + 1;
1779                                 HDC hdc = create_cwindow(fake_ctxt, process, 0, 0, 10, 10);
1780
1781                                 ret_int = 0;
1782
1783                                 if (1 || display_function_call) fprintf(stderr, "visualid=%d, fake_shareList=%d\n", visualid, fake_shareList);
1784
1785                                 if(get_visual_info_from_visual_id(pConn, visualid, &pfd))
1786                                 {
1787                                         SetPixelFormat(hdc, visualid - 1, &pfd);
1788                                         ctxt = wglCreateContext (hdc);
1789                                 }
1790                                 else
1791                                 {
1792                                         if((visualid = get_default_visual(pConn->Display, &pfd)))
1793                                         {
1794                                                 SetPixelFormat(hdc, visualid - 1, &pfd);
1795                                                 ctxt = wglCreateContext (hdc);
1796                                         }
1797                                 }
1798
1799                                 printf("HGLRC 0x%p = wglCreateContext(HDC 0x%p) visualID:%d \n", ctxt, hdc, visualid);
1800
1801                                 if (ctxt)
1802                                 {
1803                                         process->next_available_context_number ++;
1804                                         set_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt, ctxt);
1805                                         set_association_fakecontext_visualid(process, (void*)(long)fake_ctxt, visualid);
1806                                         _create_context(process, ctxt, fake_ctxt, shareList, fake_shareList);
1807                                         ret_int = fake_ctxt;
1808                                 }
1809
1810                                 if( 0 == ret_int )
1811                                 {
1812                                         int i;
1813
1814                                         for(i=0; i < MAX_ASSOC_SIZE; i++)
1815                                         {
1816                                                 if (process->association_fakecontext_glxcontext[i].key == (void *) (long)fake_ctxt)
1817                                                 {
1818                                                         process->association_fakecontext_glxcontext[i].key = NULL;
1819                                                         process->association_fakecontext_glxcontext[i].value = NULL;
1820                                                         process->association_fakecontext_glxcontext[i].hWnd = NULL;
1821                                                         process->association_fakecontext_glxcontext[i].cDC= NULL;
1822                                                         break;
1823                                                 }
1824                                         }
1825                                         printf("wglCreateContext Fail - HDC: 0x%p, visual ID: %d,  Error : %d \n", hdc, visualid, (unsigned int)GetLastError());
1826                                 }
1827
1828                                 break;
1829                         }
1830
1831                 case glXMakeCurrent_func:
1832                         {
1833                                 int i;
1834                                 HDC client_drawable = (HDC)args[1];
1835                                 HDC drawable = 0;
1836                                 PIXELFORMATDESCRIPTOR pfd;
1837                                 int fake_ctxt = args[2];
1838                                 unsigned int visualid = 0;
1839
1840                                 if (display_function_call) fprintf(stderr, "client_drawable=%p fake_ctx=%d\n", (void*)client_drawable, fake_ctxt);
1841
1842                                 if (client_drawable == 0 && fake_ctxt == 0)
1843                                 {
1844                                         ret_int = wglMakeCurrent(NULL, NULL);
1845                                         ret_int = 1;
1846                                         process->current_state = &process->default_state;
1847                                 }
1848                                 else if ((drawable = (HDC)get_association_fakepbuffer_pbuffer(process, (void*)client_drawable)))
1849                                 {
1850                                         HGLRC ctxt = (HGLRC)get_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt);
1851                                         PbufferInfo *pb_info = get_association_fakepbuffer_pbinfo(process, (void*)client_drawable);
1852
1853                                         if (ctxt == NULL)
1854                                         {
1855                                                 fprintf(stderr, "invalid fake_ctxt (%d) (*)!\n", fake_ctxt);
1856                                                 ret_int = 0;
1857                                         }
1858                                         else
1859                                         {
1860                                                 if( pb_info )
1861                                                 {
1862                                                         pb_info->context = ctxt;
1863                                                 }
1864
1865                                                 visualid = get_association_fakecontext_visualid(process, (void*)(long)fake_ctxt);
1866                                                 if(visualid)
1867                                                 {
1868                                                         /*DescribePixelFormat((HDC)dpy, (visualid -1), sizeof( PIXELFORMATDESCRIPTOR), &pfd);*/
1869
1870                                                         if(SetPixelFormat(drawable, visualid - 1, &pfd))
1871                                                         {
1872                                                                 ret_int = wglMakeCurrent(drawable, ctxt);
1873 #if defined( _MK_DBG_ )
1874                                                                 printf("%d = wglMakeCurrentPBuffer(HDC 0x%p, HGLRC 0x%p) - visualID:%d client_drawable:0x%p\n", ret_int, drawable, ctxt, visualid, client_drawable);
1875 #endif
1876                                                         }
1877                                                         else
1878                                                         {
1879                                                                 fprintf(stderr, "SetPixelFormat Error......\n");
1880                                                                 ret_int = 0;
1881                                                         }
1882
1883                                                 }
1884                                                 else
1885                                                 {
1886                                                         ret_int = 0;
1887                                                 }
1888                                         }
1889                                 }
1890                                 else
1891                                 {
1892                                         HGLRC ctxt = (HGLRC)get_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt);
1893                                         if (ctxt == NULL)
1894                                         {
1895                                                 fprintf(stderr, "invalid fake_ctxt (%d)!\n", fake_ctxt);
1896                                                 ret_int = 0;
1897                                         }
1898                                         else
1899                                         {
1900                                                 visualid = get_association_fakecontext_visualid(process, (void*)(long)fake_ctxt);
1901
1902                                                 if( visualid == 0 )
1903                                                 {
1904                                                         visualid = get_default_visual(pConn->Display, &pfd);
1905                                                 }
1906
1907                                                 drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
1908                                                 if (drawable == 0)
1909                                                 {
1910
1911                                                         drawable = create_swindow(pConn, client_drawable, process, 0, 0, 480, 800);
1912                                                         set_association_clientdrawable_serverdrawable(process, (void*)client_drawable, (void*)drawable);
1913                                                 }
1914
1915                                                 /*DescribePixelFormat((HDC)dpy, (visualid -1), sizeof( PIXELFORMATDESCRIPTOR), &pfd);*/
1916                                                 if(SetPixelFormat(drawable, visualid - 1, &pfd))
1917                                                 {
1918                                                         ret_int = wglMakeCurrent(drawable, ctxt);
1919 #if defined( _MK_DBG_ )
1920                                                         printf("%d = wglMakeCurrent(HDC 0x%p, HGLRC 0x%p) - visualID:%d client_drawable:0x%p\n", ret_int, drawable, ctxt, visualid, client_drawable);
1921 #endif
1922                                                 }
1923                                                 else
1924                                                 {
1925                                                         fprintf(stderr, "SetPixelFormat Error......\n");
1926                                                         ret_int = 0;
1927                                                 }
1928                                         }
1929                                 }
1930
1931                                 if (ret_int)
1932                                 {
1933                                         for(i=0;i<process->nbGLStates;i++)
1934                                         {
1935                                                 if (process->glstates[i]->fake_ctxt == fake_ctxt)
1936                                                 {
1937                                                         process->current_state = process->glstates[i]; /* HACK !!! REMOVE */
1938                                                         process->current_state->drawable = drawable;
1939                                                         break;
1940                                                 }
1941                                         }
1942                                 }
1943                                 break;
1944                         }
1945
1946                 case glXGetConfig_func:
1947                         {
1948                                 int visualid = args[1];
1949                                 PIXELFORMATDESCRIPTOR pfd;
1950
1951                                 if (visualid)
1952                                 {
1953                                         if( get_visual_info_from_visual_id(pConn, visualid, &pfd))
1954                                         {
1955                                                 ret_int = get_pfdAttrib(&pfd, args[2], (int*)args[3]);
1956                                         }
1957                                         else
1958                                         {
1959                                                 if( get_default_visual(pConn->Display, &pfd))
1960                                                         ret_int = get_pfdAttrib(&pfd, args[2], (int*)args[3]);
1961                                                 else
1962                                                         ret_int = GLX_BAD_VISUAL;
1963                                         }
1964                                 }
1965                                 else
1966                                 {
1967                                         if( get_default_visual(pConn->Display, &pfd))
1968                                                 ret_int = get_pfdAttrib(&pfd, args[2], (int*)args[3]);
1969                                         else
1970                                                 ret_int = GLX_BAD_VISUAL;
1971                                 }
1972
1973                                 break;
1974                         }
1975
1976                 case glXChooseVisual_func:
1977                         {
1978                                 PIXELFORMATDESCRIPTOR pfd;
1979                                 unsigned int visualid = 0;
1980                                 AssocAttribListVisual *tabAssocAttribListVisual = (AssocAttribListVisual *)pConn->tabAssocAttribListVisual ;
1981
1982                                 int i;
1983
1984                                 if ((int*)args[2] == NULL)
1985                                         ret_int = 0;
1986
1987                                 visualid = get_default_visual(pConn->Display, &pfd);
1988
1989                                 for( i = 0; i < pConn->nTabAssocAttribListVisual && (tabAssocAttribListVisual[i].visualID != visualid); i++ );
1990
1991                                 if( i >= pConn->nTabAssocAttribListVisual ) {
1992                                         pConn->tabAssocAttribListVisual = tabAssocAttribListVisual =
1993                                                 realloc(tabAssocAttribListVisual, sizeof(AssocAttribListVisual) * (pConn->nTabAssocAttribListVisual+1));
1994
1995                                         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribListLength = 0;
1996                                         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribList = NULL;
1997                                         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].visualID = i;
1998                                         pConn->nTabAssocAttribListVisual++;
1999                                 }
2000
2001                                 ret_int = visualid;
2002                                 break;
2003                         }
2004
2005                 case glXDestroyWindow_func:
2006                         {
2007                                 int i;
2008                                 HDC client_drawable = (HDC)args[1];
2009                                 HDC drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
2010                                 HWND hWnd = get_association_clientdrawable_serverwnd( process, client_drawable);
2011
2012                                 if (display_function_call) fprintf(stderr, "client_drawable=%p\n", (void*)client_drawable);
2013
2014                                 if( drawable && hWnd )
2015                                 {
2016                                         destroy_glwindow(pConn, hWnd, drawable);
2017
2018 #if defined( _MK_DBG_ )
2019                                         printf("DestoryWindw( HWND 0x%p, HDC 0x%p) Client Drawable 0x%p\n", hWnd, drawable, client_drawable);
2020 #endif
2021
2022                                         unset_association_clientdrawable_serverdrawable(process, (void *) (long)client_drawable);
2023
2024                                         for(i=0;i<process->nbGLStates;i++)
2025                                         {
2026                                                 if (process->glstates[i]->drawable == drawable)
2027                                                 {
2028                                                         process->glstates[i]->drawable = 0;
2029                                                 }
2030                                         }
2031
2032                                         if( process->current_state->drawable == drawable )
2033                                                 process->current_state = &process->default_state;
2034                                 }
2035
2036                                 break;
2037                         }
2038
2039
2040                 case glXDestroyContext_func:
2041                         {
2042                                 int fake_ctxt = (int)args[1];
2043                                 HWND hWnd = NULL;
2044                                 HDC hdc = NULL;
2045                                 HGLRC ctxt = (HGLRC)get_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt);
2046
2047                                 if (display_function_call) fprintf(stderr, "fake_ctxt=%d\n", fake_ctxt);
2048
2049                                 if (ctxt == NULL)
2050                                 {
2051                                         fprintf(stderr, "invalid fake_ctxt (%p) !\n", (void*)(long)fake_ctxt);
2052                                 }
2053                                 else
2054                                 {
2055                                         int i;
2056                                         for(i=0;i<process->nbGLStates;i++)
2057                                         {
2058                                                 if (process->glstates[i]->fake_ctxt == fake_ctxt)
2059                                                 {
2060                                                         if (ctxt == process->current_state->context)
2061                                                                 process->current_state = &process->default_state;
2062
2063                                                         int fake_shareList = process->glstates[i]->fake_shareList;
2064                                                         process->glstates[i]->ref --;
2065                                                         if (process->glstates[i]->ref == 0)
2066                                                         {
2067                                                                 fprintf(stderr, "destroy_gl_state fake_ctxt = %d\n", process->glstates[i]->fake_ctxt);
2068                                                                 destroy_gl_state(process->glstates[i]);
2069                                                                 free(process->glstates[i]);
2070                                                                 memmove(&process->glstates[i], &process->glstates[i+1], (process->nbGLStates-i-1) * sizeof(GLState*));
2071                                                                 process->nbGLStates--;
2072                                                         }
2073
2074                                                         if (fake_shareList)
2075                                                         {
2076                                                                 for(i=0;i<process->nbGLStates;i++)
2077                                                                 {
2078                                                                         if (process->glstates[i]->fake_ctxt == fake_shareList)
2079                                                                         {
2080                                                                                 process->glstates[i]->ref --;
2081                                                                                 if (process->glstates[i]->ref == 0)
2082                                                                                 {
2083                                                                                         fprintf(stderr, "destroy_gl_state fake_ctxt = %d\n", process->glstates[i]->fake_ctxt);
2084                                                                                         destroy_gl_state(process->glstates[i]);
2085                                                                                         free(process->glstates[i]);
2086                                                                                         memmove(&process->glstates[i], &process->glstates[i+1], (process->nbGLStates-i-1) * sizeof(GLState*));
2087                                                                                         process->nbGLStates--;
2088                                                                                 }
2089                                                                                 break;
2090                                                                         }
2091                                                                 }
2092                                                         }
2093
2094                                                         wglDeleteContext(ctxt);
2095
2096                                                         get_association_fakecontext_glxwnd(process, (void*)(long)fake_ctxt, hWnd, hdc);
2097                                                         destroy_glwindow(pConn, hWnd, hdc);
2098
2099                                                         unset_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt);
2100                                                         unset_association_fakecontext_visualid(process, (void*)(long)fake_ctxt);
2101
2102 #if defined( _MK_DBG_ )
2103                                                         printf("Destory Context Window ( WHND 0x%p, HRC 0x%p)", hWnd, hdc);
2104                                                         printf("wglDestroyContext(HGLRC 0x%p) - fake context : %d\n", ctxt, fake_ctxt);
2105 #endif
2106                                                         break;
2107                                                 }
2108                                         }
2109                                 }
2110                                 break;
2111                         }
2112
2113                 case glXGetProcAddress_fake_func:
2114                         {
2115                                 char *fun_name = (char*)args[0];
2116                                 if (display_function_call) fprintf(stderr, "%s\n", fun_name);
2117
2118                                 ret_int = 1;
2119                                 break;
2120                         }
2121
2122                 case glXGetProcAddress_global_fake_func:
2123                         {
2124                                 int nbElts = args[0];
2125                                 char* huge_buffer = (char*)args[1];
2126                                 char* result = (char*)args[2];
2127                                 int i;
2128                                 for(i=0;i<nbElts;i++)
2129                                 {
2130                                         int len = strlen(huge_buffer);
2131
2132                                         result[i] = 1;
2133                                         huge_buffer += len + 1;
2134                                 }
2135                                 break;
2136                         }
2137
2138                 case glXSwapBuffers_func:
2139                         {
2140                                 HDC client_drawable = (HDC)args[1];
2141                                 if (display_function_call) fprintf(stderr, "client_drawable=%p\n", (void*)client_drawable);
2142
2143                                 HDC drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
2144                                 if (drawable == 0)
2145                                 {
2146                                         fprintf(stderr, "unknown client_drawable (%p) !\n", (void*)client_drawable);
2147                                 }
2148                                 else
2149                                 {
2150 #if defined( _MK_DBG_ )   /* by    20.Nov.2009 */
2151                                         printf("SwapBuffers( HDC 0x%p)\n", drawable);
2152 #endif
2153                                         SwapBuffers(drawable);
2154                                 }
2155                                 break;
2156                         }
2157
2158                 case glXQueryVersion_func:
2159                         {
2160                                 int *pMajorVersion = (int *)args[1];
2161                                 int *pMinorVersion = (int *)args[2];
2162                                 int rVersion;
2163
2164                                 rVersion = GetVersion();
2165
2166                                 *pMajorVersion = (rVersion & 0x0000FF00) >> 8;
2167                                 *pMinorVersion = rVersion & 0x000000FF;
2168
2169
2170 #if defined( _MK_DBG_ )   /* by    20.Nov.2009 */
2171                                 printf(" Major Version : %d - Minor Version : %d \n",*pMajorVersion, *pMinorVersion);
2172 #endif
2173                                 break;
2174                         }
2175
2176                 case glXQueryExtensionsString_func:
2177                         {
2178
2179                                 fprintf(stderr, "glXQueryExtensionsString not support (Current WIN32 System)\n");
2180                                 ret_str = NULL;
2181                                 break;
2182                         }
2183
2184                 case glXGetClientString_func:
2185                         {
2186                                 static char *ventor = "support WGL of Microsoft Corporation";
2187                                 ret_str = ventor;//glXGetClientString(dpy, args[1]);
2188                                 break;
2189                         }
2190
2191                 case glXQueryServerString_func:
2192                         {
2193                                 static char *ventor = "support WGL of Microsoft Corporation";
2194                                 ret_str = ventor; //glXQueryServerString(dpy, 0, args[2]);
2195                                 break;
2196                         }
2197
2198                 case glXGetScreenDriver_func:
2199                         {
2200                                 fprintf(stderr, "glXGetScreenDriver not support (Current WIN32 System)\n");
2201                                 ret_str = NULL;
2202                                 break;
2203                         }
2204
2205                 case glXGetDriverConfig_func:
2206                         {
2207                                 fprintf(stderr, "glXGetDriverConfig not support (Current WIN32 System)\n");
2208                                 ret_str = NULL;
2209                                 break;
2210                         }
2211
2212                 case glXCreatePbuffer_func:
2213                         {
2214                                 int client_fbconfig = args[1];
2215                                 int pb_width = 0, pb_height = 0;
2216                                 int *attrib_list = (int*)args[2];
2217                                 int fake_pbuffer = process->next_available_pbuffer_number + 1;
2218                                 HDC pbuffer;
2219                                 WGLFBConfig *fbconfig = get_pfDescriptor(process, client_fbconfig);
2220
2221                                 ret_int = 0;
2222
2223                                 while (attrib_list && *attrib_list != GLX_NONE) {
2224                                         switch (*attrib_list++) {
2225                                                 case GLX_WIDTH:
2226                                                         pb_width = *attrib_list++;
2227                                                         break;
2228
2229                                                 case GLX_HEIGHT:
2230                                                         pb_height = *attrib_list++;
2231                                                         break;
2232
2233                                                 default:
2234                                                         break;
2235                                         }
2236                                 }
2237
2238                                 if(fbconfig)
2239                                 {
2240                                         pbuffer = create_pbwindow((void *) ( fake_pbuffer), process, 0, 0, pb_width, pb_height);
2241
2242 #if defined( _MK_DBG_ )
2243                                         printf(" pbuffer 0x%p = Create_pbwindow( fakebuffer : %d , width : %d, height : %d\n", pbuffer, fake_pbuffer, pb_width, pb_height);
2244 #endif
2245
2246                                         if (pbuffer)
2247                                         {
2248                                                 PbufferInfo *pb_info = (PbufferInfo *)malloc( sizeof(PbufferInfo) );
2249                                                 memset((void *) pb_info, 0, sizeof(PbufferInfo));
2250
2251                                                 process->next_available_pbuffer_number ++;
2252                                                 set_association_fakepbuffer_pbuffer(process, (void*)(long)fake_pbuffer, (void*)pbuffer);
2253                                                 ret_int = fake_pbuffer;
2254
2255                                                 pb_info->width = pb_width;
2256                                                 pb_info->height = pb_height;
2257                                                 pb_info->colorFormat = GLX_RGBA;
2258                                                 get_pfdAttrib(&fbconfig->pfd, GLX_BUFFER_SIZE, &pb_info->colorBits);
2259
2260                                                 pb_info->backBuffer = malloc( pb_width * pb_height * sizeof(int));
2261                                                 set_association_fakepbuffer_pbinfo( process, (void *)(long)fake_pbuffer, (void *) pb_info );
2262                                         }
2263                                 }
2264
2265                                 break;
2266                         }
2267
2268                 case glXCreateGLXPbufferSGIX_func:
2269                         {
2270                                 int client_fbconfig = args[1];
2271                                 int pb_width = 0, pb_height = 0;
2272                                 int fake_pbuffer = process->next_available_pbuffer_number + 1;
2273                                 HDC pbuffer;
2274                                 WGLFBConfig *fbconfig = get_pfDescriptor(process, client_fbconfig);
2275
2276                                 ret_int = 0;
2277
2278                                 pb_width = args[2];
2279                                 pb_height = args[3];
2280
2281                                 if(fbconfig)
2282                                 {
2283                                         pbuffer = create_pbwindow((void *) ( fake_pbuffer), process, 0, 0, pb_width, pb_height);
2284 #if defined( _MK_DBG_ )
2285                                         printf(" pbuffer 0x%p = Create_pbwindow( fakebuffer : %d , width : %d, height : %d\n", pbuffer, fake_pbuffer, pb_width, pb_height);
2286 #endif
2287                                         if (pbuffer)
2288                                         {
2289                                                 PbufferInfo *pb_info = (PbufferInfo *)malloc( sizeof(PbufferInfo) );
2290                                                 memset((void *) pb_info, 0, sizeof(PbufferInfo));
2291
2292                                                 process->next_available_pbuffer_number ++;
2293                                                 set_association_fakepbuffer_pbuffer(process, (void*)(long)fake_pbuffer, (void*)pbuffer);
2294                                                 ret_int = fake_pbuffer;
2295
2296                                                 pb_info->width = pb_width;
2297                                                 pb_info->height = pb_height;
2298                                                 pb_info->colorFormat = GLX_RGBA;
2299                                                 get_pfdAttrib(&fbconfig->pfd, GLX_BUFFER_SIZE, &pb_info->colorBits);
2300
2301                                                 pb_info->backBuffer = malloc( pb_width * pb_height * sizeof(int));
2302                                                 set_association_fakepbuffer_pbinfo( process, (void *)(long)fake_pbuffer, (void *) pb_info );
2303                                         }
2304                                 }
2305
2306                                 break;
2307                         }
2308
2309                 case glXDestroyPbuffer_func:
2310                 case glXDestroyGLXPbufferSGIX_func:
2311                         {
2312                                 HDC fakepbuffer = (HDC)args[1];
2313                                 HDC pbuffer = get_association_fakepbuffer_pbuffer(process, (void *)fakepbuffer);
2314                                 HWND hWnd = get_association_fakepbuffer_pbufferwnd( process, (void *)fakepbuffer);
2315                                 PbufferInfo *pb_info = get_association_fakepbuffer_pbinfo(process, (void *) fakepbuffer);
2316
2317                                 if( pbuffer && hWnd )
2318                                 {
2319                                         if(pb_info)
2320                                         {
2321                                                 free(pb_info->backBuffer);
2322                                                 free(pb_info);
2323                                         }
2324
2325                                         destroy_glwindow(pConn, hWnd, pbuffer);
2326
2327 #if defined( _MK_DBG_ )
2328                                         printf("DestoryPbuffer( HWND 0x%p, HDC 0x%p) fake pbuffer 0x%p\n", hWnd, pbuffer, fakepbuffer);
2329 #endif
2330
2331                                         unset_association_fakepbuffer_pbuffer(process, (void *) (long)fakepbuffer);
2332                                 }
2333
2334                                 break;
2335                         }
2336
2337                 case glXBindTexImageARB_func:
2338                 case glXBindTexImageATI_func:
2339                         {
2340                                 HGLRC pb_context, cur_context;
2341                                 HDC pb_drawable, cur_drawable;
2342                                 int fake_pbuffer = (int)args[1];
2343                                 PbufferInfo *pb_info = get_association_fakepbuffer_pbinfo(process, (void *) (long) fake_pbuffer);
2344
2345                                 ret_int = 0;
2346
2347                                 if( pb_info )
2348                                 {
2349
2350                                         pb_context = pb_info->context;
2351                                         pb_drawable =get_association_fakepbuffer_pbuffer(process, (void *) (long) fake_pbuffer);
2352
2353                                         if( pb_context && pb_drawable )
2354                                         {
2355                                                 cur_context = wglGetCurrentContext( );
2356                                                 cur_drawable = wglGetCurrentDC( );
2357
2358                                                 wglMakeCurrent(pb_drawable, pb_context);
2359                                                 glReadPixels(0, 0, pb_info->width, pb_info->height, pb_info->colorFormat, GL_UNSIGNED_BYTE, pb_info->backBuffer);
2360                                                 wglMakeCurrent(cur_drawable, cur_context);
2361
2362                                                 glTexImage2D(GL_TEXTURE_2D, 0, pb_info->colorFormat, pb_info->width, pb_info->height,
2363                                                                 0, pb_info->colorFormat, GL_UNSIGNED_BYTE, pb_info->backBuffer);
2364                                                 ret_int = 1;
2365                                         }
2366                                         else
2367                                         {
2368                                                 fprintf(stderr, "glXBindTexImage Error - pbuffer Null...\n");
2369                                         }
2370
2371                                 }
2372                                 else
2373                                 {
2374                                         fprintf(stderr, "glXBindTexImage Error - pbuffer information Null...\n");
2375                                 }
2376
2377
2378                                 /*TODO*/
2379                                 /*TODO*/
2380                                 break;
2381                         }
2382
2383                 case glXReleaseTexImageARB_func:
2384                 case glXReleaseTexImageATI_func:
2385                         {
2386                                 int fake_pbuffer = (int)args[1];
2387                                 HDC pbuffer = get_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
2388                                 PbufferInfo *pb_info = get_association_fakepbuffer_pbinfo(process, (void*)fake_pbuffer);
2389
2390                                 ret_int = 0;
2391
2392                                 if ( pbuffer )
2393                                 {
2394                                         if(pb_info)
2395                                         {
2396                                                 glTexImage2D(GL_TEXTURE_2D, 0, pb_info->colorFormat, pb_info->width, pb_info->height, 0, pb_info->colorFormat, GL_UNSIGNED_BYTE, NULL);
2397                                                 ret_int = 1;
2398                                         }
2399                                         else
2400                                         {
2401                                                 fprintf(stderr, "glXReleaseTexImageARB : invalid fake_pbuffer (%d) !\n", (int)fake_pbuffer);
2402                                         }
2403                                 }
2404                                 else
2405                                 {
2406                                         fprintf(stderr, "glXReleaseTexImageARB : invalid fake_pbuffer (%d) !\n", (int)fake_pbuffer);
2407                                 }
2408
2409                                 break;
2410                         }
2411
2412                 case glXQueryContext_func:
2413                         {
2414                                 ret_int = 0;
2415                                 fprintf(stderr, "glXCreateGLXPbufferSGIX not support (Current WIN32 System)\n");
2416                                 break;
2417                         }
2418
2419                 case glXQueryDrawable_func:
2420                         {
2421                                 fprintf(stderr, "glXQueryDrawable not support \n");
2422
2423                                 /*TODO*/
2424                                 /*TODO*/
2425                                 break;
2426                         }
2427
2428                 case glXQueryGLXPbufferSGIX_func:
2429                         {
2430                                 ret_int = 0;
2431
2432                                 fprintf(stderr, "glXCreateGLXPbufferSGIX not support (Current WIN32 System)\n");
2433                                 break;
2434                         }
2435
2436                 case glXCreateContextWithConfigSGIX_func:
2437                         {
2438                                 ret_int = 0;
2439
2440                                 fprintf(stderr, "glXCreateContextWithConfigSGIX not support (Current WIN32 System)\n");
2441                                 break;
2442                         }
2443
2444                 case glXSwapIntervalSGI_func:
2445                         {
2446                                 ret_int = 0;
2447
2448                                 fprintf(stderr, "glXSwapIntervalSGI not support (Current WIN32 System)\n");
2449                                 break;
2450                         }
2451
2452                 case glXCopyContext_func:
2453                         {
2454                                 HGLRC fake_src_ctxt = (HGLRC)args[1];
2455                                 HGLRC fake_dst_ctxt = (HGLRC)args[2];
2456
2457                                 if (display_function_call) fprintf(stderr, "fake_src_ctxt=%p, fake_dst_ctxt=%p\n", fake_src_ctxt, fake_dst_ctxt);
2458
2459                                 fprintf(stderr, "glXCopyContext not support (Current WIN32 System)\n");
2460                                 break;
2461                         }
2462
2463                 case glXIsDirect_func:
2464                         {
2465                                 ret_char = False;
2466                                 fprintf(stderr, "glXCopyContext not support (Current WIN32 System)\n");
2467                                 break;
2468                         }
2469
2470                 case glGetString_func:
2471                         {
2472                                 ret_str = (char*)glGetString(args[0]);
2473                                 break;
2474                         }
2475
2476                         /* Begin of texture stuff */
2477                 case glBindTexture_func:
2478                 case glBindTextureEXT_func:
2479                         {
2480                                 int target = args[0];
2481                                 unsigned int client_texture = args[1];
2482                                 unsigned int server_texture;
2483
2484                                 if (client_texture == 0)
2485                                 {
2486                                         glBindTexture(target, 0);
2487                                 }
2488                                 else
2489                                 {
2490                                         alloc_value(process->current_state->textureAllocator, client_texture);
2491                                         server_texture = process->current_state->tabTextures[client_texture];
2492                                         if (server_texture == 0)
2493                                         {
2494                                                 glGenTextures(1, &server_texture);
2495                                                 process->current_state->tabTextures[client_texture] = server_texture;
2496                                         }
2497                                         glBindTexture(target, server_texture);
2498                                 }
2499                                 break;
2500                         }
2501
2502                 case glGenTextures_fake_func:
2503                         {
2504                                 //GET_EXT_PTR(void, glGenTextures, (GLsizei n, GLuint *textures));
2505                                 int i;
2506                                 int n = args[0];
2507                                 unsigned int* clientTabTextures = malloc(n * sizeof(int));
2508                                 unsigned int* serverTabTextures = malloc(n * sizeof(int));
2509
2510                                 alloc_range(process->current_state->textureAllocator, n, clientTabTextures);
2511
2512                                 glGenTextures(n, serverTabTextures);
2513                                 for(i=0;i<n;i++)
2514                                 {
2515                                         process->current_state->tabTextures[clientTabTextures[i]] = serverTabTextures[i];
2516                                 }
2517
2518                                 free(clientTabTextures);
2519                                 free(serverTabTextures);
2520                                 break;
2521                         }
2522
2523                 case glDeleteTextures_func:
2524                         {
2525                                 //GET_EXT_PTR(void, glDeleteTextures, (GLsizei n, const GLuint *textures));
2526                                 int i;
2527                                 int n = args[0];
2528                                 unsigned int* clientTabTextures = (unsigned int*)args[1];
2529
2530                                 delete_range(process->current_state->textureAllocator, n, clientTabTextures);
2531
2532                                 unsigned int* serverTabTextures = malloc(n * sizeof(int));
2533                                 for(i=0;i<n;i++)
2534                                 {
2535                                         serverTabTextures[i] = get_server_texture(process, clientTabTextures[i]);
2536                                 }
2537                                 glDeleteTextures(n, serverTabTextures);
2538                                 for(i=0;i<n;i++)
2539                                 {
2540                                         process->current_state->tabTextures[clientTabTextures[i]] = 0;
2541                                 }
2542                                 free(serverTabTextures);
2543                                 break;
2544                         }
2545
2546                 case glPrioritizeTextures_func:
2547                         {
2548                                 GET_EXT_PTR(void, glPrioritizeTextures, (GLsizei n, const GLuint *textures, const GLclampf *priorities));
2549
2550                                 int i;
2551                                 int n = args[0];
2552                                 unsigned int* textures = (unsigned int*)args[1];
2553                                 for(i=0;i<n;i++)
2554                                 {
2555                                         textures[i] = get_server_texture(process, textures[i]);
2556                                 }
2557                                 ptr_func_glPrioritizeTextures(n, textures, (const GLclampf*)args[2]);
2558                                 break;
2559                         }
2560
2561                 case glAreTexturesResident_func:
2562                         {
2563                                 GET_EXT_PTR(void, glAreTexturesResident, (GLsizei n, const GLuint *textures, GLboolean *residences));
2564                                 int i;
2565                                 int n = args[0];
2566                                 unsigned int* textures = (unsigned int*)args[1];
2567                                 for(i=0;i<n;i++)
2568                                 {
2569                                         textures[i] = get_server_texture(process, textures[i]);
2570                                 }
2571                                 ptr_func_glAreTexturesResident(n, textures, (GLboolean*)args[2]);
2572                                 break;
2573                         }
2574
2575                 case glIsTexture_func:
2576                 case glIsTextureEXT_func:
2577                         {
2578                                 GET_EXT_PTR(GLboolean, glIsTexture, (GLuint texture ));
2579                                 unsigned int client_texture = args[0];
2580                                 unsigned int server_texture = get_server_texture(process, client_texture);
2581                                 if (server_texture)
2582                                         ret_char = ptr_func_glIsTexture(server_texture);
2583                                 else
2584                                         ret_char = 0;
2585                                 break;
2586                         }
2587
2588                 case glFramebufferTexture1DEXT_func:
2589                         {
2590                                 GET_EXT_PTR(void, glFramebufferTexture1DEXT, (int, int, int, int, int));
2591                                 unsigned int client_texture = args[3];
2592                                 unsigned int server_texture = get_server_texture(process, client_texture);
2593                                 if (server_texture)
2594                                         ptr_func_glFramebufferTexture1DEXT(args[0], args[1], args[2], server_texture, args[4]);
2595                                 break;
2596                         }
2597
2598                 case glFramebufferTexture2DEXT_func:
2599                         {
2600                                 GET_EXT_PTR(void, glFramebufferTexture2DEXT, (int, int, int, int, int));
2601                                 unsigned int client_texture = args[3];
2602                                 unsigned int server_texture = get_server_texture(process, client_texture);
2603                                 if (server_texture)
2604                                         ptr_func_glFramebufferTexture2DEXT(args[0], args[1], args[2], server_texture, args[4]);
2605                                 break;
2606                         }
2607
2608                 case glFramebufferTexture3DEXT_func:
2609                         {
2610                                 GET_EXT_PTR(void, glFramebufferTexture3DEXT, (int, int, int, int, int, int));
2611                                 unsigned int client_texture = args[3];
2612                                 unsigned int server_texture = get_server_texture(process, client_texture);
2613                                 if (server_texture)
2614                                         ptr_func_glFramebufferTexture3DEXT(args[0], args[1], args[2], server_texture, args[4], args[5]);
2615                                 break;
2616                         }
2617                         /* End of texture stuff */
2618
2619                         /* Begin of list stuff */
2620                 case glIsList_func:
2621                         {
2622                                 unsigned int client_list = args[0];
2623                                 unsigned int server_list = get_server_list(process, client_list);
2624                                 if (server_list)
2625                                         ret_char = glIsList(server_list);
2626                                 else
2627                                         ret_char = 0;
2628                                 break;
2629                         }
2630
2631                 case glDeleteLists_func:
2632                         {
2633                                 int i;
2634                                 unsigned int first_client = args[0];
2635                                 int n = args[1];
2636
2637                                 unsigned int first_server = get_server_list(process, first_client);
2638                                 for(i=0;i<n;i++)
2639                                 {
2640                                         if (get_server_list(process, first_client + i) != first_server + i)
2641                                                 break;
2642                                 }
2643                                 if (i == n)
2644                                 {
2645                                         glDeleteLists(first_server, n);
2646                                 }
2647                                 else
2648                                 {
2649                                         for(i=0;i<n;i++)
2650                                         {
2651                                                 glDeleteLists(get_server_list(process, first_client + i), 1);
2652                                         }
2653                                 }
2654
2655                                 for(i=0;i<n;i++)
2656                                 {
2657                                         process->current_state->tabLists[first_client + i] = 0;
2658                                 }
2659                                 delete_consecutive_values(process->current_state->listAllocator, first_client, n);
2660                                 break;
2661                         }
2662
2663                 case glGenLists_fake_func:
2664                         {
2665                                 int i;
2666                                 int n = args[0];
2667                                 unsigned int server_first = glGenLists(n);
2668                                 if (server_first)
2669                                 {
2670                                         unsigned int client_first = alloc_range(process->current_state->listAllocator, n, NULL);
2671                                         for(i=0;i<n;i++)
2672                                         {
2673                                                 process->current_state->tabLists[client_first + i] = server_first + i;
2674                                         }
2675                                 }
2676                                 break;
2677                         }
2678
2679                 case glNewList_func:
2680                         {
2681                                 unsigned int client_list = args[0];
2682                                 int mode = args[1];
2683                                 alloc_value(process->current_state->listAllocator, client_list);
2684                                 unsigned int server_list = get_server_list(process, client_list);
2685                                 if (server_list == 0)
2686                                 {
2687                                         server_list = glGenLists(1);
2688                                         process->current_state->tabLists[client_list] = server_list;
2689                                 }
2690                                 glNewList(server_list, mode);
2691                                 break;
2692                         }
2693
2694                 case glCallList_func:
2695                         {
2696                                 unsigned int client_list = args[0];
2697                                 unsigned int server_list = get_server_list(process, client_list);
2698                                 glCallList(server_list);
2699                                 break;
2700                         }
2701
2702                 case glCallLists_func:
2703                         {
2704                                 int i;
2705                                 int n = args[0];
2706                                 int type = args[1];
2707                                 const GLvoid* lists = (const GLvoid*)args[2];
2708                                 int* new_lists = malloc(sizeof(int) * n);
2709                                 for(i=0;i<n;i++)
2710                                 {
2711                                         new_lists[i] = get_server_list(process, translate_id(i, type, lists));
2712                                 }
2713                                 glCallLists(n, GL_UNSIGNED_INT, new_lists);
2714                                 free(new_lists);
2715                                 break;
2716                         }
2717                         /* End of list stuff */
2718
2719                         /* Begin of buffer stuff */
2720                 case glBindBufferARB_func:
2721                         {
2722                                 GET_EXT_PTR(void, glBindBufferARB, (int,int));
2723                                 int target = args[0];
2724                                 unsigned int client_buffer = args[1];
2725                                 unsigned int server_buffer;
2726
2727                                 if (client_buffer == 0)
2728                                 {
2729                                         ptr_func_glBindBufferARB(target, 0);
2730                                 }
2731                                 else
2732                                 {
2733                                         server_buffer = get_server_buffer(process, client_buffer);
2734                                         ptr_func_glBindBufferARB(target, server_buffer);
2735                                 }
2736                                 break;
2737                         }
2738
2739                 case glGenBuffersARB_fake_func:
2740                         {
2741                                 GET_EXT_PTR(void, glGenBuffersARB, (int,unsigned int*));
2742                                 int i;
2743                                 int n = args[0];
2744                                 unsigned int* clientTabBuffers = malloc(n * sizeof(int));
2745                                 unsigned int* serverTabBuffers = malloc(n * sizeof(int));
2746
2747                                 alloc_range(process->current_state->bufferAllocator, n, clientTabBuffers);
2748
2749                                 ptr_func_glGenBuffersARB(n, serverTabBuffers);
2750                                 for(i=0;i<n;i++)
2751                                 {
2752                                         process->current_state->tabBuffers[clientTabBuffers[i]] = serverTabBuffers[i];
2753                                 }
2754
2755                                 free(clientTabBuffers);
2756                                 free(serverTabBuffers);
2757                                 break;
2758                         }
2759
2760
2761                 case glDeleteBuffersARB_func:
2762                         {
2763                                 GET_EXT_PTR(void, glDeleteBuffersARB, (int,int*));
2764                                 int i;
2765                                 int n = args[0];
2766                                 unsigned int* clientTabBuffers = (unsigned int*)args[1];
2767
2768                                 delete_range(process->current_state->bufferAllocator, n, clientTabBuffers);
2769
2770                                 int* serverTabBuffers = malloc(n * sizeof(int));
2771                                 for(i=0;i<n;i++)
2772                                 {
2773                                         serverTabBuffers[i] = get_server_buffer(process, clientTabBuffers[i]);
2774                                 }
2775                                 ptr_func_glDeleteBuffersARB(n, serverTabBuffers);
2776                                 for(i=0;i<n;i++)
2777                                 {
2778                                         process->current_state->tabBuffers[clientTabBuffers[i]] = 0;
2779                                 }
2780                                 free(serverTabBuffers);
2781                                 break;
2782                         }
2783
2784                 case glIsBufferARB_func:
2785                         {
2786                                 GET_EXT_PTR(int, glIsBufferARB, (int));
2787                                 unsigned int client_buffer = args[0];
2788                                 unsigned int server_buffer = get_server_buffer(process, client_buffer);
2789                                 if (server_buffer)
2790                                         ret_int = ptr_func_glIsBufferARB(server_buffer);
2791                                 else
2792                                         ret_int = 0;
2793                                 break;
2794                         }
2795                         /* Endo of buffer stuff */
2796
2797                 case glShaderSourceARB_fake_func:
2798                         {
2799                                 GET_EXT_PTR(void, glShaderSourceARB, (int,int,char**,void*));
2800                                 int size = args[1];
2801                                 int i;
2802                                 int acc_length = 0;
2803                                 GLcharARB** tab_prog = malloc(size * sizeof(GLcharARB*));
2804                                 int* tab_length = (int*)args[3];
2805                                 for(i=0;i<size;i++)
2806                                 {
2807                                         tab_prog[i] = ((GLcharARB*)args[2]) + acc_length;
2808                                         acc_length += tab_length[i];
2809                                 }
2810                                 ptr_func_glShaderSourceARB(args[0], args[1], tab_prog, tab_length);
2811                                 free(tab_prog);
2812                                 break;
2813                         }
2814
2815                 case glShaderSource_fake_func:
2816                         {
2817                                 GET_EXT_PTR(void, glShaderSource, (int,int,char**,void*));
2818                                 int size = args[1];
2819                                 int i;
2820                                 int acc_length = 0;
2821                                 GLcharARB** tab_prog = malloc(size * sizeof(GLcharARB*));
2822                                 int* tab_length = (int*)args[3];
2823
2824                                 char **tab_prog_new;
2825                                 GLint *tab_length_new;
2826
2827                            tab_prog_new = malloc(args[1]* sizeof(char*));
2828                            tab_length_new = malloc(args[1]* sizeof(GLint));
2829
2830                            memset(tab_prog_new, 0, args[1] * sizeof(char*));
2831                            memset(tab_length_new, 0, args[1] * sizeof(GLint));
2832
2833
2834                                 for(i=0;i<size;i++)
2835                                 {
2836                                         tab_prog[i] = ((GLcharARB*)args[2]) + acc_length;
2837                                         acc_length += tab_length[i];
2838                                 }
2839
2840                                 shadersrc_gles_to_gl(args[1], tab_prog, tab_prog_new, tab_length, tab_length_new);
2841
2842                                 if (!tab_prog_new || !tab_length_new)
2843                                         break;
2844
2845                                 ptr_func_glShaderSource(args[0], args[1], tab_prog_new, tab_length_new);
2846
2847                                 for (i = 0; i < args[1]; i++)
2848                                         free(tab_prog_new[i]);
2849                                 free(tab_prog_new);
2850                                 free(tab_length_new);
2851
2852                                 free(tab_prog);
2853                                 break;
2854                         }
2855
2856                 case glVertexPointer_fake_func:
2857                         {
2858                                 int offset = args[0];
2859                                 int size = args[1];
2860                                 int type = args[2];
2861                                 int stride = args[3];
2862                                 int bytes_size = args[4];
2863                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
2864                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
2865                                 memcpy(process->current_state->vertexPointer + offset, (void*)args[5], bytes_size);
2866                                 /*fprintf(stderr, "glVertexPointer_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
2867                                   size, type, stride, bytes_size);*/
2868                                 glVertexPointer(size, type, stride, process->current_state->vertexPointer);
2869                                 break;
2870                         }
2871
2872                 case glNormalPointer_fake_func:
2873                         {
2874                                 int offset = args[0];
2875                                 int type = args[1];
2876                                 int stride = args[2];
2877                                 int bytes_size = args[3];
2878                                 process->current_state->normalPointerSize = MAX(process->current_state->normalPointerSize, offset + bytes_size);
2879                                 process->current_state->normalPointer = realloc(process->current_state->normalPointer, process->current_state->normalPointerSize);
2880                                 memcpy(process->current_state->normalPointer + offset, (void*)args[4], bytes_size);
2881                                 //fprintf(stderr, "glNormalPointer_fake_func type=%d, stride=%d, byte_size=%d\n", type, stride, bytes_size);
2882                                 glNormalPointer(type, stride, process->current_state->normalPointer);
2883                                 break;
2884                         }
2885
2886                 case glIndexPointer_fake_func:
2887                         {
2888                                 int offset = args[0];
2889                                 int type = args[1];
2890                                 int stride = args[2];
2891                                 int bytes_size = args[3];
2892                                 process->current_state->indexPointerSize = MAX(process->current_state->indexPointerSize, offset + bytes_size);
2893                                 process->current_state->indexPointer = realloc(process->current_state->indexPointer, process->current_state->indexPointerSize);
2894                                 memcpy(process->current_state->indexPointer + offset, (void*)args[4], bytes_size);
2895                                 //fprintf(stderr, "glIndexPointer_fake_func type=%d, stride=%d, byte_size=%d\n", type, stride, bytes_size);
2896                                 glIndexPointer(type, stride, process->current_state->indexPointer);
2897                                 break;
2898                         }
2899
2900                 case glEdgeFlagPointer_fake_func:
2901                         {
2902                                 int offset = args[0];
2903                                 int stride = args[1];
2904                                 int bytes_size = args[2];
2905                                 process->current_state->edgeFlagPointerSize = MAX(process->current_state->edgeFlagPointerSize, offset + bytes_size);
2906                                 process->current_state->edgeFlagPointer = realloc(process->current_state->edgeFlagPointer, process->current_state->edgeFlagPointerSize);
2907                                 memcpy(process->current_state->edgeFlagPointer + offset, (void*)args[3], bytes_size );
2908                                 //fprintf(stderr, "glEdgeFlagPointer_fake_func stride = %d, bytes_size=%d\n", stride, bytes_size);
2909                                 glEdgeFlagPointer(stride, process->current_state->edgeFlagPointer);
2910                                 break;
2911                         }
2912
2913                 case glVertexAttribPointerARB_fake_func:
2914                         {
2915                                 GET_EXT_PTR(void, glVertexAttribPointerARB, (int,int,int,int,int,void*));
2916                                 int offset = args[0];
2917                                 int index = args[1];
2918                                 int size = args[2];
2919                                 int type = args[3];
2920                                 int normalized = args[4];
2921                                 int stride = args[5];
2922                                 int bytes_size = args[6];
2923                                 process->current_state->vertexAttribPointerSize[index] = MAX(process->current_state->vertexAttribPointerSize[index], offset + bytes_size);
2924                                 process->current_state->vertexAttribPointer[index] = realloc(process->current_state->vertexAttribPointer[index],
2925                                                 process->current_state->vertexAttribPointerSize[index]);
2926                                 memcpy(process->current_state->vertexAttribPointer[index] + offset, (void*)args[7], bytes_size);
2927                                 ptr_func_glVertexAttribPointerARB(index, size, type, normalized, stride,
2928                                                 process->current_state->vertexAttribPointer[index]);
2929                                 break;
2930                         }
2931
2932                 case glVertexAttribPointerNV_fake_func:
2933                         {
2934                                 GET_EXT_PTR(void, glVertexAttribPointerNV, (int,int,int,int,void*));
2935                                 int offset = args[0];
2936                                 int index = args[1];
2937                                 int size = args[2];
2938                                 int type = args[3];
2939                                 int stride = args[4];
2940                                 int bytes_size = args[5];
2941                                 process->current_state->vertexAttribPointerNVSize[index] = MAX(process->current_state->vertexAttribPointerNVSize[index], offset + bytes_size);
2942                                 process->current_state->vertexAttribPointerNV[index] = realloc(process->current_state->vertexAttribPointerNV[index],
2943                                                 process->current_state->vertexAttribPointerNVSize[index]);
2944                                 memcpy(process->current_state->vertexAttribPointerNV[index] + offset, (void*)args[6], bytes_size);
2945                                 ptr_func_glVertexAttribPointerNV(index, size, type, stride,
2946                                                 process->current_state->vertexAttribPointerNV[index]);
2947                                 break;
2948                         }
2949
2950                 case glColorPointer_fake_func:
2951                         {
2952                                 int offset = args[0];
2953                                 int size = args[1];
2954                                 int type = args[2];
2955                                 int stride = args[3];
2956                                 int bytes_size = args[4];
2957                                 process->current_state->colorPointerSize = MAX(process->current_state->colorPointerSize, offset + bytes_size);
2958                                 process->current_state->colorPointer = realloc(process->current_state->colorPointer, process->current_state->colorPointerSize);
2959                                 memcpy(process->current_state->colorPointer + offset, (void*)args[5], bytes_size);
2960                                 //fprintf(stderr, "glColorPointer_fake_func bytes_size = %d\n", bytes_size);
2961                                 glColorPointer(size, type, stride, process->current_state->colorPointer);
2962
2963                                 break;
2964                         }
2965
2966                 case glSecondaryColorPointer_fake_func:
2967                         {
2968                                 GET_EXT_PTR(void, glSecondaryColorPointer, (int,int,int,void*));
2969                                 int offset = args[0];
2970                                 int size = args[1];
2971                                 int type = args[2];
2972                                 int stride = args[3];
2973                                 int bytes_size = args[4];
2974                                 process->current_state->secondaryColorPointerSize = MAX(process->current_state->secondaryColorPointerSize, offset + bytes_size);
2975                                 process->current_state->secondaryColorPointer = realloc(process->current_state->secondaryColorPointer, process->current_state->secondaryColorPointerSize);
2976                                 memcpy(process->current_state->secondaryColorPointer + offset, (void*)args[5], bytes_size);
2977                                 //fprintf(stderr, "glSecondaryColorPointer_fake_func bytes_size = %d\n", bytes_size);
2978                                 ptr_func_glSecondaryColorPointer(size, type, stride, process->current_state->secondaryColorPointer);
2979
2980                                 break;
2981                         }
2982
2983                 case glPushClientAttrib_func:
2984                         {
2985                                 int mask = args[0];
2986                                 if (process->current_state->clientStateSp < MAX_CLIENT_STATE_STACK_SIZE)
2987                                 {
2988                                         process->current_state->clientStateStack[process->current_state->clientStateSp].mask = mask;
2989                                         if (mask & GL_CLIENT_VERTEX_ARRAY_BIT)
2990                                         {
2991                                                 process->current_state->clientStateStack[process->current_state->clientStateSp].activeTextureIndex =
2992                                                         process->current_state->activeTextureIndex;
2993                                         }
2994                                         process->current_state->clientStateSp++;
2995                                 }
2996                                 glPushClientAttrib(mask);
2997                                 break;
2998                         }
2999
3000                 case glPopClientAttrib_func:
3001                         {
3002                                 if (process->current_state->clientStateSp > 0)
3003                                 {
3004                                         process->current_state->clientStateSp--;
3005                                         if (process->current_state->clientStateStack[process->current_state->clientStateSp].mask & GL_CLIENT_VERTEX_ARRAY_BIT)
3006                                         {
3007                                                 process->current_state->activeTextureIndex =
3008                                                         process->current_state->clientStateStack[process->current_state->clientStateSp].activeTextureIndex;
3009                                         }
3010                                 }
3011                                 glPopClientAttrib();
3012                                 break;
3013                         }
3014
3015                 case glClientActiveTexture_func:
3016                 case glClientActiveTextureARB_func:
3017                         {
3018                                 int activeTexture = args[0];
3019                                 process->current_state->activeTextureIndex = activeTexture - GL_TEXTURE0_ARB;
3020                                 do_glClientActiveTextureARB(activeTexture);
3021                                 break;
3022                         }
3023
3024                 case glTexCoordPointer_fake_func:
3025                         {
3026                                 int offset = args[0];
3027                                 int index = args[1];
3028                                 int size = args[2];
3029                                 int type = args[3];
3030                                 int stride = args[4];
3031                                 int bytes_size = args[5];
3032                                 process->current_state->texCoordPointerSize[index] = MAX(process->current_state->texCoordPointerSize[index], offset + bytes_size);
3033                                 process->current_state->texCoordPointer[index] = realloc(process->current_state->texCoordPointer[index], process->current_state->texCoordPointerSize[index]);
3034                                 memcpy(process->current_state->texCoordPointer[index] + offset, (void*)args[6], bytes_size);
3035                                 /*fprintf(stderr, "glTexCoordPointer_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
3036                                   size, type, stride, bytes_size);*/
3037                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + index);
3038                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[index]);
3039                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3040                                 break;
3041                         }
3042
3043                 case glWeightPointerARB_fake_func:
3044                         {
3045                                 GET_EXT_PTR(void, glWeightPointerARB, (int,int,int,void*));
3046                                 int offset = args[0];
3047                                 int size = args[1];
3048                                 int type = args[2];
3049                                 int stride = args[3];
3050                                 int bytes_size = args[4];
3051                                 process->current_state->weightPointerSize = MAX(process->current_state->weightPointerSize, offset + bytes_size);
3052                                 process->current_state->weightPointer = realloc(process->current_state->weightPointer, process->current_state->weightPointerSize);
3053                                 memcpy(process->current_state->weightPointer + offset, (void*)args[5], bytes_size);
3054                                 /*fprintf(stderr, "glWeightPointerARB_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
3055                                   size, type, stride, bytes_size);*/
3056                                 ptr_func_glWeightPointerARB(size, type, stride, process->current_state->weightPointer);
3057                                 break;
3058                         }
3059
3060                 case glMatrixIndexPointerARB_fake_func:
3061                         {
3062                                 GET_EXT_PTR(void, glMatrixIndexPointerARB, (int,int,int,void*));
3063                                 int offset = args[0];
3064                                 int size = args[1];
3065                                 int type = args[2];
3066                                 int stride = args[3];
3067                                 int bytes_size = args[4];
3068                                 process->current_state->matrixIndexPointerSize = MAX(process->current_state->matrixIndexPointerSize, offset + bytes_size);
3069                                 process->current_state->matrixIndexPointer = realloc(process->current_state->matrixIndexPointer, process->current_state->matrixIndexPointerSize);
3070                                 memcpy(process->current_state->matrixIndexPointer + offset, (void*)args[5], bytes_size);
3071                                 /*fprintf(stderr, "glMatrixIndexPointerARB_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
3072                                   size, type, stride, bytes_size);*/
3073                                 ptr_func_glMatrixIndexPointerARB(size, type, stride, process->current_state->matrixIndexPointer);
3074                                 break;
3075                         }
3076
3077                 case glFogCoordPointer_fake_func:
3078                         {
3079                                 GET_EXT_PTR(void, glFogCoordPointer, (int,int,void*));
3080                                 int offset = args[0];
3081                                 int type = args[1];
3082                                 int stride = args[2];
3083                                 int bytes_size = args[3];
3084                                 process->current_state->fogCoordPointerSize = MAX(process->current_state->fogCoordPointerSize, offset + bytes_size);
3085                                 process->current_state->fogCoordPointer = realloc(process->current_state->fogCoordPointer, process->current_state->fogCoordPointerSize);
3086                                 memcpy(process->current_state->fogCoordPointer + offset, (void*)args[4], bytes_size);
3087                                 //fprintf(stderr, "glFogCoordPointer_fake_func type=%d, stride=%d, byte_size=%d\n", type, stride, bytes_size);
3088                                 ptr_func_glFogCoordPointer(type, stride, process->current_state->fogCoordPointer);
3089                                 break;
3090                         }
3091
3092                 case glVariantPointerEXT_fake_func:
3093                         {
3094                                 GET_EXT_PTR(void, glVariantPointerEXT, (int,int,int,void*));
3095                                 int offset = args[0];
3096                                 int id = args[1];
3097                                 int type = args[2];
3098                                 int stride = args[3];
3099                                 int bytes_size = args[4];
3100                                 process->current_state->variantPointerEXTSize[id] = MAX(process->current_state->variantPointerEXTSize[id], offset + bytes_size);
3101                                 process->current_state->variantPointerEXT[id] = realloc(process->current_state->variantPointerEXT[id], process->current_state->variantPointerEXTSize[id]);
3102                                 memcpy(process->current_state->variantPointerEXT[id] + offset, (void*)args[5], bytes_size);
3103                                 //fprintf(stderr, "glVariantPointerEXT_fake_func[%d] type=%d, stride=%d, byte_size=%d\n", id, type, stride, bytes_size);
3104                                 ptr_func_glVariantPointerEXT(id, type, stride, process->current_state->variantPointerEXT[id]);
3105                                 break;
3106                         }
3107
3108                 case glInterleavedArrays_fake_func:
3109                         {
3110                                 GET_EXT_PTR(void, glInterleavedArrays, (int,int,void*));
3111                                 int offset = args[0];
3112                                 int format = args[1];
3113                                 int stride = args[2];
3114                                 int bytes_size = args[3];
3115                                 process->current_state->interleavedArraysSize = MAX(process->current_state->interleavedArraysSize, offset + bytes_size);
3116                                 process->current_state->interleavedArrays = realloc(process->current_state->interleavedArrays, process->current_state->interleavedArraysSize);
3117                                 memcpy(process->current_state->interleavedArrays + offset, (void*)args[4], bytes_size);
3118                                 //fprintf(stderr, "glInterleavedArrays_fake_func format=%d, stride=%d, byte_size=%d\n", format, stride, bytes_size);
3119                                 ptr_func_glInterleavedArrays(format, stride, process->current_state->interleavedArrays);
3120                                 break;
3121                         }
3122
3123                 case glElementPointerATI_fake_func:
3124                         {
3125                                 GET_EXT_PTR(void, glElementPointerATI, (int,void*));
3126                                 int type = args[0];
3127                                 int bytes_size = args[1];
3128                                 process->current_state->elementPointerATISize = bytes_size;
3129                                 process->current_state->elementPointerATI = realloc(process->current_state->elementPointerATI, process->current_state->elementPointerATISize);
3130                                 memcpy(process->current_state->elementPointerATI, (void*)args[2], bytes_size);
3131                                 //fprintf(stderr, "glElementPointerATI_fake_func type=%d, byte_size=%d\n", type, bytes_size);
3132                                 ptr_func_glElementPointerATI(type, process->current_state->elementPointerATI);
3133                                 break;
3134                         }
3135
3136                 case glTexCoordPointer01_fake_func:
3137                         {
3138                                 int size = args[0];
3139                                 int type = args[1];
3140                                 int stride = args[2];
3141                                 int bytes_size = args[3];
3142                                 process->current_state->texCoordPointerSize[0] = bytes_size;
3143                                 process->current_state->texCoordPointer[0] = realloc(process->current_state->texCoordPointer[0], bytes_size);
3144                                 memcpy(process->current_state->texCoordPointer[0], (void*)args[4], bytes_size);
3145                                 /*fprintf(stderr, "glTexCoordPointer01_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
3146                                   size, type, stride, bytes_size);*/
3147                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3148                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
3149                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3150                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
3151                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3152                                 break;
3153                         }
3154
3155                 case glTexCoordPointer012_fake_func:
3156                         {
3157                                 int size = args[0];
3158                                 int type = args[1];
3159                                 int stride = args[2];
3160                                 int bytes_size = args[3];
3161                                 process->current_state->texCoordPointerSize[0] = bytes_size;
3162                                 process->current_state->texCoordPointer[0] = realloc(process->current_state->texCoordPointer[0], bytes_size);
3163                                 memcpy(process->current_state->texCoordPointer[0], (void*)args[4], bytes_size);
3164                                 /*fprintf(stderr, "glTexCoordPointer012_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
3165                                   size, type, stride, bytes_size);*/
3166                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3167                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
3168                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3169                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
3170                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
3171                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
3172                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3173                                 break;
3174                         }
3175
3176                 case glVertexAndNormalPointer_fake_func:
3177                         {
3178                                 int vertexPointerSize = args[0];
3179                                 int vertexPointerType = args[1];
3180                                 int vertexPointerStride = args[2];
3181                                 int normalPointerType = args[3];
3182                                 int normalPointerStride = args[4];
3183                                 int bytes_size = args[5];
3184                                 void* ptr = (void*)args[6];
3185                                 process->current_state->vertexPointerSize = bytes_size;
3186                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, bytes_size);
3187                                 memcpy(process->current_state->vertexPointer, ptr, bytes_size);
3188                                 glVertexPointer(vertexPointerSize, vertexPointerType, vertexPointerStride, process->current_state->vertexPointer);
3189                                 glNormalPointer(normalPointerType, normalPointerStride, process->current_state->vertexPointer);
3190                                 break;
3191                         }
3192
3193                 case glVertexNormalPointerInterlaced_fake_func:
3194                         {
3195                                 int i = 0;
3196                                 int offset = args[i++];
3197                                 int vertexPointerSize = args[i++];
3198                                 int vertexPointerType = args[i++];
3199                                 int stride = args[i++];
3200                                 int normalPointerOffset= args[i++];
3201                                 int normalPointerType = args[i++];
3202                                 int bytes_size = args[i++];
3203                                 void* ptr = (void*)args[i++];
3204                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3205                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3206                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3207                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3208                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
3209                                 break;
3210                         }
3211
3212                 case glTuxRacerDrawElements_fake_func:
3213                         {
3214                                 int mode = args[0];
3215                                 int count = args[1];
3216                                 int isColorEnabled = args[2];
3217                                 void* ptr = (void*)args[3];
3218                                 int stride = 6 * sizeof(float) + ((isColorEnabled) ? 4 * sizeof(unsigned char) : 0);
3219                                 glVertexPointer( 3, GL_FLOAT, stride, ptr);
3220                                 glNormalPointer( GL_FLOAT, stride, ptr + 3 * sizeof(float));
3221                                 if (isColorEnabled)
3222                                         glColorPointer( 4, GL_UNSIGNED_BYTE, stride, ptr + 6 * sizeof(float));
3223                                 glDrawArrays(mode, 0, count);
3224                                 break;
3225                         }
3226
3227                 case glVertexNormalColorPointerInterlaced_fake_func:
3228                         {
3229                                 int i = 0;
3230                                 int offset = args[i++];
3231                                 int vertexPointerSize = args[i++];
3232                                 int vertexPointerType = args[i++];
3233                                 int stride = args[i++];
3234                                 int normalPointerOffset= args[i++];
3235                                 int normalPointerType = args[i++];
3236                                 int colorPointerOffset = args[i++];
3237                                 int colorPointerSize = args[i++];
3238                                 int colorPointerType = args[i++];
3239                                 int bytes_size = args[i++];
3240                                 void* ptr = (void*)args[i++];
3241                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3242                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3243                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3244                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3245                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
3246                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
3247                                 break;
3248                         }
3249
3250                 case glVertexColorTexCoord0PointerInterlaced_fake_func:
3251                         {
3252                                 int i = 0;
3253                                 int offset = args[i++];
3254                                 int vertexPointerSize = args[i++];
3255                                 int vertexPointerType = args[i++];
3256                                 int stride = args[i++];
3257                                 int colorPointerOffset = args[i++];
3258                                 int colorPointerSize = args[i++];
3259                                 int colorPointerType = args[i++];
3260                                 int texCoord0PointerOffset = args[i++];
3261                                 int texCoord0PointerSize = args[i++];
3262                                 int texCoord0PointerType = args[i++];
3263                                 int bytes_size = args[i++];
3264                                 void* ptr = (void*)args[i++];
3265                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3266                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3267                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3268                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3269                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
3270                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3271                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
3272                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3273                                 break;
3274                         }
3275
3276                 case glVertexNormalTexCoord0PointerInterlaced_fake_func:
3277                         {
3278                                 int i = 0;
3279                                 int offset = args[i++];
3280                                 int vertexPointerSize = args[i++];
3281                                 int vertexPointerType = args[i++];
3282                                 int stride = args[i++];
3283                                 int normalPointerOffset = args[i++];
3284                                 int normalPointerType = args[i++];
3285                                 int texCoord0PointerOffset = args[i++];
3286                                 int texCoord0PointerSize = args[i++];
3287                                 int texCoord0PointerType = args[i++];
3288                                 int bytes_size = args[i++];
3289                                 void* ptr = (void*)args[i++];
3290                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3291                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3292                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3293                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3294                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
3295                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3296                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
3297                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3298                                 break;
3299                         }
3300
3301                 case glVertexNormalTexCoord01PointerInterlaced_fake_func:
3302                         {
3303                                 int i = 0;
3304                                 int offset = args[i++];
3305                                 int vertexPointerSize = args[i++];
3306                                 int vertexPointerType = args[i++];
3307                                 int stride = args[i++];
3308                                 int normalPointerOffset = args[i++];
3309                                 int normalPointerType = args[i++];
3310                                 int texCoord0PointerOffset = args[i++];
3311                                 int texCoord0PointerSize = args[i++];
3312                                 int texCoord0PointerType = args[i++];
3313                                 int texCoord1PointerOffset = args[i++];
3314                                 int texCoord1PointerSize = args[i++];
3315                                 int texCoord1PointerType = args[i++];
3316                                 int bytes_size = args[i++];
3317                                 void* ptr = (void*)args[i++];
3318                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3319                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3320                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3321                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3322                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
3323                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3324                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
3325                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3326                                 glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType, stride, process->current_state->vertexPointer + texCoord1PointerOffset);
3327                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3328                                 break;
3329                         }
3330
3331                 case glVertexNormalTexCoord012PointerInterlaced_fake_func:
3332                         {
3333                                 int i = 0;
3334                                 int offset = args[i++];
3335                                 int vertexPointerSize = args[i++];
3336                                 int vertexPointerType = args[i++];
3337                                 int stride = args[i++];
3338                                 int normalPointerOffset = args[i++];
3339                                 int normalPointerType = args[i++];
3340                                 int texCoord0PointerOffset = args[i++];
3341                                 int texCoord0PointerSize = args[i++];
3342                                 int texCoord0PointerType = args[i++];
3343                                 int texCoord1PointerOffset = args[i++];
3344                                 int texCoord1PointerSize = args[i++];
3345                                 int texCoord1PointerType = args[i++];
3346                                 int texCoord2PointerOffset = args[i++];
3347                                 int texCoord2PointerSize = args[i++];
3348                                 int texCoord2PointerType = args[i++];
3349                                 int bytes_size = args[i++];
3350                                 void* ptr = (void*)args[i++];
3351                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3352                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3353                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3354                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3355                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
3356                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3357                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
3358                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3359                                 glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType, stride, process->current_state->vertexPointer + texCoord1PointerOffset);
3360                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
3361                                 glTexCoordPointer(texCoord2PointerSize, texCoord2PointerType, stride, process->current_state->vertexPointer + texCoord2PointerOffset);
3362                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3363                                 break;
3364                         }
3365
3366                 case glVertexNormalColorTexCoord0PointerInterlaced_fake_func:
3367                         {
3368                                 int i = 0;
3369                                 int offset = args[i++];
3370                                 int vertexPointerSize = args[i++];
3371                                 int vertexPointerType = args[i++];
3372                                 int stride = args[i++];
3373                                 int normalPointerOffset = args[i++];
3374                                 int normalPointerType = args[i++];
3375                                 int colorPointerOffset = args[i++];
3376                                 int colorPointerSize = args[i++];
3377                                 int colorPointerType = args[i++];
3378                                 int texCoord0PointerOffset = args[i++];
3379                                 int texCoord0PointerSize = args[i++];
3380                                 int texCoord0PointerType = args[i++];
3381                                 int bytes_size = args[i++];
3382                                 void* ptr = (void*)args[i++];
3383                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3384                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3385                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3386                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3387                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
3388                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
3389                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3390                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
3391                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3392                                 break;
3393                         }
3394
3395                 case glVertexNormalColorTexCoord01PointerInterlaced_fake_func:
3396                         {
3397                                 int i = 0;
3398                                 int offset = args[i++];
3399                                 int vertexPointerSize = args[i++];
3400                                 int vertexPointerType = args[i++];
3401                                 int stride = args[i++];
3402                                 int normalPointerOffset = args[i++];
3403                                 int normalPointerType = args[i++];
3404                                 int colorPointerOffset = args[i++];
3405                                 int colorPointerSize = args[i++];
3406                                 int colorPointerType = args[i++];
3407                                 int texCoord0PointerOffset = args[i++];
3408                                 int texCoord0PointerSize = args[i++];
3409                                 int texCoord0PointerType = args[i++];
3410                                 int texCoord1PointerOffset = args[i++];
3411                                 int texCoord1PointerSize = args[i++];
3412                                 int texCoord1PointerType = args[i++];
3413                                 int bytes_size = args[i++];
3414                                 void* ptr = (void*)args[i++];
3415                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3416                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3417                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3418                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3419                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
3420                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
3421                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3422                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
3423                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3424                                 glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType, stride, process->current_state->vertexPointer + texCoord1PointerOffset);
3425                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3426                                 break;
3427                         }
3428
3429                 case glVertexNormalColorTexCoord012PointerInterlaced_fake_func:
3430                         {
3431                                 int i = 0;
3432                                 int offset = args[i++];
3433                                 int vertexPointerSize = args[i++];
3434                                 int vertexPointerType = args[i++];
3435                                 int stride = args[i++];
3436                                 int normalPointerOffset = args[i++];
3437                                 int normalPointerType = args[i++];
3438                                 int colorPointerOffset = args[i++];
3439                                 int colorPointerSize = args[i++];
3440                                 int colorPointerType = args[i++];
3441                                 int texCoord0PointerOffset = args[i++];
3442                                 int texCoord0PointerSize = args[i++];
3443                                 int texCoord0PointerType = args[i++];
3444                                 int texCoord1PointerOffset = args[i++];
3445                                 int texCoord1PointerSize = args[i++];
3446                                 int texCoord1PointerType = args[i++];
3447                                 int texCoord2PointerOffset = args[i++];
3448                                 int texCoord2PointerSize = args[i++];
3449                                 int texCoord2PointerType = args[i++];
3450                                 int bytes_size = args[i++];
3451                                 void* ptr = (void*)args[i++];
3452                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
3453                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
3454                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
3455                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
3456                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
3457                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
3458                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3459                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
3460                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3461                                 glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType, stride, process->current_state->vertexPointer + texCoord1PointerOffset);
3462                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
3463                                 glTexCoordPointer(texCoord2PointerSize, texCoord2PointerType, stride, process->current_state->vertexPointer + texCoord2PointerOffset);
3464                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
3465                                 break;
3466                         }
3467
3468                 case _glVertexPointer_buffer_func:
3469                         {
3470                                 glVertexPointer(args[0],args[1],args[2],(void*)args[3]);
3471                                 break;
3472                         }
3473
3474                 case _glNormalPointer_buffer_func:
3475                         {
3476                                 glNormalPointer(args[0],args[1],(void*)args[2]);
3477                                 break;
3478                         }
3479
3480                 case _glColorPointer_buffer_func:
3481                         {
3482                                 glColorPointer(args[0],args[1],args[2],(void*)args[3]);
3483                                 break;
3484                         }
3485
3486                 case _glSecondaryColorPointer_buffer_func:
3487                         {
3488                                 GET_EXT_PTR(void, glSecondaryColorPointer, (int,int,int,void*));
3489                                 ptr_func_glSecondaryColorPointer(args[0],args[1],args[2],(void*)args[3]);
3490                                 break;
3491                         }
3492
3493                 case _glIndexPointer_buffer_func:
3494                         {
3495                                 glIndexPointer(args[0],args[1],(void*)args[2]);
3496                                 break;
3497                         }
3498
3499                 case _glTexCoordPointer_buffer_func:
3500                         {
3501                                 glTexCoordPointer(args[0],args[1],args[2],(void*)args[3]);
3502                                 break;
3503                         }
3504
3505                 case _glEdgeFlagPointer_buffer_func:
3506                         {
3507                                 glEdgeFlagPointer(args[0],(void*)args[1]);
3508                                 break;
3509                         }
3510
3511                 case _glVertexAttribPointerARB_buffer_func:
3512                         {
3513                                 GET_EXT_PTR(void, glVertexAttribPointerARB, (int,int,int,int,int,void*));
3514                                 ptr_func_glVertexAttribPointerARB(args[0], args[1], args[2], args[3], args[4], (void*)args[5]);
3515                                 break;
3516                         }
3517
3518                 case _glWeightPointerARB_buffer_func:
3519                         {
3520                                 GET_EXT_PTR(void, glWeightPointerARB, (int,int,int,void*));
3521                                 ptr_func_glWeightPointerARB(args[0], args[1], args[2], (void*)args[3]);
3522                                 break;
3523                         }
3524
3525                 case _glMatrixIndexPointerARB_buffer_func:
3526                         {
3527                                 GET_EXT_PTR(void, glMatrixIndexPointerARB, (int,int,int,void*));
3528                                 ptr_func_glMatrixIndexPointerARB(args[0], args[1], args[2], (void*)args[3]);
3529                                 break;
3530                         }
3531
3532                 case _glFogCoordPointer_buffer_func:
3533                         {
3534                                 GET_EXT_PTR(void, glFogCoordPointer, (int,int,void*));
3535                                 ptr_func_glFogCoordPointer(args[0], args[1], (void*)args[2]);
3536                                 break;
3537                         }
3538
3539                 case _glVariantPointerEXT_buffer_func:
3540                         {
3541                                 GET_EXT_PTR(void, glVariantPointerEXT, (int, int,int,void*));
3542                                 ptr_func_glVariantPointerEXT(args[0], args[1], args[2], (void*)args[3]);
3543                                 break;
3544                         }
3545
3546                 case _glDrawElements_buffer_func:
3547                         {
3548                                 glDrawElements(args[0],args[1],args[2],(void*)args[3]);
3549                                 break;
3550                         }
3551
3552                 case _glDrawRangeElements_buffer_func:
3553                         {
3554                                 GET_EXT_PTR(void, glDrawRangeElements, ( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices ));
3555                                 ptr_func_glDrawRangeElements(args[0],args[1],args[2],args[3],args[4],(void*)args[5]);
3556                                 break;
3557                         }
3558
3559                 case _glMultiDrawElements_buffer_func:
3560                         {
3561                                 GET_EXT_PTR(void, glMultiDrawElements, (int,int*,int,void**, int));
3562                                 ptr_func_glMultiDrawElements(args[0],(int*)args[1],args[2],(void**)args[3],args[4]);
3563                                 break;
3564                         }
3565
3566                 case _glGetError_fake_func:
3567                         {
3568                                 break;
3569                         }
3570
3571                 case glGetIntegerv_func:
3572                         {
3573                                 glGetIntegerv(args[0], (int*)args[1]);
3574                                 break;
3575                         }
3576
3577                 case _glReadPixels_pbo_func:
3578                         {
3579                                 glReadPixels(ARG_TO_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), ARG_TO_UNSIGNED_INT(args[4]), ARG_TO_UNSIGNED_INT(args[5]), (void*)(args[6]));
3580                                 break;
3581                         }
3582
3583                 case _glDrawPixels_pbo_func:
3584                         {
3585                                 glDrawPixels(ARG_TO_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_UNSIGNED_INT(args[2]), ARG_TO_UNSIGNED_INT(args[3]), (const void*)(args[4]));
3586                                 break;
3587                         }
3588
3589                 case _glMapBufferARB_fake_func:
3590                         {
3591                                 GET_EXT_PTR(GLvoid*, glMapBufferARB, (GLenum, GLenum));
3592                                 GET_EXT_PTR(GLboolean, glUnmapBufferARB, (GLenum));
3593                                 int target = args[0];
3594                                 int size = args[1];
3595                                 void* dst_ptr = (void*)args[2];
3596                                 void* src_ptr = ptr_func_glMapBufferARB(target, GL_READ_ONLY);
3597                                 if (src_ptr)
3598                                 {
3599                                         memcpy(dst_ptr, src_ptr, size);
3600                                         ret_int = ptr_func_glUnmapBufferARB(target);
3601                                 }
3602                                 else
3603                                 {
3604                                         ret_int = 0;
3605                                 }
3606                                 break;
3607                         }
3608
3609                 case fake_gluBuild2DMipmaps_func:
3610                         {
3611                                 GET_GLU_PTR(GLint, gluBuild2DMipmaps, (GLenum arg_0, GLint arg_1, GLsizei arg_2, GLsizei arg_3, GLenum arg_4, GLenum arg_5, const GLvoid * arg_6));
3612                                 if (ptr_func_gluBuild2DMipmaps == NULL)
3613                                         ptr_func_gluBuild2DMipmaps = mesa_gluBuild2DMipmaps;
3614                                 ptr_func_gluBuild2DMipmaps(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), ARG_TO_UNSIGNED_INT(args[4]), ARG_TO_UNSIGNED_INT(args[5]), (const void*)(args[6]));
3615                                 break;
3616                         }
3617
3618                 case _glSelectBuffer_fake_func:
3619                         {
3620                                 process->current_state->selectBufferSize = args[0] * 4;
3621                                 process->current_state->selectBufferPtr = realloc(process->current_state->selectBufferPtr, process->current_state->selectBufferSize);
3622                                 glSelectBuffer(args[0], process->current_state->selectBufferPtr);
3623                                 break;
3624                         }
3625
3626                 case _glGetSelectBuffer_fake_func:
3627                         {
3628                                 void* ptr = (void*)args[0];
3629                                 memcpy(ptr, process->current_state->selectBufferPtr, process->current_state->selectBufferSize);
3630                                 break;
3631                         }
3632
3633                 case _glFeedbackBuffer_fake_func:
3634                         {
3635                                 process->current_state->feedbackBufferSize = args[0] * 4;
3636                                 process->current_state->feedbackBufferPtr = realloc(process->current_state->feedbackBufferPtr, process->current_state->feedbackBufferSize);
3637                                 glFeedbackBuffer(args[0], args[1], process->current_state->feedbackBufferPtr);
3638                                 break;
3639                         }
3640
3641                 case _glGetFeedbackBuffer_fake_func:
3642                         {
3643                                 void* ptr = (void*)args[0];
3644                                 memcpy(ptr, process->current_state->feedbackBufferPtr, process->current_state->feedbackBufferSize);
3645                                 break;
3646                         }
3647
3648                 case glGetError_func:
3649                         {
3650                                 ret_int = glGetError();
3651                                 break;
3652                         }
3653
3654                 case glNewObjectBufferATI_func:
3655                         {
3656                                 GET_EXT_PTR(int, glNewObjectBufferATI, (int,void*, int));
3657                                 ret_int = ptr_func_glNewObjectBufferATI(args[0], (void*)args[1], args[2]);
3658                                 break;
3659                         }
3660
3661                 default:
3662                         execute_func(func_number, args, &ret_int, &ret_char);
3663                         break;
3664         }
3665
3666         Signature* signature = (Signature*)tab_opengl_calls[func_number];
3667         int ret_type = signature->ret_type;
3668         switch(ret_type)
3669         {
3670                 case TYPE_NONE:
3671                         break;
3672
3673                 case TYPE_CHAR:
3674                 case TYPE_UNSIGNED_CHAR:
3675                         ret_int = ret_char;
3676                         break;
3677
3678                 case TYPE_INT:
3679                 case TYPE_UNSIGNED_INT:
3680                         break;
3681
3682                 case TYPE_CONST_CHAR:
3683                         {
3684                                 strncpy(ret_string, (ret_str) ? ret_str : "", 32768);
3685                                 break;
3686                         }
3687
3688                 default:
3689                         fprintf(stderr, "unexpected ret type : %d\n", ret_type);
3690                         exit(-1);
3691                         break;
3692         }
3693
3694         return ret_int;
3695 }
3696
3697 #else
3698
3699 #include <arpa/inet.h>
3700 #include <X11/Xlib.h>
3701 #include <X11/Xutil.h>
3702
3703 #define GL_GLEXT_PROTOTYPES
3704 #define GLX_GLXEXT_PROTOTYPES
3705
3706 #include "opengl_func.h"
3707 #include "opengl_utils.h"
3708 #include "mesa_gl.h"
3709 #include "mesa_glx.h"
3710 #include "mesa_glu.h"
3711 #include "mesa_mipmap.c"
3712
3713 //#define SYSTEMATIC_ERROR_CHECK
3714
3715 #define GET_EXT_PTR(type, funcname, args_decl) \
3716         static int detect_##funcname = 0; \
3717 static type(*ptr_func_##funcname)args_decl = NULL; \
3718 if (detect_##funcname == 0) \
3719 { \
3720         detect_##funcname = 1; \
3721         ptr_func_##funcname = (type(*)args_decl)glXGetProcAddressARB((const GLubyte*)#funcname); \
3722         assert (ptr_func_##funcname); \
3723 }
3724
3725 #define GET_EXT_PTR_NO_FAIL(type, funcname, args_decl) \
3726         static int detect_##funcname = 0; \
3727 static type(*ptr_func_##funcname)args_decl = NULL; \
3728 if (detect_##funcname == 0) \
3729 { \
3730         detect_##funcname = 1; \
3731         ptr_func_##funcname = (type(*)args_decl)glXGetProcAddressARB((const GLubyte*)#funcname); \
3732 }
3733
3734 #ifndef WIN32
3735 #include <dlfcn.h>
3736 #endif
3737
3738 static void* get_glu_ptr(const char* name)
3739 {
3740         static void* handle = (void*)-1;
3741         if (handle == (void*)-1)
3742         {
3743 #ifndef WIN32
3744                 handle = dlopen("libGLU.so" ,RTLD_LAZY);
3745                 if (!handle) {
3746                         fprintf (stderr, "can't load libGLU.so : %s\n", dlerror());
3747                 }
3748 #else
3749                 handle = (void *)LoadLibrary("glu32.dll");
3750                 if (!handle) {
3751                         fprintf (stderr, "can't load glu32.dll\n");
3752                 }
3753 #endif
3754         }
3755         if (handle)
3756         {
3757 #ifndef WIN32
3758                 return dlsym(handle, name);
3759 #else
3760                 return GetProcAddress(handle, name);
3761 #endif
3762         }
3763         return NULL;
3764 }
3765
3766 #define GET_GLU_PTR(type, funcname, args_decl) \
3767         static int detect_##funcname = 0; \
3768 static type(*ptr_func_##funcname)args_decl = NULL; \
3769 if (detect_##funcname == 0) \
3770 { \
3771         detect_##funcname = 1; \
3772         ptr_func_##funcname = (type(*)args_decl)get_glu_ptr(#funcname); \
3773 }
3774
3775 int display_function_call = 0;
3776
3777 static const int defaultAttribList[] = {
3778         GLX_RGBA,
3779         GLX_RED_SIZE, 1,
3780         GLX_GREEN_SIZE, 1,
3781         GLX_BLUE_SIZE, 1,
3782         GLX_DOUBLEBUFFER,
3783         None
3784 };
3785
3786 static XVisualInfo* get_default_visual(Display* dpy)
3787 {
3788         fprintf(stderr, "get_default_visual\n");
3789         static XVisualInfo* vis = NULL;
3790         XVisualInfo theTemplate;
3791         int numVisuals;
3792         if (vis) return vis;
3793         /*if (vis == NULL)
3794           vis = glXChooseVisual(dpy, 0, (int*)defaultAttribList);*/
3795         theTemplate.screen = 0;
3796         vis = XGetVisualInfo(dpy, VisualScreenMask, &theTemplate, &numVisuals);
3797         return vis;
3798 }
3799
3800 void opengl_exec_set_parent_window(OGLS_Conn *pConn, Window _parent_window)
3801 {
3802         pConn->parent_dpy = pConn->Display;
3803         pConn->qemu_parent_window = _parent_window;
3804         if (pConn->active_win)
3805         {
3806                 XReparentWindow(pConn->Display, pConn->active_win, _parent_window, pConn->active_win_x, pConn->active_win_y);
3807         }
3808 }
3809
3810 static Window create_window(OGLS_Conn *pConn, Window local_parent_window, XVisualInfo* vis, const char *name,
3811                 int x, int y, int width, int height)
3812 {
3813         int scrnum;
3814         XSetWindowAttributes attr = {0};
3815         unsigned long mask;
3816         Window root;
3817         Window win;
3818
3819         scrnum = DefaultScreen( pConn->Display );
3820         root = RootWindow( pConn->Display, scrnum );
3821
3822         /* window attributes */
3823         attr.background_pixel = 0;
3824         attr.border_pixel = 0;
3825         attr.colormap = XCreateColormap( pConn->Display, root, vis->visual, AllocNone);
3826         attr.event_mask = StructureNotifyMask | ExposureMask /*| KeyPressMask*/;
3827         attr.save_under = True;
3828         //if (local_parent_window == NULL && qemu_parent_window == NULL)
3829         attr.override_redirect = False;
3830         //else
3831         //  attr.override_redirect = True;
3832         attr.cursor = None;
3833         mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect | CWSaveUnder ;
3834
3835         if (local_parent_window)
3836         {
3837                 win = XCreateWindow( pConn->Display, local_parent_window, 0, 0, width, height,
3838                                 0, vis->depth, InputOutput,
3839                                 vis->visual, mask, &attr );
3840         }
3841         else if (pConn->qemu_parent_window)
3842         {
3843                 win = XCreateWindow( pConn->Display, pConn->qemu_parent_window, 0, 0, width, height,
3844                                 0, vis->depth, InputOutput,
3845                                 vis->visual, mask, &attr );
3846         }
3847         else
3848         {
3849                 win = XCreateWindow( pConn->Display, root, 0, 0, width, height,
3850                                 0, vis->depth, InputOutput,
3851                                 vis->visual, mask, &attr );
3852         }
3853
3854         /* set hints and properties */
3855         {
3856                 XSizeHints sizehints;
3857                 sizehints.x = x;
3858                 sizehints.y = y;
3859                 sizehints.width  = width;
3860                 sizehints.height = height;
3861                 sizehints.flags = USSize | USPosition;
3862                 XSetWMNormalHints(pConn->Display, win, &sizehints);
3863                 XSetStandardProperties(pConn->Display, win, name, name,
3864                                 None, (char **)NULL, 0, &sizehints);
3865         }
3866
3867         /* Host Window?? ?琉??? ?苛쨈?. if( win )
3868            XMapWindow(pConn->Display, win);*/
3869
3870         XSync(pConn->Display, 0);
3871
3872         /*
3873            int loop = 1;
3874            while (loop) {
3875            while (XPending(pConn->Display) > 0) {
3876            XEvent event;
3877            XNextEvent(pConn->Display, &event);
3878            switch (event.type) {
3879            case CreateNotify:
3880            {
3881            if (((XCreateWindowEvent*)&event)->window == win)
3882            {
3883            loop = 0;
3884            }
3885            break;
3886            }
3887            }
3888            }
3889            }*/
3890
3891         pConn->active_win = win;
3892
3893         return win;
3894 }
3895
3896 static void destroy_window(OGLS_Conn *pConn, Window win )
3897 {
3898         /*int i;*/
3899
3900         XDestroyWindow(pConn->Display, win);
3901
3902         XSync(pConn->Display, 0);
3903         /*int loop = 1;
3904           while (loop) {
3905           while (XPending(pConn->Display) > 0) {
3906           XEvent event;
3907           XNextEvent(pConn->Display, &event);
3908           switch (event.type) {
3909           case DestroyNotify:
3910           {
3911           if (((XDestroyWindowEvent*)&event)->window == win)
3912           {
3913           loop = 0;
3914           }
3915           break;
3916           }
3917           }
3918           }
3919           }*/
3920
3921         if( pConn->active_win == win)
3922                 pConn->active_win = 0;
3923
3924 }
3925
3926
3927 typedef struct
3928 {
3929         void* key;
3930         void* value;
3931 } Assoc;
3932
3933
3934 #define MAX_HANDLED_PROCESS 100
3935 #define MAX_ASSOC_SIZE 100
3936
3937 #define MAX_FBCONFIG 10
3938
3939
3940 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
3941
3942
3943 typedef struct
3944 {
3945         int x;
3946         int y;
3947         int width;
3948         int height;
3949         int map_state;
3950 } WindowPosStruct;
3951
3952 typedef struct
3953 {
3954         GLbitfield     mask;
3955         int            activeTextureIndex;
3956 } ClientState;
3957
3958 #define MAX_CLIENT_STATE_STACK_SIZE 16
3959
3960 typedef struct
3961 {
3962         int ref;
3963         int fake_ctxt;
3964         int fake_shareList;
3965         GLXContext context;
3966         GLXDrawable drawable;
3967
3968         void* vertexPointer;
3969         void* normalPointer;
3970         void* colorPointer;
3971         void* secondaryColorPointer;
3972         void* indexPointer;
3973         void* texCoordPointer[NB_MAX_TEXTURES];
3974         void* edgeFlagPointer;
3975         void* vertexAttribPointer[MY_GL_MAX_VERTEX_ATTRIBS_ARB];
3976         void* vertexAttribPointerNV[MY_GL_MAX_VERTEX_ATTRIBS_NV];
3977         void* weightPointer;
3978         void* matrixIndexPointer;
3979         void* fogCoordPointer;
3980         void* variantPointerEXT[MY_GL_MAX_VARIANT_POINTER_EXT];
3981         void* interleavedArrays;
3982         void* elementPointerATI;
3983
3984         int vertexPointerSize;
3985         int normalPointerSize;
3986         int colorPointerSize;
3987         int secondaryColorPointerSize;
3988         int indexPointerSize;
3989         int texCoordPointerSize[NB_MAX_TEXTURES];
3990         int edgeFlagPointerSize;
3991         int vertexAttribPointerSize[MY_GL_MAX_VERTEX_ATTRIBS_ARB];
3992         int vertexAttribPointerNVSize[MY_GL_MAX_VERTEX_ATTRIBS_NV];
3993         int weightPointerSize;
3994         int matrixIndexPointerSize;
3995         int fogCoordPointerSize;
3996         int variantPointerEXTSize[MY_GL_MAX_VARIANT_POINTER_EXT];
3997         int interleavedArraysSize;
3998         int elementPointerATISize;
3999
4000         int selectBufferSize;
4001         void* selectBufferPtr;
4002         int feedbackBufferSize;
4003         void* feedbackBufferPtr;
4004
4005         ClientState clientStateStack[MAX_CLIENT_STATE_STACK_SIZE];
4006         int clientStateSp;
4007         int activeTextureIndex;
4008
4009         unsigned int ownTabTextures[32768];
4010         unsigned int* tabTextures;
4011         RangeAllocator ownTextureAllocator;
4012         RangeAllocator* textureAllocator;
4013
4014         unsigned int ownTabBuffers[32768];
4015         unsigned int* tabBuffers;
4016         RangeAllocator ownBufferAllocator;
4017         RangeAllocator* bufferAllocator;
4018
4019         unsigned int ownTabLists[32768];
4020         unsigned int* tabLists;
4021         RangeAllocator ownListAllocator;
4022         RangeAllocator* listAllocator;
4023
4024 #ifdef SYSTEMATIC_ERROR_CHECK
4025         int last_error;
4026 #endif
4027 } GLState;
4028
4029 typedef struct
4030 {
4031         int internal_num;
4032         int process_id;
4033         int instr_counter;
4034
4035         int x, y, width, height;
4036         WindowPosStruct currentDrawablePos;
4037
4038         int next_available_context_number;
4039         int next_available_pbuffer_number;
4040
4041         int nbGLStates;
4042         GLState default_state;
4043         GLState** glstates;
4044         GLState* current_state;
4045
4046         int nfbconfig;
4047         GLXFBConfig* fbconfigs[MAX_FBCONFIG];
4048         int fbconfigs_max[MAX_FBCONFIG];
4049         int nfbconfig_total;
4050
4051         Assoc association_fakecontext_glxcontext[MAX_ASSOC_SIZE];
4052         Assoc association_fakepbuffer_pbuffer[MAX_ASSOC_SIZE];
4053         Assoc association_clientdrawable_serverdrawable[MAX_ASSOC_SIZE];
4054         Assoc association_fakecontext_visual[MAX_ASSOC_SIZE];
4055 } ProcessStruct;
4056
4057 int last_process_id = 0;
4058
4059
4060 #define ARG_TO_CHAR(x)                (char)(x)
4061 #define ARG_TO_UNSIGNED_CHAR(x)       (unsigned char)(x)
4062 #define ARG_TO_SHORT(x)               (short)(x)
4063 #define ARG_TO_UNSIGNED_SHORT(x)      (unsigned short)(x)
4064 #define ARG_TO_INT(x)                 (int)(x)
4065 #define ARG_TO_UNSIGNED_INT(x)        (unsigned int)(x)
4066 #define ARG_TO_FLOAT(x)               (*(float*)&(x))
4067 #define ARG_TO_DOUBLE(x)              (*(double*)(x))
4068
4069 #include "server_stub.c"
4070
4071 /* ---- */
4072
4073 static void* get_association_fakecontext_glxcontext(ProcessStruct* process, void* fakecontext)
4074 {
4075         int i;
4076         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
4077         {
4078                 if (process->association_fakecontext_glxcontext[i].key == fakecontext)
4079                         return process->association_fakecontext_glxcontext[i].value;
4080         }
4081         return NULL;
4082 }
4083
4084 static void set_association_fakecontext_glxcontext(ProcessStruct* process, void* fakecontext, void* glxcontext)
4085 {
4086         int i;
4087         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
4088         {
4089                 if (process->association_fakecontext_glxcontext[i].key == fakecontext)
4090                 {
4091                         break;
4092                 }
4093         }
4094         if (i < MAX_ASSOC_SIZE)
4095         {
4096                 process->association_fakecontext_glxcontext[i].key = fakecontext;
4097                 process->association_fakecontext_glxcontext[i].value = glxcontext;
4098         }
4099         else
4100         {
4101                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
4102         }
4103 }
4104
4105 static void unset_association_fakecontext_glxcontext(ProcessStruct* process, void* fakecontext)
4106 {
4107         int i;
4108         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
4109         {
4110                 if (process->association_fakecontext_glxcontext[i].key == fakecontext)
4111                 {
4112                         memmove(&process->association_fakecontext_glxcontext[i],
4113                                         &process->association_fakecontext_glxcontext[i+1],
4114                                         sizeof(Assoc) * (MAX_ASSOC_SIZE - 1 - i));
4115                         return;
4116                 }
4117         }
4118 }
4119
4120 /* ---- */
4121
4122 static void* get_association_fakecontext_visual(ProcessStruct* process, void* fakecontext)
4123 {
4124         int i;
4125         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_visual[i].key != NULL;i++)
4126         {
4127                 if (process->association_fakecontext_visual[i].key == fakecontext)
4128                         return process->association_fakecontext_visual[i].value;
4129         }
4130         return NULL;
4131 }
4132
4133 static void set_association_fakecontext_visual(ProcessStruct* process, void* fakecontext, void* visual)
4134 {
4135         int i;
4136         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_visual[i].key != NULL;i++)
4137         {
4138                 if (process->association_fakecontext_visual[i].key == fakecontext)
4139                 {
4140                         break;
4141                 }
4142         }
4143         if (i < MAX_ASSOC_SIZE)
4144         {
4145                 process->association_fakecontext_visual[i].key = fakecontext;
4146                 process->association_fakecontext_visual[i].value = visual;
4147         }
4148         else
4149         {
4150                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
4151         }
4152 }
4153
4154 /* ---- */
4155
4156 static void* get_association_fakepbuffer_pbuffer(ProcessStruct* process, void* fakepbuffer)
4157 {
4158         int i;
4159         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
4160         {
4161                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
4162                         return process->association_fakepbuffer_pbuffer[i].value;
4163         }
4164         return NULL;
4165 }
4166 static void set_association_fakepbuffer_pbuffer(ProcessStruct* process, void* fakepbuffer, void* pbuffer)
4167 {
4168         int i;
4169         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
4170         {
4171                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
4172                 {
4173                         break;
4174                 }
4175         }
4176         if (i < MAX_ASSOC_SIZE)
4177         {
4178                 process->association_fakepbuffer_pbuffer[i].key = fakepbuffer;
4179                 process->association_fakepbuffer_pbuffer[i].value = pbuffer;
4180         }
4181         else
4182         {
4183                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
4184         }
4185 }
4186 static void unset_association_fakepbuffer_pbuffer(ProcessStruct* process, void* fakepbuffer)
4187 {
4188         int i;
4189         for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
4190         {
4191                 if (process->association_fakepbuffer_pbuffer[i].key == fakepbuffer)
4192                 {
4193                         memmove(&process->association_fakepbuffer_pbuffer[i],
4194                                         &process->association_fakepbuffer_pbuffer[i+1],
4195                                         sizeof(Assoc) * (MAX_ASSOC_SIZE - 1 - i));
4196                         return;
4197                 }
4198         }
4199 }
4200
4201 /* ---- */
4202
4203
4204 static GLXDrawable get_association_clientdrawable_serverdrawable(ProcessStruct* process, GLXDrawable clientdrawable)
4205 {
4206         int i;
4207         for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
4208         {
4209                 if (process->association_clientdrawable_serverdrawable[i].key == (void*)clientdrawable)
4210                         return (GLXDrawable)process->association_clientdrawable_serverdrawable[i].value;
4211         }
4212         return (GLXDrawable)0;
4213 }
4214
4215 #if 0
4216 static void* get_association_serverdrawable_clientdrawable(ProcessStruct* process, GLXDrawable serverdrawable)
4217 {
4218         int i;
4219         for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
4220         {
4221                 if ((GLXDrawable)process->association_clientdrawable_serverdrawable[i].value == serverdrawable)
4222                         return process->association_clientdrawable_serverdrawable[i].key;
4223         }
4224         return NULL;
4225 }
4226 #endif
4227
4228 static void set_association_clientdrawable_serverdrawable(ProcessStruct* process, void* clientdrawable, void* serverdrawable)
4229 {
4230         int i;
4231         for(i=0;process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
4232         {
4233                 if (process->association_clientdrawable_serverdrawable[i].key == clientdrawable)
4234                 {
4235                         break;
4236                 }
4237         }
4238         if (i < MAX_ASSOC_SIZE)
4239         {
4240                 process->association_clientdrawable_serverdrawable[i].key = clientdrawable;
4241                 process->association_clientdrawable_serverdrawable[i].value = serverdrawable;
4242         }
4243         else
4244         {
4245                 fprintf(stderr, "MAX_ASSOC_SIZE reached\n");
4246         }
4247 }
4248
4249 static void _get_window_pos(Display *dpy, Window win, WindowPosStruct* pos)
4250 {
4251         XWindowAttributes window_attributes_return;
4252         Window child;
4253         int x, y;
4254         Window root = DefaultRootWindow(dpy);
4255         XGetWindowAttributes(dpy, win, &window_attributes_return);
4256         XTranslateCoordinates(dpy, win, root, 0, 0, &x, &y, &child);
4257         /*printf("%d %d %d %d\n", x, y,
4258           window_attributes_return.width, window_attributes_return.height);*/
4259         pos->x = x;
4260         pos->y = y;
4261         pos->width = window_attributes_return.width;
4262         pos->height = window_attributes_return.height;
4263         pos->map_state = window_attributes_return.map_state;
4264 }
4265
4266 static int is_gl_vendor_ati(Display* dpy)
4267 {
4268         static int is_gl_vendor_ati_flag = 0;
4269         static int has_init = 0;
4270         if (has_init == 0)
4271         {
4272                 has_init = 1;
4273                 is_gl_vendor_ati_flag = (strncmp(glXGetClientString(dpy, GLX_VENDOR), "ATI", 3) == 0);
4274         }
4275         return is_gl_vendor_ati_flag;
4276 }
4277
4278 static int get_server_texture(ProcessStruct* process, unsigned int client_texture)
4279 {
4280         unsigned int server_texture = 0;
4281         if (client_texture < 32768)
4282         {
4283                 server_texture = process->current_state->tabTextures[client_texture];
4284         }
4285         else
4286         {
4287                 fprintf(stderr, "invalid texture name %d\n", client_texture);
4288         }
4289         return server_texture;
4290 }
4291
4292 static int get_server_buffer(ProcessStruct* process, unsigned int client_buffer)
4293 {
4294         unsigned int server_buffer = 0;
4295         if (client_buffer < 32768)
4296         {
4297                 server_buffer = process->current_state->tabBuffers[client_buffer];
4298         }
4299         else
4300         {
4301                 fprintf(stderr, "invalid buffer name %d\n", client_buffer);
4302         }
4303         return server_buffer;
4304 }
4305
4306
4307 static int get_server_list(ProcessStruct* process, unsigned int client_list)
4308 {
4309         unsigned int server_list = 0;
4310         if (client_list < 32768)
4311         {
4312                 server_list = process->current_state->tabLists[client_list];
4313         }
4314         else
4315         {
4316                 fprintf(stderr, "invalid list name %d\n", client_list);
4317         }
4318         return server_list;
4319 }
4320
4321 static GLXFBConfig get_fbconfig(ProcessStruct* process, int client_fbconfig)
4322 {
4323         int i;
4324         int nbtotal = 0;
4325         for(i=0;i<process->nfbconfig;i++)
4326         {
4327                 assert(client_fbconfig >= 1 + nbtotal);
4328                 if (client_fbconfig <= nbtotal + process->fbconfigs_max[i])
4329                 {
4330                         return process->fbconfigs[i][client_fbconfig-1 - nbtotal];
4331                 }
4332                 nbtotal += process->fbconfigs_max[i];
4333         }
4334         return 0;
4335 }
4336
4337 typedef struct
4338 {
4339         int attribListLength;
4340         int* attribList;
4341         XVisualInfo* visInfo;
4342 } AssocAttribListVisual;
4343
4344 static int _compute_length_of_attrib_list_including_zero(const int* attribList, int booleanMustHaveValue)
4345 {
4346         int i = 0;
4347         while(attribList[i])
4348         {
4349                 if (booleanMustHaveValue ||
4350                                 !(attribList[i] == GLX_USE_GL ||
4351                                         attribList[i] == GLX_RGBA ||
4352                                         attribList[i] == GLX_DOUBLEBUFFER ||
4353                                         attribList[i] == GLX_STEREO))
4354                 {
4355                         i+=2;
4356                 }
4357                 else
4358                 {
4359                         i++;
4360                 }
4361         }
4362         return i + 1;
4363 }
4364
4365 static int glXChooseVisualFunc( OGLS_Conn *pConn, const int* _attribList)
4366 {
4367         AssocAttribListVisual *tabAssocAttribListVisual = (AssocAttribListVisual *)pConn->tabAssocAttribListVisual ;
4368
4369         if (_attribList == NULL)
4370                 return 0;
4371         int attribListLength = _compute_length_of_attrib_list_including_zero(_attribList, 0);
4372         int i;
4373
4374         int* attribList = malloc(sizeof(int) * attribListLength);
4375         memcpy(attribList, _attribList, sizeof(int) * attribListLength);
4376
4377         i = 0;
4378         while(attribList[i])
4379         {
4380                 if (!(attribList[i] == GLX_USE_GL ||
4381                                         attribList[i] == GLX_RGBA ||
4382                                         attribList[i] == GLX_DOUBLEBUFFER ||
4383                                         attribList[i] == GLX_STEREO))
4384                 {
4385                         if (attribList[i] == GLX_SAMPLE_BUFFERS && attribList[i+1] != 0 && getenv("DISABLE_SAMPLE_BUFFERS"))
4386                         {
4387                                 fprintf(stderr, "Disabling GLX_SAMPLE_BUFFERS\n");
4388                                 attribList[i+1] = 0;
4389                         }
4390                         i+=2;
4391                 }
4392                 else
4393                 {
4394                         i++;
4395                 }
4396         }
4397
4398         for(i=0;i<pConn->nTabAssocAttribListVisual;i++)
4399         {
4400                 if (tabAssocAttribListVisual[i].attribListLength == attribListLength &&
4401                                 memcmp(tabAssocAttribListVisual[i].attribList, attribList, attribListLength * sizeof(int)) == 0)
4402                 {
4403                         free(attribList);
4404                         return (tabAssocAttribListVisual[i].visInfo) ? tabAssocAttribListVisual[i].visInfo->visualid : 0;
4405                 }
4406         }
4407         XVisualInfo* visInfo = glXChooseVisual(pConn->Display, 0, attribList);
4408         pConn->tabAssocAttribListVisual = tabAssocAttribListVisual =
4409                 realloc(tabAssocAttribListVisual, sizeof(AssocAttribListVisual) * (pConn->nTabAssocAttribListVisual+1));
4410         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribListLength = attribListLength;
4411         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribList = (int*)malloc(sizeof(int) * attribListLength);
4412         memcpy(tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribList, attribList, sizeof(int) * attribListLength);
4413         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].visInfo = visInfo;
4414         pConn->nTabAssocAttribListVisual++;
4415         free(attribList);
4416         return (visInfo) ? visInfo->visualid : 0;
4417 }
4418
4419 static XVisualInfo* get_visual_info_from_visual_id( OGLS_Conn *pConn, int visualid)
4420 {
4421         int i, n;
4422         XVisualInfo template;
4423         XVisualInfo* visInfo;
4424
4425         AssocAttribListVisual *tabAssocAttribListVisual = (AssocAttribListVisual *)pConn->tabAssocAttribListVisual ;
4426
4427         for(i=0;i<pConn->nTabAssocAttribListVisual;i++)
4428         {
4429                 if (tabAssocAttribListVisual[i].visInfo &&
4430                                 tabAssocAttribListVisual[i].visInfo->visualid == visualid)
4431                 {
4432                         return tabAssocAttribListVisual[i].visInfo;
4433                 }
4434         }
4435         template.visualid = visualid;
4436         visInfo = XGetVisualInfo(pConn->Display, VisualIDMask, &template, &n);
4437         pConn->tabAssocAttribListVisual = tabAssocAttribListVisual =
4438                 realloc(tabAssocAttribListVisual, sizeof(AssocAttribListVisual) * (pConn->nTabAssocAttribListVisual+1));
4439         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribListLength = 0;
4440         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribList = NULL;
4441         tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].visInfo = visInfo;
4442         pConn->nTabAssocAttribListVisual++;
4443         return visInfo;
4444 }
4445
4446 typedef struct
4447 {
4448         int x;
4449         int y;
4450         int width;
4451         int height;
4452         int xhot;
4453         int yhot;
4454         int* pixels;
4455 } ClientCursor;
4456
4457 static ClientCursor client_cursor = { 0 };
4458
4459 static void do_glClientActiveTextureARB(int texture)
4460 {
4461         GET_EXT_PTR_NO_FAIL(void, glClientActiveTextureARB, (int));
4462         if (ptr_func_glClientActiveTextureARB)
4463         {
4464                 ptr_func_glClientActiveTextureARB(texture);
4465         }
4466 }
4467
4468 static void do_glActiveTextureARB(int texture)
4469 {
4470         GET_EXT_PTR_NO_FAIL(void, glActiveTextureARB, (int));
4471         if (ptr_func_glActiveTextureARB)
4472         {
4473                 ptr_func_glActiveTextureARB(texture);
4474         }
4475 }
4476
4477 static void do_glUseProgramObjectARB(GLhandleARB programObj)
4478 {
4479         GET_EXT_PTR_NO_FAIL(void, glUseProgramObjectARB, (GLhandleARB));
4480         if (ptr_func_glUseProgramObjectARB)
4481         {
4482                 ptr_func_glUseProgramObjectARB(programObj);
4483         }
4484 }
4485
4486 static void destroy_gl_state(GLState* state)
4487 {
4488         int i;
4489         if (state->vertexPointer) free(state->vertexPointer);
4490         if (state->normalPointer) free(state->normalPointer);
4491         if (state->indexPointer) free(state->indexPointer);
4492         if (state->colorPointer) free(state->colorPointer);
4493         if (state->secondaryColorPointer) free(state->secondaryColorPointer);
4494         for(i=0;i<NB_MAX_TEXTURES;i++)
4495         {
4496                 if (state->texCoordPointer[i]) free(state->texCoordPointer[i]);
4497         }
4498         for(i=0;i<MY_GL_MAX_VERTEX_ATTRIBS_ARB;i++)
4499         {
4500                 if (state->vertexAttribPointer[i]) free(state->vertexAttribPointer[i]);
4501         }
4502         for(i=0;i<MY_GL_MAX_VERTEX_ATTRIBS_NV;i++)
4503         {
4504                 if (state->vertexAttribPointerNV[i]) free(state->vertexAttribPointerNV[i]);
4505         }
4506         if (state->weightPointer) free(state->weightPointer);
4507         if (state->matrixIndexPointer) free(state->matrixIndexPointer);
4508         if (state->fogCoordPointer) free(state->fogCoordPointer);
4509         for(i=0;i<MY_GL_MAX_VARIANT_POINTER_EXT;i++)
4510         {
4511                 if (state->variantPointerEXT[i]) free(state->variantPointerEXT[i]);
4512         }
4513         if (state->interleavedArrays) free(state->interleavedArrays);
4514         if (state->elementPointerATI) free(state->elementPointerATI);
4515 }
4516
4517 static void init_gl_state(GLState* state)
4518 {
4519         state->textureAllocator = &state->ownTextureAllocator;
4520         state->tabTextures = state->ownTabTextures;
4521         state->bufferAllocator = &state->ownBufferAllocator;
4522         state->tabBuffers = state->ownTabBuffers;
4523         state->listAllocator = &state->ownListAllocator;
4524         state->tabLists = state->ownTabLists;
4525 }
4526
4527 /*
4528  * Translate the nth element of list from type to GLuint.
4529  */
4530         static GLuint
4531 translate_id(GLsizei n, GLenum type, const GLvoid * list)
4532 {
4533         GLbyte *bptr;
4534         GLubyte *ubptr;
4535         GLshort *sptr;
4536         GLushort *usptr;
4537         GLint *iptr;
4538         GLuint *uiptr;
4539         GLfloat *fptr;
4540
4541         switch (type) {
4542                 case GL_BYTE:
4543                         bptr = (GLbyte *) list;
4544                         return (GLuint) *(bptr + n);
4545                 case GL_UNSIGNED_BYTE:
4546                         ubptr = (GLubyte *) list;
4547                         return (GLuint) *(ubptr + n);
4548                 case GL_SHORT:
4549                         sptr = (GLshort *) list;
4550                         return (GLuint) *(sptr + n);
4551                 case GL_UNSIGNED_SHORT:
4552                         usptr = (GLushort *) list;
4553                         return (GLuint) *(usptr + n);
4554                 case GL_INT:
4555                         iptr = (GLint *) list;
4556                         return (GLuint) *(iptr + n);
4557                 case GL_UNSIGNED_INT:
4558                         uiptr = (GLuint *) list;
4559                         return (GLuint) *(uiptr + n);
4560                 case GL_FLOAT:
4561                         fptr = (GLfloat *) list;
4562                         return (GLuint) *(fptr + n);
4563                 case GL_2_BYTES:
4564                         ubptr = ((GLubyte *) list) + 2 * n;
4565                         return (GLuint) *ubptr * 256 + (GLuint) * (ubptr + 1);
4566                 case GL_3_BYTES:
4567                         ubptr = ((GLubyte *) list) + 3 * n;
4568                         return (GLuint) * ubptr * 65536
4569                                 + (GLuint) *(ubptr + 1) * 256 + (GLuint) * (ubptr + 2);
4570                 case GL_4_BYTES:
4571                         ubptr = ((GLubyte *) list) + 4 * n;
4572                         return (GLuint) *ubptr * 16777216
4573                                 + (GLuint) *(ubptr + 1) * 65536
4574                                 + (GLuint) *(ubptr + 2) * 256 + (GLuint) * (ubptr + 3);
4575                 default:
4576                         return 0;
4577         }
4578 }
4579
4580 static void _create_context(ProcessStruct* process, GLXContext ctxt, int fake_ctxt, GLXContext shareList, int fake_shareList)
4581 {
4582         process->glstates = realloc(process->glstates, (process->nbGLStates+1)*sizeof(GLState*));
4583         process->glstates[process->nbGLStates] = malloc(sizeof(GLState));
4584         memset(process->glstates[process->nbGLStates], 0, sizeof(GLState));
4585         process->glstates[process->nbGLStates]->ref = 1;
4586         process->glstates[process->nbGLStates]->context = ctxt;
4587         process->glstates[process->nbGLStates]->fake_ctxt = fake_ctxt;
4588         process->glstates[process->nbGLStates]->fake_shareList = fake_shareList;
4589         init_gl_state(process->glstates[process->nbGLStates]);
4590         if (shareList && fake_shareList)
4591         {
4592                 int i;
4593                 for(i=0;i<process->nbGLStates;i++)
4594                 {
4595                         if (process->glstates[i]->fake_ctxt == fake_shareList)
4596                         {
4597                                 process->glstates[i]->ref ++;
4598                                 process->glstates[process->nbGLStates]->textureAllocator =
4599                                         process->glstates[i]->textureAllocator;
4600                                 process->glstates[process->nbGLStates]->tabTextures =
4601                                         process->glstates[i]->tabTextures;
4602                                 process->glstates[process->nbGLStates]->bufferAllocator =
4603                                         process->glstates[i]->bufferAllocator;
4604                                 process->glstates[process->nbGLStates]->tabBuffers =
4605                                         process->glstates[i]->tabBuffers;
4606                                 process->glstates[process->nbGLStates]->listAllocator =
4607                                         process->glstates[i]->listAllocator;
4608                                 process->glstates[process->nbGLStates]->tabLists =
4609                                         process->glstates[i]->tabLists;
4610                                 break;
4611                         }
4612                 }
4613         }
4614         process->nbGLStates++;
4615 }
4616
4617 static const char *opengl_strtok(const char *s, int *n, char **saveptr, char *prevbuf)
4618 {
4619         char *start;
4620         char *ret;
4621         char *p;
4622         int retlen;
4623     static const char *delim = " \t\n\r/";
4624
4625         if (prevbuf)
4626                 free(prevbuf);
4627
4628     if (s) {
4629         *saveptr = s;
4630     } else {
4631         if (!(*saveptr) || !(*n))
4632             return NULL;
4633         s = *saveptr;
4634     }
4635
4636     for (; *n && strchr(delim, *s); s++, (*n)--) {
4637         if (*s == '/' && *n > 1) {
4638             if (s[1] == '/') {
4639                 do {
4640                     s++, (*n)--;
4641                 } while (*n > 1 && s[1] != '\n' && s[1] != '\r');
4642             } else if (s[1] == '*') {
4643                 do {
4644                     s++, (*n)--;
4645                 } while (*n > 2 && (s[1] != '*' || s[2] != '/'));
4646                 s++, (*n)--;
4647             }
4648         }
4649     }
4650
4651         start = s;
4652     for (; *n && *s && !strchr(delim, *s); s++, (*n)--);
4653         if (*n > 0)
4654                 s++, (*n)--;
4655
4656         *saveptr = s;
4657
4658         retlen = s - start;
4659         ret = malloc(retlen + 1);
4660         p = ret;
4661
4662         while (retlen > 0) {
4663         if (*start == '/' && retlen > 1) {
4664             if (start[1] == '/') {
4665                 do {
4666                     start++, retlen--;
4667                 } while (retlen > 1 && start[1] != '\n' && start[1] != '\r');
4668                                 start++, retlen--;
4669                                 continue;
4670             } else if (start[1] == '*') {
4671                 do {
4672                     start++, retlen--;
4673                 } while (retlen > 2 && (start[1] != '*' || start[2] != '/'));
4674                 start += 3, retlen -= 3;
4675                                 continue;
4676             }
4677         }
4678                 *(p++) = *(start++), retlen--;
4679         }
4680
4681         *p = 0;
4682         return ret;
4683 }
4684
4685 static char *do_eglShaderPatch(const char *source, int length, int *patched_len)
4686 {
4687         char *saveptr = NULL;
4688         char *sp;
4689         char *p = NULL;
4690
4691     if (!length)
4692         length = strlen(source);
4693
4694     *patched_len = 0;
4695     int patched_size = length;
4696     char *patched = malloc(patched_size + 1);
4697
4698     if (!patched)
4699         return NULL;
4700
4701     p = opengl_strtok(source, &length, &saveptr, NULL);
4702     for (; p; p = opengl_strtok(0, &length, &saveptr, p)) {
4703         if (!strncmp(p, "lowp", 4) || !strncmp(p, "mediump", 7) || !strncmp(p, "highp", 5)) {
4704             continue;
4705         } else if (!strncmp(p, "precision", 9)) {
4706             while ((p = opengl_strtok(0, &length, &saveptr, p)) && !strchr(p, ';'));
4707         } else {
4708             if (!strncmp(p, "gl_MaxVertexUniformVectors", 26)) {
4709                 p = "(gl_MaxVertexUniformComponents / 4)";
4710             } else if (!strncmp(p, "gl_MaxFragmentUniformVectors", 28)) {
4711                 p = "(gl_MaxFragmentUniformComponents / 4)";
4712             } else if (!strncmp(p, "gl_MaxVaryingVectors", 20)) {
4713                 p = "(gl_MaxVaryingFloats / 4)";
4714             }
4715
4716             int new_len = strlen(p);
4717             if (*patched_len + new_len > patched_size) {
4718                 patched_size *= 2;
4719                 patched = realloc(patched, patched_size + 1);
4720
4721                 if (!patched)
4722                     return NULL;
4723             }
4724
4725             memcpy(patched + *patched_len, p, new_len);
4726             *patched_len += new_len;
4727         }
4728     }
4729
4730     patched[*patched_len] = 0;
4731     /* check that we don't leave dummy preprocessor lines */
4732     for (sp = patched; *sp;) {
4733         for (; *sp == ' ' || *sp == '\t'; sp++);
4734         if (!strncmp(sp, "#define", 7)) {
4735             for (p = sp + 7; *p == ' ' || *p == '\t'; p++);
4736             if (*p == '\n' || *p == '\r' || *p == '/') {
4737                 memset(sp, 0x20, 7);
4738             }
4739         }
4740         for (; *sp && *sp != '\n' && *sp != '\r'; sp++);
4741         for (; *sp == '\n' || *sp == '\r'; sp++);
4742     }
4743     return patched;
4744 }
4745
4746 static int
4747 shadersrc_gles_to_gl(GLsizei count, const char** string, char **s, const GLint* length, GLint *l)
4748 {
4749         int i;
4750
4751         for(i = 0; i < count; ++i) {
4752                 GLint len;
4753                 if(length) {
4754                         len = length[i];
4755                         if (len < 0)
4756                                 len = string[i] ? strlen(string[i]) : 0;
4757                 } else
4758                         len = string[i] ? strlen(string[i]) : 0;
4759
4760                 if(string[i]) {
4761                         s[i] = do_eglShaderPatch(string[i], len, &l[i]);
4762                         if(!s[i]) {
4763                                 while(i)
4764                                         free(s[--i]);
4765
4766                                 free(l);
4767                                 free(s);
4768                                 return -1;
4769                         }
4770                 } else {
4771                         s[i] = NULL;
4772                         l[i] = 0;
4773                 }
4774         }
4775
4776         return 0;
4777 }
4778
4779 int do_function_call(OGLS_Conn *pConn, int func_number, int pid, long* args, char* ret_string)
4780 {
4781         char ret_char = 0;
4782         int ret_int = 0;
4783         const char* ret_str = NULL;
4784         int iProcess;
4785         ProcessStruct* process = NULL;
4786         ProcessStruct *processTab = (ProcessStruct *) pConn->processTab;
4787
4788         if (pConn->parent_dpy)
4789         {
4790                 pConn->Display = pConn->parent_dpy;
4791         }
4792
4793         for(iProcess=0;iProcess<MAX_HANDLED_PROCESS;iProcess++)
4794         {
4795                 ProcessStruct *processTab = (ProcessStruct *) pConn->processTab;
4796                 if (processTab[iProcess].process_id == pid)
4797                 {
4798                         process = &processTab[iProcess];
4799                         break;
4800                 }
4801                 else if (processTab[iProcess].process_id == 0)
4802                 {
4803                         process = &processTab[iProcess];
4804                         memset(process, 0, sizeof(ProcessStruct));
4805                         process->process_id = pid;
4806                         process->internal_num = pConn->last_assigned_internal_num++;
4807                         init_gl_state(&process->default_state);
4808                         process->current_state = &process->default_state;
4809                         break;
4810                 }
4811         }
4812         if (process == NULL)
4813         {
4814                 fprintf(stderr, "Too many processes !\n");
4815                 return 0;
4816         }
4817         if (process->internal_num != pConn->last_active_internal_num)
4818         {
4819                 glXMakeCurrent(pConn->Display, process->current_state->drawable, process->current_state->context);
4820                 pConn->last_active_internal_num = process->internal_num;
4821         }
4822
4823         process->instr_counter++;
4824
4825         if (display_function_call) fprintf(stderr, "[%d]> %s\n", process->instr_counter, tab_opengl_calls_name[func_number]);
4826         //fprintf(stderr, "[%d]> %s\n", process->instr_counter, tab_opengl_calls_name[func_number]);
4827
4828         switch (func_number)
4829         {
4830                 case _init_func:
4831                         {
4832                                 *(int*)args[1] = 1;
4833                                 break;
4834                         }
4835
4836                 case _synchronize_func:
4837                         {
4838                                 ret_int = 1;
4839                                 break;
4840                         }
4841
4842                 case _exit_process_func:
4843                         {
4844                                 int i;
4845
4846                                 for(i=0;i < MAX_ASSOC_SIZE && process->association_fakecontext_glxcontext[i].key != NULL;i++)
4847                                 {
4848                                         GLXContext ctxt = process->association_fakecontext_glxcontext[i].value;
4849                                         //fprintf(stderr, "Destroy context corresponding to fake_context = %ld\n",
4850                                         //              (long)process->association_fakecontext_glxcontext[i].key);
4851                                         glXDestroyContext(pConn->Display, ctxt);
4852                                 }
4853
4854                                 GET_EXT_PTR(void, glXDestroyPbuffer, (Display*, GLXPbuffer));
4855                                 for(i=0;i < MAX_ASSOC_SIZE && process->association_fakepbuffer_pbuffer[i].key != NULL;i++)
4856                                 {
4857                                         GLXPbuffer pbuffer = (GLXPbuffer)process->association_fakepbuffer_pbuffer[i].value;
4858                                         fprintf(stderr, "Destroy pbuffer corresponding to fake_pbuffer = %ld\n",
4859                                                         (long)process->association_fakepbuffer_pbuffer[i].key);
4860                                         if (!is_gl_vendor_ati(pConn->Display))
4861                                                 ptr_func_glXDestroyPbuffer(pConn->Display, pbuffer);
4862                                 }
4863
4864                                 for(i=0;i < MAX_ASSOC_SIZE && process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
4865                                 {
4866                                         //fprintf(stderr, "Destroy window corresponding to client_drawable = %p\n",
4867                                         //              process->association_clientdrawable_serverdrawable[i].key);
4868
4869                                         Window win = (Window)process->association_clientdrawable_serverdrawable[i].value;
4870                                         XDestroyWindow(pConn->Display, win);
4871
4872                                         int loop = 1;
4873                                         while (loop) {
4874                                                 while (XPending(pConn->Display) > 0) {
4875                                                         XEvent event;
4876                                                         XNextEvent(pConn->Display, &event);
4877                                                         switch (event.type) {
4878                                                                 case DestroyNotify:
4879                                                                         {
4880                                                                                 if (((XDestroyWindowEvent*)&event)->window == win)
4881                                                                                 {
4882                                                                                         loop = 0;
4883                                                                                 }
4884                                                                                 break;
4885                                                                         }
4886                                                         }
4887                                                 }
4888                                         }
4889                                 }
4890
4891                                 for(i=0;i<process->nbGLStates;i++)
4892                                 {
4893                                         destroy_gl_state(process->glstates[i]);
4894                                         free(process->glstates[i]);
4895                                 }
4896                                 destroy_gl_state(&process->default_state);
4897                                 free(process->glstates);
4898
4899                                 pConn->active_win = 0;
4900
4901                                 memmove(&processTab[iProcess], &processTab[iProcess+1], (MAX_HANDLED_PROCESS - 1 - iProcess) * sizeof(ProcessStruct));
4902
4903                                 last_process_id = 0;
4904
4905                                 break;
4906                         }
4907
4908                 case _changeWindowState_func:
4909                         {
4910                                 GLXDrawable client_drawable = args[0];
4911                                 if (display_function_call) fprintf(stderr, "client_drawable=%p\n", (void*)client_drawable);
4912
4913                                 GLXDrawable drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
4914                                 if (drawable)
4915                                 {
4916                                         if (args[1] == IsViewable)
4917                                         {
4918                                                 WindowPosStruct pos;
4919                                                 _get_window_pos(pConn->Display, drawable, &pos);
4920                                                 if (pos.map_state != args[1])
4921                                                 {
4922                                                         XMapWindow(pConn->Display, drawable);
4923
4924                                                         int loop = 0; //1;
4925                                                         while (loop) {
4926                                                                 while (XPending(pConn->Display) > 0) {
4927                                                                         XEvent event;
4928                                                                         XNextEvent(pConn->Display, &event);
4929                                                                         switch (event.type) {
4930                                                                                 case ConfigureNotify:
4931                                                                                         {
4932                                                                                                 if (((XConfigureEvent*)&event)->window == drawable)
4933                                                                                                 {
4934                                                                                                         loop = 0;
4935                                                                                                 }
4936                                                                                                 break;
4937                                                                                         }
4938                                                                         }
4939                                                                 }
4940                                                         }
4941                                                 }
4942                                         }
4943                                 }
4944
4945                                 break;
4946                         }
4947
4948                 case _moveResizeWindow_func:
4949                         {
4950                                 int* params = (int*)args[1];
4951                                 GLXDrawable client_drawable = args[0];
4952                                 if (display_function_call) fprintf(stderr, "client_drawable=%p\n", (void*)client_drawable);
4953
4954                                 GLXDrawable drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
4955                                 if (drawable)
4956                                 {
4957                                         WindowPosStruct pos;
4958                                         _get_window_pos(pConn->Display, drawable, &pos);
4959                                         if (!(params[0] == pos.x && params[1] == pos.y && params[2] == pos.width && params[3] == pos.height))
4960                                         {
4961                                                 int redim = !(params[2] == pos.width && params[3] == pos.height);
4962                                                 pConn->active_win_x = params[0];
4963                                                 pConn->active_win_y = params[1];
4964
4965                                                 /*
4966                                                    fprintf(stderr, "old x=%d y=%d width=%d height=%d\n", pos.x, pos.y, pos.width, pos.height);
4967                                                    fprintf(stderr, "new x=%d y=%d width=%d height=%d\n", params[0], params[1], params[2], params[3]);
4968                                                  */
4969
4970                                                 XMoveResizeWindow(pConn->Display, drawable, params[0], params[1], params[2], params[3]);
4971                                                 _get_window_pos(pConn->Display, drawable, &pos);
4972                                                 process->currentDrawablePos = pos;
4973                                                 //if (getenv("FORCE_GL_VIEWPORT"))
4974                                                 if (redim)
4975                                                         glViewport(0, 0, params[2], params[3]);
4976                                                 int loop = 0; //1;
4977                                                 while (loop) {
4978                                                         while (XPending(pConn->Display) > 0) {
4979                                                                 XEvent event;
4980                                                                 XNextEvent(pConn->Display, &event);
4981                                                                 switch (event.type) {
4982                                                                         case ConfigureNotify:
4983                                                                                 {
4984                                                                                         if (((XConfigureEvent*)&event)->window == drawable)
4985                                                                                         {
4986                                                                                                 loop = 0;
4987                                                                                         }
4988                                                                                         break;
4989                                                                                 }
4990                                                                 }
4991                                                         }
4992                                                 }
4993                                         }
4994                                 }
4995                                 break;
4996                         }
4997
4998                 case _send_cursor_func:
4999                         {
5000                                 int x = args[0];
5001                                 int y = args[1];
5002                                 int width = args[2];
5003                                 int height = args[3];
5004                                 int xhot = args[4];
5005                                 int yhot = args[5];
5006                                 int* pixels = (int*)args[6];
5007                                 client_cursor.x = x;
5008                                 client_cursor.y = y;
5009                                 client_cursor.width = width;
5010                                 client_cursor.height = height;
5011                                 client_cursor.xhot = xhot;
5012                                 client_cursor.yhot = yhot;
5013                                 if (pixels)
5014                                 {
5015                                         client_cursor.pixels = realloc(client_cursor.pixels, client_cursor.width * client_cursor.height * sizeof(int));
5016                                         memcpy(client_cursor.pixels, pixels, client_cursor.width * client_cursor.height * sizeof(int));
5017                                 }
5018                                 //int in_window = (x >= 0 && y >= 0 &&
5019                                 //x < process->currentDrawablePos.width &&
5020                                 //y < process->currentDrawablePos.height);
5021                                 //fprintf(stderr, "cursor at %d %d   (%s)\n", x, y, (in_window) ? "in window" : "not in window");
5022                                 break;
5023                         }
5024
5025                 case glXWaitGL_func:
5026                         {
5027                                 glXWaitGL();
5028                                 ret_int = 0;
5029                                 break;
5030                         }
5031
5032                 case glXWaitX_func:
5033                         {
5034                                 glXWaitX();
5035                                 ret_int = 0;
5036                                 break;
5037                         }
5038
5039                 case glXChooseVisual_func:
5040                         {
5041                                 ret_int = glXChooseVisualFunc(pConn, (int*)args[2]);
5042                                 break;
5043                         }
5044
5045                 case glXQueryExtensionsString_func:
5046                         {
5047                                 ret_str = glXQueryExtensionsString(pConn->Display, 0);
5048                                 break;
5049                         }
5050
5051                 case glXQueryServerString_func:
5052                         {
5053                                 ret_str = glXQueryServerString(pConn->Display, 0, args[2]);
5054                                 break;
5055                         }
5056
5057                 case glXGetClientString_func:
5058                         {
5059                                 ret_str = glXGetClientString(pConn->Display, args[1]);
5060                                 break;
5061                         }
5062
5063                 case glXGetScreenDriver_func:
5064                         {
5065                                 GET_EXT_PTR(const char*, glXGetScreenDriver, (Display* , int ));
5066                                 ret_str = ptr_func_glXGetScreenDriver(pConn->Display, 0);
5067                                 break;
5068                         }
5069
5070                 case glXGetDriverConfig_func:
5071                         {
5072                                 GET_EXT_PTR(const char*, glXGetDriverConfig, (const char* ));
5073                                 ret_str = ptr_func_glXGetDriverConfig((const char*)args[0]);
5074                                 break;
5075                         }
5076
5077                 case glXCreateContext_func:
5078                         {
5079                                 int visualid = (int)args[1];
5080                                 int fake_shareList = (int)args[2];
5081                                 if (1 || display_function_call) fprintf(stderr, "visualid=%d, fake_shareList=%d\n", visualid, fake_shareList);
5082
5083                                 GLXContext shareList = get_association_fakecontext_glxcontext(process, (void*)(long)fake_shareList);
5084                                 XVisualInfo* vis = get_visual_info_from_visual_id(pConn, visualid);
5085                                 GLXContext ctxt;
5086                                 if (vis)
5087                                 {
5088                                         ctxt = glXCreateContext(pConn->Display, vis, shareList, args[3]);
5089                                 }
5090                                 else
5091                                 {
5092                                         vis = get_default_visual(pConn->Display);
5093                                         int saved_visualid = vis->visualid;
5094                                         vis->visualid = (visualid) ? visualid : saved_visualid;
5095                                         ctxt = glXCreateContext(pConn->Display, vis, shareList, args[3]);
5096                                         vis->visualid = saved_visualid;
5097                                 }
5098
5099                                 if (ctxt)
5100                                 {
5101                                         process->next_available_context_number ++;
5102                                         int fake_ctxt = process->next_available_context_number;
5103                                         set_association_fakecontext_visual(process, (void*)(long)fake_ctxt, vis);
5104                                         set_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt, ctxt);
5105                                         ret_int = fake_ctxt;
5106
5107                                         _create_context(process, ctxt, fake_ctxt, shareList, fake_shareList);
5108                                 }
5109                                 else
5110                                 {
5111                                         ret_int = 0;
5112                                 }
5113
5114                                 break;
5115                         }
5116
5117
5118                 case glXCreateNewContext_func:
5119                         {
5120                                 GET_EXT_PTR(GLXContext, glXCreateNewContext, (Display*, GLXFBConfig, int, GLXContext, int));
5121                                 GET_EXT_PTR(XVisualInfo*, glXGetVisualFromFBConfig, (Display*, GLXFBConfig));
5122                                 int client_fbconfig = args[1];
5123                                 XVisualInfo* vis = NULL;
5124
5125                                 ret_int = 0;
5126                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5127                                 if (fbconfig)
5128                                 {
5129                                         int fake_shareList = args[3];
5130                                         GLXContext shareList = get_association_fakecontext_glxcontext(process, (void*)(long)fake_shareList);
5131                                         process->next_available_context_number ++;
5132                                         int fake_ctxt = process->next_available_context_number;
5133                                         GLXContext ctxt = ptr_func_glXCreateNewContext(pConn->Display, fbconfig, args[2], shareList, args[4]);
5134                                         set_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt, ctxt);
5135
5136                                         vis = ptr_func_glXGetVisualFromFBConfig(pConn->Display, fbconfig); /* visual info ????*/
5137                                         set_association_fakecontext_visual(process, (void *)(long)fake_ctxt, vis);
5138
5139                                         ret_int = fake_ctxt;
5140
5141                                         _create_context(process, ctxt, fake_ctxt, shareList, fake_shareList);
5142                                 }
5143                                 break;
5144                         }
5145
5146                 case glXCopyContext_func:
5147                         {
5148                                 GLXContext fake_src_ctxt = (GLXContext)args[1];
5149                                 GLXContext fake_dst_ctxt = (GLXContext)args[2];
5150                                 GLXContext src_ctxt;
5151                                 GLXContext dst_ctxt;
5152                                 if (display_function_call) fprintf(stderr, "fake_src_ctxt=%p, fake_dst_ctxt=%p\n", fake_src_ctxt, fake_dst_ctxt);
5153
5154                                 if ((src_ctxt = get_association_fakecontext_glxcontext(process, fake_src_ctxt)) == NULL)
5155                                 {
5156                                         fprintf(stderr, "invalid fake_src_ctxt (%p) !\n", fake_src_ctxt);
5157                                 }
5158                                 else if ((dst_ctxt = get_association_fakecontext_glxcontext(process, fake_dst_ctxt)) == NULL)
5159                                 {
5160                                         fprintf(stderr, "invalid fake_dst_ctxt (%p) !\n", fake_dst_ctxt);
5161                                 }
5162                                 else
5163                                 {
5164                                         glXCopyContext(pConn->Display, src_ctxt, dst_ctxt, args[3]);
5165                                 }
5166                                 break;
5167                         }
5168
5169                 case glXDestroyContext_func:
5170                         {
5171                                 int fake_ctxt = (int)args[1];
5172                                 if (display_function_call) fprintf(stderr, "fake_ctxt=%d\n", fake_ctxt);
5173
5174                                 GLXContext ctxt = get_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt);
5175                                 if (ctxt == NULL)
5176                                 {
5177                                         fprintf(stderr, "invalid fake_ctxt (%p) !\n", (void*)(long)fake_ctxt);
5178                                 }
5179                                 else
5180                                 {
5181                                         int i;
5182                                         for(i=0;i<process->nbGLStates;i++)
5183                                         {
5184                                                 if (process->glstates[i]->fake_ctxt == fake_ctxt)
5185                                                 {
5186                                                         if (ctxt == process->current_state->context)
5187                                                                 process->current_state = &process->default_state;
5188
5189                                                         int fake_shareList = process->glstates[i]->fake_shareList;
5190                                                         process->glstates[i]->ref --;
5191                                                         if (process->glstates[i]->ref == 0)
5192                                                         {
5193                                                                 fprintf(stderr, "destroy_gl_state fake_ctxt = %d\n", process->glstates[i]->fake_ctxt);
5194                                                                 destroy_gl_state(process->glstates[i]);
5195                                                                 free(process->glstates[i]);
5196                                                                 memmove(&process->glstates[i], &process->glstates[i+1], (process->nbGLStates-i-1) * sizeof(GLState*));
5197                                                                 process->nbGLStates--;
5198                                                         }
5199
5200                                                         if (fake_shareList)
5201                                                         {
5202                                                                 for(i=0;i<process->nbGLStates;i++)
5203                                                                 {
5204                                                                         if (process->glstates[i]->fake_ctxt == fake_shareList)
5205                                                                         {
5206                                                                                 process->glstates[i]->ref --;
5207                                                                                 if (process->glstates[i]->ref == 0)
5208                                                                                 {
5209                                                                                         fprintf(stderr, "destroy_gl_state fake_ctxt = %d\n", process->glstates[i]->fake_ctxt);
5210                                                                                         destroy_gl_state(process->glstates[i]);
5211                                                                                         free(process->glstates[i]);
5212                                                                                         memmove(&process->glstates[i], &process->glstates[i+1], (process->nbGLStates-i-1) * sizeof(GLState*));
5213                                                                                         process->nbGLStates--;
5214                                                                                 }
5215                                                                                 break;
5216                                                                         }
5217                                                                 }
5218                                                         }
5219
5220                                                         glXDestroyContext(pConn->Display, ctxt);
5221                                                         unset_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt);
5222
5223                                                         break;
5224                                                 }
5225                                         }
5226                                 }
5227                                 break;
5228                         }
5229
5230                 case glXQueryVersion_func:
5231                         {
5232                                 ret_int = glXQueryVersion(pConn->Display, (int*)args[1], (int*)args[2]);
5233                                 break;
5234                         }
5235
5236                 case glGetString_func:
5237                         {
5238                                 ret_str = (char*)glGetString(args[0]);
5239                                 break;
5240                         }
5241
5242                 case glXMakeCurrent_func:
5243                         {
5244                                 int i;
5245                                 GLXDrawable client_drawable = (GLXDrawable)args[1];
5246                                 GLXDrawable drawable = 0;
5247                                 int fake_ctxt = args[2];
5248                                 if (display_function_call) fprintf(stderr, "client_drawable=%p fake_ctx=%d\n", (void*)client_drawable, fake_ctxt);
5249
5250                                 if (client_drawable == 0 && fake_ctxt == 0)
5251                                 {
5252                                         ret_int = glXMakeCurrent(pConn->Display, 0, NULL);
5253                                         process->current_state = &process->default_state;
5254                                 }
5255                                 else if ((drawable = (GLXDrawable)get_association_fakepbuffer_pbuffer(process, (void*)client_drawable)))
5256                                 {
5257                                         GLXContext ctxt = get_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt);
5258                                         if (ctxt == NULL)
5259                                         {
5260                                                 fprintf(stderr, "invalid fake_ctxt (%d) (*)!\n", fake_ctxt);
5261                                                 ret_int = 0;
5262                                         }
5263                                         else
5264                                         {
5265                                                 ret_int = glXMakeCurrent(pConn->Display, drawable, ctxt);
5266                                         }
5267                                 }
5268                                 else
5269                                 {
5270                                         GLXContext ctxt = get_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt);
5271                                         if (ctxt == NULL)
5272                                         {
5273                                                 fprintf(stderr, "invalid fake_ctxt (%d)!\n", fake_ctxt);
5274                                                 ret_int = 0;
5275                                         }
5276                                         else
5277                                         {
5278                                                 drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
5279                                                 if (drawable == 0)
5280                                                 {
5281                                                         XVisualInfo* vis = (XVisualInfo*)get_association_fakecontext_visual(process, (void*)(long)fake_ctxt);
5282                                                         if (vis == NULL)
5283                                                                 vis = get_default_visual(pConn->Display);
5284                                                         /*if (pConn->local_connection)
5285                                                           drawable = client_drawable;
5286                                                           else*/
5287                                                         {
5288                                                                 if (/*pConn->local_connection &&*/ client_drawable == RootWindow(pConn->Display, 0))
5289                                                                 {
5290                                                                         drawable = client_drawable;
5291                                                                 }
5292                                                                 else
5293                                                                 {
5294                                                                         drawable = create_window(pConn, (pConn->local_connection) ? (Window)client_drawable : 0, vis, "", 0, 0, 480, 800);/* Default Window 크?綬�Simulator 크???? ?????磯?.*/
5295                                                                 }
5296                                                                 //fprintf(stderr, "creating window\n");
5297                                                         }
5298                                                         set_association_clientdrawable_serverdrawable(process, (void*)client_drawable, (void*)drawable);
5299                                                 }
5300
5301                                                 ret_int = glXMakeCurrent(pConn->Display, drawable, ctxt);
5302                                         }
5303                                 }
5304
5305                                 if (ret_int)
5306                                 {
5307                                         for(i=0;i<process->nbGLStates;i++)
5308                                         {
5309                                                 if (process->glstates[i]->fake_ctxt == fake_ctxt)
5310                                                 {
5311                                                         process->current_state = process->glstates[i]; /* HACK !!! REMOVE */
5312                                                         process->current_state->drawable = drawable;
5313                                                         break;
5314                                                 }
5315                                         }
5316                                 }
5317                                 break;
5318                         }
5319
5320                 case glXSwapBuffers_func:
5321                         {
5322                                 GLXDrawable client_drawable = args[1];
5323                                 if (display_function_call) fprintf(stderr, "client_drawable=%p\n", (void*)client_drawable);
5324
5325                                 GLXDrawable drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
5326                                 if (drawable == 0)
5327                                 {
5328                                         fprintf(stderr, "unknown client_drawable (%p) !\n", (void*)client_drawable);
5329                                 }
5330                                 else
5331                                 {
5332                                         if (client_cursor.pixels && pConn->local_connection == 0)
5333                                         {
5334                                                 glPushAttrib(GL_ALL_ATTRIB_BITS);
5335                                                 glPushClientAttrib(GL_ALL_ATTRIB_BITS);
5336
5337                                                 glMatrixMode(GL_PROJECTION);
5338                                                 glPushMatrix();
5339                                                 glLoadIdentity();
5340                                                 glOrtho(0,process->currentDrawablePos.width,process->currentDrawablePos.height,0,-1,1);
5341                                                 glMatrixMode(GL_MODELVIEW);
5342                                                 glPushMatrix();
5343                                                 glLoadIdentity();
5344                                                 glPixelZoom(1,-1);
5345
5346                                                 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
5347                                                 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
5348                                                 glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
5349                                                 glPixelStorei(GL_UNPACK_LSB_FIRST, 0);
5350                                                 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
5351                                                 glShadeModel(GL_SMOOTH);
5352
5353                                                 glEnable(GL_BLEND);
5354                                                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ;
5355                                                 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
5356
5357                                                 int i,numUnits;
5358                                                 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &numUnits);
5359                                                 for(i=0;i<numUnits;i++)
5360                                                 {
5361                                                         do_glActiveTextureARB(GL_TEXTURE0_ARB + i);
5362                                                         glDisable(GL_TEXTURE_1D);
5363                                                         glDisable(GL_TEXTURE_2D);
5364                                                         glDisable(GL_TEXTURE_3D);
5365                                                 }
5366                                                 glDisable(GL_ALPHA_TEST);
5367                                                 glDisable(GL_DEPTH_TEST);
5368                                                 glDisable(GL_STENCIL_TEST);
5369                                                 glDisable(GL_SCISSOR_TEST);
5370                                                 glDisable(GL_FRAGMENT_PROGRAM_ARB);
5371                                                 glDisable(GL_VERTEX_PROGRAM_ARB);
5372                                                 do_glUseProgramObjectARB (0);
5373
5374                                                 //memset(client_cursor.pixels, 255, client_cursor.width * client_cursor.height * sizeof(int));
5375
5376                                                 glRasterPos2d(client_cursor.x - client_cursor.xhot,
5377                                                                 client_cursor.y - client_cursor.yhot);
5378                                                 glDrawPixels(client_cursor.width, client_cursor.height,
5379                                                                 GL_BGRA, GL_UNSIGNED_BYTE,
5380                                                                 client_cursor.pixels);
5381
5382                                                 glMatrixMode(GL_MODELVIEW);
5383                                                 glPopMatrix();
5384
5385                                                 glMatrixMode(GL_PROJECTION);
5386                                                 glPopMatrix();
5387
5388                                                 glPopClientAttrib();
5389                                                 glPopAttrib();
5390                                         }
5391
5392                                         glXSwapBuffers(pConn->Display, drawable);
5393                                 }
5394                                 break;
5395                         }
5396
5397                 case glXIsDirect_func:
5398                         {
5399                                 GLXContext fake_ctxt = (GLXContext)args[1];
5400                                 if (display_function_call) fprintf(stderr, "fake_ctx=%p\n", fake_ctxt);
5401                                 GLXContext ctxt = get_association_fakecontext_glxcontext(process, fake_ctxt);
5402                                 if (ctxt == NULL)
5403                                 {
5404                                         fprintf(stderr, "invalid fake_ctxt (%p) !\n", fake_ctxt);
5405                                         ret_char = False;
5406                                 }
5407                                 else
5408                                 {
5409                                         ret_char = glXIsDirect(pConn->Display, ctxt);
5410                                 }
5411                                 break;
5412                         }
5413
5414                 case glXGetConfig_func:
5415                         {
5416                                 int visualid = args[1];
5417                                 XVisualInfo* vis = NULL;
5418                                 if (visualid)
5419                                         vis = get_visual_info_from_visual_id(pConn, visualid);
5420                                 if (vis == NULL)
5421                                         vis = get_default_visual(pConn->Display);
5422                                 ret_int = glXGetConfig(pConn->Display, vis, args[2], (int*)args[3]);
5423                                 break;
5424                         }
5425
5426                 case glXGetConfig_extended_func:
5427                         {
5428                                 int visualid = args[1];
5429                                 int n = args[2];
5430                                 int i;
5431                                 XVisualInfo* vis = NULL;
5432                                 int* attribs = (int*)args[3];
5433                                 int* values = (int*)args[4];
5434                                 int* res = (int*)args[5];
5435
5436                                 if (visualid)
5437                                         vis = get_visual_info_from_visual_id(pConn, visualid);
5438                                 if (vis == NULL)
5439                                         vis = get_default_visual(pConn->Display);
5440
5441                                 for(i=0;i<n;i++)
5442                                 {
5443                                         res[i] = glXGetConfig(pConn->Display, vis, attribs[i], &values[i]);
5444                                 }
5445                                 break;
5446                         }
5447
5448                 case glXUseXFont_func:
5449                         {
5450                                 /* implementation is client-side only :-) */
5451                                 break;
5452                         }
5453
5454
5455                 case glXQueryExtension_func:
5456                         {
5457                                 ret_int = glXQueryExtension(pConn->Display, (int*)args[1], (int*)args[2]);
5458                                 break;
5459                         }
5460
5461                 case glXChooseFBConfig_func:
5462                         {
5463                                 GET_EXT_PTR(GLXFBConfig*, glXChooseFBConfig, (Display*, int, int*, int*));
5464                                 if (process->nfbconfig == MAX_FBCONFIG)
5465                                 {
5466                                         *(int*)args[3] = 0;
5467                                         ret_int = 0;
5468                                 }
5469                                 else
5470                                 {
5471                                         GLXFBConfig* fbconfigs = ptr_func_glXChooseFBConfig(pConn->Display, args[1], (int*)args[2], (int*)args[3]);
5472                                         if (fbconfigs)
5473                                         {
5474                                                 process->fbconfigs[process->nfbconfig] = fbconfigs;
5475                                                 process->fbconfigs_max[process->nfbconfig] = *(int*)args[3];
5476                                                 process->nfbconfig++;
5477                                                 ret_int = 1 + process->nfbconfig_total;
5478                                                 process->nfbconfig_total += process->fbconfigs_max[process->nfbconfig];
5479                                         }
5480                                         else
5481                                         {
5482                                                 ret_int = 0;
5483                                         }
5484                                 }
5485                                 break;
5486                         }
5487
5488                 case glXChooseFBConfigSGIX_func:
5489                         {
5490                                 GET_EXT_PTR(GLXFBConfigSGIX*, glXChooseFBConfigSGIX, (Display*, int, int*, int*));
5491                                 if (process->nfbconfig == MAX_FBCONFIG)
5492                                 {
5493                                         *(int*)args[3] = 0;
5494                                         ret_int = 0;
5495                                 }
5496                                 else
5497                                 {
5498                                         GLXFBConfigSGIX* fbconfigs = ptr_func_glXChooseFBConfigSGIX(pConn->Display, args[1], (int*)args[2], (int*)args[3]);
5499                                         if (fbconfigs)
5500                                         {
5501                                                 process->fbconfigs[process->nfbconfig] = fbconfigs;
5502                                                 process->fbconfigs_max[process->nfbconfig] = *(int*)args[3];
5503                                                 process->nfbconfig++;
5504                                                 ret_int = 1 + process->nfbconfig_total;
5505                                                 process->nfbconfig_total += process->fbconfigs_max[process->nfbconfig];
5506                                         }
5507                                         else
5508                                         {
5509                                                 ret_int = 0;
5510                                         }
5511                                 }
5512                                 break;
5513                         }
5514
5515                 case glXGetFBConfigs_func:
5516                         {
5517                                 GET_EXT_PTR(GLXFBConfig*, glXGetFBConfigs, (Display*, int, int*));
5518                                 if (process->nfbconfig == MAX_FBCONFIG)
5519                                 {
5520                                         *(int*)args[2] = 0;
5521                                         ret_int = 0;
5522                                 }
5523                                 else
5524                                 {
5525                                         GLXFBConfig* fbconfigs = ptr_func_glXGetFBConfigs(pConn->Display, args[1], (int*)args[2]);
5526                                         if (fbconfigs)
5527                                         {
5528                                                 process->fbconfigs[process->nfbconfig] = fbconfigs;
5529                                                 process->fbconfigs_max[process->nfbconfig] = *(int*)args[2];
5530                                                 process->nfbconfig++;
5531                                                 ret_int = 1 + process->nfbconfig_total;
5532                                                 process->nfbconfig_total += process->fbconfigs_max[process->nfbconfig];
5533                                         }
5534                                         else
5535                                         {
5536                                                 ret_int = 0;
5537                                         }
5538                                 }
5539                                 break;
5540                         }
5541
5542                 case glXDestroyWindow_func:
5543                         {
5544                                 GLXDrawable client_drawable = args[1];
5545                                 if (display_function_call) fprintf(stderr, "client_drawable=%p\n", (void*)client_drawable);
5546
5547                                 GLXDrawable drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
5548
5549                                 destroy_window(pConn, (Window)drawable);
5550
5551                                 int i;
5552                                 for(i=0;process->association_clientdrawable_serverdrawable[i].key != NULL;i++)
5553                                 {
5554                                         if (process->association_clientdrawable_serverdrawable[i].key == (void *) client_drawable)
5555                                         {
5556                                                 process->association_clientdrawable_serverdrawable[i].key = NULL;
5557                                                 process->association_clientdrawable_serverdrawable[i].value = NULL;
5558                                         }
5559                                 }
5560
5561                                 for(i=0;i<process->nbGLStates;i++)
5562                                 {
5563                                         if (process->glstates[i]->drawable == drawable)
5564                                         {
5565                                                 process->glstates[i]->drawable = 0;
5566                                         }
5567                                 }
5568
5569                                 if( process->current_state->drawable == drawable )
5570                                         process->current_state = &process->default_state;
5571
5572                                 break;
5573                         }
5574
5575
5576                 case glXCreatePbuffer_func:
5577                         {
5578                                 GET_EXT_PTR(GLXPbuffer, glXCreatePbuffer, (Display*, GLXFBConfig, int*));
5579                                 int client_fbconfig = args[1];
5580                                 ret_int = 0;
5581                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5582                                 if (fbconfig)
5583                                 {
5584                                         GLXPbuffer pbuffer = ptr_func_glXCreatePbuffer(pConn->Display, fbconfig, (int*)args[2]);
5585                                         fprintf(stderr, "glXCreatePbuffer --> %X\n", (int)pbuffer);
5586                                         if (pbuffer)
5587                                         {
5588                                                 process->next_available_pbuffer_number ++;
5589                                                 int fake_pbuffer = process->next_available_pbuffer_number;
5590                                                 set_association_fakepbuffer_pbuffer(process, (void*)(long)fake_pbuffer, (void*)pbuffer);
5591                                                 fprintf(stderr, "set_association_fakepbuffer_pbuffer(%d, %X)\n", fake_pbuffer, (int)pbuffer);
5592                                                 ret_int = fake_pbuffer;
5593                                         }
5594                                 }
5595                                 break;
5596                         }
5597
5598                 case glXCreateGLXPbufferSGIX_func:
5599                         {
5600                                 GET_EXT_PTR(GLXPbufferSGIX, glXCreateGLXPbufferSGIX, (Display*, GLXFBConfig, int, int, int*));
5601                                 int client_fbconfig = args[1];
5602                                 ret_int = 0;
5603                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5604                                 if (fbconfig)
5605                                 {
5606                                         GLXPbufferSGIX pbuffer = ptr_func_glXCreateGLXPbufferSGIX(pConn->Display, fbconfig, args[2], args[3], (int*)args[4]);
5607                                         if (pbuffer)
5608                                         {
5609                                                 process->next_available_pbuffer_number ++;
5610                                                 int fake_pbuffer = process->next_available_pbuffer_number;
5611                                                 set_association_fakepbuffer_pbuffer(process, (void*)(long)fake_pbuffer, (void*)pbuffer);
5612                                                 ret_int = fake_pbuffer;
5613                                         }
5614                                 }
5615                                 break;
5616                         }
5617
5618                 case glXDestroyPbuffer_func:
5619                         {
5620                                 GET_EXT_PTR(void, glXDestroyPbuffer, (Display*, GLXPbuffer));
5621                                 GLXPbuffer fake_pbuffer = (GLXPbuffer)args[1];
5622                                 if (display_function_call) fprintf(stderr, "fake_pbuffer=%d\n", (int)fake_pbuffer);
5623
5624                                 GLXPbuffer pbuffer = (GLXPbuffer)get_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
5625                                 if (pbuffer == 0)
5626                                 {
5627                                         fprintf(stderr, "invalid fake_pbuffer (%d) !\n", (int)fake_pbuffer);
5628                                 }
5629                                 else
5630                                 {
5631                                         if (!is_gl_vendor_ati(pConn->Display))
5632                                                 ptr_func_glXDestroyPbuffer(pConn->Display, pbuffer);
5633                                         unset_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
5634                                 }
5635                                 break;
5636                         }
5637
5638                 case glXDestroyGLXPbufferSGIX_func:
5639                         {
5640                                 GET_EXT_PTR(void, glXDestroyGLXPbufferSGIX, (Display*, GLXPbuffer));
5641                                 GLXPbuffer fake_pbuffer = (GLXPbuffer)args[1];
5642                                 if (display_function_call) fprintf(stderr, "fake_pbuffer=%d\n", (int)fake_pbuffer);
5643
5644                                 GLXPbuffer pbuffer = (GLXPbuffer)get_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
5645                                 if (pbuffer == 0)
5646                                 {
5647                                         fprintf(stderr, "invalid fake_pbuffer (%d) !\n", (int)fake_pbuffer);
5648                                 }
5649                                 else
5650                                 {
5651                                         if (!is_gl_vendor_ati(pConn->Display))
5652                                                 ptr_func_glXDestroyGLXPbufferSGIX(pConn->Display, pbuffer);
5653                                         unset_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
5654                                 }
5655                                 break;
5656                         }
5657
5658                 case glXBindTexImageATI_func:
5659                         {
5660                                 GET_EXT_PTR(void, glXBindTexImageATI, (Display*, GLXPbuffer, int));
5661                                 GLXPbuffer fake_pbuffer = (GLXPbuffer)args[1];
5662                                 if (display_function_call) fprintf(stderr, "fake_pbuffer=%d\n", (int)fake_pbuffer);
5663
5664                                 GLXPbuffer pbuffer = (GLXPbuffer)get_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
5665                                 if (pbuffer == 0)
5666                                 {
5667                                         fprintf(stderr, "glXBindTexImageATI : invalid fake_pbuffer (%d) !\n", (int)fake_pbuffer);
5668                                 }
5669                                 else
5670                                 {
5671                                         ptr_func_glXBindTexImageATI(pConn->Display, pbuffer, args[2]);
5672                                 }
5673                                 break;
5674                         }
5675
5676                 case glXReleaseTexImageATI_func:
5677                         {
5678                                 GET_EXT_PTR(void, glXReleaseTexImageATI, (Display*, GLXPbuffer, int));
5679                                 GLXPbuffer fake_pbuffer = (GLXPbuffer)args[1];
5680                                 if (display_function_call) fprintf(stderr, "fake_pbuffer=%d\n", (int)fake_pbuffer);
5681
5682                                 GLXPbuffer pbuffer = (GLXPbuffer)get_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
5683                                 if (pbuffer == 0)
5684                                 {
5685                                         fprintf(stderr, "glXReleaseTexImageATI : invalid fake_pbuffer (%d) !\n", (int)fake_pbuffer);
5686                                 }
5687                                 else
5688                                 {
5689                                         ptr_func_glXReleaseTexImageATI(pConn->Display, pbuffer, args[2]);
5690                                 }
5691                                 break;
5692                         }
5693
5694                 case glXBindTexImageARB_func:
5695                         {
5696                                 GET_EXT_PTR(Bool, glXBindTexImageARB, (Display*, GLXPbuffer, int));
5697                                 GLXPbuffer fake_pbuffer = (GLXPbuffer)args[1];
5698                                 if (display_function_call) fprintf(stderr, "fake_pbuffer=%d\n", (int)fake_pbuffer);
5699
5700                                 GLXPbuffer pbuffer = (GLXPbuffer)get_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
5701                                 if (pbuffer == 0)
5702                                 {
5703                                         fprintf(stderr, "glXBindTexImageARB : invalid fake_pbuffer (%d) !\n", (int)fake_pbuffer);
5704                                         ret_int = 0;
5705                                 }
5706                                 else
5707                                 {
5708                                         ret_int = ptr_func_glXBindTexImageARB(pConn->Display, pbuffer, args[2]);
5709                                 }
5710                                 break;
5711                         }
5712
5713                 case glXReleaseTexImageARB_func:
5714                         {
5715                                 GET_EXT_PTR(Bool, glXReleaseTexImageARB, (Display*, GLXPbuffer, int));
5716                                 GLXPbuffer fake_pbuffer = (GLXPbuffer)args[1];
5717                                 if (display_function_call) fprintf(stderr, "fake_pbuffer=%d\n", (int)fake_pbuffer);
5718
5719                                 GLXPbuffer pbuffer = (GLXPbuffer)get_association_fakepbuffer_pbuffer(process, (void*)fake_pbuffer);
5720                                 if (pbuffer == 0)
5721                                 {
5722                                         fprintf(stderr, "glXReleaseTexImageARB : invalid fake_pbuffer (%d) !\n", (int)fake_pbuffer);
5723                                         ret_int = 0;
5724                                 }
5725                                 else
5726                                 {
5727                                         ret_int = ptr_func_glXReleaseTexImageARB(pConn->Display, pbuffer, args[2]);
5728                                 }
5729                                 break;
5730                         }
5731
5732                 case glXGetFBConfigAttrib_func:
5733                         {
5734                                 GET_EXT_PTR(int, glXGetFBConfigAttrib, (Display*, GLXFBConfig, int, int*));
5735                                 int client_fbconfig = args[1];
5736                                 ret_int = 0;
5737                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5738                                 if (fbconfig)
5739                                         ret_int = ptr_func_glXGetFBConfigAttrib(pConn->Display, fbconfig, args[2], (int*)args[3]);
5740                                 break;
5741                         }
5742
5743                 case glXGetFBConfigAttrib_extended_func:
5744                         {
5745                                 GET_EXT_PTR(int, glXGetFBConfigAttrib, (Display*, GLXFBConfig, int, int*));
5746                                 int client_fbconfig = args[1];
5747                                 int n = args[2];
5748                                 int i;
5749                                 int* attribs = (int*)args[3];
5750                                 int* values = (int*)args[4];
5751                                 int* res = (int*)args[5];
5752                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5753
5754                                 for(i=0;i<n;i++)
5755                                 {
5756                                         if (fbconfig)
5757                                         {
5758                                                 res[i] = ptr_func_glXGetFBConfigAttrib(pConn->Display, fbconfig, attribs[i], &values[i]);
5759                                         }
5760                                         else
5761                                         {
5762                                                 res[i] = 0;
5763                                         }
5764                                 }
5765                                 break;
5766                         }
5767
5768                 case glXGetFBConfigAttribSGIX_func:
5769                         {
5770                                 GET_EXT_PTR(int, glXGetFBConfigAttribSGIX, (Display*, GLXFBConfigSGIX, int, int*));
5771                                 int client_fbconfig = args[1];
5772                                 ret_int = 0;
5773                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5774                                 if (fbconfig)
5775                                         ret_int = ptr_func_glXGetFBConfigAttribSGIX(pConn->Display, (GLXFBConfigSGIX)fbconfig, args[2], (int*)args[3]);
5776                                 break;
5777                         }
5778
5779                 case glXQueryContext_func:
5780                         {
5781                                 GET_EXT_PTR(int, glXQueryContext, (Display*, GLXContext, int, int*));
5782                                 GLXContext fake_ctxt = (GLXContext)args[1];
5783                                 if (display_function_call) fprintf(stderr, "fake_ctx=%p\n", fake_ctxt);
5784                                 GLXContext ctxt = get_association_fakecontext_glxcontext(process, fake_ctxt);
5785                                 if (ctxt == NULL)
5786                                 {
5787                                         fprintf(stderr, "invalid fake_ctxt (%p) !\n", fake_ctxt);
5788                                         ret_int = 0;
5789                                 }
5790                                 else
5791                                 {
5792                                         ret_int = ptr_func_glXQueryContext(pConn->Display, ctxt, args[2], (int*)args[3]);
5793                                 }
5794                                 break;
5795                         }
5796
5797                 case glXQueryDrawable_func:
5798                         {
5799                                 GET_EXT_PTR(void, glXQueryDrawable, (Display*, GLXDrawable, int, int*));
5800                                 GLXDrawable client_drawable = (GLXDrawable)args[1];
5801                                 GLXDrawable drawable = get_association_clientdrawable_serverdrawable(process, client_drawable);
5802                                 if (display_function_call) fprintf(stderr, "client_drawable=%d\n", (int)client_drawable);
5803                                 if (drawable == 0)
5804                                 {
5805                                         fprintf(stderr, "invalid client_drawable (%d) !\n", (int)client_drawable);
5806                                 }
5807                                 else
5808                                 {
5809                                         ptr_func_glXQueryDrawable(pConn->Display, drawable, args[2], (int*)args[3]);
5810                                 }
5811                                 break;
5812                         }
5813
5814                 case glXQueryGLXPbufferSGIX_func:
5815                         {
5816                                 GET_EXT_PTR(int, glXQueryGLXPbufferSGIX, (Display*, GLXFBConfigSGIX, int, int*));
5817                                 int client_fbconfig = args[1];
5818                                 ret_int = 0;
5819                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5820                                 if (fbconfig)
5821                                         ret_int = ptr_func_glXQueryGLXPbufferSGIX(pConn->Display, (GLXFBConfigSGIX)fbconfig, args[2], (int*)args[3]);
5822                                 break;
5823                         }
5824
5825                 case glXCreateContextWithConfigSGIX_func:
5826                         {
5827                                 GET_EXT_PTR(GLXContext, glXCreateContextWithConfigSGIX, (Display*, GLXFBConfigSGIX, int, GLXContext, int));
5828                                 int client_fbconfig = args[1];
5829                                 ret_int = 0;
5830                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5831                                 if (fbconfig)
5832                                 {
5833                                         GLXContext shareList = get_association_fakecontext_glxcontext(process, (void*)args[3]);
5834                                         process->next_available_context_number ++;
5835                                         int fake_ctxt = process->next_available_context_number;
5836                                         GLXContext ctxt = ptr_func_glXCreateContextWithConfigSGIX(pConn->Display, (GLXFBConfigSGIX)fbconfig, args[2], shareList, args[4]);
5837                                         set_association_fakecontext_glxcontext(process, (void*)(long)fake_ctxt, ctxt);
5838                                         ret_int = fake_ctxt;
5839                                 }
5840                                 break;
5841                         }
5842
5843                 case glXGetVisualFromFBConfig_func:
5844                         {
5845                                 GET_EXT_PTR(XVisualInfo*, glXGetVisualFromFBConfig, (Display*, GLXFBConfig));
5846                                 int client_fbconfig = args[1];
5847                                 ret_int = 0;
5848                                 GLXFBConfig fbconfig = get_fbconfig(process, client_fbconfig);
5849                                 if (fbconfig)
5850                                 {
5851                                         AssocAttribListVisual *tabAssocAttribListVisual = (AssocAttribListVisual *)pConn->tabAssocAttribListVisual ;
5852                                         XVisualInfo* vis = ptr_func_glXGetVisualFromFBConfig(pConn->Display, fbconfig);
5853                                         ret_int = (vis) ? vis->visualid : 0;
5854                                         if (vis)
5855                                         {
5856                                                 pConn->tabAssocAttribListVisual = tabAssocAttribListVisual =
5857                                                         realloc(tabAssocAttribListVisual, sizeof(AssocAttribListVisual) * (pConn->nTabAssocAttribListVisual+1));
5858                                                 tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribListLength = 0;
5859                                                 tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].attribList = NULL;
5860                                                 tabAssocAttribListVisual[pConn->nTabAssocAttribListVisual].visInfo = vis;
5861                                                 pConn->nTabAssocAttribListVisual++;
5862                                                 pConn->tabAssocAttribListVisual = tabAssocAttribListVisual;
5863                                         }
5864                                         if (display_function_call) fprintf(stderr, "visualid = %d\n", ret_int);
5865                                 }
5866                                 break;
5867                         }
5868
5869                 case glXSwapIntervalSGI_func:
5870                         {
5871                                 GET_EXT_PTR(int, glXSwapIntervalSGI, (int));
5872                                 ret_int = ptr_func_glXSwapIntervalSGI(args[0]);
5873                                 break;
5874                         }
5875
5876                 case glXGetProcAddress_fake_func:
5877                         {
5878                                 if (display_function_call) fprintf(stderr, "%s\n", (char*)args[0]);
5879                                 ret_int = glXGetProcAddressARB((const GLubyte*)args[0]) != NULL;
5880                                 break;
5881                         }
5882
5883                 case glXGetProcAddress_global_fake_func:
5884                         {
5885                                 int nbElts = args[0];
5886                                 char* huge_buffer = (char*)args[1];
5887                                 char* result = (char*)args[2];
5888                                 int i;
5889
5890                                 for(i=0;i<nbElts;i++)
5891                                 {
5892                                         int len = strlen(huge_buffer);
5893                                         result[i] = glXGetProcAddressARB((const GLubyte*)huge_buffer) != NULL;
5894                                         huge_buffer += len + 1;
5895                                 }
5896                                 break;
5897                         }
5898
5899                         /* Begin of texture stuff */
5900                 case glBindTexture_func:
5901                 case glBindTextureEXT_func:
5902                         {
5903                                 int target = args[0];
5904                                 unsigned int client_texture = args[1];
5905                                 unsigned int server_texture;
5906
5907                                 if (client_texture == 0)
5908                                 {
5909                                         glBindTexture(target, 0);
5910                                 }
5911                                 else
5912                                 {
5913                                         alloc_value(process->current_state->textureAllocator, client_texture);
5914                                         server_texture = process->current_state->tabTextures[client_texture];
5915                                         if (server_texture == 0)
5916                                         {
5917                                                 glGenTextures(1, &server_texture);
5918                                                 process->current_state->tabTextures[client_texture] = server_texture;
5919                                         }
5920                                         glBindTexture(target, server_texture);
5921                                 }
5922                                 break;
5923                         }
5924
5925                 case glGenTextures_fake_func:
5926                         {
5927                                 GET_EXT_PTR(void, glGenTextures, (GLsizei n, GLuint *textures));
5928                                 int i;
5929                                 int n = args[0];
5930                                 unsigned int* clientTabTextures = malloc(n * sizeof(int));
5931                                 unsigned int* serverTabTextures = malloc(n * sizeof(int));
5932
5933                                 alloc_range(process->current_state->textureAllocator, n, clientTabTextures);
5934
5935                                 ptr_func_glGenTextures(n, serverTabTextures);
5936                                 for(i=0;i<n;i++)
5937                                 {
5938                                         process->current_state->tabTextures[clientTabTextures[i]] = serverTabTextures[i];
5939                                 }
5940
5941                                 free(clientTabTextures);
5942                                 free(serverTabTextures);
5943                                 break;
5944                         }
5945
5946
5947                 case glDeleteTextures_func:
5948                         {
5949                                 GET_EXT_PTR(void, glDeleteTextures, (GLsizei n, const GLuint *textures));
5950                                 int i;
5951                                 int n = args[0];
5952                                 unsigned int* clientTabTextures = (unsigned int*)args[1];
5953
5954                                 delete_range(process->current_state->textureAllocator, n, clientTabTextures);
5955
5956                                 unsigned int* serverTabTextures = malloc(n * sizeof(int));
5957                                 for(i=0;i<n;i++)
5958                                 {
5959                                         serverTabTextures[i] = get_server_texture(process, clientTabTextures[i]);
5960                                 }
5961                                 ptr_func_glDeleteTextures(n, serverTabTextures);
5962                                 for(i=0;i<n;i++)
5963                                 {
5964                                         process->current_state->tabTextures[clientTabTextures[i]] = 0;
5965                                 }
5966                                 free(serverTabTextures);
5967                                 break;
5968                         }
5969
5970                 case glPrioritizeTextures_func:
5971                         {
5972                                 GET_EXT_PTR(void, glPrioritizeTextures, (GLsizei n, const GLuint *textures, const GLclampf *priorities));
5973
5974                                 int i;
5975                                 int n = args[0];
5976                                 unsigned int* textures = (unsigned int*)args[1];
5977                                 for(i=0;i<n;i++)
5978                                 {
5979                                         textures[i] = get_server_texture(process, textures[i]);
5980                                 }
5981                                 ptr_func_glPrioritizeTextures(n, textures, (const GLclampf*)args[2]);
5982                                 break;
5983                         }
5984
5985                 case glAreTexturesResident_func:
5986                         {
5987                                 GET_EXT_PTR(void, glAreTexturesResident, (GLsizei n, const GLuint *textures, GLboolean *residences));
5988                                 int i;
5989                                 int n = args[0];
5990                                 unsigned int* textures = (unsigned int*)args[1];
5991                                 for(i=0;i<n;i++)
5992                                 {
5993                                         textures[i] = get_server_texture(process, textures[i]);
5994                                 }
5995                                 ptr_func_glAreTexturesResident(n, textures, (GLboolean*)args[2]);
5996                                 break;
5997                         }
5998
5999                 case glIsTexture_func:
6000                 case glIsTextureEXT_func:
6001                         {
6002                                 GET_EXT_PTR(GLboolean, glIsTexture, (GLuint texture ));
6003                                 unsigned int client_texture = args[0];
6004                                 unsigned int server_texture = get_server_texture(process, client_texture);
6005                                 if (server_texture)
6006                                         ret_char = ptr_func_glIsTexture(server_texture);
6007                                 else
6008                                         ret_char = 0;
6009                                 break;
6010                         }
6011
6012                 case glFramebufferTexture1DEXT_func:
6013                         {
6014                                 GET_EXT_PTR(void, glFramebufferTexture1DEXT, (int, int, int, int, int));
6015                                 unsigned int client_texture = args[3];
6016                                 unsigned int server_texture = get_server_texture(process, client_texture);
6017                                 if (server_texture)
6018                                         ptr_func_glFramebufferTexture1DEXT(args[0], args[1], args[2], server_texture, args[4]);
6019                                 break;
6020                         }
6021
6022                 case glFramebufferTexture2DEXT_func:
6023                         {
6024                                 GET_EXT_PTR(void, glFramebufferTexture2DEXT, (int, int, int, int, int));
6025                                 unsigned int client_texture = args[3];
6026                                 unsigned int server_texture = get_server_texture(process, client_texture);
6027                                 if (server_texture)
6028                                         ptr_func_glFramebufferTexture2DEXT(args[0], args[1], args[2], server_texture, args[4]);
6029                                 break;
6030                         }
6031
6032                 case glFramebufferTexture3DEXT_func:
6033                         {
6034                                 GET_EXT_PTR(void, glFramebufferTexture3DEXT, (int, int, int, int, int, int));
6035                                 unsigned int client_texture = args[3];
6036                                 unsigned int server_texture = get_server_texture(process, client_texture);
6037                                 if (server_texture)
6038                                         ptr_func_glFramebufferTexture3DEXT(args[0], args[1], args[2], server_texture, args[4], args[5]);
6039                                 break;
6040                         }
6041                         /* End of texture stuff */
6042
6043                         /* Begin of list stuff */
6044                 case glIsList_func:
6045                         {
6046                                 unsigned int client_list = args[0];
6047                                 unsigned int server_list = get_server_list(process, client_list);
6048                                 if (server_list)
6049                                         ret_char = glIsList(server_list);
6050                                 else
6051                                         ret_char = 0;
6052                                 break;
6053                         }
6054
6055                 case glDeleteLists_func:
6056                         {
6057                                 int i;
6058                                 unsigned int first_client = args[0];
6059                                 int n = args[1];
6060
6061                                 unsigned int first_server = get_server_list(process, first_client);
6062                                 for(i=0;i<n;i++)
6063                                 {
6064                                         if (get_server_list(process, first_client + i) != first_server + i)
6065                                                 break;
6066                                 }
6067                                 if (i == n)
6068                                 {
6069                                         glDeleteLists(first_server, n);
6070                                 }
6071                                 else
6072                                 {
6073                                         for(i=0;i<n;i++)
6074                                         {
6075                                                 glDeleteLists(get_server_list(process, first_client + i), 1);
6076                                         }
6077                                 }
6078
6079                                 for(i=0;i<n;i++)
6080                                 {
6081                                         process->current_state->tabLists[first_client + i] = 0;
6082                                 }
6083                                 delete_consecutive_values(process->current_state->listAllocator, first_client, n);
6084                                 break;
6085                         }
6086
6087                 case glGenLists_fake_func:
6088                         {
6089                                 int i;
6090                                 int n = args[0];
6091                                 unsigned int server_first = glGenLists(n);
6092                                 if (server_first)
6093                                 {
6094                                         unsigned int client_first = alloc_range(process->current_state->listAllocator, n, NULL);
6095                                         for(i=0;i<n;i++)
6096                                         {
6097                                                 process->current_state->tabLists[client_first + i] = server_first + i;
6098                                         }
6099                                 }
6100                                 break;
6101                         }
6102
6103                 case glNewList_func:
6104                         {
6105                                 unsigned int client_list = args[0];
6106                                 int mode = args[1];
6107                                 alloc_value(process->current_state->listAllocator, client_list);
6108                                 unsigned int server_list = get_server_list(process, client_list);
6109                                 if (server_list == 0)
6110                                 {
6111                                         server_list = glGenLists(1);
6112                                         process->current_state->tabLists[client_list] = server_list;
6113                                 }
6114                                 glNewList(server_list, mode);
6115                                 break;
6116                         }
6117
6118                 case glCallList_func:
6119                         {
6120                                 unsigned int client_list = args[0];
6121                                 unsigned int server_list = get_server_list(process, client_list);
6122                                 glCallList(server_list);
6123                                 break;
6124                         }
6125
6126                 case glCallLists_func:
6127                         {
6128                                 int i;
6129                                 int n = args[0];
6130                                 int type = args[1];
6131                                 const GLvoid* lists = (const GLvoid*)args[2];
6132                                 int* new_lists = malloc(sizeof(int) * n);
6133                                 for(i=0;i<n;i++)
6134                                 {
6135                                         new_lists[i] = get_server_list(process, translate_id(i, type, lists));
6136                                 }
6137                                 glCallLists(n, GL_UNSIGNED_INT, new_lists);
6138                                 free(new_lists);
6139                                 break;
6140                         }
6141
6142
6143                         /* End of list stuff */
6144
6145                         /* Begin of buffer stuff */
6146                 case glBindBufferARB_func:
6147                         {
6148                                 GET_EXT_PTR(void, glBindBufferARB, (int,int));
6149                                 int target = args[0];
6150                                 unsigned int client_buffer = args[1];
6151                                 unsigned int server_buffer;
6152
6153                                 if (client_buffer == 0)
6154                                 {
6155                                         ptr_func_glBindBufferARB(target, 0);
6156                                 }
6157                                 else
6158                                 {
6159                                         server_buffer = get_server_buffer(process, client_buffer);
6160                                         ptr_func_glBindBufferARB(target, server_buffer);
6161                                 }
6162                                 break;
6163                         }
6164
6165                 case glGenBuffersARB_fake_func:
6166                         {
6167                                 GET_EXT_PTR(void, glGenBuffersARB, (int,unsigned int*));
6168                                 int i;
6169                                 int n = args[0];
6170                                 unsigned int* clientTabBuffers = malloc(n * sizeof(int));
6171                                 unsigned int* serverTabBuffers = malloc(n * sizeof(int));
6172
6173                                 alloc_range(process->current_state->bufferAllocator, n, clientTabBuffers);
6174
6175                                 ptr_func_glGenBuffersARB(n, serverTabBuffers);
6176                                 for(i=0;i<n;i++)
6177                                 {
6178                                         process->current_state->tabBuffers[clientTabBuffers[i]] = serverTabBuffers[i];
6179                                 }
6180
6181                                 free(clientTabBuffers);
6182                                 free(serverTabBuffers);
6183                                 break;
6184                         }
6185
6186
6187                 case glDeleteBuffersARB_func:
6188                         {
6189                                 GET_EXT_PTR(void, glDeleteBuffersARB, (int,int*));
6190                                 int i;
6191                                 int n = args[0];
6192                                 unsigned int* clientTabBuffers = (unsigned int*)args[1];
6193
6194                                 delete_range(process->current_state->bufferAllocator, n, clientTabBuffers);
6195
6196                                 int* serverTabBuffers = malloc(n * sizeof(int));
6197                                 for(i=0;i<n;i++)
6198                                 {
6199                                         serverTabBuffers[i] = get_server_buffer(process, clientTabBuffers[i]);
6200                                 }
6201                                 ptr_func_glDeleteBuffersARB(n, serverTabBuffers);
6202                                 for(i=0;i<n;i++)
6203                                 {
6204                                         process->current_state->tabBuffers[clientTabBuffers[i]] = 0;
6205                                 }
6206                                 free(serverTabBuffers);
6207                                 break;
6208                         }
6209
6210                 case glIsBufferARB_func:
6211                         {
6212                                 GET_EXT_PTR(int, glIsBufferARB, (int));
6213                                 unsigned int client_buffer = args[0];
6214                                 unsigned int server_buffer = get_server_buffer(process, client_buffer);
6215                                 if (server_buffer)
6216                                         ret_int = ptr_func_glIsBufferARB(server_buffer);
6217                                 else
6218                                         ret_int = 0;
6219                                 break;
6220                         }
6221
6222                         /* Endo of buffer stuff */
6223
6224                 case glShaderSourceARB_fake_func:
6225                         {
6226                                 GET_EXT_PTR(void, glShaderSourceARB, (int,int,char**,void*));
6227                                 int size = args[1];
6228                                 int i;
6229                                 int acc_length = 0;
6230                                 GLcharARB** tab_prog = malloc(size * sizeof(GLcharARB*));
6231                                 int* tab_length = (int*)args[3];
6232                                 for(i=0;i<size;i++)
6233                                 {
6234                                         tab_prog[i] = ((GLcharARB*)args[2]) + acc_length;
6235                                         acc_length += tab_length[i];
6236                                 }
6237                                 ptr_func_glShaderSourceARB(args[0], args[1], tab_prog, tab_length);
6238                                 free(tab_prog);
6239                                 break;
6240                         }
6241
6242                 case glShaderSource_fake_func:
6243                         {
6244                                 GET_EXT_PTR(void, glShaderSource, (int,int,char**,void*));
6245                                 int size = args[1];
6246                                 int i;
6247                                 int acc_length = 0;
6248                                 GLcharARB** tab_prog = malloc(size * sizeof(GLcharARB*));
6249                                 int* tab_length = (int*)args[3];
6250
6251                                 char **tab_prog_new;
6252                                 GLint *tab_length_new;
6253
6254                            tab_prog_new = malloc(args[1]* sizeof(char*));
6255                            tab_length_new = malloc(args[1]* sizeof(GLint));
6256
6257                            memset(tab_prog_new, 0, args[1] * sizeof(char*));
6258                            memset(tab_length_new, 0, args[1] * sizeof(GLint));
6259
6260
6261                                 for(i=0;i<size;i++)
6262                                 {
6263                                         tab_prog[i] = ((GLcharARB*)args[2]) + acc_length;
6264                                         acc_length += tab_length[i];
6265                                 }
6266
6267                                 shadersrc_gles_to_gl(args[1], tab_prog, tab_prog_new, tab_length, tab_length_new);
6268
6269                                 if (!tab_prog_new || !tab_length_new)
6270                                         break;
6271
6272                                 ptr_func_glShaderSource(args[0], args[1], tab_prog_new, tab_length_new);
6273
6274                                 for (i = 0; i < args[1]; i++)
6275                                         free(tab_prog_new[i]);
6276                                 free(tab_prog_new);
6277                                 free(tab_length_new);
6278
6279                                 free(tab_prog);
6280                                 break;
6281                         }
6282
6283                 case glVertexPointer_fake_func:
6284                         {
6285                                 int offset = args[0];
6286                                 int size = args[1];
6287                                 int type = args[2];
6288                                 int stride = args[3];
6289                                 int bytes_size = args[4];
6290                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6291                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6292                                 memcpy(process->current_state->vertexPointer + offset, (void*)args[5], bytes_size);
6293                                 /*fprintf(stderr, "glVertexPointer_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
6294                                   size, type, stride, bytes_size);*/
6295                                 glVertexPointer(size, type, stride, process->current_state->vertexPointer);
6296                                 break;
6297                         }
6298
6299                 case glNormalPointer_fake_func:
6300                         {
6301                                 int offset = args[0];
6302                                 int type = args[1];
6303                                 int stride = args[2];
6304                                 int bytes_size = args[3];
6305                                 process->current_state->normalPointerSize = MAX(process->current_state->normalPointerSize, offset + bytes_size);
6306                                 process->current_state->normalPointer = realloc(process->current_state->normalPointer, process->current_state->normalPointerSize);
6307                                 memcpy(process->current_state->normalPointer + offset, (void*)args[4], bytes_size);
6308                                 //fprintf(stderr, "glNormalPointer_fake_func type=%d, stride=%d, byte_size=%d\n", type, stride, bytes_size);
6309                                 glNormalPointer(type, stride, process->current_state->normalPointer);
6310                                 break;
6311                         }
6312
6313                 case glIndexPointer_fake_func:
6314                         {
6315                                 int offset = args[0];
6316                                 int type = args[1];
6317                                 int stride = args[2];
6318                                 int bytes_size = args[3];
6319                                 process->current_state->indexPointerSize = MAX(process->current_state->indexPointerSize, offset + bytes_size);
6320                                 process->current_state->indexPointer = realloc(process->current_state->indexPointer, process->current_state->indexPointerSize);
6321                                 memcpy(process->current_state->indexPointer + offset, (void*)args[4], bytes_size);
6322                                 //fprintf(stderr, "glIndexPointer_fake_func type=%d, stride=%d, byte_size=%d\n", type, stride, bytes_size);
6323                                 glIndexPointer(type, stride, process->current_state->indexPointer);
6324                                 break;
6325                         }
6326
6327                 case glEdgeFlagPointer_fake_func:
6328                         {
6329                                 int offset = args[0];
6330                                 int stride = args[1];
6331                                 int bytes_size = args[2];
6332                                 process->current_state->edgeFlagPointerSize = MAX(process->current_state->edgeFlagPointerSize, offset + bytes_size);
6333                                 process->current_state->edgeFlagPointer = realloc(process->current_state->edgeFlagPointer, process->current_state->edgeFlagPointerSize);
6334                                 memcpy(process->current_state->edgeFlagPointer + offset, (void*)args[3], bytes_size );
6335                                 //fprintf(stderr, "glEdgeFlagPointer_fake_func stride = %d, bytes_size=%d\n", stride, bytes_size);
6336                                 glEdgeFlagPointer(stride, process->current_state->edgeFlagPointer);
6337                                 break;
6338                         }
6339
6340                 case glVertexAttribPointerARB_fake_func:
6341                         {
6342                                 GET_EXT_PTR(void, glVertexAttribPointerARB, (int,int,int,int,int,void*));
6343                                 int offset = args[0];
6344                                 int index = args[1];
6345                                 int size = args[2];
6346                                 int type = args[3];
6347                                 int normalized = args[4];
6348                                 int stride = args[5];
6349                                 int bytes_size = args[6];
6350                                 process->current_state->vertexAttribPointerSize[index] = MAX(process->current_state->vertexAttribPointerSize[index], offset + bytes_size);
6351                                 process->current_state->vertexAttribPointer[index] = realloc(process->current_state->vertexAttribPointer[index],
6352                                                 process->current_state->vertexAttribPointerSize[index]);
6353                                 memcpy(process->current_state->vertexAttribPointer[index] + offset, (void*)args[7], bytes_size);
6354                                 ptr_func_glVertexAttribPointerARB(index, size, type, normalized, stride,
6355                                                 process->current_state->vertexAttribPointer[index]);
6356                                 break;
6357                         }
6358
6359                 case glVertexAttribPointerNV_fake_func:
6360                         {
6361                                 GET_EXT_PTR(void, glVertexAttribPointerNV, (int,int,int,int,void*));
6362                                 int offset = args[0];
6363                                 int index = args[1];
6364                                 int size = args[2];
6365                                 int type = args[3];
6366                                 int stride = args[4];
6367                                 int bytes_size = args[5];
6368                                 process->current_state->vertexAttribPointerNVSize[index] = MAX(process->current_state->vertexAttribPointerNVSize[index], offset + bytes_size);
6369                                 process->current_state->vertexAttribPointerNV[index] = realloc(process->current_state->vertexAttribPointerNV[index],
6370                                                 process->current_state->vertexAttribPointerNVSize[index]);
6371                                 memcpy(process->current_state->vertexAttribPointerNV[index] + offset, (void*)args[6], bytes_size);
6372                                 ptr_func_glVertexAttribPointerNV(index, size, type, stride,
6373                                                 process->current_state->vertexAttribPointerNV[index]);
6374                                 break;
6375                         }
6376
6377                 case glColorPointer_fake_func:
6378                         {
6379                                 int offset = args[0];
6380                                 int size = args[1];
6381                                 int type = args[2];
6382                                 int stride = args[3];
6383                                 int bytes_size = args[4];
6384                                 process->current_state->colorPointerSize = MAX(process->current_state->colorPointerSize, offset + bytes_size);
6385                                 process->current_state->colorPointer = realloc(process->current_state->colorPointer, process->current_state->colorPointerSize);
6386                                 memcpy(process->current_state->colorPointer + offset, (void*)args[5], bytes_size);
6387                                 //fprintf(stderr, "glColorPointer_fake_func bytes_size = %d\n", bytes_size);
6388                                 glColorPointer(size, type, stride, process->current_state->colorPointer);
6389
6390                                 break;
6391                         }
6392
6393                 case glSecondaryColorPointer_fake_func:
6394                         {
6395                                 GET_EXT_PTR(void, glSecondaryColorPointer, (int,int,int,void*));
6396                                 int offset = args[0];
6397                                 int size = args[1];
6398                                 int type = args[2];
6399                                 int stride = args[3];
6400                                 int bytes_size = args[4];
6401                                 process->current_state->secondaryColorPointerSize = MAX(process->current_state->secondaryColorPointerSize, offset + bytes_size);
6402                                 process->current_state->secondaryColorPointer = realloc(process->current_state->secondaryColorPointer, process->current_state->secondaryColorPointerSize);
6403                                 memcpy(process->current_state->secondaryColorPointer + offset, (void*)args[5], bytes_size);
6404                                 //fprintf(stderr, "glSecondaryColorPointer_fake_func bytes_size = %d\n", bytes_size);
6405                                 ptr_func_glSecondaryColorPointer(size, type, stride, process->current_state->secondaryColorPointer);
6406
6407                                 break;
6408                         }
6409
6410                 case glPushClientAttrib_func:
6411                         {
6412                                 int mask = args[0];
6413                                 if (process->current_state->clientStateSp < MAX_CLIENT_STATE_STACK_SIZE)
6414                                 {
6415                                         process->current_state->clientStateStack[process->current_state->clientStateSp].mask = mask;
6416                                         if (mask & GL_CLIENT_VERTEX_ARRAY_BIT)
6417                                         {
6418                                                 process->current_state->clientStateStack[process->current_state->clientStateSp].activeTextureIndex =
6419                                                         process->current_state->activeTextureIndex;
6420                                         }
6421                                         process->current_state->clientStateSp++;
6422                                 }
6423                                 glPushClientAttrib(mask);
6424                                 break;
6425                         }
6426
6427                 case glPopClientAttrib_func:
6428                         {
6429                                 if (process->current_state->clientStateSp > 0)
6430                                 {
6431                                         process->current_state->clientStateSp--;
6432                                         if (process->current_state->clientStateStack[process->current_state->clientStateSp].mask & GL_CLIENT_VERTEX_ARRAY_BIT)
6433                                         {
6434                                                 process->current_state->activeTextureIndex =
6435                                                         process->current_state->clientStateStack[process->current_state->clientStateSp].activeTextureIndex;
6436                                         }
6437                                 }
6438                                 glPopClientAttrib();
6439                                 break;
6440                         }
6441
6442                 case glClientActiveTexture_func:
6443                 case glClientActiveTextureARB_func:
6444                         {
6445                                 int activeTexture = args[0];
6446                                 process->current_state->activeTextureIndex = activeTexture - GL_TEXTURE0_ARB;
6447                                 do_glClientActiveTextureARB(activeTexture);
6448                                 break;
6449                         }
6450
6451                 case glTexCoordPointer_fake_func:
6452                         {
6453                                 int offset = args[0];
6454                                 int index = args[1];
6455                                 int size = args[2];
6456                                 int type = args[3];
6457                                 int stride = args[4];
6458                                 int bytes_size = args[5];
6459                                 process->current_state->texCoordPointerSize[index] = MAX(process->current_state->texCoordPointerSize[index], offset + bytes_size);
6460                                 process->current_state->texCoordPointer[index] = realloc(process->current_state->texCoordPointer[index], process->current_state->texCoordPointerSize[index]);
6461                                 memcpy(process->current_state->texCoordPointer[index] + offset, (void*)args[6], bytes_size);
6462                                 /*fprintf(stderr, "glTexCoordPointer_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
6463                                   size, type, stride, bytes_size);*/
6464                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + index);
6465                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[index]);
6466                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6467                                 break;
6468                         }
6469
6470                 case glWeightPointerARB_fake_func:
6471                         {
6472                                 GET_EXT_PTR(void, glWeightPointerARB, (int,int,int,void*));
6473                                 int offset = args[0];
6474                                 int size = args[1];
6475                                 int type = args[2];
6476                                 int stride = args[3];
6477                                 int bytes_size = args[4];
6478                                 process->current_state->weightPointerSize = MAX(process->current_state->weightPointerSize, offset + bytes_size);
6479                                 process->current_state->weightPointer = realloc(process->current_state->weightPointer, process->current_state->weightPointerSize);
6480                                 memcpy(process->current_state->weightPointer + offset, (void*)args[5], bytes_size);
6481                                 /*fprintf(stderr, "glWeightPointerARB_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
6482                                   size, type, stride, bytes_size);*/
6483                                 ptr_func_glWeightPointerARB(size, type, stride, process->current_state->weightPointer);
6484                                 break;
6485                         }
6486
6487                 case glMatrixIndexPointerARB_fake_func:
6488                         {
6489                                 GET_EXT_PTR(void, glMatrixIndexPointerARB, (int,int,int,void*));
6490                                 int offset = args[0];
6491                                 int size = args[1];
6492                                 int type = args[2];
6493                                 int stride = args[3];
6494                                 int bytes_size = args[4];
6495                                 process->current_state->matrixIndexPointerSize = MAX(process->current_state->matrixIndexPointerSize, offset + bytes_size);
6496                                 process->current_state->matrixIndexPointer = realloc(process->current_state->matrixIndexPointer, process->current_state->matrixIndexPointerSize);
6497                                 memcpy(process->current_state->matrixIndexPointer + offset, (void*)args[5], bytes_size);
6498                                 /*fprintf(stderr, "glMatrixIndexPointerARB_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
6499                                   size, type, stride, bytes_size);*/
6500                                 ptr_func_glMatrixIndexPointerARB(size, type, stride, process->current_state->matrixIndexPointer);
6501                                 break;
6502                         }
6503
6504                 case glFogCoordPointer_fake_func:
6505                         {
6506                                 GET_EXT_PTR(void, glFogCoordPointer, (int,int,void*));
6507                                 int offset = args[0];
6508                                 int type = args[1];
6509                                 int stride = args[2];
6510                                 int bytes_size = args[3];
6511                                 process->current_state->fogCoordPointerSize = MAX(process->current_state->fogCoordPointerSize, offset + bytes_size);
6512                                 process->current_state->fogCoordPointer = realloc(process->current_state->fogCoordPointer, process->current_state->fogCoordPointerSize);
6513                                 memcpy(process->current_state->fogCoordPointer + offset, (void*)args[4], bytes_size);
6514                                 //fprintf(stderr, "glFogCoordPointer_fake_func type=%d, stride=%d, byte_size=%d\n", type, stride, bytes_size);
6515                                 ptr_func_glFogCoordPointer(type, stride, process->current_state->fogCoordPointer);
6516                                 break;
6517                         }
6518
6519                 case glVariantPointerEXT_fake_func:
6520                         {
6521                                 GET_EXT_PTR(void, glVariantPointerEXT, (int,int,int,void*));
6522                                 int offset = args[0];
6523                                 int id = args[1];
6524                                 int type = args[2];
6525                                 int stride = args[3];
6526                                 int bytes_size = args[4];
6527                                 process->current_state->variantPointerEXTSize[id] = MAX(process->current_state->variantPointerEXTSize[id], offset + bytes_size);
6528                                 process->current_state->variantPointerEXT[id] = realloc(process->current_state->variantPointerEXT[id], process->current_state->variantPointerEXTSize[id]);
6529                                 memcpy(process->current_state->variantPointerEXT[id] + offset, (void*)args[5], bytes_size);
6530                                 //fprintf(stderr, "glVariantPointerEXT_fake_func[%d] type=%d, stride=%d, byte_size=%d\n", id, type, stride, bytes_size);
6531                                 ptr_func_glVariantPointerEXT(id, type, stride, process->current_state->variantPointerEXT[id]);
6532                                 break;
6533                         }
6534
6535                 case glInterleavedArrays_fake_func:
6536                         {
6537                                 GET_EXT_PTR(void, glInterleavedArrays, (int,int,void*));
6538                                 int offset = args[0];
6539                                 int format = args[1];
6540                                 int stride = args[2];
6541                                 int bytes_size = args[3];
6542                                 process->current_state->interleavedArraysSize = MAX(process->current_state->interleavedArraysSize, offset + bytes_size);
6543                                 process->current_state->interleavedArrays = realloc(process->current_state->interleavedArrays, process->current_state->interleavedArraysSize);
6544                                 memcpy(process->current_state->interleavedArrays + offset, (void*)args[4], bytes_size);
6545                                 //fprintf(stderr, "glInterleavedArrays_fake_func format=%d, stride=%d, byte_size=%d\n", format, stride, bytes_size);
6546                                 ptr_func_glInterleavedArrays(format, stride, process->current_state->interleavedArrays);
6547                                 break;
6548                         }
6549
6550                 case glElementPointerATI_fake_func:
6551                         {
6552                                 GET_EXT_PTR(void, glElementPointerATI, (int,void*));
6553                                 int type = args[0];
6554                                 int bytes_size = args[1];
6555                                 process->current_state->elementPointerATISize = bytes_size;
6556                                 process->current_state->elementPointerATI = realloc(process->current_state->elementPointerATI, process->current_state->elementPointerATISize);
6557                                 memcpy(process->current_state->elementPointerATI, (void*)args[2], bytes_size);
6558                                 //fprintf(stderr, "glElementPointerATI_fake_func type=%d, byte_size=%d\n", type, bytes_size);
6559                                 ptr_func_glElementPointerATI(type, process->current_state->elementPointerATI);
6560                                 break;
6561                         }
6562
6563                 case glTexCoordPointer01_fake_func:
6564                         {
6565                                 int size = args[0];
6566                                 int type = args[1];
6567                                 int stride = args[2];
6568                                 int bytes_size = args[3];
6569                                 process->current_state->texCoordPointerSize[0] = bytes_size;
6570                                 process->current_state->texCoordPointer[0] = realloc(process->current_state->texCoordPointer[0], bytes_size);
6571                                 memcpy(process->current_state->texCoordPointer[0], (void*)args[4], bytes_size);
6572                                 /*fprintf(stderr, "glTexCoordPointer01_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
6573                                   size, type, stride, bytes_size);*/
6574                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6575                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
6576                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
6577                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
6578                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6579                                 break;
6580                         }
6581
6582                 case glTexCoordPointer012_fake_func:
6583                         {
6584                                 int size = args[0];
6585                                 int type = args[1];
6586                                 int stride = args[2];
6587                                 int bytes_size = args[3];
6588                                 process->current_state->texCoordPointerSize[0] = bytes_size;
6589                                 process->current_state->texCoordPointer[0] = realloc(process->current_state->texCoordPointer[0], bytes_size);
6590                                 memcpy(process->current_state->texCoordPointer[0], (void*)args[4], bytes_size);
6591                                 /*fprintf(stderr, "glTexCoordPointer012_fake_func size=%d, type=%d, stride=%d, byte_size=%d\n",
6592                                   size, type, stride, bytes_size);*/
6593                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6594                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
6595                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
6596                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
6597                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
6598                                 glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[0]);
6599                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6600                                 break;
6601                         }
6602
6603
6604                 case glVertexAndNormalPointer_fake_func:
6605                         {
6606                                 int vertexPointerSize = args[0];
6607                                 int vertexPointerType = args[1];
6608                                 int vertexPointerStride = args[2];
6609                                 int normalPointerType = args[3];
6610                                 int normalPointerStride = args[4];
6611                                 int bytes_size = args[5];
6612                                 void* ptr = (void*)args[6];
6613                                 process->current_state->vertexPointerSize = bytes_size;
6614                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, bytes_size);
6615                                 memcpy(process->current_state->vertexPointer, ptr, bytes_size);
6616                                 glVertexPointer(vertexPointerSize, vertexPointerType, vertexPointerStride, process->current_state->vertexPointer);
6617                                 glNormalPointer(normalPointerType, normalPointerStride, process->current_state->vertexPointer);
6618                                 break;
6619                         }
6620
6621                 case glVertexNormalPointerInterlaced_fake_func:
6622                         {
6623                                 int i = 0;
6624                                 int offset = args[i++];
6625                                 int vertexPointerSize = args[i++];
6626                                 int vertexPointerType = args[i++];
6627                                 int stride = args[i++];
6628                                 int normalPointerOffset= args[i++];
6629                                 int normalPointerType = args[i++];
6630                                 int bytes_size = args[i++];
6631                                 void* ptr = (void*)args[i++];
6632                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6633                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6634                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6635                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6636                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
6637                                 break;
6638                         }
6639
6640                 case glTuxRacerDrawElements_fake_func:
6641                         {
6642                                 int mode = args[0];
6643                                 int count = args[1];
6644                                 int isColorEnabled = args[2];
6645                                 void* ptr = (void*)args[3];
6646                                 int stride = 6 * sizeof(float) + ((isColorEnabled) ? 4 * sizeof(unsigned char) : 0);
6647                                 glVertexPointer( 3, GL_FLOAT, stride, ptr);
6648                                 glNormalPointer( GL_FLOAT, stride, ptr + 3 * sizeof(float));
6649                                 if (isColorEnabled)
6650                                         glColorPointer( 4, GL_UNSIGNED_BYTE, stride, ptr + 6 * sizeof(float));
6651                                 glDrawArrays(mode, 0, count);
6652                                 break;
6653                         }
6654
6655                 case glVertexNormalColorPointerInterlaced_fake_func:
6656                         {
6657                                 int i = 0;
6658                                 int offset = args[i++];
6659                                 int vertexPointerSize = args[i++];
6660                                 int vertexPointerType = args[i++];
6661                                 int stride = args[i++];
6662                                 int normalPointerOffset= args[i++];
6663                                 int normalPointerType = args[i++];
6664                                 int colorPointerOffset = args[i++];
6665                                 int colorPointerSize = args[i++];
6666                                 int colorPointerType = args[i++];
6667                                 int bytes_size = args[i++];
6668                                 void* ptr = (void*)args[i++];
6669                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6670                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6671                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6672                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6673                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
6674                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
6675                                 break;
6676                         }
6677
6678                 case glVertexColorTexCoord0PointerInterlaced_fake_func:
6679                         {
6680                                 int i = 0;
6681                                 int offset = args[i++];
6682                                 int vertexPointerSize = args[i++];
6683                                 int vertexPointerType = args[i++];
6684                                 int stride = args[i++];
6685                                 int colorPointerOffset = args[i++];
6686                                 int colorPointerSize = args[i++];
6687                                 int colorPointerType = args[i++];
6688                                 int texCoord0PointerOffset = args[i++];
6689                                 int texCoord0PointerSize = args[i++];
6690                                 int texCoord0PointerType = args[i++];
6691                                 int bytes_size = args[i++];
6692                                 void* ptr = (void*)args[i++];
6693                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6694                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6695                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6696                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6697                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
6698                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6699                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
6700                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6701                                 break;
6702                         }
6703
6704                 case glVertexNormalTexCoord0PointerInterlaced_fake_func:
6705                         {
6706                                 int i = 0;
6707                                 int offset = args[i++];
6708                                 int vertexPointerSize = args[i++];
6709                                 int vertexPointerType = args[i++];
6710                                 int stride = args[i++];
6711                                 int normalPointerOffset = args[i++];
6712                                 int normalPointerType = args[i++];
6713                                 int texCoord0PointerOffset = args[i++];
6714                                 int texCoord0PointerSize = args[i++];
6715                                 int texCoord0PointerType = args[i++];
6716                                 int bytes_size = args[i++];
6717                                 void* ptr = (void*)args[i++];
6718                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6719                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6720                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6721                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6722                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
6723                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6724                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
6725                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6726                                 break;
6727                         }
6728
6729                 case glVertexNormalTexCoord01PointerInterlaced_fake_func:
6730                         {
6731                                 int i = 0;
6732                                 int offset = args[i++];
6733                                 int vertexPointerSize = args[i++];
6734                                 int vertexPointerType = args[i++];
6735                                 int stride = args[i++];
6736                                 int normalPointerOffset = args[i++];
6737                                 int normalPointerType = args[i++];
6738                                 int texCoord0PointerOffset = args[i++];
6739                                 int texCoord0PointerSize = args[i++];
6740                                 int texCoord0PointerType = args[i++];
6741                                 int texCoord1PointerOffset = args[i++];
6742                                 int texCoord1PointerSize = args[i++];
6743                                 int texCoord1PointerType = args[i++];
6744                                 int bytes_size = args[i++];
6745                                 void* ptr = (void*)args[i++];
6746                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6747                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6748                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6749                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6750                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
6751                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6752                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
6753                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
6754                                 glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType, stride, process->current_state->vertexPointer + texCoord1PointerOffset);
6755                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6756                                 break;
6757                         }
6758
6759                 case glVertexNormalTexCoord012PointerInterlaced_fake_func:
6760                         {
6761                                 int i = 0;
6762                                 int offset = args[i++];
6763                                 int vertexPointerSize = args[i++];
6764                                 int vertexPointerType = args[i++];
6765                                 int stride = args[i++];
6766                                 int normalPointerOffset = args[i++];
6767                                 int normalPointerType = args[i++];
6768                                 int texCoord0PointerOffset = args[i++];
6769                                 int texCoord0PointerSize = args[i++];
6770                                 int texCoord0PointerType = args[i++];
6771                                 int texCoord1PointerOffset = args[i++];
6772                                 int texCoord1PointerSize = args[i++];
6773                                 int texCoord1PointerType = args[i++];
6774                                 int texCoord2PointerOffset = args[i++];
6775                                 int texCoord2PointerSize = args[i++];
6776                                 int texCoord2PointerType = args[i++];
6777                                 int bytes_size = args[i++];
6778                                 void* ptr = (void*)args[i++];
6779                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6780                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6781                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6782                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6783                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
6784                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6785                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
6786                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
6787                                 glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType, stride, process->current_state->vertexPointer + texCoord1PointerOffset);
6788                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
6789                                 glTexCoordPointer(texCoord2PointerSize, texCoord2PointerType, stride, process->current_state->vertexPointer + texCoord2PointerOffset);
6790                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6791                                 break;
6792                         }
6793
6794                 case glVertexNormalColorTexCoord0PointerInterlaced_fake_func:
6795                         {
6796                                 int i = 0;
6797                                 int offset = args[i++];
6798                                 int vertexPointerSize = args[i++];
6799                                 int vertexPointerType = args[i++];
6800                                 int stride = args[i++];
6801                                 int normalPointerOffset = args[i++];
6802                                 int normalPointerType = args[i++];
6803                                 int colorPointerOffset = args[i++];
6804                                 int colorPointerSize = args[i++];
6805                                 int colorPointerType = args[i++];
6806                                 int texCoord0PointerOffset = args[i++];
6807                                 int texCoord0PointerSize = args[i++];
6808                                 int texCoord0PointerType = args[i++];
6809                                 int bytes_size = args[i++];
6810                                 void* ptr = (void*)args[i++];
6811                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6812                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6813                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6814                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6815                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
6816                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
6817                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6818                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
6819                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6820                                 break;
6821                         }
6822
6823                 case glVertexNormalColorTexCoord01PointerInterlaced_fake_func:
6824                         {
6825                                 int i = 0;
6826                                 int offset = args[i++];
6827                                 int vertexPointerSize = args[i++];
6828                                 int vertexPointerType = args[i++];
6829                                 int stride = args[i++];
6830                                 int normalPointerOffset = args[i++];
6831                                 int normalPointerType = args[i++];
6832                                 int colorPointerOffset = args[i++];
6833                                 int colorPointerSize = args[i++];
6834                                 int colorPointerType = args[i++];
6835                                 int texCoord0PointerOffset = args[i++];
6836                                 int texCoord0PointerSize = args[i++];
6837                                 int texCoord0PointerType = args[i++];
6838                                 int texCoord1PointerOffset = args[i++];
6839                                 int texCoord1PointerSize = args[i++];
6840                                 int texCoord1PointerType = args[i++];
6841                                 int bytes_size = args[i++];
6842                                 void* ptr = (void*)args[i++];
6843                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6844                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6845                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6846                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6847                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
6848                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
6849                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6850                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
6851                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
6852                                 glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType, stride, process->current_state->vertexPointer + texCoord1PointerOffset);
6853                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6854                                 break;
6855                         }
6856
6857                 case glVertexNormalColorTexCoord012PointerInterlaced_fake_func:
6858                         {
6859                                 int i = 0;
6860                                 int offset = args[i++];
6861                                 int vertexPointerSize = args[i++];
6862                                 int vertexPointerType = args[i++];
6863                                 int stride = args[i++];
6864                                 int normalPointerOffset = args[i++];
6865                                 int normalPointerType = args[i++];
6866                                 int colorPointerOffset = args[i++];
6867                                 int colorPointerSize = args[i++];
6868                                 int colorPointerType = args[i++];
6869                                 int texCoord0PointerOffset = args[i++];
6870                                 int texCoord0PointerSize = args[i++];
6871                                 int texCoord0PointerType = args[i++];
6872                                 int texCoord1PointerOffset = args[i++];
6873                                 int texCoord1PointerSize = args[i++];
6874                                 int texCoord1PointerType = args[i++];
6875                                 int texCoord2PointerOffset = args[i++];
6876                                 int texCoord2PointerSize = args[i++];
6877                                 int texCoord2PointerType = args[i++];
6878                                 int bytes_size = args[i++];
6879                                 void* ptr = (void*)args[i++];
6880                                 process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, offset + bytes_size);
6881                                 process->current_state->vertexPointer = realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize);
6882                                 memcpy(process->current_state->vertexPointer + offset, ptr, bytes_size);
6883                                 glVertexPointer(vertexPointerSize, vertexPointerType, stride, process->current_state->vertexPointer);
6884                                 glNormalPointer(normalPointerType, stride, process->current_state->vertexPointer + normalPointerOffset);
6885                                 glColorPointer(colorPointerSize, colorPointerType, stride, process->current_state->vertexPointer + colorPointerOffset);
6886                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
6887                                 glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType, stride, process->current_state->vertexPointer + texCoord0PointerOffset);
6888                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
6889                                 glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType, stride, process->current_state->vertexPointer + texCoord1PointerOffset);
6890                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
6891                                 glTexCoordPointer(texCoord2PointerSize, texCoord2PointerType, stride, process->current_state->vertexPointer + texCoord2PointerOffset);
6892                                 do_glClientActiveTextureARB(GL_TEXTURE0_ARB + process->current_state->activeTextureIndex);
6893                                 break;
6894                         }
6895
6896                 case _glVertexPointer_buffer_func:
6897                         {
6898                                 glVertexPointer(args[0],args[1],args[2],(void*)args[3]);
6899                                 break;
6900                         }
6901
6902                 case _glNormalPointer_buffer_func:
6903                         {
6904                                 glNormalPointer(args[0],args[1],(void*)args[2]);
6905                                 break;
6906                         }
6907
6908                 case _glColorPointer_buffer_func:
6909                         {
6910                                 glColorPointer(args[0],args[1],args[2],(void*)args[3]);
6911                                 break;
6912                         }
6913
6914                 case _glSecondaryColorPointer_buffer_func:
6915                         {
6916                                 GET_EXT_PTR(void, glSecondaryColorPointer, (int,int,int,void*));
6917                                 ptr_func_glSecondaryColorPointer(args[0],args[1],args[2],(void*)args[3]);
6918                                 break;
6919                         }
6920
6921                 case _glIndexPointer_buffer_func:
6922                         {
6923                                 glIndexPointer(args[0],args[1],(void*)args[2]);
6924                                 break;
6925                         }
6926
6927                 case _glTexCoordPointer_buffer_func:
6928                         {
6929                                 glTexCoordPointer(args[0],args[1],args[2],(void*)args[3]);
6930                                 break;
6931                         }
6932
6933                 case _glEdgeFlagPointer_buffer_func:
6934                         {
6935                                 glEdgeFlagPointer(args[0],(void*)args[1]);
6936                                 break;
6937                         }
6938
6939                 case _glVertexAttribPointerARB_buffer_func:
6940                         {
6941                                 GET_EXT_PTR(void, glVertexAttribPointerARB, (int,int,int,int,int,void*));
6942                                 ptr_func_glVertexAttribPointerARB(args[0], args[1], args[2], args[3], args[4], (void*)args[5]);
6943                                 break;
6944                         }
6945
6946                 case _glWeightPointerARB_buffer_func:
6947                         {
6948                                 GET_EXT_PTR(void, glWeightPointerARB, (int,int,int,void*));
6949                                 ptr_func_glWeightPointerARB(args[0], args[1], args[2], (void*)args[3]);
6950                                 break;
6951                         }
6952
6953                 case _glMatrixIndexPointerARB_buffer_func:
6954                         {
6955                                 GET_EXT_PTR(void, glMatrixIndexPointerARB, (int,int,int,void*));
6956                                 ptr_func_glMatrixIndexPointerARB(args[0], args[1], args[2], (void*)args[3]);
6957                                 break;
6958                         }
6959
6960                 case _glFogCoordPointer_buffer_func:
6961                         {
6962                                 GET_EXT_PTR(void, glFogCoordPointer, (int,int,void*));
6963                                 ptr_func_glFogCoordPointer(args[0], args[1], (void*)args[2]);
6964                                 break;
6965                         }
6966
6967                 case _glVariantPointerEXT_buffer_func:
6968                         {
6969                                 GET_EXT_PTR(void, glVariantPointerEXT, (int, int,int,void*));
6970                                 ptr_func_glVariantPointerEXT(args[0], args[1], args[2], (void*)args[3]);
6971                                 break;
6972                         }
6973
6974                 case _glDrawElements_buffer_func:
6975                         {
6976                                 glDrawElements(args[0],args[1],args[2],(void*)args[3]);
6977                                 break;
6978                         }
6979
6980                 case _glDrawRangeElements_buffer_func:
6981                         {
6982                                 glDrawRangeElements(args[0],args[1],args[2],args[3],args[4],(void*)args[5]);
6983                                 break;
6984                         }
6985
6986                 case _glMultiDrawElements_buffer_func:
6987                         {
6988                                 GET_EXT_PTR(void, glMultiDrawElements, (int,int*,int,void**, int));
6989                                 ptr_func_glMultiDrawElements(args[0],(int*)args[1],args[2],(void**)args[3],args[4]);
6990                                 break;
6991                         }
6992
6993                 case _glGetError_fake_func:
6994                         {
6995                                 break;
6996                         }
6997
6998                 case glGetIntegerv_func:
6999                         {
7000                                 glGetIntegerv(args[0], (int*)args[1]);
7001                                 //fprintf(stderr,"glGetIntegerv(%X)=%d\n", (int)args[0], *(int*)args[1]);
7002                                 break;
7003                         }
7004
7005                 case _glReadPixels_pbo_func:
7006                         {
7007                                 glReadPixels(ARG_TO_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), ARG_TO_UNSIGNED_INT(args[4]), ARG_TO_UNSIGNED_INT(args[5]), (void*)(args[6]));
7008                                 break;
7009                         }
7010
7011                 case _glDrawPixels_pbo_func:
7012                         {
7013                                 glDrawPixels(ARG_TO_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_UNSIGNED_INT(args[2]), ARG_TO_UNSIGNED_INT(args[3]), (const void*)(args[4]));
7014                                 break;
7015                         }
7016
7017                 case _glMapBufferARB_fake_func:
7018                         {
7019                                 GET_EXT_PTR(GLvoid*, glMapBufferARB, (GLenum, GLenum));
7020                                 GET_EXT_PTR(GLboolean, glUnmapBufferARB, (GLenum));
7021                                 int target = args[0];
7022                                 int size = args[1];
7023                                 void* dst_ptr = (void*)args[2];
7024                                 void* src_ptr = ptr_func_glMapBufferARB(target, GL_READ_ONLY);
7025                                 if (src_ptr)
7026                                 {
7027                                         memcpy(dst_ptr, src_ptr, size);
7028                                         ret_int = ptr_func_glUnmapBufferARB(target);
7029                                 }
7030                                 else
7031                                 {
7032                                         ret_int = 0;
7033                                 }
7034                                 break;
7035                         }
7036
7037                 case fake_gluBuild2DMipmaps_func:
7038                         {
7039                                 GET_GLU_PTR(GLint, gluBuild2DMipmaps, (GLenum arg_0, GLint arg_1, GLsizei arg_2, GLsizei arg_3, GLenum arg_4, GLenum arg_5, const GLvoid * arg_6));
7040                                 if (ptr_func_gluBuild2DMipmaps == NULL)
7041                                         ptr_func_gluBuild2DMipmaps = mesa_gluBuild2DMipmaps;
7042                                 ptr_func_gluBuild2DMipmaps(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), ARG_TO_UNSIGNED_INT(args[4]), ARG_TO_UNSIGNED_INT(args[5]), (const void*)(args[6]));
7043                                 break;
7044                         }
7045
7046                 case _glSelectBuffer_fake_func:
7047                         {
7048                                 process->current_state->selectBufferSize = args[0] * 4;
7049                                 process->current_state->selectBufferPtr = realloc(process->current_state->selectBufferPtr, process->current_state->selectBufferSize);
7050                                 glSelectBuffer(args[0], process->current_state->selectBufferPtr);
7051                                 break;
7052                         }
7053
7054                 case _glGetSelectBuffer_fake_func:
7055                         {
7056                                 void* ptr = (void*)args[0];
7057                                 memcpy(ptr, process->current_state->selectBufferPtr, process->current_state->selectBufferSize);
7058                                 break;
7059                         }
7060
7061                 case _glFeedbackBuffer_fake_func:
7062                         {
7063                                 process->current_state->feedbackBufferSize = args[0] * 4;
7064                                 process->current_state->feedbackBufferPtr = realloc(process->current_state->feedbackBufferPtr, process->current_state->feedbackBufferSize);
7065                                 glFeedbackBuffer(args[0], args[1], process->current_state->feedbackBufferPtr);
7066                                 break;
7067                         }
7068
7069                 case _glGetFeedbackBuffer_fake_func:
7070                         {
7071                                 void* ptr = (void*)args[0];
7072                                 memcpy(ptr, process->current_state->feedbackBufferPtr, process->current_state->feedbackBufferSize);
7073                                 break;
7074                         }
7075
7076                         /*
7077                            case glEnableClientState_func:
7078                            {
7079                            if (display_function_call) fprintf(stderr, "cap : %s\n", nameArrays[args[0] - GL_VERTEX_ARRAY]);
7080                            glEnableClientState(args[0]);
7081                            break;
7082                            }
7083
7084                            case glDisableClientState_func:
7085                            {
7086                            if (display_function_call) fprintf(stderr, "cap : %s\n", nameArrays[args[0] - GL_VERTEX_ARRAY]);
7087                            glDisableClientState(args[0]);
7088                            break;
7089                            }
7090
7091                            case glClientActiveTexture_func:
7092                            case glClientActiveTextureARB_func:
7093                            {
7094                            if (display_function_call) fprintf(stderr, "client activeTexture %d\n", args[0] - GL_TEXTURE0_ARB);
7095                            glClientActiveTextureARB(args[0]);
7096                            break;
7097                            }
7098
7099                            case glActiveTextureARB_func:
7100                            {
7101                            if (display_function_call) fprintf(stderr, "server activeTexture %d\n", args[0] - GL_TEXTURE0_ARB);
7102                            glActiveTextureARB(args[0]);
7103                            break;
7104                            }
7105
7106                            case glLockArraysEXT_func:
7107                            break;
7108
7109                            case glUnlockArraysEXT_func:
7110                            break;
7111
7112                            case glArrayElement_func:
7113                            {
7114                            glArrayElement(args[0]);
7115                            break;
7116                            }
7117
7118                            case glDrawArrays_func:
7119                            {
7120                            glDrawArrays(args[0],args[1],args[2]);
7121                            break;
7122                            }
7123
7124                            case glDrawElements_func:
7125                            {
7126                            glDrawElements(args[0],args[1],args[2],(void*)args[3]);
7127                            break;
7128                            }
7129
7130                            case glDrawRangeElements_func:
7131                            {
7132                            glDrawRangeElements(args[0],args[1],args[2],args[3],args[4],(void*)args[5]);
7133                            break;
7134                            }
7135                          */
7136
7137                 case glGetError_func:
7138                         {
7139 #ifdef SYSTEMATIC_ERROR_CHECK
7140                                 ret_int = process->current_state->last_error;
7141 #else
7142                                 ret_int = glGetError();
7143 #endif
7144                                 break;
7145                         }
7146
7147                 case glNewObjectBufferATI_func:
7148                         {
7149                                 GET_EXT_PTR(int, glNewObjectBufferATI, (int,void*, int));
7150                                 ret_int = ptr_func_glNewObjectBufferATI(args[0], (void*)args[1], args[2]);
7151                                 break;
7152                         }
7153
7154                 default:
7155                         execute_func(func_number, args, &ret_int, &ret_char);
7156                         break;
7157         }
7158
7159 #ifdef SYSTEMATIC_ERROR_CHECK
7160         if (func_number == glGetError_func)
7161         {
7162                 process->current_state->last_error = 0;
7163         }
7164         else
7165         {
7166                 process->current_state->last_error = glGetError();
7167                 if (process->current_state->last_error != 0)
7168                 {
7169                         printf("error %s 0x%X\n",  tab_opengl_calls_name[func_number], process->current_state->last_error);
7170                 }
7171         }
7172 #endif
7173
7174         Signature* signature = (Signature*)tab_opengl_calls[func_number];
7175         int ret_type = signature->ret_type;
7176         //int nb_args = signature->nb_args;
7177         switch(ret_type)
7178         {
7179                 case TYPE_NONE:
7180                         break;
7181
7182                 case TYPE_CHAR:
7183                 case TYPE_UNSIGNED_CHAR:
7184                         ret_int = ret_char;
7185                         break;
7186
7187                 case TYPE_INT:
7188                 case TYPE_UNSIGNED_INT:
7189                         break;
7190
7191                 case TYPE_CONST_CHAR:
7192                         {
7193                                 strncpy(ret_string, (ret_str) ? ret_str : "", 32768);
7194                                 break;
7195                         }
7196
7197                 default:
7198                         fprintf(stderr, "unexpected ret type : %d\n", ret_type);
7199                         exit(-1);
7200                         break;
7201         }
7202
7203         if (display_function_call) fprintf(stderr, "[%d]< %s\n", process->instr_counter, tab_opengl_calls_name[func_number]);
7204
7205         return ret_int;
7206 }
7207 #endif
7208
7209 void create_process_tab( OGLS_Conn *pConn )
7210 {
7211         if (pConn == NULL) {
7212                 fprintf(stderr, "create_process_tab: pConn is NULL.\n");
7213                 return;
7214         }
7215         pConn->processTab = malloc( sizeof(ProcessStruct)*MAX_HANDLED_PROCESS );
7216         if( !pConn->processTab )
7217         {
7218                 perror( "init_process_tab" );
7219                 return ;
7220         }
7221
7222         memset(pConn->processTab, 0, sizeof(ProcessStruct)*MAX_HANDLED_PROCESS );
7223 }
7224
7225 void remove_process_tab( OGLS_Conn *pConn )
7226 {
7227         if( !pConn->processTab ) return ;
7228         free( pConn->processTab );
7229         pConn->processTab = NULL;
7230 }