VirtualBox

vbox的更動 63942 路徑 trunk/src/VBox/HostServices


忽略:
時間撮記:
2016-9-22 上午11:01:17 (8 年 以前)
作者:
vboxsync
訊息:

OpenGL: fixed the most annoying coding style flaws, mainly removing spaces after '(' and before ')', no semantic change

位置:
trunk/src/VBox/HostServices/SharedOpenGL
檔案:
修改 11 筆資料

圖例:

未更動
新增
刪除

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_dispatch.py

    r63939 r63942  
    3535    if wrap:
    3636        print('#if defined(CR_%s)' % wrap)
    37     print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s( %s )' % ( func_name, apiutil.MakeDeclarationString( params ) ))
     37    print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s(%s)' % ( func_name, apiutil.MakeDeclarationString( params ) ))
    3838    print('{')
    39     print('\tcrState%s( %s );' % (func_name, apiutil.MakeCallString( params ) ))
    40     print('\tcr_server.head_spu->dispatch_table.%s( %s );' % (func_name, apiutil.MakeCallString( params ) ))
     39    print('\tcrState%s(%s);' % (func_name, apiutil.MakeCallString( params ) ))
     40    print('\tcr_server.head_spu->dispatch_table.%s(%s);' % (func_name, apiutil.MakeCallString( params ) ))
    4141    print('}')
    4242    if wrap:
    … …  
    105105    if current:
    106106        params = apiutil.Parameters(func_name)
    107         print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s( %s )' % ( func_name, apiutil.MakeDeclarationString(params) ))
     107        print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s(%s)' % ( func_name, apiutil.MakeDeclarationString(params) ))
    108108        print('{')
    109109        print('\t%s' % (condition))
    110110        print('\t{')
    111         print('\t\tcr_server.head_spu->dispatch_table.%s( %s );' % (func_name, apiutil.MakeCallString(params) ))
     111        print('\t\tcr_server.head_spu->dispatch_table.%s(%s);' % (func_name, apiutil.MakeCallString(params) ))
    112112        print("\t\tcr_server.current.c.%s.%s%s = cr_unpackData;" % (name,type,array))
    113113        print('\t}')

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_dispatch_header.py

    r63939 r63942  
    4141        return_type = apiutil.ReturnType(func_name)
    4242       
    43         print('%s SERVER_DISPATCH_APIENTRY crServerDispatch%s( %s );' % (return_type, func_name, apiutil.MakeDeclarationString( params )))
     43        print('%s SERVER_DISPATCH_APIENTRY crServerDispatch%s(%s);' % (return_type, func_name, apiutil.MakeDeclarationString( params )))
    4444
    4545print("""

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_get.py

    r63939 r63942  
    119119        params = apiutil.Parameters(func_name)
    120120
    121         print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s( %s )' % (func_name, apiutil.MakeDeclarationString( params ) ))
     121        print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s(%s)' % (func_name, apiutil.MakeDeclarationString( params ) ))
    122122        print('{')
    123123
    … …  
    132132        params[-1] = (local_argname, local_argtype, 0)
    133133
    134         print('\tcr_server.head_spu->dispatch_table.%s( %s );' % ( func_name, apiutil.MakeCallString(params) ))
     134        print('\tcr_server.head_spu->dispatch_table.%s(%s);' % ( func_name, apiutil.MakeCallString(params) ))
    135135
    136136        if func_name in convert_bufferid:
    … …  
    140140
    141141        if func_name in no_pnames:
    142             print('\tcrServerReturnValue( &(%s[0]), %d*sizeof(%s) );' % (local_argname, max_components[func_name], local_argtype ))
     142            print('\tcrServerReturnValue(&(%s[0]), %d*sizeof(%s));' % (local_argname, max_components[func_name], local_argtype ))
    143143        else:
    144             print('\tcrServerReturnValue( &(%s[0]), crStateHlpComponentsCount(pname)*sizeof(%s) );' % (local_argname, local_argtype ))
     144            print('\tcrServerReturnValue(&(%s[0]), crStateHlpComponentsCount(pname)*sizeof(%s));' % (local_argname, local_argtype ))
    145145        print ('}\n')

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_retval.py

    r63939 r63942  
    6969        continue
    7070    if return_type != 'void':
    71         print('%s SERVER_DISPATCH_APIENTRY crServerDispatch%s( %s )' % ( return_type, func_name, apiutil.MakeDeclarationString(params)))
     71        print('%s SERVER_DISPATCH_APIENTRY crServerDispatch%s(%s)' % ( return_type, func_name, apiutil.MakeDeclarationString(params)))
    7272        print('{')
    7373        print('\t%s retval;' % return_type)
    74         print('\tretval = cr_server.head_spu->dispatch_table.%s( %s );' % (func_name, apiutil.MakeCallString(params) ))
     74        print('\tretval = cr_server.head_spu->dispatch_table.%s(%s);' % (func_name, apiutil.MakeCallString(params) ))
    7575        print('\tcrServerReturnValue( &retval, sizeof(retval) );')
    7676        print('\treturn retval; /* WILL PROBABLY BE IGNORED */')

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_simpleget.py

    r63939 r63942  
    3030    func_name = funcs[index]
    3131    params = apiutil.Parameters(func_name)
    32     print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s( %s )' % ( func_name, apiutil.MakeDeclarationString(params)))
     32    print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s(%s)' % ( func_name, apiutil.MakeDeclarationString(params)))
    3333    print('{')
    3434    print('\t%s *get_values;' % types[index])

  • trunk/src/VBox/HostServices/SharedOpenGL/dlm/dlm_generated.py

    r56922 r63942  
    197197        callstring += ", c"
    198198        argstring += ", CRClientState *c"
    199     print 'void DLM_APIENTRY crDLMCompile%s( %s )' % (functionName, argstring)
     199    print 'void DLM_APIENTRY crDLMCompile%s(%s)' % (functionName, argstring)
    200200    print '{'
    201201    print '    CRDLMContextState *state = CURRENT_STATE();'

  • trunk/src/VBox/HostServices/SharedOpenGL/dlm/dlm_header.py

    r56922 r63942  
    238238
    239239                if mode == 'header':
    240                         print 'extern void DLM_APIENTRY crDLMCompile%s( %s );' % (func_name, argstring)
     240                        print 'extern void DLM_APIENTRY crDLMCompile%s(%s);' % (func_name, argstring)
    241241                elif mode == 'defs':
    242242                        print "crDLMCompile%s" % func_name
    … …  
    262262                argstring = apiutil.MakeDeclarationString(params)
    263263                if mode == 'header':
    264                         print 'int DLM_APIENTRY crDLMCheckList%s( %s );' % (func_name, argstring)
     264                        print 'int DLM_APIENTRY crDLMCheckList%s(%s);' % (func_name, argstring)
    265265                elif mode == 'defs':
    266266                        print "crDLMCheckList%s" % func_name

  • trunk/src/VBox/HostServices/SharedOpenGL/expando/expando.py

    r54905 r63942  
    4545                needDL = 1
    4646
    47         print 'static %s EXPANDOSPU_APIENTRY expando%s( %s )' % ( return_type, func_name, declarationString)
     47        print 'static %s EXPANDOSPU_APIENTRY expando%s(%s)' % ( return_type, func_name, declarationString)
    4848        print '{'
    4949        if needDL:
    … …  
    7575            print '\texpando_spu.super.%s(%s);' % (func_name, basicCallString)
    7676        if apiutil.SetsClientState(func_name):
    77                 print '\tcrState%s( %s );' % (func_name, basicCallString)       
     77                print '\tcrState%s(%s);' % (func_name, basicCallString)
    7878       
    7979        if return_type != "void":

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack.py

    r63939 r63942  
    7171    argument out of the buffer's operand area."""
    7272    if arg_type == "GLdouble" or arg_type == "GLclampd":
    73         retval = "READ_DOUBLE( %d )" % offset
    74     else:
    75         retval = "READ_DATA( %d, %s )" % (offset, arg_type)
     73        retval = "READ_DOUBLE(%d)" % offset
     74    else:
     75        retval = "READ_DATA(%d, %s)" % (offset, arg_type)
    7676    return retval
    7777
    … …  
    8282    arg_len = apiutil.PacketLength( params )
    8383    if (return_type != 'void'):
    84         print('\tSET_RETURN_PTR( %d );' % (arg_len + 8)) # extended opcode plus packet length
     84        print('\tSET_RETURN_PTR(%d);' % (arg_len + 8)) # extended opcode plus packet length
    8585    else:
    8686        paramList = [ ('foo', 'void *', 0) ]
    87         print('\tSET_RETURN_PTR( %d );' % (arg_len + 8 - apiutil.PacketLength(paramList)))
     87        print('\tSET_RETURN_PTR(%d);' % (arg_len + 8 - apiutil.PacketLength(paramList)))
    8888
    8989
    … …  
    9595        arg_len += apiutil.PacketLength( paramList )
    9696
    97     print('\tSET_WRITEBACK_PTR( %d );' % (arg_len + 8)) # extended opcode plus packet length
     97    print('\tSET_WRITEBACK_PTR(%d);' % (arg_len + 8)) # extended opcode plus packet length
    9898
    9999
    … …  
    121121    else:
    122122        print("\t", end="")
    123     print("cr_unpackDispatch.%s( %s );" % (func_name, apiutil.MakeCallString(params)))
     123    print("cr_unpackDispatch.%s(%s);" % (func_name, apiutil.MakeCallString(params)))
    124124
    125125
    … …  
    136136        print("#else")
    137137        for index in range(0, vecSize):
    138             print("\tGLdouble v" + repr(index) + " = READ_DOUBLE(", repr(index * 8), ");")
     138            print("\tGLdouble v" + repr(index) + " = READ_DOUBLE(" + repr(index * 8) + ");")
    139139        if return_type != "void":
    140             print("\t(void) cr_unpackDispatch.%s(" % func_name, end=" ")
     140            print("\t(void) cr_unpackDispatch.%s(" % func_name, end="")
    141141        else:
    142             print("\tcr_unpackDispatch.%s(" % func_name, end=" ")
     142            print("\tcr_unpackDispatch.%s(" % func_name, end="")
    143143        for index in range(0, vecSize):
    144             print("v" + repr(index), end=" ")
     144            print("v" + repr(index), end="")
    145145            if index != vecSize - 1:
    146146                print(",", end=" ")
    … …  
    178178        print("\tINCR_DATA_PTR_NO_ARGS( );")
    179179    else:
    180         print("\tINCR_DATA_PTR( %d );" % packet_length)
     180        print("\tINCR_DATA_PTR(%d);" % packet_length)
    181181    print("}\n")
    182182
    … …  
    258258#endif
    259259
    260     for (i = 0 ; i < num_opcodes ; i++)
     260    for (i = 0; i < num_opcodes; i++)
    261261    {
    262262   

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_map.c

    r15532 r63942  
    1010
    1111
    12 void crUnpackMap2d( void  )
     12void crUnpackMap2d(void)
    1313{
    14         GLenum target = READ_DATA( sizeof( int ) + 0, GLenum );
    15         GLdouble u1 = READ_DOUBLE( sizeof( int ) + 4 );
    16         GLdouble u2 = READ_DOUBLE( sizeof( int ) + 12 );
    17         GLint ustride = READ_DATA( sizeof( int ) + 20, GLint );
    18         GLint uorder = READ_DATA( sizeof( int ) + 24, GLint );
    19         GLdouble v1 = READ_DOUBLE( sizeof( int ) + 28 );
    20         GLdouble v2 = READ_DOUBLE( sizeof( int ) + 36 );
    21         GLint vstride = READ_DATA( sizeof( int ) + 44, GLint );
    22         GLint vorder = READ_DATA( sizeof( int ) + 48, GLint );
     14        GLenum target = READ_DATA(sizeof(int) + 0, GLenum);
     15        GLdouble u1 = READ_DOUBLE(sizeof(int) + 4);
     16        GLdouble u2 = READ_DOUBLE(sizeof(int) + 12);
     17        GLint ustride = READ_DATA(sizeof(int) + 20, GLint);
     18        GLint uorder = READ_DATA(sizeof(int) + 24, GLint);
     19        GLdouble v1 = READ_DOUBLE(sizeof(int) + 28);
     20        GLdouble v2 = READ_DOUBLE(sizeof(int) + 36);
     21        GLint vstride = READ_DATA(sizeof(int) + 44, GLint);
     22        GLint vorder = READ_DATA(sizeof(int) + 48, GLint);
    2323
    24         int n_points = READ_DATA( 0, int ) - ( sizeof( int ) + 52 );
     24        int n_points = READ_DATA(0, int) - (sizeof(int) + 52);
    2525        GLdouble *points;
    2626
    27         if ( n_points & 0x7 )
    28                 crError( "crUnpackMap2d: n_points=%d, expected multiple of 8\n", n_points );
    29         points = (GLdouble *) crAlloc( n_points );
    30         crMemcpy( points, DATA_POINTER( sizeof(int) + 52, GLdouble ), n_points );
     27        if (n_points & 0x7)
     28                crError("crUnpackMap2d: n_points=%d, expected multiple of 8\n", n_points);
     29        points = (GLdouble *) crAlloc(n_points);
     30        crMemcpy(points, DATA_POINTER(sizeof(int) + 52, GLdouble), n_points);
    3131
    32         cr_unpackDispatch.Map2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
    33                          points );
    34         crFree( points );
     32        cr_unpackDispatch.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
     33                         points);
     34        crFree(points);
    3535
    3636        INCR_VAR_PTR();
    3737}
    3838
    39 void crUnpackMap2f( void  )
     39void crUnpackMap2f(void)
    4040{
    41         GLenum target = READ_DATA( sizeof( int ) + 0, GLenum );
    42         GLfloat u1 = READ_DATA( sizeof( int ) + 4, GLfloat );
    43         GLfloat u2 = READ_DATA( sizeof( int ) + 8, GLfloat );
    44         GLint ustride = READ_DATA( sizeof( int ) + 12, GLint );
    45         GLint uorder = READ_DATA( sizeof( int ) + 16, GLint );
    46         GLfloat v1 = READ_DATA( sizeof( int ) + 20, GLfloat );
    47         GLfloat v2 = READ_DATA( sizeof( int ) + 24, GLfloat );
    48         GLint vstride = READ_DATA( sizeof( int ) + 28, GLint );
    49         GLint vorder = READ_DATA( sizeof( int ) + 32, GLint );
    50         GLfloat *points = DATA_POINTER( sizeof( int ) + 36 , GLfloat );
     41        GLenum target = READ_DATA(sizeof(int) + 0, GLenum);
     42        GLfloat u1 = READ_DATA(sizeof(int) + 4, GLfloat);
     43        GLfloat u2 = READ_DATA(sizeof(int) + 8, GLfloat);
     44        GLint ustride = READ_DATA(sizeof(int) + 12, GLint);
     45        GLint uorder = READ_DATA(sizeof(int) + 16, GLint);
     46        GLfloat v1 = READ_DATA(sizeof(int) + 20, GLfloat);
     47        GLfloat v2 = READ_DATA(sizeof(int) + 24, GLfloat);
     48        GLint vstride = READ_DATA(sizeof(int) + 28, GLint);
     49        GLint vorder = READ_DATA(sizeof(int) + 32, GLint);
     50        GLfloat *points = DATA_POINTER(sizeof(int) + 36 , GLfloat);
    5151
    52         cr_unpackDispatch.Map2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
    53                          points );
     52        cr_unpackDispatch.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
     53                         points);
    5454        INCR_VAR_PTR();
    5555}
    5656
    57 void crUnpackMap1d( void  )
     57void crUnpackMap1d(void)
    5858{
    59         GLenum target = READ_DATA( sizeof( int ) + 0, GLenum );
    60         GLdouble u1 = READ_DOUBLE( sizeof( int ) + 4 );
    61         GLdouble u2 = READ_DOUBLE( sizeof( int ) + 12 );
    62         GLint stride = READ_DATA( sizeof( int ) + 20, GLint );
    63         GLint order = READ_DATA( sizeof( int ) + 24, GLint );
     59        GLenum target = READ_DATA(sizeof(int) + 0, GLenum);
     60        GLdouble u1 = READ_DOUBLE(sizeof(int) + 4);
     61        GLdouble u2 = READ_DOUBLE(sizeof(int) + 12);
     62        GLint stride = READ_DATA(sizeof(int) + 20, GLint);
     63        GLint order = READ_DATA(sizeof(int) + 24, GLint);
    6464
    65         int n_points = READ_DATA( 0, int ) - ( sizeof(int) + 28 );
     65        int n_points = READ_DATA(0, int) - (sizeof(int) + 28);
    6666        GLdouble *points;
    6767
    68         if ( n_points & 0x7 )
    69                 crError( "crUnpackMap1d: n_points=%d, expected multiple of 8\n", n_points );
    70         points = (GLdouble *) crAlloc( n_points );
    71         crMemcpy( points, DATA_POINTER( sizeof(int) + 28, GLdouble ), n_points );
     68        if (n_points & 0x7)
     69                crError("crUnpackMap1d: n_points=%d, expected multiple of 8\n", n_points);
     70        points = (GLdouble *) crAlloc(n_points);
     71        crMemcpy(points, DATA_POINTER(sizeof(int) + 28, GLdouble), n_points);
    7272       
    73         cr_unpackDispatch.Map1d( target, u1, u2, stride, order, points );
    74         crFree( points );
     73        cr_unpackDispatch.Map1d(target, u1, u2, stride, order, points);
     74        crFree(points);
    7575
    7676        INCR_VAR_PTR();
    7777}
    7878
    79 void crUnpackMap1f( void  )
     79void crUnpackMap1f(void)
    8080{
    81         GLenum target = READ_DATA( sizeof( int ) + 0, GLenum );
    82         GLfloat u1 = READ_DATA( sizeof( int ) + 4, GLfloat );
    83         GLfloat u2 = READ_DATA( sizeof( int ) + 8, GLfloat );
    84         GLint stride = READ_DATA( sizeof( int ) + 12, GLint );
    85         GLint order = READ_DATA( sizeof( int ) + 16, GLint );
    86         GLfloat *points = DATA_POINTER( sizeof( int ) + 20, GLfloat );
     81        GLenum target = READ_DATA(sizeof(int) + 0, GLenum);
     82        GLfloat u1 = READ_DATA(sizeof(int) + 4, GLfloat);
     83        GLfloat u2 = READ_DATA(sizeof(int) + 8, GLfloat);
     84        GLint stride = READ_DATA(sizeof(int) + 12, GLint);
     85        GLint order = READ_DATA(sizeof(int) + 16, GLint);
     86        GLfloat *points = DATA_POINTER(sizeof(int) + 20, GLfloat);
    8787
    88         cr_unpackDispatch.Map1f( target, u1, u2, stride, order, points );
     88        cr_unpackDispatch.Map1f(target, u1, u2, stride, order, points);
    8989        INCR_VAR_PTR();
    9090}

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_program.c

    r15532 r63942  
    1414void crUnpackExtendProgramParameter4dvNV(void)
    1515{
    16         GLenum target = READ_DATA( 8, GLenum );
    17         GLuint index = READ_DATA( 12, GLuint );
    18         GLdouble params[4];
    19         params[0] = READ_DOUBLE( 16 );
    20         params[1] = READ_DOUBLE( 24 );
    21         params[2] = READ_DOUBLE( 32 );
    22         params[3] = READ_DOUBLE( 40 );
    23         cr_unpackDispatch.ProgramParameter4dvNV( target, index, params );
     16        GLenum target = READ_DATA(8, GLenum);
     17        GLuint index = READ_DATA(12, GLuint);
     18        GLdouble params[4];
     19        params[0] = READ_DOUBLE(16);
     20        params[1] = READ_DOUBLE(24);
     21        params[2] = READ_DOUBLE(32);
     22        params[3] = READ_DOUBLE(40);
     23        cr_unpackDispatch.ProgramParameter4dvNV(target, index, params);
    2424}
    2525
    … …  
    2727void crUnpackExtendProgramParameter4fvNV(void)
    2828{
    29         GLenum target = READ_DATA( 8, GLenum );
    30         GLuint index = READ_DATA( 12, GLuint );
    31         GLfloat params[4];
    32         params[0] = READ_DATA( 16, GLfloat );
    33         params[1] = READ_DATA( 20, GLfloat );
    34         params[2] = READ_DATA( 24, GLfloat );
    35         params[3] = READ_DATA( 28, GLfloat );
    36         cr_unpackDispatch.ProgramParameter4fvNV( target, index, params );
     29        GLenum target = READ_DATA(8, GLenum);
     30        GLuint index = READ_DATA(12, GLuint);
     31        GLfloat params[4];
     32        params[0] = READ_DATA(16, GLfloat);
     33        params[1] = READ_DATA(20, GLfloat);
     34        params[2] = READ_DATA(24, GLfloat);
     35        params[3] = READ_DATA(28, GLfloat);
     36        cr_unpackDispatch.ProgramParameter4fvNV(target, index, params);
    3737}
    3838
    … …  
    4040void crUnpackExtendProgramParameters4dvNV(void)
    4141{
    42         GLenum target = READ_DATA( 8, GLenum );
    43         GLuint index = READ_DATA( 12, GLuint );
    44         GLuint num = READ_DATA( 16, GLuint);
     42        GLenum target = READ_DATA(8, GLenum);
     43        GLuint index = READ_DATA(12, GLuint);
     44        GLuint num = READ_DATA(16, GLuint);
    4545        GLdouble *params = (GLdouble *) crAlloc(num * 4 * sizeof(GLdouble));
    4646        if (params) {
    4747                GLuint i;
    4848                for (i = 0; i < 4 * num; i++) {
    49                         params[i] = READ_DATA( 20 + i * 8, GLdouble );
     49                        params[i] = READ_DATA(20 + i * 8, GLdouble);
    5050                }
    51                 cr_unpackDispatch.ProgramParameters4dvNV( target, index, num, params );
     51                cr_unpackDispatch.ProgramParameters4dvNV(target, index, num, params);
    5252                crFree(params);
    5353        }
    … …  
    5757void crUnpackExtendProgramParameters4fvNV(void)
    5858{
    59         GLenum target = READ_DATA( 8, GLenum );
    60         GLuint index = READ_DATA( 12, GLuint );
    61         GLuint num = READ_DATA( 16, GLuint);
     59        GLenum target = READ_DATA(8, GLenum);
     60        GLuint index = READ_DATA(12, GLuint);
     61        GLuint num = READ_DATA(16, GLuint);
    6262        GLfloat *params = (GLfloat *) crAlloc(num * 4 * sizeof(GLfloat));
    6363        if (params) {
    6464                GLuint i;
    6565                for (i = 0; i < 4 * num; i++) {
    66                         params[i] = READ_DATA( 20 + i * 4, GLfloat );
     66                        params[i] = READ_DATA(20 + i * 4, GLfloat);
    6767                }
    68                 cr_unpackDispatch.ProgramParameters4fvNV( target, index, num, params );
     68                cr_unpackDispatch.ProgramParameters4fvNV(target, index, num, params);
    6969                crFree(params);
    7070        }
    … …  
    7474void crUnpackExtendAreProgramsResidentNV(void)
    7575{
    76         GLsizei n = READ_DATA( 8, GLsizei );
    77         const GLuint *programs = DATA_POINTER( 12, const GLuint );
     76        GLsizei n = READ_DATA(8, GLsizei);
     77        const GLuint *programs = DATA_POINTER(12, const GLuint);
    7878        SET_RETURN_PTR(12 + n * sizeof(GLuint));
    7979        SET_WRITEBACK_PTR(20 + n * sizeof(GLuint));
    80         (void) cr_unpackDispatch.AreProgramsResidentNV( n, programs, NULL );
     80        (void) cr_unpackDispatch.AreProgramsResidentNV(n, programs, NULL);
    8181}
    8282
    … …  
    8484void crUnpackExtendLoadProgramNV(void)
    8585{
    86         GLenum target = READ_DATA( 8, GLenum );
    87         GLuint id = READ_DATA( 12, GLuint );
    88         GLsizei len = READ_DATA( 16, GLsizei );
    89         GLvoid *program = DATA_POINTER( 20, GLvoid );
    90         cr_unpackDispatch.LoadProgramNV( target, id, len, program );
     86        GLenum target = READ_DATA(8, GLenum);
     87        GLuint id = READ_DATA(12, GLuint);
     88        GLsizei len = READ_DATA(16, GLsizei);
     89        GLvoid *program = DATA_POINTER(20, GLvoid);
     90        cr_unpackDispatch.LoadProgramNV(target, id, len, program);
    9191}
    9292
    … …  
    9494void crUnpackExtendExecuteProgramNV(void)
    9595{
    96         GLenum target = READ_DATA( 8, GLenum );
    97         GLuint id = READ_DATA( 12, GLuint );
    98         GLfloat params[4];
    99         params[0] = READ_DATA( 16, GLfloat );
    100         params[1] = READ_DATA( 20, GLfloat );
    101         params[2] = READ_DATA( 24, GLfloat );
    102         params[3] = READ_DATA( 28, GLfloat );
    103         cr_unpackDispatch.ExecuteProgramNV( target, id, params );
     96        GLenum target = READ_DATA(8, GLenum);
     97        GLuint id = READ_DATA(12, GLuint);
     98        GLfloat params[4];
     99        params[0] = READ_DATA(16, GLfloat);
     100        params[1] = READ_DATA(20, GLfloat);
     101        params[2] = READ_DATA(24, GLfloat);
     102        params[3] = READ_DATA(28, GLfloat);
     103        cr_unpackDispatch.ExecuteProgramNV(target, id, params);
    104104}
    105105
    106106void crUnpackExtendRequestResidentProgramsNV(void)
    107107{
    108         GLsizei n = READ_DATA( 8, GLsizei );
    109         crError( "RequestResidentProgramsNV needs to be special cased!" );
    110         cr_unpackDispatch.RequestResidentProgramsNV( n, NULL );
     108        GLsizei n = READ_DATA(8, GLsizei);
     109        crError("RequestResidentProgramsNV needs to be special cased!");
     110        cr_unpackDispatch.RequestResidentProgramsNV(n, NULL);
    111111}
    112112
    … …  
    114114void crUnpackExtendProgramLocalParameter4fvARB(void)
    115115{
    116         GLenum target = READ_DATA( 8, GLenum );
    117         GLuint index = READ_DATA( 12, GLuint );
    118         GLfloat params[4];
    119         params[0] = READ_DATA( 16, GLfloat );
    120         params[1] = READ_DATA( 20, GLfloat );
    121         params[2] = READ_DATA( 24, GLfloat );
    122         params[3] = READ_DATA( 28, GLfloat );
    123         cr_unpackDispatch.ProgramLocalParameter4fvARB( target, index, params );
     116        GLenum target = READ_DATA(8, GLenum);
     117        GLuint index = READ_DATA(12, GLuint);
     118        GLfloat params[4];
     119        params[0] = READ_DATA(16, GLfloat);
     120        params[1] = READ_DATA(20, GLfloat);
     121        params[2] = READ_DATA(24, GLfloat);
     122        params[3] = READ_DATA(28, GLfloat);
     123        cr_unpackDispatch.ProgramLocalParameter4fvARB(target, index, params);
    124124}
    125125
    … …  
    127127void crUnpackExtendProgramLocalParameter4dvARB(void)
    128128{
    129         GLenum target = READ_DATA( 8, GLenum );
    130         GLuint index = READ_DATA( 12, GLuint );
    131         GLdouble params[4];
    132         params[0] = READ_DOUBLE( 16 );
    133         params[1] = READ_DOUBLE( 24 );
    134         params[2] = READ_DOUBLE( 32 );
    135         params[3] = READ_DOUBLE( 40 );
    136         cr_unpackDispatch.ProgramLocalParameter4dvARB( target, index, params );
     129        GLenum target = READ_DATA(8, GLenum);
     130        GLuint index = READ_DATA(12, GLuint);
     131        GLdouble params[4];
     132        params[0] = READ_DOUBLE(16);
     133        params[1] = READ_DOUBLE(24);
     134        params[2] = READ_DOUBLE(32);
     135        params[3] = READ_DOUBLE(40);
     136        cr_unpackDispatch.ProgramLocalParameter4dvARB(target, index, params);
    137137}
    138138
    … …  
    141141void crUnpackExtendProgramNamedParameter4dvNV(void)
    142142{
    143         GLuint id = READ_DATA( 8, GLuint );
    144         GLsizei len = READ_DATA( 12, GLsizei );
    145         GLdouble params[4];
    146         GLubyte *name = crAlloc( len );
    147         params[0] = READ_DOUBLE( 16 );
    148         params[1] = READ_DOUBLE( 24 );
    149         params[2] = READ_DOUBLE( 32 );
    150         params[3] = READ_DOUBLE( 40 );
    151         crMemcpy( name, DATA_POINTER( 48, GLubyte ), len );
    152         cr_unpackDispatch.ProgramNamedParameter4dvNV( id, len, name, params );
     143        GLuint id = READ_DATA(8, GLuint);
     144        GLsizei len = READ_DATA(12, GLsizei);
     145        GLdouble params[4];
     146        GLubyte *name = crAlloc(len);
     147        params[0] = READ_DOUBLE(16);
     148        params[1] = READ_DOUBLE(24);
     149        params[2] = READ_DOUBLE(32);
     150        params[3] = READ_DOUBLE(40);
     151        crMemcpy(name, DATA_POINTER(48, GLubyte), len);
     152        cr_unpackDispatch.ProgramNamedParameter4dvNV(id, len, name, params);
    153153}
    154154
    155155void crUnpackExtendProgramNamedParameter4dNV(void)
    156156{
    157         GLuint id = READ_DATA( 8, GLuint );
    158         GLsizei len = READ_DATA( 12, GLsizei );
    159         GLdouble params[4];
    160         GLubyte *name = crAlloc ( len );
    161         params[0] = READ_DOUBLE( 16 );
    162         params[1] = READ_DOUBLE( 24 );
    163         params[2] = READ_DOUBLE( 32 );
    164         params[3] = READ_DOUBLE( 40 );
    165         crMemcpy( name, DATA_POINTER( 48, GLubyte ), len );
    166         cr_unpackDispatch.ProgramNamedParameter4dNV( id, len, name, params[0], params[1], params[2], params[3] );
     157        GLuint id = READ_DATA(8, GLuint);
     158        GLsizei len = READ_DATA(12, GLsizei);
     159        GLdouble params[4];
     160        GLubyte *name = crAlloc (len);
     161        params[0] = READ_DOUBLE(16);
     162        params[1] = READ_DOUBLE(24);
     163        params[2] = READ_DOUBLE(32);
     164        params[3] = READ_DOUBLE(40);
     165        crMemcpy(name, DATA_POINTER(48, GLubyte), len);
     166        cr_unpackDispatch.ProgramNamedParameter4dNV(id, len, name, params[0], params[1], params[2], params[3]);
    167167}
    168168
    169169void crUnpackExtendProgramNamedParameter4fNV(void)
    170170{
    171         GLenum id = READ_DATA( 8, GLuint );
    172         GLsizei len = READ_DATA( 12, GLsizei );
    173         GLfloat params[4];
    174         GLubyte *name = crAlloc( len);
    175         params[0] = READ_DATA( 16, GLfloat );
    176         params[1] = READ_DATA( 20, GLfloat );
    177         params[2] = READ_DATA( 24, GLfloat );
    178         params[3] = READ_DATA( 28, GLfloat );
    179         crMemcpy( name, DATA_POINTER( 32,  GLubyte ), len );
    180         cr_unpackDispatch.ProgramNamedParameter4fNV( id, len, name, params[0], params[1], params[2], params[3] );
     171        GLenum id = READ_DATA(8, GLuint);
     172        GLsizei len = READ_DATA(12, GLsizei);
     173        GLfloat params[4];
     174        GLubyte *name = crAlloc(len);
     175        params[0] = READ_DATA(16, GLfloat);
     176        params[1] = READ_DATA(20, GLfloat);
     177        params[2] = READ_DATA(24, GLfloat);
     178        params[3] = READ_DATA(28, GLfloat);
     179        crMemcpy(name, DATA_POINTER(32,  GLubyte), len);
     180        cr_unpackDispatch.ProgramNamedParameter4fNV(id, len, name, params[0], params[1], params[2], params[3]);
    181181}
    182182
    183183void crUnpackExtendProgramNamedParameter4fvNV(void)
    184184{
    185         GLenum id = READ_DATA( 8, GLuint );
    186         GLsizei len = READ_DATA( 12, GLsizei );
    187         GLfloat params[4];
    188         GLubyte *name = crAlloc( len);
    189         params[0] = READ_DATA( 16, GLfloat );
    190         params[1] = READ_DATA( 20, GLfloat );
    191         params[2] = READ_DATA( 24, GLfloat );
    192         params[3] = READ_DATA( 28, GLfloat );
    193         crMemcpy( name, DATA_POINTER( 32, GLubyte ), len );
    194         cr_unpackDispatch.ProgramNamedParameter4fvNV( id, len, name, params );
     185        GLenum id = READ_DATA(8, GLuint);
     186        GLsizei len = READ_DATA(12, GLsizei);
     187        GLfloat params[4];
     188        GLubyte *name = crAlloc(len);
     189        params[0] = READ_DATA(16, GLfloat);
     190        params[1] = READ_DATA(20, GLfloat);
     191        params[2] = READ_DATA(24, GLfloat);
     192        params[3] = READ_DATA(28, GLfloat);
     193        crMemcpy(name, DATA_POINTER(32, GLubyte), len);
     194        cr_unpackDispatch.ProgramNamedParameter4fvNV(id, len, name, params);
    195195}
    196196
    197197void crUnpackExtendGetProgramNamedParameterdvNV(void)
    198198{
    199         GLuint id = READ_DATA( 8, GLuint );
    200         GLsizei len = READ_DATA( 12, GLsizei );
    201         const GLubyte *name = DATA_POINTER( 16, GLubyte );
    202         SET_RETURN_PTR( 16+len );
    203         SET_WRITEBACK_PTR( 16+len+8 );
    204         cr_unpackDispatch.GetProgramNamedParameterdvNV( id, len, name, NULL );
     199        GLuint id = READ_DATA(8, GLuint);
     200        GLsizei len = READ_DATA(12, GLsizei);
     201        const GLubyte *name = DATA_POINTER(16, GLubyte);
     202        SET_RETURN_PTR(16+len);
     203        SET_WRITEBACK_PTR(16+len+8);
     204        cr_unpackDispatch.GetProgramNamedParameterdvNV(id, len, name, NULL);
    205205}
    206206
    207207void crUnpackExtendGetProgramNamedParameterfvNV(void)
    208208{
    209         GLuint id = READ_DATA( 8, GLuint );
    210         GLsizei len = READ_DATA( 12, GLsizei );
    211         const GLubyte *name = DATA_POINTER( 16, GLubyte );
    212         SET_RETURN_PTR( 16+len );
    213         SET_WRITEBACK_PTR( 16+len+8 );
    214         cr_unpackDispatch.GetProgramNamedParameterfvNV( id, len, name, NULL );
     209        GLuint id = READ_DATA(8, GLuint);
     210        GLsizei len = READ_DATA(12, GLsizei);
     211        const GLubyte *name = DATA_POINTER(16, GLubyte);
     212        SET_RETURN_PTR(16+len);
     213        SET_WRITEBACK_PTR(16+len+8);
     214        cr_unpackDispatch.GetProgramNamedParameterfvNV(id, len, name, NULL);
    215215}
    216216
    217217void crUnpackExtendProgramStringARB(void)
    218218{
    219       GLenum target = READ_DATA( 8, GLenum );
    220       GLenum format = READ_DATA( 12, GLuint );
    221       GLsizei len = READ_DATA( 16, GLsizei );
    222       GLvoid *program = DATA_POINTER( 20, GLvoid );
    223       cr_unpackDispatch.ProgramStringARB( target, format, len, program );
     219      GLenum target = READ_DATA(8, GLenum);
     220      GLenum format = READ_DATA(12, GLuint);
     221      GLsizei len = READ_DATA(16, GLsizei);
     222      GLvoid *program = DATA_POINTER(20, GLvoid);
     223      cr_unpackDispatch.ProgramStringARB(target, format, len, program);
    224224}
    225225
    … …  
    230230void crUnpackExtendProgramEnvParameter4dvARB(void)
    231231{
    232         GLenum target = READ_DATA( 8, GLenum );
    233         GLuint index = READ_DATA( 12, GLuint );
    234         GLdouble params[4];
    235         params[0] = READ_DOUBLE( 16 );
    236         params[1] = READ_DOUBLE( 24 );
    237         params[2] = READ_DOUBLE( 32 );
    238         params[3] = READ_DOUBLE( 40 );
    239         cr_unpackDispatch.ProgramEnvParameter4dvARB( target, index, params );
     232        GLenum target = READ_DATA(8, GLenum);
     233        GLuint index = READ_DATA(12, GLuint);
     234        GLdouble params[4];
     235        params[0] = READ_DOUBLE(16);
     236        params[1] = READ_DOUBLE(24);
     237        params[2] = READ_DOUBLE(32);
     238        params[3] = READ_DOUBLE(40);
     239        cr_unpackDispatch.ProgramEnvParameter4dvARB(target, index, params);
    240240}
    241241
    242242void crUnpackExtendProgramEnvParameter4fvARB(void)
    243243{
    244         GLenum target = READ_DATA( 8, GLenum );
    245         GLuint index = READ_DATA( 12, GLuint );
    246         GLfloat params[4];
    247         params[0] = READ_DATA( 16, GLfloat );
    248         params[1] = READ_DATA( 20, GLfloat );
    249         params[2] = READ_DATA( 24, GLfloat );
    250         params[3] = READ_DATA( 28, GLfloat );
    251         cr_unpackDispatch.ProgramEnvParameter4fvARB( target, index, params );
     244        GLenum target = READ_DATA(8, GLenum);
     245        GLuint index = READ_DATA(12, GLuint);
     246        GLfloat params[4];
     247        params[0] = READ_DATA(16, GLfloat);
     248        params[1] = READ_DATA(20, GLfloat);
     249        params[2] = READ_DATA(24, GLfloat);
     250        params[3] = READ_DATA(28, GLfloat);
     251        cr_unpackDispatch.ProgramEnvParameter4fvARB(target, index, params);
    252252}
    253253
    254254void crUnpackExtendDeleteProgramsARB(void)
    255255{
    256         GLsizei n = READ_DATA( 8, GLsizei );
    257         const GLuint *programs = DATA_POINTER( 12, GLuint );
    258         cr_unpackDispatch.DeleteProgramsARB( n, programs );
     256        GLsizei n = READ_DATA(8, GLsizei);
     257        const GLuint *programs = DATA_POINTER(12, GLuint);
     258        cr_unpackDispatch.DeleteProgramsARB(n, programs);
    259259}
    260260
    261261void crUnpackVertexAttrib4NbvARB(void)
    262262{
    263         GLuint index = READ_DATA( 0, GLuint );
     263        GLuint index = READ_DATA(0, GLuint);
    264264        const GLbyte *v = DATA_POINTER(4, const GLbyte);
    265         cr_unpackDispatch.VertexAttrib4NbvARB( index, v );
    266         INCR_DATA_PTR( 8 );
     265        cr_unpackDispatch.VertexAttrib4NbvARB(index, v);
     266        INCR_DATA_PTR(8);
    267267}
    268268
    269269void crUnpackVertexAttrib4NivARB(void)
    270270{
    271         GLuint index = READ_DATA( 0, GLuint );
     271        GLuint index = READ_DATA(0, GLuint);
    272272        const GLint *v = DATA_POINTER(4, const GLint);
    273         cr_unpackDispatch.VertexAttrib4NivARB( index, v );
    274         INCR_DATA_PTR( 20 );
     273        cr_unpackDispatch.VertexAttrib4NivARB(index, v);
     274        INCR_DATA_PTR(20);
    275275}
    276276
    277277void crUnpackVertexAttrib4NsvARB(void)
    278278{
    279         GLuint index = READ_DATA( 0, GLuint );
     279        GLuint index = READ_DATA(0, GLuint);
    280280        const GLshort *v = DATA_POINTER(4, const GLshort);
    281         cr_unpackDispatch.VertexAttrib4NsvARB( index, v );
    282         INCR_DATA_PTR( 12 );
     281        cr_unpackDispatch.VertexAttrib4NsvARB(index, v);
     282        INCR_DATA_PTR(12);
    283283}
    284284
    285285void crUnpackVertexAttrib4NubvARB(void)
    286286{
    287         GLuint index = READ_DATA( 0, GLuint );
     287        GLuint index = READ_DATA(0, GLuint);
    288288        const GLubyte *v = DATA_POINTER(4, const GLubyte);
    289         cr_unpackDispatch.VertexAttrib4NubvARB( index, v );
    290         INCR_DATA_PTR( 8 );
     289        cr_unpackDispatch.VertexAttrib4NubvARB(index, v);
     290        INCR_DATA_PTR(8);
    291291}
    292292
    293293void crUnpackVertexAttrib4NuivARB(void)
    294294{
    295         GLuint index = READ_DATA( 0, GLuint );
     295        GLuint index = READ_DATA(0, GLuint);
    296296        const GLuint *v = DATA_POINTER(4, const GLuint);
    297         cr_unpackDispatch.VertexAttrib4NuivARB( index, v );
    298         INCR_DATA_PTR( 20 );
     297        cr_unpackDispatch.VertexAttrib4NuivARB(index, v);
     298        INCR_DATA_PTR(20);
    299299}
    300300
    301301void crUnpackVertexAttrib4NusvARB(void)
    302302{
    303         GLuint index = READ_DATA( 0, GLuint );
     303        GLuint index = READ_DATA(0, GLuint);
    304304        const GLushort *v = DATA_POINTER(4, const GLushort);
    305         cr_unpackDispatch.VertexAttrib4NusvARB( index, v );
    306         INCR_DATA_PTR( 12 );
     305        cr_unpackDispatch.VertexAttrib4NusvARB(index, v);
     306        INCR_DATA_PTR(12);
    307307}
    308308
    309309void crUnpackVertexAttrib4bvARB(void)
    310310{
    311         GLuint index = READ_DATA( 0, GLuint );
     311        GLuint index = READ_DATA(0, GLuint);
    312312        const GLbyte *v = DATA_POINTER(4, const GLbyte);
    313         cr_unpackDispatch.VertexAttrib4bvARB( index, v );
    314         INCR_DATA_PTR( 8 );
     313        cr_unpackDispatch.VertexAttrib4bvARB(index, v);
     314        INCR_DATA_PTR(8);
    315315}
    316316
    317317void crUnpackVertexAttrib4ivARB(void)
    318318{
    319         GLuint index = READ_DATA( 0, GLuint );
     319        GLuint index = READ_DATA(0, GLuint);
    320320        const GLint *v = DATA_POINTER(4, const GLint);
    321         cr_unpackDispatch.VertexAttrib4ivARB( index, v );
    322         INCR_DATA_PTR( 20 );
     321        cr_unpackDispatch.VertexAttrib4ivARB(index, v);
     322        INCR_DATA_PTR(20);
    323323}
    324324
    325325void crUnpackVertexAttrib4ubvARB(void)
    326326{
    327         GLuint index = READ_DATA( 0, GLuint );
     327        GLuint index = READ_DATA(0, GLuint);
    328328        const GLubyte *v = DATA_POINTER(4, const GLubyte);
    329         cr_unpackDispatch.VertexAttrib4ubvARB( index, v );
    330         INCR_DATA_PTR( 8 );
     329        cr_unpackDispatch.VertexAttrib4ubvARB(index, v);
     330        INCR_DATA_PTR(8);
    331331}
    332332
    333333void crUnpackVertexAttrib4uivARB(void)
    334334{
    335         GLuint index = READ_DATA( 0, GLuint );
     335        GLuint index = READ_DATA(0, GLuint);
    336336        const GLuint *v = DATA_POINTER(4, const GLuint);
    337         cr_unpackDispatch.VertexAttrib4uivARB( index, v );
    338         INCR_DATA_PTR( 20 );
     337        cr_unpackDispatch.VertexAttrib4uivARB(index, v);
     338        INCR_DATA_PTR(20);
    339339}
    340340
    341341void crUnpackVertexAttrib4usvARB(void)
    342342{
    343         GLuint index = READ_DATA( 0, GLuint );
     343        GLuint index = READ_DATA(0, GLuint);
    344344        const GLushort *v = DATA_POINTER(4, const GLushort);
    345         cr_unpackDispatch.VertexAttrib4usvARB( index, v );
    346         INCR_DATA_PTR( 12 );
    347 }
     345        cr_unpackDispatch.VertexAttrib4usvARB(index, v);
     346        INCR_DATA_PTR(12);
     347}
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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