VirtualBox

Changeset 20083 in vbox


Ignore:
Timestamp:
May 27, 2009 1:21:13 PM (15 years ago)
Author:
vboxsync
Message:

crOpenGL: tabs to spaces

Location:
trunk/src/VBox/Additions/common/crOpenGL/pack
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/common/crOpenGL/pack/pack.py

    r15532 r20083  
    3030static void __fillin( int offset, char *name, SPUGenericFunction func )
    3131{
    32         _cr_pack_table[offset].name = crStrdup( name );
    33         _cr_pack_table[offset].fn = func;
     32    _cr_pack_table[offset].name = crStrdup( name );
     33    _cr_pack_table[offset].fn = func;
    3434}"""
    3535
    … …  
    3737
    3838for func_name in keys:
    39         if ("get" in apiutil.Properties(func_name) or
    40             apiutil.FindSpecial( "packspu", func_name ) or
    41             apiutil.FindSpecial( "packspu_flush", func_name ) or
    42                 apiutil.FindSpecial( "packspu_vertex", func_name )):
    43           pack_specials.append( func_name )
     39    if ("get" in apiutil.Properties(func_name) or
     40        apiutil.FindSpecial( "packspu", func_name ) or
     41        apiutil.FindSpecial( "packspu_flush", func_name ) or
     42        apiutil.FindSpecial( "packspu_vertex", func_name )):
     43      pack_specials.append( func_name )
    4444
    4545print '\nvoid packspuCreateFunctions( void )'
    4646print '{'
    4747for index in range(len(keys)):
    48         func_name = keys[index]
    49         if apiutil.FindSpecial( "packspu_unimplemented", func_name ):
    50                 continue
    51         if func_name in pack_specials:
    52                 print '\t__fillin( %3d, "%s", (SPUGenericFunction) packspu_%s );' % (index, func_name, func_name )
    53         else:
    54                 print '\t__fillin( %3d, "%s", (SPUGenericFunction) (pack_spu.swap ? crPack%sSWAP : crPack%s) );' % (index, func_name, func_name, func_name )
     48    func_name = keys[index]
     49    if apiutil.FindSpecial( "packspu_unimplemented", func_name ):
     50        continue
     51    if func_name in pack_specials:
     52        print '\t__fillin( %3d, "%s", (SPUGenericFunction) packspu_%s );' % (index, func_name, func_name )
     53    else:
     54        print '\t__fillin( %3d, "%s", (SPUGenericFunction) (pack_spu.swap ? crPack%sSWAP : crPack%s) );' % (index, func_name, func_name, func_name )
    5555print '\t__fillin( %3d, NULL, NULL );' % num_funcs
    5656print '}'

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_beginend.py

    r15532 r20083  
    1919void PACKSPU_APIENTRY packspu_Begin( GLenum mode )
    2020{
    21         GET_THREAD(thread);
    22         CRPackBuffer *buf = &thread->BeginEndBuffer;
     21    GET_THREAD(thread);
     22    CRPackBuffer *buf = &thread->BeginEndBuffer;
    2323
    24         /* XXX comparing mode >= 0 here is not needed since mode is unsigned */
    25         CRASSERT( mode >= GL_POINTS && mode <= GL_POLYGON );
     24    /* XXX comparing mode >= 0 here is not needed since mode is unsigned */
     25    CRASSERT( mode >= GL_POINTS && mode <= GL_POLYGON );
    2626
    27         if (pack_spu.swap)
    28         {
    29                 crPackBeginSWAP( mode );
    30         }
    31         else
    32         {
    33                 crPackBegin( mode );
    34         }
     27    if (pack_spu.swap)
     28    {
     29        crPackBeginSWAP( mode );
     30    }
     31    else
     32    {
     33        crPackBegin( mode );
     34    }
    3535
    36         if ( thread->netServer.conn->Barf ) {
    37                 thread->BeginEndMode = mode;
    38                 thread->BeginEndState = -1;
    39                 if ( mode == GL_LINES || mode == GL_TRIANGLES || mode == GL_QUADS || mode == GL_POLYGON )
    40                 {
    41                         CRASSERT(!buf->pack);
     36    if ( thread->netServer.conn->Barf ) {
     37        thread->BeginEndMode = mode;
     38        thread->BeginEndState = -1;
     39        if ( mode == GL_LINES || mode == GL_TRIANGLES || mode == GL_QUADS || mode == GL_POLYGON )
     40        {
     41            CRASSERT(!buf->pack);
    4242
    43                         crPackReleaseBuffer( thread->packer );
    44                         buf->pack = crNetAlloc( thread->netServer.conn );
    45                         crPackInitBuffer( buf, buf->pack, thread->netServer.conn->buffer_size, thread->netServer.conn->mtu );
    46                         buf->holds_BeginEnd = 1;
    47                         buf->in_BeginEnd = 1;
    48                         crPackSetBuffer( thread->packer, buf );
     43            crPackReleaseBuffer( thread->packer );
     44            buf->pack = crNetAlloc( thread->netServer.conn );
     45            crPackInitBuffer( buf, buf->pack, thread->netServer.conn->buffer_size, thread->netServer.conn->mtu );
     46            buf->holds_BeginEnd = 1;
     47            buf->in_BeginEnd = 1;
     48            crPackSetBuffer( thread->packer, buf );
    4949
    50                         thread->BeginEndState = 0;
    51                 }
    52         }
     50            thread->BeginEndState = 0;
     51        }
     52    }
    5353}
    5454
    5555void PACKSPU_APIENTRY packspu_End( void )
    5656{
    57         GET_THREAD(thread);
    58         CRPackBuffer *buf = &thread->BeginEndBuffer;
     57    GET_THREAD(thread);
     58    CRPackBuffer *buf = &thread->BeginEndBuffer;
    5959
    60         if ( thread->netServer.conn->Barf &&
    61                 (thread->BeginEndMode == GL_LINES
    62                 || thread->BeginEndMode == GL_TRIANGLES
    63                 || thread->BeginEndMode == GL_QUADS
    64                 || thread->BeginEndMode == GL_POLYGON ) )
    65         {
    66                 CRASSERT(buf->pack);
     60    if ( thread->netServer.conn->Barf &&
     61        (thread->BeginEndMode == GL_LINES
     62        || thread->BeginEndMode == GL_TRIANGLES
     63        || thread->BeginEndMode == GL_QUADS
     64        || thread->BeginEndMode == GL_POLYGON ) )
     65    {
     66        CRASSERT(buf->pack);
    6767
    68                 crPackReleaseBuffer( thread->packer );
    69                 crPackSetBuffer( thread->packer, &thread->normBuffer );
    70                 if ( !crPackCanHoldBuffer( buf ) )
    71                         packspuFlush( (void *) thread );
     68        crPackReleaseBuffer( thread->packer );
     69        crPackSetBuffer( thread->packer, &thread->normBuffer );
     70        if ( !crPackCanHoldBuffer( buf ) )
     71            packspuFlush( (void *) thread );
    7272
    73                 crPackAppendBuffer( buf );
    74                 crNetFree( thread->netServer.conn, buf->pack );
    75                 buf->pack = NULL;
    76         }
     73        crPackAppendBuffer( buf );
     74        crNetFree( thread->netServer.conn, buf->pack );
     75        buf->pack = NULL;
     76    }
    7777
    78         if (pack_spu.swap)
    79         {
    80                 crPackEndSWAP();
    81         }
    82         else
    83         {
    84                 crPackEnd();
    85         }
     78    if (pack_spu.swap)
     79    {
     80        crPackEndSWAP();
     81    }
     82    else
     83    {
     84        crPackEnd();
     85    }
    8686}
    8787
    8888static void DoVertex( void )
    8989{
    90         GET_THREAD(thread);
    91         CRPackBuffer *buf = &thread->BeginEndBuffer;
    92         CRPackBuffer *gbuf = &thread->normBuffer;
    93         int num_data;
    94         int num_opcode;
     90    GET_THREAD(thread);
     91    CRPackBuffer *buf = &thread->BeginEndBuffer;
     92    CRPackBuffer *gbuf = &thread->normBuffer;
     93    int num_data;
     94    int num_opcode;
    9595
    96         /*crDebug( "really doing Vertex" );*/
    97         crPackReleaseBuffer( thread->packer );
    98         num_data = buf->data_current - buf->data_start;
    99         num_opcode = buf->opcode_start - buf->opcode_current;
    100         crPackSetBuffer( thread->packer, gbuf );
    101         if ( !crPackCanHoldBuffer( buf ) )
    102                 /* doesn't hold, first flush gbuf*/
    103                 packspuFlush( (void *) thread );
     96    /*crDebug( "really doing Vertex" );*/
     97    crPackReleaseBuffer( thread->packer );
     98    num_data = buf->data_current - buf->data_start;
     99    num_opcode = buf->opcode_start - buf->opcode_current;
     100    crPackSetBuffer( thread->packer, gbuf );
     101    if ( !crPackCanHoldBuffer( buf ) )
     102        /* doesn't hold, first flush gbuf*/
     103        packspuFlush( (void *) thread );
    104104
    105         crPackAppendBuffer( buf );
    106         crPackReleaseBuffer( thread->packer );
    107         crPackSetBuffer( thread->packer, buf );
    108         crPackResetPointers(thread->packer);
     105    crPackAppendBuffer( buf );
     106    crPackReleaseBuffer( thread->packer );
     107    crPackSetBuffer( thread->packer, buf );
     108    crPackResetPointers(thread->packer);
    109109}
    110110
    111111static void RunState( void )
    112112{
    113         GET_THREAD(thread);
    114         if (! thread->netServer.conn->Barf ) return;
    115         if (thread->BeginEndState == -1) return;
    116         switch(thread->BeginEndMode) {
    117         case GL_POLYGON:
    118                 return;
    119         case GL_LINES:
    120                 thread->BeginEndState = (thread->BeginEndState + 1) % 2;
    121                 if (thread->BeginEndState)
    122                         return;
    123                 break;
    124         case GL_TRIANGLES:
    125                 thread->BeginEndState = (thread->BeginEndState + 1) % 3;
    126                 if (thread->BeginEndState)
    127                         return;
    128                 break;
    129         case GL_QUADS:
    130                 thread->BeginEndState = (thread->BeginEndState + 1) % 4;
    131                 if (thread->BeginEndState)
    132                         return;
    133                 break;
    134         }
    135         DoVertex();
     113    GET_THREAD(thread);
     114    if (! thread->netServer.conn->Barf ) return;
     115    if (thread->BeginEndState == -1) return;
     116    switch(thread->BeginEndMode) {
     117    case GL_POLYGON:
     118        return;
     119    case GL_LINES:
     120        thread->BeginEndState = (thread->BeginEndState + 1) % 2;
     121        if (thread->BeginEndState)
     122            return;
     123        break;
     124    case GL_TRIANGLES:
     125        thread->BeginEndState = (thread->BeginEndState + 1) % 3;
     126        if (thread->BeginEndState)
     127            return;
     128        break;
     129    case GL_QUADS:
     130        thread->BeginEndState = (thread->BeginEndState + 1) % 4;
     131        if (thread->BeginEndState)
     132            return;
     133        break;
     134    }
     135    DoVertex();
    136136}
    137137"""
    … …  
    140140
    141141for func_name in apiutil.AllSpecials( "packspu_vertex" ):
    142         params = apiutil.Parameters(func_name)
    143         print 'void PACKSPU_APIENTRY packspu_%s( %s )' % ( func_name, apiutil.MakeDeclarationString(params) )
    144         print '{'
    145         print '\tif (pack_spu.swap)'
    146         print '\t{'
    147         print '\t\tcrPack%sSWAP( %s );' % ( func_name, apiutil.MakeCallString( params ) )
    148         print '\t}'
    149         print '\telse'
    150         print '\t{'
    151         print '\t\tcrPack%s( %s );' % ( func_name, apiutil.MakeCallString( params ) )
    152         print '\t}'
    153         print '\tRunState();'
    154         print '}'
     142    params = apiutil.Parameters(func_name)
     143    print 'void PACKSPU_APIENTRY packspu_%s( %s )' % ( func_name, apiutil.MakeDeclarationString(params) )
     144    print '{'
     145    print '\tif (pack_spu.swap)'
     146    print '\t{'
     147    print '\t\tcrPack%sSWAP( %s );' % ( func_name, apiutil.MakeCallString( params ) )
     148    print '\t}'
     149    print '\telse'
     150    print '\t{'
     151    print '\t\tcrPack%s( %s );' % ( func_name, apiutil.MakeCallString( params ) )
     152    print '\t}'
     153    print '\tRunState();'
     154    print '}'

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_bufferobject.c

    r15532 r20083  
    1515packspu_MapBufferARB( GLenum target, GLenum access )
    1616{
    17         GLint size = -1;
    18         GET_CONTEXT(ctx);
    19         void *buffer;
    20         CRBufferObject *bufObj;
     17    GLint size = -1;
     18    GET_CONTEXT(ctx);
     19    void *buffer;
     20    CRBufferObject *bufObj;
    2121
    22         (void) crStateMapBufferARB( target, access );
     22    (void) crStateMapBufferARB( target, access );
    2323
    24         crStateGetBufferParameterivARB(target, GL_BUFFER_SIZE_ARB, &size);
    25         if (size <= 0)
    26                 return NULL;
     24    crStateGetBufferParameterivARB(target, GL_BUFFER_SIZE_ARB, &size);
     25    if (size <= 0)
     26        return NULL;
    2727
    28         if (crStateGetError()) {
    29                 /* something may have gone wrong already */
    30                 return NULL;
    31         }
     28    if (crStateGetError()) {
     29        /* something may have gone wrong already */
     30        return NULL;
     31    }
    3232
    33         /* allocate buffer space */
    34         buffer = crAlloc(size);
    35         if (!buffer) {
    36                 return NULL;
    37         }
     33    /* allocate buffer space */
     34    buffer = crAlloc(size);
     35    if (!buffer) {
     36        return NULL;
     37    }
    3838
    39         /* update state tracker info */
    40         if (target == GL_ARRAY_BUFFER_ARB) {
    41                 bufObj = ctx->clientState->bufferobject.arrayBuffer;
    42         }
    43         else {
    44                 CRASSERT(target == GL_ELEMENT_ARRAY_BUFFER_ARB);
    45                 bufObj = ctx->clientState->bufferobject.elementsBuffer;
    46         }
    47         bufObj->pointer = buffer;
     39    /* update state tracker info */
     40    if (target == GL_ARRAY_BUFFER_ARB) {
     41        bufObj = ctx->clientState->bufferobject.arrayBuffer;
     42    }
     43    else {
     44        CRASSERT(target == GL_ELEMENT_ARRAY_BUFFER_ARB);
     45        bufObj = ctx->clientState->bufferobject.elementsBuffer;
     46    }
     47    bufObj->pointer = buffer;
    4848
    49         /* Get current buffer data from server.
    50         * Ideally, if we could detect that the entire buffer was being
    51         * rewritten, we wouldn't have to fetch the current data here.
    52         */
    53         packspu_GetBufferSubDataARB(target, 0, bufObj->size, buffer);
     49    /* Get current buffer data from server.
     50    * Ideally, if we could detect that the entire buffer was being
     51    * rewritten, we wouldn't have to fetch the current data here.
     52    */
     53    packspu_GetBufferSubDataARB(target, 0, bufObj->size, buffer);
    5454
    55         return buffer;
     55    return buffer;
    5656}
    5757
    … …  
    6060packspu_UnmapBufferARB( GLenum target )
    6161{
    62         CRBufferObject *bufObj;
    63         GET_CONTEXT(ctx);
     62    CRBufferObject *bufObj;
     63    GET_CONTEXT(ctx);
    6464
    65         if (target == GL_ARRAY_BUFFER_ARB) {
    66                 bufObj = ctx->clientState->bufferobject.arrayBuffer;
    67         }
    68         else {
    69                 CRASSERT(target == GL_ELEMENT_ARRAY_BUFFER_ARB);
    70                 bufObj = ctx->clientState->bufferobject.elementsBuffer;
    71         }
     65    if (target == GL_ARRAY_BUFFER_ARB) {
     66        bufObj = ctx->clientState->bufferobject.arrayBuffer;
     67    }
     68    else {
     69        CRASSERT(target == GL_ELEMENT_ARRAY_BUFFER_ARB);
     70        bufObj = ctx->clientState->bufferobject.elementsBuffer;
     71    }
    7272
    73         /* send new buffer contents to server */
    74         crPackBufferDataARB( target, bufObj->size, bufObj->pointer, bufObj->usage );
     73    /* send new buffer contents to server */
     74    crPackBufferDataARB( target, bufObj->size, bufObj->pointer, bufObj->usage );
    7575
    76         /* free the buffer / unmap it */
    77         crFree(bufObj->pointer);
     76    /* free the buffer / unmap it */
     77    crFree(bufObj->pointer);
    7878
    79         crStateUnmapBufferARB( target );
     79    crStateUnmapBufferARB( target );
    8080
    81         return GL_TRUE;
     81    return GL_TRUE;
    8282}
    8383
    … …  
    8585void PACKSPU_APIENTRY
    8686packspu_BufferDataARB( GLenum target, GLsizeiptrARB size,
    87                                                                                         const GLvoid * data, GLenum usage )
     87                                            const GLvoid * data, GLenum usage )
    8888{
    89         crStateBufferDataARB(target, size, data, usage);
    90         crPackBufferDataARB(target, size, data, usage);
     89    crStateBufferDataARB(target, size, data, usage);
     90    crPackBufferDataARB(target, size, data, usage);
    9191}
    9292
    … …  
    9595packspu_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
    9696{
    97         crStateGetBufferPointervARB( target, pname, params );
     97    crStateGetBufferPointervARB( target, pname, params );
    9898}
    9999
    … …  
    102102packspu_GetBufferParameterivARB( GLenum target, GLenum pname, GLint * params )
    103103{
    104         crStateGetBufferParameterivARB( target, pname, params );
     104    crStateGetBufferParameterivARB( target, pname, params );
    105105}
    106106
    … …  
    112112packspu_BindBufferARB( GLenum target, GLuint buffer )
    113113{
    114         crStateBindBufferARB(target, buffer);
    115         crPackBindBufferARB(target, buffer);
     114    crStateBindBufferARB(target, buffer);
     115    crPackBindBufferARB(target, buffer);
    116116}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_client.c

    r15532 r20083  
    1313{
    1414#if CR_ARB_vertex_buffer_object
    15         GET_CONTEXT(ctx);
    16         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    17                 if (pack_spu.swap)
    18                         crPackFogCoordPointerEXTSWAP( type, stride, pointer );
    19                 else
    20                         crPackFogCoordPointerEXT( type, stride, pointer );
    21         }
    22 #endif
    23         crStateFogCoordPointerEXT( type, stride, pointer );
     15    GET_CONTEXT(ctx);
     16    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     17        if (pack_spu.swap)
     18            crPackFogCoordPointerEXTSWAP( type, stride, pointer );
     19        else
     20            crPackFogCoordPointerEXT( type, stride, pointer );
     21    }
     22#endif
     23    crStateFogCoordPointerEXT( type, stride, pointer );
    2424}
    2525
    … …  
    2727{
    2828#if CR_ARB_vertex_buffer_object
    29         GET_CONTEXT(ctx);
    30         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    31                 if (pack_spu.swap)
    32                         crPackColorPointerSWAP( size, type, stride, pointer );
    33                 else
    34                         crPackColorPointer( size, type, stride, pointer );
    35         }
    36 #endif
    37         crStateColorPointer( size, type, stride, pointer );
     29    GET_CONTEXT(ctx);
     30    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     31        if (pack_spu.swap)
     32            crPackColorPointerSWAP( size, type, stride, pointer );
     33        else
     34            crPackColorPointer( size, type, stride, pointer );
     35    }
     36#endif
     37    crStateColorPointer( size, type, stride, pointer );
    3838}
    3939
    … …  
    4141{
    4242#if CR_ARB_vertex_buffer_object
    43         GET_CONTEXT(ctx);
    44         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    45                 if (pack_spu.swap)
    46                         crPackSecondaryColorPointerEXTSWAP( size, type, stride, pointer );
    47                 else
    48                         crPackSecondaryColorPointerEXT( size, type, stride, pointer );
    49         }
    50 #endif
    51         crStateSecondaryColorPointerEXT( size, type, stride, pointer );
     43    GET_CONTEXT(ctx);
     44    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     45        if (pack_spu.swap)
     46            crPackSecondaryColorPointerEXTSWAP( size, type, stride, pointer );
     47        else
     48            crPackSecondaryColorPointerEXT( size, type, stride, pointer );
     49    }
     50#endif
     51    crStateSecondaryColorPointerEXT( size, type, stride, pointer );
    5252}
    5353
    … …  
    5555{
    5656#if CR_ARB_vertex_buffer_object
    57         GET_CONTEXT(ctx);
    58         CRASSERT(ctx->clientState->extensions.ARB_vertex_buffer_object);
    59         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    60                 if (pack_spu.swap)
    61                         crPackVertexPointerSWAP( size, type, stride, pointer );
    62                 else
    63                         crPackVertexPointer( size, type, stride, pointer );
    64         }
    65 #endif
    66         crStateVertexPointer( size, type, stride, pointer );
     57    GET_CONTEXT(ctx);
     58    CRASSERT(ctx->clientState->extensions.ARB_vertex_buffer_object);
     59    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     60        if (pack_spu.swap)
     61            crPackVertexPointerSWAP( size, type, stride, pointer );
     62        else
     63            crPackVertexPointer( size, type, stride, pointer );
     64    }
     65#endif
     66    crStateVertexPointer( size, type, stride, pointer );
    6767}
    6868
    … …  
    7070{
    7171#if CR_ARB_vertex_buffer_object
    72         GET_CONTEXT(ctx);
    73         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    74                 if (pack_spu.swap)
    75                         crPackTexCoordPointerSWAP( size, type, stride, pointer );
    76                 else
    77                         crPackTexCoordPointer( size, type, stride, pointer );
    78         }
    79 #endif
    80         crStateTexCoordPointer( size, type, stride, pointer );
     72    GET_CONTEXT(ctx);
     73    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     74        if (pack_spu.swap)
     75            crPackTexCoordPointerSWAP( size, type, stride, pointer );
     76        else
     77            crPackTexCoordPointer( size, type, stride, pointer );
     78    }
     79#endif
     80    crStateTexCoordPointer( size, type, stride, pointer );
    8181}
    8282
    … …  
    8484{
    8585#if CR_ARB_vertex_buffer_object
    86         GET_CONTEXT(ctx);
    87         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    88                 if (pack_spu.swap)
    89                         crPackNormalPointerSWAP( type, stride, pointer );
    90                 else
    91                         crPackNormalPointer( type, stride, pointer );
    92         }
    93 #endif
    94         crStateNormalPointer( type, stride, pointer );
     86    GET_CONTEXT(ctx);
     87    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     88        if (pack_spu.swap)
     89            crPackNormalPointerSWAP( type, stride, pointer );
     90        else
     91            crPackNormalPointer( type, stride, pointer );
     92    }
     93#endif
     94    crStateNormalPointer( type, stride, pointer );
    9595}
    9696
    … …  
    9898{
    9999#if CR_ARB_vertex_buffer_object
    100         GET_CONTEXT(ctx);
    101         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    102                 if (pack_spu.swap)
    103                         crPackEdgeFlagPointerSWAP( stride, pointer );
    104                 else
    105                         crPackEdgeFlagPointer( stride, pointer );
    106         }
    107 #endif
    108         crStateEdgeFlagPointer( stride, pointer );
     100    GET_CONTEXT(ctx);
     101    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     102        if (pack_spu.swap)
     103            crPackEdgeFlagPointerSWAP( stride, pointer );
     104        else
     105            crPackEdgeFlagPointer( stride, pointer );
     106    }
     107#endif
     108    crStateEdgeFlagPointer( stride, pointer );
    109109}
    110110
    … …  
    112112{
    113113#if CR_ARB_vertex_buffer_object
    114         GET_CONTEXT(ctx);
    115         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    116                 if (pack_spu.swap)
    117                         crPackVertexAttribPointerARBSWAP( index, size, type, normalized, stride, pointer );
    118                 else
    119                         crPackVertexAttribPointerARB( index, size, type, normalized, stride, pointer );
    120         }
    121 #endif
    122         crStateVertexAttribPointerARB( index, size, type, normalized, stride, pointer );
     114    GET_CONTEXT(ctx);
     115    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     116        if (pack_spu.swap)
     117            crPackVertexAttribPointerARBSWAP( index, size, type, normalized, stride, pointer );
     118        else
     119            crPackVertexAttribPointerARB( index, size, type, normalized, stride, pointer );
     120    }
     121#endif
     122    crStateVertexAttribPointerARB( index, size, type, normalized, stride, pointer );
    123123}
    124124
    … …  
    126126{
    127127#if CR_ARB_vertex_buffer_object
    128         GET_CONTEXT(ctx);
    129         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    130                 if (pack_spu.swap)
    131                         crPackVertexAttribPointerNVSWAP( index, size, type, stride, pointer );
    132                 else
    133                         crPackVertexAttribPointerNV( index, size, type, stride, pointer );
    134         }
    135 #endif
    136         crStateVertexAttribPointerNV( index, size, type, stride, pointer );
     128    GET_CONTEXT(ctx);
     129    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     130        if (pack_spu.swap)
     131            crPackVertexAttribPointerNVSWAP( index, size, type, stride, pointer );
     132        else
     133            crPackVertexAttribPointerNV( index, size, type, stride, pointer );
     134    }
     135#endif
     136    crStateVertexAttribPointerNV( index, size, type, stride, pointer );
    137137}
    138138
    139139void PACKSPU_APIENTRY packspu_GetPointerv( GLenum pname, GLvoid **params )
    140140{
    141         crStateGetPointerv( pname, params );
     141    crStateGetPointerv( pname, params );
    142142}
    143143
    … …  
    145145{
    146146#if CR_ARB_vertex_buffer_object
    147         GET_CONTEXT(ctx);
    148         if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
    149                 if (pack_spu.swap)
    150                         crPackInterleavedArraysSWAP( format, stride, pointer );
    151                 else
    152                         crPackInterleavedArrays( format, stride, pointer );
    153         }
    154 #endif
    155         crStateInterleavedArrays( format, stride, pointer );
     147    GET_CONTEXT(ctx);
     148    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     149        if (pack_spu.swap)
     150            crPackInterleavedArraysSWAP( format, stride, pointer );
     151        else
     152            crPackInterleavedArrays( format, stride, pointer );
     153    }
     154#endif
     155    crStateInterleavedArrays( format, stride, pointer );
    156156}
    157157
    … …  
    160160packspu_ArrayElement( GLint index )
    161161{
    162         GLboolean serverArrays = GL_FALSE;
    163 
    164 #if CR_ARB_vertex_buffer_object
    165         GET_CONTEXT(ctx);
    166         if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    167                 serverArrays = crStateUseServerArrays();
    168 #endif
    169 
    170         if (serverArrays) {
    171                 /* Send the DrawArrays command over the wire */
    172                 if (pack_spu.swap)
    173                         crPackArrayElementSWAP( index );
    174                 else
    175                         crPackArrayElement( index );
    176         }
    177         else {
    178                 /* evaluate locally */
    179                 GET_CONTEXT(ctx);
    180                 CRClientState *clientState = &(ctx->clientState->client);
    181                 if (pack_spu.swap)
    182                         crPackExpandArrayElementSWAP( index, clientState );
    183                 else
    184                         crPackExpandArrayElement( index, clientState );
    185         }
     162    GLboolean serverArrays = GL_FALSE;
     163
     164#if CR_ARB_vertex_buffer_object
     165    GET_CONTEXT(ctx);
     166    if (ctx->clientState->extensions.ARB_vertex_buffer_object)
     167        serverArrays = crStateUseServerArrays();
     168#endif
     169
     170    if (serverArrays) {
     171        /* Send the DrawArrays command over the wire */
     172        if (pack_spu.swap)
     173            crPackArrayElementSWAP( index );
     174        else
     175            crPackArrayElement( index );
     176    }
     177    else {
     178        /* evaluate locally */
     179        GET_CONTEXT(ctx);
     180        CRClientState *clientState = &(ctx->clientState->client);
     181        if (pack_spu.swap)
     182            crPackExpandArrayElementSWAP( index, clientState );
     183        else
     184            crPackExpandArrayElement( index, clientState );
     185    }
    186186}
    187187
    … …  
    190190packspu_DrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
    191191{
    192         GLboolean serverArrays = GL_FALSE;
    193 
    194 #if CR_ARB_vertex_buffer_object
    195         GET_CONTEXT(ctx);
    196         if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    197                 serverArrays = crStateUseServerArrays();
    198 #endif
    199 
    200         if (serverArrays) {
    201                 /* Send the DrawArrays command over the wire */
    202                 if (pack_spu.swap)
    203                         crPackDrawElementsSWAP( mode, count, type, indices );
    204                 else
    205                         crPackDrawElements( mode, count, type, indices );
    206         }
    207         else {
    208                 /* evaluate locally */
    209                 GET_CONTEXT(ctx);
    210                 CRClientState *clientState = &(ctx->clientState->client);
    211                 if (pack_spu.swap)
    212                         crPackExpandDrawElementsSWAP( mode, count, type, indices, clientState );
    213                 else
    214                         crPackExpandDrawElements( mode, count, type, indices, clientState );
    215         }
     192    GLboolean serverArrays = GL_FALSE;
     193
     194#if CR_ARB_vertex_buffer_object
     195    GET_CONTEXT(ctx);
     196    if (ctx->clientState->extensions.ARB_vertex_buffer_object)
     197        serverArrays = crStateUseServerArrays();
     198#endif
     199
     200    if (serverArrays) {
     201        /* Send the DrawArrays command over the wire */
     202        if (pack_spu.swap)
     203            crPackDrawElementsSWAP( mode, count, type, indices );
     204        else
     205            crPackDrawElements( mode, count, type, indices );
     206    }
     207    else {
     208        /* evaluate locally */
     209        GET_CONTEXT(ctx);
     210        CRClientState *clientState = &(ctx->clientState->client);
     211        if (pack_spu.swap)
     212            crPackExpandDrawElementsSWAP( mode, count, type, indices, clientState );
     213        else
     214            crPackExpandDrawElements( mode, count, type, indices, clientState );
     215    }
    216216}
    217217
    … …  
    220220packspu_DrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices )
    221221{
    222         GLboolean serverArrays = GL_FALSE;
    223 
    224 #if CR_ARB_vertex_buffer_object
    225         GET_CONTEXT(ctx);
    226         if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    227                 serverArrays = crStateUseServerArrays();
    228 #endif
    229 
    230         if (serverArrays) {
    231                 /* Send the DrawRangeElements command over the wire */
    232                 if (pack_spu.swap)
    233                         crPackDrawRangeElementsSWAP( mode, start, end, count, type, indices );
    234                 else
    235                         crPackDrawRangeElements( mode, start, end, count, type, indices );
    236         }
    237         else {
    238                 /* evaluate locally */
    239                 GET_CONTEXT(ctx);
    240                 CRClientState *clientState = &(ctx->clientState->client);
    241                 if (pack_spu.swap)
    242                         crPackExpandDrawRangeElementsSWAP( mode, start, end, count, type, indices, clientState );
    243                 else
    244                         crPackExpandDrawRangeElements( mode, start, end, count, type, indices, clientState );
    245         }
     222    GLboolean serverArrays = GL_FALSE;
     223
     224#if CR_ARB_vertex_buffer_object
     225    GET_CONTEXT(ctx);
     226    if (ctx->clientState->extensions.ARB_vertex_buffer_object)
     227        serverArrays = crStateUseServerArrays();
     228#endif
     229
     230    if (serverArrays) {
     231        /* Send the DrawRangeElements command over the wire */
     232        if (pack_spu.swap)
     233            crPackDrawRangeElementsSWAP( mode, start, end, count, type, indices );
     234        else
     235            crPackDrawRangeElements( mode, start, end, count, type, indices );
     236    }
     237    else {
     238        /* evaluate locally */
     239        GET_CONTEXT(ctx);
     240        CRClientState *clientState = &(ctx->clientState->client);
     241        if (pack_spu.swap)
     242            crPackExpandDrawRangeElementsSWAP( mode, start, end, count, type, indices, clientState );
     243        else
     244            crPackExpandDrawRangeElements( mode, start, end, count, type, indices, clientState );
     245    }
    246246}
    247247
    … …  
    250250packspu_DrawArrays( GLenum mode, GLint first, GLsizei count )
    251251{
    252         GLboolean serverArrays = GL_FALSE;
    253 
    254 #if CR_ARB_vertex_buffer_object
    255         GET_CONTEXT(ctx);
    256         if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    257                 serverArrays = crStateUseServerArrays();
    258 #endif
    259 
    260         if (serverArrays) {
    261                 /* Send the DrawArrays command over the wire */
    262                 if (pack_spu.swap)
    263                         crPackDrawArraysSWAP( mode, first, count );
    264                 else
    265                         crPackDrawArrays( mode, first, count );
    266         }
    267         else {
    268                 /* evaluate locally */
    269                 GET_CONTEXT(ctx);
    270                 CRClientState *clientState = &(ctx->clientState->client);
    271                 if (pack_spu.swap)
    272                         crPackExpandDrawArraysSWAP( mode, first, count, clientState );
    273                 else
    274                         crPackExpandDrawArrays( mode, first, count, clientState );
    275         }
     252    GLboolean serverArrays = GL_FALSE;
     253
     254#if CR_ARB_vertex_buffer_object
     255    GET_CONTEXT(ctx);
     256    if (ctx->clientState->extensions.ARB_vertex_buffer_object)
     257        serverArrays = crStateUseServerArrays();
     258#endif
     259
     260    if (serverArrays) {
     261        /* Send the DrawArrays command over the wire */
     262        if (pack_spu.swap)
     263            crPackDrawArraysSWAP( mode, first, count );
     264        else
     265            crPackDrawArrays( mode, first, count );
     266    }
     267    else {
     268        /* evaluate locally */
     269        GET_CONTEXT(ctx);
     270        CRClientState *clientState = &(ctx->clientState->client);
     271        if (pack_spu.swap)
     272            crPackExpandDrawArraysSWAP( mode, first, count, clientState );
     273        else
     274            crPackExpandDrawArrays( mode, first, count, clientState );
     275    }
    276276}
    277277
    … …  
    280280void PACKSPU_APIENTRY packspu_MultiDrawArraysEXT( GLenum mode, GLint *first, GLsizei *count, GLsizei primcount )
    281281{
    282         GLint i;
    283         for (i = 0; i < primcount; i++) {
    284                 if (count[i] > 0) {
    285                         packspu_DrawArrays(mode, first[i], count[i]);
    286                 }
    287         }
     282    GLint i;
     283    for (i = 0; i < primcount; i++) {
     284        if (count[i] > 0) {
     285            packspu_DrawArrays(mode, first[i], count[i]);
     286        }
     287    }
    288288}
    289289
    290290void PACKSPU_APIENTRY packspu_MultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount )
    291291{
    292         GLint i;
    293         for (i = 0; i < primcount; i++) {
    294                 if (count[i] > 0) {
    295                         packspu_DrawElements(mode, count[i], type, indices[i]);
    296                 }
    297         }
     292    GLint i;
     293    for (i = 0; i < primcount; i++) {
     294        if (count[i] > 0) {
     295            packspu_DrawElements(mode, count[i], type, indices[i]);
     296        }
     297    }
    298298}
    299299#endif
    … …  
    302302void PACKSPU_APIENTRY packspu_EnableClientState( GLenum array )
    303303{
    304         crStateEnableClientState( array );
     304    crStateEnableClientState( array );
    305305}
    306306
    307307void PACKSPU_APIENTRY packspu_DisableClientState( GLenum array )
    308308{
    309         crStateDisableClientState( array );
     309    crStateDisableClientState( array );
    310310}
    311311
    312312void PACKSPU_APIENTRY packspu_ClientActiveTextureARB( GLenum texUnit )
    313313{
    314         crStateClientActiveTextureARB( texUnit );
    315         /* XXX also send to server for texcoord arrays? */
     314    crStateClientActiveTextureARB( texUnit );
     315    /* XXX also send to server for texcoord arrays? */
    316316}
    317317
    … …  
    319319void PACKSPU_APIENTRY packspu_Enable( GLenum cap )
    320320{
    321         switch (cap) {
    322         case GL_VERTEX_ARRAY:
    323         case GL_NORMAL_ARRAY:
    324         case GL_COLOR_ARRAY:
    325         case GL_INDEX_ARRAY:
    326         case GL_TEXTURE_COORD_ARRAY:
    327         case GL_EDGE_FLAG_ARRAY:
    328         case GL_FOG_COORDINATE_ARRAY_EXT:
    329         case GL_SECONDARY_COLOR_ARRAY_EXT:
     321    switch (cap) {
     322    case GL_VERTEX_ARRAY:
     323    case GL_NORMAL_ARRAY:
     324    case GL_COLOR_ARRAY:
     325    case GL_INDEX_ARRAY:
     326    case GL_TEXTURE_COORD_ARRAY:
     327    case GL_EDGE_FLAG_ARRAY:
     328    case GL_FOG_COORDINATE_ARRAY_EXT:
     329    case GL_SECONDARY_COLOR_ARRAY_EXT:
    330330#if CR_NV_vertex_program
    331         case GL_VERTEX_ATTRIB_ARRAY0_NV:
    332         case GL_VERTEX_ATTRIB_ARRAY1_NV:
    333         case GL_VERTEX_ATTRIB_ARRAY2_NV:
    334         case GL_VERTEX_ATTRIB_ARRAY3_NV:
    335         case GL_VERTEX_ATTRIB_ARRAY4_NV:
    336         case GL_VERTEX_ATTRIB_ARRAY5_NV:
    337         case GL_VERTEX_ATTRIB_ARRAY6_NV:
    338         case GL_VERTEX_ATTRIB_ARRAY7_NV:
    339         case GL_VERTEX_ATTRIB_ARRAY8_NV:
    340         case GL_VERTEX_ATTRIB_ARRAY9_NV:
    341         case GL_VERTEX_ATTRIB_ARRAY10_NV:
    342         case GL_VERTEX_ATTRIB_ARRAY11_NV:
    343         case GL_VERTEX_ATTRIB_ARRAY12_NV:
    344         case GL_VERTEX_ATTRIB_ARRAY13_NV:
    345         case GL_VERTEX_ATTRIB_ARRAY14_NV:
    346         case GL_VERTEX_ATTRIB_ARRAY15_NV:
     331    case GL_VERTEX_ATTRIB_ARRAY0_NV:
     332    case GL_VERTEX_ATTRIB_ARRAY1_NV:
     333    case GL_VERTEX_ATTRIB_ARRAY2_NV:
     334    case GL_VERTEX_ATTRIB_ARRAY3_NV:
     335    case GL_VERTEX_ATTRIB_ARRAY4_NV:
     336    case GL_VERTEX_ATTRIB_ARRAY5_NV:
     337    case GL_VERTEX_ATTRIB_ARRAY6_NV:
     338    case GL_VERTEX_ATTRIB_ARRAY7_NV:
     339    case GL_VERTEX_ATTRIB_ARRAY8_NV:
     340    case GL_VERTEX_ATTRIB_ARRAY9_NV:
     341    case GL_VERTEX_ATTRIB_ARRAY10_NV:
     342    case GL_VERTEX_ATTRIB_ARRAY11_NV:
     343    case GL_VERTEX_ATTRIB_ARRAY12_NV:
     344    case GL_VERTEX_ATTRIB_ARRAY13_NV:
     345    case GL_VERTEX_ATTRIB_ARRAY14_NV:
     346    case GL_VERTEX_ATTRIB_ARRAY15_NV:
    347347#endif /* CR_NV_vertex_program */
    348                 crStateEnableClientState(cap);
    349                 break;
    350         default:
    351                 ;
    352         }
    353 
    354         if (pack_spu.swap)
    355                 crPackEnableSWAP(cap);
    356         else
    357                 crPackEnable(cap);
     348        crStateEnableClientState(cap);
     349        break;
     350    default:
     351        ;
     352    }
     353
     354    if (pack_spu.swap)
     355        crPackEnableSWAP(cap);
     356    else
     357        crPackEnable(cap);
    358358}
    359359
    … …  
    361361void PACKSPU_APIENTRY packspu_Disable( GLenum cap )
    362362{
    363         switch (cap) {
    364         case GL_VERTEX_ARRAY:
    365         case GL_NORMAL_ARRAY:
    366         case GL_COLOR_ARRAY:
    367         case GL_INDEX_ARRAY:
    368         case GL_TEXTURE_COORD_ARRAY:
    369         case GL_EDGE_FLAG_ARRAY:
    370         case GL_FOG_COORDINATE_ARRAY_EXT:
    371         case GL_SECONDARY_COLOR_ARRAY_EXT:
     363    switch (cap) {
     364    case GL_VERTEX_ARRAY:
     365    case GL_NORMAL_ARRAY:
     366    case GL_COLOR_ARRAY:
     367    case GL_INDEX_ARRAY:
     368    case GL_TEXTURE_COORD_ARRAY:
     369    case GL_EDGE_FLAG_ARRAY:
     370    case GL_FOG_COORDINATE_ARRAY_EXT:
     371    case GL_SECONDARY_COLOR_ARRAY_EXT:
    372372#if CR_NV_vertex_program
    373         case GL_VERTEX_ATTRIB_ARRAY0_NV:
    374         case GL_VERTEX_ATTRIB_ARRAY1_NV:
    375         case GL_VERTEX_ATTRIB_ARRAY2_NV:
    376         case GL_VERTEX_ATTRIB_ARRAY3_NV:
    377         case GL_VERTEX_ATTRIB_ARRAY4_NV:
    378         case GL_VERTEX_ATTRIB_ARRAY5_NV:
    379         case GL_VERTEX_ATTRIB_ARRAY6_NV:
    380         case GL_VERTEX_ATTRIB_ARRAY7_NV:
    381         case GL_VERTEX_ATTRIB_ARRAY8_NV:
    382         case GL_VERTEX_ATTRIB_ARRAY9_NV:
    383         case GL_VERTEX_ATTRIB_ARRAY10_NV:
    384         case GL_VERTEX_ATTRIB_ARRAY11_NV:
    385         case GL_VERTEX_ATTRIB_ARRAY12_NV:
    386         case GL_VERTEX_ATTRIB_ARRAY13_NV:
    387         case GL_VERTEX_ATTRIB_ARRAY14_NV:
    388         case GL_VERTEX_ATTRIB_ARRAY15_NV:
     373    case GL_VERTEX_ATTRIB_ARRAY0_NV:
     374    case GL_VERTEX_ATTRIB_ARRAY1_NV:
     375    case GL_VERTEX_ATTRIB_ARRAY2_NV:
     376    case GL_VERTEX_ATTRIB_ARRAY3_NV:
     377    case GL_VERTEX_ATTRIB_ARRAY4_NV:
     378    case GL_VERTEX_ATTRIB_ARRAY5_NV:
     379    case GL_VERTEX_ATTRIB_ARRAY6_NV:
     380    case GL_VERTEX_ATTRIB_ARRAY7_NV:
     381    case GL_VERTEX_ATTRIB_ARRAY8_NV:
     382    case GL_VERTEX_ATTRIB_ARRAY9_NV:
     383    case GL_VERTEX_ATTRIB_ARRAY10_NV:
     384    case GL_VERTEX_ATTRIB_ARRAY11_NV:
     385    case GL_VERTEX_ATTRIB_ARRAY12_NV:
     386    case GL_VERTEX_ATTRIB_ARRAY13_NV:
     387    case GL_VERTEX_ATTRIB_ARRAY14_NV:
     388    case GL_VERTEX_ATTRIB_ARRAY15_NV:
    389389#endif /* CR_NV_vertex_program */
    390                 crStateDisableClientState(cap);
    391                 break;
    392         default:
    393                 ;
    394         }
    395 
    396         if (pack_spu.swap)
    397                 crPackDisableSWAP(cap);
    398         else
    399                 crPackDisable(cap);
     390        crStateDisableClientState(cap);
     391        break;
     392    default:
     393        ;
     394    }
     395
     396    if (pack_spu.swap)
     397        crPackDisableSWAP(cap);
     398    else
     399        crPackDisable(cap);
    400400}
    401401
    … …  
    403403void PACKSPU_APIENTRY packspu_PushClientAttrib( GLbitfield mask )
    404404{
    405         crStatePushClientAttrib(mask);
     405    crStatePushClientAttrib(mask);
    406406}
    407407
    408408void PACKSPU_APIENTRY packspu_PopClientAttrib( void )
    409409{
    410         crStatePopClientAttrib();
    411 }
     410    crStatePopClientAttrib();
     411}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_flush.py

    r15532 r20083  
    2626
    2727for func_name in apiutil.AllSpecials( "packspu_flush" ):
    28         params = apiutil.Parameters(func_name)
    29         print 'void PACKSPU_APIENTRY packspu_%s( %s )' % ( func_name, apiutil.MakeDeclarationString(params))
    30         print '{'
    31         print '\tGET_THREAD(thread);'
    32         print '\tif (pack_spu.swap)'
    33         print '\t{'
    34         print '\t\tcrPack%sSWAP( %s );' % ( func_name, apiutil.MakeCallString( params ) )
    35         print '\t}'
    36         print '\telse'
    37         print '\t{'
    38         print '\t\tcrPack%s( %s );' % ( func_name, apiutil.MakeCallString( params ) )
    39         print '\t}'
    40         print '\tpackspuFlush( (void *) thread );'
    41         print '}\n'
     28    params = apiutil.Parameters(func_name)
     29    print 'void PACKSPU_APIENTRY packspu_%s( %s )' % ( func_name, apiutil.MakeDeclarationString(params))
     30    print '{'
     31    print '\tGET_THREAD(thread);'
     32    print '\tif (pack_spu.swap)'
     33    print '\t{'
     34    print '\t\tcrPack%sSWAP( %s );' % ( func_name, apiutil.MakeCallString( params ) )
     35    print '\t}'
     36    print '\telse'
     37    print '\t{'
     38    print '\t\tcrPack%s( %s );' % ( func_name, apiutil.MakeCallString( params ) )
     39    print '\t}'
     40    print '\tpackspuFlush( (void *) thread );'
     41    print '}\n'

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_get.py

    r15532 r20083  
    2323
    2424easy_swaps = {
    25         'GenTextures': '(unsigned int) n',
    26         'GetClipPlane': '4',
    27         'GetPolygonStipple': '0'
     25    'GenTextures': '(unsigned int) n',
     26    'GetClipPlane': '4',
     27    'GetPolygonStipple': '0'
    2828}
    29        
     29   
    3030simple_funcs = [ 'GetIntegerv', 'GetFloatv', 'GetDoublev', 'GetBooleanv' ]
    3131simple_swaps = [ 'SWAP32', 'SWAPFLOAT', 'SWAPDOUBLE', '(GLboolean) SWAP32' ]
    3232
    3333hard_funcs = {
    34         'GetLightfv': 'SWAPFLOAT',
    35         'GetLightiv': 'SWAP32',
    36         'GetMaterialfv': 'SWAPFLOAT',
    37         'GetMaterialiv': 'SWAP32',
    38         'GetTexEnvfv': 'SWAPFLOAT',
    39         'GetTexEnviv': 'SWAP32',
    40         'GetTexGendv': 'SWAPDOUBLE',
    41         'GetTexGenfv': 'SWAPFLOAT',
    42         'GetTexGeniv': 'SWAP32',
    43         'GetTexLevelParameterfv': 'SWAPFLOAT',
    44         'GetTexLevelParameteriv': 'SWAP32',
    45         'GetTexParameterfv': 'SWAPFLOAT',
    46         'GetTexParameteriv': 'SWAP32' }
     34    'GetLightfv': 'SWAPFLOAT',
     35    'GetLightiv': 'SWAP32',
     36    'GetMaterialfv': 'SWAPFLOAT',
     37    'GetMaterialiv': 'SWAP32',
     38    'GetTexEnvfv': 'SWAPFLOAT',
     39    'GetTexEnviv': 'SWAP32',
     40    'GetTexGendv': 'SWAPDOUBLE',
     41    'GetTexGenfv': 'SWAPFLOAT',
     42    'GetTexGeniv': 'SWAP32',
     43    'GetTexLevelParameterfv': 'SWAPFLOAT',
     44    'GetTexLevelParameteriv': 'SWAP32',
     45    'GetTexParameterfv': 'SWAPFLOAT',
     46    'GetTexParameteriv': 'SWAP32' }
    4747
    4848keys = apiutil.GetDispatchedFunctions(sys.argv[1]+"/APIspec.txt")
    4949
    5050for func_name in keys:
    51         params = apiutil.Parameters(func_name)
    52         return_type = apiutil.ReturnType(func_name)
    53         if apiutil.FindSpecial( "packspu", func_name ):
    54                 continue
     51    params = apiutil.Parameters(func_name)
     52    return_type = apiutil.ReturnType(func_name)
     53    if apiutil.FindSpecial( "packspu", func_name ):
     54        continue
    5555
    56         if "get" in apiutil.Properties(func_name):
    57                 print '%s PACKSPU_APIENTRY packspu_%s( %s )' % ( return_type, func_name, apiutil.MakeDeclarationString( params ) )
    58                 print '{'
    59                 print '\tGET_THREAD(thread);'
    60                 print '\tint writeback = 1;'
    61                 if return_type != 'void':
    62                         print '\t%s return_val = (%s) 0;' % (return_type, return_type)
    63                         params.append( ("&return_val", "foo", 0) )
    64                 if (func_name in easy_swaps.keys() and easy_swaps[func_name] != '0') or func_name in simple_funcs or func_name in hard_funcs.keys():
    65                         print '\tunsigned int i;'
    66                 print '\tif (!(pack_spu.thread[0].netServer.conn->actual_network))'
    67                 print '\t{'
    68                 print '\t\tcrError( "packspu_%s doesn\'t work when there\'s no actual network involved!\\nTry using the simplequery SPU in your chain!" );' % func_name
    69                 print '\t}'
    70                 if func_name in simple_funcs:
    71                         print '\tif (pname == GL_UNPACK_ALIGNMENT ||'
    72                         print '\t\tpname == GL_UNPACK_ROW_LENGTH ||'
    73                         print '\t\tpname == GL_UNPACK_SKIP_PIXELS ||'
    74                         print '\t\tpname == GL_UNPACK_LSB_FIRST ||'
    75                         print '\t\tpname == GL_UNPACK_SWAP_BYTES ||'
    76                         print '#ifdef CR_OPENGL_VERSION_1_2'
    77                         print '\t\tpname == GL_UNPACK_IMAGE_HEIGHT ||'
    78                         print '#endif'
    79                         print '\t\tpname == GL_UNPACK_SKIP_ROWS ||'
    80                         print '\t\tpname == GL_PACK_ALIGNMENT ||'
    81                         print '\t\tpname == GL_PACK_ROW_LENGTH ||'
    82                         print '\t\tpname == GL_PACK_SKIP_PIXELS ||'
    83                         print '\t\tpname == GL_PACK_LSB_FIRST ||'
    84                         print '\t\tpname == GL_PACK_SWAP_BYTES ||'
    85                         print '#ifdef CR_OPENGL_VERSION_1_2'
    86                         print '\t\tpname == GL_PACK_IMAGE_HEIGHT ||'
    87                         print '#endif'
    88                         print '\t\tpname == GL_PACK_SKIP_ROWS) {'
    89                         print '\t\t\tcrState%s( pname, params );' % func_name
    90                         print '\t\t\treturn;'
    91                         print '\t}'
    92                 params.append( ("&writeback", "foo", 0) )
    93                 print '\tif (pack_spu.swap)'
    94                 print '\t{'
    95                 print '\t\tcrPack%sSWAP( %s );' % (func_name, apiutil.MakeCallString( params ) )
    96                 print '\t}'
    97                 print '\telse'
    98                 print '\t{'
    99                 print '\t\tcrPack%s( %s );' % (func_name, apiutil.MakeCallString( params ) )
    100                 print '\t}'
    101                 print '\tpackspuFlush( (void *) thread );'
    102                 print '\twhile (writeback)'
    103                 print '\t\tcrNetRecv();'
    104                 lastParamName = params[-2][0]
    105                 if return_type != 'void':
    106                         print '\tif (pack_spu.swap)'
    107                         print '\t{'
    108                         print '\t\treturn_val = (%s) SWAP32(return_val);' % return_type
    109                         print '\t}'
    110                         print '\treturn return_val;'
    111                 if func_name in easy_swaps.keys() and easy_swaps[func_name] != '0':
    112                         limit = easy_swaps[func_name]
    113                         print '\tif (pack_spu.swap)'
    114                         print '\t{'
    115                         print '\t\tfor (i = 0 ; i < %s ; i++)' % limit
    116                         print '\t\t{'
    117                         if params[-2][1].find( "double" ) > -1:
    118                                 print '\t\t\t%s[i] = SWAPDOUBLE(%s[i]);' % (lastParamName, lastParamName)
    119                         else:
    120                                 print '\t\t\t%s[i] = SWAP32(%s[i]);' % (lastParamName, lastParamName)
    121                         print '\t\t}'
    122                         print '\t}'
    123                 for index in range(len(simple_funcs)):
    124                         if simple_funcs[index] == func_name:
    125                                 print '\tif (pack_spu.swap)'
    126                                 print '\t{'
    127                                 print '\t\tfor (i = 0 ; i < __numValues( pname ) ; i++)'
    128                                 print '\t\t{'
    129                                 if simple_swaps[index] == 'SWAPDOUBLE':
    130                                         print '\t\t\t%s[i] = %s(%s[i]);' % (lastParamName, simple_swaps[index], lastParamName)
    131                                 else:
    132                                         print '\t\t\t((GLuint *) %s)[i] = %s(%s[i]);' % (lastParamName, simple_swaps[index], lastParamName)
    133                                 print '\t\t}'
    134                                 print '\t}'
    135                 if func_name in hard_funcs.keys():
    136                         print '\tif (pack_spu.swap)'
    137                         print '\t{'
    138                         print '\t\tfor (i = 0 ; i < lookupComponents(pname) ; i++)'
    139                         print '\t\t{'
    140                         if hard_funcs[func_name] == 'SWAPDOUBLE':
    141                                 print '\t\t\t%s[i] = %s(%s[i]);' % (lastParamName, hard_funcs[func_name], lastParamName)
    142                         else:
    143                                 print '\t\t\t((GLuint *) %s)[i] = %s(%s[i]);' % (lastParamName, hard_funcs[func_name], lastParamName)
    144                         print '\t\t}'
    145                         print '\t}'
    146                 print '}\n'
     56    if "get" in apiutil.Properties(func_name):
     57        print '%s PACKSPU_APIENTRY packspu_%s( %s )' % ( return_type, func_name, apiutil.MakeDeclarationString( params ) )
     58        print '{'
     59        print '\tGET_THREAD(thread);'
     60        print '\tint writeback = 1;'
     61        if return_type != 'void':
     62            print '\t%s return_val = (%s) 0;' % (return_type, return_type)
     63            params.append( ("&return_val", "foo", 0) )
     64        if (func_name in easy_swaps.keys() and easy_swaps[func_name] != '0') or func_name in simple_funcs or func_name in hard_funcs.keys():
     65            print '\tunsigned int i;'
     66        print '\tif (!(pack_spu.thread[0].netServer.conn->actual_network))'
     67        print '\t{'
     68        print '\t\tcrError( "packspu_%s doesn\'t work when there\'s no actual network involved!\\nTry using the simplequery SPU in your chain!" );' % func_name
     69        print '\t}'
     70        if func_name in simple_funcs:
     71            print '\tif (pname == GL_UNPACK_ALIGNMENT ||'
     72            print '\t\tpname == GL_UNPACK_ROW_LENGTH ||'
     73            print '\t\tpname == GL_UNPACK_SKIP_PIXELS ||'
     74            print '\t\tpname == GL_UNPACK_LSB_FIRST ||'
     75            print '\t\tpname == GL_UNPACK_SWAP_BYTES ||'
     76            print '#ifdef CR_OPENGL_VERSION_1_2'
     77            print '\t\tpname == GL_UNPACK_IMAGE_HEIGHT ||'
     78            print '#endif'
     79            print '\t\tpname == GL_UNPACK_SKIP_ROWS ||'
     80            print '\t\tpname == GL_PACK_ALIGNMENT ||'
     81            print '\t\tpname == GL_PACK_ROW_LENGTH ||'
     82            print '\t\tpname == GL_PACK_SKIP_PIXELS ||'
     83            print '\t\tpname == GL_PACK_LSB_FIRST ||'
     84            print '\t\tpname == GL_PACK_SWAP_BYTES ||'
     85            print '#ifdef CR_OPENGL_VERSION_1_2'
     86            print '\t\tpname == GL_PACK_IMAGE_HEIGHT ||'
     87            print '#endif'
     88            print '\t\tpname == GL_PACK_SKIP_ROWS) {'
     89            print '\t\t\tcrState%s( pname, params );' % func_name
     90            print '\t\t\treturn;'
     91            print '\t}'
     92        params.append( ("&writeback", "foo", 0) )
     93        print '\tif (pack_spu.swap)'
     94        print '\t{'
     95        print '\t\tcrPack%sSWAP( %s );' % (func_name, apiutil.MakeCallString( params ) )
     96        print '\t}'
     97        print '\telse'
     98        print '\t{'
     99        print '\t\tcrPack%s( %s );' % (func_name, apiutil.MakeCallString( params ) )
     100        print '\t}'
     101        print '\tpackspuFlush( (void *) thread );'
     102        print '\twhile (writeback)'
     103        print '\t\tcrNetRecv();'
     104        lastParamName = params[-2][0]
     105        if return_type != 'void':
     106            print '\tif (pack_spu.swap)'
     107            print '\t{'
     108            print '\t\treturn_val = (%s) SWAP32(return_val);' % return_type
     109            print '\t}'
     110            print '\treturn return_val;'
     111        if func_name in easy_swaps.keys() and easy_swaps[func_name] != '0':
     112            limit = easy_swaps[func_name]
     113            print '\tif (pack_spu.swap)'
     114            print '\t{'
     115            print '\t\tfor (i = 0 ; i < %s ; i++)' % limit
     116            print '\t\t{'
     117            if params[-2][1].find( "double" ) > -1:
     118                print '\t\t\t%s[i] = SWAPDOUBLE(%s[i]);' % (lastParamName, lastParamName)
     119            else:
     120                print '\t\t\t%s[i] = SWAP32(%s[i]);' % (lastParamName, lastParamName)
     121            print '\t\t}'
     122            print '\t}'
     123        for index in range(len(simple_funcs)):
     124            if simple_funcs[index] == func_name:
     125                print '\tif (pack_spu.swap)'
     126                print '\t{'
     127                print '\t\tfor (i = 0 ; i < __numValues( pname ) ; i++)'
     128                print '\t\t{'
     129                if simple_swaps[index] == 'SWAPDOUBLE':
     130                    print '\t\t\t%s[i] = %s(%s[i]);' % (lastParamName, simple_swaps[index], lastParamName)
     131                else:
     132                    print '\t\t\t((GLuint *) %s)[i] = %s(%s[i]);' % (lastParamName, simple_swaps[index], lastParamName)
     133                print '\t\t}'
     134                print '\t}'
     135        if func_name in hard_funcs.keys():
     136            print '\tif (pack_spu.swap)'
     137            print '\t{'
     138            print '\t\tfor (i = 0 ; i < lookupComponents(pname) ; i++)'
     139            print '\t\t{'
     140            if hard_funcs[func_name] == 'SWAPDOUBLE':
     141                print '\t\t\t%s[i] = %s(%s[i]);' % (lastParamName, hard_funcs[func_name], lastParamName)
     142            else:
     143                print '\t\t\t((GLuint *) %s)[i] = %s(%s[i]);' % (lastParamName, hard_funcs[func_name], lastParamName)
     144            print '\t\t}'
     145            print '\t}'
     146        print '}\n'

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_getstring.c

    r15532 r20083  
    1414GetExtensions(void)
    1515{
    16         GLubyte return_value[10*1000];
    17         const GLubyte *extensions, *ext;
    18         GET_THREAD(thread);
    19         int writeback = 1;
     16    GLubyte return_value[10*1000];
     17    const GLubyte *extensions, *ext;
     18    GET_THREAD(thread);
     19    int writeback = 1;
    2020
    21         if (pack_spu.swap)
    22         {
    23                 crPackGetStringSWAP( GL_EXTENSIONS, return_value, &writeback );
    24         }
    25         else
    26         {
    27                 crPackGetString( GL_EXTENSIONS, return_value, &writeback );
    28         }
    29         packspuFlush( (void *) thread );
     21    if (pack_spu.swap)
     22    {
     23        crPackGetStringSWAP( GL_EXTENSIONS, return_value, &writeback );
     24    }
     25    else
     26    {
     27        crPackGetString( GL_EXTENSIONS, return_value, &writeback );
     28    }
     29    packspuFlush( (void *) thread );
    3030
    31         while (writeback)
    32                 crNetRecv();
     31    while (writeback)
     32        crNetRecv();
    3333
    34         CRASSERT(crStrlen((char *)return_value) < 10*1000);
     34    CRASSERT(crStrlen((char *)return_value) < 10*1000);
    3535
    36         /* OK, we got the result from the server.  Now we have to
    37         * intersect is with the set of extensions that Chromium understands
    38         * and tack on the Chromium-specific extensions.
    39         */
    40         extensions = return_value;
    41         ext = crStateMergeExtensions(1, &extensions);
     36    /* OK, we got the result from the server.  Now we have to
     37    * intersect is with the set of extensions that Chromium understands
     38    * and tack on the Chromium-specific extensions.
     39    */
     40    extensions = return_value;
     41    ext = crStateMergeExtensions(1, &extensions);
    4242
    43         return ext;  /* XXX we should return a static string here! */
     43    return ext;  /* XXX we should return a static string here! */
    4444}
    4545
    … …  
    4848GetVersionString(void)
    4949{
    50         GLubyte return_value[100];
    51         GET_THREAD(thread);
    52         int writeback = 1;
    53         GLfloat version;
     50    GLubyte return_value[100];
     51    GET_THREAD(thread);
     52    int writeback = 1;
     53    GLfloat version;
    5454
    55         if (pack_spu.swap)
    56                 crPackGetStringSWAP( GL_VERSION, return_value, &writeback );
    57         else
    58                 crPackGetString( GL_VERSION, return_value, &writeback );
    59         packspuFlush( (void *) thread );
     55    if (pack_spu.swap)
     56        crPackGetStringSWAP( GL_VERSION, return_value, &writeback );
     57    else
     58        crPackGetString( GL_VERSION, return_value, &writeback );
     59    packspuFlush( (void *) thread );
    6060
    61         while (writeback)
    62                 crNetRecv();
     61    while (writeback)
     62        crNetRecv();
    6363
    64         CRASSERT(crStrlen((char *)return_value) < 100);
     64    CRASSERT(crStrlen((char *)return_value) < 100);
    6565
    66         version = crStrToFloat((char *) return_value);
    67         version = crStateComputeVersion(version);
     66    version = crStrToFloat((char *) return_value);
     67    version = crStateComputeVersion(version);
    6868
    69         return version;
     69    return version;
    7070}
    7171
    … …  
    7373const GLubyte * PACKSPU_APIENTRY packspu_GetString( GLenum name )
    7474{
    75         GET_CONTEXT(ctx);
    76         if (name == GL_EXTENSIONS)
    77         {
    78                 return GetExtensions();
    79         }
    80         else if (name == GL_VERSION)
    81         {
    82                 float version = GetVersionString();
    83                 sprintf(ctx->glVersion, "%g Chromium %s", version, CR_VERSION_STRING);
    84                 return (const GLubyte *) ctx->glVersion;
    85         }
    86         else
    87         {
    88                 return crStateGetString(name);
    89         }
     75    GET_CONTEXT(ctx);
     76    if (name == GL_EXTENSIONS)
     77    {
     78        return GetExtensions();
     79    }
     80    else if (name == GL_VERSION)
     81    {
     82        float version = GetVersionString();
     83        sprintf(ctx->glVersion, "%g Chromium %s", version, CR_VERSION_STRING);
     84        return (const GLubyte *) ctx->glVersion;
     85    }
     86    else
     87    {
     88        return crStateGetString(name);
     89    }
    9090}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_init.c

    r15532 r20083  
    1515
    1616SPUFunctions pack_functions = {
    17         NULL, /* CHILD COPY */
    18         NULL, /* DATA */
    19         _cr_pack_table /* THE ACTUAL FUNCTIONS */
     17    NULL, /* CHILD COPY */
     18    NULL, /* DATA */
     19    _cr_pack_table /* THE ACTUAL FUNCTIONS */
    2020};
    2121
    … …  
    2929static SPUFunctions *
    3030packSPUInit( int id, SPU *child, SPU *self,
    31                                                 unsigned int context_id,
    32                                                 unsigned int num_contexts )
     31                        unsigned int context_id,
     32                        unsigned int num_contexts )
    3333{
    34         ThreadInfo *thread;
     34    ThreadInfo *thread;
    3535
    36         (void) context_id;
    37         (void) num_contexts;
    38         (void) child;
    39         (void) self;
     36    (void) context_id;
     37    (void) num_contexts;
     38    (void) child;
     39    (void) self;
    4040
    4141#ifdef CHROMIUM_THREADSAFE
    42         crInitMutex(&_PackMutex);
     42    crInitMutex(&_PackMutex);
    4343#endif
    4444
    45         pack_spu.id = id;
     45    pack_spu.id = id;
    4646
    47         packspuSetVBoxConfiguration( child );
     47    packspuSetVBoxConfiguration( child );
    4848
    49         /* This connects to the server, sets up the packer, etc. */
    50         thread = packspuNewThread( crThreadID() );
     49    /* This connects to the server, sets up the packer, etc. */
     50    thread = packspuNewThread( crThreadID() );
    5151
    52         if (!thread) {
    53                 return NULL;
    54         }
    55         CRASSERT( thread == &(pack_spu.thread[0]) );
     52    if (!thread) {
     53        return NULL;
     54    }
     55    CRASSERT( thread == &(pack_spu.thread[0]) );
    5656
    57         packspuCreateFunctions();
    58         crStateInit();
     57    packspuCreateFunctions();
     58    crStateInit();
    5959
    60         return &pack_functions;
     60    return &pack_functions;
    6161}
    6262
    … …  
    6464packSPUSelfDispatch(SPUDispatchTable *self)
    6565{
    66         (void)self;
     66    (void)self;
    6767}
    6868
    … …  
    7070packSPUCleanup(void)
    7171{
    72         return 1;
     72    return 1;
    7373}
    7474
    … …  
    7676
    7777int SPULoad( char **name, char **super, SPUInitFuncPtr *init,
    78              SPUSelfDispatchFuncPtr *self, SPUCleanupFuncPtr *cleanup,
    79              SPUOptionsPtr *options, int *flags )
     78         SPUSelfDispatchFuncPtr *self, SPUCleanupFuncPtr *cleanup,
     79         SPUOptionsPtr *options, int *flags )
    8080{
    81         *name = "pack";
    82         *super = NULL;
    83         *init = packSPUInit;
    84         *self = packSPUSelfDispatch;
    85         *cleanup = packSPUCleanup;
    86         *options = packSPUOptions;
    87         *flags = (SPU_HAS_PACKER|SPU_IS_TERMINAL|SPU_MAX_SERVERS_ONE);
     81    *name = "pack";
     82    *super = NULL;
     83    *init = packSPUInit;
     84    *self = packSPUSelfDispatch;
     85    *cleanup = packSPUCleanup;
     86    *options = packSPUOptions;
     87    *flags = (SPU_HAS_PACKER|SPU_IS_TERMINAL|SPU_MAX_SERVERS_ONE);
    8888
    89         return 1;
     89    return 1;
    9090}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c

    r15532 r20083  
    1212{
    1313
    14         CRMessage msg;
    15         int len;
    16        
    17         GET_THREAD(thread);
     14    CRMessage msg;
     15    int len;
     16   
     17    GET_THREAD(thread);
    1818
    19        
    20         switch(target)
    21         {
    22                 case GL_GATHER_PACK_CR:
    23                         /* flush the current pack buffer */
    24                         packspuFlush( (void *) thread );
     19   
     20    switch(target)
     21    {
     22        case GL_GATHER_PACK_CR:
     23            /* flush the current pack buffer */
     24            packspuFlush( (void *) thread );
    2525
    26                         /* the connection is thread->server.conn */
    27                         msg.header.type = CR_MESSAGE_GATHER;
    28                         msg.gather.offset = 69;
    29                         len = sizeof(CRMessageGather);
    30                         crNetSend(thread->netServer.conn, NULL, &msg, len);
    31                         break;
    32                        
    33                 default:
    34                         if (pack_spu.swap)
    35                                 crPackChromiumParametervCRSWAP(target, type, count, values);
    36                         else
    37                                 crPackChromiumParametervCR(target, type, count, values);
    38         }
     26            /* the connection is thread->server.conn */
     27            msg.header.type = CR_MESSAGE_GATHER;
     28            msg.gather.offset = 69;
     29            len = sizeof(CRMessageGather);
     30            crNetSend(thread->netServer.conn, NULL, &msg, len);
     31            break;
     32           
     33        default:
     34            if (pack_spu.swap)
     35                crPackChromiumParametervCRSWAP(target, type, count, values);
     36            else
     37                crPackChromiumParametervCR(target, type, count, values);
     38    }
    3939
    4040
    … …  
    4343void PACKSPU_APIENTRY packspu_Finish( void )
    4444{
    45         GET_THREAD(thread);
    46         GLint writeback = pack_spu.thread[0].netServer.conn->actual_network;
    47         if (pack_spu.swap)
    48         {
    49                 crPackFinishSWAP(  );
    50                 if (writeback)
    51                         crPackWritebackSWAP( &writeback );
    52         }
    53         else
    54         {
    55                 crPackFinish(  );
    56                 if (writeback)
    57                         crPackWriteback( &writeback );
    58         }
    59         packspuFlush( (void *) thread );
    60         while (writeback)
    61                 crNetRecv();
     45    GET_THREAD(thread);
     46    GLint writeback = pack_spu.thread[0].netServer.conn->actual_network;
     47    if (pack_spu.swap)
     48    {
     49        crPackFinishSWAP(  );
     50        if (writeback)
     51            crPackWritebackSWAP( &writeback );
     52    }
     53    else
     54    {
     55        crPackFinish(  );
     56        if (writeback)
     57            crPackWriteback( &writeback );
     58    }
     59    packspuFlush( (void *) thread );
     60    while (writeback)
     61        crNetRecv();
    6262}
    6363
    … …  
    6565GLint PACKSPU_APIENTRY packspu_WindowCreate( const char *dpyName, GLint visBits )
    6666{
    67         static int num_calls = 0;
    68         int writeback = pack_spu.thread[0].netServer.conn->actual_network;
    69         GLint return_val = (GLint) 0;
     67    static int num_calls = 0;
     68    int writeback = pack_spu.thread[0].netServer.conn->actual_network;
     69    GLint return_val = (GLint) 0;
    7070
    71         /* WindowCreate is special - just like CreateContext.
    72         * GET_THREAD(thread) doesn't work as the thread won't have called
    73         * MakeCurrent yet, so we've got to use the first thread's packer
    74         * buffer.
    75         */
     71    /* WindowCreate is special - just like CreateContext.
     72    * GET_THREAD(thread) doesn't work as the thread won't have called
     73    * MakeCurrent yet, so we've got to use the first thread's packer
     74    * buffer.
     75    */
    7676
    77         crPackSetContext( pack_spu.thread[0].packer );
     77    crPackSetContext( pack_spu.thread[0].packer );
    7878
    79         if (pack_spu.swap)
    80         {
    81                 crPackWindowCreateSWAP( dpyName, visBits, &return_val, &writeback );
    82         }
    83         else
    84         {
    85                 crPackWindowCreate( dpyName, visBits, &return_val, &writeback );
    86         }
    87         packspuFlush( &pack_spu.thread[0] );
    88         if (!(pack_spu.thread[0].netServer.conn->actual_network))
    89         {
    90                 return num_calls++;
    91         }
    92         else
    93         {
    94                 while (writeback)
    95                         crNetRecv();
    96                 if (pack_spu.swap)
    97                 {
    98                         return_val = (GLint) SWAP32(return_val);
    99                 }
    100                 return return_val;
    101         }
     79    if (pack_spu.swap)
     80    {
     81        crPackWindowCreateSWAP( dpyName, visBits, &return_val, &writeback );
     82    }
     83    else
     84    {
     85        crPackWindowCreate( dpyName, visBits, &return_val, &writeback );
     86    }
     87    packspuFlush( &pack_spu.thread[0] );
     88    if (!(pack_spu.thread[0].netServer.conn->actual_network))
     89    {
     90        return num_calls++;
     91    }
     92    else
     93    {
     94        while (writeback)
     95            crNetRecv();
     96        if (pack_spu.swap)
     97        {
     98            return_val = (GLint) SWAP32(return_val);
     99        }
     100        return return_val;
     101    }
    102102}
    103103
    … …  
    106106GLboolean PACKSPU_APIENTRY
    107107packspu_AreTexturesResident( GLsizei n, const GLuint * textures,
    108                                                                                                                 GLboolean * residences )
     108                                                        GLboolean * residences )
    109109{
    110         GET_THREAD(thread);
    111         int writeback = 1;
    112         GLboolean return_val = GL_TRUE;
    113         GLsizei i;
     110    GET_THREAD(thread);
     111    int writeback = 1;
     112    GLboolean return_val = GL_TRUE;
     113    GLsizei i;
    114114
    115         if (!(pack_spu.thread[0].netServer.conn->actual_network))
    116         {
    117                 crError( "packspu_AreTexturesResident doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
    118         }
     115    if (!(pack_spu.thread[0].netServer.conn->actual_network))
     116    {
     117        crError( "packspu_AreTexturesResident doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
     118    }
    119119
    120         if (pack_spu.swap)
    121         {
    122                 crPackAreTexturesResidentSWAP( n, textures, residences, &return_val, &writeback );
    123         }
    124         else
    125         {
    126                 crPackAreTexturesResident( n, textures, residences, &return_val, &writeback );
    127         }
    128         packspuFlush( (void *) thread );
     120    if (pack_spu.swap)
     121    {
     122        crPackAreTexturesResidentSWAP( n, textures, residences, &return_val, &writeback );
     123    }
     124    else
     125    {
     126        crPackAreTexturesResident( n, textures, residences, &return_val, &writeback );
     127    }
     128    packspuFlush( (void *) thread );
    129129
    130         while (writeback)
    131                 crNetRecv();
     130    while (writeback)
     131        crNetRecv();
    132132
    133         /* Since the Chromium packer/unpacker can't return both 'residences'
    134         * and the function's return value, compute the return value here.
    135         */
    136         for (i = 0; i < n; i++) {
    137                 if (!residences[i]) {
    138                         return_val = GL_FALSE;
    139                         break;
    140                 }
    141         }
     133    /* Since the Chromium packer/unpacker can't return both 'residences'
     134    * and the function's return value, compute the return value here.
     135    */
     136    for (i = 0; i < n; i++) {
     137        if (!residences[i]) {
     138            return_val = GL_FALSE;
     139            break;
     140        }
     141    }
    142142
    143         return return_val;
     143    return return_val;
    144144}
    145145
    … …  
    147147GLboolean PACKSPU_APIENTRY
    148148packspu_AreProgramsResidentNV( GLsizei n, const GLuint * ids,
    149                                                                                                                         GLboolean * residences )
     149                                                            GLboolean * residences )
    150150{
    151         GET_THREAD(thread);
    152         int writeback = 1;
    153         GLboolean return_val = GL_TRUE;
    154         GLsizei i;
     151    GET_THREAD(thread);
     152    int writeback = 1;
     153    GLboolean return_val = GL_TRUE;
     154    GLsizei i;
    155155
    156         if (!(pack_spu.thread[0].netServer.conn->actual_network))
    157         {
    158                 crError( "packspu_AreProgramsResidentNV doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
    159         }
    160         if (pack_spu.swap)
    161         {
    162                 crPackAreProgramsResidentNVSWAP( n, ids, residences, &return_val, &writeback );
    163         }
    164         else
    165         {
    166                 crPackAreProgramsResidentNV( n, ids, residences, &return_val, &writeback );
    167         }
    168         packspuFlush( (void *) thread );
     156    if (!(pack_spu.thread[0].netServer.conn->actual_network))
     157    {
     158        crError( "packspu_AreProgramsResidentNV doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
     159    }
     160    if (pack_spu.swap)
     161    {
     162        crPackAreProgramsResidentNVSWAP( n, ids, residences, &return_val, &writeback );
     163    }
     164    else
     165    {
     166        crPackAreProgramsResidentNV( n, ids, residences, &return_val, &writeback );
     167    }
     168    packspuFlush( (void *) thread );
    169169
    170         while (writeback)
    171                 crNetRecv();
     170    while (writeback)
     171        crNetRecv();
    172172
    173         /* Since the Chromium packer/unpacker can't return both 'residences'
    174         * and the function's return value, compute the return value here.
    175         */
    176         for (i = 0; i < n; i++) {
    177                 if (!residences[i]) {
    178                         return_val = GL_FALSE;
    179                         break;
    180                 }
    181         }
     173    /* Since the Chromium packer/unpacker can't return both 'residences'
     174    * and the function's return value, compute the return value here.
     175    */
     176    for (i = 0; i < n; i++) {
     177        if (!residences[i]) {
     178            return_val = GL_FALSE;
     179            break;
     180        }
     181    }
    182182
    183         return return_val;
     183    return return_val;
    184184}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_pixel.c

    r15532 r20083  
    33
    44   See the file LICENSE.txt for information on redistributing this software. */
    5        
     5   
    66#include "cr_packfunctions.h"
    77#include "cr_glstate.h"
    … …  
    1313void PACKSPU_APIENTRY packspu_PixelStoref( GLenum pname, GLfloat param )
    1414{
    15         /* NOTE: we do not send pixel store parameters to the server!
    16         * When we pack a glDrawPixels or glTexImage2D image we interpret
    17         * the user's pixel store parameters at that time and pack the
    18         * image in a canonical layout (see util/pixel.c).
    19         */
    20         crStatePixelStoref( pname, param );
     15    /* NOTE: we do not send pixel store parameters to the server!
     16    * When we pack a glDrawPixels or glTexImage2D image we interpret
     17    * the user's pixel store parameters at that time and pack the
     18    * image in a canonical layout (see util/pixel.c).
     19    */
     20    crStatePixelStoref( pname, param );
    2121}
    2222
    2323void PACKSPU_APIENTRY packspu_PixelStorei( GLenum pname, GLint param )
    2424{
    25         crStatePixelStorei( pname, param );
     25    crStatePixelStorei( pname, param );
    2626}
    2727
    2828void PACKSPU_APIENTRY packspu_DrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
    2929{
    30         GET_THREAD(thread);
    31         ContextInfo *ctx = thread->currentContext;
    32         CRClientState *clientState = &(ctx->clientState->client);
    33         if (pack_spu.swap)
    34                 crPackDrawPixelsSWAP( width, height, format, type, pixels, &(clientState->unpack) );
    35         else
    36                 crPackDrawPixels( width, height, format, type, pixels, &(clientState->unpack) );
     30    GET_THREAD(thread);
     31    ContextInfo *ctx = thread->currentContext;
     32    CRClientState *clientState = &(ctx->clientState->client);
     33    if (pack_spu.swap)
     34        crPackDrawPixelsSWAP( width, height, format, type, pixels, &(clientState->unpack) );
     35    else
     36        crPackDrawPixels( width, height, format, type, pixels, &(clientState->unpack) );
    3737}
    3838
    3939void PACKSPU_APIENTRY packspu_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
    4040{
    41         GET_THREAD(thread);
    42         ContextInfo *ctx = thread->currentContext;
    43         CRClientState *clientState = &(ctx->clientState->client);
    44         int writeback;
    45         pack_spu.ReadPixels++;
    46         if (pack_spu.swap)
    47                 crPackReadPixelsSWAP( x, y, width, height, format, type, pixels,
    48                                                         &(clientState->pack), &writeback );
    49         else
    50                 crPackReadPixels( x, y, width, height, format, type, pixels,
    51                                                         &(clientState->pack), &writeback );
    52         packspuFlush( (void *) thread );
    53         while (pack_spu.ReadPixels)
    54                 crNetRecv();
     41    GET_THREAD(thread);
     42    ContextInfo *ctx = thread->currentContext;
     43    CRClientState *clientState = &(ctx->clientState->client);
     44    int writeback;
     45    pack_spu.ReadPixels++;
     46    if (pack_spu.swap)
     47        crPackReadPixelsSWAP( x, y, width, height, format, type, pixels,
     48                            &(clientState->pack), &writeback );
     49    else
     50        crPackReadPixels( x, y, width, height, format, type, pixels,
     51                            &(clientState->pack), &writeback );
     52    packspuFlush( (void *) thread );
     53    while (pack_spu.ReadPixels)
     54        crNetRecv();
    5555}
    5656
    5757void PACKSPU_APIENTRY packspu_CopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
    5858{
    59         GET_THREAD(thread);
    60         if (pack_spu.swap)
    61                 crPackCopyPixelsSWAP( x, y, width, height, type );
    62         else
    63                 crPackCopyPixels( x, y, width, height, type );
    64         /* XXX why flush here? */
    65         packspuFlush( (void *) thread );
     59    GET_THREAD(thread);
     60    if (pack_spu.swap)
     61        crPackCopyPixelsSWAP( x, y, width, height, type );
     62    else
     63        crPackCopyPixels( x, y, width, height, type );
     64    /* XXX why flush here? */
     65    packspuFlush( (void *) thread );
    6666}
    6767
    6868void PACKSPU_APIENTRY packspu_Bitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
    6969{
    70         GET_CONTEXT(ctx);
    71         CRClientState *clientState = &(ctx->clientState->client);
    72         if (pack_spu.swap)
    73                 crPackBitmapSWAP( width, height, xorig, yorig, xmove, ymove, bitmap, &(clientState->unpack) );
    74         else
    75                 crPackBitmap( width, height, xorig, yorig, xmove, ymove, bitmap, &(clientState->unpack) );
     70    GET_CONTEXT(ctx);
     71    CRClientState *clientState = &(ctx->clientState->client);
     72    if (pack_spu.swap)
     73        crPackBitmapSWAP( width, height, xorig, yorig, xmove, ymove, bitmap, &(clientState->unpack) );
     74    else
     75        crPackBitmap( width, height, xorig, yorig, xmove, ymove, bitmap, &(clientState->unpack) );
    7676}
    7777
    7878void PACKSPU_APIENTRY packspu_TexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
    7979{
    80         GET_CONTEXT(ctx);
    81         CRClientState *clientState = &(ctx->clientState->client);
    82         if (pack_spu.swap)
    83                 crPackTexImage1DSWAP( target, level, internalformat, width, border, format, type, pixels, &(clientState->unpack) );
    84         else
    85                 crPackTexImage1D( target, level, internalformat, width, border, format, type, pixels, &(clientState->unpack) );
     80    GET_CONTEXT(ctx);
     81    CRClientState *clientState = &(ctx->clientState->client);
     82    if (pack_spu.swap)
     83        crPackTexImage1DSWAP( target, level, internalformat, width, border, format, type, pixels, &(clientState->unpack) );
     84    else
     85        crPackTexImage1D( target, level, internalformat, width, border, format, type, pixels, &(clientState->unpack) );
    8686}
    8787
    8888void PACKSPU_APIENTRY packspu_TexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
    8989{
    90         GET_CONTEXT(ctx);
    91         CRClientState *clientState = &(ctx->clientState->client);
    92         if (pack_spu.swap)
    93                 crPackTexImage2DSWAP( target, level, internalformat, width, height, border, format, type, pixels, &(clientState->unpack) );
    94         else
    95                 crPackTexImage2D( target, level, internalformat, width, height, border, format, type, pixels, &(clientState->unpack) );
     90    GET_CONTEXT(ctx);
     91    CRClientState *clientState = &(ctx->clientState->client);
     92    if (pack_spu.swap)
     93        crPackTexImage2DSWAP( target, level, internalformat, width, height, border, format, type, pixels, &(clientState->unpack) );
     94    else
     95        crPackTexImage2D( target, level, internalformat, width, height, border, format, type, pixels, &(clientState->unpack) );
    9696}
    9797
    … …  
    9999void PACKSPU_APIENTRY packspu_TexImage3DEXT( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
    100100{
    101         GET_CONTEXT(ctx);
    102         CRClientState *clientState = &(ctx->clientState->client);
    103         if (pack_spu.swap)
    104                 crPackTexImage3DEXTSWAP( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
    105         else
    106                 crPackTexImage3DEXT( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
     101    GET_CONTEXT(ctx);
     102    CRClientState *clientState = &(ctx->clientState->client);
     103    if (pack_spu.swap)
     104        crPackTexImage3DEXTSWAP( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
     105    else
     106        crPackTexImage3DEXT( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
    107107}
    108108#endif
    … …  
    111111void PACKSPU_APIENTRY packspu_TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
    112112{
    113         GET_CONTEXT(ctx);
    114         CRClientState *clientState = &(ctx->clientState->client);
    115         if (pack_spu.swap)
    116                 crPackTexImage3DSWAP( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
    117         else
    118                 crPackTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
     113    GET_CONTEXT(ctx);
     114    CRClientState *clientState = &(ctx->clientState->client);
     115    if (pack_spu.swap)
     116        crPackTexImage3DSWAP( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
     117    else
     118        crPackTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
    119119}
    120120#endif /* CR_OPENGL_VERSION_1_2 */
    … …  
    122122void PACKSPU_APIENTRY packspu_TexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
    123123{
    124         GET_CONTEXT(ctx);
    125         CRClientState *clientState = &(ctx->clientState->client);
    126         if (pack_spu.swap)
    127                 crPackTexSubImage1DSWAP( target, level, xoffset, width, format, type, pixels, &(clientState->unpack) );
    128         else
    129                 crPackTexSubImage1D( target, level, xoffset, width, format, type, pixels, &(clientState->unpack) );
     124    GET_CONTEXT(ctx);
     125    CRClientState *clientState = &(ctx->clientState->client);
     126    if (pack_spu.swap)
     127        crPackTexSubImage1DSWAP( target, level, xoffset, width, format, type, pixels, &(clientState->unpack) );
     128    else
     129        crPackTexSubImage1D( target, level, xoffset, width, format, type, pixels, &(clientState->unpack) );
    130130}
    131131
    132132void PACKSPU_APIENTRY packspu_TexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
    133133{
    134         GET_CONTEXT(ctx);
    135         CRClientState *clientState = &(ctx->clientState->client);
    136         if (pack_spu.swap)
    137                 crPackTexSubImage2DSWAP( target, level, xoffset, yoffset, width, height, format, type, pixels, &(clientState->unpack) );
    138         else
    139                 crPackTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels, &(clientState->unpack) );
     134    GET_CONTEXT(ctx);
     135    CRClientState *clientState = &(ctx->clientState->client);
     136    if (pack_spu.swap)
     137        crPackTexSubImage2DSWAP( target, level, xoffset, yoffset, width, height, format, type, pixels, &(clientState->unpack) );
     138    else
     139        crPackTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels, &(clientState->unpack) );
    140140}
    141141
    … …  
    143143void PACKSPU_APIENTRY packspu_TexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels )
    144144{
    145         GET_CONTEXT(ctx);
    146         CRClientState *clientState = &(ctx->clientState->client);
    147         if (pack_spu.swap)
    148                 crPackTexSubImage3DSWAP( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels, &(clientState->unpack) );
    149         else
    150                 crPackTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels, &(clientState->unpack) );
     145    GET_CONTEXT(ctx);
     146    CRClientState *clientState = &(ctx->clientState->client);
     147    if (pack_spu.swap)
     148        crPackTexSubImage3DSWAP( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels, &(clientState->unpack) );
     149    else
     150        crPackTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels, &(clientState->unpack) );
    151151}
    152152#endif /* CR_OPENGL_VERSION_1_2 */
    … …  
    154154void PACKSPU_APIENTRY packspu_ZPixCR( GLsizei width, GLsizei height, GLenum format, GLenum type, GLenum ztype, GLint zparm, GLint length, const GLvoid *pixels )
    155155{
    156         GET_CONTEXT(ctx);
    157         CRClientState *clientState = &(ctx->clientState->client);
    158         if (pack_spu.swap)
    159                 crPackZPixCRSWAP( width, height, format, type, ztype, zparm, length, pixels, &(clientState->unpack) );
    160         else
    161                 crPackZPixCR( width, height, format, type, ztype, zparm, length, pixels, &(clientState->unpack) );
     156    GET_CONTEXT(ctx);
     157    CRClientState *clientState = &(ctx->clientState->client);
     158    if (pack_spu.swap)
     159        crPackZPixCRSWAP( width, height, format, type, ztype, zparm, length, pixels, &(clientState->unpack) );
     160    else
     161        crPackZPixCR( width, height, format, type, ztype, zparm, length, pixels, &(clientState->unpack) );
    162162}
    163163
    164164void PACKSPU_APIENTRY packspu_GetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
    165165{
    166         GET_THREAD(thread);
    167         ContextInfo *ctx = thread->currentContext;
    168         CRClientState *clientState = &(ctx->clientState->client);
    169         int writeback = 1;
    170         /* XXX note: we're not observing the pixel pack parameters here.
    171         * To do so, we'd have to allocate a temporary image buffer (how large???)
    172         * and copy the image to the user's buffer using the pixel pack params.
    173         */
    174         if (pack_spu.swap)
    175                 crPackGetTexImageSWAP( target, level, format, type, pixels, &(clientState->pack), &writeback );
    176         else
    177                 crPackGetTexImage( target, level, format, type, pixels, &(clientState->pack), &writeback );
    178         packspuFlush( (void *) thread );
    179         while (writeback)
    180                 crNetRecv();
     166    GET_THREAD(thread);
     167    ContextInfo *ctx = thread->currentContext;
     168    CRClientState *clientState = &(ctx->clientState->client);
     169    int writeback = 1;
     170    /* XXX note: we're not observing the pixel pack parameters here.
     171    * To do so, we'd have to allocate a temporary image buffer (how large???)
     172    * and copy the image to the user's buffer using the pixel pack params.
     173    */
     174    if (pack_spu.swap)
     175        crPackGetTexImageSWAP( target, level, format, type, pixels, &(clientState->pack), &writeback );
     176    else
     177        crPackGetTexImage( target, level, format, type, pixels, &(clientState->pack), &writeback );
     178    packspuFlush( (void *) thread );
     179    while (writeback)
     180        crNetRecv();
    181181}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_proto.py

    r15532 r20083  
    3030# make list of special functions
    3131for func_name in keys:
    32         if ("get" in apiutil.Properties(func_name) or
    33             apiutil.FindSpecial( "packspu", func_name ) or
    34             apiutil.FindSpecial( "packspu_flush", func_name ) or
    35                 apiutil.FindSpecial( "packspu_vertex", func_name )):
    36           pack_specials.append( func_name )
     32    if ("get" in apiutil.Properties(func_name) or
     33        apiutil.FindSpecial( "packspu", func_name ) or
     34        apiutil.FindSpecial( "packspu_flush", func_name ) or
     35        apiutil.FindSpecial( "packspu_vertex", func_name )):
     36      pack_specials.append( func_name )
    3737
    3838for func_name in keys:
    39         if apiutil.FindSpecial( "packspu_unimplemented", func_name ):
    40                 continue
    41         if func_name in pack_specials:
    42                 return_type = apiutil.ReturnType(func_name)
    43                 params = apiutil.Parameters(func_name)
    44                 print 'extern %s PACKSPU_APIENTRY packspu_%s( %s );' % ( return_type, func_name, apiutil.MakeDeclarationString(params) )
     39    if apiutil.FindSpecial( "packspu_unimplemented", func_name ):
     40        continue
     41    if func_name in pack_specials:
     42        return_type = apiutil.ReturnType(func_name)
     43        params = apiutil.Parameters(func_name)
     44        print 'extern %s PACKSPU_APIENTRY packspu_%s( %s );' % ( return_type, func_name, apiutil.MakeDeclarationString(params) )
    4545
    4646

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_swapbuf.c

    r15532 r20083  
    1515void PACKSPU_APIENTRY packspu_SwapBuffers( GLint window, GLint flags )
    1616{
    17         GET_THREAD(thread);
    18         if (pack_spu.swap)
    19         {
    20                 crPackSwapBuffersSWAP( window, flags );
    21         }
    22         else
    23         {
    24                 crPackSwapBuffers( window, flags );
    25         }
    26         packspuFlush( (void *) thread );
     17    GET_THREAD(thread);
     18    if (pack_spu.swap)
     19    {
     20        crPackSwapBuffersSWAP( window, flags );
     21    }
     22    else
     23    {
     24        crPackSwapBuffers( window, flags );
     25    }
     26    packspuFlush( (void *) thread );
    2727}
    2828
    … …  
    3232void PACKSPU_APIENTRY packspu_SwapBuffers( GLint window, GLint flags )
    3333{
    34         GET_THREAD(thread);
     34    GET_THREAD(thread);
    3535
    36         if (pack_spu.swap)
    37         {
    38                 crPackSwapBuffersSWAP( window, flags );
    39         }
    40         else
    41         {
    42                 crPackSwapBuffers( window, flags );
    43         }
    44         packspuFlush( (void *) thread );
     36    if (pack_spu.swap)
     37    {
     38        crPackSwapBuffersSWAP( window, flags );
     39    }
     40    else
     41    {
     42        crPackSwapBuffers( window, flags );
     43    }
     44    packspuFlush( (void *) thread );
    4545
    46         if (!(thread->netServer.conn->actual_network))
    47         {
    48                 /* no synchronization needed */
    49                 return;
    50         }
     46    if (!(thread->netServer.conn->actual_network))
     47    {
     48        /* no synchronization needed */
     49        return;
     50    }
    5151
    52         if (pack_spu.swapbuffer_sync) {
    53                 /* This won't block unless there has been more than 1 frame
    54                 * since we received a writeback acknowledgement.  In the
    55                 * normal case there's no performance penalty for doing this
    56                 * (beyond the cost of packing the writeback request into the
    57                 * stream and receiving the reply), but it eliminates the
    58                 * problem of runaway rendering that can occur, eg when
    59                 * rendering frames consisting of a single large display list
    60                 * in a tight loop.
    61                 *
    62                 * Note that this is *not* the same as doing a sync after each
    63                 * swapbuffers, which would force a round-trip 'bubble' into
    64                 * the network stream under normal conditions.
    65                 *
    66                 * This is complicated because writeback in the pack spu is
    67                 * overriden to always set the value to zero when the
    68                 * reply is received, rather than decrementing it:
    69                 */
    70                 switch( thread->writeback ) {
    71                 case 0:
    72                         /* Request writeback.
    73                         */
    74                         thread->writeback = 1;
    75                         if (pack_spu.swap)
    76                         {
    77                                 crPackWritebackSWAP( (GLint *) &thread->writeback );
    78                         }
    79                         else
    80                         {
    81                                 crPackWriteback( (GLint *) &thread->writeback );
    82                         }
    83                         break;
    84                 case 1:
    85                         /* Make sure writeback from previous frame has been received.
    86                         */
    87                         while (thread->writeback)
    88                         {
    89                                 crNetRecv();
    90                         }
    91                         break;
    92                 }
    93         }
     52    if (pack_spu.swapbuffer_sync) {
     53        /* This won't block unless there has been more than 1 frame
     54        * since we received a writeback acknowledgement.  In the
     55        * normal case there's no performance penalty for doing this
     56        * (beyond the cost of packing the writeback request into the
     57        * stream and receiving the reply), but it eliminates the
     58        * problem of runaway rendering that can occur, eg when
     59        * rendering frames consisting of a single large display list
     60        * in a tight loop.
     61        *
     62        * Note that this is *not* the same as doing a sync after each
     63        * swapbuffers, which would force a round-trip 'bubble' into
     64        * the network stream under normal conditions.
     65        *
     66        * This is complicated because writeback in the pack spu is
     67        * overriden to always set the value to zero when the
     68        * reply is received, rather than decrementing it:
     69        */
     70        switch( thread->writeback ) {
     71        case 0:
     72            /* Request writeback.
     73            */
     74            thread->writeback = 1;
     75            if (pack_spu.swap)
     76            {
     77                crPackWritebackSWAP( (GLint *) &thread->writeback );
     78            }
     79            else
     80            {
     81                crPackWriteback( (GLint *) &thread->writeback );
     82            }
     83            break;
     84        case 1:
     85            /* Make sure writeback from previous frame has been received.
     86            */
     87            while (thread->writeback)
     88            {
     89                crNetRecv();
     90            }
     91            break;
     92        }
     93    }
    9494
    95         /* want to emit a parameteri here */
    96         if (pack_spu.emit_GATHER_POST_SWAPBUFFERS)
    97         {
    98                 if (pack_spu.swap)
    99                         crPackChromiumParameteriCRSWAP(GL_GATHER_POST_SWAPBUFFERS_CR, 1);
    100                 else
    101                         crPackChromiumParameteriCR(GL_GATHER_POST_SWAPBUFFERS_CR, 1);
    102         }
     95    /* want to emit a parameteri here */
     96    if (pack_spu.emit_GATHER_POST_SWAPBUFFERS)
     97    {
     98        if (pack_spu.swap)
     99            crPackChromiumParameteriCRSWAP(GL_GATHER_POST_SWAPBUFFERS_CR, 1);
     100        else
     101            crPackChromiumParameteriCR(GL_GATHER_POST_SWAPBUFFERS_CR, 1);
     102    }
    103103}
    104104
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