VirtualBox

Changeset 33457 in vbox for trunk


Ignore:
Timestamp:
Oct 26, 2010 11:12:30 AM (14 years ago)
Author:
vboxsync
Message:

crOpenGL: tabs to spaces

Location:
trunk/src/VBox/GuestHost/OpenGL/packer
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_beginend.c

    r15532 r33457  
    1010void PACK_APIENTRY crPackBegin( GLenum mode )
    1111{
    12         GET_PACKER_CONTEXT(pc);
    13         unsigned char *data_ptr;
    14         (void) pc;
    15         if (pc->buffer.canBarf)
    16         {
    17                 if (!pc->buffer.holds_BeginEnd)
    18                         pc->Flush( pc->flush_arg );
    19                 pc->buffer.in_BeginEnd = 1;
    20                 pc->buffer.holds_BeginEnd = 1;
    21         }
    22         GET_BUFFERED_POINTER( pc, 4 );
    23         pc->current.begin_data = data_ptr;
    24         pc->current.begin_op = pc->buffer.opcode_current;
    25         pc->current.attribsUsedMask = 0;
    26         WRITE_DATA( 0, GLenum, mode );
    27         WRITE_OPCODE( pc, CR_BEGIN_OPCODE );
     12    GET_PACKER_CONTEXT(pc);
     13    unsigned char *data_ptr;
     14    (void) pc;
     15    if (pc->buffer.canBarf)
     16    {
     17        if (!pc->buffer.holds_BeginEnd)
     18            pc->Flush( pc->flush_arg );
     19        pc->buffer.in_BeginEnd = 1;
     20        pc->buffer.holds_BeginEnd = 1;
     21    }
     22    GET_BUFFERED_POINTER( pc, 4 );
     23    pc->current.begin_data = data_ptr;
     24    pc->current.begin_op = pc->buffer.opcode_current;
     25    pc->current.attribsUsedMask = 0;
     26    WRITE_DATA( 0, GLenum, mode );
     27    WRITE_OPCODE( pc, CR_BEGIN_OPCODE );
    2828}
    2929
    3030void PACK_APIENTRY crPackBeginSWAP( GLenum mode )
    3131{
    32         GET_PACKER_CONTEXT(pc);
    33         unsigned char *data_ptr;
    34         (void) pc;
    35         if (pc->buffer.canBarf)
    36         {
    37                 if (!pc->buffer.holds_BeginEnd)
    38                         pc->Flush( pc->flush_arg );
    39                 pc->buffer.in_BeginEnd = 1;
    40                 pc->buffer.holds_BeginEnd = 1;
    41         }
    42         GET_BUFFERED_POINTER( pc, 4 );
    43         pc->current.begin_data = data_ptr;
    44         pc->current.begin_op = pc->buffer.opcode_current;
    45         pc->current.attribsUsedMask = 0;
    46         WRITE_DATA( 0, GLenum, SWAP32(mode) );
    47         WRITE_OPCODE( pc, CR_BEGIN_OPCODE );
     32    GET_PACKER_CONTEXT(pc);
     33    unsigned char *data_ptr;
     34    (void) pc;
     35    if (pc->buffer.canBarf)
     36    {
     37        if (!pc->buffer.holds_BeginEnd)
     38            pc->Flush( pc->flush_arg );
     39        pc->buffer.in_BeginEnd = 1;
     40        pc->buffer.holds_BeginEnd = 1;
     41    }
     42    GET_BUFFERED_POINTER( pc, 4 );
     43    pc->current.begin_data = data_ptr;
     44    pc->current.begin_op = pc->buffer.opcode_current;
     45    pc->current.attribsUsedMask = 0;
     46    WRITE_DATA( 0, GLenum, SWAP32(mode) );
     47    WRITE_OPCODE( pc, CR_BEGIN_OPCODE );
    4848}
    4949
    5050void PACK_APIENTRY crPackEnd( void )
    5151{
    52         GET_PACKER_CONTEXT(pc);
    53         unsigned char *data_ptr;
    54         (void) pc;
    55         GET_BUFFERED_POINTER_NO_ARGS( pc );
    56         WRITE_OPCODE( pc, CR_END_OPCODE );
    57         pc->buffer.in_BeginEnd = 0;
     52    GET_PACKER_CONTEXT(pc);
     53    unsigned char *data_ptr;
     54    (void) pc;
     55    GET_BUFFERED_POINTER_NO_ARGS( pc );
     56    WRITE_OPCODE( pc, CR_END_OPCODE );
     57    pc->buffer.in_BeginEnd = 0;
    5858}
    5959
    6060void PACK_APIENTRY crPackEndSWAP( void )
    6161{
    62         GET_PACKER_CONTEXT(pc);
    63         unsigned char *data_ptr;
    64         (void) pc;
    65         GET_BUFFERED_POINTER_NO_ARGS( pc );
    66         WRITE_OPCODE( pc, CR_END_OPCODE );
    67         pc->buffer.in_BeginEnd = 0;
     62    GET_PACKER_CONTEXT(pc);
     63    unsigned char *data_ptr;
     64    (void) pc;
     65    GET_BUFFERED_POINTER_NO_ARGS( pc );
     66    WRITE_OPCODE( pc, CR_END_OPCODE );
     67    pc->buffer.in_BeginEnd = 0;
    6868}
    6969

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_bounds.c

    r15532 r33457  
    1111void PACK_APIENTRY crPackBoundsInfoCR( const CRrecti *bounds, const GLbyte *payload, GLint len, GLint num_opcodes )
    1212{
    13         GET_PACKER_CONTEXT(pc);
    14         /* Don't get the buffered_ptr here because we've already
    15         * verified that there's enough space for everything. */
     13    GET_PACKER_CONTEXT(pc);
     14    /* Don't get the buffered_ptr here because we've already
     15    * verified that there's enough space for everything. */
    1616
    17         unsigned char *data_ptr = pc->buffer.data_current;
    18         int len_aligned     = ( len + 0x3 ) & ~0x3;
    19         int total_len = 24 + len_aligned;
     17    unsigned char *data_ptr = pc->buffer.data_current;
     18    int len_aligned     = ( len + 0x3 ) & ~0x3;
     19    int total_len = 24 + len_aligned;
    2020
    21         WRITE_DATA( 0, int, total_len );
    22         WRITE_DATA( 4, int, bounds->x1 );
    23         WRITE_DATA( 8, int, bounds->y1 );
    24         WRITE_DATA( 12, int, bounds->x2 );
    25         WRITE_DATA( 16, int, bounds->y2 );
    26         WRITE_DATA( 20, int, num_opcodes );
     21    WRITE_DATA( 0, int, total_len );
     22    WRITE_DATA( 4, int, bounds->x1 );
     23    WRITE_DATA( 8, int, bounds->y1 );
     24    WRITE_DATA( 12, int, bounds->x2 );
     25    WRITE_DATA( 16, int, bounds->y2 );
     26    WRITE_DATA( 20, int, num_opcodes );
    2727
    28         /* skip the BOUNDSINFO */
    29         data_ptr += 24;
     28    /* skip the BOUNDSINFO */
     29    data_ptr += 24;
    3030
    31         /* put in padding opcodes (deliberately bogus) */
    32         switch ( len_aligned - len )
    33         {
    34           case 3: *data_ptr++ = 0xff; /* FALLTHROUGH */
    35           case 2: *data_ptr++ = 0xff; /* FALLTHROUGH */
    36           case 1: *data_ptr++ = 0xff; /* FALLTHROUGH */
    37           default: break;
    38         }
     31    /* put in padding opcodes (deliberately bogus) */
     32    switch ( len_aligned - len )
     33    {
     34      case 3: *data_ptr++ = 0xff; /* FALLTHROUGH */
     35      case 2: *data_ptr++ = 0xff; /* FALLTHROUGH */
     36      case 1: *data_ptr++ = 0xff; /* FALLTHROUGH */
     37      default: break;
     38    }
    3939
    40         crMemcpy( data_ptr, payload, len );
     40    crMemcpy( data_ptr, payload, len );
    4141
    42         WRITE_OPCODE( pc, CR_BOUNDSINFOCR_OPCODE );
    43         pc->buffer.data_current += 24 + len_aligned;
     42    WRITE_OPCODE( pc, CR_BOUNDSINFOCR_OPCODE );
     43    pc->buffer.data_current += 24 + len_aligned;
    4444}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_clipplane.c

    r15532 r33457  
    1010void PACK_APIENTRY crPackClipPlane( GLenum plane, const GLdouble *equation )
    1111{
    12         GET_PACKER_CONTEXT(pc);
    13         unsigned char *data_ptr;
    14         int packet_length = sizeof( plane ) + 4*sizeof(*equation);
    15         GET_BUFFERED_POINTER(pc, packet_length );
    16         WRITE_DATA( 0, GLenum, plane );
    17         WRITE_DOUBLE( 4, equation[0] );
    18         WRITE_DOUBLE( 12, equation[1] );
    19         WRITE_DOUBLE( 20, equation[2] );
    20         WRITE_DOUBLE( 28, equation[3] );
    21         WRITE_OPCODE( pc, CR_CLIPPLANE_OPCODE );
     12    GET_PACKER_CONTEXT(pc);
     13    unsigned char *data_ptr;
     14    int packet_length = sizeof( plane ) + 4*sizeof(*equation);
     15    GET_BUFFERED_POINTER(pc, packet_length );
     16    WRITE_DATA( 0, GLenum, plane );
     17    WRITE_DOUBLE( 4, equation[0] );
     18    WRITE_DOUBLE( 12, equation[1] );
     19    WRITE_DOUBLE( 20, equation[2] );
     20    WRITE_DOUBLE( 28, equation[3] );
     21    WRITE_OPCODE( pc, CR_CLIPPLANE_OPCODE );
    2222}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_error.c

    r15532 r33457  
    1717void crPackErrorFunction( CRPackContext *pc, CRPackErrorHandlerFunc function )
    1818{
    19         pc->Error = function;
     19    pc->Error = function;
    2020}
    2121
    … …  
    2727void __PackError( int line, const char *file, GLenum error, const char *info)
    2828{
    29         GET_PACKER_CONTEXT(pc);
     29    GET_PACKER_CONTEXT(pc);
    3030
    31         if (pc->Error)
    32                 pc->Error( line, file, error, info );
     31    if (pc->Error)
     32        pc->Error( line, file, error, info );
    3333
    34         if (crGetenv("CR_DEBUG"))
    35         {
    36                 char *glerr;
     34    if (crGetenv("CR_DEBUG"))
     35    {
     36        char *glerr;
    3737
    38                 switch (error) {
    39                 case GL_NO_ERROR:
    40                         glerr = "GL_NO_ERROR";
    41                         break;
    42                 case GL_INVALID_VALUE:
    43                         glerr = "GL_INVALID_VALUE";
    44                         break;
    45                 case GL_INVALID_ENUM:
    46                         glerr = "GL_INVALID_ENUM";
    47                         break;
    48                 case GL_INVALID_OPERATION:
    49                         glerr = "GL_INVALID_OPERATION";
    50                         break;
    51                 case GL_STACK_OVERFLOW:
    52                         glerr = "GL_STACK_OVERFLOW";
    53                         break;
    54                 case GL_STACK_UNDERFLOW:
    55                         glerr = "GL_STACK_UNDERFLOW";
    56                         break;
    57                 case GL_OUT_OF_MEMORY:
    58                         glerr = "GL_OUT_OF_MEMORY";
    59                         break;
    60                 case GL_TABLE_TOO_LARGE:
    61                         glerr = "GL_TABLE_TOO_LARGE";
    62                         break;
    63                 default:
    64                         glerr = "unknown";
    65                         break;
    66                 }
     38        switch (error) {
     39        case GL_NO_ERROR:
     40            glerr = "GL_NO_ERROR";
     41            break;
     42        case GL_INVALID_VALUE:
     43            glerr = "GL_INVALID_VALUE";
     44            break;
     45        case GL_INVALID_ENUM:
     46            glerr = "GL_INVALID_ENUM";
     47            break;
     48        case GL_INVALID_OPERATION:
     49            glerr = "GL_INVALID_OPERATION";
     50            break;
     51        case GL_STACK_OVERFLOW:
     52            glerr = "GL_STACK_OVERFLOW";
     53            break;
     54        case GL_STACK_UNDERFLOW:
     55            glerr = "GL_STACK_UNDERFLOW";
     56            break;
     57        case GL_OUT_OF_MEMORY:
     58            glerr = "GL_OUT_OF_MEMORY";
     59            break;
     60        case GL_TABLE_TOO_LARGE:
     61            glerr = "GL_TABLE_TOO_LARGE";
     62            break;
     63        default:
     64            glerr = "unknown";
     65            break;
     66        }
    6767
    68                 crWarning( "GL error in packer: %s, line %d: %s: %s",
    69                                                 file, line, glerr, info );
    70         }
     68        crWarning( "GL error in packer: %s, line %d: %s: %s",
     69                        file, line, glerr, info );
     70    }
    7171}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_extensions.c

    r15532 r33457  
    1111int __packTexParameterNumParams( GLenum param )
    1212{
    13         switch( param )
    14         {
     13    switch( param )
     14    {
    1515#ifdef CR_EXT_texture_filter_anisotropic
    16                 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
    17                         return 1;
     16        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
     17            return 1;
    1818#endif
    19                 default:
    20                         break;
    21         }
    22         return 0;
     19        default:
     20            break;
     21    }
     22    return 0;
    2323}
    2424
    2525int __packFogParamsLength( GLenum param )
    2626{
    27         static int one_param = sizeof( GLfloat );
     27    static int one_param = sizeof( GLfloat );
    2828        (void) one_param;
    29         switch( param )
    30         {
     29    switch( param )
     30    {
    3131#ifdef CR_NV_fog_distance
    32                 case GL_FOG_DISTANCE_MODE_NV:
    33                         return one_param;
     32        case GL_FOG_DISTANCE_MODE_NV:
     33            return one_param;
    3434#endif
    35                 default:
    36                         break;
    37         }
    38         return 0;
     35        default:
     36            break;
     37    }
     38    return 0;
    3939}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_feedback.c

    r15532 r33457  
    1010void PACK_APIENTRY crPackFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
    1111{
    12         (void) size;
    13         (void) type;
    14         (void) buffer;
     12    (void) size;
     13    (void) type;
     14    (void) buffer;
    1515
    16         crWarning("Packer wont pass FeedbackBuffer()\n");
    17         crWarning("Try using the feedbackspu\n");
     16    crWarning("Packer wont pass FeedbackBuffer()\n");
     17    crWarning("Try using the feedbackspu\n");
    1818}
    1919
    2020void PACK_APIENTRY crPackFeedbackBufferSWAP( GLsizei size, GLenum type, GLfloat *buffer )
    2121{
    22         (void) size;
    23         (void) type;
    24         (void) buffer;
     22    (void) size;
     23    (void) type;
     24    (void) buffer;
    2525
    26         crWarning("Packer wont pass FeedbackBuffer()\n");
    27         crWarning("Try using the feedbackspu\n");
     26    crWarning("Packer wont pass FeedbackBuffer()\n");
     27    crWarning("Try using the feedbackspu\n");
    2828}
    2929
    3030void PACK_APIENTRY crPackSelectBuffer( GLsizei size, GLuint *buffer )
    3131{
    32         (void) size;
    33         (void) buffer;
     32    (void) size;
     33    (void) buffer;
    3434
    35         crWarning("Packer wont pass SelectBuffer()\n");
    36         crWarning("Try using the feedbackspu\n");
     35    crWarning("Packer wont pass SelectBuffer()\n");
     36    crWarning("Try using the feedbackspu\n");
    3737}
    3838
    3939void PACK_APIENTRY crPackSelectBufferSWAP( GLsizei size, GLuint *buffer )
    4040{
    41         (void) size;
    42         (void) buffer;
     41    (void) size;
     42    (void) buffer;
    4343
    44         crWarning("Packer wont pass SelectBuffer()\n");
    45         crWarning("Try using the feedbackspu\n");
     44    crWarning("Packer wont pass SelectBuffer()\n");
     45    crWarning("Try using the feedbackspu\n");
    4646}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_fence.c

    r15532 r33457  
    1010crPackDeleteFencesNV(GLsizei n, const GLuint * fences)
    1111{
    12         unsigned char *data_ptr;
    13         int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*fences);
     12    unsigned char *data_ptr;
     13    int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*fences);
    1414
    15         if( !fences )
    16                 return;
     15    if( !fences )
     16        return;
    1717
    18         data_ptr = (unsigned char *) crPackAlloc(packet_length);
    19         WRITE_DATA(0, GLenum, CR_DELETEFENCESNV_EXTEND_OPCODE);
    20         WRITE_DATA(4, GLsizei, n);
    21         crMemcpy(data_ptr + 8, fences, n * sizeof(*fences));
    22         crHugePacket(CR_EXTEND_OPCODE, data_ptr);
    23         crPackFree(data_ptr);
     18    data_ptr = (unsigned char *) crPackAlloc(packet_length);
     19    WRITE_DATA(0, GLenum, CR_DELETEFENCESNV_EXTEND_OPCODE);
     20    WRITE_DATA(4, GLsizei, n);
     21    crMemcpy(data_ptr + 8, fences, n * sizeof(*fences));
     22    crHugePacket(CR_EXTEND_OPCODE, data_ptr);
     23    crPackFree(data_ptr);
    2424}
    2525
    2626void PACK_APIENTRY crPackDeleteFencesNVSWAP( GLsizei n, const GLuint *fences )
    2727{
    28         unsigned char *data_ptr;
    29         int i;
    30         int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*fences);
     28    unsigned char *data_ptr;
     29    int i;
     30    int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*fences);
    3131
    32         if( !fences )
    33                 return;
     32    if( !fences )
     33        return;
    3434
    35         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    36         WRITE_DATA(0, GLenum, CR_DELETEFENCESNV_EXTEND_OPCODE);
    37         WRITE_DATA(4, GLsizei, n);
    38         for (i = 0 ; i < n ; i++)
    39         {
    40                 WRITE_DATA(i*sizeof(GLuint) + 8, GLuint, SWAP32(fences[i]));
    41         }
    42         crHugePacket(CR_EXTEND_OPCODE, data_ptr);
    43         crPackFree(data_ptr);
     35    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     36    WRITE_DATA(0, GLenum, CR_DELETEFENCESNV_EXTEND_OPCODE);
     37    WRITE_DATA(4, GLsizei, n);
     38    for (i = 0 ; i < n ; i++)
     39    {
     40        WRITE_DATA(i*sizeof(GLuint) + 8, GLuint, SWAP32(fences[i]));
     41    }
     42    crHugePacket(CR_EXTEND_OPCODE, data_ptr);
     43    crPackFree(data_ptr);
    4444}
    4545

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_fog.c

    r15532 r33457  
    1010static GLboolean __handleFogData( GLenum pname, const GLfloat *params )
    1111{
    12         GET_PACKER_CONTEXT(pc);
    13         int params_length = 0;
    14         int packet_length = sizeof( int ) + sizeof( pname );
    15         unsigned char *data_ptr;
    16         switch( pname )
    17         {
    18                 case GL_FOG_MODE:
    19                 case GL_FOG_DENSITY:
    20                 case GL_FOG_START:
    21                 case GL_FOG_END:
    22                 case GL_FOG_INDEX:
    23                         params_length = sizeof( *params );
    24                         break;
    25                 case GL_FOG_COLOR:
    26                         params_length = 4*sizeof( *params );
    27                         break;
    28                 default:
    29                         params_length = __packFogParamsLength( pname );
    30                         if (!params_length)
    31                         {
    32                                 char msg[100];
    33                                 sprintf(msg, "Invalid pname in Fog: %d", (int) pname );
    34                                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM, msg);
    35                                 return GL_FALSE;
    36                         }
    37                         break;
    38         }
    39         packet_length += params_length;
     12    GET_PACKER_CONTEXT(pc);
     13    int params_length = 0;
     14    int packet_length = sizeof( int ) + sizeof( pname );
     15    unsigned char *data_ptr;
     16    switch( pname )
     17    {
     18        case GL_FOG_MODE:
     19        case GL_FOG_DENSITY:
     20        case GL_FOG_START:
     21        case GL_FOG_END:
     22        case GL_FOG_INDEX:
     23            params_length = sizeof( *params );
     24            break;
     25        case GL_FOG_COLOR:
     26            params_length = 4*sizeof( *params );
     27            break;
     28        default:
     29            params_length = __packFogParamsLength( pname );
     30            if (!params_length)
     31            {
     32                char msg[100];
     33                sprintf(msg, "Invalid pname in Fog: %d", (int) pname );
     34                __PackError( __LINE__, __FILE__, GL_INVALID_ENUM, msg);
     35                return GL_FALSE;
     36            }
     37            break;
     38    }
     39    packet_length += params_length;
    4040
    41         GET_BUFFERED_POINTER(pc, packet_length );
    42         WRITE_DATA( 0, int, packet_length );
    43         WRITE_DATA( 4, GLenum, pname );
    44         WRITE_DATA( 8, GLfloat, params[0] );
    45         if (packet_length > 12)
    46         {
    47                 WRITE_DATA( 12, GLfloat, params[1] );
    48                 WRITE_DATA( 16, GLfloat, params[2] );
    49                 WRITE_DATA( 20, GLfloat, params[3] );
    50         }
    51         return GL_TRUE;
     41    GET_BUFFERED_POINTER(pc, packet_length );
     42    WRITE_DATA( 0, int, packet_length );
     43    WRITE_DATA( 4, GLenum, pname );
     44    WRITE_DATA( 8, GLfloat, params[0] );
     45    if (packet_length > 12)
     46    {
     47        WRITE_DATA( 12, GLfloat, params[1] );
     48        WRITE_DATA( 16, GLfloat, params[2] );
     49        WRITE_DATA( 20, GLfloat, params[3] );
     50    }
     51    return GL_TRUE;
    5252}
    5353
    5454void PACK_APIENTRY crPackFogfv(GLenum pname, const GLfloat *params)
    5555{
    56         GET_PACKER_CONTEXT(pc);
    57         if (__handleFogData( pname, params ))
    58                 WRITE_OPCODE( pc, CR_FOGFV_OPCODE );
     56    GET_PACKER_CONTEXT(pc);
     57    if (__handleFogData( pname, params ))
     58        WRITE_OPCODE( pc, CR_FOGFV_OPCODE );
    5959}
    6060
    6161void PACK_APIENTRY crPackFogiv(GLenum pname, const GLint *params)
    6262{
    63         GET_PACKER_CONTEXT(pc);
    64         /* floats and ints are the same size, so the packing should be the same */
    65         if (__handleFogData( pname, (const GLfloat *) params ))
    66                 WRITE_OPCODE( pc, CR_FOGIV_OPCODE );
     63    GET_PACKER_CONTEXT(pc);
     64    /* floats and ints are the same size, so the packing should be the same */
     65    if (__handleFogData( pname, (const GLfloat *) params ))
     66        WRITE_OPCODE( pc, CR_FOGIV_OPCODE );
    6767}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_lights.c

    r15532 r33457  
    1010static GLboolean __handleLightData( GLenum light, GLenum pname, const GLfloat *params )
    1111{
    12         GET_PACKER_CONTEXT(pc);
    13         unsigned int packet_length = sizeof( int ) + sizeof( light ) + sizeof( pname );
    14         unsigned int params_length = 0;
    15         unsigned char *data_ptr;
    16         switch( pname )
    17         {
    18                 case GL_AMBIENT:
    19                 case GL_DIFFUSE:
    20                 case GL_SPECULAR:
    21                 case GL_POSITION:
    22                         params_length = 4*sizeof( *params );
    23                         break;
    24                 case GL_SPOT_DIRECTION:
    25                         params_length = 3*sizeof( *params );
    26                         break;
    27                 case GL_SPOT_EXPONENT:
    28                 case GL_SPOT_CUTOFF:
    29                 case GL_CONSTANT_ATTENUATION:
    30                 case GL_LINEAR_ATTENUATION:
    31                 case GL_QUADRATIC_ATTENUATION:
    32                         params_length = sizeof( *params );
    33                         break;
    34                 default:
    35                         __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    36                                                                         "crPackLight(bad pname)" );
    37                         return GL_FALSE;
    38         }
    39         packet_length += params_length;
    40         GET_BUFFERED_POINTER(pc, packet_length );
    41         WRITE_DATA( 0, int, packet_length );
    42         WRITE_DATA( sizeof( int ) + 0, GLenum, light );
    43         WRITE_DATA( sizeof( int ) + 4, GLenum, pname );
    44         WRITE_DATA( sizeof( int ) + 8, GLfloat, params[0] );
    45         if (params_length > sizeof( *params ))
    46         {
    47                 WRITE_DATA( sizeof( int ) + 12, GLfloat, params[1] );
    48                 WRITE_DATA( sizeof( int ) + 16, GLfloat, params[2] );
    49         }
    50         if (params_length > 3*sizeof( *params ))
    51         {
    52                 WRITE_DATA( sizeof( int ) + 20, GLfloat, params[3] );
    53         }
    54         return GL_TRUE;
     12    GET_PACKER_CONTEXT(pc);
     13    unsigned int packet_length = sizeof( int ) + sizeof( light ) + sizeof( pname );
     14    unsigned int params_length = 0;
     15    unsigned char *data_ptr;
     16    switch( pname )
     17    {
     18        case GL_AMBIENT:
     19        case GL_DIFFUSE:
     20        case GL_SPECULAR:
     21        case GL_POSITION:
     22            params_length = 4*sizeof( *params );
     23            break;
     24        case GL_SPOT_DIRECTION:
     25            params_length = 3*sizeof( *params );
     26            break;
     27        case GL_SPOT_EXPONENT:
     28        case GL_SPOT_CUTOFF:
     29        case GL_CONSTANT_ATTENUATION:
     30        case GL_LINEAR_ATTENUATION:
     31        case GL_QUADRATIC_ATTENUATION:
     32            params_length = sizeof( *params );
     33            break;
     34        default:
     35            __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     36                                    "crPackLight(bad pname)" );
     37            return GL_FALSE;
     38    }
     39    packet_length += params_length;
     40    GET_BUFFERED_POINTER(pc, packet_length );
     41    WRITE_DATA( 0, int, packet_length );
     42    WRITE_DATA( sizeof( int ) + 0, GLenum, light );
     43    WRITE_DATA( sizeof( int ) + 4, GLenum, pname );
     44    WRITE_DATA( sizeof( int ) + 8, GLfloat, params[0] );
     45    if (params_length > sizeof( *params ))
     46    {
     47        WRITE_DATA( sizeof( int ) + 12, GLfloat, params[1] );
     48        WRITE_DATA( sizeof( int ) + 16, GLfloat, params[2] );
     49    }
     50    if (params_length > 3*sizeof( *params ))
     51    {
     52        WRITE_DATA( sizeof( int ) + 20, GLfloat, params[3] );
     53    }
     54    return GL_TRUE;
    5555}
    5656
    5757void PACK_APIENTRY crPackLightfv (GLenum light, GLenum pname, const GLfloat *params)
    5858{
    59         GET_PACKER_CONTEXT(pc);
    60         if (__handleLightData( light, pname, params ))
    61                 WRITE_OPCODE( pc, CR_LIGHTFV_OPCODE );
     59    GET_PACKER_CONTEXT(pc);
     60    if (__handleLightData( light, pname, params ))
     61        WRITE_OPCODE( pc, CR_LIGHTFV_OPCODE );
    6262}
    6363
    6464void PACK_APIENTRY crPackLightiv (GLenum light, GLenum pname, const GLint *params)
    6565{
    66         /* floats and ints are the same size, so the packing should be the same */
    67         GET_PACKER_CONTEXT(pc);
    68         if (__handleLightData( light, pname, (const GLfloat *) params ))
    69                 WRITE_OPCODE( pc, CR_LIGHTIV_OPCODE );
     66    /* floats and ints are the same size, so the packing should be the same */
     67    GET_PACKER_CONTEXT(pc);
     68    if (__handleLightData( light, pname, (const GLfloat *) params ))
     69        WRITE_OPCODE( pc, CR_LIGHTIV_OPCODE );
    7070}
    7171
    7272static GLboolean __handleLightModelData( GLenum pname, const GLfloat *params )
    7373{
    74         GET_PACKER_CONTEXT(pc);
    75         unsigned int packet_length = sizeof( int ) + sizeof( pname );
    76         unsigned int params_length = 0;
    77         unsigned char *data_ptr;
    78         switch( pname )
    79         {
    80                 case GL_LIGHT_MODEL_AMBIENT:
    81                         params_length = 4*sizeof( *params );
    82                         break;
    83                 case GL_LIGHT_MODEL_TWO_SIDE:
    84                 case GL_LIGHT_MODEL_LOCAL_VIEWER:
    85                         params_length = sizeof( *params );
    86                         break;
    87                 default:
    88                         __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    89                                                                         "crPackLightModel(bad pname)" );
    90                         return GL_FALSE;
    91         }
    92         packet_length += params_length;
    93         GET_BUFFERED_POINTER(pc, packet_length );
    94         WRITE_DATA( 0, int, packet_length );
    95         WRITE_DATA( sizeof( int ) + 0, GLenum, pname );
    96         WRITE_DATA( sizeof( int ) + 4, GLfloat, params[0] );
    97         if (params_length > sizeof( *params ))
    98         {
    99                 WRITE_DATA( sizeof( int ) + 8, GLfloat, params[1] );
    100                 WRITE_DATA( sizeof( int ) + 12, GLfloat, params[2] );
    101                 WRITE_DATA( sizeof( int ) + 16, GLfloat, params[3] );
    102         }
    103         return GL_TRUE;
     74    GET_PACKER_CONTEXT(pc);
     75    unsigned int packet_length = sizeof( int ) + sizeof( pname );
     76    unsigned int params_length = 0;
     77    unsigned char *data_ptr;
     78    switch( pname )
     79    {
     80        case GL_LIGHT_MODEL_AMBIENT:
     81            params_length = 4*sizeof( *params );
     82            break;
     83        case GL_LIGHT_MODEL_TWO_SIDE:
     84        case GL_LIGHT_MODEL_LOCAL_VIEWER:
     85            params_length = sizeof( *params );
     86            break;
     87        default:
     88            __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     89                                    "crPackLightModel(bad pname)" );
     90            return GL_FALSE;
     91    }
     92    packet_length += params_length;
     93    GET_BUFFERED_POINTER(pc, packet_length );
     94    WRITE_DATA( 0, int, packet_length );
     95    WRITE_DATA( sizeof( int ) + 0, GLenum, pname );
     96    WRITE_DATA( sizeof( int ) + 4, GLfloat, params[0] );
     97    if (params_length > sizeof( *params ))
     98    {
     99        WRITE_DATA( sizeof( int ) + 8, GLfloat, params[1] );
     100        WRITE_DATA( sizeof( int ) + 12, GLfloat, params[2] );
     101        WRITE_DATA( sizeof( int ) + 16, GLfloat, params[3] );
     102    }
     103    return GL_TRUE;
    104104}
    105105
    106106void PACK_APIENTRY crPackLightModelfv (GLenum pname, const GLfloat *params)
    107107{
    108         GET_PACKER_CONTEXT(pc);
    109         if (__handleLightModelData( pname, params ))
    110                 WRITE_OPCODE( pc, CR_LIGHTMODELFV_OPCODE );
     108    GET_PACKER_CONTEXT(pc);
     109    if (__handleLightModelData( pname, params ))
     110        WRITE_OPCODE( pc, CR_LIGHTMODELFV_OPCODE );
    111111}
    112112
    113113void PACK_APIENTRY crPackLightModeliv (GLenum pname, const GLint *params)
    114114{
    115         /* floats and ints are the same size, so the packing should be the same */
    116         GET_PACKER_CONTEXT(pc);
    117         if (__handleLightModelData( pname, (const GLfloat *) params ))
    118                 WRITE_OPCODE( pc, CR_LIGHTMODELIV_OPCODE );
     115    /* floats and ints are the same size, so the packing should be the same */
     116    GET_PACKER_CONTEXT(pc);
     117    if (__handleLightModelData( pname, (const GLfloat *) params ))
     118        WRITE_OPCODE( pc, CR_LIGHTMODELIV_OPCODE );
    119119}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_lists.c

    r15532 r33457  
    1111static int __gl_CallListsNumBytes( GLenum type )
    1212{
    13         switch( type )
    14         {
    15                 case GL_BYTE:
    16                 case GL_UNSIGNED_BYTE:
    17                 case GL_2_BYTES:
    18                         return 1;
    19                 case GL_SHORT:
    20                 case GL_UNSIGNED_SHORT:
    21                 case GL_3_BYTES:
    22                         return 2;
    23                 case GL_INT:
    24                 case GL_UNSIGNED_INT:
    25                 case GL_FLOAT:
    26                 case GL_4_BYTES:
    27                         return 4;
    28                 default:
    29                         return -1;
    30         }
     13    switch( type )
     14    {
     15        case GL_BYTE:
     16        case GL_UNSIGNED_BYTE:
     17        case GL_2_BYTES:
     18            return 1;
     19        case GL_SHORT:
     20        case GL_UNSIGNED_SHORT:
     21        case GL_3_BYTES:
     22            return 2;
     23        case GL_INT:
     24        case GL_UNSIGNED_INT:
     25        case GL_FLOAT:
     26        case GL_4_BYTES:
     27            return 4;
     28        default:
     29            return -1;
     30    }
    3131}
    3232
    3333void PACK_APIENTRY crPackCallLists(GLint n, GLenum type,
    34                 const GLvoid *lists )
     34        const GLvoid *lists )
    3535{
    36         unsigned char *data_ptr;
    37         int packet_length;
     36    unsigned char *data_ptr;
     37    int packet_length;
    3838
    39         int num_bytes = __gl_CallListsNumBytes( type ) * n;
    40         if (num_bytes < 0)
    41         {
    42                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    43                                                                 "crPackCallLists(bad type)" );
    44                 return;
    45         }
     39    int num_bytes = __gl_CallListsNumBytes( type ) * n;
     40    if (num_bytes < 0)
     41    {
     42        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     43                                "crPackCallLists(bad type)" );
     44        return;
     45    }
    4646
    47         packet_length =
    48                 sizeof( n ) +
    49                 sizeof( type ) +
    50                 num_bytes;
     47    packet_length =
     48        sizeof( n ) +
     49        sizeof( type ) +
     50        num_bytes;
    5151
    52         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    53         WRITE_DATA( 0, GLint, n );
    54         WRITE_DATA( 4, GLenum, type );
    55         crMemcpy( data_ptr + 8, lists, num_bytes );
     52    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     53    WRITE_DATA( 0, GLint, n );
     54    WRITE_DATA( 4, GLenum, type );
     55    crMemcpy( data_ptr + 8, lists, num_bytes );
    5656
    57         crHugePacket( CR_CALLLISTS_OPCODE, data_ptr );
     57    crHugePacket( CR_CALLLISTS_OPCODE, data_ptr );
    5858    crPackFree( data_ptr );
    5959}
    … …  
    6363void PACK_APIENTRY crPackNewList( GLuint list, GLenum mode )
    6464{
    65         GET_PACKER_CONTEXT(pc);
    66         unsigned char *data_ptr;
    67         (void) pc;
    68         GET_BUFFERED_POINTER( pc, 16 );
    69         WRITE_DATA( 0, GLint, 16 );
    70         WRITE_DATA( 4, GLenum, CR_NEWLIST_EXTEND_OPCODE );
    71         WRITE_DATA( 8, GLuint, list );
    72         WRITE_DATA( 12, GLenum, mode );
    73         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    74         pc->buffer.in_List = GL_TRUE;
    75         pc->buffer.holds_List = GL_TRUE;
     65    GET_PACKER_CONTEXT(pc);
     66    unsigned char *data_ptr;
     67    (void) pc;
     68    GET_BUFFERED_POINTER( pc, 16 );
     69    WRITE_DATA( 0, GLint, 16 );
     70    WRITE_DATA( 4, GLenum, CR_NEWLIST_EXTEND_OPCODE );
     71    WRITE_DATA( 8, GLuint, list );
     72    WRITE_DATA( 12, GLenum, mode );
     73    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     74    pc->buffer.in_List = GL_TRUE;
     75    pc->buffer.holds_List = GL_TRUE;
    7676}
    7777
    7878void PACK_APIENTRY crPackEndList( void )
    7979{
    80         GET_PACKER_CONTEXT(pc);
    81         unsigned char *data_ptr;
    82         GET_BUFFERED_POINTER( pc, 8 );
    83         WRITE_DATA( 0, GLint, 8 );
    84         WRITE_DATA( 4, GLenum, CR_ENDLIST_EXTEND_OPCODE );
    85         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    86         pc->buffer.in_List = GL_FALSE;
     80    GET_PACKER_CONTEXT(pc);
     81    unsigned char *data_ptr;
     82    GET_BUFFERED_POINTER( pc, 8 );
     83    WRITE_DATA( 0, GLint, 8 );
     84    WRITE_DATA( 4, GLenum, CR_ENDLIST_EXTEND_OPCODE );
     85    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     86    pc->buffer.in_List = GL_FALSE;
    8787}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_map.c

    r15532 r33457  
    1616static int __gl_Map2NumComponents( GLenum target )
    1717{
    18         switch( target )
    19         {
    20         case GL_MAP2_VERTEX_3:
    21         case GL_MAP2_NORMAL:
    22         case GL_MAP2_TEXTURE_COORD_3:
    23                 return 3;
    24         case GL_MAP2_VERTEX_4:
    25         case GL_MAP2_COLOR_4:
    26         case GL_MAP2_TEXTURE_COORD_4:
    27         case GL_MAP1_VERTEX_ATTRIB0_4_NV:
    28         case GL_MAP1_VERTEX_ATTRIB1_4_NV:
    29         case GL_MAP1_VERTEX_ATTRIB2_4_NV:
    30         case GL_MAP1_VERTEX_ATTRIB3_4_NV:
    31         case GL_MAP1_VERTEX_ATTRIB4_4_NV:
    32         case GL_MAP1_VERTEX_ATTRIB5_4_NV:
    33         case GL_MAP1_VERTEX_ATTRIB6_4_NV:
    34         case GL_MAP1_VERTEX_ATTRIB7_4_NV:
    35         case GL_MAP1_VERTEX_ATTRIB8_4_NV:
    36         case GL_MAP1_VERTEX_ATTRIB9_4_NV:
    37         case GL_MAP1_VERTEX_ATTRIB10_4_NV:
    38         case GL_MAP1_VERTEX_ATTRIB11_4_NV:
    39         case GL_MAP1_VERTEX_ATTRIB12_4_NV:
    40         case GL_MAP1_VERTEX_ATTRIB13_4_NV:
    41         case GL_MAP1_VERTEX_ATTRIB14_4_NV:
    42         case GL_MAP1_VERTEX_ATTRIB15_4_NV:
    43         case GL_MAP2_VERTEX_ATTRIB0_4_NV:
    44         case GL_MAP2_VERTEX_ATTRIB1_4_NV:
    45         case GL_MAP2_VERTEX_ATTRIB2_4_NV:
    46         case GL_MAP2_VERTEX_ATTRIB3_4_NV:
    47         case GL_MAP2_VERTEX_ATTRIB4_4_NV:
    48         case GL_MAP2_VERTEX_ATTRIB5_4_NV:
    49         case GL_MAP2_VERTEX_ATTRIB6_4_NV:
    50         case GL_MAP2_VERTEX_ATTRIB7_4_NV:
    51         case GL_MAP2_VERTEX_ATTRIB8_4_NV:
    52         case GL_MAP2_VERTEX_ATTRIB9_4_NV:
    53         case GL_MAP2_VERTEX_ATTRIB10_4_NV:
    54         case GL_MAP2_VERTEX_ATTRIB11_4_NV:
    55         case GL_MAP2_VERTEX_ATTRIB12_4_NV:
    56         case GL_MAP2_VERTEX_ATTRIB13_4_NV:
    57         case GL_MAP2_VERTEX_ATTRIB14_4_NV:
    58         case GL_MAP2_VERTEX_ATTRIB15_4_NV:
    59                 return 4;
    60         case GL_MAP2_INDEX:
    61         case GL_MAP2_TEXTURE_COORD_1:
    62                 return 1;
    63         case GL_MAP2_TEXTURE_COORD_2:
    64                 return 2;
    65         default:
    66                 return -1;
    67         }
     18    switch( target )
     19    {
     20    case GL_MAP2_VERTEX_3:
     21    case GL_MAP2_NORMAL:
     22    case GL_MAP2_TEXTURE_COORD_3:
     23        return 3;
     24    case GL_MAP2_VERTEX_4:
     25    case GL_MAP2_COLOR_4:
     26    case GL_MAP2_TEXTURE_COORD_4:
     27    case GL_MAP1_VERTEX_ATTRIB0_4_NV:
     28    case GL_MAP1_VERTEX_ATTRIB1_4_NV:
     29    case GL_MAP1_VERTEX_ATTRIB2_4_NV:
     30    case GL_MAP1_VERTEX_ATTRIB3_4_NV:
     31    case GL_MAP1_VERTEX_ATTRIB4_4_NV:
     32    case GL_MAP1_VERTEX_ATTRIB5_4_NV:
     33    case GL_MAP1_VERTEX_ATTRIB6_4_NV:
     34    case GL_MAP1_VERTEX_ATTRIB7_4_NV:
     35    case GL_MAP1_VERTEX_ATTRIB8_4_NV:
     36    case GL_MAP1_VERTEX_ATTRIB9_4_NV:
     37    case GL_MAP1_VERTEX_ATTRIB10_4_NV:
     38    case GL_MAP1_VERTEX_ATTRIB11_4_NV:
     39    case GL_MAP1_VERTEX_ATTRIB12_4_NV:
     40    case GL_MAP1_VERTEX_ATTRIB13_4_NV:
     41    case GL_MAP1_VERTEX_ATTRIB14_4_NV:
     42    case GL_MAP1_VERTEX_ATTRIB15_4_NV:
     43    case GL_MAP2_VERTEX_ATTRIB0_4_NV:
     44    case GL_MAP2_VERTEX_ATTRIB1_4_NV:
     45    case GL_MAP2_VERTEX_ATTRIB2_4_NV:
     46    case GL_MAP2_VERTEX_ATTRIB3_4_NV:
     47    case GL_MAP2_VERTEX_ATTRIB4_4_NV:
     48    case GL_MAP2_VERTEX_ATTRIB5_4_NV:
     49    case GL_MAP2_VERTEX_ATTRIB6_4_NV:
     50    case GL_MAP2_VERTEX_ATTRIB7_4_NV:
     51    case GL_MAP2_VERTEX_ATTRIB8_4_NV:
     52    case GL_MAP2_VERTEX_ATTRIB9_4_NV:
     53    case GL_MAP2_VERTEX_ATTRIB10_4_NV:
     54    case GL_MAP2_VERTEX_ATTRIB11_4_NV:
     55    case GL_MAP2_VERTEX_ATTRIB12_4_NV:
     56    case GL_MAP2_VERTEX_ATTRIB13_4_NV:
     57    case GL_MAP2_VERTEX_ATTRIB14_4_NV:
     58    case GL_MAP2_VERTEX_ATTRIB15_4_NV:
     59        return 4;
     60    case GL_MAP2_INDEX:
     61    case GL_MAP2_TEXTURE_COORD_1:
     62        return 1;
     63    case GL_MAP2_TEXTURE_COORD_2:
     64        return 2;
     65    default:
     66        return -1;
     67    }
    6868}
    6969
    7070static int __gl_Map1NumComponents( GLenum target )
    7171{
    72         switch( target )
    73         {
    74         case GL_MAP1_VERTEX_3:
    75         case GL_MAP1_NORMAL:
    76         case GL_MAP1_TEXTURE_COORD_3:
    77                 return 3;
    78         case GL_MAP1_VERTEX_4:
    79         case GL_MAP1_COLOR_4:
    80         case GL_MAP1_TEXTURE_COORD_4:
    81                 return 4;
    82         case GL_MAP1_INDEX:
    83         case GL_MAP1_TEXTURE_COORD_1:
    84                 return 1;
    85         case GL_MAP1_TEXTURE_COORD_2:
    86                 return 2;
    87         default:
    88                 return -1;
    89         }
     72    switch( target )
     73    {
     74    case GL_MAP1_VERTEX_3:
     75    case GL_MAP1_NORMAL:
     76    case GL_MAP1_TEXTURE_COORD_3:
     77        return 3;
     78    case GL_MAP1_VERTEX_4:
     79    case GL_MAP1_COLOR_4:
     80    case GL_MAP1_TEXTURE_COORD_4:
     81        return 4;
     82    case GL_MAP1_INDEX:
     83    case GL_MAP1_TEXTURE_COORD_1:
     84        return 1;
     85    case GL_MAP1_TEXTURE_COORD_2:
     86        return 2;
     87    default:
     88        return -1;
     89    }
    9090}
    9191
    9292void PACK_APIENTRY crPackMap2d(GLenum target, GLdouble u1,
    93                 GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2,
    94                 GLint vstride, GLint vorder, const GLdouble *points)
    95 {
    96         unsigned char *data_ptr;
    97         int u,v;
    98         GLdouble *dest_data, *src_data;
    99         int packet_length =
    100                 sizeof( target ) +
    101                 sizeof( u1 ) +
    102                 sizeof( u2 ) +
    103                 sizeof( uorder ) +
    104                 sizeof( ustride ) +
    105                 sizeof( v1 ) +
    106                 sizeof( v2 ) +
    107                 sizeof( vorder ) +
    108                 sizeof( vstride );
    109 
    110         int num_components = __gl_Map2NumComponents( target );
    111         if (num_components < 0)
    112         {
    113                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    114                                                                 "crPackMap2d(bad target)" );
    115                 return;
    116         }
    117 
    118         packet_length += num_components*uorder*vorder*sizeof( *points );
    119 
    120         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    121 
    122         WRITE_DATA( 0, GLenum, target );
    123         WRITE_DOUBLE( 4, u1 );
    124         WRITE_DOUBLE( 12, u2 );
    125         WRITE_DATA( 20, GLint, num_components );
    126         WRITE_DATA( 24, GLint, uorder );
    127         WRITE_DOUBLE( 28, v1 );
    128         WRITE_DOUBLE( 36, v2 );
    129         WRITE_DATA( 44, GLint, num_components*uorder );
    130         WRITE_DATA( 48, GLint, vorder );
    131 
    132         dest_data = (GLdouble *) (data_ptr + 52);
    133         src_data = (GLdouble *) points;
    134         for (v = 0 ; v < vorder ; v++)
    135         {
    136                 for (u = 0 ; u < uorder ; u++)
    137                 {
    138                         crMemcpy( dest_data, src_data, num_components * sizeof( *points ) );
    139                         dest_data += num_components;
    140                         src_data += ustride;
    141                 }
    142                 src_data += vstride - ustride*uorder;
    143         }
    144 
    145         crHugePacket( CR_MAP2D_OPCODE, data_ptr );
     93        GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2,
     94        GLint vstride, GLint vorder, const GLdouble *points)
     95{
     96    unsigned char *data_ptr;
     97    int u,v;
     98    GLdouble *dest_data, *src_data;
     99    int packet_length =
     100        sizeof( target ) +
     101        sizeof( u1 ) +
     102        sizeof( u2 ) +
     103        sizeof( uorder ) +
     104        sizeof( ustride ) +
     105        sizeof( v1 ) +
     106        sizeof( v2 ) +
     107        sizeof( vorder ) +
     108        sizeof( vstride );
     109
     110    int num_components = __gl_Map2NumComponents( target );
     111    if (num_components < 0)
     112    {
     113        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     114                                "crPackMap2d(bad target)" );
     115        return;
     116    }
     117
     118    packet_length += num_components*uorder*vorder*sizeof( *points );
     119
     120    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     121
     122    WRITE_DATA( 0, GLenum, target );
     123    WRITE_DOUBLE( 4, u1 );
     124    WRITE_DOUBLE( 12, u2 );
     125    WRITE_DATA( 20, GLint, num_components );
     126    WRITE_DATA( 24, GLint, uorder );
     127    WRITE_DOUBLE( 28, v1 );
     128    WRITE_DOUBLE( 36, v2 );
     129    WRITE_DATA( 44, GLint, num_components*uorder );
     130    WRITE_DATA( 48, GLint, vorder );
     131
     132    dest_data = (GLdouble *) (data_ptr + 52);
     133    src_data = (GLdouble *) points;
     134    for (v = 0 ; v < vorder ; v++)
     135    {
     136        for (u = 0 ; u < uorder ; u++)
     137        {
     138            crMemcpy( dest_data, src_data, num_components * sizeof( *points ) );
     139            dest_data += num_components;
     140            src_data += ustride;
     141        }
     142        src_data += vstride - ustride*uorder;
     143    }
     144
     145    crHugePacket( CR_MAP2D_OPCODE, data_ptr );
    146146    crPackFree( data_ptr );
    147147}
    148148
    149149void PACK_APIENTRY crPackMap2f(GLenum target, GLfloat u1,
    150                 GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2,
    151                 GLint vstride, GLint vorder, const GLfloat *points)
    152 {
    153         unsigned char *data_ptr;
    154         int u,v;
    155         GLfloat *dest_data, *src_data;
    156         int packet_length =
    157                 sizeof( target ) +
    158                 sizeof( u1 ) +
    159                 sizeof( u2 ) +
    160                 sizeof( uorder ) +
    161                 sizeof( ustride ) +
    162                 sizeof( v1 ) +
    163                 sizeof( v2 ) +
    164                 sizeof( vorder ) +
    165                 sizeof( vstride );
    166 
    167         int num_components = __gl_Map2NumComponents( target );
    168         if (num_components < 0)
    169         {
    170                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    171                                                                 "crPackMap2f(bad target)" );
    172                 return;
    173         }
    174 
    175         packet_length += num_components*uorder*vorder*sizeof( *points );
    176 
    177         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    178 
    179         WRITE_DATA( 0, GLenum, target );
    180         WRITE_DATA( 4, GLfloat, u1 );
    181         WRITE_DATA( 8, GLfloat, u2 );
    182         WRITE_DATA( 12, GLint, num_components );
    183         WRITE_DATA( 16, GLint, uorder );
    184         WRITE_DATA( 20, GLfloat, v1 );
    185         WRITE_DATA( 24, GLfloat, v2 );
    186         WRITE_DATA( 28, GLint, num_components*uorder );
    187         WRITE_DATA( 32, GLint, vorder );
    188 
    189         dest_data = (GLfloat *) (data_ptr + 36);
    190         src_data = (GLfloat *) points;
    191         for (v = 0 ; v < vorder ; v++)
    192         {
    193                 for (u = 0 ; u < uorder ; u++)
    194                 {
    195                         crMemcpy( dest_data, src_data, num_components * sizeof( *points ) );
    196                         dest_data += num_components;
    197                         src_data += ustride;
    198                 }
    199                 src_data += vstride - ustride*uorder;
    200         }
    201 
    202         crHugePacket( CR_MAP2F_OPCODE, data_ptr );
     150        GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2,
     151        GLint vstride, GLint vorder, const GLfloat *points)
     152{
     153    unsigned char *data_ptr;
     154    int u,v;
     155    GLfloat *dest_data, *src_data;
     156    int packet_length =
     157        sizeof( target ) +
     158        sizeof( u1 ) +
     159        sizeof( u2 ) +
     160        sizeof( uorder ) +
     161        sizeof( ustride ) +
     162        sizeof( v1 ) +
     163        sizeof( v2 ) +
     164        sizeof( vorder ) +
     165        sizeof( vstride );
     166
     167    int num_components = __gl_Map2NumComponents( target );
     168    if (num_components < 0)
     169    {
     170        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     171                                "crPackMap2f(bad target)" );
     172        return;
     173    }
     174
     175    packet_length += num_components*uorder*vorder*sizeof( *points );
     176
     177    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     178
     179    WRITE_DATA( 0, GLenum, target );
     180    WRITE_DATA( 4, GLfloat, u1 );
     181    WRITE_DATA( 8, GLfloat, u2 );
     182    WRITE_DATA( 12, GLint, num_components );
     183    WRITE_DATA( 16, GLint, uorder );
     184    WRITE_DATA( 20, GLfloat, v1 );
     185    WRITE_DATA( 24, GLfloat, v2 );
     186    WRITE_DATA( 28, GLint, num_components*uorder );
     187    WRITE_DATA( 32, GLint, vorder );
     188
     189    dest_data = (GLfloat *) (data_ptr + 36);
     190    src_data = (GLfloat *) points;
     191    for (v = 0 ; v < vorder ; v++)
     192    {
     193        for (u = 0 ; u < uorder ; u++)
     194        {
     195            crMemcpy( dest_data, src_data, num_components * sizeof( *points ) );
     196            dest_data += num_components;
     197            src_data += ustride;
     198        }
     199        src_data += vstride - ustride*uorder;
     200    }
     201
     202    crHugePacket( CR_MAP2F_OPCODE, data_ptr );
    203203    crPackFree( data_ptr );
    204204}
    205205
    206206void PACK_APIENTRY crPackMap1d( GLenum target, GLdouble u1,
    207                 GLdouble u2, GLint stride, GLint order, const GLdouble *points )
    208 {
    209         unsigned char *data_ptr;
    210         int packet_length =
    211                 sizeof( target ) +
    212                 sizeof( u1 ) +
    213                 sizeof( u2 ) +
    214                 sizeof( stride ) +
    215                 sizeof( order );
    216 
    217         int num_components = __gl_Map1NumComponents( target );
    218         GLdouble *src_data, *dest_data;
    219         int u;
    220 
    221         if (num_components < 0)
    222         {
    223                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    224                                                                 "crPackMap1d(bad target)" );
    225                 return;
    226         }
    227 
    228         packet_length += num_components * order * sizeof( *points );
    229 
    230         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    231 
    232         WRITE_DATA( 0, GLenum, target );
    233         WRITE_DOUBLE( 4, u1 );
    234         WRITE_DOUBLE( 12, u2 );
    235         WRITE_DATA( 20, GLint, num_components );
    236         WRITE_DATA( 24, GLint, order );
    237 
    238         dest_data = (GLdouble *) (data_ptr + 28);
    239         src_data = (GLdouble *) points;
    240         for (u = 0 ; u < order ; u++)
    241         {
    242                 crMemcpy( dest_data, src_data, num_components * sizeof( *points ) );
    243                 dest_data += num_components;
    244                 src_data += stride;
    245         }
    246 
    247         crHugePacket( CR_MAP1D_OPCODE, data_ptr );
     207        GLdouble u2, GLint stride, GLint order, const GLdouble *points )
     208{
     209    unsigned char *data_ptr;
     210    int packet_length =
     211        sizeof( target ) +
     212        sizeof( u1 ) +
     213        sizeof( u2 ) +
     214        sizeof( stride ) +
     215        sizeof( order );
     216
     217    int num_components = __gl_Map1NumComponents( target );
     218    GLdouble *src_data, *dest_data;
     219    int u;
     220
     221    if (num_components < 0)
     222    {
     223        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     224                                "crPackMap1d(bad target)" );
     225        return;
     226    }
     227
     228    packet_length += num_components * order * sizeof( *points );
     229
     230    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     231
     232    WRITE_DATA( 0, GLenum, target );
     233    WRITE_DOUBLE( 4, u1 );
     234    WRITE_DOUBLE( 12, u2 );
     235    WRITE_DATA( 20, GLint, num_components );
     236    WRITE_DATA( 24, GLint, order );
     237
     238    dest_data = (GLdouble *) (data_ptr + 28);
     239    src_data = (GLdouble *) points;
     240    for (u = 0 ; u < order ; u++)
     241    {
     242        crMemcpy( dest_data, src_data, num_components * sizeof( *points ) );
     243        dest_data += num_components;
     244        src_data += stride;
     245    }
     246
     247    crHugePacket( CR_MAP1D_OPCODE, data_ptr );
    248248    crPackFree( data_ptr );
    249249}
    250250
    251251void PACK_APIENTRY crPackMap1f( GLenum target, GLfloat u1,
    252                 GLfloat u2, GLint stride, GLint order, const GLfloat *points )
    253 {
    254         unsigned char *data_ptr;
    255         int packet_length =
    256                 sizeof( target ) +
    257                 sizeof( u1 ) +
    258                 sizeof( u2 ) +
    259                 sizeof( stride ) +
    260                 sizeof( order );
    261 
    262         int num_components = __gl_Map1NumComponents( target );
    263         GLfloat *src_data, *dest_data;
    264         int u;
    265 
    266         if (num_components < 0)
    267         {
    268                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    269                                                                 "crPackMap1f(bad target)" );
    270                 return;
    271         }
    272 
    273         packet_length += num_components * order * sizeof( *points );
    274 
    275         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    276 
    277         WRITE_DATA( 0, GLenum, target );
    278         WRITE_DATA( 4, GLfloat, u1 );
    279         WRITE_DATA( 8, GLfloat, u2 );
    280         WRITE_DATA( 12, GLint, num_components );
    281         WRITE_DATA( 16, GLint, order );
    282 
    283         dest_data = (GLfloat *) (data_ptr + 20);
    284         src_data = (GLfloat *) points;
    285         for (u = 0 ; u < order ; u++)
    286         {
    287                 crMemcpy( dest_data, src_data, num_components * sizeof( *points ) );
    288                 dest_data += num_components;
    289                 src_data += stride;
    290         }
    291 
    292         crHugePacket( CR_MAP1F_OPCODE, data_ptr );
    293     crPackFree( data_ptr );
    294 }
     252        GLfloat u2, GLint stride, GLint order, const GLfloat *points )
     253{
     254    unsigned char *data_ptr;
     255    int packet_length =
     256        sizeof( target ) +
     257        sizeof( u1 ) +
     258        sizeof( u2 ) +
     259        sizeof( stride ) +
     260        sizeof( order );
     261
     262    int num_components = __gl_Map1NumComponents( target );
     263    GLfloat *src_data, *dest_data;
     264    int u;
     265
     266    if (num_components < 0)
     267    {
     268        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     269                                "crPackMap1f(bad target)" );
     270        return;
     271    }
     272
     273    packet_length += num_components * order * sizeof( *points );
     274
     275    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     276
     277    WRITE_DATA( 0, GLenum, target );
     278    WRITE_DATA( 4, GLfloat, u1 );
     279    WRITE_DATA( 8, GLfloat, u2 );
     280    WRITE_DATA( 12, GLint, num_components );
     281    WRITE_DATA( 16, GLint, order );
     282
     283    dest_data = (GLfloat *) (data_ptr + 20);
     284    src_data = (GLfloat *) points;
     285    for (u = 0 ; u < order ; u++)
     286    {
     287        crMemcpy( dest_data, src_data, num_components * sizeof( *points ) );
     288        dest_data += num_components;
     289        src_data += stride;
     290    }
     291
     292    crHugePacket( CR_MAP1F_OPCODE, data_ptr );
     293    crPackFree( data_ptr );
     294}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_materials.c

    r15532 r33457  
    1010static void __handleMaterialData( GLenum face, GLenum pname, const GLfloat *params )
    1111{
    12         GET_PACKER_CONTEXT(pc);
    13         unsigned int packet_length = sizeof( int ) + sizeof( face ) + sizeof( pname );
    14         unsigned int params_length = 0;
    15         unsigned char *data_ptr;
    16         switch( pname )
    17         {
    18                 case GL_AMBIENT:
    19                 case GL_DIFFUSE:
    20                 case GL_SPECULAR:
    21                 case GL_EMISSION:
    22                 case GL_AMBIENT_AND_DIFFUSE:
    23                         params_length = 4*sizeof( *params );
    24                         break;
    25                 case GL_COLOR_INDEXES:
    26                         params_length = 3*sizeof( *params );
    27                         break;
    28                 case GL_SHININESS:
    29                         params_length = sizeof( *params );
    30                         break;
    31                 default:
    32                         __PackError(__LINE__, __FILE__, GL_INVALID_ENUM, "glMaterial(pname)");
    33                         return;
    34         }
    35         packet_length += params_length;
     12    GET_PACKER_CONTEXT(pc);
     13    unsigned int packet_length = sizeof( int ) + sizeof( face ) + sizeof( pname );
     14    unsigned int params_length = 0;
     15    unsigned char *data_ptr;
     16    switch( pname )
     17    {
     18        case GL_AMBIENT:
     19        case GL_DIFFUSE:
     20        case GL_SPECULAR:
     21        case GL_EMISSION:
     22        case GL_AMBIENT_AND_DIFFUSE:
     23            params_length = 4*sizeof( *params );
     24            break;
     25        case GL_COLOR_INDEXES:
     26            params_length = 3*sizeof( *params );
     27            break;
     28        case GL_SHININESS:
     29            params_length = sizeof( *params );
     30            break;
     31        default:
     32            __PackError(__LINE__, __FILE__, GL_INVALID_ENUM, "glMaterial(pname)");
     33            return;
     34    }
     35    packet_length += params_length;
    3636
    37         GET_BUFFERED_POINTER(pc, packet_length );
    38         WRITE_DATA( 0, int, packet_length );
    39         WRITE_DATA( sizeof( int ) + 0, GLenum, face );
    40         WRITE_DATA( sizeof( int ) + 4, GLenum, pname );
    41         WRITE_DATA( sizeof( int ) + 8, GLfloat, params[0] );
    42         if (params_length > sizeof( *params ))
    43         {
    44                 WRITE_DATA( sizeof( int ) + 12, GLfloat, params[1] );
    45                 WRITE_DATA( sizeof( int ) + 16, GLfloat, params[2] );
    46         }
    47         if (packet_length > 3*sizeof( *params ) )
    48         {
    49                 WRITE_DATA( sizeof( int ) + 20, GLfloat, params[3] );
    50         }
     37    GET_BUFFERED_POINTER(pc, packet_length );
     38    WRITE_DATA( 0, int, packet_length );
     39    WRITE_DATA( sizeof( int ) + 0, GLenum, face );
     40    WRITE_DATA( sizeof( int ) + 4, GLenum, pname );
     41    WRITE_DATA( sizeof( int ) + 8, GLfloat, params[0] );
     42    if (params_length > sizeof( *params ))
     43    {
     44        WRITE_DATA( sizeof( int ) + 12, GLfloat, params[1] );
     45        WRITE_DATA( sizeof( int ) + 16, GLfloat, params[2] );
     46    }
     47    if (packet_length > 3*sizeof( *params ) )
     48    {
     49        WRITE_DATA( sizeof( int ) + 20, GLfloat, params[3] );
     50    }
    5151}
    5252
    5353void PACK_APIENTRY crPackMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
    5454{
    55         GET_PACKER_CONTEXT(pc);
    56         __handleMaterialData( face, pname, params );
    57         WRITE_OPCODE( pc, CR_MATERIALFV_OPCODE );
     55    GET_PACKER_CONTEXT(pc);
     56    __handleMaterialData( face, pname, params );
     57    WRITE_OPCODE( pc, CR_MATERIALFV_OPCODE );
    5858}
    5959
    6060void PACK_APIENTRY crPackMaterialiv(GLenum face, GLenum pname, const GLint *params)
    6161{
    62         /* floats and ints are the same size, so the packing should be the same */
    63         GET_PACKER_CONTEXT(pc);
    64         __handleMaterialData( face, pname, (const GLfloat *) params );
    65         WRITE_OPCODE( pc, CR_MATERIALIV_OPCODE );
     62    /* floats and ints are the same size, so the packing should be the same */
     63    GET_PACKER_CONTEXT(pc);
     64    __handleMaterialData( face, pname, (const GLfloat *) params );
     65    WRITE_OPCODE( pc, CR_MATERIALIV_OPCODE );
    6666}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_matrices.c

    r15532 r33457  
    1010void PACK_APIENTRY crPackMultMatrixd( const GLdouble *m )
    1111{
    12         GET_PACKER_CONTEXT(pc);
    13         unsigned char *data_ptr;
    14         int packet_length = 16*sizeof( *m );
    15         GET_BUFFERED_POINTER(pc, packet_length );
    16         WRITE_DOUBLE( 0*sizeof(double), m[ 0] );
    17         WRITE_DOUBLE( 1*sizeof(double), m[ 1] );
    18         WRITE_DOUBLE( 2*sizeof(double), m[ 2] );
    19         WRITE_DOUBLE( 3*sizeof(double), m[ 3] );
    20         WRITE_DOUBLE( 4*sizeof(double), m[ 4] );
    21         WRITE_DOUBLE( 5*sizeof(double), m[ 5] );
    22         WRITE_DOUBLE( 6*sizeof(double), m[ 6] );
    23         WRITE_DOUBLE( 7*sizeof(double), m[ 7] );
    24         WRITE_DOUBLE( 8*sizeof(double), m[ 8] );
    25         WRITE_DOUBLE( 9*sizeof(double), m[ 9] );
    26         WRITE_DOUBLE( 10*sizeof(double), m[10] );
    27         WRITE_DOUBLE( 11*sizeof(double), m[11] );
    28         WRITE_DOUBLE( 12*sizeof(double), m[12] );
    29         WRITE_DOUBLE( 13*sizeof(double), m[13] );
    30         WRITE_DOUBLE( 14*sizeof(double), m[14] );
    31         WRITE_DOUBLE( 15*sizeof(double), m[15] );
    32         WRITE_OPCODE( pc, CR_MULTMATRIXD_OPCODE );
     12    GET_PACKER_CONTEXT(pc);
     13    unsigned char *data_ptr;
     14    int packet_length = 16*sizeof( *m );
     15    GET_BUFFERED_POINTER(pc, packet_length );
     16    WRITE_DOUBLE( 0*sizeof(double), m[ 0] );
     17    WRITE_DOUBLE( 1*sizeof(double), m[ 1] );
     18    WRITE_DOUBLE( 2*sizeof(double), m[ 2] );
     19    WRITE_DOUBLE( 3*sizeof(double), m[ 3] );
     20    WRITE_DOUBLE( 4*sizeof(double), m[ 4] );
     21    WRITE_DOUBLE( 5*sizeof(double), m[ 5] );
     22    WRITE_DOUBLE( 6*sizeof(double), m[ 6] );
     23    WRITE_DOUBLE( 7*sizeof(double), m[ 7] );
     24    WRITE_DOUBLE( 8*sizeof(double), m[ 8] );
     25    WRITE_DOUBLE( 9*sizeof(double), m[ 9] );
     26    WRITE_DOUBLE( 10*sizeof(double), m[10] );
     27    WRITE_DOUBLE( 11*sizeof(double), m[11] );
     28    WRITE_DOUBLE( 12*sizeof(double), m[12] );
     29    WRITE_DOUBLE( 13*sizeof(double), m[13] );
     30    WRITE_DOUBLE( 14*sizeof(double), m[14] );
     31    WRITE_DOUBLE( 15*sizeof(double), m[15] );
     32    WRITE_OPCODE( pc, CR_MULTMATRIXD_OPCODE );
    3333}
    3434
    3535void PACK_APIENTRY crPackMultMatrixf( const GLfloat *m )
    3636{
    37         GET_PACKER_CONTEXT(pc);
    38         unsigned char *data_ptr;
    39         int packet_length = 16*sizeof( *m );
    40         GET_BUFFERED_POINTER(pc, packet_length );
    41         WRITE_DATA( 0*sizeof(GLfloat), GLfloat, m[ 0] );
    42         WRITE_DATA( 1*sizeof(GLfloat), GLfloat, m[ 1] );
    43         WRITE_DATA( 2*sizeof(GLfloat), GLfloat, m[ 2] );
    44         WRITE_DATA( 3*sizeof(GLfloat), GLfloat, m[ 3] );
    45         WRITE_DATA( 4*sizeof(GLfloat), GLfloat, m[ 4] );
    46         WRITE_DATA( 5*sizeof(GLfloat), GLfloat, m[ 5] );
    47         WRITE_DATA( 6*sizeof(GLfloat), GLfloat, m[ 6] );
    48         WRITE_DATA( 7*sizeof(GLfloat), GLfloat, m[ 7] );
    49         WRITE_DATA( 8*sizeof(GLfloat), GLfloat, m[ 8] );
    50         WRITE_DATA( 9*sizeof(GLfloat), GLfloat, m[ 9] );
    51         WRITE_DATA( 10*sizeof(GLfloat), GLfloat, m[10] );
    52         WRITE_DATA( 11*sizeof(GLfloat), GLfloat, m[11] );
    53         WRITE_DATA( 12*sizeof(GLfloat), GLfloat, m[12] );
    54         WRITE_DATA( 13*sizeof(GLfloat), GLfloat, m[13] );
    55         WRITE_DATA( 14*sizeof(GLfloat), GLfloat, m[14] );
    56         WRITE_DATA( 15*sizeof(GLfloat), GLfloat, m[15] );
    57         WRITE_OPCODE( pc, CR_MULTMATRIXF_OPCODE );
     37    GET_PACKER_CONTEXT(pc);
     38    unsigned char *data_ptr;
     39    int packet_length = 16*sizeof( *m );
     40    GET_BUFFERED_POINTER(pc, packet_length );
     41    WRITE_DATA( 0*sizeof(GLfloat), GLfloat, m[ 0] );
     42    WRITE_DATA( 1*sizeof(GLfloat), GLfloat, m[ 1] );
     43    WRITE_DATA( 2*sizeof(GLfloat), GLfloat, m[ 2] );
     44    WRITE_DATA( 3*sizeof(GLfloat), GLfloat, m[ 3] );
     45    WRITE_DATA( 4*sizeof(GLfloat), GLfloat, m[ 4] );
     46    WRITE_DATA( 5*sizeof(GLfloat), GLfloat, m[ 5] );
     47    WRITE_DATA( 6*sizeof(GLfloat), GLfloat, m[ 6] );
     48    WRITE_DATA( 7*sizeof(GLfloat), GLfloat, m[ 7] );
     49    WRITE_DATA( 8*sizeof(GLfloat), GLfloat, m[ 8] );
     50    WRITE_DATA( 9*sizeof(GLfloat), GLfloat, m[ 9] );
     51    WRITE_DATA( 10*sizeof(GLfloat), GLfloat, m[10] );
     52    WRITE_DATA( 11*sizeof(GLfloat), GLfloat, m[11] );
     53    WRITE_DATA( 12*sizeof(GLfloat), GLfloat, m[12] );
     54    WRITE_DATA( 13*sizeof(GLfloat), GLfloat, m[13] );
     55    WRITE_DATA( 14*sizeof(GLfloat), GLfloat, m[14] );
     56    WRITE_DATA( 15*sizeof(GLfloat), GLfloat, m[15] );
     57    WRITE_OPCODE( pc, CR_MULTMATRIXF_OPCODE );
    5858}
    5959
    6060void PACK_APIENTRY crPackLoadMatrixd( const GLdouble *m )
    6161{
    62         GET_PACKER_CONTEXT(pc);
    63         unsigned char *data_ptr;
    64         int packet_length = 16*sizeof( *m );
    65         GET_BUFFERED_POINTER(pc, packet_length );
    66         WRITE_DOUBLE( 0*sizeof(double), m[ 0] );
    67         WRITE_DOUBLE( 1*sizeof(double), m[ 1] );
    68         WRITE_DOUBLE( 2*sizeof(double), m[ 2] );
    69         WRITE_DOUBLE( 3*sizeof(double), m[ 3] );
    70         WRITE_DOUBLE( 4*sizeof(double), m[ 4] );
    71         WRITE_DOUBLE( 5*sizeof(double), m[ 5] );
    72         WRITE_DOUBLE( 6*sizeof(double), m[ 6] );
    73         WRITE_DOUBLE( 7*sizeof(double), m[ 7] );
    74         WRITE_DOUBLE( 8*sizeof(double), m[ 8] );
    75         WRITE_DOUBLE( 9*sizeof(double), m[ 9] );
    76         WRITE_DOUBLE( 10*sizeof(double), m[10] );
    77         WRITE_DOUBLE( 11*sizeof(double), m[11] );
    78         WRITE_DOUBLE( 12*sizeof(double), m[12] );
    79         WRITE_DOUBLE( 13*sizeof(double), m[13] );
    80         WRITE_DOUBLE( 14*sizeof(double), m[14] );
    81         WRITE_DOUBLE( 15*sizeof(double), m[15] );
    82         WRITE_OPCODE( pc, CR_LOADMATRIXD_OPCODE );
     62    GET_PACKER_CONTEXT(pc);
     63    unsigned char *data_ptr;
     64    int packet_length = 16*sizeof( *m );
     65    GET_BUFFERED_POINTER(pc, packet_length );
     66    WRITE_DOUBLE( 0*sizeof(double), m[ 0] );
     67    WRITE_DOUBLE( 1*sizeof(double), m[ 1] );
     68    WRITE_DOUBLE( 2*sizeof(double), m[ 2] );
     69    WRITE_DOUBLE( 3*sizeof(double), m[ 3] );
     70    WRITE_DOUBLE( 4*sizeof(double), m[ 4] );
     71    WRITE_DOUBLE( 5*sizeof(double), m[ 5] );
     72    WRITE_DOUBLE( 6*sizeof(double), m[ 6] );
     73    WRITE_DOUBLE( 7*sizeof(double), m[ 7] );
     74    WRITE_DOUBLE( 8*sizeof(double), m[ 8] );
     75    WRITE_DOUBLE( 9*sizeof(double), m[ 9] );
     76    WRITE_DOUBLE( 10*sizeof(double), m[10] );
     77    WRITE_DOUBLE( 11*sizeof(double), m[11] );
     78    WRITE_DOUBLE( 12*sizeof(double), m[12] );
     79    WRITE_DOUBLE( 13*sizeof(double), m[13] );
     80    WRITE_DOUBLE( 14*sizeof(double), m[14] );
     81    WRITE_DOUBLE( 15*sizeof(double), m[15] );
     82    WRITE_OPCODE( pc, CR_LOADMATRIXD_OPCODE );
    8383}
    8484
    8585void PACK_APIENTRY crPackLoadMatrixf( const GLfloat *m )
    8686{
    87         GET_PACKER_CONTEXT(pc);
    88         unsigned char *data_ptr;
    89         int packet_length = 16*sizeof( *m );
    90         GET_BUFFERED_POINTER(pc, packet_length );
    91         WRITE_DATA( 0*sizeof(GLfloat), GLfloat, m[ 0] );
    92         WRITE_DATA( 1*sizeof(GLfloat), GLfloat, m[ 1] );
    93         WRITE_DATA( 2*sizeof(GLfloat), GLfloat, m[ 2] );
    94         WRITE_DATA( 3*sizeof(GLfloat), GLfloat, m[ 3] );
    95         WRITE_DATA( 4*sizeof(GLfloat), GLfloat, m[ 4] );
    96         WRITE_DATA( 5*sizeof(GLfloat), GLfloat, m[ 5] );
    97         WRITE_DATA( 6*sizeof(GLfloat), GLfloat, m[ 6] );
    98         WRITE_DATA( 7*sizeof(GLfloat), GLfloat, m[ 7] );
    99         WRITE_DATA( 8*sizeof(GLfloat), GLfloat, m[ 8] );
    100         WRITE_DATA( 9*sizeof(GLfloat), GLfloat, m[ 9] );
    101         WRITE_DATA( 10*sizeof(GLfloat), GLfloat, m[10] );
    102         WRITE_DATA( 11*sizeof(GLfloat), GLfloat, m[11] );
    103         WRITE_DATA( 12*sizeof(GLfloat), GLfloat, m[12] );
    104         WRITE_DATA( 13*sizeof(GLfloat), GLfloat, m[13] );
    105         WRITE_DATA( 14*sizeof(GLfloat), GLfloat, m[14] );
    106         WRITE_DATA( 15*sizeof(GLfloat), GLfloat, m[15] );
    107         WRITE_OPCODE( pc, CR_LOADMATRIXF_OPCODE );
     87    GET_PACKER_CONTEXT(pc);
     88    unsigned char *data_ptr;
     89    int packet_length = 16*sizeof( *m );
     90    GET_BUFFERED_POINTER(pc, packet_length );
     91    WRITE_DATA( 0*sizeof(GLfloat), GLfloat, m[ 0] );
     92    WRITE_DATA( 1*sizeof(GLfloat), GLfloat, m[ 1] );
     93    WRITE_DATA( 2*sizeof(GLfloat), GLfloat, m[ 2] );
     94    WRITE_DATA( 3*sizeof(GLfloat), GLfloat, m[ 3] );
     95    WRITE_DATA( 4*sizeof(GLfloat), GLfloat, m[ 4] );
     96    WRITE_DATA( 5*sizeof(GLfloat), GLfloat, m[ 5] );
     97    WRITE_DATA( 6*sizeof(GLfloat), GLfloat, m[ 6] );
     98    WRITE_DATA( 7*sizeof(GLfloat), GLfloat, m[ 7] );
     99    WRITE_DATA( 8*sizeof(GLfloat), GLfloat, m[ 8] );
     100    WRITE_DATA( 9*sizeof(GLfloat), GLfloat, m[ 9] );
     101    WRITE_DATA( 10*sizeof(GLfloat), GLfloat, m[10] );
     102    WRITE_DATA( 11*sizeof(GLfloat), GLfloat, m[11] );
     103    WRITE_DATA( 12*sizeof(GLfloat), GLfloat, m[12] );
     104    WRITE_DATA( 13*sizeof(GLfloat), GLfloat, m[13] );
     105    WRITE_DATA( 14*sizeof(GLfloat), GLfloat, m[14] );
     106    WRITE_DATA( 15*sizeof(GLfloat), GLfloat, m[15] );
     107    WRITE_OPCODE( pc, CR_LOADMATRIXF_OPCODE );
    108108}
    109109
    110110void PACK_APIENTRY crPackMultTransposeMatrixdARB( const GLdouble *m )
    111111{
    112         GET_PACKER_CONTEXT(pc);
    113         unsigned char *data_ptr;
    114         int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);
    115         GET_BUFFERED_POINTER(pc, packet_length );
    116         WRITE_DATA( 0, GLint, packet_length );
    117         WRITE_DATA( 4, GLenum, CR_MULTTRANSPOSEMATRIXDARB_EXTEND_OPCODE );
    118         WRITE_DOUBLE( 8 + 0*sizeof(double), m[ 0] );
    119         WRITE_DOUBLE( 8 + 1*sizeof(double), m[ 1] );
    120         WRITE_DOUBLE( 8 + 2*sizeof(double), m[ 2] );
    121         WRITE_DOUBLE( 8 + 3*sizeof(double), m[ 3] );
    122         WRITE_DOUBLE( 8 + 4*sizeof(double), m[ 4] );
    123         WRITE_DOUBLE( 8 + 5*sizeof(double), m[ 5] );
    124         WRITE_DOUBLE( 8 + 6*sizeof(double), m[ 6] );
    125         WRITE_DOUBLE( 8 + 7*sizeof(double), m[ 7] );
    126         WRITE_DOUBLE( 8 + 8*sizeof(double), m[ 8] );
    127         WRITE_DOUBLE( 8 + 9*sizeof(double), m[ 9] );
    128         WRITE_DOUBLE( 8 + 10*sizeof(double), m[10] );
    129         WRITE_DOUBLE( 8 + 11*sizeof(double), m[11] );
    130         WRITE_DOUBLE( 8 + 12*sizeof(double), m[12] );
    131         WRITE_DOUBLE( 8 + 13*sizeof(double), m[13] );
    132         WRITE_DOUBLE( 8 + 14*sizeof(double), m[14] );
    133         WRITE_DOUBLE( 8 + 15*sizeof(double), m[15] );
    134         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     112    GET_PACKER_CONTEXT(pc);
     113    unsigned char *data_ptr;
     114    int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);
     115    GET_BUFFERED_POINTER(pc, packet_length );
     116    WRITE_DATA( 0, GLint, packet_length );
     117    WRITE_DATA( 4, GLenum, CR_MULTTRANSPOSEMATRIXDARB_EXTEND_OPCODE );
     118    WRITE_DOUBLE( 8 + 0*sizeof(double), m[ 0] );
     119    WRITE_DOUBLE( 8 + 1*sizeof(double), m[ 1] );
     120    WRITE_DOUBLE( 8 + 2*sizeof(double), m[ 2] );
     121    WRITE_DOUBLE( 8 + 3*sizeof(double), m[ 3] );
     122    WRITE_DOUBLE( 8 + 4*sizeof(double), m[ 4] );
     123    WRITE_DOUBLE( 8 + 5*sizeof(double), m[ 5] );
     124    WRITE_DOUBLE( 8 + 6*sizeof(double), m[ 6] );
     125    WRITE_DOUBLE( 8 + 7*sizeof(double), m[ 7] );
     126    WRITE_DOUBLE( 8 + 8*sizeof(double), m[ 8] );
     127    WRITE_DOUBLE( 8 + 9*sizeof(double), m[ 9] );
     128    WRITE_DOUBLE( 8 + 10*sizeof(double), m[10] );
     129    WRITE_DOUBLE( 8 + 11*sizeof(double), m[11] );
     130    WRITE_DOUBLE( 8 + 12*sizeof(double), m[12] );
     131    WRITE_DOUBLE( 8 + 13*sizeof(double), m[13] );
     132    WRITE_DOUBLE( 8 + 14*sizeof(double), m[14] );
     133    WRITE_DOUBLE( 8 + 15*sizeof(double), m[15] );
     134    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    135135}
    136136
    137137void PACK_APIENTRY crPackMultTransposeMatrixfARB( const GLfloat *m )
    138138{
    139         GET_PACKER_CONTEXT(pc);
    140         unsigned char *data_ptr;
    141         int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);
    142         GET_BUFFERED_POINTER(pc, packet_length );
    143         WRITE_DATA( 0, GLint, packet_length );
    144         WRITE_DATA( 4, GLenum, CR_MULTTRANSPOSEMATRIXFARB_EXTEND_OPCODE );
    145         WRITE_DATA( 8 + 0*sizeof(GLfloat), GLfloat, m[ 0] );
    146         WRITE_DATA( 8 + 1*sizeof(GLfloat), GLfloat, m[ 1] );
    147         WRITE_DATA( 8 + 2*sizeof(GLfloat), GLfloat, m[ 2] );
    148         WRITE_DATA( 8 + 3*sizeof(GLfloat), GLfloat, m[ 3] );
    149         WRITE_DATA( 8 + 4*sizeof(GLfloat), GLfloat, m[ 4] );
    150         WRITE_DATA( 8 + 5*sizeof(GLfloat), GLfloat, m[ 5] );
    151         WRITE_DATA( 8 + 6*sizeof(GLfloat), GLfloat, m[ 6] );
    152         WRITE_DATA( 8 + 7*sizeof(GLfloat), GLfloat, m[ 7] );
    153         WRITE_DATA( 8 + 8*sizeof(GLfloat), GLfloat, m[ 8] );
    154         WRITE_DATA( 8 + 9*sizeof(GLfloat), GLfloat, m[ 9] );
    155         WRITE_DATA( 8 + 10*sizeof(GLfloat), GLfloat, m[10] );
    156         WRITE_DATA( 8 + 11*sizeof(GLfloat), GLfloat, m[11] );
    157         WRITE_DATA( 8 + 12*sizeof(GLfloat), GLfloat, m[12] );
    158         WRITE_DATA( 8 + 13*sizeof(GLfloat), GLfloat, m[13] );
    159         WRITE_DATA( 8 + 14*sizeof(GLfloat), GLfloat, m[14] );
    160         WRITE_DATA( 8 + 15*sizeof(GLfloat), GLfloat, m[15] );
    161         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     139    GET_PACKER_CONTEXT(pc);
     140    unsigned char *data_ptr;
     141    int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);
     142    GET_BUFFERED_POINTER(pc, packet_length );
     143    WRITE_DATA( 0, GLint, packet_length );
     144    WRITE_DATA( 4, GLenum, CR_MULTTRANSPOSEMATRIXFARB_EXTEND_OPCODE );
     145    WRITE_DATA( 8 + 0*sizeof(GLfloat), GLfloat, m[ 0] );
     146    WRITE_DATA( 8 + 1*sizeof(GLfloat), GLfloat, m[ 1] );
     147    WRITE_DATA( 8 + 2*sizeof(GLfloat), GLfloat, m[ 2] );
     148    WRITE_DATA( 8 + 3*sizeof(GLfloat), GLfloat, m[ 3] );
     149    WRITE_DATA( 8 + 4*sizeof(GLfloat), GLfloat, m[ 4] );
     150    WRITE_DATA( 8 + 5*sizeof(GLfloat), GLfloat, m[ 5] );
     151    WRITE_DATA( 8 + 6*sizeof(GLfloat), GLfloat, m[ 6] );
     152    WRITE_DATA( 8 + 7*sizeof(GLfloat), GLfloat, m[ 7] );
     153    WRITE_DATA( 8 + 8*sizeof(GLfloat), GLfloat, m[ 8] );
     154    WRITE_DATA( 8 + 9*sizeof(GLfloat), GLfloat, m[ 9] );
     155    WRITE_DATA( 8 + 10*sizeof(GLfloat), GLfloat, m[10] );
     156    WRITE_DATA( 8 + 11*sizeof(GLfloat), GLfloat, m[11] );
     157    WRITE_DATA( 8 + 12*sizeof(GLfloat), GLfloat, m[12] );
     158    WRITE_DATA( 8 + 13*sizeof(GLfloat), GLfloat, m[13] );
     159    WRITE_DATA( 8 + 14*sizeof(GLfloat), GLfloat, m[14] );
     160    WRITE_DATA( 8 + 15*sizeof(GLfloat), GLfloat, m[15] );
     161    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    162162}
    163163
    164164void PACK_APIENTRY crPackLoadTransposeMatrixdARB( const GLdouble *m )
    165165{
    166         GET_PACKER_CONTEXT(pc);
    167         unsigned char *data_ptr;
    168         int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);
    169         GET_BUFFERED_POINTER(pc, packet_length );
    170         WRITE_DATA( 0, GLint, packet_length );
    171         WRITE_DATA( 4, GLenum, CR_LOADTRANSPOSEMATRIXDARB_EXTEND_OPCODE );
    172         WRITE_DOUBLE( 8 + 0*sizeof(double), m[ 0] );
    173         WRITE_DOUBLE( 8 + 1*sizeof(double), m[ 1] );
    174         WRITE_DOUBLE( 8 + 2*sizeof(double), m[ 2] );
    175         WRITE_DOUBLE( 8 + 3*sizeof(double), m[ 3] );
    176         WRITE_DOUBLE( 8 + 4*sizeof(double), m[ 4] );
    177         WRITE_DOUBLE( 8 + 5*sizeof(double), m[ 5] );
    178         WRITE_DOUBLE( 8 + 6*sizeof(double), m[ 6] );
    179         WRITE_DOUBLE( 8 + 7*sizeof(double), m[ 7] );
    180         WRITE_DOUBLE( 8 + 8*sizeof(double), m[ 8] );
    181         WRITE_DOUBLE( 8 + 9*sizeof(double), m[ 9] );
    182         WRITE_DOUBLE( 8 + 10*sizeof(double), m[10] );
    183         WRITE_DOUBLE( 8 + 11*sizeof(double), m[11] );
    184         WRITE_DOUBLE( 8 + 12*sizeof(double), m[12] );
    185         WRITE_DOUBLE( 8 + 13*sizeof(double), m[13] );
    186         WRITE_DOUBLE( 8 + 14*sizeof(double), m[14] );
    187         WRITE_DOUBLE( 8 + 15*sizeof(double), m[15] );
    188         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     166    GET_PACKER_CONTEXT(pc);
     167    unsigned char *data_ptr;
     168    int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);
     169    GET_BUFFERED_POINTER(pc, packet_length );
     170    WRITE_DATA( 0, GLint, packet_length );
     171    WRITE_DATA( 4, GLenum, CR_LOADTRANSPOSEMATRIXDARB_EXTEND_OPCODE );
     172    WRITE_DOUBLE( 8 + 0*sizeof(double), m[ 0] );
     173    WRITE_DOUBLE( 8 + 1*sizeof(double), m[ 1] );
     174    WRITE_DOUBLE( 8 + 2*sizeof(double), m[ 2] );
     175    WRITE_DOUBLE( 8 + 3*sizeof(double), m[ 3] );
     176    WRITE_DOUBLE( 8 + 4*sizeof(double), m[ 4] );
     177    WRITE_DOUBLE( 8 + 5*sizeof(double), m[ 5] );
     178    WRITE_DOUBLE( 8 + 6*sizeof(double), m[ 6] );
     179    WRITE_DOUBLE( 8 + 7*sizeof(double), m[ 7] );
     180    WRITE_DOUBLE( 8 + 8*sizeof(double), m[ 8] );
     181    WRITE_DOUBLE( 8 + 9*sizeof(double), m[ 9] );
     182    WRITE_DOUBLE( 8 + 10*sizeof(double), m[10] );
     183    WRITE_DOUBLE( 8 + 11*sizeof(double), m[11] );
     184    WRITE_DOUBLE( 8 + 12*sizeof(double), m[12] );
     185    WRITE_DOUBLE( 8 + 13*sizeof(double), m[13] );
     186    WRITE_DOUBLE( 8 + 14*sizeof(double), m[14] );
     187    WRITE_DOUBLE( 8 + 15*sizeof(double), m[15] );
     188    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    189189}
    190190
    191191void PACK_APIENTRY crPackLoadTransposeMatrixfARB( const GLfloat *m )
    192192{
    193         GET_PACKER_CONTEXT(pc);
    194         unsigned char *data_ptr;
    195         int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);
    196         GET_BUFFERED_POINTER(pc, packet_length );
    197         WRITE_DATA( 0, GLint, packet_length );
    198         WRITE_DATA( 4, GLenum, CR_LOADTRANSPOSEMATRIXFARB_EXTEND_OPCODE );
    199         WRITE_DATA( 8 + 0*sizeof(GLfloat), GLfloat, m[ 0] );
    200         WRITE_DATA( 8 + 1*sizeof(GLfloat), GLfloat, m[ 1] );
    201         WRITE_DATA( 8 + 2*sizeof(GLfloat), GLfloat, m[ 2] );
    202         WRITE_DATA( 8 + 3*sizeof(GLfloat), GLfloat, m[ 3] );
    203         WRITE_DATA( 8 + 4*sizeof(GLfloat), GLfloat, m[ 4] );
    204         WRITE_DATA( 8 + 5*sizeof(GLfloat), GLfloat, m[ 5] );
    205         WRITE_DATA( 8 + 6*sizeof(GLfloat), GLfloat, m[ 6] );
    206         WRITE_DATA( 8 + 7*sizeof(GLfloat), GLfloat, m[ 7] );
    207         WRITE_DATA( 8 + 8*sizeof(GLfloat), GLfloat, m[ 8] );
    208         WRITE_DATA( 8 + 9*sizeof(GLfloat), GLfloat, m[ 9] );
    209         WRITE_DATA( 8 + 10*sizeof(GLfloat), GLfloat, m[10] );
    210         WRITE_DATA( 8 + 11*sizeof(GLfloat), GLfloat, m[11] );
    211         WRITE_DATA( 8 + 12*sizeof(GLfloat), GLfloat, m[12] );
    212         WRITE_DATA( 8 + 13*sizeof(GLfloat), GLfloat, m[13] );
    213         WRITE_DATA( 8 + 14*sizeof(GLfloat), GLfloat, m[14] );
    214         WRITE_DATA( 8 + 15*sizeof(GLfloat), GLfloat, m[15] );
    215         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    216 }
     193    GET_PACKER_CONTEXT(pc);
     194    unsigned char *data_ptr;
     195    int packet_length = 16*sizeof( *m ) + sizeof(GLint) + sizeof(GLenum);
     196    GET_BUFFERED_POINTER(pc, packet_length );
     197    WRITE_DATA( 0, GLint, packet_length );
     198    WRITE_DATA( 4, GLenum, CR_LOADTRANSPOSEMATRIXFARB_EXTEND_OPCODE );
     199    WRITE_DATA( 8 + 0*sizeof(GLfloat), GLfloat, m[ 0] );
     200    WRITE_DATA( 8 + 1*sizeof(GLfloat), GLfloat, m[ 1] );
     201    WRITE_DATA( 8 + 2*sizeof(GLfloat), GLfloat, m[ 2] );
     202    WRITE_DATA( 8 + 3*sizeof(GLfloat), GLfloat, m[ 3] );
     203    WRITE_DATA( 8 + 4*sizeof(GLfloat), GLfloat, m[ 4] );
     204    WRITE_DATA( 8 + 5*sizeof(GLfloat), GLfloat, m[ 5] );
     205    WRITE_DATA( 8 + 6*sizeof(GLfloat), GLfloat, m[ 6] );
     206    WRITE_DATA( 8 + 7*sizeof(GLfloat), GLfloat, m[ 7] );
     207    WRITE_DATA( 8 + 8*sizeof(GLfloat), GLfloat, m[ 8] );
     208    WRITE_DATA( 8 + 9*sizeof(GLfloat), GLfloat, m[ 9] );
     209    WRITE_DATA( 8 + 10*sizeof(GLfloat), GLfloat, m[10] );
     210    WRITE_DATA( 8 + 11*sizeof(GLfloat), GLfloat, m[11] );
     211    WRITE_DATA( 8 + 12*sizeof(GLfloat), GLfloat, m[12] );
     212    WRITE_DATA( 8 + 13*sizeof(GLfloat), GLfloat, m[13] );
     213    WRITE_DATA( 8 + 14*sizeof(GLfloat), GLfloat, m[14] );
     214    WRITE_DATA( 8 + 15*sizeof(GLfloat), GLfloat, m[15] );
     215    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     216}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_misc.c

    r21845 r33457  
    1010void PACK_APIENTRY crPackChromiumParametervCR(GLenum target, GLenum type, GLsizei count, const GLvoid *values)
    1111{
    12         GET_PACKER_CONTEXT(pc);
    13         unsigned int header_length = 2 * sizeof(int) + sizeof(target) + sizeof(type) + sizeof(count);
    14         unsigned int packet_length;
    15         unsigned int params_length = 0;
    16         unsigned char *data_ptr;
    17         int i, pos;
     12    GET_PACKER_CONTEXT(pc);
     13    unsigned int header_length = 2 * sizeof(int) + sizeof(target) + sizeof(type) + sizeof(count);
     14    unsigned int packet_length;
     15    unsigned int params_length = 0;
     16    unsigned char *data_ptr;
     17    int i, pos;
    1818
    19         switch (type) {
    20         case GL_BYTE:
    21         case GL_UNSIGNED_BYTE:
    22                 params_length = sizeof(GLbyte) * count;
    23                 break;
    24         case GL_SHORT:
    25         case GL_UNSIGNED_SHORT:
    26                 params_length = sizeof(GLshort) * count;
    27                 break;
    28         case GL_INT:
    29         case GL_UNSIGNED_INT:
    30                 params_length = sizeof(GLint) * count;
    31                 break;
    32         case GL_FLOAT:
    33                 params_length = sizeof(GLfloat) * count;
    34                 break;
     19    switch (type) {
     20    case GL_BYTE:
     21    case GL_UNSIGNED_BYTE:
     22        params_length = sizeof(GLbyte) * count;
     23        break;
     24    case GL_SHORT:
     25    case GL_UNSIGNED_SHORT:
     26        params_length = sizeof(GLshort) * count;
     27        break;
     28    case GL_INT:
     29    case GL_UNSIGNED_INT:
     30        params_length = sizeof(GLint) * count;
     31        break;
     32    case GL_FLOAT:
     33        params_length = sizeof(GLfloat) * count;
     34        break;
    3535#if 0
    36         case GL_DOUBLE:
    37                 params_length = sizeof(GLdouble) * count;
    38                 break;
     36    case GL_DOUBLE:
     37        params_length = sizeof(GLdouble) * count;
     38        break;
    3939#endif
    40         default:
    41                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    42                                                                 "crPackChromiumParametervCR(bad type)" );
    43                 return;
    44         }
     40    default:
     41        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     42                                "crPackChromiumParametervCR(bad type)" );
     43        return;
     44    }
    4545
    46         packet_length = header_length + params_length;
     46    packet_length = header_length + params_length;
    4747
    48         GET_BUFFERED_POINTER(pc, packet_length );
    49         WRITE_DATA( 0, GLint, packet_length );
    50         WRITE_DATA( 4, GLenum, CR_CHROMIUMPARAMETERVCR_EXTEND_OPCODE );
    51         WRITE_DATA( 8, GLenum, target );
    52         WRITE_DATA( 12, GLenum, type );
    53         WRITE_DATA( 16, GLsizei, count );
    54         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     48    GET_BUFFERED_POINTER(pc, packet_length );
     49    WRITE_DATA( 0, GLint, packet_length );
     50    WRITE_DATA( 4, GLenum, CR_CHROMIUMPARAMETERVCR_EXTEND_OPCODE );
     51    WRITE_DATA( 8, GLenum, target );
     52    WRITE_DATA( 12, GLenum, type );
     53    WRITE_DATA( 16, GLsizei, count );
     54    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    5555
    56         pos = header_length;
     56    pos = header_length;
    5757
    58         switch (type) {
    59         case GL_BYTE:
    60         case GL_UNSIGNED_BYTE:
    61                 for (i = 0; i < count; i++, pos += sizeof(GLbyte)) {
    62                         WRITE_DATA( pos, GLbyte, ((GLbyte *) values)[i]);
    63                 }
    64                 break;
    65         case GL_SHORT:
    66         case GL_UNSIGNED_SHORT:
    67                 for (i = 0; i < count; i++, pos += sizeof(GLshort)) {
    68                         WRITE_DATA( pos, GLshort, ((GLshort *) values)[i]);
    69                 }
    70                 break;
    71         case GL_INT:
    72         case GL_UNSIGNED_INT:
    73                 for (i = 0; i < count; i++, pos += sizeof(GLint)) {
    74                         WRITE_DATA( pos, GLint, ((GLint *) values)[i]);
    75                 }
    76                 break;
    77         case GL_FLOAT:
    78                 for (i = 0; i < count; i++, pos += sizeof(GLfloat)) {
    79                         WRITE_DATA( pos, GLfloat, ((GLfloat *) values)[i]);
    80                 }
    81                 break;
     58    switch (type) {
     59    case GL_BYTE:
     60    case GL_UNSIGNED_BYTE:
     61        for (i = 0; i < count; i++, pos += sizeof(GLbyte)) {
     62            WRITE_DATA( pos, GLbyte, ((GLbyte *) values)[i]);
     63        }
     64        break;
     65    case GL_SHORT:
     66    case GL_UNSIGNED_SHORT:
     67        for (i = 0; i < count; i++, pos += sizeof(GLshort)) {
     68            WRITE_DATA( pos, GLshort, ((GLshort *) values)[i]);
     69        }
     70        break;
     71    case GL_INT:
     72    case GL_UNSIGNED_INT:
     73        for (i = 0; i < count; i++, pos += sizeof(GLint)) {
     74            WRITE_DATA( pos, GLint, ((GLint *) values)[i]);
     75        }
     76        break;
     77    case GL_FLOAT:
     78        for (i = 0; i < count; i++, pos += sizeof(GLfloat)) {
     79            WRITE_DATA( pos, GLfloat, ((GLfloat *) values)[i]);
     80        }
     81        break;
    8282#if 0
    83         case GL_DOUBLE:
    84                 for (i = 0; i < count; i++) {
    85                         WRITE_foo_DATA( sizeof(int) + 12, GLdouble, ((GLdouble *) values)[i]);
    86                 }
    87                 break;
     83    case GL_DOUBLE:
     84        for (i = 0; i < count; i++) {
     85            WRITE_foo_DATA( sizeof(int) + 12, GLdouble, ((GLdouble *) values)[i]);
     86        }
     87        break;
    8888#endif
    89         default:
    90                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    91                                                                 "crPackChromiumParametervCR(bad type)" );
    92                 return;
    93         }
     89    default:
     90        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     91                                "crPackChromiumParametervCR(bad type)" );
     92        return;
     93    }
    9494}
    9595
    … …  
    9898    unsigned char *data_ptr;
    9999    int packet_length = sizeof(GLenum)+sizeof(n)+n*sizeof(*ids);
    100         GET_PACKER_CONTEXT(pc);
     100    GET_PACKER_CONTEXT(pc);
    101101    if (!ids) return;
    102102    data_ptr = (unsigned char *) crPackAlloc(packet_length);

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_pica.c

    r15532 r33457  
    1010
    1111void PACK_APIENTRY crPackPicaListCompositors(const PICAuint *config,
    12                                         PICAint *numResults,
    13                                         PICAcompItem *results, PICAerror *return_value, int* writeback )
     12                    PICAint *numResults,
     13                    PICAcompItem *results, PICAerror *return_value, int* writeback )
    1414{
    1515     crWarning("You can't really pack PICA calls!");
    … …  
    2121}
    2222void PACK_APIENTRY crPackPicaListCompositorsSWAP(const PICAuint *config,
    23                                              PICAint *numResults,
    24                                              PICAcompItem *results, PICAerror *return_value, int* writeback )
     23                         PICAint *numResults,
     24                         PICAcompItem *results, PICAerror *return_value, int* writeback )
    2525{
    2626     crWarning("You can't really pack PICA calls!");
    … …  
    3232}
    3333void PACK_APIENTRY crPackPicaGetCompositorParamiv(PICAcompID compositor,
    34                                               PICAparam pname,
    35                                               PICAint *params, PICAerror *return_value, int* writeback )
     34                          PICAparam pname,
     35                          PICAint *params, PICAerror *return_value, int* writeback )
    3636{
    3737     
    … …  
    4444}
    4545void PACK_APIENTRY crPackPicaGetCompositorParamivSWAP(PICAcompID compositor,
    46                                                   PICAparam pname,
    47                                                   PICAint *params, PICAerror *return_value, int* writeback )
     46                          PICAparam pname,
     47                          PICAint *params, PICAerror *return_value, int* writeback )
    4848{
    4949     
    … …  
    5656}
    5757void PACK_APIENTRY crPackPicaGetCompositorParamfv(PICAcompID compositor,
    58                                               PICAparam pname,
    59                                               PICAfloat *params, PICAerror *return_value, int* writeback )
     58                          PICAparam pname,
     59                          PICAfloat *params, PICAerror *return_value, int* writeback )
    6060{
    6161
    … …  
    6868}
    6969void PACK_APIENTRY crPackPicaGetCompositorParamfvSWAP(PICAcompID compositor,
    70                                                   PICAparam pname,
    71                                                   PICAfloat *params, PICAerror *return_value, int* writeback )
     70                          PICAparam pname,
     71                          PICAfloat *params, PICAerror *return_value, int* writeback )
    7272{
    7373
    … …  
    8080}
    8181void PACK_APIENTRY crPackPicaGetCompositorParamcv(PICAcompID compositor,
    82                                               PICAparam pname,
    83                                               PICAchar **params, PICAerror *return_value, int* writeback )
     82                          PICAparam pname,
     83                          PICAchar **params, PICAerror *return_value, int* writeback )
    8484{
    8585
    … …  
    9292}
    9393void PACK_APIENTRY crPackPicaGetCompositorParamcvSWAP(PICAcompID compositor,
    94                                                   PICAparam pname,
    95                                                   PICAchar **params, PICAerror *return_value, int* writeback )
     94                          PICAparam pname,
     95                          PICAchar **params, PICAerror *return_value, int* writeback )
    9696{
    9797
    … …  
    104104}
    105105void PACK_APIENTRY crPackPicaListNodes(PICAcompID compositor,
    106                                    PICAint *num,
    107                                    PICAnodeItem *results, PICAerror *return_value, int* writeback )
     106                   PICAint *num,
     107                   PICAnodeItem *results, PICAerror *return_value, int* writeback )
    108108{
    109109
    … …  
    116116}
    117117void PACK_APIENTRY crPackPicaListNodesSWAP(PICAcompID compositor,
    118                                        PICAint *num,
    119                                        PICAnodeItem *results, PICAerror *return_value, int* writeback )
     118                       PICAint *num,
     119                       PICAnodeItem *results, PICAerror *return_value, int* writeback )
    120120{
    121121
    … …  
    129129
    130130void PACK_APIENTRY crPackPicaCreateContext(const PICAuint *config,
    131                                        const PICAnodeID *nodes,
    132                                        PICAuint numNodes, PICAcontextID *return_value, int* writeback )
     131                       const PICAnodeID *nodes,
     132                       PICAuint numNodes, PICAcontextID *return_value, int* writeback )
    133133{
    134134
    … …  
    141141}
    142142void PACK_APIENTRY crPackPicaCreateContextSWAP(const PICAuint *config,
    143                                            const PICAnodeID *nodes,
    144                                            PICAuint numNodes, PICAcontextID *return_value, int* writeback )
     143                       const PICAnodeID *nodes,
     144                       PICAuint numNodes, PICAcontextID *return_value, int* writeback )
    145145{
    146146
    … …  
    170170
    171171void PACK_APIENTRY crPackPicaSetContextParami(PICAcontextID ctx,
    172                                           PICAparam pname,
    173                                           PICAint param, PICAerror *return_value, int* writeback )
     172                      PICAparam pname,
     173                      PICAint param, PICAerror *return_value, int* writeback )
    174174{
    175175
    … …  
    182182}
    183183void PACK_APIENTRY crPackPicaSetContextParamiSWAP(PICAcontextID ctx,
    184                                               PICAparam pname,
    185                                               PICAint param, PICAerror *return_value, int* writeback )
     184                          PICAparam pname,
     185                          PICAint param, PICAerror *return_value, int* writeback )
    186186{
    187187
    … …  
    194194}
    195195void PACK_APIENTRY crPackPicaSetContextParamiv(PICAcontextID ctx,
    196                                            PICAparam pname,
    197                                            const PICAint *param, PICAerror *return_value, int* writeback )
     196                       PICAparam pname,
     197                       const PICAint *param, PICAerror *return_value, int* writeback )
    198198{
    199199
    … …  
    206206}
    207207void PACK_APIENTRY crPackPicaSetContextParamivSWAP(PICAcontextID ctx,
    208                                                PICAparam pname,
    209                                                const PICAint *param, PICAerror *return_value, int* writeback )
     208                           PICAparam pname,
     209                           const PICAint *param, PICAerror *return_value, int* writeback )
    210210{
    211211
    … …  
    218218}
    219219void PACK_APIENTRY crPackPicaSetContextParamf(PICAcontextID ctx,
    220                                           PICAparam pname,
    221                                           PICAfloat param, PICAerror *return_value, int* writeback )
     220                      PICAparam pname,
     221                      PICAfloat param, PICAerror *return_value, int* writeback )
    222222{
    223223
    … …  
    230230}
    231231void PACK_APIENTRY crPackPicaSetContextParamfSWAP(PICAcontextID ctx,
    232                                               PICAparam pname,
    233                                               PICAfloat param, PICAerror *return_value, int* writeback )
     232                          PICAparam pname,
     233                          PICAfloat param, PICAerror *return_value, int* writeback )
    234234{
    235235
    … …  
    242242}
    243243void PACK_APIENTRY crPackPicaSetContextParamfv(PICAcontextID ctx,
    244                                            PICAparam pname,
    245                                            const PICAfloat *param, PICAerror *return_value, int* writeback )
     244                       PICAparam pname,
     245                       const PICAfloat *param, PICAerror *return_value, int* writeback )
    246246{
    247247
    … …  
    254254}
    255255void PACK_APIENTRY crPackPicaSetContextParamfvSWAP(PICAcontextID ctx,
    256                                                PICAparam pname,
    257                                                const PICAfloat *param, PICAerror *return_value, int* writeback )
     256                           PICAparam pname,
     257                           const PICAfloat *param, PICAerror *return_value, int* writeback )
    258258{
    259259
    … …  
    266266}
    267267void PACK_APIENTRY crPackPicaSetContextParamv(PICAcontextID ctx,
    268                                           PICAparam pname,
    269                                           const PICAvoid *param, PICAerror *return_value, int* writeback )
     268                      PICAparam pname,
     269                      const PICAvoid *param, PICAerror *return_value, int* writeback )
    270270{
    271271
    … …  
    278278}
    279279void PACK_APIENTRY crPackPicaSetContextParamvSWAP(PICAcontextID ctx,
    280                                               PICAparam pname,
    281                                               const PICAvoid *param, PICAerror *return_value, int* writeback )
     280                          PICAparam pname,
     281                          const PICAvoid *param, PICAerror *return_value, int* writeback )
    282282{
    283283
    … …  
    291291
    292292void PACK_APIENTRY crPackPicaGetContextParamiv(PICAcontextID ctx,
    293                                            PICAparam pname,
    294                                            PICAint *param, PICAerror *return_value, int* writeback )
     293                       PICAparam pname,
     294                       PICAint *param, PICAerror *return_value, int* writeback )
    295295{
    296296
    … …  
    304304
    305305void PACK_APIENTRY crPackPicaGetContextParamivSWAP(PICAcontextID ctx,
    306                                                PICAparam pname,
    307                                                PICAint *param, PICAerror *return_value, int* writeback )
     306                           PICAparam pname,
     307                           PICAint *param, PICAerror *return_value, int* writeback )
    308308{
    309309
    … …  
    316316} 
    317317void PACK_APIENTRY crPackPicaGetContextParamfv(PICAcontextID ctx,
    318                                            PICAparam pname,
    319                                            PICAfloat *param, PICAerror *return_value, int* writeback )
     318                       PICAparam pname,
     319                       PICAfloat *param, PICAerror *return_value, int* writeback )
    320320{
    321321
    … …  
    328328} 
    329329void PACK_APIENTRY crPackPicaGetContextParamfvSWAP(PICAcontextID ctx,
    330                                                PICAparam pname,
    331                                                PICAfloat *param, PICAerror *return_value, int* writeback )
     330                           PICAparam pname,
     331                           PICAfloat *param, PICAerror *return_value, int* writeback )
    332332{
    333333
    … …  
    340340} 
    341341void PACK_APIENTRY crPackPicaGetContextParamcv(PICAcontextID ctx,
    342                                            PICAparam pname,
    343                                            PICAchar **param, PICAerror *return_value, int* writeback )
     342                       PICAparam pname,
     343                       PICAchar **param, PICAerror *return_value, int* writeback )
    344344{
    345345
    … …  
    352352} 
    353353void PACK_APIENTRY crPackPicaGetContextParamcvSWAP(PICAcontextID ctx,
    354                                                PICAparam pname,
    355                                                PICAchar **param, PICAerror *return_value, int* writeback )
     354                           PICAparam pname,
     355                           PICAchar **param, PICAerror *return_value, int* writeback )
    356356{
    357357
    … …  
    364364} 
    365365void PACK_APIENTRY crPackPicaGetContextParamv(PICAcontextID ctx,
    366                                           PICAparam pname,
    367                                           PICAvoid *param, PICAerror *return_value, int* writeback )
     366                      PICAparam pname,
     367                      PICAvoid *param, PICAerror *return_value, int* writeback )
    368368{
    369369
    … …  
    376376} 
    377377void PACK_APIENTRY crPackPicaGetContextParamvSWAP(PICAcontextID ctx,
    378                                               PICAparam pname,
    379                                               PICAvoid *param, PICAerror *return_value, int* writeback )
     378                          PICAparam pname,
     379                          PICAvoid *param, PICAerror *return_value, int* writeback )
    380380{
    381381
    … …  
    389389
    390390void PACK_APIENTRY crPackPicaBindLocalContext(PICAcontextID globalCtx,
    391                                           PICAnodeID node, PICAcontextID *return_value, int* writeback )
     391                      PICAnodeID node, PICAcontextID *return_value, int* writeback )
    392392{
    393393
    … …  
    400400
    401401void PACK_APIENTRY crPackPicaBindLocalContextSWAP(PICAcontextID globalCtx,
    402                                               PICAnodeID node, PICAcontextID *return_value, int* writeback )
     402                          PICAnodeID node, PICAcontextID *return_value, int* writeback )
    403403{
    404404
    … …  
    427427
    428428void PACK_APIENTRY crPackPicaStartFrame(PICAcontextID lctx,
    429                                     const PICAframeID *frameID,
    430                                     PICAuint numLocalFramelets,
    431                                     PICAuint numOrders,
    432                                     const PICAuint *orderList,
    433                                     const PICArect *srcRectList,
    434                                     const PICApoint *dstList, PICAerror *return_value, int* writeback )
     429                    const PICAframeID *frameID,
     430                    PICAuint numLocalFramelets,
     431                    PICAuint numOrders,
     432                    const PICAuint *orderList,
     433                    const PICArect *srcRectList,
     434                    const PICApoint *dstList, PICAerror *return_value, int* writeback )
    435435{
    436436     
    … …  
    448448
    449449void PACK_APIENTRY crPackPicaStartFrameSWAP(PICAcontextID lctx,
    450                                         const PICAframeID *frameID,
    451                                         PICAuint numLocalFramelets,
    452                                         PICAuint numOrders,
    453                                         const PICAuint *orderList,
    454                                         const PICArect *srcRectList,
    455                                         const PICApoint *dstList, PICAerror *return_value, int* writeback )
     450                    const PICAframeID *frameID,
     451                    PICAuint numLocalFramelets,
     452                    PICAuint numOrders,
     453                    const PICAuint *orderList,
     454                    const PICArect *srcRectList,
     455                    const PICApoint *dstList, PICAerror *return_value, int* writeback )
    456456{
    457457     
    … …  
    484484}
    485485void PACK_APIENTRY crPackPicaCancelFrame(PICAcontextID ctx,
    486                                      PICAframeID frameID, PICAerror *return_value, int* writeback )
     486                     PICAframeID frameID, PICAerror *return_value, int* writeback )
    487487{
    488488     
    … …  
    494494}
    495495void PACK_APIENTRY crPackPicaCancelFrameSWAP(PICAcontextID ctx,
    496                                         PICAframeID frameID, PICAerror *return_value, int* writeback )
     496                    PICAframeID frameID, PICAerror *return_value, int* writeback )
    497497{
    498498     
    … …  
    504504}
    505505void PACK_APIENTRY crPackPicaQueryFrame(PICAcontextID ctx,
    506                                     PICAframeID frameID,
    507                                     PICAnodeID nodeID,
    508                                     PICAfloat timeout, PICAstatus *return_value, int* writeback )
     506                    PICAframeID frameID,
     507                    PICAnodeID nodeID,
     508                    PICAfloat timeout, PICAstatus *return_value, int* writeback )
    509509{
    510510     
    … …  
    518518}
    519519void PACK_APIENTRY crPackPicaQueryFrameSWAP(PICAcontextID ctx,
    520                                         PICAframeID frameID,
    521                                         PICAnodeID nodeID,
    522                                         PICAfloat timeout, PICAstatus *return_value, int* writeback )
     520                    PICAframeID frameID,
     521                    PICAnodeID nodeID,
     522                    PICAfloat timeout, PICAstatus *return_value, int* writeback )
    523523{
    524524     
    … …  
    532532}
    533533void PACK_APIENTRY crPackPicaAddGfxFramelet(PICAcontextID lctx,
    534                                         const PICArect *srcRect,
    535                                         const PICApoint *dstPos,
    536                                         PICAuint order,
    537                                         PICAint iVolatile, PICAerror *return_value, int* writeback )
     534                    const PICArect *srcRect,
     535                    const PICApoint *dstPos,
     536                    PICAuint order,
     537                    PICAint iVolatile, PICAerror *return_value, int* writeback )
    538538{
    539539     
    … …  
    548548}
    549549void PACK_APIENTRY crPackPicaAddGfxFrameletSWAP(PICAcontextID lctx,
    550                                             const PICArect *srcRect,
    551                                             const PICApoint *dstPos,
    552                                             PICAuint order,
    553                                             PICAint iVolatile, PICAerror *return_value, int* writeback )
     550                        const PICArect *srcRect,
     551                        const PICApoint *dstPos,
     552                        PICAuint order,
     553                        PICAint iVolatile, PICAerror *return_value, int* writeback )
    554554{
    555555     
    … …  
    564564}
    565565void PACK_APIENTRY crPackPicaAddMemFramelet(PICAcontextID lctx,
    566                                         const PICAvoid *colorBuffer,
    567                                         const PICAvoid *depthBuffer,
    568                                         PICAuint span_x,
    569                                         const PICArect *srcRect,
    570                                         const PICApoint *dstPos,
    571                                         PICAuint order,
    572                                         PICAint iVolatile, PICAerror *return_value, int* writeback )
     566                    const PICAvoid *colorBuffer,
     567                    const PICAvoid *depthBuffer,
     568                    PICAuint span_x,
     569                    const PICArect *srcRect,
     570                    const PICApoint *dstPos,
     571                    PICAuint order,
     572                    PICAint iVolatile, PICAerror *return_value, int* writeback )
    573573{
    574574     
    … …  
    586586}
    587587void PACK_APIENTRY crPackPicaAddMemFrameletSWAP(PICAcontextID lctx,
    588                                             const PICAvoid *colorBuffer,
    589                                             const PICAvoid *depthBuffer,
    590                                             PICAuint span_x,
    591                                             const PICArect *srcRect,
    592                                             const PICApoint *dstPos,
    593                                             PICAuint order,
    594                                             PICAint iVolatile,
    595                                             PICAerror *return_value,
    596                                             int* writeback )
     588                        const PICAvoid *colorBuffer,
     589                        const PICAvoid *depthBuffer,
     590                        PICAuint span_x,
     591                        const PICArect *srcRect,
     592                        const PICApoint *dstPos,
     593                        PICAuint order,
     594                        PICAint iVolatile,
     595                        PICAerror *return_value,
     596                        int* writeback )
    597597{
    598598     
    … …  
    610610}
    611611void PACK_APIENTRY crPackPicaReadFrame(PICAcontextID lctx,
    612                                    PICAframeID frameID,
    613                                    PICAuint format,
    614                                    PICAvoid *colorbuffer,
    615                                    PICAvoid *depthbuffer,
    616                                    const PICArect *rect,
    617                                    PICAerror *return_value,
    618                                    int* writeback )
     612                   PICAframeID frameID,
     613                   PICAuint format,
     614                   PICAvoid *colorbuffer,
     615                   PICAvoid *depthbuffer,
     616                   const PICArect *rect,
     617                   PICAerror *return_value,
     618                   int* writeback )
    619619{
    620620     
    … …  
    630630}
    631631void PACK_APIENTRY crPackPicaReadFrameSWAP(PICAcontextID lctx,
    632                                        PICAframeID frameID,
    633                                        PICAuint format,
    634                                        PICAvoid *colorbuffer,
    635                                        PICAvoid *depthbuffer,
    636                                        const PICArect *rect,
    637                                        PICAerror *return_value,
    638                                        int* writeback )
     632                       PICAframeID frameID,
     633                       PICAuint format,
     634                       PICAvoid *colorbuffer,
     635                       PICAvoid *depthbuffer,
     636                       const PICArect *rect,
     637                       PICAerror *return_value,
     638                       int* writeback )
    639639{
    640640     

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_point.c

    r15532 r33457  
    1313static GLboolean __handlePointDataf( GLenum pname, const GLfloat *params )
    1414{
    15         GET_PACKER_CONTEXT(pc);
    16         int params_length = 0;
    17         int packet_length = 2 * sizeof( int ) + sizeof( pname );
    18         unsigned char *data_ptr;
    19         switch( pname )
    20         {
    21                 case GL_POINT_SIZE_MIN_ARB:
    22                 case GL_POINT_SIZE_MAX_ARB:
    23                 case GL_POINT_FADE_THRESHOLD_SIZE_ARB:
    24                         params_length = sizeof( *params );
    25                         break;
    26                 case GL_POINT_DISTANCE_ATTENUATION_ARB:
    27                         params_length = 3 * sizeof( *params );
    28                         break;
    29                 default:
    30                         {
    31                                 char msg[100];
    32                                 sprintf(msg, "Invalid pname in PointParameter: %d", (int) pname );
    33                                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM, msg);
    34                         }                                                               
    35                         return GL_FALSE;
    36         }
    37         packet_length += params_length;
     15    GET_PACKER_CONTEXT(pc);
     16    int params_length = 0;
     17    int packet_length = 2 * sizeof( int ) + sizeof( pname );
     18    unsigned char *data_ptr;
     19    switch( pname )
     20    {
     21        case GL_POINT_SIZE_MIN_ARB:
     22        case GL_POINT_SIZE_MAX_ARB:
     23        case GL_POINT_FADE_THRESHOLD_SIZE_ARB:
     24            params_length = sizeof( *params );
     25            break;
     26        case GL_POINT_DISTANCE_ATTENUATION_ARB:
     27            params_length = 3 * sizeof( *params );
     28            break;
     29        default:
     30            {
     31                char msg[100];
     32                sprintf(msg, "Invalid pname in PointParameter: %d", (int) pname );
     33                __PackError( __LINE__, __FILE__, GL_INVALID_ENUM, msg);
     34            }                               
     35            return GL_FALSE;
     36    }
     37    packet_length += params_length;
    3838
    39         GET_BUFFERED_POINTER(pc, packet_length );
    40         WRITE_DATA( 0, GLint, packet_length );
    41         WRITE_DATA( 4, GLenum, CR_POINTPARAMETERFVARB_EXTEND_OPCODE );
    42         WRITE_DATA( 8, GLenum, pname );
    43         WRITE_DATA( 12, GLfloat, params[0] );
    44         if (packet_length > 16)
    45         {
    46                 WRITE_DATA( 16, GLfloat, params[1] );
    47                 WRITE_DATA( 20, GLfloat, params[2] );
    48         }
    49         return GL_TRUE;
     39    GET_BUFFERED_POINTER(pc, packet_length );
     40    WRITE_DATA( 0, GLint, packet_length );
     41    WRITE_DATA( 4, GLenum, CR_POINTPARAMETERFVARB_EXTEND_OPCODE );
     42    WRITE_DATA( 8, GLenum, pname );
     43    WRITE_DATA( 12, GLfloat, params[0] );
     44    if (packet_length > 16)
     45    {
     46        WRITE_DATA( 16, GLfloat, params[1] );
     47        WRITE_DATA( 20, GLfloat, params[2] );
     48    }
     49    return GL_TRUE;
    5050}
    5151
    5252void PACK_APIENTRY crPackPointParameterfvARB(GLenum pname, const GLfloat *params)
    5353{
    54         GET_PACKER_CONTEXT(pc);
    55         if (__handlePointDataf( pname, params ))
    56                 WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     54    GET_PACKER_CONTEXT(pc);
     55    if (__handlePointDataf( pname, params ))
     56        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    5757}
    5858
    … …  
    6161static GLboolean __handlePointDatai( GLenum pname, const GLint *params )
    6262{
    63         GET_PACKER_CONTEXT(pc);
    64         int params_length = 0;
    65         int packet_length = 2 * sizeof( int ) + sizeof( pname );
    66         unsigned char *data_ptr;
    67         switch( pname )
    68         {
    69                 case GL_POINT_SIZE_MIN_ARB:
    70                 case GL_POINT_SIZE_MAX_ARB:
    71                 case GL_POINT_FADE_THRESHOLD_SIZE_ARB:
    72                         params_length = sizeof( *params );
    73                         break;
    74                 case GL_POINT_DISTANCE_ATTENUATION_ARB:
    75                         params_length = 3 * sizeof( *params );
    76                         break;
    77                 default:
    78                         {
    79                                 char msg[100];
    80                                 sprintf(msg, "Invalid pname in PointParameter: %d", (int) pname );
    81                                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM, msg);
    82                         }
    83                         return GL_FALSE;
    84         }
    85         packet_length += params_length;
     63    GET_PACKER_CONTEXT(pc);
     64    int params_length = 0;
     65    int packet_length = 2 * sizeof( int ) + sizeof( pname );
     66    unsigned char *data_ptr;
     67    switch( pname )
     68    {
     69        case GL_POINT_SIZE_MIN_ARB:
     70        case GL_POINT_SIZE_MAX_ARB:
     71        case GL_POINT_FADE_THRESHOLD_SIZE_ARB:
     72            params_length = sizeof( *params );
     73            break;
     74        case GL_POINT_DISTANCE_ATTENUATION_ARB:
     75            params_length = 3 * sizeof( *params );
     76            break;
     77        default:
     78            {
     79                char msg[100];
     80                sprintf(msg, "Invalid pname in PointParameter: %d", (int) pname );
     81                __PackError( __LINE__, __FILE__, GL_INVALID_ENUM, msg);
     82            }
     83            return GL_FALSE;
     84    }
     85    packet_length += params_length;
    8686
    87         GET_BUFFERED_POINTER(pc, packet_length );
    88         WRITE_DATA( 0, GLint, packet_length );
    89         WRITE_DATA( 4, GLenum, CR_POINTPARAMETERIV_EXTEND_OPCODE );
    90         WRITE_DATA( 8, GLenum, pname );
    91         WRITE_DATA( 12, GLint, params[0] );
    92         if (packet_length > 16)
    93         {
    94                 WRITE_DATA( 16, GLint, params[1] );
    95                 WRITE_DATA( 20, GLint, params[2] );
    96         }
    97         return GL_TRUE;
     87    GET_BUFFERED_POINTER(pc, packet_length );
     88    WRITE_DATA( 0, GLint, packet_length );
     89    WRITE_DATA( 4, GLenum, CR_POINTPARAMETERIV_EXTEND_OPCODE );
     90    WRITE_DATA( 8, GLenum, pname );
     91    WRITE_DATA( 12, GLint, params[0] );
     92    if (packet_length > 16)
     93    {
     94        WRITE_DATA( 16, GLint, params[1] );
     95        WRITE_DATA( 20, GLint, params[2] );
     96    }
     97    return GL_TRUE;
    9898}
    9999
    100100void PACK_APIENTRY crPackPointParameteriv(GLenum pname, const GLint *params)
    101101{
    102         GET_PACKER_CONTEXT(pc);
    103         if (__handlePointDatai( pname, params ))
    104                 WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     102    GET_PACKER_CONTEXT(pc);
     103    if (__handlePointDatai( pname, params ))
     104        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    105105}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_program.c

    r31474 r33457  
    1717void PACK_APIENTRY crPackProgramParameters4dvNV (GLenum target, GLuint index, GLuint num, const GLdouble * params)
    1818{
    19         GET_PACKER_CONTEXT(pc);
    20         unsigned char *data_ptr;
    21         int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLdouble);
    22 
    23         GET_BUFFERED_POINTER(pc, packet_length);
    24         WRITE_DATA(0, int, packet_length);
    25         WRITE_DATA(sizeof(int) + 0, GLenum, target);
    26         WRITE_DATA(sizeof(int) + 4, GLuint, index);
    27         WRITE_DATA(sizeof(int) + 8, GLuint, num);
    28         crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLdouble));
    29 
    30         WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4DVNV_EXTEND_OPCODE);
     19    GET_PACKER_CONTEXT(pc);
     20    unsigned char *data_ptr;
     21    int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLdouble);
     22
     23    GET_BUFFERED_POINTER(pc, packet_length);
     24    WRITE_DATA(0, int, packet_length);
     25    WRITE_DATA(sizeof(int) + 0, GLenum, target);
     26    WRITE_DATA(sizeof(int) + 4, GLuint, index);
     27    WRITE_DATA(sizeof(int) + 8, GLuint, num);
     28    crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLdouble));
     29
     30    WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4DVNV_EXTEND_OPCODE);
    3131}
    3232
    … …  
    3434void PACK_APIENTRY crPackProgramParameters4fvNV (GLenum target, GLuint index, GLuint num, const GLfloat * params)
    3535{
    36         GET_PACKER_CONTEXT(pc);
    37         unsigned char *data_ptr;
    38         int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLfloat);
    39 
    40         GET_BUFFERED_POINTER(pc, packet_length);
    41         WRITE_DATA(0, int, packet_length);
    42         WRITE_DATA(sizeof(int) + 0, GLenum, target);
    43         WRITE_DATA(sizeof(int) + 4, GLuint, index);
    44         WRITE_DATA(sizeof(int) + 8, GLuint, num);
    45         crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLfloat));
    46 
    47         WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4FVNV_EXTEND_OPCODE);
     36    GET_PACKER_CONTEXT(pc);
     37    unsigned char *data_ptr;
     38    int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLfloat);
     39
     40    GET_BUFFERED_POINTER(pc, packet_length);
     41    WRITE_DATA(0, int, packet_length);
     42    WRITE_DATA(sizeof(int) + 0, GLenum, target);
     43    WRITE_DATA(sizeof(int) + 4, GLuint, index);
     44    WRITE_DATA(sizeof(int) + 8, GLuint, num);
     45    crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLfloat));
     46
     47    WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4FVNV_EXTEND_OPCODE);
    4848}
    4949
    … …  
    5151void PACK_APIENTRY crPackVertexAttribs1dvNV( GLuint index, GLsizei n, const GLdouble *v )
    5252{
    53         GLint i;
    54         /* reverse order so we hit index 0 last (provoking glVertex) */
    55         for (i = n - 1; i >= 0; i--)
    56                 crPackVertexAttrib1dvARB(index + i, v + i);
     53    GLint i;
     54    /* reverse order so we hit index 0 last (provoking glVertex) */
     55    for (i = n - 1; i >= 0; i--)
     56        crPackVertexAttrib1dvARB(index + i, v + i);
    5757}
    5858
    … …  
    6060void PACK_APIENTRY crPackVertexAttribs1fvNV( GLuint index, GLsizei n, const GLfloat *v )
    6161{
    62         GLint i;
    63         /* reverse order so we hit index 0 last (provoking glVertex) */
    64         for (i = n - 1; i >= 0; i--)
    65                 crPackVertexAttrib1fvARB(index + i, v + i);
     62    GLint i;
     63    /* reverse order so we hit index 0 last (provoking glVertex) */
     64    for (i = n - 1; i >= 0; i--)
     65        crPackVertexAttrib1fvARB(index + i, v + i);
    6666}
    6767
    … …  
    6969void PACK_APIENTRY crPackVertexAttribs1svNV( GLuint index, GLsizei n, const GLshort *v )
    7070{
    71         GLint i;
    72         /* reverse order so we hit index 0 last (provoking glVertex) */
    73         for (i = n - 1; i >= 0; i--)
    74                 crPackVertexAttrib1svARB(index + i, v + i);
     71    GLint i;
     72    /* reverse order so we hit index 0 last (provoking glVertex) */
     73    for (i = n - 1; i >= 0; i--)
     74        crPackVertexAttrib1svARB(index + i, v + i);
    7575}
    7676
    … …  
    7878void PACK_APIENTRY crPackVertexAttribs2dvNV( GLuint index, GLsizei n, const GLdouble *v )
    7979{
    80         GLint i;
    81         /* reverse order so we hit index 0 last (provoking glVertex) */
    82         for (i = n - 1; i >= 0; i--)
    83                 crPackVertexAttrib2dvARB(index + i, v + 2 * i);
     80    GLint i;
     81    /* reverse order so we hit index 0 last (provoking glVertex) */
     82    for (i = n - 1; i >= 0; i--)
     83        crPackVertexAttrib2dvARB(index + i, v + 2 * i);
    8484}
    8585
    8686void PACK_APIENTRY crPackVertexAttribs2fvNV( GLuint index, GLsizei n, const GLfloat *v )
    8787{
    88         GLint i;
    89         /* reverse order so we hit index 0 last (provoking glVertex) */
    90         for (i = n - 1; i >= 0; i--)
    91                 crPackVertexAttrib2fvARB(index + i, v + 2 * i);
     88    GLint i;
     89    /* reverse order so we hit index 0 last (provoking glVertex) */
     90    for (i = n - 1; i >= 0; i--)
     91        crPackVertexAttrib2fvARB(index + i, v + 2 * i);
    9292}
    9393
    9494void PACK_APIENTRY crPackVertexAttribs2svNV( GLuint index, GLsizei n, const GLshort *v )
    9595{
    96         GLint i;
    97         /* reverse order so we hit index 0 last (provoking glVertex) */
    98         for (i = n - 1; i >= 0; i--)
    99                 crPackVertexAttrib2svARB(index + i, v + 2 * i);
     96    GLint i;
     97    /* reverse order so we hit index 0 last (provoking glVertex) */
     98    for (i = n - 1; i >= 0; i--)
     99        crPackVertexAttrib2svARB(index + i, v + 2 * i);
    100100}
    101101
    102102void PACK_APIENTRY crPackVertexAttribs3dvNV( GLuint index, GLsizei n, const GLdouble *v )
    103103{
    104         GLint i;
    105         /* reverse order so we hit index 0 last (provoking glVertex) */
    106         for (i = n - 1; i >= 0; i--)
    107                 crPackVertexAttrib3dvARB(index + i, v + 3 * i);
     104    GLint i;
     105    /* reverse order so we hit index 0 last (provoking glVertex) */
     106    for (i = n - 1; i >= 0; i--)
     107        crPackVertexAttrib3dvARB(index + i, v + 3 * i);
    108108}
    109109
    110110void PACK_APIENTRY crPackVertexAttribs3fvNV( GLuint index, GLsizei n, const GLfloat *v )
    111111{
    112         GLint i;
    113         /* reverse order so we hit index 0 last (provoking glVertex) */
    114         for (i = n - 1; i >= 0; i--)
    115                 crPackVertexAttrib3fvARB(index + i, v + 3 * i);
     112    GLint i;
     113    /* reverse order so we hit index 0 last (provoking glVertex) */
     114    for (i = n - 1; i >= 0; i--)
     115        crPackVertexAttrib3fvARB(index + i, v + 3 * i);
    116116}
    117117
    118118void PACK_APIENTRY crPackVertexAttribs3svNV( GLuint index, GLsizei n, const GLshort *v )
    119119{
    120         GLint i;
    121         /* reverse order so we hit index 0 last (provoking glVertex) */
    122         for (i = n - 1; i >= 0; i--)
    123                 crPackVertexAttrib3svARB(index + i, v + 3 * i);
     120    GLint i;
     121    /* reverse order so we hit index 0 last (provoking glVertex) */
     122    for (i = n - 1; i >= 0; i--)
     123        crPackVertexAttrib3svARB(index + i, v + 3 * i);
    124124}
    125125
    126126void PACK_APIENTRY crPackVertexAttribs4dvNV( GLuint index, GLsizei n, const GLdouble *v )
    127127{
    128         GLint i;
    129         /* reverse order so we hit index 0 last (provoking glVertex) */
    130         for (i = n - 1; i >= 0; i--)
    131                 crPackVertexAttrib4dvARB(index + i, v + 4 * i);
     128    GLint i;
     129    /* reverse order so we hit index 0 last (provoking glVertex) */
     130    for (i = n - 1; i >= 0; i--)
     131        crPackVertexAttrib4dvARB(index + i, v + 4 * i);
    132132}
    133133
    134134void PACK_APIENTRY crPackVertexAttribs4fvNV( GLuint index, GLsizei n, const GLfloat *v )
    135135{
    136         GLint i;
    137         /* reverse order so we hit index 0 last (provoking glVertex) */
    138         for (i = n - 1; i >= 0; i--)
    139                 crPackVertexAttrib4fvARB(index + i, v + 4 * i);
     136    GLint i;
     137    /* reverse order so we hit index 0 last (provoking glVertex) */
     138    for (i = n - 1; i >= 0; i--)
     139        crPackVertexAttrib4fvARB(index + i, v + 4 * i);
    140140}
    141141
    142142void PACK_APIENTRY crPackVertexAttribs4svNV( GLuint index, GLsizei n, const GLshort *v )
    143143{
    144         GLint i;
    145         /* reverse order so we hit index 0 last (provoking glVertex) */
    146         for (i = n - 1; i >= 0; i--)
    147                 crPackVertexAttrib4svARB(index + i, v + 4 * i);
     144    GLint i;
     145    /* reverse order so we hit index 0 last (provoking glVertex) */
     146    for (i = n - 1; i >= 0; i--)
     147        crPackVertexAttrib4svARB(index + i, v + 4 * i);
    148148}
    149149
    150150void PACK_APIENTRY crPackVertexAttribs4ubvNV( GLuint index, GLsizei n, const GLubyte *v )
    151151{
    152         GLint i;
    153         /* reverse order so we hit index 0 last (provoking glVertex) */
    154         for (i = n - 1; i >= 0; i--)
    155                 crPackVertexAttrib4ubvARB(index + i, v + 4 * i);
     152    GLint i;
     153    /* reverse order so we hit index 0 last (provoking glVertex) */
     154    for (i = n - 1; i >= 0; i--)
     155        crPackVertexAttrib4ubvARB(index + i, v + 4 * i);
    156156}
    157157
    … …  
    159159void PACK_APIENTRY crPackExecuteProgramNV( GLenum target, GLuint id, const GLfloat *params )
    160160{
    161         const int packet_length = 32;
    162         unsigned char *data_ptr;
    163         GET_PACKER_CONTEXT(pc);
    164 
    165         GET_BUFFERED_POINTER(pc, packet_length);
    166         WRITE_DATA(0, int, packet_length);
    167         WRITE_DATA(4, GLenum, CR_EXECUTEPROGRAMNV_EXTEND_OPCODE);
    168         WRITE_DATA(8, GLenum, target);
    169         WRITE_DATA(12, GLuint, id);
    170         WRITE_DATA(16, GLfloat, params[0] );
    171         WRITE_DATA(20, GLfloat, params[1] );
    172         WRITE_DATA(24, GLfloat, params[2] );
    173         WRITE_DATA(28, GLfloat, params[3] );
    174         WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     161    const int packet_length = 32;
     162    unsigned char *data_ptr;
     163    GET_PACKER_CONTEXT(pc);
     164
     165    GET_BUFFERED_POINTER(pc, packet_length);
     166    WRITE_DATA(0, int, packet_length);
     167    WRITE_DATA(4, GLenum, CR_EXECUTEPROGRAMNV_EXTEND_OPCODE);
     168    WRITE_DATA(8, GLenum, target);
     169    WRITE_DATA(12, GLuint, id);
     170    WRITE_DATA(16, GLfloat, params[0] );
     171    WRITE_DATA(20, GLfloat, params[1] );
     172    WRITE_DATA(24, GLfloat, params[2] );
     173    WRITE_DATA(28, GLfloat, params[3] );
     174    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
    175175}
    176176
    177177void PACK_APIENTRY crPackLoadProgramNV( GLenum target, GLuint id, GLsizei len, const GLubyte *program )
    178178{
    179         const int packet_length = 20 + len;
    180         unsigned char *data_ptr;
    181         GET_PACKER_CONTEXT(pc);
    182 
    183         GET_BUFFERED_POINTER(pc, packet_length);
    184         WRITE_DATA(0, int, packet_length);
    185         WRITE_DATA(4, GLenum, CR_LOADPROGRAMNV_EXTEND_OPCODE);
    186         WRITE_DATA(8, GLenum, target);
    187         WRITE_DATA(12, GLuint, id);
    188         WRITE_DATA(16, GLsizei, len );
    189         crMemcpy( (void *) (data_ptr + 20), program, len );
    190         WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     179    const int packet_length = 20 + len;
     180    unsigned char *data_ptr;
     181    GET_PACKER_CONTEXT(pc);
     182
     183    GET_BUFFERED_POINTER(pc, packet_length);
     184    WRITE_DATA(0, int, packet_length);
     185    WRITE_DATA(4, GLenum, CR_LOADPROGRAMNV_EXTEND_OPCODE);
     186    WRITE_DATA(8, GLenum, target);
     187    WRITE_DATA(12, GLuint, id);
     188    WRITE_DATA(16, GLsizei, len );
     189    crMemcpy( (void *) (data_ptr + 20), program, len );
     190    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
    191191}
    192192
    193193void PACK_APIENTRY crPackRequestResidentProgramsNV( GLsizei n, const GLuint *ids )
    194194{
    195         GET_PACKER_CONTEXT(pc);
    196         (void) pc;
    197         (void) n;
    198         (void) ids;
    199         /* We're no-op'ing this function for now. */
     195    GET_PACKER_CONTEXT(pc);
     196    (void) pc;
     197    (void) n;
     198    (void) ids;
     199    /* We're no-op'ing this function for now. */
    200200}
    201201
    … …  
    203203void PACK_APIENTRY crPackProgramNamedParameter4fNV (GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
    204204{
    205         GET_PACKER_CONTEXT(pc);
    206         unsigned char *data_ptr;
    207         int packet_length = 32 + len;
    208 
    209         GET_BUFFERED_POINTER(pc, packet_length);
    210         WRITE_DATA(0, GLint, packet_length);
    211         WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4FNV_EXTEND_OPCODE);
    212         WRITE_DATA(8, GLuint, id);
    213         WRITE_DATA(12, GLsizei, len);
    214         WRITE_DATA(16, GLfloat, x);
    215         WRITE_DATA(20, GLfloat, y);
    216         WRITE_DATA(24, GLfloat, z);
    217         WRITE_DATA(28, GLfloat, w);
    218         crMemcpy( (void *) (data_ptr + 32), name, len );
    219         WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     205    GET_PACKER_CONTEXT(pc);
     206    unsigned char *data_ptr;
     207    int packet_length = 32 + len;
     208
     209    GET_BUFFERED_POINTER(pc, packet_length);
     210    WRITE_DATA(0, GLint, packet_length);
     211    WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4FNV_EXTEND_OPCODE);
     212    WRITE_DATA(8, GLuint, id);
     213    WRITE_DATA(12, GLsizei, len);
     214    WRITE_DATA(16, GLfloat, x);
     215    WRITE_DATA(20, GLfloat, y);
     216    WRITE_DATA(24, GLfloat, z);
     217    WRITE_DATA(28, GLfloat, w);
     218    crMemcpy( (void *) (data_ptr + 32), name, len );
     219    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
    220220}
    221221
    222222void PACK_APIENTRY crPackProgramNamedParameter4dNV (GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
    223223{
    224         GET_PACKER_CONTEXT(pc);
    225         unsigned char *data_ptr;
    226         int packet_length = 48 + len;
    227 
    228         GET_BUFFERED_POINTER(pc, packet_length);
    229         WRITE_DATA(0, GLint, packet_length);
    230         WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4DNV_EXTEND_OPCODE);
    231         WRITE_DATA(8, GLenum, id);
    232         WRITE_DATA(12, GLuint, len);
    233         WRITE_DOUBLE(16, x);
    234         WRITE_DOUBLE(24, y);
    235         WRITE_DOUBLE(32, z);
    236         WRITE_DOUBLE(40, w);
    237         crMemcpy( (void *) (data_ptr + 48), name, len );
    238 
    239         WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     224    GET_PACKER_CONTEXT(pc);
     225    unsigned char *data_ptr;
     226    int packet_length = 48 + len;
     227
     228    GET_BUFFERED_POINTER(pc, packet_length);
     229    WRITE_DATA(0, GLint, packet_length);
     230    WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4DNV_EXTEND_OPCODE);
     231    WRITE_DATA(8, GLenum, id);
     232    WRITE_DATA(12, GLuint, len);
     233    WRITE_DOUBLE(16, x);
     234    WRITE_DOUBLE(24, y);
     235    WRITE_DOUBLE(32, z);
     236    WRITE_DOUBLE(40, w);
     237    crMemcpy( (void *) (data_ptr + 48), name, len );
     238
     239    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
    240240}
    241241
    242242void PACK_APIENTRY crPackProgramNamedParameter4fvNV (GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
    243243{
    244         crPackProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
     244    crPackProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
    245245}
    246246
    247247void PACK_APIENTRY crPackProgramNamedParameter4dvNV (GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
    248248{
    249         crPackProgramNamedParameter4dNV(id, len, name, v[0], v[1], v[2], v[3]);
     249    crPackProgramNamedParameter4dNV(id, len, name, v[0], v[1], v[2], v[3]);
    250250}
    251251
    … …  
    253253void PACK_APIENTRY
    254254crPackAreProgramsResidentNV(GLsizei n, const GLuint * programs,
    255                                                                                                                 GLboolean *residences, GLboolean *return_val,
    256                                                                                                                 int *writeback)
    257 {
    258         GET_PACKER_CONTEXT(pc);
    259         unsigned char *data_ptr;
    260         int packet_length;
    261 
    262         (void) return_val; /* Caller must compute this from residences!!! */
    263 
    264         packet_length = sizeof(int) +   /* packet length */
    265                 sizeof(GLenum) +                                                /* extend opcode */
    266                 sizeof(n) +                                                                     /* num programs */
    267                 n * sizeof(*programs) +                 /* programs */
    268                 8 + 8;
    269 
    270         GET_BUFFERED_POINTER(pc, packet_length);
    271         WRITE_DATA(0, int, packet_length);
    272         WRITE_DATA(4, GLenum, CR_AREPROGRAMSRESIDENTNV_EXTEND_OPCODE);
    273         WRITE_DATA(8, GLsizei, n);
    274         crMemcpy(data_ptr + 12, programs, n * sizeof(*programs));
    275         WRITE_NETWORK_POINTER(12 + n * sizeof(*programs),       (void *) residences);
    276         WRITE_NETWORK_POINTER(20 + n * sizeof(*programs), (void *) writeback);
    277         WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     255                                                        GLboolean *residences, GLboolean *return_val,
     256                                                        int *writeback)
     257{
     258    GET_PACKER_CONTEXT(pc);
     259    unsigned char *data_ptr;
     260    int packet_length;
     261
     262    (void) return_val; /* Caller must compute this from residences!!! */
     263
     264    packet_length = sizeof(int) +   /* packet length */
     265        sizeof(GLenum) +                        /* extend opcode */
     266        sizeof(n) +                                 /* num programs */
     267        n * sizeof(*programs) +         /* programs */
     268        8 + 8;
     269
     270    GET_BUFFERED_POINTER(pc, packet_length);
     271    WRITE_DATA(0, int, packet_length);
     272    WRITE_DATA(4, GLenum, CR_AREPROGRAMSRESIDENTNV_EXTEND_OPCODE);
     273    WRITE_DATA(8, GLsizei, n);
     274    crMemcpy(data_ptr + 12, programs, n * sizeof(*programs));
     275    WRITE_NETWORK_POINTER(12 + n * sizeof(*programs),   (void *) residences);
     276    WRITE_NETWORK_POINTER(20 + n * sizeof(*programs), (void *) writeback);
     277    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
    278278}
    279279
    … …  
    281281void PACK_APIENTRY crPackGetProgramNamedParameterfvNV( GLuint id, GLsizei len, const GLubyte *name, GLfloat *params, int *writeback )
    282282{
    283         int packet_length = 32 + len;
    284         GET_PACKER_CONTEXT(pc);
    285         unsigned char *data_ptr;
    286         GET_BUFFERED_POINTER( pc, packet_length );
    287         WRITE_DATA( 0, GLint, packet_length );
    288         WRITE_DATA( 4, GLenum, CR_GETPROGRAMNAMEDPARAMETERFVNV_EXTEND_OPCODE );
    289         WRITE_DATA( 8, GLuint, id );
    290         WRITE_DATA( 12, GLsizei, len );
    291         crMemcpy(data_ptr + 16, name, len);
    292         WRITE_NETWORK_POINTER( 16 + len, (void *) params );
    293         WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
    294         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     283    int packet_length = 32 + len;
     284    GET_PACKER_CONTEXT(pc);
     285    unsigned char *data_ptr;
     286    GET_BUFFERED_POINTER( pc, packet_length );
     287    WRITE_DATA( 0, GLint, packet_length );
     288    WRITE_DATA( 4, GLenum, CR_GETPROGRAMNAMEDPARAMETERFVNV_EXTEND_OPCODE );
     289    WRITE_DATA( 8, GLuint, id );
     290    WRITE_DATA( 12, GLsizei, len );
     291    crMemcpy(data_ptr + 16, name, len);
     292    WRITE_NETWORK_POINTER( 16 + len, (void *) params );
     293    WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
     294    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    295295}
    296296
    297297void PACK_APIENTRY crPackGetProgramNamedParameterdvNV( GLuint id, GLsizei len, const GLubyte *name, GLdouble *params, int *writeback )
    298298{
    299         int packet_length = 32 + len;
    300         GET_PACKER_CONTEXT(pc);
    301         unsigned char *data_ptr;
    302         GET_BUFFERED_POINTER( pc, packet_length );
    303         WRITE_DATA( 0, GLint, packet_length );
    304         WRITE_DATA( 4, GLenum, CR_GETPROGRAMNAMEDPARAMETERDVNV_EXTEND_OPCODE );
    305         WRITE_DATA( 8, GLuint, id );
    306         WRITE_DATA( 12, GLsizei, len );
    307         crMemcpy(data_ptr + 16, name, len);
    308         WRITE_NETWORK_POINTER( 16 + len, (void *) params );
    309         WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
    310         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     299    int packet_length = 32 + len;
     300    GET_PACKER_CONTEXT(pc);
     301    unsigned char *data_ptr;
     302    GET_BUFFERED_POINTER( pc, packet_length );
     303    WRITE_DATA( 0, GLint, packet_length );
     304    WRITE_DATA( 4, GLenum, CR_GETPROGRAMNAMEDPARAMETERDVNV_EXTEND_OPCODE );
     305    WRITE_DATA( 8, GLuint, id );
     306    WRITE_DATA( 12, GLsizei, len );
     307    crMemcpy(data_ptr + 16, name, len);
     308    WRITE_NETWORK_POINTER( 16 + len, (void *) params );
     309    WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
     310    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    311311}
    312312
    … …  
    314314void PACK_APIENTRY crPackDeleteProgramsARB( GLsizei n, const GLuint *ids )
    315315{
    316         unsigned char *data_ptr;
    317         int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*ids);
    318 
    319         if (!ids)
    320                 return;
    321 
    322         data_ptr = (unsigned char *) crPackAlloc(packet_length);
    323         WRITE_DATA( 0, GLenum, CR_DELETEPROGRAMSARB_EXTEND_OPCODE );
    324         WRITE_DATA( 4, GLsizei, n );
    325         crMemcpy( data_ptr + 8, ids, n * sizeof(*ids) );
    326         crHugePacket( CR_EXTEND_OPCODE, data_ptr );
    327         crPackFree( data_ptr );
     316    unsigned char *data_ptr;
     317    int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*ids);
     318
     319    if (!ids)
     320        return;
     321
     322    data_ptr = (unsigned char *) crPackAlloc(packet_length);
     323    WRITE_DATA( 0, GLenum, CR_DELETEPROGRAMSARB_EXTEND_OPCODE );
     324    WRITE_DATA( 4, GLsizei, n );
     325    crMemcpy( data_ptr + 8, ids, n * sizeof(*ids) );
     326    crHugePacket( CR_EXTEND_OPCODE, data_ptr );
     327    crPackFree( data_ptr );
    328328}
    329329
    … …  
    331331void PACK_APIENTRY  crPackProgramStringARB( GLenum target, GLenum format, GLsizei len, const void *string )
    332332{
    333         const int packet_length = 20 + len;
    334         unsigned char *data_ptr;
    335         GET_PACKER_CONTEXT(pc);
    336 
    337         GET_BUFFERED_POINTER(pc, packet_length);
    338         WRITE_DATA(0, int, packet_length);
    339         WRITE_DATA(4, GLenum, CR_PROGRAMSTRINGARB_EXTEND_OPCODE);
    340         WRITE_DATA(8, GLenum, target);
    341         WRITE_DATA(12, GLuint, format);
    342         WRITE_DATA(16, GLsizei, len );
    343         crMemcpy( (void *) (data_ptr + 20), string, len );
    344         WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     333    const int packet_length = 20 + len;
     334    unsigned char *data_ptr;
     335    GET_PACKER_CONTEXT(pc);
     336
     337    GET_BUFFERED_POINTER(pc, packet_length);
     338    WRITE_DATA(0, int, packet_length);
     339    WRITE_DATA(4, GLenum, CR_PROGRAMSTRINGARB_EXTEND_OPCODE);
     340    WRITE_DATA(8, GLenum, target);
     341    WRITE_DATA(12, GLuint, format);
     342    WRITE_DATA(16, GLsizei, len );
     343    crMemcpy( (void *) (data_ptr + 20), string, len );
     344    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
    345345}
    346346
    … …  
    353353void PACK_APIENTRY crPackVertexAttrib4NbvARB( GLuint index, const GLbyte *v )
    354354{
    355         GET_PACKER_CONTEXT(pc);
    356         unsigned char *data_ptr;
    357         GET_BUFFERED_POINTER( pc, 8 );
    358         pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
    359         pc->current.attribsUsedMask |= (1 << index);
    360         WRITE_DATA( 0, GLuint, index );
    361         WRITE_DATA( 4, GLbyte, v[0] );
    362         WRITE_DATA( 5, GLbyte, v[1] );
    363         WRITE_DATA( 6, GLbyte, v[2] );
    364         WRITE_DATA( 7, GLbyte, v[3] );
    365         WRITE_OPCODE( pc, CR_VERTEXATTRIB4NBVARB_OPCODE );
     355    GET_PACKER_CONTEXT(pc);
     356    unsigned char *data_ptr;
     357    GET_BUFFERED_POINTER( pc, 8 );
     358    pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
     359    pc->current.attribsUsedMask |= (1 << index);
     360    WRITE_DATA( 0, GLuint, index );
     361    WRITE_DATA( 4, GLbyte, v[0] );
     362    WRITE_DATA( 5, GLbyte, v[1] );
     363    WRITE_DATA( 6, GLbyte, v[2] );
     364    WRITE_DATA( 7, GLbyte, v[3] );
     365    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NBVARB_OPCODE );
    366366}
    367367
    368368void PACK_APIENTRY crPackVertexAttrib4NivARB( GLuint index, const GLint *v )
    369369{
    370         GET_PACKER_CONTEXT(pc);
    371         unsigned char *data_ptr;
    372         GET_BUFFERED_POINTER( pc, 20 );
    373         pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
    374         pc->current.attribsUsedMask |= (1 << index);
    375         WRITE_DATA( 0, GLuint, index );
    376         WRITE_DATA( 4, GLint, v[0] );
    377         WRITE_DATA( 8, GLint, v[1] );
    378         WRITE_DATA( 12, GLint, v[2] );
    379         WRITE_DATA( 16, GLint, v[3] );
    380         WRITE_OPCODE( pc, CR_VERTEXATTRIB4NIVARB_OPCODE );
     370    GET_PACKER_CONTEXT(pc);
     371    unsigned char *data_ptr;
     372    GET_BUFFERED_POINTER( pc, 20 );
     373    pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
     374    pc->current.attribsUsedMask |= (1 << index);
     375    WRITE_DATA( 0, GLuint, index );
     376    WRITE_DATA( 4, GLint, v[0] );
     377    WRITE_DATA( 8, GLint, v[1] );
     378    WRITE_DATA( 12, GLint, v[2] );
     379    WRITE_DATA( 16, GLint, v[3] );
     380    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NIVARB_OPCODE );
    381381}
    382382
    383383void PACK_APIENTRY crPackVertexAttrib4NsvARB( GLuint index, const GLshort *v )
    384384{
    385         GET_PACKER_CONTEXT(pc);
    386         unsigned char *data_ptr;
    387         GET_BUFFERED_POINTER( pc, 12 );
    388         pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
    389         pc->current.attribsUsedMask |= (1 << index);
    390         WRITE_DATA( 0, GLuint, index );
    391         WRITE_DATA( 4, GLshort, v[0] );
    392         WRITE_DATA( 6, GLshort, v[1] );
    393         WRITE_DATA( 8, GLshort, v[2] );
    394         WRITE_DATA( 10, GLshort, v[3] );
    395         WRITE_OPCODE( pc, CR_VERTEXATTRIB4NSVARB_OPCODE );
     385    GET_PACKER_CONTEXT(pc);
     386    unsigned char *data_ptr;
     387    GET_BUFFERED_POINTER( pc, 12 );
     388    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
     389    pc->current.attribsUsedMask |= (1 << index);
     390    WRITE_DATA( 0, GLuint, index );
     391    WRITE_DATA( 4, GLshort, v[0] );
     392    WRITE_DATA( 6, GLshort, v[1] );
     393    WRITE_DATA( 8, GLshort, v[2] );
     394    WRITE_DATA( 10, GLshort, v[3] );
     395    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NSVARB_OPCODE );
    396396}
    397397
    398398void PACK_APIENTRY crPackVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
    399399{
    400         GET_PACKER_CONTEXT(pc);
    401         unsigned char *data_ptr;
    402         GET_BUFFERED_POINTER( pc, 8 );
    403         pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
    404         pc->current.attribsUsedMask |= (1 << index);
    405         WRITE_DATA( 0, GLuint, index );
    406         WRITE_DATA( 4, GLubyte, v[0] );
    407         WRITE_DATA( 5, GLubyte, v[1] );
    408         WRITE_DATA( 6, GLubyte, v[2] );
    409         WRITE_DATA( 7, GLubyte, v[3] );
    410         WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUBVARB_OPCODE );
     400    GET_PACKER_CONTEXT(pc);
     401    unsigned char *data_ptr;
     402    GET_BUFFERED_POINTER( pc, 8 );
     403    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
     404    pc->current.attribsUsedMask |= (1 << index);
     405    WRITE_DATA( 0, GLuint, index );
     406    WRITE_DATA( 4, GLubyte, v[0] );
     407    WRITE_DATA( 5, GLubyte, v[1] );
     408    WRITE_DATA( 6, GLubyte, v[2] );
     409    WRITE_DATA( 7, GLubyte, v[3] );
     410    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUBVARB_OPCODE );
    411411}
    412412
    413413void PACK_APIENTRY crPackVertexAttrib4NuivARB(GLuint index, const GLuint * v)
    414414{
    415         GET_PACKER_CONTEXT(pc);
    416         unsigned char *data_ptr;
    417         GET_BUFFERED_POINTER( pc, 20 );
    418         pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
    419         pc->current.attribsUsedMask |= (1 << index);
    420         WRITE_DATA( 0, GLuint, index );
    421         WRITE_DATA( 4, GLuint, v[0] );
    422         WRITE_DATA( 8, GLuint, v[1] );
    423         WRITE_DATA( 12, GLuint, v[2] );
    424         WRITE_DATA( 16, GLuint, v[3] );
    425         WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUIVARB_OPCODE );
     415    GET_PACKER_CONTEXT(pc);
     416    unsigned char *data_ptr;
     417    GET_BUFFERED_POINTER( pc, 20 );
     418    pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
     419    pc->current.attribsUsedMask |= (1 << index);
     420    WRITE_DATA( 0, GLuint, index );
     421    WRITE_DATA( 4, GLuint, v[0] );
     422    WRITE_DATA( 8, GLuint, v[1] );
     423    WRITE_DATA( 12, GLuint, v[2] );
     424    WRITE_DATA( 16, GLuint, v[3] );
     425    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUIVARB_OPCODE );
    426426}
    427427
    428428void PACK_APIENTRY crPackVertexAttrib4NusvARB(GLuint index, const GLushort * v)
    429429{
    430         GET_PACKER_CONTEXT(pc);
    431         unsigned char *data_ptr;
    432         GET_BUFFERED_POINTER( pc, 12 );
    433         pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
    434         pc->current.attribsUsedMask |= (1 << index);
    435         WRITE_DATA( 0, GLuint, index );
    436         WRITE_DATA( 4, GLushort, v[0] );
    437         WRITE_DATA( 6, GLushort, v[1] );
    438         WRITE_DATA( 8, GLushort, v[2] );
    439         WRITE_DATA( 10, GLushort, v[3] );
    440         WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUSVARB_OPCODE );
     430    GET_PACKER_CONTEXT(pc);
     431    unsigned char *data_ptr;
     432    GET_BUFFERED_POINTER( pc, 12 );
     433    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
     434    pc->current.attribsUsedMask |= (1 << index);
     435    WRITE_DATA( 0, GLuint, index );
     436    WRITE_DATA( 4, GLushort, v[0] );
     437    WRITE_DATA( 6, GLushort, v[1] );
     438    WRITE_DATA( 8, GLushort, v[2] );
     439    WRITE_DATA( 10, GLushort, v[3] );
     440    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUSVARB_OPCODE );
    441441}
    442442
    443443void PACK_APIENTRY crPackVertexAttrib4bvARB(GLuint index, const GLbyte * v)
    444444{
    445         GET_PACKER_CONTEXT(pc);
    446         unsigned char *data_ptr;
    447         GET_BUFFERED_POINTER( pc, 8 );
    448         pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
    449         pc->current.attribsUsedMask |= (1 << index);
    450         WRITE_DATA( 0, GLuint, index );
    451         WRITE_DATA( 4, GLbyte, v[0] );
    452         WRITE_DATA( 5, GLbyte, v[1] );
    453         WRITE_DATA( 6, GLbyte, v[2] );
    454         WRITE_DATA( 7, GLbyte, v[3] );
    455         WRITE_OPCODE( pc, CR_VERTEXATTRIB4BVARB_OPCODE );
     445    GET_PACKER_CONTEXT(pc);
     446    unsigned char *data_ptr;
     447    GET_BUFFERED_POINTER( pc, 8 );
     448    pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
     449    pc->current.attribsUsedMask |= (1 << index);
     450    WRITE_DATA( 0, GLuint, index );
     451    WRITE_DATA( 4, GLbyte, v[0] );
     452    WRITE_DATA( 5, GLbyte, v[1] );
     453    WRITE_DATA( 6, GLbyte, v[2] );
     454    WRITE_DATA( 7, GLbyte, v[3] );
     455    WRITE_OPCODE( pc, CR_VERTEXATTRIB4BVARB_OPCODE );
    456456}
    457457
    458458void PACK_APIENTRY crPackVertexAttrib4ivARB(GLuint index, const GLint * v)
    459459{
    460         GET_PACKER_CONTEXT(pc);
    461         unsigned char *data_ptr;
    462         GET_BUFFERED_POINTER( pc, 20 );
    463         pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
    464         pc->current.attribsUsedMask |= (1 << index);
    465         WRITE_DATA( 0, GLuint, index );
    466         WRITE_DATA( 4, GLint, v[0] );
    467         WRITE_DATA( 8, GLint, v[1] );
    468         WRITE_DATA( 12, GLint, v[2] );
    469         WRITE_DATA( 16, GLint, v[3] );
    470         WRITE_OPCODE( pc, CR_VERTEXATTRIB4IVARB_OPCODE );
     460    GET_PACKER_CONTEXT(pc);
     461    unsigned char *data_ptr;
     462    GET_BUFFERED_POINTER( pc, 20 );
     463    pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
     464    pc->current.attribsUsedMask |= (1 << index);
     465    WRITE_DATA( 0, GLuint, index );
     466    WRITE_DATA( 4, GLint, v[0] );
     467    WRITE_DATA( 8, GLint, v[1] );
     468    WRITE_DATA( 12, GLint, v[2] );
     469    WRITE_DATA( 16, GLint, v[3] );
     470    WRITE_OPCODE( pc, CR_VERTEXATTRIB4IVARB_OPCODE );
    471471}
    472472
    473473void PACK_APIENTRY crPackVertexAttrib4uivARB(GLuint index, const GLuint * v)
    474474{
    475         GET_PACKER_CONTEXT(pc);
    476         unsigned char *data_ptr;
    477         GET_BUFFERED_POINTER( pc, 20 );
    478         pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
    479         pc->current.attribsUsedMask |= (1 << index);
    480         WRITE_DATA( 0, GLuint, index );
    481         WRITE_DATA( 4, GLuint, v[0] );
    482         WRITE_DATA( 8, GLuint, v[1] );
    483         WRITE_DATA( 12, GLuint, v[2] );
    484         WRITE_DATA( 16, GLuint, v[3] );
    485         WRITE_OPCODE( pc, CR_VERTEXATTRIB4UIVARB_OPCODE );
     475    GET_PACKER_CONTEXT(pc);
     476    unsigned char *data_ptr;
     477    GET_BUFFERED_POINTER( pc, 20 );
     478    pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
     479    pc->current.attribsUsedMask |= (1 << index);
     480    WRITE_DATA( 0, GLuint, index );
     481    WRITE_DATA( 4, GLuint, v[0] );
     482    WRITE_DATA( 8, GLuint, v[1] );
     483    WRITE_DATA( 12, GLuint, v[2] );
     484    WRITE_DATA( 16, GLuint, v[3] );
     485    WRITE_OPCODE( pc, CR_VERTEXATTRIB4UIVARB_OPCODE );
    486486}
    487487
    488488void PACK_APIENTRY crPackVertexAttrib4usvARB(GLuint index, const GLushort * v)
    489489{
    490         GET_PACKER_CONTEXT(pc);
    491         unsigned char *data_ptr;
    492         GET_BUFFERED_POINTER( pc, 12 );
    493         pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
    494         pc->current.attribsUsedMask |= (1 << index);
    495         WRITE_DATA( 0, GLuint, index );
    496         WRITE_DATA( 4, GLushort, v[0] );
    497         WRITE_DATA( 6, GLushort, v[1] );
    498         WRITE_DATA( 8, GLushort, v[2] );
    499         WRITE_DATA( 10, GLushort, v[3] );
    500         WRITE_OPCODE( pc, CR_VERTEXATTRIB4USVARB_OPCODE );
     490    GET_PACKER_CONTEXT(pc);
     491    unsigned char *data_ptr;
     492    GET_BUFFERED_POINTER( pc, 12 );
     493    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
     494    pc->current.attribsUsedMask |= (1 << index);
     495    WRITE_DATA( 0, GLuint, index );
     496    WRITE_DATA( 4, GLushort, v[0] );
     497    WRITE_DATA( 6, GLushort, v[1] );
     498    WRITE_DATA( 8, GLushort, v[2] );
     499    WRITE_DATA( 10, GLushort, v[3] );
     500    WRITE_OPCODE( pc, CR_VERTEXATTRIB4USVARB_OPCODE );
    501501}
    502502
    … …  
    504504void PACK_APIENTRY crPackVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
    505505{
    506         GET_PACKER_CONTEXT(pc);
    507         unsigned char *data_ptr;
    508         GET_BUFFERED_POINTER( pc, 8 );
    509         pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
    510         pc->current.attribsUsedMask |= (1 << index);
    511         WRITE_DATA( 0, GLuint, index );
    512         WRITE_DATA( 4, GLubyte, v[0] );
    513         WRITE_DATA( 5, GLubyte, v[1] );
    514         WRITE_DATA( 6, GLubyte, v[2] );
    515         WRITE_DATA( 7, GLubyte, v[3] );
    516         WRITE_OPCODE( pc, CR_VERTEXATTRIB4UBVARB_OPCODE );
    517 }
    518 
     506    GET_PACKER_CONTEXT(pc);
     507    unsigned char *data_ptr;
     508    GET_BUFFERED_POINTER( pc, 8 );
     509    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
     510    pc->current.attribsUsedMask |= (1 << index);
     511    WRITE_DATA( 0, GLuint, index );
     512    WRITE_DATA( 4, GLubyte, v[0] );
     513    WRITE_DATA( 5, GLubyte, v[1] );
     514    WRITE_DATA( 6, GLubyte, v[2] );
     515    WRITE_DATA( 7, GLubyte, v[3] );
     516    WRITE_OPCODE( pc, CR_VERTEXATTRIB4UBVARB_OPCODE );
     517}
     518

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_regcombiner.c

    r15532 r33457  
    1010static GLboolean __handleCombinerParameterData( GLenum pname, const GLfloat *params, GLenum extended_opcode )
    1111{
    12         GET_PACKER_CONTEXT(pc);
    13         unsigned int params_length = 0;
    14         unsigned int packet_length = sizeof( int ) + sizeof( extended_opcode ) + sizeof( pname );
    15         unsigned char *data_ptr;
     12    GET_PACKER_CONTEXT(pc);
     13    unsigned int params_length = 0;
     14    unsigned int packet_length = sizeof( int ) + sizeof( extended_opcode ) + sizeof( pname );
     15    unsigned char *data_ptr;
    1616
    17         switch( pname )
    18         {
    19                 case GL_CONSTANT_COLOR0_NV:
    20                 case GL_CONSTANT_COLOR1_NV:
    21                         params_length = 4 * sizeof( *params );
    22                         break;
    23                 case GL_NUM_GENERAL_COMBINERS_NV:
    24                 case GL_COLOR_SUM_CLAMP_NV:
    25                         params_length = sizeof( *params );
    26                         break;
    27                 default:
    28                         __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    29                                                                         "crPackCombinerParameter(bad pname)" );
    30                         CRASSERT(0);
    31                         return GL_FALSE;
    32         }
    33         packet_length += params_length;
    34         GET_BUFFERED_POINTER(pc, packet_length );
    35         WRITE_DATA( 0, int, packet_length );
    36         WRITE_DATA( sizeof( int ) + 0, GLenum, extended_opcode );
    37         WRITE_DATA( sizeof( int ) + 4, GLenum, pname );
    38         WRITE_DATA( sizeof( int ) + 8, GLfloat, params[0] );
    39         if (params_length > sizeof( *params ))
    40         {
    41                 WRITE_DATA( sizeof( int ) + 12, GLfloat, params[1] );
    42                 WRITE_DATA( sizeof( int ) + 16, GLfloat, params[2] );
    43                 WRITE_DATA( sizeof( int ) + 20, GLfloat, params[3] );
    44                 CRASSERT(packet_length == sizeof(int) + 20 + 4);
    45         }
    46         return GL_TRUE;
     17    switch( pname )
     18    {
     19        case GL_CONSTANT_COLOR0_NV:
     20        case GL_CONSTANT_COLOR1_NV:
     21            params_length = 4 * sizeof( *params );
     22            break;
     23        case GL_NUM_GENERAL_COMBINERS_NV:
     24        case GL_COLOR_SUM_CLAMP_NV:
     25            params_length = sizeof( *params );
     26            break;
     27        default:
     28            __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     29                                    "crPackCombinerParameter(bad pname)" );
     30            CRASSERT(0);
     31            return GL_FALSE;
     32    }
     33    packet_length += params_length;
     34    GET_BUFFERED_POINTER(pc, packet_length );
     35    WRITE_DATA( 0, int, packet_length );
     36    WRITE_DATA( sizeof( int ) + 0, GLenum, extended_opcode );
     37    WRITE_DATA( sizeof( int ) + 4, GLenum, pname );
     38    WRITE_DATA( sizeof( int ) + 8, GLfloat, params[0] );
     39    if (params_length > sizeof( *params ))
     40    {
     41        WRITE_DATA( sizeof( int ) + 12, GLfloat, params[1] );
     42        WRITE_DATA( sizeof( int ) + 16, GLfloat, params[2] );
     43        WRITE_DATA( sizeof( int ) + 20, GLfloat, params[3] );
     44        CRASSERT(packet_length == sizeof(int) + 20 + 4);
     45    }
     46    return GL_TRUE;
    4747}
    4848
    4949void PACK_APIENTRY crPackCombinerParameterfvNV( GLenum pname, const GLfloat *params )
    5050{
    51         GET_PACKER_CONTEXT(pc);
    52         if (__handleCombinerParameterData( pname, params, CR_COMBINERPARAMETERFVNV_EXTEND_OPCODE ))
    53                 WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     51    GET_PACKER_CONTEXT(pc);
     52    if (__handleCombinerParameterData( pname, params, CR_COMBINERPARAMETERFVNV_EXTEND_OPCODE ))
     53        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    5454}
    5555
    5656void PACK_APIENTRY crPackCombinerParameterivNV( GLenum pname, const GLint *params )
    5757{
    58         /* floats and ints are the same size, so the packing should be the same */
    59         GET_PACKER_CONTEXT(pc);
    60         if (__handleCombinerParameterData( pname, (const GLfloat *) params, CR_COMBINERPARAMETERIVNV_EXTEND_OPCODE ))
    61                 WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     58    /* floats and ints are the same size, so the packing should be the same */
     59    GET_PACKER_CONTEXT(pc);
     60    if (__handleCombinerParameterData( pname, (const GLfloat *) params, CR_COMBINERPARAMETERIVNV_EXTEND_OPCODE ))
     61        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    6262}
    6363
    6464void PACK_APIENTRY crPackCombinerStageParameterfvNV( GLenum stage, GLenum pname, const GLfloat *params )
    6565{
    66         GET_PACKER_CONTEXT(pc);
    67         unsigned char *data_ptr;
     66    GET_PACKER_CONTEXT(pc);
     67    unsigned char *data_ptr;
    6868
    69         GET_BUFFERED_POINTER(pc, 32 );
    70         WRITE_DATA( 0, GLint, 32 );
    71         WRITE_DATA( 4, GLenum, CR_COMBINERSTAGEPARAMETERFVNV_EXTEND_OPCODE );
    72         WRITE_DATA( 8, GLenum, stage );
    73         WRITE_DATA( 12, GLenum, pname );
    74         WRITE_DATA( 16, GLfloat, params[0] );
    75         WRITE_DATA( 20, GLfloat, params[1] );
    76         WRITE_DATA( 24, GLfloat, params[2] );
    77         WRITE_DATA( 28, GLfloat, params[3] );
    78         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     69    GET_BUFFERED_POINTER(pc, 32 );
     70    WRITE_DATA( 0, GLint, 32 );
     71    WRITE_DATA( 4, GLenum, CR_COMBINERSTAGEPARAMETERFVNV_EXTEND_OPCODE );
     72    WRITE_DATA( 8, GLenum, stage );
     73    WRITE_DATA( 12, GLenum, pname );
     74    WRITE_DATA( 16, GLfloat, params[0] );
     75    WRITE_DATA( 20, GLfloat, params[1] );
     76    WRITE_DATA( 24, GLfloat, params[2] );
     77    WRITE_DATA( 28, GLfloat, params[3] );
     78    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    7979}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_swap_lists.c

    r15532 r33457  
    1111static int __gl_CallListsNumBytes( GLenum type )
    1212{
    13         switch( type )
    14         {
    15                 case GL_BYTE:
    16                 case GL_UNSIGNED_BYTE:
    17                 case GL_2_BYTES:
    18                         return 1;
    19                 case GL_SHORT:
    20                 case GL_UNSIGNED_SHORT:
    21                 case GL_3_BYTES:
    22                         return 2;
    23                 case GL_INT:
    24                 case GL_UNSIGNED_INT:
    25                 case GL_FLOAT:
    26                 case GL_4_BYTES:
    27                         return 4;
    28                 default:
    29                         return -1;
    30         }
     13    switch( type )
     14    {
     15        case GL_BYTE:
     16        case GL_UNSIGNED_BYTE:
     17        case GL_2_BYTES:
     18            return 1;
     19        case GL_SHORT:
     20        case GL_UNSIGNED_SHORT:
     21        case GL_3_BYTES:
     22            return 2;
     23        case GL_INT:
     24        case GL_UNSIGNED_INT:
     25        case GL_FLOAT:
     26        case GL_4_BYTES:
     27            return 4;
     28        default:
     29            return -1;
     30    }
    3131}
    3232
    3333void PACK_APIENTRY crPackCallListsSWAP(GLint n, GLenum type,
    34                 const GLvoid *lists )
     34        const GLvoid *lists )
    3535{
    36         unsigned char *data_ptr;
    37         int packet_length;
    38         GLshort *shortPtr;
    39         GLint   *intPtr;
    40         int i;
     36    unsigned char *data_ptr;
     37    int packet_length;
     38    GLshort *shortPtr;
     39    GLint   *intPtr;
     40    int i;
    4141
    42         int bytesPerList = __gl_CallListsNumBytes( type );
    43         int numBytes = bytesPerList * n;
     42    int bytesPerList = __gl_CallListsNumBytes( type );
     43    int numBytes = bytesPerList * n;
    4444
    45         if (numBytes < 0)
    46         {
    47                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    48                                                                 "crPackCallLists(bad type)" );
    49                 return;
    50         }
     45    if (numBytes < 0)
     46    {
     47        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     48                                "crPackCallLists(bad type)" );
     49        return;
     50    }
    5151
    52         packet_length = sizeof( n ) +
    53                 sizeof( type ) +
    54                 numBytes;
     52    packet_length = sizeof( n ) +
     53        sizeof( type ) +
     54        numBytes;
    5555
    56         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    57         WRITE_DATA( 0, GLint, SWAP32(n) );
    58         WRITE_DATA( 4, GLenum, SWAP32(type) );
     56    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     57    WRITE_DATA( 0, GLint, SWAP32(n) );
     58    WRITE_DATA( 4, GLenum, SWAP32(type) );
    5959
    60         crMemcpy( data_ptr + 8, lists, numBytes );
    61         shortPtr = (GLshort *) (data_ptr + 8);
    62         intPtr   = (GLint *) (data_ptr + 8);
     60    crMemcpy( data_ptr + 8, lists, numBytes );
     61    shortPtr = (GLshort *) (data_ptr + 8);
     62    intPtr   = (GLint *) (data_ptr + 8);
    6363
    64         if (bytesPerList > 1)
    65         {
    66                 for ( i = 0 ; i < n ; i++)
    67                 {
    68                         switch( bytesPerList )
    69                         {
    70                                 case 2:
    71                                   *shortPtr = SWAP16(*shortPtr);
    72                                   shortPtr+=1;
    73                                         break;
    74                                 case 4:
    75                                   *intPtr = SWAP32(*intPtr);
    76                                   intPtr+=1;
    77                                         break;
    78                         }
    79                 }
    80         }
     64    if (bytesPerList > 1)
     65    {
     66        for ( i = 0 ; i < n ; i++)
     67        {
     68            switch( bytesPerList )
     69            {
     70                case 2:
     71                  *shortPtr = SWAP16(*shortPtr);
     72                  shortPtr+=1;
     73                    break;
     74                case 4:
     75                  *intPtr = SWAP32(*intPtr);
     76                  intPtr+=1;
     77                    break;
     78            }
     79        }
     80    }
    8181
    82         crHugePacket( CR_CALLLISTS_OPCODE, data_ptr );
    83         crPackFree( data_ptr );
     82    crHugePacket( CR_CALLLISTS_OPCODE, data_ptr );
     83    crPackFree( data_ptr );
    8484}
    8585
    … …  
    8787void PACK_APIENTRY crPackNewListSWAP( GLuint list, GLenum mode )
    8888{
    89         GET_PACKER_CONTEXT(pc);
    90         unsigned char *data_ptr;
    91         (void) pc;
    92         GET_BUFFERED_POINTER( pc, 16 );
    93         WRITE_DATA( 0, GLint, SWAP32(16) );
    94         WRITE_DATA( 4, GLenum, SWAP32(CR_NEWLIST_EXTEND_OPCODE) );
    95         WRITE_DATA( 8, GLuint, SWAP32(list) );
    96         WRITE_DATA( 12, GLenum, SWAP32(mode) );
    97         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    98         pc->buffer.in_List = GL_TRUE;
    99         pc->buffer.holds_List = GL_TRUE;
     89    GET_PACKER_CONTEXT(pc);
     90    unsigned char *data_ptr;
     91    (void) pc;
     92    GET_BUFFERED_POINTER( pc, 16 );
     93    WRITE_DATA( 0, GLint, SWAP32(16) );
     94    WRITE_DATA( 4, GLenum, SWAP32(CR_NEWLIST_EXTEND_OPCODE) );
     95    WRITE_DATA( 8, GLuint, SWAP32(list) );
     96    WRITE_DATA( 12, GLenum, SWAP32(mode) );
     97    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     98    pc->buffer.in_List = GL_TRUE;
     99    pc->buffer.holds_List = GL_TRUE;
    100100}
    101101
    … …  
    103103void PACK_APIENTRY crPackEndListSWAP( void )
    104104{
    105         GET_PACKER_CONTEXT(pc);
    106         unsigned char *data_ptr;
    107         (void) pc;
    108         GET_BUFFERED_POINTER( pc, 8 );
    109         WRITE_DATA( 0, GLint, SWAP32(8) );
    110         WRITE_DATA( 4, GLenum, SWAP32(CR_ENDLIST_EXTEND_OPCODE) );
    111         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    112         pc->buffer.in_List = GL_FALSE;
     105    GET_PACKER_CONTEXT(pc);
     106    unsigned char *data_ptr;
     107    (void) pc;
     108    GET_BUFFERED_POINTER( pc, 8 );
     109    WRITE_DATA( 0, GLint, SWAP32(8) );
     110    WRITE_DATA( 4, GLenum, SWAP32(CR_ENDLIST_EXTEND_OPCODE) );
     111    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     112    pc->buffer.in_List = GL_FALSE;
    113113}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_swap_map.c

    r15532 r33457  
    1616static int __gl_Map2NumComponents( GLenum target )
    1717{
    18         switch( target )
    19         {
    20         case GL_MAP2_VERTEX_3:
    21         case GL_MAP2_NORMAL:
    22         case GL_MAP2_TEXTURE_COORD_3:
    23                 return 3;
    24         case GL_MAP2_VERTEX_4:
    25         case GL_MAP2_COLOR_4:
    26         case GL_MAP2_TEXTURE_COORD_4:
    27                 return 4;
    28         case GL_MAP2_INDEX:
    29         case GL_MAP2_TEXTURE_COORD_1:
    30                 return 1;
    31         case GL_MAP2_TEXTURE_COORD_2:
    32                 return 2;
    33         default:
    34                 return -1;
    35         }
     18    switch( target )
     19    {
     20    case GL_MAP2_VERTEX_3:
     21    case GL_MAP2_NORMAL:
     22    case GL_MAP2_TEXTURE_COORD_3:
     23        return 3;
     24    case GL_MAP2_VERTEX_4:
     25    case GL_MAP2_COLOR_4:
     26    case GL_MAP2_TEXTURE_COORD_4:
     27        return 4;
     28    case GL_MAP2_INDEX:
     29    case GL_MAP2_TEXTURE_COORD_1:
     30        return 1;
     31    case GL_MAP2_TEXTURE_COORD_2:
     32        return 2;
     33    default:
     34        return -1;
     35    }
    3636}
    3737
    3838static int __gl_Map1NumComponents( GLenum target )
    3939{
    40         switch( target )
    41         {
    42         case GL_MAP1_VERTEX_3:
    43         case GL_MAP1_NORMAL:
    44         case GL_MAP1_TEXTURE_COORD_3:
    45                 return 3;
    46         case GL_MAP1_VERTEX_4:
    47         case GL_MAP1_COLOR_4:
    48         case GL_MAP1_TEXTURE_COORD_4:
    49                 return 4;
    50         case GL_MAP1_INDEX:
    51         case GL_MAP1_TEXTURE_COORD_1:
    52                 return 1;
    53         case GL_MAP1_TEXTURE_COORD_2:
    54                 return 2;
    55         default:
    56                 return -1;
    57         }
     40    switch( target )
     41    {
     42    case GL_MAP1_VERTEX_3:
     43    case GL_MAP1_NORMAL:
     44    case GL_MAP1_TEXTURE_COORD_3:
     45        return 3;
     46    case GL_MAP1_VERTEX_4:
     47    case GL_MAP1_COLOR_4:
     48    case GL_MAP1_TEXTURE_COORD_4:
     49        return 4;
     50    case GL_MAP1_INDEX:
     51    case GL_MAP1_TEXTURE_COORD_1:
     52        return 1;
     53    case GL_MAP1_TEXTURE_COORD_2:
     54        return 2;
     55    default:
     56        return -1;
     57    }
    5858}
    5959
    6060void PACK_APIENTRY crPackMap2dSWAP(GLenum target, GLdouble u1,
    61                 GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2,
    62                 GLint vstride, GLint vorder, const GLdouble *points)
    63 {
    64         unsigned char *data_ptr;
    65         int u,v;
    66         int comp;
    67         GLdouble *dest_data, *src_data;
    68         int packet_length =
    69                 sizeof( target ) +
    70                 sizeof( u1 ) +
    71                 sizeof( u2 ) +
    72                 sizeof( uorder ) +
    73                 sizeof( ustride ) +
    74                 sizeof( v1 ) +
    75                 sizeof( v2 ) +
    76                 sizeof( vorder ) +
    77                 sizeof( vstride );
    78 
    79         int num_components = __gl_Map2NumComponents( target );
    80         if (num_components < 0)
    81         {
    82                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    83                                                                 "crPackMap2d(bad target)" );
    84                 return;
    85         }
    86 
    87         packet_length += num_components*uorder*vorder*sizeof( *points );
    88 
    89         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    90 
    91         WRITE_DATA( 0, GLenum, SWAP32(target) );
    92         WRITE_SWAPPED_DOUBLE( 4, u1 );
    93         WRITE_SWAPPED_DOUBLE( 12, u2 );
    94         WRITE_DATA( 20, GLint, SWAP32(num_components) );
    95         WRITE_DATA( 24, GLint, SWAP32(uorder) );
    96         WRITE_SWAPPED_DOUBLE( 28, v1 );
    97         WRITE_SWAPPED_DOUBLE( 36, v2 );
    98         WRITE_DATA( 44, GLint, SWAP32(num_components*uorder) );
    99         WRITE_DATA( 48, GLint, SWAP32(vorder) );
    100 
    101         dest_data = (GLdouble *) (data_ptr + 52);
    102         src_data = (GLdouble *) points;
    103         for (v = 0 ; v < vorder ; v++)
    104         {
    105                 for (u = 0 ; u < uorder ; u++)
    106                 {
    107                         for (comp = 0 ; comp < num_components ; comp++)
    108                         {
    109                                 WRITE_SWAPPED_DOUBLE( ((unsigned char *) dest_data + comp*sizeof(*points)) - data_ptr, *(src_data + comp) );
    110                         }
    111                         dest_data += num_components;
    112                         src_data += ustride;
    113                 }
    114                 src_data += vstride - ustride*uorder;
    115         }
    116 
    117         crHugePacket( CR_MAP2D_OPCODE, data_ptr );
    118         crPackFree( data_ptr );
     61        GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2,
     62        GLint vstride, GLint vorder, const GLdouble *points)
     63{
     64    unsigned char *data_ptr;
     65    int u,v;
     66    int comp;
     67    GLdouble *dest_data, *src_data;
     68    int packet_length =
     69        sizeof( target ) +
     70        sizeof( u1 ) +
     71        sizeof( u2 ) +
     72        sizeof( uorder ) +
     73        sizeof( ustride ) +
     74        sizeof( v1 ) +
     75        sizeof( v2 ) +
     76        sizeof( vorder ) +
     77        sizeof( vstride );
     78
     79    int num_components = __gl_Map2NumComponents( target );
     80    if (num_components < 0)
     81    {
     82        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     83                                "crPackMap2d(bad target)" );
     84        return;
     85    }
     86
     87    packet_length += num_components*uorder*vorder*sizeof( *points );
     88
     89    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     90
     91    WRITE_DATA( 0, GLenum, SWAP32(target) );
     92    WRITE_SWAPPED_DOUBLE( 4, u1 );
     93    WRITE_SWAPPED_DOUBLE( 12, u2 );
     94    WRITE_DATA( 20, GLint, SWAP32(num_components) );
     95    WRITE_DATA( 24, GLint, SWAP32(uorder) );
     96    WRITE_SWAPPED_DOUBLE( 28, v1 );
     97    WRITE_SWAPPED_DOUBLE( 36, v2 );
     98    WRITE_DATA( 44, GLint, SWAP32(num_components*uorder) );
     99    WRITE_DATA( 48, GLint, SWAP32(vorder) );
     100
     101    dest_data = (GLdouble *) (data_ptr + 52);
     102    src_data = (GLdouble *) points;
     103    for (v = 0 ; v < vorder ; v++)
     104    {
     105        for (u = 0 ; u < uorder ; u++)
     106        {
     107            for (comp = 0 ; comp < num_components ; comp++)
     108            {
     109                WRITE_SWAPPED_DOUBLE( ((unsigned char *) dest_data + comp*sizeof(*points)) - data_ptr, *(src_data + comp) );
     110            }
     111            dest_data += num_components;
     112            src_data += ustride;
     113        }
     114        src_data += vstride - ustride*uorder;
     115    }
     116
     117    crHugePacket( CR_MAP2D_OPCODE, data_ptr );
     118    crPackFree( data_ptr );
    119119}
    120120
    121121void PACK_APIENTRY crPackMap2fSWAP(GLenum target, GLfloat u1,
    122                 GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2,
    123                 GLint vstride, GLint vorder, const GLfloat *points)
    124 {
    125         unsigned char *data_ptr;
    126         int u,v;
    127         int comp;
    128         GLfloat *dest_data, *src_data;
    129         int packet_length =
    130                 sizeof( target ) +
    131                 sizeof( u1 ) +
    132                 sizeof( u2 ) +
    133                 sizeof( uorder ) +
    134                 sizeof( ustride ) +
    135                 sizeof( v1 ) +
    136                 sizeof( v2 ) +
    137                 sizeof( vorder ) +
    138                 sizeof( vstride );
    139 
    140         int num_components = __gl_Map2NumComponents( target );
    141         if (num_components < 0)
    142         {
    143                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    144                                                                 "crPackMap2f(bad target)" );
    145                 return;
    146         }
    147 
    148         packet_length += num_components*uorder*vorder*sizeof( *points );
    149 
    150         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    151 
    152         WRITE_DATA( 0, GLenum, SWAP32(target) );
    153         WRITE_DATA( 4, GLuint, SWAPFLOAT(u1) );
    154         WRITE_DATA( 8, GLuint, SWAPFLOAT(u2) );
    155         WRITE_DATA( 12, GLint, SWAP32(num_components) );
    156         WRITE_DATA( 16, GLint, SWAP32(uorder) );
    157         WRITE_DATA( 20, GLuint, SWAPFLOAT(v1) );
    158         WRITE_DATA( 24, GLuint, SWAPFLOAT(v2) );
    159         WRITE_DATA( 28, GLint, SWAP32(num_components*uorder) );
    160         WRITE_DATA( 32, GLint, SWAP32(vorder) );
    161 
    162         dest_data = (GLfloat *) (data_ptr + 36);
    163         src_data = (GLfloat *) points;
    164         for (v = 0 ; v < vorder ; v++)
    165         {
    166                 for (u = 0 ; u < uorder ; u++)
    167                 {
    168                         for (comp = 0 ; comp < num_components ; comp++)
    169                         {
    170                                 WRITE_DATA( (unsigned char *) dest_data + comp*sizeof(*points) - data_ptr, GLuint, SWAPFLOAT( *(src_data + comp) ) );
    171                         }
    172                         dest_data += num_components;
    173                         src_data += ustride;
    174                 }
    175                 src_data += vstride - ustride*uorder;
    176         }
    177 
    178         crHugePacket( CR_MAP2F_OPCODE, data_ptr );
    179         crPackFree( data_ptr );
     122        GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2,
     123        GLint vstride, GLint vorder, const GLfloat *points)
     124{
     125    unsigned char *data_ptr;
     126    int u,v;
     127    int comp;
     128    GLfloat *dest_data, *src_data;
     129    int packet_length =
     130        sizeof( target ) +
     131        sizeof( u1 ) +
     132        sizeof( u2 ) +
     133        sizeof( uorder ) +
     134        sizeof( ustride ) +
     135        sizeof( v1 ) +
     136        sizeof( v2 ) +
     137        sizeof( vorder ) +
     138        sizeof( vstride );
     139
     140    int num_components = __gl_Map2NumComponents( target );
     141    if (num_components < 0)
     142    {
     143        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     144                                "crPackMap2f(bad target)" );
     145        return;
     146    }
     147
     148    packet_length += num_components*uorder*vorder*sizeof( *points );
     149
     150    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     151
     152    WRITE_DATA( 0, GLenum, SWAP32(target) );
     153    WRITE_DATA( 4, GLuint, SWAPFLOAT(u1) );
     154    WRITE_DATA( 8, GLuint, SWAPFLOAT(u2) );
     155    WRITE_DATA( 12, GLint, SWAP32(num_components) );
     156    WRITE_DATA( 16, GLint, SWAP32(uorder) );
     157    WRITE_DATA( 20, GLuint, SWAPFLOAT(v1) );
     158    WRITE_DATA( 24, GLuint, SWAPFLOAT(v2) );
     159    WRITE_DATA( 28, GLint, SWAP32(num_components*uorder) );
     160    WRITE_DATA( 32, GLint, SWAP32(vorder) );
     161
     162    dest_data = (GLfloat *) (data_ptr + 36);
     163    src_data = (GLfloat *) points;
     164    for (v = 0 ; v < vorder ; v++)
     165    {
     166        for (u = 0 ; u < uorder ; u++)
     167        {
     168            for (comp = 0 ; comp < num_components ; comp++)
     169            {
     170                WRITE_DATA( (unsigned char *) dest_data + comp*sizeof(*points) - data_ptr, GLuint, SWAPFLOAT( *(src_data + comp) ) );
     171            }
     172            dest_data += num_components;
     173            src_data += ustride;
     174        }
     175        src_data += vstride - ustride*uorder;
     176    }
     177
     178    crHugePacket( CR_MAP2F_OPCODE, data_ptr );
     179    crPackFree( data_ptr );
    180180}
    181181
    182182void PACK_APIENTRY crPackMap1dSWAP( GLenum target, GLdouble u1,
    183                 GLdouble u2, GLint stride, GLint order, const GLdouble *points )
    184 {
    185         unsigned char *data_ptr;
    186         int packet_length =
    187                 sizeof( target ) +
    188                 sizeof( u1 ) +
    189                 sizeof( u2 ) +
    190                 sizeof( stride ) +
    191                 sizeof( order );
    192 
    193         int num_components = __gl_Map1NumComponents( target );
    194         GLdouble *src_data, *dest_data;
    195         int u;
    196         int comp;
    197 
    198         if (num_components < 0)
    199         {
    200                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    201                                                                 "crPackMap1d(bad target)" );
    202                 return;
    203         }
    204 
    205         packet_length += num_components * order * sizeof( *points );
    206 
    207         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    208 
    209         WRITE_DATA( 0, GLenum, SWAP32(target) );
    210         WRITE_SWAPPED_DOUBLE( 4, u1 );
    211         WRITE_SWAPPED_DOUBLE( 12, u2 );
    212         WRITE_DATA( 20, GLint, SWAP32(num_components) );
    213         WRITE_DATA( 24, GLint, SWAP32(order) );
    214 
    215         dest_data = (GLdouble *) (data_ptr + 28);
    216         src_data = (GLdouble *) points;
    217         for (u = 0 ; u < order ; u++)
    218         {
    219                 for (comp = 0 ; comp < num_components ; comp++)
    220                 {
    221                         WRITE_SWAPPED_DOUBLE( (unsigned char *) dest_data + comp*sizeof(*points) - data_ptr, *(src_data + comp) );
    222                 }
    223                 dest_data += num_components;
    224                 src_data += stride;
    225         }
    226 
    227         crHugePacket( CR_MAP1D_OPCODE, data_ptr );
    228         crPackFree( data_ptr );
     183        GLdouble u2, GLint stride, GLint order, const GLdouble *points )
     184{
     185    unsigned char *data_ptr;
     186    int packet_length =
     187        sizeof( target ) +
     188        sizeof( u1 ) +
     189        sizeof( u2 ) +
     190        sizeof( stride ) +
     191        sizeof( order );
     192
     193    int num_components = __gl_Map1NumComponents( target );
     194    GLdouble *src_data, *dest_data;
     195    int u;
     196    int comp;
     197
     198    if (num_components < 0)
     199    {
     200        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     201                                "crPackMap1d(bad target)" );
     202        return;
     203    }
     204
     205    packet_length += num_components * order * sizeof( *points );
     206
     207    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     208
     209    WRITE_DATA( 0, GLenum, SWAP32(target) );
     210    WRITE_SWAPPED_DOUBLE( 4, u1 );
     211    WRITE_SWAPPED_DOUBLE( 12, u2 );
     212    WRITE_DATA( 20, GLint, SWAP32(num_components) );
     213    WRITE_DATA( 24, GLint, SWAP32(order) );
     214
     215    dest_data = (GLdouble *) (data_ptr + 28);
     216    src_data = (GLdouble *) points;
     217    for (u = 0 ; u < order ; u++)
     218    {
     219        for (comp = 0 ; comp < num_components ; comp++)
     220        {
     221            WRITE_SWAPPED_DOUBLE( (unsigned char *) dest_data + comp*sizeof(*points) - data_ptr, *(src_data + comp) );
     222        }
     223        dest_data += num_components;
     224        src_data += stride;
     225    }
     226
     227    crHugePacket( CR_MAP1D_OPCODE, data_ptr );
     228    crPackFree( data_ptr );
    229229}
    230230
    231231void PACK_APIENTRY crPackMap1fSWAP( GLenum target, GLfloat u1,
    232                 GLfloat u2, GLint stride, GLint order, const GLfloat *points )
    233 {
    234         unsigned char *data_ptr;
    235         int packet_length =
    236                 sizeof( target ) +
    237                 sizeof( u1 ) +
    238                 sizeof( u2 ) +
    239                 sizeof( stride ) +
    240                 sizeof( order );
    241 
    242         int num_components = __gl_Map1NumComponents( target );
    243         GLfloat *src_data, *dest_data;
    244         int u;
    245         int comp;
    246 
    247         if (num_components < 0)
    248         {
    249                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    250                                                                 "crPackMap1f(bad target)" );
    251                 return;
    252         }
    253 
    254         packet_length += num_components * order * sizeof( *points );
    255 
    256         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    257 
    258         WRITE_DATA( 0, GLenum, SWAP32(target) );
    259         WRITE_DATA( 4, GLuint, SWAPFLOAT(u1) );
    260         WRITE_DATA( 8, GLuint, SWAPFLOAT(u2) );
    261         WRITE_DATA( 12, GLint, SWAP32(num_components) );
    262         WRITE_DATA( 16, GLint, SWAP32(order) );
    263 
    264         dest_data = (GLfloat *) (data_ptr + 20);
    265         src_data = (GLfloat *) points;
    266         for (u = 0 ; u < order ; u++)
    267         {
    268                 for (comp = 0 ; comp < num_components ; comp++)
    269                 {
    270                         WRITE_DATA( (unsigned char *) dest_data + comp*sizeof(*points) - data_ptr, GLuint, SWAPFLOAT( *(src_data + comp) ) );
    271                 }
    272                 dest_data += num_components;
    273                 src_data += stride;
    274         }
    275 
    276         crHugePacket( CR_MAP1F_OPCODE, data_ptr );
    277         crPackFree( data_ptr );
    278 }
     232        GLfloat u2, GLint stride, GLint order, const GLfloat *points )
     233{
     234    unsigned char *data_ptr;
     235    int packet_length =
     236        sizeof( target ) +
     237        sizeof( u1 ) +
     238        sizeof( u2 ) +
     239        sizeof( stride ) +
     240        sizeof( order );
     241
     242    int num_components = __gl_Map1NumComponents( target );
     243    GLfloat *src_data, *dest_data;
     244    int u;
     245    int comp;
     246
     247    if (num_components < 0)
     248    {
     249        __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     250                                "crPackMap1f(bad target)" );
     251        return;
     252    }
     253
     254    packet_length += num_components * order * sizeof( *points );
     255
     256    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     257
     258    WRITE_DATA( 0, GLenum, SWAP32(target) );
     259    WRITE_DATA( 4, GLuint, SWAPFLOAT(u1) );
     260    WRITE_DATA( 8, GLuint, SWAPFLOAT(u2) );
     261    WRITE_DATA( 12, GLint, SWAP32(num_components) );
     262    WRITE_DATA( 16, GLint, SWAP32(order) );
     263
     264    dest_data = (GLfloat *) (data_ptr + 20);
     265    src_data = (GLfloat *) points;
     266    for (u = 0 ; u < order ; u++)
     267    {
     268        for (comp = 0 ; comp < num_components ; comp++)
     269        {
     270            WRITE_DATA( (unsigned char *) dest_data + comp*sizeof(*points) - data_ptr, GLuint, SWAPFLOAT( *(src_data + comp) ) );
     271        }
     272        dest_data += num_components;
     273        src_data += stride;
     274    }
     275
     276    crHugePacket( CR_MAP1F_OPCODE, data_ptr );
     277    crPackFree( data_ptr );
     278}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_swap_pixelmap.c

    r15532 r33457  
    99static unsigned char * __gl_HandlePixelMapData( GLenum map, GLsizei mapsize, int size_of_value, const GLvoid *values )
    1010{
    11         int i;
     11    int i;
    1212
    13         int packet_length =
    14                 sizeof( map ) +
    15                 sizeof( mapsize ) +
    16                 mapsize*size_of_value;
    17         unsigned char *data_ptr = (unsigned char *) crPackAlloc( packet_length );
     13    int packet_length =
     14        sizeof( map ) +
     15        sizeof( mapsize ) +
     16        mapsize*size_of_value;
     17    unsigned char *data_ptr = (unsigned char *) crPackAlloc( packet_length );
    1818
    19         WRITE_DATA( 0, GLenum, SWAP32(map) );
    20         WRITE_DATA( 4, GLsizei, SWAP32(mapsize) );
     19    WRITE_DATA( 0, GLenum, SWAP32(map) );
     20    WRITE_DATA( 4, GLsizei, SWAP32(mapsize) );
    2121
    22         for (i = 0 ; i < mapsize ; i++)
    23         {
    24                 switch( size_of_value )
    25                 {
    26                         case 2:
    27                                 WRITE_DATA( 8 + i*sizeof(GLshort), GLshort, SWAP16(*((GLshort *)values + i) ));
    28                                 break;
    29                         case 4:
    30                                 WRITE_DATA( 8 + i*sizeof(GLint), GLint, SWAP32(*((GLint *)values + i) ));
    31                                 break;
    32                 }
    33         }
    34         return data_ptr;
     22    for (i = 0 ; i < mapsize ; i++)
     23    {
     24        switch( size_of_value )
     25        {
     26            case 2:
     27                WRITE_DATA( 8 + i*sizeof(GLshort), GLshort, SWAP16(*((GLshort *)values + i) ));
     28                break;
     29            case 4:
     30                WRITE_DATA( 8 + i*sizeof(GLint), GLint, SWAP32(*((GLint *)values + i) ));
     31                break;
     32        }
     33    }
     34    return data_ptr;
    3535}
    3636
    3737void PACK_APIENTRY crPackPixelMapfvSWAP(GLenum map, GLsizei mapsize,
    38                 const GLfloat *values )
     38        const GLfloat *values )
    3939{
    40         unsigned char *data_ptr = __gl_HandlePixelMapData( map, mapsize, sizeof( *values ), values );
     40    unsigned char *data_ptr = __gl_HandlePixelMapData( map, mapsize, sizeof( *values ), values );
    4141
    42         crHugePacket( CR_PIXELMAPFV_OPCODE, data_ptr );
    43         crPackFree( data_ptr );
     42    crHugePacket( CR_PIXELMAPFV_OPCODE, data_ptr );
     43    crPackFree( data_ptr );
    4444}
    4545
    4646void PACK_APIENTRY crPackPixelMapuivSWAP(GLenum map, GLsizei mapsize,
    47                 const GLuint *values )
     47        const GLuint *values )
    4848{
    49         unsigned char *data_ptr = __gl_HandlePixelMapData( map, mapsize, sizeof( *values ), values );
     49    unsigned char *data_ptr = __gl_HandlePixelMapData( map, mapsize, sizeof( *values ), values );
    5050
    51         crHugePacket( CR_PIXELMAPUIV_OPCODE, data_ptr );
    52         crPackFree( data_ptr );
     51    crHugePacket( CR_PIXELMAPUIV_OPCODE, data_ptr );
     52    crPackFree( data_ptr );
    5353}
    5454
    5555void PACK_APIENTRY crPackPixelMapusvSWAP(GLenum map, GLsizei mapsize,
    56                 const GLushort *values )
     56        const GLushort *values )
    5757{
    58         unsigned char *data_ptr = __gl_HandlePixelMapData( map, mapsize, sizeof( *values ), values );
     58    unsigned char *data_ptr = __gl_HandlePixelMapData( map, mapsize, sizeof( *values ), values );
    5959
    60         crHugePacket( CR_PIXELMAPUSV_OPCODE, data_ptr );
    61         crPackFree( data_ptr );
     60    crHugePacket( CR_PIXELMAPUSV_OPCODE, data_ptr );
     61    crPackFree( data_ptr );
    6262}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_swap_texture.c

    r15532 r33457  
    1212
    1313void PACK_APIENTRY crPackTexImage1DSWAP(GLenum target, GLint level,
    14                 GLint internalformat, GLsizei width, GLint border, GLenum format,
    15                 GLenum type, const GLvoid *pixels, const CRPixelPackState *unpackstate )
    16 {
    17         unsigned char *data_ptr;
    18         int packet_length;
    19         int isnull = (pixels == NULL);
    20 
    21         packet_length =
    22                 sizeof( target ) +
    23                 sizeof( level ) +
    24                 sizeof( internalformat ) +
    25                 sizeof( width ) +
    26                 sizeof( border ) +
    27                 sizeof( format ) +
    28                 sizeof( type ) +
    29                 sizeof( int );
    30 
    31         if (pixels)
    32         {
    33                 packet_length += crImageSize( format, type, width, 1 );
    34         }
    35 
    36         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    37         WRITE_DATA( 0, GLenum, SWAP32(target) );
    38         WRITE_DATA( 4, GLint, SWAP32(level) );
    39         WRITE_DATA( 8, GLint, SWAP32(internalformat) );
    40         WRITE_DATA( 12, GLsizei, SWAP32(width) );
    41         WRITE_DATA( 16, GLint, SWAP32(border) );
    42         WRITE_DATA( 20, GLenum, SWAP32(format) );
    43         WRITE_DATA( 24, GLenum, SWAP32(type) );
    44         WRITE_DATA( 28, int, SWAP32(isnull) );
    45 
    46         if (pixels) {
    47                 CRPixelPackState tmpUnpackState = *unpackstate;
    48                 /* flip application-requested swapBytes state */
    49                 tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
    50 
    51                 crPixelCopy1D( (void *)(data_ptr + 32), format, type,
    52                                                                         pixels, format, type, width, &tmpUnpackState );
    53         }
    54 
    55         crHugePacket( CR_TEXIMAGE1D_OPCODE, data_ptr );
    56         crPackFree( data_ptr );
     14        GLint internalformat, GLsizei width, GLint border, GLenum format,
     15        GLenum type, const GLvoid *pixels, const CRPixelPackState *unpackstate )
     16{
     17    unsigned char *data_ptr;
     18    int packet_length;
     19    int isnull = (pixels == NULL);
     20
     21    packet_length =
     22        sizeof( target ) +
     23        sizeof( level ) +
     24        sizeof( internalformat ) +
     25        sizeof( width ) +
     26        sizeof( border ) +
     27        sizeof( format ) +
     28        sizeof( type ) +
     29        sizeof( int );
     30
     31    if (pixels)
     32    {
     33        packet_length += crImageSize( format, type, width, 1 );
     34    }
     35
     36    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     37    WRITE_DATA( 0, GLenum, SWAP32(target) );
     38    WRITE_DATA( 4, GLint, SWAP32(level) );
     39    WRITE_DATA( 8, GLint, SWAP32(internalformat) );
     40    WRITE_DATA( 12, GLsizei, SWAP32(width) );
     41    WRITE_DATA( 16, GLint, SWAP32(border) );
     42    WRITE_DATA( 20, GLenum, SWAP32(format) );
     43    WRITE_DATA( 24, GLenum, SWAP32(type) );
     44    WRITE_DATA( 28, int, SWAP32(isnull) );
     45
     46    if (pixels) {
     47        CRPixelPackState tmpUnpackState = *unpackstate;
     48        /* flip application-requested swapBytes state */
     49        tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
     50
     51        crPixelCopy1D( (void *)(data_ptr + 32), format, type,
     52                                    pixels, format, type, width, &tmpUnpackState );
     53    }
     54
     55    crHugePacket( CR_TEXIMAGE1D_OPCODE, data_ptr );
     56    crPackFree( data_ptr );
    5757}
    5858
    5959void PACK_APIENTRY crPackTexImage2DSWAP(GLenum target, GLint level,
    60                 GLint internalformat, GLsizei width, GLsizei height, GLint border,
    61                 GLenum format, GLenum type, const GLvoid *pixels,
    62                 const CRPixelPackState *unpackstate )
    63 {
    64         unsigned char *data_ptr;
    65         int packet_length;
    66         int isnull = (pixels == NULL);
    67 
    68         packet_length =
    69                 sizeof( target ) +
    70                 sizeof( level ) +
    71                 sizeof( internalformat ) +
    72                 sizeof( width ) +
    73                 sizeof( height ) +
    74                 sizeof( border ) +
    75                 sizeof( format ) +
    76                 sizeof( type ) +
    77                 sizeof( int );
    78 
    79         if (pixels)
    80         {
    81                 packet_length += crImageSize( format, type, width, height );
    82         }
    83 
    84         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    85         WRITE_DATA( 0, GLenum, SWAP32(target) );
    86         WRITE_DATA( 4, GLint, SWAP32(level) );
    87         WRITE_DATA( 8, GLint, SWAP32(internalformat) );
    88         WRITE_DATA( 12, GLsizei, SWAP32(width) );
    89         WRITE_DATA( 16, GLsizei, SWAP32(height) );
    90         WRITE_DATA( 20, GLint, SWAP32(border) );
    91         WRITE_DATA( 24, GLenum, SWAP32(format) );
    92         WRITE_DATA( 28, GLenum, SWAP32(type) );
    93         WRITE_DATA( 32, int, SWAP32(isnull) );
    94 
    95         if (pixels)
    96         {
    97                 CRPixelPackState tmpUnpackState = *unpackstate;
    98                 /* flip application-requested swapBytes state */
    99                 tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
    100 
    101                 crPixelCopy2D( width, height,
    102                                                                         (void *)(data_ptr + 36), format, type, NULL,  /* dst */
    103                                                                         pixels, format, type, &tmpUnpackState );  /* src */
    104         }
    105 
    106         crHugePacket( CR_TEXIMAGE2D_OPCODE, data_ptr );
    107         crPackFree( data_ptr );
     60        GLint internalformat, GLsizei width, GLsizei height, GLint border,
     61        GLenum format, GLenum type, const GLvoid *pixels,
     62        const CRPixelPackState *unpackstate )
     63{
     64    unsigned char *data_ptr;
     65    int packet_length;
     66    int isnull = (pixels == NULL);
     67
     68    packet_length =
     69        sizeof( target ) +
     70        sizeof( level ) +
     71        sizeof( internalformat ) +
     72        sizeof( width ) +
     73        sizeof( height ) +
     74        sizeof( border ) +
     75        sizeof( format ) +
     76        sizeof( type ) +
     77        sizeof( int );
     78
     79    if (pixels)
     80    {
     81        packet_length += crImageSize( format, type, width, height );
     82    }
     83
     84    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     85    WRITE_DATA( 0, GLenum, SWAP32(target) );
     86    WRITE_DATA( 4, GLint, SWAP32(level) );
     87    WRITE_DATA( 8, GLint, SWAP32(internalformat) );
     88    WRITE_DATA( 12, GLsizei, SWAP32(width) );
     89    WRITE_DATA( 16, GLsizei, SWAP32(height) );
     90    WRITE_DATA( 20, GLint, SWAP32(border) );
     91    WRITE_DATA( 24, GLenum, SWAP32(format) );
     92    WRITE_DATA( 28, GLenum, SWAP32(type) );
     93    WRITE_DATA( 32, int, SWAP32(isnull) );
     94
     95    if (pixels)
     96    {
     97        CRPixelPackState tmpUnpackState = *unpackstate;
     98        /* flip application-requested swapBytes state */
     99        tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
     100
     101        crPixelCopy2D( width, height,
     102                                    (void *)(data_ptr + 36), format, type, NULL,  /* dst */
     103                                    pixels, format, type, &tmpUnpackState );  /* src */
     104    }
     105
     106    crHugePacket( CR_TEXIMAGE2D_OPCODE, data_ptr );
     107    crPackFree( data_ptr );
    108108}
    109109
    110110#if defined( GL_EXT_texture3D )
    111111void PACK_APIENTRY crPackTexImage3DEXTSWAP(GLenum target, GLint level,
    112                                                                                                                                                                         GLenum internalformat,
     112                                                                                    GLenum internalformat,
    113113                GLsizei width, GLsizei height, GLsizei depth, GLint border,
    114114                GLenum format, GLenum type, const GLvoid *pixels,
    115115                const CRPixelPackState *unpackstate )
    116116{
    117         unsigned char *data_ptr;
    118         int packet_length;
    119         int isnull = (pixels == NULL);
    120         int is_distrib = ( (type == GL_TRUE) || (type == GL_FALSE) ) ;
    121         int distrib_buf_len = 0;
    122         int tex_size = 0;
    123 
    124         packet_length =
    125                 sizeof( target ) +
    126                 sizeof( level ) +
    127                 sizeof( internalformat ) +
    128                 sizeof( width ) +
    129                 sizeof( height ) +
    130                 sizeof( depth ) +
    131                 sizeof( border ) +
    132                 sizeof( format ) +
    133                 sizeof( type ) +
    134                 sizeof( int );
    135 
    136         if (pixels)
    137         {
    138                 if ( is_distrib )
    139                 {
    140                         distrib_buf_len = crStrlen( pixels ) + 1 +
    141                                 ( (type == GL_TRUE) ? width*height*3 : 0 ) ;
    142                         packet_length += distrib_buf_len ;
    143                 }
    144                 else
    145                 {
    146                         tex_size = crTextureSize( format, type, width, height, depth );
    147                         packet_length += tex_size;
    148                 }
    149         }
    150 
    151         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    152         WRITE_DATA( 0, GLenum, SWAP32( target ) );
    153         WRITE_DATA( 4, GLint, SWAP32( level ) );
    154         WRITE_DATA( 8, GLint, SWAP32( internalformat ) );
    155         WRITE_DATA( 12, GLsizei, SWAP32( width ) );
    156         WRITE_DATA( 16, GLsizei, SWAP32( height ) );
    157         WRITE_DATA( 20, GLsizei, SWAP32( depth ) );
    158         WRITE_DATA( 24, GLint, SWAP32( border ) );
    159         WRITE_DATA( 28, GLenum, SWAP32( format ) );
    160         WRITE_DATA( 32, GLenum, SWAP32( type ) );
    161         WRITE_DATA( 36, int, SWAP32( isnull ) );
    162 
    163         if (pixels)
    164         {
    165                 if ( is_distrib )
    166                 {
    167                         crMemcpy( (void*)(data_ptr + 40), pixels, distrib_buf_len ) ;
    168                 }
    169                 else
    170                 {
    171                         CRPixelPackState tmpUnpackState = *unpackstate;
    172                         /* flip application-requested swapBytes state */
    173                         tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
    174 
    175                         crPixelCopy3D( width, height, depth,
    176                                                                                 (void *)(data_ptr + 40), format, type, NULL,
    177                                                                                 pixels, format, type, &tmpUnpackState );
    178                 }
    179         }
    180 
    181         crHugePacket( CR_TEXIMAGE3DEXT_OPCODE, data_ptr );
    182         crPackFree( data_ptr );
     117    unsigned char *data_ptr;
     118    int packet_length;
     119    int isnull = (pixels == NULL);
     120    int is_distrib = ( (type == GL_TRUE) || (type == GL_FALSE) ) ;
     121    int distrib_buf_len = 0;
     122    int tex_size = 0;
     123
     124    packet_length =
     125        sizeof( target ) +
     126        sizeof( level ) +
     127        sizeof( internalformat ) +
     128        sizeof( width ) +
     129        sizeof( height ) +
     130        sizeof( depth ) +
     131        sizeof( border ) +
     132        sizeof( format ) +
     133        sizeof( type ) +
     134        sizeof( int );
     135
     136    if (pixels)
     137    {
     138        if ( is_distrib )
     139        {
     140            distrib_buf_len = crStrlen( pixels ) + 1 +
     141                ( (type == GL_TRUE) ? width*height*3 : 0 ) ;
     142            packet_length += distrib_buf_len ;
     143        }
     144        else
     145        {
     146            tex_size = crTextureSize( format, type, width, height, depth );
     147            packet_length += tex_size;
     148        }
     149    }
     150
     151    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     152    WRITE_DATA( 0, GLenum, SWAP32( target ) );
     153    WRITE_DATA( 4, GLint, SWAP32( level ) );
     154    WRITE_DATA( 8, GLint, SWAP32( internalformat ) );
     155    WRITE_DATA( 12, GLsizei, SWAP32( width ) );
     156    WRITE_DATA( 16, GLsizei, SWAP32( height ) );
     157    WRITE_DATA( 20, GLsizei, SWAP32( depth ) );
     158    WRITE_DATA( 24, GLint, SWAP32( border ) );
     159    WRITE_DATA( 28, GLenum, SWAP32( format ) );
     160    WRITE_DATA( 32, GLenum, SWAP32( type ) );
     161    WRITE_DATA( 36, int, SWAP32( isnull ) );
     162
     163    if (pixels)
     164    {
     165        if ( is_distrib )
     166        {
     167            crMemcpy( (void*)(data_ptr + 40), pixels, distrib_buf_len ) ;
     168        }
     169        else
     170        {
     171            CRPixelPackState tmpUnpackState = *unpackstate;
     172            /* flip application-requested swapBytes state */
     173            tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
     174
     175            crPixelCopy3D( width, height, depth,
     176                                        (void *)(data_ptr + 40), format, type, NULL,
     177                                        pixels, format, type, &tmpUnpackState );
     178        }
     179    }
     180
     181    crHugePacket( CR_TEXIMAGE3DEXT_OPCODE, data_ptr );
     182    crPackFree( data_ptr );
    183183}
    184184#endif /* GL_EXT_texture3D */
    … …  
    186186#ifdef CR_OPENGL_VERSION_1_2
    187187void PACK_APIENTRY crPackTexImage3DSWAP(GLenum target, GLint level,
    188                                                                                                                                                                 GLint internalformat,
    189                                                                                                                                                                 GLsizei width, GLsizei height,
    190                                                                                                                                                                 GLsizei depth, GLint border,
    191                                                                                                                                                                 GLenum format, GLenum type,
    192                                                                                                                                                                 const GLvoid *pixels,
    193                                                                                                                                                                 const CRPixelPackState *unpackstate )
    194 {
    195         unsigned char *data_ptr;
    196         int packet_length;
    197         int isnull = (pixels == NULL);
    198         int is_distrib = ( (type == GL_TRUE) || (type == GL_FALSE) ) ;
    199         int distrib_buf_len = 0;
    200         int tex_size = 0;
    201 
    202         packet_length =
    203                 sizeof( target ) +
    204                 sizeof( level ) +
    205                 sizeof( internalformat ) +
    206                 sizeof( width ) +
    207                 sizeof( height ) +
    208                 sizeof( depth ) +
    209                 sizeof( border ) +
    210                 sizeof( format ) +
    211                 sizeof( type ) +
    212                 sizeof( int );
    213 
    214         if (pixels)
    215         {
    216                 if ( is_distrib )
    217                 {
    218                         distrib_buf_len = crStrlen( pixels ) + 1 +
    219                                 ( (type == GL_TRUE) ? width*height*3 : 0 ) ;
    220                         packet_length += distrib_buf_len ;
    221                 }
    222                 else
    223                 {
    224                         tex_size = crTextureSize( format, type, width, height, depth );
    225                         packet_length += tex_size;
    226                 }
    227         }
    228 
    229         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    230         WRITE_DATA( 0, GLenum, SWAP32( target ) );
    231         WRITE_DATA( 4, GLint, SWAP32( level ) );
    232         WRITE_DATA( 8, GLint, SWAP32( internalformat ) );
    233         WRITE_DATA( 12, GLsizei, SWAP32( width ) );
    234         WRITE_DATA( 16, GLsizei, SWAP32( height ) );
    235         WRITE_DATA( 20, GLsizei, SWAP32( depth ) );
    236         WRITE_DATA( 24, GLint, SWAP32( border ) );
    237         WRITE_DATA( 28, GLenum, SWAP32( format ) );
    238         WRITE_DATA( 32, GLenum, SWAP32( type ) );
    239         WRITE_DATA( 36, int, SWAP32( isnull ) );
    240 
    241         if (pixels)
    242         {
    243                 if ( is_distrib )
    244                 {
    245                         crMemcpy( (void*)(data_ptr + 40), pixels, distrib_buf_len ) ;
    246                 }
    247                 else
    248                 {
    249                         CRPixelPackState tmpUnpackState = *unpackstate;
    250                         /* flip application-requested swapBytes state */
    251                         tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
    252 
    253                         crPixelCopy3D( width, height, depth,
    254                                                                                 (void *)(data_ptr + 40), format, type, NULL,
    255                                                                                 pixels, format, type, &tmpUnpackState );
    256                 }
    257         }
    258 
    259         crHugePacket( CR_TEXIMAGE3D_OPCODE, data_ptr );
    260         crPackFree( data_ptr );
     188                                                                                GLint internalformat,
     189                                                                                GLsizei width, GLsizei height,
     190                                                                                GLsizei depth, GLint border,
     191                                                                                GLenum format, GLenum type,
     192                                                                                const GLvoid *pixels,
     193                                                                                const CRPixelPackState *unpackstate )
     194{
     195    unsigned char *data_ptr;
     196    int packet_length;
     197    int isnull = (pixels == NULL);
     198    int is_distrib = ( (type == GL_TRUE) || (type == GL_FALSE) ) ;
     199    int distrib_buf_len = 0;
     200    int tex_size = 0;
     201
     202    packet_length =
     203        sizeof( target ) +
     204        sizeof( level ) +
     205        sizeof( internalformat ) +
     206        sizeof( width ) +
     207        sizeof( height ) +
     208        sizeof( depth ) +
     209        sizeof( border ) +
     210        sizeof( format ) +
     211        sizeof( type ) +
     212        sizeof( int );
     213
     214    if (pixels)
     215    {
     216        if ( is_distrib )
     217        {
     218            distrib_buf_len = crStrlen( pixels ) + 1 +
     219                ( (type == GL_TRUE) ? width*height*3 : 0 ) ;
     220            packet_length += distrib_buf_len ;
     221        }
     222        else
     223        {
     224            tex_size = crTextureSize( format, type, width, height, depth );
     225            packet_length += tex_size;
     226        }
     227    }
     228
     229    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     230    WRITE_DATA( 0, GLenum, SWAP32( target ) );
     231    WRITE_DATA( 4, GLint, SWAP32( level ) );
     232    WRITE_DATA( 8, GLint, SWAP32( internalformat ) );
     233    WRITE_DATA( 12, GLsizei, SWAP32( width ) );
     234    WRITE_DATA( 16, GLsizei, SWAP32( height ) );
     235    WRITE_DATA( 20, GLsizei, SWAP32( depth ) );
     236    WRITE_DATA( 24, GLint, SWAP32( border ) );
     237    WRITE_DATA( 28, GLenum, SWAP32( format ) );
     238    WRITE_DATA( 32, GLenum, SWAP32( type ) );
     239    WRITE_DATA( 36, int, SWAP32( isnull ) );
     240
     241    if (pixels)
     242    {
     243        if ( is_distrib )
     244        {
     245            crMemcpy( (void*)(data_ptr + 40), pixels, distrib_buf_len ) ;
     246        }
     247        else
     248        {
     249            CRPixelPackState tmpUnpackState = *unpackstate;
     250            /* flip application-requested swapBytes state */
     251            tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
     252
     253            crPixelCopy3D( width, height, depth,
     254                                        (void *)(data_ptr + 40), format, type, NULL,
     255                                        pixels, format, type, &tmpUnpackState );
     256        }
     257    }
     258
     259    crHugePacket( CR_TEXIMAGE3D_OPCODE, data_ptr );
     260    crPackFree( data_ptr );
    261261}
    262262#endif /* CR_OPENGL_VERSION_1_2 */
    … …  
    265265void PACK_APIENTRY crPackDeleteTexturesSWAP( GLsizei n, const GLuint *textures )
    266266{
    267         unsigned char *data_ptr;
    268         int i;
    269 
    270         int packet_length =
    271                 sizeof( n ) +
    272                 n*sizeof( *textures );
    273 
    274         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    275         WRITE_DATA( 0, GLsizei, SWAP32(n) );
    276 
    277         for ( i = 0 ; i < n ; i++)
    278         {
    279                 WRITE_DATA( i*sizeof(int) + 4, GLint, SWAP32(textures[i]) );
    280         }
    281         crHugePacket( CR_DELETETEXTURES_OPCODE, data_ptr );
    282         crPackFree( data_ptr );
     267    unsigned char *data_ptr;
     268    int i;
     269
     270    int packet_length =
     271        sizeof( n ) +
     272        n*sizeof( *textures );
     273
     274    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     275    WRITE_DATA( 0, GLsizei, SWAP32(n) );
     276
     277    for ( i = 0 ; i < n ; i++)
     278    {
     279        WRITE_DATA( i*sizeof(int) + 4, GLint, SWAP32(textures[i]) );
     280    }
     281    crHugePacket( CR_DELETETEXTURES_OPCODE, data_ptr );
     282    crPackFree( data_ptr );
    283283}
    284284
    285285static void __handleTexEnvData( GLenum target, GLenum pname, const GLfloat *params )
    286286{
    287         GET_PACKER_CONTEXT(pc);
    288         unsigned char *data_ptr;
    289         int num_params;
    290         int i;
    291 
    292         int packet_length =
    293                 sizeof( int ) +
    294                 sizeof( target ) +
    295                 sizeof( pname );
    296 
    297         num_params = 1;
    298         if ( pname == GL_TEXTURE_ENV_COLOR )
    299         {
    300                 num_params = 4;
    301         }
    302 
    303         packet_length += num_params*sizeof(*params);
    304 
    305         GET_BUFFERED_POINTER(pc, packet_length );
    306         WRITE_DATA( 0, int, SWAP32(packet_length) );
    307         WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(target) );
    308         WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
    309         for ( i = 0 ; i < num_params ; i++)
    310         {
    311                 WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAPFLOAT( params[i] ) );
    312         }
     287    GET_PACKER_CONTEXT(pc);
     288    unsigned char *data_ptr;
     289    int num_params;
     290    int i;
     291
     292    int packet_length =
     293        sizeof( int ) +
     294        sizeof( target ) +
     295        sizeof( pname );
     296
     297    num_params = 1;
     298    if ( pname == GL_TEXTURE_ENV_COLOR )
     299    {
     300        num_params = 4;
     301    }
     302
     303    packet_length += num_params*sizeof(*params);
     304
     305    GET_BUFFERED_POINTER(pc, packet_length );
     306    WRITE_DATA( 0, int, SWAP32(packet_length) );
     307    WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(target) );
     308    WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
     309    for ( i = 0 ; i < num_params ; i++)
     310    {
     311        WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAPFLOAT( params[i] ) );
     312    }
    313313}
    314314
    315315
    316316void PACK_APIENTRY crPackTexEnvfvSWAP( GLenum target, GLenum pname,
    317                 const GLfloat *params )
    318 {
    319         GET_PACKER_CONTEXT(pc);
    320         __handleTexEnvData( target, pname, params );
    321         WRITE_OPCODE( pc, CR_TEXENVFV_OPCODE );
     317        const GLfloat *params )
     318{
     319    GET_PACKER_CONTEXT(pc);
     320    __handleTexEnvData( target, pname, params );
     321    WRITE_OPCODE( pc, CR_TEXENVFV_OPCODE );
    322322}
    323323
    324324void PACK_APIENTRY crPackTexEnvivSWAP( GLenum target, GLenum pname,
    325                 const GLint *params )
    326 {
    327         /* floats and ints are the same size, so the packing should be the same */
    328         GET_PACKER_CONTEXT(pc);
    329         __handleTexEnvData( target, pname, (const GLfloat *) params );
    330         WRITE_OPCODE( pc, CR_TEXENVIV_OPCODE );
     325        const GLint *params )
     326{
     327    /* floats and ints are the same size, so the packing should be the same */
     328    GET_PACKER_CONTEXT(pc);
     329    __handleTexEnvData( target, pname, (const GLfloat *) params );
     330    WRITE_OPCODE( pc, CR_TEXENVIV_OPCODE );
    331331}
    332332
    333333void PACK_APIENTRY crPackTexEnviSWAP( GLenum target, GLenum pname, GLint param )
    334334{
    335         crPackTexEnvivSWAP( target, pname, &param );
     335    crPackTexEnvivSWAP( target, pname, &param );
    336336}
    337337
    338338void PACK_APIENTRY crPackTexEnvfSWAP( GLenum target, GLenum pname, GLfloat param )
    339339{
    340         crPackTexEnvfvSWAP( target, pname, &param );
     340    crPackTexEnvfvSWAP( target, pname, &param );
    341341}
    342342
    343343void PACK_APIENTRY crPackPrioritizeTexturesSWAP( GLsizei n,
    344                 const GLuint *textures, const GLclampf *priorities )
    345 {
    346         unsigned char *data_ptr;
    347         int packet_length =
    348                 sizeof( n ) +
    349                 n*sizeof( *textures ) +
    350                 n*sizeof( *priorities );
    351         int i;
    352 
    353         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    354         WRITE_DATA( 0, GLsizei, SWAP32(n) );
    355         for ( i = 0 ; i < n ; i++)
    356         {
    357                 WRITE_DATA( i*sizeof(int) + 4, GLint, SWAP32(textures[i]));
    358         }
    359         for ( i = 0 ; i < n ; i++)
    360         {
    361                 WRITE_DATA( i*sizeof(int) + 4 + n*sizeof( *textures ),
    362                                 GLuint, SWAPFLOAT(priorities[i]));
    363         }
    364 
    365         crHugePacket( CR_PRIORITIZETEXTURES_OPCODE, data_ptr );
    366         crPackFree( data_ptr );
     344        const GLuint *textures, const GLclampf *priorities )
     345{
     346    unsigned char *data_ptr;
     347    int packet_length =
     348        sizeof( n ) +
     349        n*sizeof( *textures ) +
     350        n*sizeof( *priorities );
     351    int i;
     352
     353    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     354    WRITE_DATA( 0, GLsizei, SWAP32(n) );
     355    for ( i = 0 ; i < n ; i++)
     356    {
     357        WRITE_DATA( i*sizeof(int) + 4, GLint, SWAP32(textures[i]));
     358    }
     359    for ( i = 0 ; i < n ; i++)
     360    {
     361        WRITE_DATA( i*sizeof(int) + 4 + n*sizeof( *textures ),
     362                GLuint, SWAPFLOAT(priorities[i]));
     363    }
     364
     365    crHugePacket( CR_PRIORITIZETEXTURES_OPCODE, data_ptr );
     366    crPackFree( data_ptr );
    367367}
    368368
    369369static void __handleTexGenData( GLenum coord, GLenum pname,
    370                 int sizeof_param, const GLvoid *params )
    371 {
    372         GET_PACKER_CONTEXT(pc);
    373         unsigned char *data_ptr;
    374         int packet_length = sizeof( int ) + sizeof( coord ) + sizeof( pname );
    375         int num_params = 1;
    376         int i;
    377         if (pname == GL_OBJECT_PLANE || pname == GL_EYE_PLANE)
    378         {
    379                 num_params = 4;
    380         }
    381         packet_length += num_params * sizeof_param;
    382        
    383         GET_BUFFERED_POINTER(pc, packet_length );
    384         WRITE_DATA( 0, int, SWAP32(packet_length) );
    385         WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(coord) );
    386         WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
    387         for ( i = 0 ; i < num_params ; i++)
    388         {
    389                 WRITE_DATA( (i+1)*sizeof( int ) + 8, GLint, SWAP32(((GLint *)params)[i]) );
    390         }
     370        int sizeof_param, const GLvoid *params )
     371{
     372    GET_PACKER_CONTEXT(pc);
     373    unsigned char *data_ptr;
     374    int packet_length = sizeof( int ) + sizeof( coord ) + sizeof( pname );
     375    int num_params = 1;
     376    int i;
     377    if (pname == GL_OBJECT_PLANE || pname == GL_EYE_PLANE)
     378    {
     379        num_params = 4;
     380    }
     381    packet_length += num_params * sizeof_param;
     382   
     383    GET_BUFFERED_POINTER(pc, packet_length );
     384    WRITE_DATA( 0, int, SWAP32(packet_length) );
     385    WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(coord) );
     386    WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
     387    for ( i = 0 ; i < num_params ; i++)
     388    {
     389        WRITE_DATA( (i+1)*sizeof( int ) + 8, GLint, SWAP32(((GLint *)params)[i]) );
     390    }
    391391}
    392392
    393393void PACK_APIENTRY crPackTexGendvSWAP( GLenum coord, GLenum pname,
    394                 const GLdouble *params )
    395 {
    396         GET_PACKER_CONTEXT(pc);
    397         __handleTexGenData( coord, pname, sizeof( *params ), params );
    398         WRITE_OPCODE( pc, CR_TEXGENDV_OPCODE );
     394        const GLdouble *params )
     395{
     396    GET_PACKER_CONTEXT(pc);
     397    __handleTexGenData( coord, pname, sizeof( *params ), params );
     398    WRITE_OPCODE( pc, CR_TEXGENDV_OPCODE );
    399399}
    400400
    401401void PACK_APIENTRY crPackTexGenfvSWAP( GLenum coord, GLenum pname,
    402                 const GLfloat *params )
    403 {
    404         GET_PACKER_CONTEXT(pc);
    405         __handleTexGenData( coord, pname, sizeof( *params ), params );
    406         WRITE_OPCODE( pc, CR_TEXGENFV_OPCODE );
     402        const GLfloat *params )
     403{
     404    GET_PACKER_CONTEXT(pc);
     405    __handleTexGenData( coord, pname, sizeof( *params ), params );
     406    WRITE_OPCODE( pc, CR_TEXGENFV_OPCODE );
    407407}
    408408
    409409void PACK_APIENTRY crPackTexGenivSWAP( GLenum coord, GLenum pname,
    410                 const GLint *params )
    411 {
    412         GET_PACKER_CONTEXT(pc);
    413         __handleTexGenData( coord, pname, sizeof( *params ), params );
    414         WRITE_OPCODE( pc, CR_TEXGENIV_OPCODE );
     410        const GLint *params )
     411{
     412    GET_PACKER_CONTEXT(pc);
     413    __handleTexGenData( coord, pname, sizeof( *params ), params );
     414    WRITE_OPCODE( pc, CR_TEXGENIV_OPCODE );
    415415}
    416416
    417417void PACK_APIENTRY crPackTexGendSWAP( GLenum coord, GLenum pname, GLdouble param )
    418418{
    419         crPackTexGendvSWAP( coord, pname, &param );
     419    crPackTexGendvSWAP( coord, pname, &param );
    420420}
    421421
    422422void PACK_APIENTRY crPackTexGenfSWAP( GLenum coord, GLenum pname, GLfloat param )
    423423{
    424         crPackTexGenfvSWAP( coord, pname, &param );
     424    crPackTexGenfvSWAP( coord, pname, &param );
    425425}
    426426
    427427void PACK_APIENTRY crPackTexGeniSWAP( GLenum coord, GLenum pname, GLint param )
    428428{
    429         crPackTexGenivSWAP( coord, pname, &param );
     429    crPackTexGenivSWAP( coord, pname, &param );
    430430}
    431431
    432432static GLboolean __handleTexParameterData( GLenum target, GLenum pname, const GLfloat *params )
    433433{
    434         GET_PACKER_CONTEXT(pc);
    435         unsigned char *data_ptr;
    436         int packet_length = sizeof( int ) + sizeof( target ) + sizeof( pname );
    437         int num_params = 0;
    438         int i;
    439 
    440         switch( pname )
    441         {
    442 
    443         case GL_TEXTURE_MIN_FILTER:
    444         case GL_TEXTURE_MAG_FILTER:
    445         case GL_TEXTURE_WRAP_R:
    446         case GL_TEXTURE_WRAP_S:
    447         case GL_TEXTURE_WRAP_T:
     434    GET_PACKER_CONTEXT(pc);
     435    unsigned char *data_ptr;
     436    int packet_length = sizeof( int ) + sizeof( target ) + sizeof( pname );
     437    int num_params = 0;
     438    int i;
     439
     440    switch( pname )
     441    {
     442
     443    case GL_TEXTURE_MIN_FILTER:
     444    case GL_TEXTURE_MAG_FILTER:
     445    case GL_TEXTURE_WRAP_R:
     446    case GL_TEXTURE_WRAP_S:
     447    case GL_TEXTURE_WRAP_T:
    448448#ifdef GL_TEXTURE_PRIORITY
    449         case GL_TEXTURE_PRIORITY:
     449    case GL_TEXTURE_PRIORITY:
    450450#endif
    451           num_params = 1;
    452                 break;
    453         case GL_TEXTURE_MAX_ANISOTROPY_EXT:
    454                 num_params = 1;
    455                 break;
    456         case GL_TEXTURE_MIN_LOD:
    457         case GL_TEXTURE_MAX_LOD:
    458         case GL_TEXTURE_BASE_LEVEL:
    459         case GL_TEXTURE_MAX_LEVEL:
    460                 num_params = 1;
    461                 break;
    462         case GL_TEXTURE_BORDER_COLOR:
    463                 num_params = 4;
    464                 break;
     451      num_params = 1;
     452        break;
     453    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
     454        num_params = 1;
     455        break;
     456    case GL_TEXTURE_MIN_LOD:
     457    case GL_TEXTURE_MAX_LOD:
     458    case GL_TEXTURE_BASE_LEVEL:
     459    case GL_TEXTURE_MAX_LEVEL:
     460        num_params = 1;
     461        break;
     462    case GL_TEXTURE_BORDER_COLOR:
     463        num_params = 4;
     464        break;
    465465#ifdef CR_ARB_shadow
    466         case GL_TEXTURE_COMPARE_MODE_ARB:
    467         case GL_TEXTURE_COMPARE_FUNC_ARB:
    468                 num_params = 1;
    469                 break;
     466    case GL_TEXTURE_COMPARE_MODE_ARB:
     467    case GL_TEXTURE_COMPARE_FUNC_ARB:
     468        num_params = 1;
     469        break;
    470470#endif
    471471#ifdef CR_ARB_shadow_ambient
    472         case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
    473                 num_params = 1;
    474                 break;
     472    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
     473        num_params = 1;
     474        break;
    475475#endif
    476476#ifdef CR_ARB_depth_texture
    477         case GL_DEPTH_TEXTURE_MODE_ARB:
    478                 num_params = 1;
    479                 break;
     477    case GL_DEPTH_TEXTURE_MODE_ARB:
     478        num_params = 1;
     479        break;
    480480#endif
    481481#ifdef CR_SGIS_generate_mipmap
    482         case GL_GENERATE_MIPMAP_SGIS:
    483                 num_params = 1;
    484                 break;
     482    case GL_GENERATE_MIPMAP_SGIS:
     483        num_params = 1;
     484        break;
    485485#endif
    486                 default:
    487                         num_params = __packTexParameterNumParams( pname );
    488                         if (!num_params)
    489                         {
    490                                 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
    491                                                                                 "crPackTexParameter(bad pname)" );
    492                                 return GL_FALSE;
    493                         }
    494         }
    495         packet_length += num_params * sizeof(*params);
    496 
    497         GET_BUFFERED_POINTER(pc, packet_length );
    498         WRITE_DATA( 0, int, SWAP32(packet_length) );
    499         WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(target) );
    500         WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
    501         for ( i = 0 ; i < num_params ; i++)
    502         {
    503                 WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAPFLOAT(params[i]) );
    504         }
    505         return GL_TRUE;
     486        default:
     487            num_params = __packTexParameterNumParams( pname );
     488            if (!num_params)
     489            {
     490                __PackError( __LINE__, __FILE__, GL_INVALID_ENUM,
     491                                        "crPackTexParameter(bad pname)" );
     492                return GL_FALSE;
     493            }
     494    }
     495    packet_length += num_params * sizeof(*params);
     496
     497    GET_BUFFERED_POINTER(pc, packet_length );
     498    WRITE_DATA( 0, int, SWAP32(packet_length) );
     499    WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(target) );
     500    WRITE_DATA( sizeof( int ) + 4, GLenum, SWAP32(pname) );
     501    for ( i = 0 ; i < num_params ; i++)
     502    {
     503        WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAPFLOAT(params[i]) );
     504    }
     505    return GL_TRUE;
    506506}
    507507
    508508void PACK_APIENTRY crPackTexParameterfvSWAP( GLenum target, GLenum pname,
    509                 const GLfloat *params )
    510 {
    511         GET_PACKER_CONTEXT(pc);
    512         if (__handleTexParameterData( target, pname, params ))
    513                 WRITE_OPCODE( pc, CR_TEXPARAMETERFV_OPCODE );
     509        const GLfloat *params )
     510{
     511    GET_PACKER_CONTEXT(pc);
     512    if (__handleTexParameterData( target, pname, params ))
     513        WRITE_OPCODE( pc, CR_TEXPARAMETERFV_OPCODE );
    514514}
    515515
    516516void PACK_APIENTRY crPackTexParameterivSWAP( GLenum target, GLenum pname,
    517                 const GLint *params )
    518 {
    519         GET_PACKER_CONTEXT(pc);
    520         if (__handleTexParameterData( target, pname, (GLfloat *) params ))
    521                 WRITE_OPCODE( pc, CR_TEXPARAMETERIV_OPCODE );
     517        const GLint *params )
     518{
     519    GET_PACKER_CONTEXT(pc);
     520    if (__handleTexParameterData( target, pname, (GLfloat *) params ))
     521        WRITE_OPCODE( pc, CR_TEXPARAMETERIV_OPCODE );
    522522}
    523523
    524524void PACK_APIENTRY crPackTexParameterfSWAP( GLenum target, GLenum pname, GLfloat param )
    525525{
    526         crPackTexParameterfvSWAP( target, pname, &param );
     526    crPackTexParameterfvSWAP( target, pname, &param );
    527527}
    528528
    529529void PACK_APIENTRY crPackTexParameteriSWAP( GLenum target, GLenum pname, GLint param )
    530530{
    531         crPackTexParameterivSWAP( target, pname, &param );
     531    crPackTexParameterivSWAP( target, pname, &param );
    532532}
    533533
    … …  
    546546                sizeof( xoffset ) +
    547547                sizeof( yoffset ) +
    548                 sizeof( zoffset ) +
     548        sizeof( zoffset ) +
    549549                sizeof( width ) +
    550550                sizeof( height ) +
    551                 sizeof( depth ) +
     551        sizeof( depth ) +
    552552                sizeof( format ) +
    553553                sizeof( type ) +
    … …  
    559559        WRITE_DATA( 8, GLint, SWAP32(xoffset) );
    560560        WRITE_DATA( 12, GLint, SWAP32(yoffset) );
    561                 WRITE_DATA( 16, GLint, SWAP32(zoffset) );
     561        WRITE_DATA( 16, GLint, SWAP32(zoffset) );
    562562        WRITE_DATA( 20, GLsizei, SWAP32(width) );
    563563        WRITE_DATA( 24, GLsizei, SWAP32(height) );
    564                 WRITE_DATA( 28, GLsizei, SWAP32(depth) );
     564        WRITE_DATA( 28, GLsizei, SWAP32(depth) );
    565565        WRITE_DATA( 32, GLenum, SWAP32(format) );
    566566        WRITE_DATA( 36, GLenum, SWAP32(type) );
    … …  
    576576
    577577void PACK_APIENTRY crPackTexSubImage2DSWAP (GLenum target, GLint level,
    578                 GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
    579                 GLenum format, GLenum type, const GLvoid *pixels,
    580                 const CRPixelPackState *unpackstate )
    581 {
    582         unsigned char *data_ptr;
    583         int packet_length;
    584 
    585         CRPixelPackState tmpUnpackState = *unpackstate;
    586 
    587         packet_length =
    588                 sizeof( target ) +
    589                 sizeof( level ) +
    590                 sizeof( xoffset ) +
    591                 sizeof( yoffset ) +
    592                 sizeof( width ) +
    593                 sizeof( height ) +
    594                 sizeof( format ) +
    595                 sizeof( type ) +
    596                 crImageSize( format, type, width, height );
    597 
    598         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    599         WRITE_DATA( 0, GLenum, SWAP32(target) );
    600         WRITE_DATA( 4, GLint, SWAP32(level) );
    601         WRITE_DATA( 8, GLint, SWAP32(xoffset) );
    602         WRITE_DATA( 12, GLint, SWAP32(yoffset) );
    603         WRITE_DATA( 16, GLsizei, SWAP32(width) );
    604         WRITE_DATA( 20, GLsizei, SWAP32(height) );
    605         WRITE_DATA( 24, GLenum, SWAP32(format) );
    606         WRITE_DATA( 28, GLenum, SWAP32(type) );
    607 
    608         /* flip application-requested swapBytes state */
    609         tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
    610 
    611         crPixelCopy2D( width, height,
    612                                                                 (GLvoid *) (data_ptr + 32), format, type, NULL,  /* dst */
    613                                                                 pixels, format, type, &tmpUnpackState );  /* src */
    614 
    615         crHugePacket( CR_TEXSUBIMAGE2D_OPCODE, data_ptr );
    616         crPackFree( data_ptr );
     578        GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
     579        GLenum format, GLenum type, const GLvoid *pixels,
     580        const CRPixelPackState *unpackstate )
     581{
     582    unsigned char *data_ptr;
     583    int packet_length;
     584
     585    CRPixelPackState tmpUnpackState = *unpackstate;
     586
     587    packet_length =
     588        sizeof( target ) +
     589        sizeof( level ) +
     590        sizeof( xoffset ) +
     591        sizeof( yoffset ) +
     592        sizeof( width ) +
     593        sizeof( height ) +
     594        sizeof( format ) +
     595        sizeof( type ) +
     596        crImageSize( format, type, width, height );
     597
     598    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     599    WRITE_DATA( 0, GLenum, SWAP32(target) );
     600    WRITE_DATA( 4, GLint, SWAP32(level) );
     601    WRITE_DATA( 8, GLint, SWAP32(xoffset) );
     602    WRITE_DATA( 12, GLint, SWAP32(yoffset) );
     603    WRITE_DATA( 16, GLsizei, SWAP32(width) );
     604    WRITE_DATA( 20, GLsizei, SWAP32(height) );
     605    WRITE_DATA( 24, GLenum, SWAP32(format) );
     606    WRITE_DATA( 28, GLenum, SWAP32(type) );
     607
     608    /* flip application-requested swapBytes state */
     609    tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
     610
     611    crPixelCopy2D( width, height,
     612                                (GLvoid *) (data_ptr + 32), format, type, NULL,  /* dst */
     613                                pixels, format, type, &tmpUnpackState );  /* src */
     614
     615    crHugePacket( CR_TEXSUBIMAGE2D_OPCODE, data_ptr );
     616    crPackFree( data_ptr );
    617617}
    618618
    619619void PACK_APIENTRY crPackTexSubImage1DSWAP (GLenum target, GLint level,
    620                 GLint xoffset, GLsizei width, GLenum format, GLenum type,
    621                 const GLvoid *pixels, const CRPixelPackState *unpackstate )
    622 {
    623         unsigned char *data_ptr;
    624         int packet_length;
     620        GLint xoffset, GLsizei width, GLenum format, GLenum type,
     621        const GLvoid *pixels, const CRPixelPackState *unpackstate )
     622{
     623    unsigned char *data_ptr;
     624    int packet_length;
    625625    CRPixelPackState tmpUnpackState = *unpackstate;
    626626
    627         packet_length =
    628                 sizeof( target ) +
    629                 sizeof( level ) +
    630                 sizeof( xoffset ) +
    631                 sizeof( width ) +
    632                 sizeof( format ) +
    633                 sizeof( type ) +
    634                 crImageSize( format, type, width, 1 );
    635 
    636         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    637         WRITE_DATA( 0, GLenum, SWAP32(target) );
    638         WRITE_DATA( 4, GLint, SWAP32(level) );
    639         WRITE_DATA( 8, GLint, SWAP32(xoffset) );
    640         WRITE_DATA( 12, GLsizei, SWAP32(width) );
    641         WRITE_DATA( 16, GLenum, SWAP32(format) );
    642         WRITE_DATA( 20, GLenum, SWAP32(type) );
    643 
    644         /* flip application-requested swapBytes state */
    645         tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
    646 
    647         crPixelCopy1D((GLvoid *) (data_ptr + 24), format, type,
    648                                                                 pixels, format, type, width, &tmpUnpackState );
    649 
    650         crHugePacket( CR_TEXSUBIMAGE1D_OPCODE, data_ptr );
    651         crPackFree( data_ptr );
     627    packet_length =
     628        sizeof( target ) +
     629        sizeof( level ) +
     630        sizeof( xoffset ) +
     631        sizeof( width ) +
     632        sizeof( format ) +
     633        sizeof( type ) +
     634        crImageSize( format, type, width, 1 );
     635
     636    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     637    WRITE_DATA( 0, GLenum, SWAP32(target) );
     638    WRITE_DATA( 4, GLint, SWAP32(level) );
     639    WRITE_DATA( 8, GLint, SWAP32(xoffset) );
     640    WRITE_DATA( 12, GLsizei, SWAP32(width) );
     641    WRITE_DATA( 16, GLenum, SWAP32(format) );
     642    WRITE_DATA( 20, GLenum, SWAP32(type) );
     643
     644    /* flip application-requested swapBytes state */
     645    tmpUnpackState.swapBytes = unpackstate->swapBytes ? GL_FALSE : GL_TRUE;
     646
     647    crPixelCopy1D((GLvoid *) (data_ptr + 24), format, type,
     648                                pixels, format, type, width, &tmpUnpackState );
     649
     650    crHugePacket( CR_TEXSUBIMAGE1D_OPCODE, data_ptr );
     651    crPackFree( data_ptr );
    652652}
    653653
    654654void PACK_APIENTRY crPackAreTexturesResidentSWAP( GLsizei n, const GLuint *textures, GLboolean *residences, GLboolean *return_val, int *writeback )
    655655{
    656         GET_PACKER_CONTEXT(pc);
    657         unsigned char *data_ptr;
    658         int packet_length;
    659         int i;
    660 
    661         packet_length =
    662                 sizeof( int ) +            /* packet length */
    663                 sizeof( GLenum ) +       /* extend-o opcode */
    664                 sizeof( n ) +            /* num_textures */
    665                 n*sizeof( *textures ) +  /* textures */
    666                 8 + 8 + 8;               /* return pointers */
    667 
    668         GET_BUFFERED_POINTER(pc, packet_length);
    669         WRITE_DATA( 0, int, SWAP32(packet_length) );
    670         WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(CR_ARETEXTURESRESIDENT_EXTEND_OPCODE) );
    671         WRITE_DATA( sizeof( int ) + 4, GLsizei, SWAP32(n) );
    672         for (i = 0 ; i < n ; i++)
    673         {
    674                 WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAP32(textures[i]) );
    675         }
    676         WRITE_NETWORK_POINTER( sizeof( int ) + 8 + n*sizeof( *textures ), (void *) residences );
    677         WRITE_NETWORK_POINTER( sizeof( int ) + 16 + n*sizeof( *textures ), (void *) return_val );
    678         WRITE_NETWORK_POINTER( sizeof( int ) + 24 + n*sizeof( *textures ), (void *) writeback );
    679         WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     656    GET_PACKER_CONTEXT(pc);
     657    unsigned char *data_ptr;
     658    int packet_length;
     659    int i;
     660
     661    packet_length =
     662        sizeof( int ) +            /* packet length */
     663        sizeof( GLenum ) +       /* extend-o opcode */
     664        sizeof( n ) +            /* num_textures */
     665        n*sizeof( *textures ) +  /* textures */
     666        8 + 8 + 8;               /* return pointers */
     667
     668    GET_BUFFERED_POINTER(pc, packet_length);
     669    WRITE_DATA( 0, int, SWAP32(packet_length) );
     670    WRITE_DATA( sizeof( int ) + 0, GLenum, SWAP32(CR_ARETEXTURESRESIDENT_EXTEND_OPCODE) );
     671    WRITE_DATA( sizeof( int ) + 4, GLsizei, SWAP32(n) );
     672    for (i = 0 ; i < n ; i++)
     673    {
     674        WRITE_DATA( (i+1)*sizeof( int ) + 8, GLuint, SWAP32(textures[i]) );
     675    }
     676    WRITE_NETWORK_POINTER( sizeof( int ) + 8 + n*sizeof( *textures ), (void *) residences );
     677    WRITE_NETWORK_POINTER( sizeof( int ) + 16 + n*sizeof( *textures ), (void *) return_val );
     678    WRITE_NETWORK_POINTER( sizeof( int ) + 24 + n*sizeof( *textures ), (void *) writeback );
     679    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
    680680}
    681681
    … …  
    687687void PACK_APIENTRY crPackCompressedTexImage1DARBSWAP( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imagesize, const GLvoid *data )
    688688{
    689         unsigned char *data_ptr;
    690         int packet_length;
    691         int isnull = (data == NULL);
    692 
    693         /* All extended opcodes have their first 8 bytes predefined:
    694         * the first four indicate the packet size, and the next four
    695         * indicate the actual extended opcode.
    696         */
    697         packet_length =
    698                 sizeof( GLenum) + /* extended opcode */
    699                 sizeof( target ) +
    700                 sizeof( level ) +
    701                 sizeof( internalformat ) +
    702                 sizeof( width ) +
    703                 sizeof( border ) +
    704                 sizeof( imagesize ) +
    705                 sizeof( int );
    706 
    707         if (data)
    708         {
    709                 packet_length += imagesize;
    710         }
    711 
    712         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    713         WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE1DARB_EXTEND_OPCODE) );
    714         WRITE_DATA( 4, GLenum, SWAP32(target) );
    715         WRITE_DATA( 8, GLint, SWAP32(level) );
    716         WRITE_DATA( 12, GLint, SWAP32(internalformat) );
    717         WRITE_DATA( 16, GLsizei, SWAP32(width) );
    718         WRITE_DATA( 20, GLint, SWAP32(border) );
    719         WRITE_DATA( 24, GLsizei, SWAP32(imagesize) );
    720         WRITE_DATA( 28, int, SWAP32(isnull) );
    721 
    722         if (data) {
    723                 crMemcpy( (void *)(data_ptr + 32), (void *)data, imagesize);
    724         }
    725 
    726         crHugePacket( CR_EXTEND_OPCODE, data_ptr );
    727         crPackFree( data_ptr );
     689    unsigned char *data_ptr;
     690    int packet_length;
     691    int isnull = (data == NULL);
     692
     693    /* All extended opcodes have their first 8 bytes predefined:
     694    * the first four indicate the packet size, and the next four
     695    * indicate the actual extended opcode.
     696    */
     697    packet_length =
     698        sizeof( GLenum) + /* extended opcode */
     699        sizeof( target ) +
     700        sizeof( level ) +
     701        sizeof( internalformat ) +
     702        sizeof( width ) +
     703        sizeof( border ) +
     704        sizeof( imagesize ) +
     705        sizeof( int );
     706
     707    if (data)
     708    {
     709        packet_length += imagesize;
     710    }
     711
     712    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     713    WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE1DARB_EXTEND_OPCODE) );
     714    WRITE_DATA( 4, GLenum, SWAP32(target) );
     715    WRITE_DATA( 8, GLint, SWAP32(level) );
     716    WRITE_DATA( 12, GLint, SWAP32(internalformat) );
     717    WRITE_DATA( 16, GLsizei, SWAP32(width) );
     718    WRITE_DATA( 20, GLint, SWAP32(border) );
     719    WRITE_DATA( 24, GLsizei, SWAP32(imagesize) );
     720    WRITE_DATA( 28, int, SWAP32(isnull) );
     721
     722    if (data) {
     723        crMemcpy( (void *)(data_ptr + 32), (void *)data, imagesize);
     724    }
     725
     726    crHugePacket( CR_EXTEND_OPCODE, data_ptr );
     727    crPackFree( data_ptr );
    728728}
    729729
    730730void PACK_APIENTRY crPackCompressedTexImage2DARBSWAP( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imagesize, const GLvoid *data )
    731731{
    732         unsigned char *data_ptr;
    733         int packet_length;
    734         int isnull = (data == NULL);
    735 
    736         /* All extended opcodes have their first 8 bytes predefined:
    737         * the first four indicate the packet size, and the next four
    738         * indicate the actual extended opcode.
    739         */
    740         packet_length =
    741                 sizeof( GLenum) + /* extended opcode */
    742                 sizeof( target ) +
    743                 sizeof( level ) +
    744                 sizeof( internalformat ) +
    745                 sizeof( width ) +
    746                 sizeof( height ) +
    747                 sizeof( border ) +
    748                 sizeof( imagesize ) +
    749                 sizeof( int ); /* isnull */
    750 
    751         if (data)
    752         {
    753                 packet_length += imagesize;
    754         }
    755 
    756         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    757         WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE2DARB_EXTEND_OPCODE) );
    758         WRITE_DATA( 4, GLenum, SWAP32(target) );
    759         WRITE_DATA( 8, GLint, SWAP32(level) );
    760         WRITE_DATA( 12, GLint, SWAP32(internalformat) );
    761         WRITE_DATA( 16, GLsizei, SWAP32(width) );
    762         WRITE_DATA( 20, GLsizei, SWAP32(height) );
    763         WRITE_DATA( 24, GLint, SWAP32(border) );
    764         WRITE_DATA( 28, GLsizei, SWAP32(imagesize) );
    765         WRITE_DATA( 32, int, SWAP32(isnull) );
    766 
    767         if (data) {
    768                 crMemcpy( (void *)(data_ptr + 36), (void *)data, imagesize);
    769         }
    770 
    771         crHugePacket( CR_EXTEND_OPCODE, data_ptr );
    772         crPackFree( data_ptr );
     732    unsigned char *data_ptr;
     733    int packet_length;
     734    int isnull = (data == NULL);
     735
     736    /* All extended opcodes have their first 8 bytes predefined:
     737    * the first four indicate the packet size, and the next four
     738    * indicate the actual extended opcode.
     739    */
     740    packet_length =
     741        sizeof( GLenum) + /* extended opcode */
     742        sizeof( target ) +
     743        sizeof( level ) +
     744        sizeof( internalformat ) +
     745        sizeof( width ) +
     746        sizeof( height ) +
     747        sizeof( border ) +
     748        sizeof( imagesize ) +
     749        sizeof( int ); /* isnull */
     750
     751    if (data)
     752    {
     753        packet_length += imagesize;
     754    }
     755
     756    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     757    WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE2DARB_EXTEND_OPCODE) );
     758    WRITE_DATA( 4, GLenum, SWAP32(target) );
     759    WRITE_DATA( 8, GLint, SWAP32(level) );
     760    WRITE_DATA( 12, GLint, SWAP32(internalformat) );
     761    WRITE_DATA( 16, GLsizei, SWAP32(width) );
     762    WRITE_DATA( 20, GLsizei, SWAP32(height) );
     763    WRITE_DATA( 24, GLint, SWAP32(border) );
     764    WRITE_DATA( 28, GLsizei, SWAP32(imagesize) );
     765    WRITE_DATA( 32, int, SWAP32(isnull) );
     766
     767    if (data) {
     768        crMemcpy( (void *)(data_ptr + 36), (void *)data, imagesize);
     769    }
     770
     771    crHugePacket( CR_EXTEND_OPCODE, data_ptr );
     772    crPackFree( data_ptr );
    773773}
    774774
    775775void PACK_APIENTRY crPackCompressedTexImage3DARBSWAP( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imagesize, const GLvoid *data )
    776776{
    777         unsigned char *data_ptr;
    778         int packet_length;
    779         int isnull = (data == NULL);
    780 
    781         /* All extended opcodes have their first 8 bytes predefined:
    782         * the first four indicate the packet size, and the next four
    783         * indicate the actual extended opcode.
    784         */
    785         packet_length =
    786                 sizeof( GLenum) + /* extended opcode */
    787                 sizeof( target ) +
    788                 sizeof( level ) +
    789                 sizeof( internalformat ) +
    790                 sizeof( width ) +
    791                 sizeof( height ) +
    792                 sizeof( depth ) +
    793                 sizeof( border ) +
    794                 sizeof( imagesize ) +
    795                 sizeof( int ); /* isnull */
    796 
    797         if (data)
    798         {
    799                 packet_length += imagesize;
    800         }
    801 
    802         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    803         WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE3DARB_EXTEND_OPCODE) );
    804         WRITE_DATA( 4, GLenum, SWAP32(target) );
    805         WRITE_DATA( 8, GLint, SWAP32(level) );
    806         WRITE_DATA( 12, GLint, SWAP32(internalformat) );
    807         WRITE_DATA( 16, GLsizei, SWAP32(width) );
    808         WRITE_DATA( 20, GLsizei, SWAP32(height) );
    809         WRITE_DATA( 24, GLsizei, SWAP32(depth) );
    810         WRITE_DATA( 28, GLint, SWAP32(border) );
    811         WRITE_DATA( 32, GLsizei, SWAP32(imagesize) );
    812         WRITE_DATA( 36, int, SWAP32(isnull) );
    813 
    814         if (data) {
    815                 crMemcpy( (void *)(data_ptr + 40), (void *)data, imagesize);
    816         }
    817 
    818         crHugePacket( CR_EXTEND_OPCODE, data_ptr );
    819         crPackFree( data_ptr );
     777    unsigned char *data_ptr;
     778    int packet_length;
     779    int isnull = (data == NULL);
     780
     781    /* All extended opcodes have their first 8 bytes predefined:
     782    * the first four indicate the packet size, and the next four
     783    * indicate the actual extended opcode.
     784    */
     785    packet_length =
     786        sizeof( GLenum) + /* extended opcode */
     787        sizeof( target ) +
     788        sizeof( level ) +
     789        sizeof( internalformat ) +
     790        sizeof( width ) +
     791        sizeof( height ) +
     792        sizeof( depth ) +
     793        sizeof( border ) +
     794        sizeof( imagesize ) +
     795        sizeof( int ); /* isnull */
     796
     797    if (data)
     798    {
     799        packet_length += imagesize;
     800    }
     801
     802    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     803    WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXIMAGE3DARB_EXTEND_OPCODE) );
     804    WRITE_DATA( 4, GLenum, SWAP32(target) );
     805    WRITE_DATA( 8, GLint, SWAP32(level) );
     806    WRITE_DATA( 12, GLint, SWAP32(internalformat) );
     807    WRITE_DATA( 16, GLsizei, SWAP32(width) );
     808    WRITE_DATA( 20, GLsizei, SWAP32(height) );
     809    WRITE_DATA( 24, GLsizei, SWAP32(depth) );
     810    WRITE_DATA( 28, GLint, SWAP32(border) );
     811    WRITE_DATA( 32, GLsizei, SWAP32(imagesize) );
     812    WRITE_DATA( 36, int, SWAP32(isnull) );
     813
     814    if (data) {
     815        crMemcpy( (void *)(data_ptr + 40), (void *)data, imagesize);
     816    }
     817
     818    crHugePacket( CR_EXTEND_OPCODE, data_ptr );
     819    crPackFree( data_ptr );
    820820}
    821821
    822822void PACK_APIENTRY crPackCompressedTexSubImage1DARBSWAP( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imagesize, const GLvoid *data )
    823823{
    824         unsigned char *data_ptr;
    825         int packet_length;
    826         int isnull = (data == NULL);
    827 
    828         /* All extended opcodes have their first 8 bytes predefined:
    829         * the first four indicate the packet size, and the next four
    830         * indicate the actual extended opcode.
    831         */
    832         packet_length =
    833                 sizeof( GLenum) + /* extended opcode */
    834                 sizeof( target ) +
    835                 sizeof( level ) +
    836                 sizeof( xoffset ) +
    837                 sizeof( width ) +
    838                 sizeof( format ) +
    839                 sizeof( imagesize ) +
    840                 sizeof( int ); /* isnull */
    841 
    842         if (data)
    843         {
    844                 packet_length += imagesize;
    845         }
    846 
    847         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    848         WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXSUBIMAGE1DARB_EXTEND_OPCODE) );
    849         WRITE_DATA( 4, GLenum, SWAP32(target) );
    850         WRITE_DATA( 8, GLint, SWAP32(level) );
    851         WRITE_DATA( 12, GLint, SWAP32(xoffset) );
    852         WRITE_DATA( 16, GLsizei, SWAP32(width) );
    853         WRITE_DATA( 20, GLenum, SWAP32(format) );
    854         WRITE_DATA( 24, GLsizei, SWAP32(imagesize) );
    855         WRITE_DATA( 28, int, SWAP32(isnull) );
    856 
    857         if (data) {
    858                 crMemcpy( (void *)(data_ptr + 32), (void *)data, imagesize);
    859         }
    860 
    861         crHugePacket( CR_EXTEND_OPCODE, data_ptr );
    862         crPackFree( data_ptr );
     824    unsigned char *data_ptr;
     825    int packet_length;
     826    int isnull = (data == NULL);
     827
     828    /* All extended opcodes have their first 8 bytes predefined:
     829    * the first four indicate the packet size, and the next four
     830    * indicate the actual extended opcode.
     831    */
     832    packet_length =
     833        sizeof( GLenum) + /* extended opcode */
     834        sizeof( target ) +
     835        sizeof( level ) +
     836        sizeof( xoffset ) +
     837        sizeof( width ) +
     838        sizeof( format ) +
     839        sizeof( imagesize ) +
     840        sizeof( int ); /* isnull */
     841
     842    if (data)
     843    {
     844        packet_length += imagesize;
     845    }
     846
     847    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     848    WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXSUBIMAGE1DARB_EXTEND_OPCODE) );
     849    WRITE_DATA( 4, GLenum, SWAP32(target) );
     850    WRITE_DATA( 8, GLint, SWAP32(level) );
     851    WRITE_DATA( 12, GLint, SWAP32(xoffset) );
     852    WRITE_DATA( 16, GLsizei, SWAP32(width) );
     853    WRITE_DATA( 20, GLenum, SWAP32(format) );
     854    WRITE_DATA( 24, GLsizei, SWAP32(imagesize) );
     855    WRITE_DATA( 28, int, SWAP32(isnull) );
     856
     857    if (data) {
     858        crMemcpy( (void *)(data_ptr + 32), (void *)data, imagesize);
     859    }
     860
     861    crHugePacket( CR_EXTEND_OPCODE, data_ptr );
     862    crPackFree( data_ptr );
    863863}
    864864
    865865void PACK_APIENTRY crPackCompressedTexSubImage2DARBSWAP( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imagesize, const GLvoid *data )
    866866{
    867         unsigned char *data_ptr;
    868         int packet_length;
    869         int isnull = (data == NULL);
    870 
    871         /* All extended opcodes have their first 8 bytes predefined:
    872         * the first four indicate the packet size, and the next four
    873         * indicate the actual extended opcode.
    874         */
    875         packet_length =
    876                 sizeof( GLenum) + /* extended opcode */
    877                 sizeof( target ) +
    878                 sizeof( level ) +
    879                 sizeof( xoffset ) +
    880                 sizeof( yoffset ) +
    881                 sizeof( width ) +
    882                 sizeof( height ) +
    883                 sizeof( format ) +
    884                 sizeof( imagesize ) +
    885                 sizeof( int ); /* isnull */
    886 
    887         if (data)
    888         {
    889                 packet_length += imagesize;
    890         }
    891 
    892         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    893         WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXSUBIMAGE2DARB_EXTEND_OPCODE) );
    894         WRITE_DATA( 4, GLenum, SWAP32(target) );
    895         WRITE_DATA( 8, GLint, SWAP32(level) );
    896         WRITE_DATA( 12, GLint, SWAP32(xoffset) );
    897         WRITE_DATA( 16, GLint, SWAP32(yoffset) );
    898         WRITE_DATA( 20, GLsizei, SWAP32(width) );
    899         WRITE_DATA( 24, GLsizei, SWAP32(height) );
    900         WRITE_DATA( 28, GLenum, SWAP32(format) );
    901         WRITE_DATA( 32, GLsizei, SWAP32(imagesize) );
    902         WRITE_DATA( 36, int, SWAP32(isnull) );
    903 
    904         if (data) {
    905                 crMemcpy( (void *)(data_ptr + 40), (void *)data, imagesize);
    906         }
    907 
    908         crHugePacket( CR_EXTEND_OPCODE, data_ptr );
    909         crPackFree( data_ptr );
     867    unsigned char *data_ptr;
     868    int packet_length;
     869    int isnull = (data == NULL);
     870
     871    /* All extended opcodes have their first 8 bytes predefined:
     872    * the first four indicate the packet size, and the next four
     873    * indicate the actual extended opcode.
     874    */
     875    packet_length =
     876        sizeof( GLenum) + /* extended opcode */
     877        sizeof( target ) +
     878        sizeof( level ) +
     879        sizeof( xoffset ) +
     880        sizeof( yoffset ) +
     881        sizeof( width ) +
     882        sizeof( height ) +
     883        sizeof( format ) +
     884        sizeof( imagesize ) +
     885        sizeof( int ); /* isnull */
     886
     887    if (data)
     888    {
     889        packet_length += imagesize;
     890    }
     891
     892    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     893    WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXSUBIMAGE2DARB_EXTEND_OPCODE) );
     894    WRITE_DATA( 4, GLenum, SWAP32(target) );
     895    WRITE_DATA( 8, GLint, SWAP32(level) );
     896    WRITE_DATA( 12, GLint, SWAP32(xoffset) );
     897    WRITE_DATA( 16, GLint, SWAP32(yoffset) );
     898    WRITE_DATA( 20, GLsizei, SWAP32(width) );
     899    WRITE_DATA( 24, GLsizei, SWAP32(height) );
     900    WRITE_DATA( 28, GLenum, SWAP32(format) );
     901    WRITE_DATA( 32, GLsizei, SWAP32(imagesize) );
     902    WRITE_DATA( 36, int, SWAP32(isnull) );
     903
     904    if (data) {
     905        crMemcpy( (void *)(data_ptr + 40), (void *)data, imagesize);
     906    }
     907
     908    crHugePacket( CR_EXTEND_OPCODE, data_ptr );
     909    crPackFree( data_ptr );
    910910}
    911911
    912912void PACK_APIENTRY crPackCompressedTexSubImage3DARBSWAP( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imagesize, const GLvoid *data )
    913913{
    914         unsigned char *data_ptr;
    915         int packet_length;
    916         int isnull = (data == NULL);
    917 
    918         /* All extended opcodes have their first 8 bytes predefined:
    919         * the first four indicate the packet size, and the next four
    920         * indicate the actual extended opcode.
    921         */
    922         packet_length =
    923                 sizeof( GLenum) + /* extended opcode */
    924                 sizeof( target ) +
    925                 sizeof( level ) +
    926                 sizeof( xoffset ) +
    927                 sizeof( yoffset ) +
    928                 sizeof( zoffset ) +
    929                 sizeof( width ) +
    930                 sizeof( height ) +
    931                 sizeof( depth ) +
    932                 sizeof( format ) +
    933                 sizeof( imagesize ) +
    934                 sizeof( int ); /* isnull */
    935 
    936         if (data)
    937         {
    938                 packet_length += imagesize;
    939         }
    940 
    941         data_ptr = (unsigned char *) crPackAlloc( packet_length );
    942         WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXSUBIMAGE3DARB_EXTEND_OPCODE) );
    943         WRITE_DATA( 4, GLenum, SWAP32(target) );
    944         WRITE_DATA( 8, GLint, SWAP32(level) );
    945         WRITE_DATA( 12, GLint, SWAP32(xoffset) );
    946         WRITE_DATA( 16, GLint, SWAP32(yoffset) );
    947         WRITE_DATA( 20, GLint, SWAP32(zoffset) );
    948         WRITE_DATA( 24, GLsizei, SWAP32(width) );
    949         WRITE_DATA( 28, GLsizei, SWAP32(height) );
    950         WRITE_DATA( 32, GLsizei, SWAP32(depth) );
    951         WRITE_DATA( 36, GLenum, SWAP32(format) );
    952         WRITE_DATA( 40, GLsizei, SWAP32(imagesize) );
    953         WRITE_DATA( 44, int, SWAP32(isnull) );
    954 
    955         if (data) {
    956                 crMemcpy( (void *)(data_ptr + 48), (void *)data, imagesize);
    957         }
    958 
    959         crHugePacket( CR_EXTEND_OPCODE, data_ptr );
    960         crPackFree( data_ptr );
     914    unsigned char *data_ptr;
     915    int packet_length;
     916    int isnull = (data == NULL);
     917
     918    /* All extended opcodes have their first 8 bytes predefined:
     919    * the first four indicate the packet size, and the next four
     920    * indicate the actual extended opcode.
     921    */
     922    packet_length =
     923        sizeof( GLenum) + /* extended opcode */
     924        sizeof( target ) +
     925        sizeof( level ) +
     926        sizeof( xoffset ) +
     927        sizeof( yoffset ) +
     928        sizeof( zoffset ) +
     929        sizeof( width ) +
     930        sizeof( height ) +
     931        sizeof( depth ) +
     932        sizeof( format ) +
     933        sizeof( imagesize ) +
     934        sizeof( int ); /* isnull */
     935
     936    if (data)
     937    {
     938        packet_length += imagesize;
     939    }
     940
     941    data_ptr = (unsigned char *) crPackAlloc( packet_length );
     942    WRITE_DATA( 0, GLenum, SWAP32(CR_COMPRESSEDTEXSUBIMAGE3DARB_EXTEND_OPCODE) );
     943    WRITE_DATA( 4, GLenum, SWAP32(target) );
     944    WRITE_DATA( 8, GLint, SWAP32(level) );
     945    WRITE_DATA( 12, GLint, SWAP32(xoffset) );
     946    WRITE_DATA( 16, GLint, SWAP32(yoffset) );
     947    WRITE_DATA( 20, GLint, SWAP32(zoffset) );
     948    WRITE_DATA( 24, GLsizei, SWAP32(width) );
     949    WRITE_DATA( 28, GLsizei, SWAP32(height) );
     950    WRITE_DATA( 32, GLsizei, SWAP32(depth) );
     951    WRITE_DATA( 36, GLenum, SWAP32(format) );
     952    WRITE_DATA( 40, GLsizei, SWAP32(imagesize) );
     953    WRITE_DATA( 44, int, SWAP32(isnull) );
     954
     955    if (data) {
     956        crMemcpy( (void *)(data_ptr + 48), (void *)data, imagesize);
     957    }
     958
     959    crHugePacket( CR_EXTEND_OPCODE, data_ptr );
     960    crPackFree( data_ptr );
    961961}
    962962
    963963void PACK_APIENTRY crPackGetCompressedTexImageARBSWAP( GLenum target, GLint level, GLvoid *img, int *writeback )
    964964{
    965         GET_PACKER_CONTEXT(pc);
    966         crError ( "GetCompressedTexImageARB needs to be special cased!");
    967         (void) pc;
    968         (void) target;
    969         (void) level;
    970         (void) img;
    971         (void) writeback;
    972 }
     965    GET_PACKER_CONTEXT(pc);
     966    crError ( "GetCompressedTexImageARB needs to be special cased!");
     967    (void) pc;
     968    (void) target;
     969    (void) level;
     970    (void) img;
     971    (void) writeback;
     972}
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette