← Back to branch summary

~ubuntu-branches/ubuntu/edgy/xorg-server/edgy-updates

« back to all changes in this revision

Viewing changes to GL/glx/render2swap.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Parra Novo
  • Date: 2006-07-25 20:06:28 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20060725200628-gjmmd9gxfxdc4ejs
Tags: 1:1.1.1-0ubuntu1
* New Upstream version
* Changed Build-Depends from mesa-swrast-source to mesa-swx11-source,
  following Debian package nomenclature
* Re-did 12_security_policy_in_etc.diff for 1.1.1
* Dropped 15_security_allocate_local.diff (applied upstream)
* Dropped 16_SECURITY_setuid.diff (applied upstream)
* Dropped 000_ubuntu_fix_read_kernel_mapping.patch (applied upstream)
* Dropped 002_ubuntu_fix_for_certain_intel_chipsets.patch (applied upstream)
* Updated versioned Build-Depends on mesa-swx11-source to version
  6.5.0.cvs.20060725-0ubuntu1
* Added arrayobj.c, arrayobj.h, bitset.h & rbadaptors.h to
  GL/symlink-mesa.sh (linked from mesa-swx11-source)
* Added arrayobj.c to default build target on GL/mesa/main

Show diffs side-by-side

added added

removed removed

Lines of Context:
GL/glx/render2swap.c
41
41
 
42
42
#include "glxserver.h"
43
43
#include "unpack.h"
44
 
#include "g_disptab.h"
45
 
#include "g_disptab_EXT.h"
 
44
#include "indirect_size.h"
 
45
#include "indirect_dispatch.h"
 
46
#include "glapitable.h"
 
47
#include "glapi.h"
 
48
#include "glthread.h"
 
49
#include "dispatch.h"
46
50
 
47
51
 
48
52
void __glXDispSwap_Map1f(GLbyte *pc)
74
78
    }
75
79
    __GLX_SWAP_FLOAT_ARRAY(points, compsize);
76
80
 
77
 
    glMap1f(target, u1, u2, k, order, points);
 
81
    CALL_Map1f( GET_DISPATCH(), (target, u1, u2, k, order, points) );
78
82
}
79
83
 
80
84
void __glXDispSwap_Map2f(GLbyte *pc)
115
119
    }
116
120
    __GLX_SWAP_FLOAT_ARRAY(points, compsize);
117
121
 
118
 
    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 
122
    CALL_Map2f( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
119
123
}
120
124
 
121
125
void __glXDispSwap_Map1d(GLbyte *pc)
159
163
#else
160
164
    points = (GLdouble*) pc;
161
165
#endif
162
 
    glMap1d(target, u1, u2, k, order, points);
 
166
    CALL_Map1d( GET_DISPATCH(), (target, u1, u2, k, order, points) );
163
167
}
164
168
 
165
169
void __glXDispSwap_Map2d(GLbyte *pc)
211
215
#else
212
216
    points = (GLdouble*) pc;
213
217
#endif
214
 
    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
215
 
}
216
 
 
217
 
void __glXDispSwap_CallLists(GLbyte *pc)
218
 
{
219
 
    GLenum type;
220
 
    GLsizei n;
221
 
    __GLX_DECLARE_SWAP_VARIABLES;
222
 
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
223
 
 
224
 
    __GLX_SWAP_INT(pc + 4);
225
 
    __GLX_SWAP_INT(pc + 0);
226
 
    type = *(GLenum *)(pc + 4);
227
 
    n = *(GLsizei *)(pc + 0);
228
 
 
229
 
    switch (type) {
230
 
      case GL_BYTE:
231
 
      case GL_UNSIGNED_BYTE:
232
 
      case GL_2_BYTES:
233
 
      case GL_3_BYTES:
234
 
      case GL_4_BYTES:
235
 
        break;
236
 
      case GL_SHORT:
237
 
      case GL_UNSIGNED_SHORT:
238
 
        __GLX_SWAP_SHORT_ARRAY(pc+8, n);
239
 
        break;
240
 
      case GL_INT:
241
 
      case GL_UNSIGNED_INT:
242
 
        __GLX_SWAP_INT_ARRAY(pc+8, n);
243
 
        break;
244
 
      case GL_FLOAT:
245
 
        __GLX_SWAP_FLOAT_ARRAY(pc+8, n);
246
 
        break;
247
 
    }
248
 
 
249
 
    glCallLists(n, type, pc+8);
 
218
    CALL_Map2d( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
250
219
}
251
220
 
252
221
static void swapArray(GLint numVals, GLenum datatype,
342
311
        GLint numVals = compHeader[i].numVals;
343
312
        GLenum component = compHeader[i].component;
344
313
 
 
314
        __GLX_SWAP_INT(&datatype);
 
315
        __GLX_SWAP_INT(&numVals);
 
316
        __GLX_SWAP_INT(&component);
 
317
 
345
318
        swapArray(numVals, datatype, stride, numVertexes, pc);
346
319
 
347
320
        switch (component) {
348
321
          case GL_VERTEX_ARRAY:
349
 
            glEnableClientState(GL_VERTEX_ARRAY);
350
 
            glVertexPointer(numVals, datatype, stride, pc);
 
322
            CALL_EnableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
 
323
            CALL_VertexPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
351
324
            break;
352
325
          case GL_NORMAL_ARRAY:
353
 
            glEnableClientState(GL_NORMAL_ARRAY);
354
 
            glNormalPointer(datatype, stride, pc);
 
326
            CALL_EnableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
 
327
            CALL_NormalPointer( GET_DISPATCH(), (datatype, stride, pc) );
355
328
            break;
356
329
          case GL_COLOR_ARRAY:
357
 
            glEnableClientState(GL_COLOR_ARRAY);
358
 
            glColorPointer(numVals, datatype, stride, pc);
 
330
            CALL_EnableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
 
331
            CALL_ColorPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
359
332
            break;
360
333
          case GL_INDEX_ARRAY:
361
 
            glEnableClientState(GL_INDEX_ARRAY);
362
 
            glIndexPointer(datatype, stride, pc);
 
334
            CALL_EnableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
 
335
            CALL_IndexPointer( GET_DISPATCH(), (datatype, stride, pc) );
363
336
            break;
364
337
          case GL_TEXTURE_COORD_ARRAY:
365
 
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
366
 
            glTexCoordPointer(numVals, datatype, stride, pc);
 
338
            CALL_EnableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
 
339
            CALL_TexCoordPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
367
340
            break;
368
341
          case GL_EDGE_FLAG_ARRAY:
369
 
            glEnableClientState(GL_EDGE_FLAG_ARRAY);
370
 
            glEdgeFlagPointer(stride, (const GLboolean *)pc);
 
342
            CALL_EnableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
 
343
            CALL_EdgeFlagPointer( GET_DISPATCH(), (stride, (const GLboolean *)pc) );
 
344
            break;
 
345
          case GL_SECONDARY_COLOR_ARRAY:
 
346
            CALL_EnableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) );
 
347
            CALL_SecondaryColorPointerEXT( GET_DISPATCH(), (numVals, datatype, stride, pc) );
 
348
            break;
 
349
          case GL_FOG_COORD_ARRAY:
 
350
            CALL_EnableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) );
 
351
            CALL_FogCoordPointerEXT( GET_DISPATCH(), (datatype, stride, pc) );
371
352
            break;
372
353
          default:
373
354
            break;
376
357
        pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
377
358
    }
378
359
 
379
 
    glDrawArrays(primType, 0, numVertexes);
 
360
    CALL_DrawArrays( GET_DISPATCH(), (primType, 0, numVertexes) );
380
361
 
381
362
    /* turn off anything we might have turned on */
382
 
    glDisableClientState(GL_VERTEX_ARRAY);
383
 
    glDisableClientState(GL_NORMAL_ARRAY);
384
 
    glDisableClientState(GL_COLOR_ARRAY);
385
 
    glDisableClientState(GL_INDEX_ARRAY);
386
 
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
387
 
    glDisableClientState(GL_EDGE_FLAG_ARRAY);
 
363
    CALL_DisableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
 
364
    CALL_DisableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
 
365
    CALL_DisableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
 
366
    CALL_DisableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
 
367
    CALL_DisableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
 
368
    CALL_DisableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
 
369
    CALL_DisableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) );
 
370
    CALL_DisableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) );
388
371
}
389
372
 
390
373
void __glXDispSwap_DrawArraysEXT(GLbyte *pc)