← Back to branch summary

~ubuntu-branches/ubuntu/raring/virtualbox-ose/raring

« back to all changes in this revision

Viewing changes to src/VBox/GuestHost/OpenGL/packer/pack_program.c

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2011-01-30 23:27:25 UTC
  • mfrom: (0.3.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20110130232725-2ouajjd2ggdet0zd
Tags: 4.0.2-dfsg-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - Add Apport hook.
    - debian/virtualbox-ose.files/source_virtualbox-ose.py
    - debian/virtualbox-ose.install
  - Drop *-source packages.
* Drop ubuntu-01-fix-build-gcc45.patch, fixed upstream.
* Drop ubuntu-02-as-needed.patch, added to the Debian package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/GuestHost/OpenGL/packer/pack_program.c
16
16
 
17
17
void PACK_APIENTRY crPackProgramParameters4dvNV (GLenum target, GLuint index, GLuint num, const GLdouble * params)
18
18
{
19
 
        GET_PACKER_CONTEXT(pc);
20
 
        unsigned char *data_ptr;
21
 
        int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLdouble);
22
 
 
23
 
        GET_BUFFERED_POINTER(pc, packet_length);
24
 
        WRITE_DATA(0, int, packet_length);
25
 
        WRITE_DATA(sizeof(int) + 0, GLenum, target);
26
 
        WRITE_DATA(sizeof(int) + 4, GLuint, index);
27
 
        WRITE_DATA(sizeof(int) + 8, GLuint, num);
28
 
        crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLdouble));
29
 
 
30
 
        WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4DVNV_EXTEND_OPCODE);
 
19
    CR_GET_PACKER_CONTEXT(pc);
 
20
    unsigned char *data_ptr;
 
21
    int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLdouble);
 
22
 
 
23
    CR_GET_BUFFERED_POINTER(pc, packet_length);
 
24
    WRITE_DATA(0, int, packet_length);
 
25
    WRITE_DATA(sizeof(int) + 0, GLenum, target);
 
26
    WRITE_DATA(sizeof(int) + 4, GLuint, index);
 
27
    WRITE_DATA(sizeof(int) + 8, GLuint, num);
 
28
    crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLdouble));
 
29
 
 
30
    WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4DVNV_EXTEND_OPCODE);
 
31
    CR_UNLOCK_PACKER_CONTEXT(pc);
31
32
}
32
33
 
33
34
 
34
35
void PACK_APIENTRY crPackProgramParameters4fvNV (GLenum target, GLuint index, GLuint num, const GLfloat * params)
35
36
{
36
 
        GET_PACKER_CONTEXT(pc);
37
 
        unsigned char *data_ptr;
38
 
        int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLfloat);
39
 
 
40
 
        GET_BUFFERED_POINTER(pc, packet_length);
41
 
        WRITE_DATA(0, int, packet_length);
42
 
        WRITE_DATA(sizeof(int) + 0, GLenum, target);
43
 
        WRITE_DATA(sizeof(int) + 4, GLuint, index);
44
 
        WRITE_DATA(sizeof(int) + 8, GLuint, num);
45
 
        crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLfloat));
46
 
 
47
 
        WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4FVNV_EXTEND_OPCODE);
 
37
    CR_GET_PACKER_CONTEXT(pc);
 
38
    unsigned char *data_ptr;
 
39
    int packet_length = sizeof(int) + sizeof(target) + sizeof(index) + sizeof(num) + num * 4 * sizeof(GLfloat);
 
40
 
 
41
    CR_GET_BUFFERED_POINTER(pc, packet_length);
 
42
    WRITE_DATA(0, int, packet_length);
 
43
    WRITE_DATA(sizeof(int) + 0, GLenum, target);
 
44
    WRITE_DATA(sizeof(int) + 4, GLuint, index);
 
45
    WRITE_DATA(sizeof(int) + 8, GLuint, num);
 
46
    crMemcpy(data_ptr + sizeof(int) + 12, params, num * 4 * sizeof(GLfloat));
 
47
 
 
48
    WRITE_OPCODE(pc, CR_PROGRAMPARAMETERS4FVNV_EXTEND_OPCODE);
 
49
    CR_UNLOCK_PACKER_CONTEXT(pc);
48
50
}
49
51
 
50
52
 
51
53
void PACK_APIENTRY crPackVertexAttribs1dvNV( GLuint index, GLsizei n, const GLdouble *v )
52
54
{
53
 
        GLint i;
54
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
55
 
        for (i = n - 1; i >= 0; i--)
56
 
                crPackVertexAttrib1dvARB(index + i, v + i);
 
55
    GLint i;
 
56
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
57
    for (i = n - 1; i >= 0; i--)
 
58
        crPackVertexAttrib1dvARB(index + i, v + i);
57
59
}
58
60
 
59
61
 
60
62
void PACK_APIENTRY crPackVertexAttribs1fvNV( GLuint index, GLsizei n, const GLfloat *v )
61
63
{
62
 
        GLint i;
63
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
64
 
        for (i = n - 1; i >= 0; i--)
65
 
                crPackVertexAttrib1fvARB(index + i, v + i);
 
64
    GLint i;
 
65
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
66
    for (i = n - 1; i >= 0; i--)
 
67
        crPackVertexAttrib1fvARB(index + i, v + i);
66
68
}
67
69
 
68
70
 
69
71
void PACK_APIENTRY crPackVertexAttribs1svNV( GLuint index, GLsizei n, const GLshort *v )
70
72
{
71
 
        GLint i;
72
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
73
 
        for (i = n - 1; i >= 0; i--)
74
 
                crPackVertexAttrib1svARB(index + i, v + i);
 
73
    GLint i;
 
74
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
75
    for (i = n - 1; i >= 0; i--)
 
76
        crPackVertexAttrib1svARB(index + i, v + i);
75
77
}
76
78
 
77
79
 
78
80
void PACK_APIENTRY crPackVertexAttribs2dvNV( GLuint index, GLsizei n, const GLdouble *v )
79
81
{
80
 
        GLint i;
81
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
82
 
        for (i = n - 1; i >= 0; i--)
83
 
                crPackVertexAttrib2dvARB(index + i, v + 2 * i);
 
82
    GLint i;
 
83
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
84
    for (i = n - 1; i >= 0; i--)
 
85
        crPackVertexAttrib2dvARB(index + i, v + 2 * i);
84
86
}
85
87
 
86
88
void PACK_APIENTRY crPackVertexAttribs2fvNV( GLuint index, GLsizei n, const GLfloat *v )
87
89
{
88
 
        GLint i;
89
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
90
 
        for (i = n - 1; i >= 0; i--)
91
 
                crPackVertexAttrib2fvARB(index + i, v + 2 * i);
 
90
    GLint i;
 
91
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
92
    for (i = n - 1; i >= 0; i--)
 
93
        crPackVertexAttrib2fvARB(index + i, v + 2 * i);
92
94
}
93
95
 
94
96
void PACK_APIENTRY crPackVertexAttribs2svNV( GLuint index, GLsizei n, const GLshort *v )
95
97
{
96
 
        GLint i;
97
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
98
 
        for (i = n - 1; i >= 0; i--)
99
 
                crPackVertexAttrib2svARB(index + i, v + 2 * i);
 
98
    GLint i;
 
99
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
100
    for (i = n - 1; i >= 0; i--)
 
101
        crPackVertexAttrib2svARB(index + i, v + 2 * i);
100
102
}
101
103
 
102
104
void PACK_APIENTRY crPackVertexAttribs3dvNV( GLuint index, GLsizei n, const GLdouble *v )
103
105
{
104
 
        GLint i;
105
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
106
 
        for (i = n - 1; i >= 0; i--)
107
 
                crPackVertexAttrib3dvARB(index + i, v + 3 * i);
 
106
    GLint i;
 
107
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
108
    for (i = n - 1; i >= 0; i--)
 
109
        crPackVertexAttrib3dvARB(index + i, v + 3 * i);
108
110
}
109
111
 
110
112
void PACK_APIENTRY crPackVertexAttribs3fvNV( GLuint index, GLsizei n, const GLfloat *v )
111
113
{
112
 
        GLint i;
113
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
114
 
        for (i = n - 1; i >= 0; i--)
115
 
                crPackVertexAttrib3fvARB(index + i, v + 3 * i);
 
114
    GLint i;
 
115
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
116
    for (i = n - 1; i >= 0; i--)
 
117
        crPackVertexAttrib3fvARB(index + i, v + 3 * i);
116
118
}
117
119
 
118
120
void PACK_APIENTRY crPackVertexAttribs3svNV( GLuint index, GLsizei n, const GLshort *v )
119
121
{
120
 
        GLint i;
121
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
122
 
        for (i = n - 1; i >= 0; i--)
123
 
                crPackVertexAttrib3svARB(index + i, v + 3 * i);
 
122
    GLint i;
 
123
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
124
    for (i = n - 1; i >= 0; i--)
 
125
        crPackVertexAttrib3svARB(index + i, v + 3 * i);
124
126
}
125
127
 
126
128
void PACK_APIENTRY crPackVertexAttribs4dvNV( GLuint index, GLsizei n, const GLdouble *v )
127
129
{
128
 
        GLint i;
129
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
130
 
        for (i = n - 1; i >= 0; i--)
131
 
                crPackVertexAttrib4dvARB(index + i, v + 4 * i);
 
130
    GLint i;
 
131
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
132
    for (i = n - 1; i >= 0; i--)
 
133
        crPackVertexAttrib4dvARB(index + i, v + 4 * i);
132
134
}
133
135
 
134
136
void PACK_APIENTRY crPackVertexAttribs4fvNV( GLuint index, GLsizei n, const GLfloat *v )
135
137
{
136
 
        GLint i;
137
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
138
 
        for (i = n - 1; i >= 0; i--)
139
 
                crPackVertexAttrib4fvARB(index + i, v + 4 * i);
 
138
    GLint i;
 
139
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
140
    for (i = n - 1; i >= 0; i--)
 
141
        crPackVertexAttrib4fvARB(index + i, v + 4 * i);
140
142
}
141
143
 
142
144
void PACK_APIENTRY crPackVertexAttribs4svNV( GLuint index, GLsizei n, const GLshort *v )
143
145
{
144
 
        GLint i;
145
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
146
 
        for (i = n - 1; i >= 0; i--)
147
 
                crPackVertexAttrib4svARB(index + i, v + 4 * i);
 
146
    GLint i;
 
147
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
148
    for (i = n - 1; i >= 0; i--)
 
149
        crPackVertexAttrib4svARB(index + i, v + 4 * i);
148
150
}
149
151
 
150
152
void PACK_APIENTRY crPackVertexAttribs4ubvNV( GLuint index, GLsizei n, const GLubyte *v )
151
153
{
152
 
        GLint i;
153
 
        /* reverse order so we hit index 0 last (provoking glVertex) */
154
 
        for (i = n - 1; i >= 0; i--)
155
 
                crPackVertexAttrib4ubvARB(index + i, v + 4 * i);
 
154
    GLint i;
 
155
    /* reverse order so we hit index 0 last (provoking glVertex) */
 
156
    for (i = n - 1; i >= 0; i--)
 
157
        crPackVertexAttrib4ubvARB(index + i, v + 4 * i);
156
158
}
157
159
 
158
160
 
159
161
void PACK_APIENTRY crPackExecuteProgramNV( GLenum target, GLuint id, const GLfloat *params )
160
162
{
161
 
        const int packet_length = 32;
162
 
        unsigned char *data_ptr;
163
 
        GET_PACKER_CONTEXT(pc);
 
163
    const int packet_length = 32;
 
164
    unsigned char *data_ptr;
 
165
    CR_GET_PACKER_CONTEXT(pc);
164
166
 
165
 
        GET_BUFFERED_POINTER(pc, packet_length);
166
 
        WRITE_DATA(0, int, packet_length);
167
 
        WRITE_DATA(4, GLenum, CR_EXECUTEPROGRAMNV_EXTEND_OPCODE);
168
 
        WRITE_DATA(8, GLenum, target);
169
 
        WRITE_DATA(12, GLuint, id);
170
 
        WRITE_DATA(16, GLfloat, params[0] );
171
 
        WRITE_DATA(20, GLfloat, params[1] );
172
 
        WRITE_DATA(24, GLfloat, params[2] );
173
 
        WRITE_DATA(28, GLfloat, params[3] );
174
 
        WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
167
    CR_GET_BUFFERED_POINTER(pc, packet_length);
 
168
    WRITE_DATA(0, int, packet_length);
 
169
    WRITE_DATA(4, GLenum, CR_EXECUTEPROGRAMNV_EXTEND_OPCODE);
 
170
    WRITE_DATA(8, GLenum, target);
 
171
    WRITE_DATA(12, GLuint, id);
 
172
    WRITE_DATA(16, GLfloat, params[0] );
 
173
    WRITE_DATA(20, GLfloat, params[1] );
 
174
    WRITE_DATA(24, GLfloat, params[2] );
 
175
    WRITE_DATA(28, GLfloat, params[3] );
 
176
    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
177
    CR_UNLOCK_PACKER_CONTEXT(pc);
175
178
}
176
179
 
177
180
void PACK_APIENTRY crPackLoadProgramNV( GLenum target, GLuint id, GLsizei len, const GLubyte *program )
178
181
{
179
 
        const int packet_length = 20 + len;
180
 
        unsigned char *data_ptr;
181
 
        GET_PACKER_CONTEXT(pc);
 
182
    const int packet_length = 20 + len;
 
183
    unsigned char *data_ptr;
 
184
    CR_GET_PACKER_CONTEXT(pc);
182
185
 
183
 
        GET_BUFFERED_POINTER(pc, packet_length);
184
 
        WRITE_DATA(0, int, packet_length);
185
 
        WRITE_DATA(4, GLenum, CR_LOADPROGRAMNV_EXTEND_OPCODE);
186
 
        WRITE_DATA(8, GLenum, target);
187
 
        WRITE_DATA(12, GLuint, id);
188
 
        WRITE_DATA(16, GLsizei, len );
189
 
        crMemcpy( (void *) (data_ptr + 20), program, len );
190
 
        WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
186
    CR_GET_BUFFERED_POINTER(pc, packet_length);
 
187
    WRITE_DATA(0, int, packet_length);
 
188
    WRITE_DATA(4, GLenum, CR_LOADPROGRAMNV_EXTEND_OPCODE);
 
189
    WRITE_DATA(8, GLenum, target);
 
190
    WRITE_DATA(12, GLuint, id);
 
191
    WRITE_DATA(16, GLsizei, len );
 
192
    crMemcpy( (void *) (data_ptr + 20), program, len );
 
193
    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
194
    CR_UNLOCK_PACKER_CONTEXT(pc);
191
195
}
192
196
 
193
197
void PACK_APIENTRY crPackRequestResidentProgramsNV( GLsizei n, const GLuint *ids )
194
198
{
195
 
        GET_PACKER_CONTEXT(pc);
196
 
        (void) pc;
197
 
        (void) n;
198
 
        (void) ids;
199
 
        /* We're no-op'ing this function for now. */
 
199
    CR_GET_PACKER_CONTEXT(pc);
 
200
    (void) pc;
 
201
    (void) n;
 
202
    (void) ids;
 
203
    /* We're no-op'ing this function for now. */
200
204
}
201
205
 
202
206
 
203
207
void PACK_APIENTRY crPackProgramNamedParameter4fNV (GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
204
208
{
205
 
        GET_PACKER_CONTEXT(pc);
206
 
        unsigned char *data_ptr;
207
 
        int packet_length = 32 + len;
 
209
    CR_GET_PACKER_CONTEXT(pc);
 
210
    unsigned char *data_ptr;
 
211
    int packet_length = 32 + len;
208
212
 
209
 
        GET_BUFFERED_POINTER(pc, packet_length);
210
 
        WRITE_DATA(0, GLint, packet_length);
211
 
        WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4FNV_EXTEND_OPCODE);
212
 
        WRITE_DATA(8, GLuint, id);
213
 
        WRITE_DATA(12, GLsizei, len);
214
 
        WRITE_DATA(16, GLfloat, x);
215
 
        WRITE_DATA(20, GLfloat, y);
216
 
        WRITE_DATA(24, GLfloat, z);
217
 
        WRITE_DATA(28, GLfloat, w);
218
 
        crMemcpy( (void *) (data_ptr + 32), name, len );
219
 
        WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
213
    CR_GET_BUFFERED_POINTER(pc, packet_length);
 
214
    WRITE_DATA(0, GLint, packet_length);
 
215
    WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4FNV_EXTEND_OPCODE);
 
216
    WRITE_DATA(8, GLuint, id);
 
217
    WRITE_DATA(12, GLsizei, len);
 
218
    WRITE_DATA(16, GLfloat, x);
 
219
    WRITE_DATA(20, GLfloat, y);
 
220
    WRITE_DATA(24, GLfloat, z);
 
221
    WRITE_DATA(28, GLfloat, w);
 
222
    crMemcpy( (void *) (data_ptr + 32), name, len );
 
223
    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
224
    CR_UNLOCK_PACKER_CONTEXT(pc);
220
225
}
221
226
 
222
227
void PACK_APIENTRY crPackProgramNamedParameter4dNV (GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
223
228
{
224
 
        GET_PACKER_CONTEXT(pc);
225
 
        unsigned char *data_ptr;
226
 
        int packet_length = 48 + len;
227
 
 
228
 
        GET_BUFFERED_POINTER(pc, packet_length);
229
 
        WRITE_DATA(0, GLint, packet_length);
230
 
        WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4DNV_EXTEND_OPCODE);
231
 
        WRITE_DATA(8, GLenum, id);
232
 
        WRITE_DATA(12, GLuint, len);
233
 
        WRITE_DOUBLE(16, x);
234
 
        WRITE_DOUBLE(24, y);
235
 
        WRITE_DOUBLE(32, z);
236
 
        WRITE_DOUBLE(40, w);
237
 
        crMemcpy( (void *) (data_ptr + 48), name, len );
238
 
 
239
 
        WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
229
    CR_GET_PACKER_CONTEXT(pc);
 
230
    unsigned char *data_ptr;
 
231
    int packet_length = 48 + len;
 
232
 
 
233
    CR_GET_BUFFERED_POINTER(pc, packet_length);
 
234
    WRITE_DATA(0, GLint, packet_length);
 
235
    WRITE_DATA(4, GLenum, CR_PROGRAMNAMEDPARAMETER4DNV_EXTEND_OPCODE);
 
236
    WRITE_DATA(8, GLenum, id);
 
237
    WRITE_DATA(12, GLuint, len);
 
238
    WRITE_DOUBLE(16, x);
 
239
    WRITE_DOUBLE(24, y);
 
240
    WRITE_DOUBLE(32, z);
 
241
    WRITE_DOUBLE(40, w);
 
242
    crMemcpy( (void *) (data_ptr + 48), name, len );
 
243
 
 
244
    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
245
    CR_UNLOCK_PACKER_CONTEXT(pc);
240
246
}
241
247
 
242
248
void PACK_APIENTRY crPackProgramNamedParameter4fvNV (GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
243
249
{
244
 
        crPackProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
 
250
    crPackProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
245
251
}
246
252
 
247
253
void PACK_APIENTRY crPackProgramNamedParameter4dvNV (GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
248
254
{
249
 
        crPackProgramNamedParameter4dNV(id, len, name, v[0], v[1], v[2], v[3]);
 
255
    crPackProgramNamedParameter4dNV(id, len, name, v[0], v[1], v[2], v[3]);
250
256
}
251
257
 
252
258
 
253
259
void PACK_APIENTRY
254
260
crPackAreProgramsResidentNV(GLsizei n, const GLuint * programs,
255
 
                                                                                                                GLboolean *residences, GLboolean *return_val,
256
 
                                                                                                                int *writeback)
 
261
                                                        GLboolean *residences, GLboolean *return_val,
 
262
                                                        int *writeback)
257
263
{
258
 
        GET_PACKER_CONTEXT(pc);
259
 
        unsigned char *data_ptr;
260
 
        int packet_length;
261
 
 
262
 
        (void) return_val; /* Caller must compute this from residences!!! */
263
 
 
264
 
        packet_length = sizeof(int) +   /* packet length */
265
 
                sizeof(GLenum) +                                                /* extend opcode */
266
 
                sizeof(n) +                                                                     /* num programs */
267
 
                n * sizeof(*programs) +                 /* programs */
268
 
                8 + 8;
269
 
 
270
 
        GET_BUFFERED_POINTER(pc, packet_length);
271
 
        WRITE_DATA(0, int, packet_length);
272
 
        WRITE_DATA(4, GLenum, CR_AREPROGRAMSRESIDENTNV_EXTEND_OPCODE);
273
 
        WRITE_DATA(8, GLsizei, n);
274
 
        crMemcpy(data_ptr + 12, programs, n * sizeof(*programs));
275
 
        WRITE_NETWORK_POINTER(12 + n * sizeof(*programs),       (void *) residences);
276
 
        WRITE_NETWORK_POINTER(20 + n * sizeof(*programs), (void *) writeback);
277
 
        WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
264
    CR_GET_PACKER_CONTEXT(pc);
 
265
    unsigned char *data_ptr;
 
266
    int packet_length;
 
267
 
 
268
    (void) return_val; /* Caller must compute this from residences!!! */
 
269
 
 
270
    packet_length = sizeof(int) +   /* packet length */
 
271
        sizeof(GLenum) +                        /* extend opcode */
 
272
        sizeof(n) +                                 /* num programs */
 
273
        n * sizeof(*programs) +         /* programs */
 
274
        8 + 8;
 
275
 
 
276
    CR_GET_BUFFERED_POINTER(pc, packet_length);
 
277
    WRITE_DATA(0, int, packet_length);
 
278
    WRITE_DATA(4, GLenum, CR_AREPROGRAMSRESIDENTNV_EXTEND_OPCODE);
 
279
    WRITE_DATA(8, GLsizei, n);
 
280
    crMemcpy(data_ptr + 12, programs, n * sizeof(*programs));
 
281
    WRITE_NETWORK_POINTER(12 + n * sizeof(*programs),   (void *) residences);
 
282
    WRITE_NETWORK_POINTER(20 + n * sizeof(*programs), (void *) writeback);
 
283
    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
284
    CR_UNLOCK_PACKER_CONTEXT(pc);
278
285
}
279
286
 
280
287
 
281
288
void PACK_APIENTRY crPackGetProgramNamedParameterfvNV( GLuint id, GLsizei len, const GLubyte *name, GLfloat *params, int *writeback )
282
289
{
283
 
        int packet_length = 32 + len;
284
 
        GET_PACKER_CONTEXT(pc);
285
 
        unsigned char *data_ptr;
286
 
        GET_BUFFERED_POINTER( pc, packet_length );
287
 
        WRITE_DATA( 0, GLint, packet_length );
288
 
        WRITE_DATA( 4, GLenum, CR_GETPROGRAMNAMEDPARAMETERFVNV_EXTEND_OPCODE );
289
 
        WRITE_DATA( 8, GLuint, id );
290
 
        WRITE_DATA( 12, GLsizei, len );
291
 
        crMemcpy(data_ptr + 16, name, len);
292
 
        WRITE_NETWORK_POINTER( 16 + len, (void *) params );
293
 
        WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
294
 
        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
 
290
    int packet_length = 32 + len;
 
291
    CR_GET_PACKER_CONTEXT(pc);
 
292
    unsigned char *data_ptr;
 
293
    CR_GET_BUFFERED_POINTER( pc, packet_length );
 
294
    WRITE_DATA( 0, GLint, packet_length );
 
295
    WRITE_DATA( 4, GLenum, CR_GETPROGRAMNAMEDPARAMETERFVNV_EXTEND_OPCODE );
 
296
    WRITE_DATA( 8, GLuint, id );
 
297
    WRITE_DATA( 12, GLsizei, len );
 
298
    crMemcpy(data_ptr + 16, name, len);
 
299
    WRITE_NETWORK_POINTER( 16 + len, (void *) params );
 
300
    WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
 
301
    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
 
302
    CR_UNLOCK_PACKER_CONTEXT(pc);
295
303
}
296
304
 
297
305
void PACK_APIENTRY crPackGetProgramNamedParameterdvNV( GLuint id, GLsizei len, const GLubyte *name, GLdouble *params, int *writeback )
298
306
{
299
 
        int packet_length = 32 + len;
300
 
        GET_PACKER_CONTEXT(pc);
301
 
        unsigned char *data_ptr;
302
 
        GET_BUFFERED_POINTER( pc, packet_length );
303
 
        WRITE_DATA( 0, GLint, packet_length );
304
 
        WRITE_DATA( 4, GLenum, CR_GETPROGRAMNAMEDPARAMETERDVNV_EXTEND_OPCODE );
305
 
        WRITE_DATA( 8, GLuint, id );
306
 
        WRITE_DATA( 12, GLsizei, len );
307
 
        crMemcpy(data_ptr + 16, name, len);
308
 
        WRITE_NETWORK_POINTER( 16 + len, (void *) params );
309
 
        WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
310
 
        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
 
307
    int packet_length = 32 + len;
 
308
    CR_GET_PACKER_CONTEXT(pc);
 
309
    unsigned char *data_ptr;
 
310
    CR_GET_BUFFERED_POINTER( pc, packet_length );
 
311
    WRITE_DATA( 0, GLint, packet_length );
 
312
    WRITE_DATA( 4, GLenum, CR_GETPROGRAMNAMEDPARAMETERDVNV_EXTEND_OPCODE );
 
313
    WRITE_DATA( 8, GLuint, id );
 
314
    WRITE_DATA( 12, GLsizei, len );
 
315
    crMemcpy(data_ptr + 16, name, len);
 
316
    WRITE_NETWORK_POINTER( 16 + len, (void *) params );
 
317
    WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
 
318
    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
 
319
    CR_UNLOCK_PACKER_CONTEXT(pc);
311
320
}
312
321
 
313
322
 
314
323
void PACK_APIENTRY crPackDeleteProgramsARB( GLsizei n, const GLuint *ids )
315
324
{
316
 
        unsigned char *data_ptr;
317
 
        int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*ids);
318
 
 
319
 
        if (!ids)
320
 
                return;
321
 
 
322
 
        data_ptr = (unsigned char *) crPackAlloc(packet_length);
323
 
        WRITE_DATA( 0, GLenum, CR_DELETEPROGRAMSARB_EXTEND_OPCODE );
324
 
        WRITE_DATA( 4, GLsizei, n );
325
 
        crMemcpy( data_ptr + 8, ids, n * sizeof(*ids) );
326
 
        crHugePacket( CR_EXTEND_OPCODE, data_ptr );
327
 
        crPackFree( data_ptr );
 
325
    unsigned char *data_ptr;
 
326
    int packet_length = sizeof(GLenum) + sizeof(n) + n * sizeof(*ids);
 
327
 
 
328
    if (!ids)
 
329
        return;
 
330
 
 
331
    data_ptr = (unsigned char *) crPackAlloc(packet_length);
 
332
    WRITE_DATA( 0, GLenum, CR_DELETEPROGRAMSARB_EXTEND_OPCODE );
 
333
    WRITE_DATA( 4, GLsizei, n );
 
334
    crMemcpy( data_ptr + 8, ids, n * sizeof(*ids) );
 
335
    crHugePacket( CR_EXTEND_OPCODE, data_ptr );
 
336
    crPackFree( data_ptr );
328
337
}
329
338
 
330
339
 
331
340
void PACK_APIENTRY  crPackProgramStringARB( GLenum target, GLenum format, GLsizei len, const void *string )
332
341
{
333
 
        const int packet_length = 20 + len;
334
 
        unsigned char *data_ptr;
335
 
        GET_PACKER_CONTEXT(pc);
 
342
    const int packet_length = 20 + len;
 
343
    unsigned char *data_ptr;
 
344
    CR_GET_PACKER_CONTEXT(pc);
336
345
 
337
 
        GET_BUFFERED_POINTER(pc, packet_length);
338
 
        WRITE_DATA(0, int, packet_length);
339
 
        WRITE_DATA(4, GLenum, CR_PROGRAMSTRINGARB_EXTEND_OPCODE);
340
 
        WRITE_DATA(8, GLenum, target);
341
 
        WRITE_DATA(12, GLuint, format);
342
 
        WRITE_DATA(16, GLsizei, len );
343
 
        crMemcpy( (void *) (data_ptr + 20), string, len );
344
 
        WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
346
    CR_GET_BUFFERED_POINTER(pc, packet_length);
 
347
    WRITE_DATA(0, int, packet_length);
 
348
    WRITE_DATA(4, GLenum, CR_PROGRAMSTRINGARB_EXTEND_OPCODE);
 
349
    WRITE_DATA(8, GLenum, target);
 
350
    WRITE_DATA(12, GLuint, format);
 
351
    WRITE_DATA(16, GLsizei, len );
 
352
    crMemcpy( (void *) (data_ptr + 20), string, len );
 
353
    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
 
354
    CR_UNLOCK_PACKER_CONTEXT(pc);
345
355
}
346
356
 
347
357
 
352
362
 
353
363
void PACK_APIENTRY crPackVertexAttrib4NbvARB( GLuint index, const GLbyte *v )
354
364
{
355
 
        GET_PACKER_CONTEXT(pc);
356
 
        unsigned char *data_ptr;
357
 
        (void) pc;
358
 
        GET_BUFFERED_POINTER( pc, 8 );
359
 
        pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
360
 
        pc->current.attribsUsedMask |= (1 << index);
361
 
        WRITE_DATA( 0, GLuint, index );
362
 
        WRITE_DATA( 4, GLbyte, v[0] );
363
 
        WRITE_DATA( 5, GLbyte, v[1] );
364
 
        WRITE_DATA( 6, GLbyte, v[2] );
365
 
        WRITE_DATA( 7, GLbyte, v[3] );
366
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4NBVARB_OPCODE );
 
365
    CR_GET_PACKER_CONTEXT(pc);
 
366
    unsigned char *data_ptr;
 
367
    CR_GET_BUFFERED_POINTER( pc, 8 );
 
368
    pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
 
369
    pc->current.attribsUsedMask |= (1 << index);
 
370
    WRITE_DATA( 0, GLuint, index );
 
371
    WRITE_DATA( 4, GLbyte, v[0] );
 
372
    WRITE_DATA( 5, GLbyte, v[1] );
 
373
    WRITE_DATA( 6, GLbyte, v[2] );
 
374
    WRITE_DATA( 7, GLbyte, v[3] );
 
375
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NBVARB_OPCODE );
 
376
    CR_UNLOCK_PACKER_CONTEXT(pc);
367
377
}
368
378
 
369
379
void PACK_APIENTRY crPackVertexAttrib4NivARB( GLuint index, const GLint *v )
370
380
{
371
 
        GET_PACKER_CONTEXT(pc);
372
 
        unsigned char *data_ptr;
373
 
        (void) pc;
374
 
        GET_BUFFERED_POINTER( pc, 20 );
375
 
        pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
376
 
        pc->current.attribsUsedMask |= (1 << index);
377
 
        WRITE_DATA( 0, GLuint, index );
378
 
        WRITE_DATA( 4, GLint, v[0] );
379
 
        WRITE_DATA( 8, GLint, v[1] );
380
 
        WRITE_DATA( 12, GLint, v[2] );
381
 
        WRITE_DATA( 16, GLint, v[3] );
382
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4NIVARB_OPCODE );
 
381
    CR_GET_PACKER_CONTEXT(pc);
 
382
    unsigned char *data_ptr;
 
383
    CR_GET_BUFFERED_POINTER( pc, 20 );
 
384
    pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
 
385
    pc->current.attribsUsedMask |= (1 << index);
 
386
    WRITE_DATA( 0, GLuint, index );
 
387
    WRITE_DATA( 4, GLint, v[0] );
 
388
    WRITE_DATA( 8, GLint, v[1] );
 
389
    WRITE_DATA( 12, GLint, v[2] );
 
390
    WRITE_DATA( 16, GLint, v[3] );
 
391
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NIVARB_OPCODE );
 
392
    CR_UNLOCK_PACKER_CONTEXT(pc);
383
393
}
384
394
 
385
395
void PACK_APIENTRY crPackVertexAttrib4NsvARB( GLuint index, const GLshort *v )
386
396
{
387
 
        GET_PACKER_CONTEXT(pc);
388
 
        unsigned char *data_ptr;
389
 
        (void) pc;
390
 
        GET_BUFFERED_POINTER( pc, 12 );
391
 
        pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
392
 
        pc->current.attribsUsedMask |= (1 << index);
393
 
        WRITE_DATA( 0, GLuint, index );
394
 
        WRITE_DATA( 4, GLshort, v[0] );
395
 
        WRITE_DATA( 6, GLshort, v[1] );
396
 
        WRITE_DATA( 8, GLshort, v[2] );
397
 
        WRITE_DATA( 10, GLshort, v[3] );
398
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4NSVARB_OPCODE );
 
397
    CR_GET_PACKER_CONTEXT(pc);
 
398
    unsigned char *data_ptr;
 
399
    CR_GET_BUFFERED_POINTER( pc, 12 );
 
400
    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
 
401
    pc->current.attribsUsedMask |= (1 << index);
 
402
    WRITE_DATA( 0, GLuint, index );
 
403
    WRITE_DATA( 4, GLshort, v[0] );
 
404
    WRITE_DATA( 6, GLshort, v[1] );
 
405
    WRITE_DATA( 8, GLshort, v[2] );
 
406
    WRITE_DATA( 10, GLshort, v[3] );
 
407
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NSVARB_OPCODE );
 
408
    CR_UNLOCK_PACKER_CONTEXT(pc);
399
409
}
400
410
 
401
411
void PACK_APIENTRY crPackVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
402
412
{
403
 
        GET_PACKER_CONTEXT(pc);
404
 
        unsigned char *data_ptr;
405
 
        (void) pc;
406
 
        GET_BUFFERED_POINTER( pc, 8 );
407
 
        pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
408
 
        pc->current.attribsUsedMask |= (1 << index);
409
 
        WRITE_DATA( 0, GLuint, index );
410
 
        WRITE_DATA( 4, GLubyte, v[0] );
411
 
        WRITE_DATA( 5, GLubyte, v[1] );
412
 
        WRITE_DATA( 6, GLubyte, v[2] );
413
 
        WRITE_DATA( 7, GLubyte, v[3] );
414
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUBVARB_OPCODE );
 
413
    CR_GET_PACKER_CONTEXT(pc);
 
414
    unsigned char *data_ptr;
 
415
    CR_GET_BUFFERED_POINTER( pc, 8 );
 
416
    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
 
417
    pc->current.attribsUsedMask |= (1 << index);
 
418
    WRITE_DATA( 0, GLuint, index );
 
419
    WRITE_DATA( 4, GLubyte, v[0] );
 
420
    WRITE_DATA( 5, GLubyte, v[1] );
 
421
    WRITE_DATA( 6, GLubyte, v[2] );
 
422
    WRITE_DATA( 7, GLubyte, v[3] );
 
423
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUBVARB_OPCODE );
 
424
    CR_UNLOCK_PACKER_CONTEXT(pc);
415
425
}
416
426
 
417
427
void PACK_APIENTRY crPackVertexAttrib4NuivARB(GLuint index, const GLuint * v)
418
428
{
419
 
        GET_PACKER_CONTEXT(pc);
420
 
        unsigned char *data_ptr;
421
 
        (void) pc;
422
 
        GET_BUFFERED_POINTER( pc, 20 );
423
 
        pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
424
 
        pc->current.attribsUsedMask |= (1 << index);
425
 
        WRITE_DATA( 0, GLuint, index );
426
 
        WRITE_DATA( 4, GLuint, v[0] );
427
 
        WRITE_DATA( 8, GLuint, v[1] );
428
 
        WRITE_DATA( 12, GLuint, v[2] );
429
 
        WRITE_DATA( 16, GLuint, v[3] );
430
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUIVARB_OPCODE );
 
429
    CR_GET_PACKER_CONTEXT(pc);
 
430
    unsigned char *data_ptr;
 
431
    CR_GET_BUFFERED_POINTER( pc, 20 );
 
432
    pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
 
433
    pc->current.attribsUsedMask |= (1 << index);
 
434
    WRITE_DATA( 0, GLuint, index );
 
435
    WRITE_DATA( 4, GLuint, v[0] );
 
436
    WRITE_DATA( 8, GLuint, v[1] );
 
437
    WRITE_DATA( 12, GLuint, v[2] );
 
438
    WRITE_DATA( 16, GLuint, v[3] );
 
439
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUIVARB_OPCODE );
 
440
    CR_UNLOCK_PACKER_CONTEXT(pc);
431
441
}
432
442
 
433
443
void PACK_APIENTRY crPackVertexAttrib4NusvARB(GLuint index, const GLushort * v)
434
444
{
435
 
        GET_PACKER_CONTEXT(pc);
436
 
        unsigned char *data_ptr;
437
 
        (void) pc;
438
 
        GET_BUFFERED_POINTER( pc, 12 );
439
 
        pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
440
 
        pc->current.attribsUsedMask |= (1 << index);
441
 
        WRITE_DATA( 0, GLuint, index );
442
 
        WRITE_DATA( 4, GLushort, v[0] );
443
 
        WRITE_DATA( 6, GLushort, v[1] );
444
 
        WRITE_DATA( 8, GLushort, v[2] );
445
 
        WRITE_DATA( 10, GLushort, v[3] );
446
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUSVARB_OPCODE );
 
445
    CR_GET_PACKER_CONTEXT(pc);
 
446
    unsigned char *data_ptr;
 
447
    CR_GET_BUFFERED_POINTER( pc, 12 );
 
448
    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
 
449
    pc->current.attribsUsedMask |= (1 << index);
 
450
    WRITE_DATA( 0, GLuint, index );
 
451
    WRITE_DATA( 4, GLushort, v[0] );
 
452
    WRITE_DATA( 6, GLushort, v[1] );
 
453
    WRITE_DATA( 8, GLushort, v[2] );
 
454
    WRITE_DATA( 10, GLushort, v[3] );
 
455
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4NUSVARB_OPCODE );
 
456
    CR_UNLOCK_PACKER_CONTEXT(pc);
447
457
}
448
458
 
449
459
void PACK_APIENTRY crPackVertexAttrib4bvARB(GLuint index, const GLbyte * v)
450
460
{
451
 
        GET_PACKER_CONTEXT(pc);
452
 
        unsigned char *data_ptr;
453
 
        (void) pc;
454
 
        GET_BUFFERED_POINTER( pc, 8 );
455
 
        pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
456
 
        pc->current.attribsUsedMask |= (1 << index);
457
 
        WRITE_DATA( 0, GLuint, index );
458
 
        WRITE_DATA( 4, GLbyte, v[0] );
459
 
        WRITE_DATA( 5, GLbyte, v[1] );
460
 
        WRITE_DATA( 6, GLbyte, v[2] );
461
 
        WRITE_DATA( 7, GLbyte, v[3] );
462
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4BVARB_OPCODE );
 
461
    CR_GET_PACKER_CONTEXT(pc);
 
462
    unsigned char *data_ptr;
 
463
    CR_GET_BUFFERED_POINTER( pc, 8 );
 
464
    pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
 
465
    pc->current.attribsUsedMask |= (1 << index);
 
466
    WRITE_DATA( 0, GLuint, index );
 
467
    WRITE_DATA( 4, GLbyte, v[0] );
 
468
    WRITE_DATA( 5, GLbyte, v[1] );
 
469
    WRITE_DATA( 6, GLbyte, v[2] );
 
470
    WRITE_DATA( 7, GLbyte, v[3] );
 
471
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4BVARB_OPCODE );
 
472
    CR_UNLOCK_PACKER_CONTEXT(pc);
463
473
}
464
474
 
465
475
void PACK_APIENTRY crPackVertexAttrib4ivARB(GLuint index, const GLint * v)
466
476
{
467
 
        GET_PACKER_CONTEXT(pc);
468
 
        unsigned char *data_ptr;
469
 
        (void) pc;
470
 
        GET_BUFFERED_POINTER( pc, 20 );
471
 
        pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
472
 
        pc->current.attribsUsedMask |= (1 << index);
473
 
        WRITE_DATA( 0, GLuint, index );
474
 
        WRITE_DATA( 4, GLint, v[0] );
475
 
        WRITE_DATA( 8, GLint, v[1] );
476
 
        WRITE_DATA( 12, GLint, v[2] );
477
 
        WRITE_DATA( 16, GLint, v[3] );
478
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4IVARB_OPCODE );
 
477
    CR_GET_PACKER_CONTEXT(pc);
 
478
    unsigned char *data_ptr;
 
479
    CR_GET_BUFFERED_POINTER( pc, 20 );
 
480
    pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
 
481
    pc->current.attribsUsedMask |= (1 << index);
 
482
    WRITE_DATA( 0, GLuint, index );
 
483
    WRITE_DATA( 4, GLint, v[0] );
 
484
    WRITE_DATA( 8, GLint, v[1] );
 
485
    WRITE_DATA( 12, GLint, v[2] );
 
486
    WRITE_DATA( 16, GLint, v[3] );
 
487
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4IVARB_OPCODE );
 
488
    CR_UNLOCK_PACKER_CONTEXT(pc);
479
489
}
480
490
 
481
491
void PACK_APIENTRY crPackVertexAttrib4uivARB(GLuint index, const GLuint * v)
482
492
{
483
 
        GET_PACKER_CONTEXT(pc);
484
 
        unsigned char *data_ptr;
485
 
        (void) pc;
486
 
        GET_BUFFERED_POINTER( pc, 20 );
487
 
        pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
488
 
        pc->current.attribsUsedMask |= (1 << index);
489
 
        WRITE_DATA( 0, GLuint, index );
490
 
        WRITE_DATA( 4, GLuint, v[0] );
491
 
        WRITE_DATA( 8, GLuint, v[1] );
492
 
        WRITE_DATA( 12, GLuint, v[2] );
493
 
        WRITE_DATA( 16, GLuint, v[3] );
494
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4UIVARB_OPCODE );
 
493
    CR_GET_PACKER_CONTEXT(pc);
 
494
    unsigned char *data_ptr;
 
495
    CR_GET_BUFFERED_POINTER( pc, 20 );
 
496
    pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
 
497
    pc->current.attribsUsedMask |= (1 << index);
 
498
    WRITE_DATA( 0, GLuint, index );
 
499
    WRITE_DATA( 4, GLuint, v[0] );
 
500
    WRITE_DATA( 8, GLuint, v[1] );
 
501
    WRITE_DATA( 12, GLuint, v[2] );
 
502
    WRITE_DATA( 16, GLuint, v[3] );
 
503
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4UIVARB_OPCODE );
 
504
    CR_UNLOCK_PACKER_CONTEXT(pc);
495
505
}
496
506
 
497
507
void PACK_APIENTRY crPackVertexAttrib4usvARB(GLuint index, const GLushort * v)
498
508
{
499
 
        GET_PACKER_CONTEXT(pc);
500
 
        unsigned char *data_ptr;
501
 
        (void) pc;
502
 
        GET_BUFFERED_POINTER( pc, 12 );
503
 
        pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
504
 
        pc->current.attribsUsedMask |= (1 << index);
505
 
        WRITE_DATA( 0, GLuint, index );
506
 
        WRITE_DATA( 4, GLushort, v[0] );
507
 
        WRITE_DATA( 6, GLushort, v[1] );
508
 
        WRITE_DATA( 8, GLushort, v[2] );
509
 
        WRITE_DATA( 10, GLushort, v[3] );
510
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4USVARB_OPCODE );
 
509
    CR_GET_PACKER_CONTEXT(pc);
 
510
    unsigned char *data_ptr;
 
511
    CR_GET_BUFFERED_POINTER( pc, 12 );
 
512
    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
 
513
    pc->current.attribsUsedMask |= (1 << index);
 
514
    WRITE_DATA( 0, GLuint, index );
 
515
    WRITE_DATA( 4, GLushort, v[0] );
 
516
    WRITE_DATA( 6, GLushort, v[1] );
 
517
    WRITE_DATA( 8, GLushort, v[2] );
 
518
    WRITE_DATA( 10, GLushort, v[3] );
 
519
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4USVARB_OPCODE );
 
520
    CR_UNLOCK_PACKER_CONTEXT(pc);
511
521
}
512
522
 
513
523
 
514
524
void PACK_APIENTRY crPackVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
515
525
{
516
 
        GET_PACKER_CONTEXT(pc);
517
 
        unsigned char *data_ptr;
518
 
        (void) pc;
519
 
        GET_BUFFERED_POINTER( pc, 8 );
520
 
        pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
521
 
        pc->current.attribsUsedMask |= (1 << index);
522
 
        WRITE_DATA( 0, GLuint, index );
523
 
        WRITE_DATA( 4, GLubyte, v[0] );
524
 
        WRITE_DATA( 5, GLubyte, v[1] );
525
 
        WRITE_DATA( 6, GLubyte, v[2] );
526
 
        WRITE_DATA( 7, GLubyte, v[3] );
527
 
        WRITE_OPCODE( pc, CR_VERTEXATTRIB4UBVARB_OPCODE );
 
526
    CR_GET_PACKER_CONTEXT(pc);
 
527
    unsigned char *data_ptr;
 
528
    CR_GET_BUFFERED_POINTER( pc, 8 );
 
529
    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
 
530
    pc->current.attribsUsedMask |= (1 << index);
 
531
    WRITE_DATA( 0, GLuint, index );
 
532
    WRITE_DATA( 4, GLubyte, v[0] );
 
533
    WRITE_DATA( 5, GLubyte, v[1] );
 
534
    WRITE_DATA( 6, GLubyte, v[2] );
 
535
    WRITE_DATA( 7, GLubyte, v[3] );
 
536
    WRITE_OPCODE( pc, CR_VERTEXATTRIB4UBVARB_OPCODE );
 
537
    CR_UNLOCK_PACKER_CONTEXT(pc);
528
538
}
529
539