VirtualBox

Changeset 78375 in vbox for trunk/src/VBox/Additions/common


Ignore:
Timestamp:
May 3, 2019 9:51:02 PM (6 years ago)
Author:
vboxsync
Message:

Additions/common/crOpengl,GuestHost/OpenGL,HostServices/SharedOpenGL: Eliminate all global variables from the state tracker library (state_tracker) in preparation of the SPU DLL merging, bugref:9435

Location:
trunk/src/VBox/Additions/common/crOpenGL
Files:
18 edited

Legend:

Unmodified
Added
Removed

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

    r63942 r78375  
    9494        }
    9595
    96         return crStateRenderMode( mode );
     96        return crStateRenderMode(&feedback_spu.StateTracker, mode );
    9797}
    9898
    … …  
    100100{
    101101        if (feedback_spu.render_mode == GL_FEEDBACK)
    102                 crStateFeedbackBegin( mode );
    103         else if (feedback_spu.render_mode == GL_SELECT)
    104                 crStateSelectBegin( mode );
     102                crStateFeedbackBegin(&feedback_spu.StateTracker, mode );
     103        else if (feedback_spu.render_mode == GL_SELECT)
     104                crStateSelectBegin(&feedback_spu.StateTracker, mode );
    105105        else
    106106        {
    107                 crStateBegin( mode );
     107                crStateBegin(&feedback_spu.StateTracker, mode );
    108108                feedback_spu.super.Begin( mode );
    109109        }
    … …  
    113113{
    114114        if (feedback_spu.render_mode == GL_FEEDBACK)
    115                 crStateFeedbackEnd( );
    116         else if (feedback_spu.render_mode == GL_SELECT)
    117                 crStateSelectEnd( );
     115                crStateFeedbackEnd(&feedback_spu.StateTracker);
     116        else if (feedback_spu.render_mode == GL_SELECT)
     117                crStateSelectEnd(&feedback_spu.StateTracker);
    118118        else
    119119        {
    120                 crStateEnd( );
     120                crStateEnd(&feedback_spu.StateTracker);
    121121                feedback_spu.super.End( );
    122122        }
    … …  
    125125static void FEEDBACKSPU_APIENTRY feedbackspu_Bitmap ( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
    126126{
    127         crStateBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
    128 
    129         if (feedback_spu.render_mode == GL_FEEDBACK)
    130                 crStateFeedbackBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
    131         else if (feedback_spu.render_mode == GL_SELECT)
    132                 crStateSelectBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
     127        crStateBitmap(&feedback_spu.StateTracker, width, height, xorig, yorig, xmove, ymove, bitmap );
     128
     129        if (feedback_spu.render_mode == GL_FEEDBACK)
     130                crStateFeedbackBitmap(&feedback_spu.StateTracker, width, height, xorig, yorig, xmove, ymove, bitmap );
     131        else if (feedback_spu.render_mode == GL_SELECT)
     132                crStateSelectBitmap(&feedback_spu.StateTracker, width, height, xorig, yorig, xmove, ymove, bitmap );
    133133        else
    134134                feedback_spu.super.Bitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
    … …  
    138138{
    139139        if (feedback_spu.render_mode == GL_FEEDBACK)
    140                 crStateFeedbackCopyPixels( x, y, width, height, type );
    141         else if (feedback_spu.render_mode == GL_SELECT)
    142                 crStateSelectCopyPixels( x, y, width, height, type );
     140                crStateFeedbackCopyPixels(&feedback_spu.StateTracker, x, y, width, height, type );
     141        else if (feedback_spu.render_mode == GL_SELECT)
     142                crStateSelectCopyPixels(&feedback_spu.StateTracker, x, y, width, height, type );
    143143        else
    144144                feedback_spu.super.CopyPixels( x, y, width, height, type );
    … …  
    148148{
    149149        if (feedback_spu.render_mode == GL_FEEDBACK)
    150                 crStateFeedbackDrawPixels( width, height, format, type, pixels );
    151         else if (feedback_spu.render_mode == GL_SELECT)
    152                 crStateSelectDrawPixels( width, height, format, type, pixels );
     150                crStateFeedbackDrawPixels(&feedback_spu.StateTracker, width, height, format, type, pixels );
     151        else if (feedback_spu.render_mode == GL_SELECT)
     152                crStateSelectDrawPixels(&feedback_spu.StateTracker, width, height, format, type, pixels );
    153153        else
    154154                feedback_spu.super.DrawPixels( width, height, format, type, pixels );
    … …  
    161161            pname == GL_FEEDBACK_BUFFER_TYPE ||
    162162            pname == GL_SELECTION_BUFFER_SIZE)
    163                 crStateFeedbackGetBooleanv( pname, params );
    164         else
    165         if (pname == GL_VIEWPORT && feedback_spu.default_viewport)
    166                 crStateGetBooleanv( pname, params );
     163                crStateFeedbackGetBooleanv(&feedback_spu.StateTracker, pname, params );
     164        else
     165        if (pname == GL_VIEWPORT && feedback_spu.default_viewport)
     166                crStateGetBooleanv(&feedback_spu.StateTracker, pname, params );
    167167        else
    168168                feedback_spu.super.GetBooleanv( pname, params );
    … …  
    175175            pname == GL_FEEDBACK_BUFFER_TYPE ||
    176176            pname == GL_SELECTION_BUFFER_SIZE)
    177                 crStateFeedbackGetDoublev( pname, params );
    178         else
    179         if (pname == GL_VIEWPORT && feedback_spu.default_viewport)
    180                 crStateGetDoublev( pname, params );
     177                crStateFeedbackGetDoublev(&feedback_spu.StateTracker, pname, params );
     178        else
     179        if (pname == GL_VIEWPORT && feedback_spu.default_viewport)
     180                crStateGetDoublev(&feedback_spu.StateTracker, pname, params );
    181181        else
    182182                feedback_spu.super.GetDoublev( pname, params );
    … …  
    189189            pname == GL_FEEDBACK_BUFFER_TYPE ||
    190190            pname == GL_SELECTION_BUFFER_SIZE)
    191                 crStateFeedbackGetFloatv( pname, params );
    192         else
    193         if (pname == GL_VIEWPORT && feedback_spu.default_viewport)
    194                 crStateGetFloatv( pname, params );
     191                crStateFeedbackGetFloatv(&feedback_spu.StateTracker, pname, params );
     192        else
     193        if (pname == GL_VIEWPORT && feedback_spu.default_viewport)
     194                crStateGetFloatv(&feedback_spu.StateTracker, pname, params );
    195195        else
    196196                feedback_spu.super.GetFloatv( pname, params );
    … …  
    203203            pname == GL_FEEDBACK_BUFFER_TYPE ||
    204204            pname == GL_SELECTION_BUFFER_SIZE)
    205                 crStateFeedbackGetIntegerv( pname, params );
    206         else
    207         if (pname == GL_VIEWPORT && feedback_spu.default_viewport)
    208                 crStateGetIntegerv( pname, params );
     205                crStateFeedbackGetIntegerv(&feedback_spu.StateTracker, pname, params );
     206        else
     207        if (pname == GL_VIEWPORT && feedback_spu.default_viewport)
     208                crStateGetIntegerv(&feedback_spu.StateTracker, pname, params );
    209209        else
    210210                feedback_spu.super.GetIntegerv( pname, params );

  • trunk/src/VBox/Additions/common/crOpenGL/feedback/feedback_context.c

    r78341 r78375  
    5050    }
    5151
    52     feedback_spu.context[slot].clientState = crStateCreateContext(NULL, visual, NULL);
     52    feedback_spu.context[slot].clientState = crStateCreateContext(&feedback_spu.StateTracker, NULL, visual, NULL);
    5353    feedback_spu.context[slot].clientCtx = ctx;
    5454
    … …  
    7777        CRASSERT(slot < feedback_spu.numContexts);
    7878
    79         crStateMakeCurrent(feedback_spu.context[slot].clientState);
     79        crStateMakeCurrent(&feedback_spu.StateTracker, feedback_spu.context[slot].clientState);
    8080
    81         crStateGetIntegerv(GL_RENDER_MODE, &oldmode);
     81        crStateGetIntegerv(&feedback_spu.StateTracker, GL_RENDER_MODE, &oldmode);
    8282
    8383        if (oldmode!=feedback_spu.render_mode)
    … …  
    8888    else
    8989    {
    90         crStateMakeCurrent(NULL);
     90        crStateMakeCurrent(&feedback_spu.StateTracker, NULL);
    9191    }
    9292
    … …  
    107107        CRASSERT(slot < feedback_spu.numContexts);
    108108
    109         crStateDestroyContext(feedback_spu.context[slot].clientState);
     109        crStateDestroyContext(&feedback_spu.StateTracker, feedback_spu.context[slot].clientState);
    110110
    111111        feedback_spu.context[slot].clientState = NULL;

  • trunk/src/VBox/Additions/common/crOpenGL/feedback/feedback_state.py

    r63942 r78375  
    2929        print('%s FEEDBACKSPU_APIENTRY feedbackspu_%s(%s)' % (return_type, func_name, apiutil.MakeDeclarationString(params)))
    3030        print('{')
    31         print('\tcrState%s(%s);' % (func_name, apiutil.MakeCallString(params)))
     31        if len(params) == 0:
     32            print('\tcrState%s(&feedback_spu.StateTracker);' % (func_name,))
     33        else:
     34            print('\tcrState%s(&feedback_spu.StateTracker, %s);' % (func_name, apiutil.MakeCallString(params)))
    3235        print('')
    3336        print('\tfeedback_spu.super.%s(%s);' % (func_name, apiutil.MakeCallString(params)))

  • trunk/src/VBox/Additions/common/crOpenGL/feedback/feedbackspu.h

    r78341 r78375  
    4343
    4444    CRmutex mutex;
     45
     46    /** The state tracker state. */
     47    CRStateTracker StateTracker;
    4548} feedbackSPU;
    4649

  • trunk/src/VBox/Additions/common/crOpenGL/feedback/feedbackspu_init.c

    r78341 r78375  
    4545
    4646        /* create/init default state tracker */
    47         crStateInit();
     47        crStateInit(&feedback_spu.StateTracker);
    4848
    49     feedback_spu.defaultctx = crStateCreateContext(NULL, 0, NULL);
    50     crStateSetCurrent(feedback_spu.defaultctx);
     49    feedback_spu.defaultctx = crStateCreateContext(&feedback_spu.StateTracker, NULL, 0, NULL);
     50    crStateSetCurrent(&feedback_spu.StateTracker, feedback_spu.defaultctx);
    5151
    5252    feedback_spu.numContexts = 0;

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu.h

    r78341 r78375  
    109109    int numContexts;
    110110    ContextInfo context[CR_MAX_CONTEXTS];
     111
     112    /** State tracker state. */
     113    CRStateTracker    StateTracker;
    111114} PackSPU;
    112115

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

    r78190 r78375  
    3636        GLboolean serverArrays = GL_FALSE;
    3737        if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    38             serverArrays = crStateUseServerArrays();
     38            serverArrays = crStateUseServerArrays(&pack_spu.StateTracker);
    3939        if (serverArrays) {
    4040            CRClientState *clientState = &(ctx->clientState->client);

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

    r78190 r78375  
    3131
    3232    CRASSERT(GL_TRUE == ctx->clientState->bufferobject.retainBufferData);
    33     buffer = crStateMapBufferARB(target, access);
     33    buffer = crStateMapBufferARB(&pack_spu.StateTracker, target, access);
    3434
    3535#ifdef CR_ARB_pixel_buffer_object
    … …  
    6767#endif
    6868
    69     crStateGetBufferSubDataARB(target, offset, size, data);
     69    crStateGetBufferSubDataARB(&pack_spu.StateTracker, target, offset, size, data);
    7070}
    7171
    … …  
    8686
    8787    CRASSERT(GL_TRUE == ctx->clientState->bufferobject.retainBufferData);
    88     crStateUnmapBufferARB( target );
     88    crStateUnmapBufferARB(&pack_spu.StateTracker, target );
    8989
    9090    return GL_TRUE;
    … …  
    9696{
    9797    /*crDebug("packspu_BufferDataARB size:%d", size);*/
    98     crStateBufferDataARB(target, size, data, usage);
     98    crStateBufferDataARB(&pack_spu.StateTracker,target, size, data, usage);
    9999    crPackBufferDataARB(target, size, data, usage);
    100100}
    … …  
    104104{
    105105    /*crDebug("packspu_BufferSubDataARB size:%d", size);*/
    106     crStateBufferSubDataARB(target, offset, size, data);
     106    crStateBufferSubDataARB(&pack_spu.StateTracker,target, offset, size, data);
    107107    crPackBufferSubDataARB(target, offset, size, data);
    108108}
    … …  
    112112packspu_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
    113113{
    114     crStateGetBufferPointervARB( target, pname, params );
     114    crStateGetBufferPointervARB(&pack_spu.StateTracker, target, pname, params );
    115115}
    116116
    … …  
    119119packspu_GetBufferParameterivARB( GLenum target, GLenum pname, GLint * params )
    120120{
    121     crStateGetBufferParameterivARB( target, pname, params );
     121    crStateGetBufferParameterivARB(&pack_spu.StateTracker, target, pname, params );
    122122}
    123123
    … …  
    128128packspu_BindBufferARB( GLenum target, GLuint buffer )
    129129{
    130     crStateBindBufferARB(target, buffer);
     130    crStateBindBufferARB(&pack_spu.StateTracker, target, buffer);
    131131    crPackBindBufferARB(target, buffer);
    132132}
    … …  
    145145    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    146146
    147     crStateRegBuffers(n, buffer);
     147    crStateRegBuffers(&pack_spu.StateTracker,n, buffer);
    148148}
    149149
    150150void PACKSPU_APIENTRY packspu_DeleteBuffersARB( GLsizei n, const GLuint * buffer )
    151151{
    152     crStateDeleteBuffersARB( n, buffer );
     152    crStateDeleteBuffersARB(&pack_spu.StateTracker, n, buffer );
    153153    crPackDeleteBuffersARB(n, buffer);
    154154}

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

    r78190 r78375  
    1919    }
    2020#endif
    21     crStateFogCoordPointerEXT( type, stride, pointer );
     21    crStateFogCoordPointerEXT(&pack_spu.StateTracker, type, stride, pointer );
    2222}
    2323
    … …  
    3030    }
    3131#endif
    32     crStateColorPointer( size, type, stride, pointer );
     32    crStateColorPointer(&pack_spu.StateTracker, size, type, stride, pointer );
    3333}
    3434
    … …  
    4141    }
    4242#endif
    43     crStateSecondaryColorPointerEXT( size, type, stride, pointer );
     43    crStateSecondaryColorPointerEXT(&pack_spu.StateTracker, size, type, stride, pointer );
    4444}
    4545
    … …  
    5353    }
    5454#endif
    55     crStateVertexPointer( size, type, stride, pointer );
     55    crStateVertexPointer(&pack_spu.StateTracker, size, type, stride, pointer );
    5656}
    5757
    … …  
    6464    }
    6565#endif
    66     crStateTexCoordPointer( size, type, stride, pointer );
     66    crStateTexCoordPointer(&pack_spu.StateTracker, size, type, stride, pointer );
    6767}
    6868
    … …  
    7575    }
    7676#endif
    77     crStateNormalPointer( type, stride, pointer );
     77    crStateNormalPointer(&pack_spu.StateTracker, type, stride, pointer );
    7878}
    7979
    … …  
    8686    }
    8787#endif
    88     crStateEdgeFlagPointer( stride, pointer );
     88    crStateEdgeFlagPointer(&pack_spu.StateTracker, stride, pointer );
    8989}
    9090
    … …  
    9797    }
    9898#endif
    99     crStateVertexAttribPointerARB( index, size, type, normalized, stride, pointer );
     99    crStateVertexAttribPointerARB(&pack_spu.StateTracker, index, size, type, normalized, stride, pointer );
    100100}
    101101
    … …  
    108108    }
    109109#endif
    110     crStateVertexAttribPointerNV( index, size, type, stride, pointer );
     110    crStateVertexAttribPointerNV(&pack_spu.StateTracker, index, size, type, stride, pointer );
    111111}
    112112
    … …  
    119119    }
    120120#endif
    121     crStateIndexPointer(type, stride, pointer);
     121    crStateIndexPointer(&pack_spu.StateTracker, type, stride, pointer);
    122122}
    123123
    124124void PACKSPU_APIENTRY packspu_GetPointerv( GLenum pname, GLvoid **params )
    125125{
    126     crStateGetPointerv( pname, params );
     126    crStateGetPointerv(&pack_spu.StateTracker, pname, params );
    127127}
    128128
    … …  
    138138    /*crDebug("packspu_InterleavedArrays");*/
    139139
    140     crStateInterleavedArrays( format, stride, pointer );
     140    crStateInterleavedArrays(&pack_spu.StateTracker, format, stride, pointer );
    141141}
    142142
    … …  
    219219#ifdef DEBUG
    220220    {
    221         CRContext *pCurState = crStateGetCurrent();
     221        CRContext *pCurState = crStateGetCurrent(&pack_spu.StateTracker);
    222222
    223223        Assert(g == pCurState);
    … …  
    282282    {
    283283        CRContext *g = pRestoreCtx->pCtx->clientState;
    284         CRContext *pCurState = crStateGetCurrent();
     284        CRContext *pCurState = crStateGetCurrent(&pack_spu.StateTracker);
    285285
    286286        Assert(g == pCurState);
    … …  
    319319        if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    320320        {
    321             serverArrays = crStateUseServerArrays();
     321            serverArrays = crStateUseServerArrays(&pack_spu.StateTracker);
    322322            if (ctx->fCheckZerroVertAttr)
    323323                cZvaValues = crStateNeedDummyZeroVertexArray(thread->currentContext->clientState, &thread->packer->current, aAttrib);
    … …  
    395395    {
    396396        GET_CONTEXT(ctx);
    397         elementsBuffer = crStateGetCurrent()->bufferobject.elementsBuffer;
     397        elementsBuffer = crStateGetCurrent(&pack_spu.StateTracker)->bufferobject.elementsBuffer;
    398398        /*crDebug("DrawElements count=%d, indices=%p", count, indices);*/
    399399        if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    400400        {
    401             serverArrays = crStateUseServerArrays();
     401            serverArrays = crStateUseServerArrays(&pack_spu.StateTracker);
    402402            if (ctx->fCheckZerroVertAttr)
    403403                cZvaValues = crStateNeedDummyZeroVertexArray(thread->currentContext->clientState, &thread->packer->current, aAttrib);
    … …  
    452452        if ((max-min)<(GLuint)(2*count))
    453453        {
    454             crStateLockArraysEXT(min, max-min+1);
     454            crStateLockArraysEXT(&pack_spu.StateTracker, min, max-min+1);
    455455
    456456            serverArrays = crStateUseServerArrays();
    … …  
    461461            else
    462462            {
    463                 crStateUnlockArraysEXT();
     463                crStateUnlockArraysEXT(&pack_spu.StateTracker);
    464464            }
    465465        }
    … …  
    539539        if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    540540        {
    541              serverArrays = crStateUseServerArrays();
     541             serverArrays = crStateUseServerArrays(&pack_spu.StateTracker);
    542542             if (ctx->fCheckZerroVertAttr)
    543543                 cZvaValues = crStateNeedDummyZeroVertexArray(thread->currentContext->clientState, &thread->packer->current, aAttrib);
    … …  
    608608        if (ctx->clientState->extensions.ARB_vertex_buffer_object)
    609609        {
    610              serverArrays = crStateUseServerArrays();
     610             serverArrays = crStateUseServerArrays(&pack_spu.StateTracker);
    611611             if (ctx->fCheckZerroVertAttr)
    612612                 cZvaValues = crStateNeedDummyZeroVertexArray(thread->currentContext->clientState, &thread->packer->current, aAttrib);
    … …  
    617617    if (!serverArrays && !ctx->clientState->client.array.locked && (count>3))
    618618    {
    619         crStateLockArraysEXT(first, count);
    620         serverArrays = crStateUseServerArrays();
     619        crStateLockArraysEXT(&pack_spu.StateTracker, first, count);
     620        serverArrays = crStateUseServerArrays(&pack_spu.StateTracker);
    621621        if (serverArrays)
    622622        {
    … …  
    625625        else
    626626        {
    627             crStateUnlockArraysEXT();
     627            crStateUnlockArraysEXT(&pack_spu.StateTracker);
    628628        }
    629629    }
    … …  
    714714void PACKSPU_APIENTRY packspu_EnableClientState( GLenum array )
    715715{
    716     crStateEnableClientState(array);
     716    crStateEnableClientState(&pack_spu.StateTracker, array);
    717717    crPackEnableClientState(array);
    718718}
    … …  
    720720void PACKSPU_APIENTRY packspu_DisableClientState( GLenum array )
    721721{
    722     crStateDisableClientState(array);
     722    crStateDisableClientState(&pack_spu.StateTracker, array);
    723723    crPackDisableClientState(array);
    724724}
    … …  
    726726void PACKSPU_APIENTRY packspu_ClientActiveTextureARB( GLenum texUnit )
    727727{
    728     crStateClientActiveTextureARB(texUnit);
     728    crStateClientActiveTextureARB(&pack_spu.StateTracker, texUnit);
    729729    crPackClientActiveTextureARB(texUnit);
    730730}
    … …  
    732732void PACKSPU_APIENTRY packspu_EnableVertexAttribArrayARB(GLuint index)
    733733{
    734     crStateEnableVertexAttribArrayARB(index);
     734    crStateEnableVertexAttribArrayARB(&pack_spu.StateTracker, index);
    735735    crPackEnableVertexAttribArrayARB(index);
    736736}
    … …  
    739739void PACKSPU_APIENTRY packspu_DisableVertexAttribArrayARB(GLuint index)
    740740{
    741     crStateDisableVertexAttribArrayARB(index);
     741    crStateDisableVertexAttribArrayARB(&pack_spu.StateTracker, index);
    742742    crPackDisableVertexAttribArrayARB(index);
    743743}
    … …  
    747747    if (cap!=GL_LIGHT_MODEL_TWO_SIDE)
    748748    {
    749         crStateEnable(cap);
     749        crStateEnable(&pack_spu.StateTracker, cap);
    750750        crPackEnable(cap);
    751751    }
    … …  
    758758            g_glmts1_warn=1;
    759759        }
    760         crStateLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
     760        crStateLightModeli(&pack_spu.StateTracker, GL_LIGHT_MODEL_TWO_SIDE, 1);
    761761        crPackLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
    762762    }
    … …  
    768768    if (cap!=GL_LIGHT_MODEL_TWO_SIDE)
    769769    {
    770         crStateDisable(cap);
     770        crStateDisable(&pack_spu.StateTracker, cap);
    771771        crPackDisable(cap);
    772772    }
    … …  
    779779            g_glmts0_warn=1;
    780780        }
    781         crStateLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
     781        crStateLightModeli(&pack_spu.StateTracker, GL_LIGHT_MODEL_TWO_SIDE, 0);
    782782        crPackLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
    783783    }
    … …  
    786786GLboolean PACKSPU_APIENTRY packspu_IsEnabled(GLenum cap)
    787787{
    788     GLboolean res = crStateIsEnabled(cap);
     788    GLboolean res = crStateIsEnabled(&pack_spu.StateTracker, cap);
    789789#ifdef DEBUG
    790790    {
    … …  
    804804void PACKSPU_APIENTRY packspu_PushClientAttrib( GLbitfield mask )
    805805{
    806     crStatePushClientAttrib(mask);
     806    crStatePushClientAttrib(&pack_spu.StateTracker, mask);
    807807    crPackPushClientAttrib(mask);
    808808}
    … …  
    810810void PACKSPU_APIENTRY packspu_PopClientAttrib( void )
    811811{
    812     crStatePopClientAttrib();
     812    crStatePopClientAttrib(&pack_spu.StateTracker);
    813813    crPackPopClientAttrib();
    814814}
    … …  
    818818    if (first>=0 && count>0)
    819819    {
    820         crStateLockArraysEXT(first, count);
     820        crStateLockArraysEXT(&pack_spu.StateTracker, first, count);
    821821        /*Note: this is a workaround for quake3 based apps.
    822822          It's modifying vertex data between glLockArraysEXT and glDrawElements calls,
    … …  
    838838    }
    839839
    840     crStateUnlockArraysEXT();
    841 }
     840    crStateUnlockArraysEXT(&pack_spu.StateTracker);
     841}

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

    r78341 r78375  
    394394    /* Fill in the new context info */
    395395    /* XXX fix-up sharedCtx param here */
    396     pack_spu.context[slot].clientState = crStateCreateContext(NULL, visual, NULL);
     396    pack_spu.context[slot].clientState = crStateCreateContext(&pack_spu.StateTracker, NULL, visual, NULL);
    397397    pack_spu.context[slot].clientState->bufferobject.retainBufferData = GL_TRUE;
    398398    pack_spu.context[slot].serverCtx = serverCtx;
    … …  
    442442
    443443        crPackDestroyContext( context->serverCtx );
    444         crStateDestroyContext( context->clientState );
     444        crStateDestroyContext(&pack_spu.StateTracker, context->clientState );
    445445
    446446        context->clientState = NULL;
    … …  
    463463            crPackSetContext(NULL);
    464464        }
    465         crStateMakeCurrent( NULL );
     465        crStateMakeCurrent(&pack_spu.StateTracker, NULL);
    466466    }
    467467    else
    … …  
    540540        }
    541541
    542         crStateMakeCurrent( newCtx->clientState );
     542        crStateMakeCurrent(&pack_spu.StateTracker, newCtx->clientState );
    543543        //crStateSetCurrentPointers(newCtx->clientState, &thread->packer->current);
    544544        serverCtx = pack_spu.context[slot].serverCtx;
    545545    }
    546546    else {
    547         crStateMakeCurrent( NULL );
     547        crStateMakeCurrent(&pack_spu.StateTracker, NULL );
    548548        if (CRPACKSPU_IS_WDDM_CRHGSMI())
    549549        {

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

    r78190 r78375  
    2525packspu_FramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
    2626{
    27     crStateFramebufferTexture1DEXT(target, attachment, textarget, texture, level);
     27    crStateFramebufferTexture1DEXT(&pack_spu.StateTracker, target, attachment, textarget, texture, level);
    2828    crPackFramebufferTexture1DEXT(target, attachment, textarget, texture, level);
    2929}
    … …  
    3232packspu_FramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
    3333{
    34     crStateFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
     34    crStateFramebufferTexture2DEXT(&pack_spu.StateTracker, target, attachment, textarget, texture, level);
    3535    crPackFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
    3636}
    … …  
    3939packspu_FramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
    4040{
    41     crStateFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
     41    crStateFramebufferTexture3DEXT(&pack_spu.StateTracker, target, attachment, textarget, texture, level, zoffset);
    4242    crPackFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
    4343}
    … …  
    4646packspu_BindFramebufferEXT(GLenum target, GLuint framebuffer)
    4747{
    48         crStateBindFramebufferEXT(target, framebuffer);
     48    crStateBindFramebufferEXT(&pack_spu.StateTracker, target, framebuffer);
    4949    crPackBindFramebufferEXT(target, framebuffer);
    5050}
    … …  
    5353packspu_DeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
    5454{
    55         crStateDeleteFramebuffersEXT(n, framebuffers);
     55    crStateDeleteFramebuffersEXT(&pack_spu.StateTracker, n, framebuffers);
    5656    crPackDeleteFramebuffersEXT(n, framebuffers);
    5757}
    … …  
    6060packspu_DeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)
    6161{
    62         crStateDeleteRenderbuffersEXT(n, renderbuffers);
     62    crStateDeleteRenderbuffersEXT(&pack_spu.StateTracker, n, renderbuffers);
    6363    crPackDeleteRenderbuffersEXT(n, renderbuffers);
    6464}
    … …  
    6767packspu_FramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
    6868{
    69         crStateFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);
     69    crStateFramebufferRenderbufferEXT(&pack_spu.StateTracker, target, attachment, renderbuffertarget, renderbuffer);
    7070    crPackFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);
    7171}
    … …  
    7474packspu_BindRenderbufferEXT(GLenum target, GLuint renderbuffer)
    7575{
    76     crStateBindRenderbufferEXT(target, renderbuffer);
     76    crStateBindRenderbufferEXT(&pack_spu.StateTracker, target, renderbuffer);
    7777    crPackBindRenderbufferEXT(target, renderbuffer);
    7878}
    … …  
    8181packspu_CheckFramebufferStatusEXT(GLenum target)
    8282{
    83         GET_THREAD(thread);
    84         int writeback = 1;
    85     GLenum status = crStateCheckFramebufferStatusEXT(target);
     83    GET_THREAD(thread);
     84    int writeback = 1;
     85    GLenum status = crStateCheckFramebufferStatusEXT(&pack_spu.StateTracker, target);
    8686
    8787    if (status!=GL_FRAMEBUFFER_UNDEFINED)
    … …  
    9292    crPackCheckFramebufferStatusEXT(target, &status, &writeback);
    9393
    94         packspuFlush((void *) thread);
     94    packspuFlush((void *) thread);
    9595    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    9696
    97     crStateSetFramebufferStatus(target, status);
     97    crStateSetFramebufferStatus(&pack_spu.StateTracker, target, status);
    9898    return status;
    9999}
    … …  
    112112    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    113113
    114     crStateRegFramebuffers(n, framebuffers);
     114    crStateRegFramebuffers(&pack_spu.StateTracker, n, framebuffers);
    115115}
    116116
    … …  
    128128    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    129129
    130     crStateRegRenderbuffers(n, renderbuffers);
     130    crStateRegRenderbuffers(&pack_spu.StateTracker, n, renderbuffers);
    131131}

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

    r78190 r78375  
    118118                %s localparams;
    119119                localparams = (%s) crAlloc(__numValues(pname) * sizeof(*localparams));
    120                 crState%s(pname, localparams);
     120                crState%s(&pack_spu.StateTracker, pname, localparams);
    121121                crPack%s(%s, &writeback);
    122122                packspuFlush( (void *) thread );
    … …  
    136136#endif
    137137            {
    138                 crState%s(pname, params);
     138                crState%s(&pack_spu.StateTracker, pname, params);
    139139                return;
    140140            }
    … …  
    150150        %s localparams;
    151151        localparams = (%s) crAlloc(__numValues(pname) * sizeof(*localparams));
    152         crState%s(index, pname, localparams);
     152        crState%s(&pack_spu.StateTracker, index, pname, localparams);
    153153        crPack%s(index, %s, &writeback);
    154154        packspuFlush( (void *) thread );
    … …  
    164164        crFree(localparams);
    165165#else
    166         crState%s(pname, params);
     166        crState%s(&pack_spu.StateTracker, pname, params);
    167167#endif
    168168        return;

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

    r78190 r78375  
    149149#endif
    150150            {
    151                 return crStateGetString(name);
     151                return crStateGetString(&pack_spu.StateTracker, name);
    152152            }
    153153        case GL_RENDERER:
    … …  
    161161#endif
    162162            {
    163                 return crStateGetString(name);
     163                return crStateGetString(&pack_spu.StateTracker, name);
    164164            }
    165165
    … …  
    188188#endif
    189189        default:
    190             return crStateGetString(name);
     190            return crStateGetString(&pack_spu.StateTracker, name);
    191191    }
    192192}

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

    r78190 r78375  
    3636    packspuFlush((void *) thread);
    3737    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    38     crStateCreateProgram(return_val);
     38    crStateCreateProgram(&pack_spu.StateTracker, return_val);
    3939
    4040    return return_val;
    … …  
    5959GLint PACKSPU_APIENTRY packspu_GetUniformLocation(GLuint program, const char * name)
    6060{
    61     if (!crStateIsProgramUniformsCached(program))
     61    if (!crStateIsProgramUniformsCached(&pack_spu.StateTracker, program))
    6262    {
    6363        GET_THREAD(thread);
    … …  
    8282        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    8383
    84         crStateGLSLProgramCacheUniforms(program, pData[0], &pData[1]);
    85 
    86         CRASSERT(crStateIsProgramUniformsCached(program));
     84        crStateGLSLProgramCacheUniforms(&pack_spu.StateTracker, program, pData[0], &pData[1]);
     85
     86        CRASSERT(crStateIsProgramUniformsCached(&pack_spu.StateTracker, program));
    8787
    8888        crFree(pData);
    … …  
    9090
    9191    /*crDebug("packspu_GetUniformLocation(%d, %s)=%i", program, name, crStateGetUniformLocation(program, name));*/
    92     return crStateGetUniformLocation(program, name);
     92    return crStateGetUniformLocation(&pack_spu.StateTracker, program, name);
    9393}
    9494
    … …  
    114114        return packspu_GetAttribLocationUnchached(program, name);
    115115
    116     if (!crStateIsProgramAttribsCached(program))
     116    if (!crStateIsProgramAttribsCached(&pack_spu.StateTracker, program))
    117117    {
    118118        GET_THREAD(thread);
    … …  
    137137        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    138138
    139         crStateGLSLProgramCacheAttribs(program, pData[0], &pData[1]);
    140 
    141         CRASSERT(crStateIsProgramAttribsCached(program));
     139        crStateGLSLProgramCacheAttribs(&pack_spu.StateTracker, program, pData[0], &pData[1]);
     140
     141        CRASSERT(crStateIsProgramAttribsCached(&pack_spu.StateTracker, program));
    142142
    143143        crFree(pData);
    … …  
    145145
    146146    /*crDebug("packspu_GetAttribLocation(%d, %s)=%i", program, name, crStateGetAttribLocation(program, name));*/
    147     return crStateGetAttribLocation(program, name);
     147    return crStateGetAttribLocation(&pack_spu.StateTracker, program, name);
    148148}
    149149
    … …  
    168168void PACKSPU_APIENTRY packspu_DeleteProgram(GLuint program)
    169169{
    170     crStateDeleteProgram(program);
     170    crStateDeleteProgram(&pack_spu.StateTracker, program);
    171171    crPackDeleteProgram(program);
    172172}
    … …  
    174174void PACK_APIENTRY packspu_DeleteObjectARB(VBoxGLhandleARB obj)
    175175{
    176     GLuint hwid = crStateGetProgramHWID(obj);
     176    GLuint hwid = crStateGetProgramHWID(&pack_spu.StateTracker, obj);
    177177
    178178    CRASSERT(obj);
    … …  
    182182    if (hwid)
    183183    {
    184         crStateDeleteProgram(obj);
     184        crStateDeleteProgram(&pack_spu.StateTracker, obj);
    185185    }
    186186
    … …  
    206206#endif
    207207
    208     crStateLinkProgram(program);
     208    crStateLinkProgram(&pack_spu.StateTracker, program);
    209209    crPackLinkProgram(program);
    210210
    … …  
    214214    if (!linkStatus)
    215215    {
    216         CRContext *ctx = crStateGetCurrent();
     216        CRContext *ctx = crStateGetCurrent(&pack_spu.StateTracker);
    217217        packspu_RecCheckInitRec();
    218218        crRecDumpProgram(&pack_spu.Recorder, ctx, program, program);
    … …  
    235235    if (!compileStatus)
    236236    {
    237         CRContext *ctx = crStateGetCurrent();
     237        CRContext *ctx = crStateGetCurrent(&pack_spu.StateTracker);
    238238        packspu_RecCheckInitRec();
    239239        crRecDumpShader(&pack_spu.Recorder, ctx, shader, shader);

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

    r78341 r78375  
    77#include "cr_mem.h"
    88#include "cr_spu.h"
    9 #include "cr_glstate.h"
    109#include "packspu.h"
    1110#include "cr_packfunctions.h"
    … …  
    2120
    2221PackSPU pack_spu;
     22DECLHIDDEN(PCRStateTracker) g_pStateTracker;
    2323
    2424CRtsd _PackTSD;
    … …  
    9393
    9494    packspuCreateFunctions();
    95     crStateInit();
     95    crStateInit(&pack_spu.StateTracker);
     96    g_pStateTracker = &pack_spu.StateTracker;
    9697
    9798    return &pack_functions;

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

    r78341 r78375  
    9898    GLint buffer;
    9999
    100     crStateGetIntegerv(GL_DRAW_BUFFER, &buffer);
     100    crStateGetIntegerv(&pack_spu.StateTracker, GL_DRAW_BUFFER, &buffer);
    101101    /*Usually buffer==GL_BACK, so put this extra check to simplify boolean eval on runtime*/
    102102    return  (buffer != GL_BACK)
    … …  
    116116    hadtoflush = packspuSyncOnFlushes();
    117117
    118     crStateDrawBuffer(mode);
     118    crStateDrawBuffer(&pack_spu.StateTracker, mode);
    119119    crPackDrawBuffer(mode);
    120120
    … …  
    197197void PACKSPU_APIENTRY packspu_NewList(GLuint list, GLenum mode)
    198198{
    199     crStateNewList(list, mode);
     199    crStateNewList(&pack_spu.StateTracker, list, mode);
    200200    crPackNewList(list, mode);
    201201}
    … …  
    203203void PACKSPU_APIENTRY packspu_EndList()
    204204{
    205     crStateEndList();
     205    crStateEndList(&pack_spu.StateTracker);
    206206    crPackEndList();
    207207}
    … …  
    366366    crPackGetPolygonStipple( mask, &writeback );
    367367#ifdef CR_ARB_pixel_buffer_object
    368     if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     368    if (!crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    369369#endif
    370370    {
    … …  
    381381    crPackGetPixelMapfv( map, values, &writeback );
    382382#ifdef CR_ARB_pixel_buffer_object
    383     if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     383    if (!crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    384384#endif
    385385    {
    … …  
    397397
    398398#ifdef CR_ARB_pixel_buffer_object
    399     if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     399    if (!crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    400400#endif
    401401    {
    … …  
    412412    crPackGetPixelMapusv( map, values, &writeback );
    413413#ifdef CR_ARB_pixel_buffer_object
    414     if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     414    if (!crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    415415#endif
    416416    {
    … …  
    449449            return;
    450450        case GL_SHARE_CONTEXT_RESOURCES_CR:
    451             crStateShareContext(value);
     451            crStateShareContext(&pack_spu.StateTracker, value);
    452452            break;
    453453        case GL_RCUSAGE_TEXTURE_SET_CR:
    454454        {
    455455            Assert(value);
    456             crStateSetTextureUsed(value, GL_TRUE);
     456            crStateSetTextureUsed(&pack_spu.StateTracker, value, GL_TRUE);
    457457            break;
    458458        }
    … …  
    462462#ifdef DEBUG
    463463            {
    464                 CRContext *pCurState = crStateGetCurrent();
     464                CRContext *pCurState = crStateGetCurrent(&pack_spu.StateTracker);
    465465                CRTextureObj *tobj = (CRTextureObj*)crHashtableSearch(pCurState->shared->textureTable, value);
    466466                Assert(tobj);
    467467            }
    468468#endif
    469             crStateSetTextureUsed(value, GL_FALSE);
     469            crStateSetTextureUsed(&pack_spu.StateTracker, value, GL_FALSE);
    470470            break;
    471471        }
    … …  
    481481    int writeback = 1;
    482482    GLenum return_val = (GLenum) 0;
    483     CRContext *pCurState = crStateGetCurrent();
     483    CRContext *pCurState = crStateGetCurrent(&pack_spu.StateTracker);
    484484    NOREF(pCurState); /* it's unused, but I don't know about side effects.. */
    485485
    … …  
    620620    crSetTSD(&_PackTSD, NULL);
    621621
    622     crStateVBoxAttachThread();
     622    crStateVBoxAttachThread(&pack_spu.StateTracker);
    623623}
    624624
    … …  
    701701    }
    702702
    703     crStateVBoxDetachThread();
     703    crStateVBoxDetachThread(&pack_spu.StateTracker);
    704704}
    705705

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

    r78190 r78375  
    269269     * image in a canonical layout (see util/pixel.c).
    270270     */
    271     crStatePixelStoref( pname, param );
     271    crStatePixelStoref(&pack_spu.StateTracker, pname, param );
    272272}
    273273
    274274void PACKSPU_APIENTRY packspu_PixelStorei( GLenum pname, GLint param )
    275275{
    276     crStatePixelStorei( pname, param );
     276    crStatePixelStorei(&pack_spu.StateTracker, pname, param );
    277277}
    278278
    … …  
    283283    CRClientState *clientState = &(ctx->clientState->client);
    284284
    285     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     285    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    286286    {
    287287        packspu_ApplyUnpackState();
    … …  
    290290    crPackDrawPixels( width, height, format, type, pixels, &(clientState->unpack) );
    291291
    292     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     292    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    293293    {
    294294        packspu_RestoreUnpackState();
    … …  
    303303    int writeback;
    304304
    305     if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     305    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    306306    {
    307307        packspu_ApplyPackState();
    … …  
    310310    crPackReadPixels(x, y, width, height, format, type, pixels, &(clientState->pack), &writeback);
    311311
    312     if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     312    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    313313    {
    314314        packspu_RestorePackState();
    … …  
    316316
    317317#ifdef CR_ARB_pixel_buffer_object
    318     if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     318    if (!crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    319319#endif
    320320    {
    … …  
    340340    CRClientState *clientState = &(ctx->clientState->client);
    341341
    342     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     342    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    343343    {
    344344        packspu_ApplyUnpackState();
    … …  
    347347    crPackBitmap(width, height, xorig, yorig, xmove, ymove, bitmap, &(clientState->unpack));
    348348
    349     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     349    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    350350    {
    351351        packspu_RestoreUnpackState();
    … …  
    360360    if (!packspu_CheckTexImageParams(internalformat, format, type))
    361361    {
    362         if (pixels || crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     362        if (pixels || crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    363363        {
    364364            crWarning("packspu_TexImage1D invalid internalFormat(%x)/format(%x)/type(%x)", internalformat, format, type);
    … …  
    370370    }
    371371
    372     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     372    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    373373    {
    374374        packspu_ApplyUnpackState();
    … …  
    376376
    377377    crPackTexImage1D( target, level, internalformat, width, border, format, type, pixels, &(clientState->unpack) );
    378     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     378    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    379379    {
    380380        packspu_RestoreUnpackState();
    … …  
    389389    if (!packspu_CheckTexImageParams(internalformat, format, type))
    390390    {
    391         if (pixels || crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     391        if (pixels || crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    392392        {
    393393            crWarning("packspu_TexImage2D invalid internalFormat(%x)/format(%x)/type(%x)", internalformat, format, type);
    … …  
    399399    }
    400400
    401     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     401    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    402402    {
    403403        packspu_ApplyUnpackState();
    … …  
    405405
    406406    crPackTexImage2D( target, level, internalformat, width, height, border, format, type, pixels, &(clientState->unpack) );
    407     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     407    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    408408    {
    409409        packspu_RestoreUnpackState();
    … …  
    417417    CRClientState *clientState = &(ctx->clientState->client);
    418418
    419     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     419    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    420420    {
    421421        packspu_ApplyUnpackState();
    … …  
    423423
    424424    crPackTexImage3DEXT( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
    425     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     425    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    426426    {
    427427        packspu_RestoreUnpackState();
    … …  
    436436    CRClientState *clientState = &(ctx->clientState->client);
    437437
    438     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     438    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    439439    {
    440440        packspu_ApplyUnpackState();
    … …  
    442442
    443443    crPackTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels, &(clientState->unpack) );
    444     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     444    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    445445    {
    446446        packspu_RestoreUnpackState();
    … …  
    460460    }
    461461
    462     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     462    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    463463    {
    464464        packspu_ApplyUnpackState();
    … …  
    466466
    467467    crPackTexSubImage1D( target, level, xoffset, width, format, type, pixels, &(clientState->unpack) );
    468     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     468    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    469469    {
    470470        packspu_RestoreUnpackState();
    … …  
    483483    }
    484484
    485     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     485    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    486486    {
    487487        packspu_ApplyUnpackState();
    … …  
    489489
    490490    crPackTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels, &(clientState->unpack) );
    491     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     491    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    492492    {
    493493        packspu_RestoreUnpackState();
    … …  
    501501    CRClientState *clientState = &(ctx->clientState->client);
    502502
    503     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     503    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    504504    {
    505505        packspu_ApplyUnpackState();
    … …  
    507507
    508508    crPackTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels, &(clientState->unpack) );
    509     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     509    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    510510    {
    511511        packspu_RestoreUnpackState();
    … …  
    533533     */
    534534
    535     if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     535    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    536536    {
    537537        packspu_ApplyPackState();
    … …  
    539539
    540540    crPackGetTexImage( target, level, format, type, pixels, &(clientState->pack), &writeback );
    541     if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     541    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    542542    {
    543543        packspu_RestorePackState();
    … …  
    545545
    546546#ifdef CR_ARB_pixel_buffer_object
    547     if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     547    if (!crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    548548#endif
    549549    {
    … …  
    558558    int writeback = 1;
    559559
    560     if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     560    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    561561    {
    562562        packspu_ApplyPackState();
    … …  
    564564
    565565    crPackGetCompressedTexImageARB( target, level, img, &writeback );
    566     if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     566    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    567567    {
    568568        packspu_RestorePackState();
    … …  
    570570
    571571#ifdef CR_ARB_pixel_buffer_object
    572     if (!crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
     572    if (!crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
    573573#endif
    574574    {
    … …  
    582582                                GLint border, GLsizei imagesize, const GLvoid *data)
    583583{
    584     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     584    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    585585    {
    586586        packspu_ApplyUnpackState();
    … …  
    589589    crPackCompressedTexImage1DARB(target, level, internalformat, width, border, imagesize, data);
    590590
    591     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     591    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    592592    {
    593593        packspu_RestoreUnpackState();
    … …  
    599599                                GLsizei height, GLint border, GLsizei imagesize, const GLvoid *data)
    600600{
    601     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     601    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    602602    {
    603603        packspu_ApplyUnpackState();
    … …  
    606606    crPackCompressedTexImage2DARB(target, level, internalformat, width, height, border, imagesize, data);
    607607
    608     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     608    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    609609    {
    610610        packspu_RestoreUnpackState();
    … …  
    616616                                GLsizei height, GLsizei depth, GLint border, GLsizei imagesize, const GLvoid *data)
    617617{
    618     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     618    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    619619    {
    620620        packspu_ApplyUnpackState();
    … …  
    623623    crPackCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imagesize, data);
    624624
    625     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     625    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    626626    {
    627627        packspu_RestoreUnpackState();
    … …  
    633633                                   GLenum format, GLsizei imagesize, const GLvoid *data)
    634634{
    635     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     635    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    636636    {
    637637        packspu_ApplyUnpackState();
    … …  
    640640    crPackCompressedTexSubImage1DARB(target, level, xoffset, width, format, imagesize, data);
    641641
    642     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     642    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    643643    {
    644644        packspu_RestoreUnpackState();
    … …  
    650650                                   GLsizei width, GLsizei height, GLenum format, GLsizei imagesize, const GLvoid *data)
    651651{
    652     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     652    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    653653    {
    654654        packspu_ApplyUnpackState();
    … …  
    657657    crPackCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imagesize, data);
    658658
    659     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     659    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    660660    {
    661661        packspu_RestoreUnpackState();
    … …  
    668668                                   GLsizei imagesize, const GLvoid *data)
    669669{
    670     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
     670    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
    671671    {
    672672        packspu_ApplyUnpackState();
    … …  
    675675    crPackCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imagesize, data);
    676676
    677     if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
    678     {
    679         packspu_RestoreUnpackState();
    680     }
    681 }
     677    if (crStateIsBufferBound(&pack_spu.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
     678    {
     679        packspu_RestoreUnpackState();
     680    }
     681}

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

    r78190 r78375  
    2424void PACKSPU_APIENTRY packspu_ActiveTextureARB(GLenum texture)
    2525{
    26     crStateActiveTextureARB(texture);
     26    crStateActiveTextureARB(&pack_spu.StateTracker, texture);
    2727    crPackActiveTextureARB(texture);
    2828}
    … …  
    3030void PACKSPU_APIENTRY packspu_BindTexture(GLenum target, GLuint texture)
    3131{
    32     crStateBindTexture(target, texture);
     32    crStateBindTexture(&pack_spu.StateTracker, target, texture);
    3333    crPackBindTexture(target, texture);
    3434}
    … …  
    3636void PACKSPU_APIENTRY packspu_DeleteTextures(GLsizei n, const GLuint * textures)
    3737{
    38     crStateDeleteTextures(n, textures);
     38    crStateDeleteTextures(&pack_spu.StateTracker, n, textures);
    3939    crPackDeleteTextures(n, textures);
    4040}
    … …  
    5252    packspuFlush( (void *) thread );
    5353    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    54     crStateRegTextures(n, textures);
     54    crStateRegTextures(&pack_spu.StateTracker, n, textures);
    5555}
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