1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009 VMware, Inc. All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26
27 #include <stdio.h>
28 #include <inttypes.h> /* for PRId64 macro */
29
30 #include "glheader.h"
31 #include "imports.h"
32 #include "bufferobj.h"
33 #include "context.h"
34 #include "enable.h"
35 #include "enums.h"
36 #include "hash.h"
37 #include "image.h"
38 #include "macros.h"
39 #include "mtypes.h"
40 #include "varray.h"
41 #include "arrayobj.h"
42 #include "main/dispatch.h"
43
44
45 /** Used to do error checking for GL_EXT_vertex_array_bgra */
46 #define BGRA_OR_4 5
47
48
49 /** Used to indicate which GL datatypes are accepted by each of the
50 * glVertex/Color/Attrib/EtcPointer() functions.
51 */
52 #define BOOL_BIT (1 << 0)
53 #define BYTE_BIT (1 << 1)
54 #define UNSIGNED_BYTE_BIT (1 << 2)
55 #define SHORT_BIT (1 << 3)
56 #define UNSIGNED_SHORT_BIT (1 << 4)
57 #define INT_BIT (1 << 5)
58 #define UNSIGNED_INT_BIT (1 << 6)
59 #define HALF_BIT (1 << 7)
60 #define FLOAT_BIT (1 << 8)
61 #define DOUBLE_BIT (1 << 9)
62 #define FIXED_ES_BIT (1 << 10)
63 #define FIXED_GL_BIT (1 << 11)
64 #define UNSIGNED_INT_2_10_10_10_REV_BIT (1 << 12)
65 #define INT_2_10_10_10_REV_BIT (1 << 13)
66 #define UNSIGNED_INT_10F_11F_11F_REV_BIT (1 << 14)
67 #define ALL_TYPE_BITS ((1 << 15) - 1)
68
69 #define ATTRIB_FORMAT_TYPES_MASK (BYTE_BIT | UNSIGNED_BYTE_BIT | \
70 SHORT_BIT | UNSIGNED_SHORT_BIT | \
71 INT_BIT | UNSIGNED_INT_BIT | \
72 HALF_BIT | FLOAT_BIT | DOUBLE_BIT | \
73 FIXED_GL_BIT | \
74 UNSIGNED_INT_2_10_10_10_REV_BIT | \
75 INT_2_10_10_10_REV_BIT | \
76 UNSIGNED_INT_10F_11F_11F_REV_BIT)
77
78 #define ATTRIB_IFORMAT_TYPES_MASK (BYTE_BIT | UNSIGNED_BYTE_BIT | \
79 SHORT_BIT | UNSIGNED_SHORT_BIT | \
80 INT_BIT | UNSIGNED_INT_BIT)
81
82 #define ATTRIB_LFORMAT_TYPES_MASK DOUBLE_BIT
83
84
85 /** Convert GL datatype enum into a <type>_BIT value seen above */
86 static GLbitfield
type_to_bit(const struct gl_context * ctx,GLenum type)87 type_to_bit(const struct gl_context *ctx, GLenum type)
88 {
89 switch (type) {
90 case GL_BOOL:
91 return BOOL_BIT;
92 case GL_BYTE:
93 return BYTE_BIT;
94 case GL_UNSIGNED_BYTE:
95 return UNSIGNED_BYTE_BIT;
96 case GL_SHORT:
97 return SHORT_BIT;
98 case GL_UNSIGNED_SHORT:
99 return UNSIGNED_SHORT_BIT;
100 case GL_INT:
101 return INT_BIT;
102 case GL_UNSIGNED_INT:
103 return UNSIGNED_INT_BIT;
104 case GL_HALF_FLOAT:
105 case GL_HALF_FLOAT_OES:
106 if (ctx->Extensions.ARB_half_float_vertex)
107 return HALF_BIT;
108 else
109 return 0x0;
110 case GL_FLOAT:
111 return FLOAT_BIT;
112 case GL_DOUBLE:
113 return DOUBLE_BIT;
114 case GL_FIXED:
115 return _mesa_is_desktop_gl(ctx) ? FIXED_GL_BIT : FIXED_ES_BIT;
116 case GL_UNSIGNED_INT_2_10_10_10_REV:
117 return UNSIGNED_INT_2_10_10_10_REV_BIT;
118 case GL_INT_2_10_10_10_REV:
119 return INT_2_10_10_10_REV_BIT;
120 case GL_UNSIGNED_INT_10F_11F_11F_REV:
121 return UNSIGNED_INT_10F_11F_11F_REV_BIT;
122 default:
123 return 0;
124 }
125 }
126
127
128 /**
129 * Sets the BufferBindingIndex field for the vertex attribute given by
130 * attribIndex.
131 */
132 static void
vertex_attrib_binding(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint attribIndex,GLuint bindingIndex)133 vertex_attrib_binding(struct gl_context *ctx,
134 struct gl_vertex_array_object *vao,
135 GLuint attribIndex,
136 GLuint bindingIndex)
137 {
138 struct gl_array_attributes *array = &vao->VertexAttrib[attribIndex];
139
140 if (!_mesa_is_bufferobj(vao->BufferBinding[bindingIndex].BufferObj))
141 vao->VertexAttribBufferMask &= ~VERT_BIT(attribIndex);
142 else
143 vao->VertexAttribBufferMask |= VERT_BIT(attribIndex);
144
145 if (array->BufferBindingIndex != bindingIndex) {
146 const GLbitfield64 array_bit = VERT_BIT(attribIndex);
147
148 FLUSH_VERTICES(ctx, _NEW_ARRAY);
149
150 vao->BufferBinding[array->BufferBindingIndex]._BoundArrays &= ~array_bit;
151 vao->BufferBinding[bindingIndex]._BoundArrays |= array_bit;
152
153 array->BufferBindingIndex = bindingIndex;
154
155 vao->NewArrays |= array_bit;
156 }
157 }
158
159
160 /**
161 * Binds a buffer object to the vertex buffer binding point given by index,
162 * and sets the Offset and Stride fields.
163 */
164 void
_mesa_bind_vertex_buffer(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint index,struct gl_buffer_object * vbo,GLintptr offset,GLsizei stride)165 _mesa_bind_vertex_buffer(struct gl_context *ctx,
166 struct gl_vertex_array_object *vao,
167 GLuint index,
168 struct gl_buffer_object *vbo,
169 GLintptr offset, GLsizei stride)
170 {
171 struct gl_vertex_buffer_binding *binding = &vao->BufferBinding[index];
172
173 if (binding->BufferObj != vbo ||
174 binding->Offset != offset ||
175 binding->Stride != stride) {
176
177 FLUSH_VERTICES(ctx, _NEW_ARRAY);
178
179 _mesa_reference_buffer_object(ctx, &binding->BufferObj, vbo);
180
181 binding->Offset = offset;
182 binding->Stride = stride;
183
184 if (!_mesa_is_bufferobj(vbo))
185 vao->VertexAttribBufferMask &= ~binding->_BoundArrays;
186 else
187 vao->VertexAttribBufferMask |= binding->_BoundArrays;
188
189 vao->NewArrays |= binding->_BoundArrays;
190 }
191 }
192
193
194 /**
195 * Sets the InstanceDivisor field in the vertex buffer binding point
196 * given by bindingIndex.
197 */
198 static void
vertex_binding_divisor(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint bindingIndex,GLuint divisor)199 vertex_binding_divisor(struct gl_context *ctx,
200 struct gl_vertex_array_object *vao,
201 GLuint bindingIndex,
202 GLuint divisor)
203 {
204 struct gl_vertex_buffer_binding *binding =
205 &vao->BufferBinding[bindingIndex];
206
207 if (binding->InstanceDivisor != divisor) {
208 FLUSH_VERTICES(ctx, _NEW_ARRAY);
209 binding->InstanceDivisor = divisor;
210 vao->NewArrays |= binding->_BoundArrays;
211 }
212 }
213
214
215 /**
216 * Examine the API profile and extensions to determine which types are legal
217 * for vertex arrays. This is called once from update_array_format().
218 */
219 static GLbitfield
get_legal_types_mask(const struct gl_context * ctx)220 get_legal_types_mask(const struct gl_context *ctx)
221 {
222 GLbitfield legalTypesMask = ALL_TYPE_BITS;
223
224 if (_mesa_is_gles(ctx)) {
225 legalTypesMask &= ~(FIXED_GL_BIT |
226 DOUBLE_BIT |
227 UNSIGNED_INT_10F_11F_11F_REV_BIT);
228
229 /* GL_INT and GL_UNSIGNED_INT data is not allowed in OpenGL ES until
230 * 3.0. The 2_10_10_10 types are added in OpenGL ES 3.0 or
231 * GL_OES_vertex_type_10_10_10_2. GL_HALF_FLOAT data is not allowed
232 * until 3.0 or with the GL_OES_vertex_half float extension, which isn't
233 * quite as trivial as we'd like because it uses a different enum value
234 * for GL_HALF_FLOAT_OES.
235 */
236 if (ctx->Version < 30) {
237 legalTypesMask &= ~(UNSIGNED_INT_BIT |
238 INT_BIT |
239 UNSIGNED_INT_2_10_10_10_REV_BIT |
240 INT_2_10_10_10_REV_BIT);
241
242 if (!_mesa_has_OES_vertex_half_float(ctx))
243 legalTypesMask &= ~HALF_BIT;
244 }
245 }
246 else {
247 legalTypesMask &= ~FIXED_ES_BIT;
248
249 if (!ctx->Extensions.ARB_ES2_compatibility)
250 legalTypesMask &= ~FIXED_GL_BIT;
251
252 if (!ctx->Extensions.ARB_vertex_type_2_10_10_10_rev)
253 legalTypesMask &= ~(UNSIGNED_INT_2_10_10_10_REV_BIT |
254 INT_2_10_10_10_REV_BIT);
255
256 if (!ctx->Extensions.ARB_vertex_type_10f_11f_11f_rev)
257 legalTypesMask &= ~UNSIGNED_INT_10F_11F_11F_REV_BIT;
258 }
259
260 return legalTypesMask;
261 }
262
263
264 /**
265 * \param attrib The index of the attribute array
266 * \param size Components per element (1, 2, 3 or 4)
267 * \param type Datatype of each component (GL_FLOAT, GL_INT, etc)
268 * \param format Either GL_RGBA or GL_BGRA.
269 * \param normalized Whether integer types are converted to floats in [-1, 1]
270 * \param integer Integer-valued values (will not be normalized to [-1, 1])
271 * \param doubles Double values not reduced to floats
272 * \param relativeOffset Offset of the first element relative to the binding
273 * offset.
274 * \param flush_verties Should \c FLUSH_VERTICES be invoked before updating
275 * state?
276 */
277 void
_mesa_update_array_format(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint attrib,GLint size,GLenum type,GLenum format,GLboolean normalized,GLboolean integer,GLboolean doubles,GLuint relativeOffset,bool flush_vertices)278 _mesa_update_array_format(struct gl_context *ctx,
279 struct gl_vertex_array_object *vao,
280 GLuint attrib, GLint size, GLenum type,
281 GLenum format, GLboolean normalized,
282 GLboolean integer, GLboolean doubles,
283 GLuint relativeOffset, bool flush_vertices)
284 {
285 struct gl_array_attributes *const array = &vao->VertexAttrib[attrib];
286 GLint elementSize;
287
288 assert(size <= 4);
289
290 if (flush_vertices) {
291 FLUSH_VERTICES(ctx, 0);
292 }
293
294 elementSize = _mesa_bytes_per_vertex_attrib(size, type);
295 assert(elementSize != -1);
296
297 array->Size = size;
298 array->Type = type;
299 array->Format = format;
300 array->Normalized = normalized;
301 array->Integer = integer;
302 array->Doubles = doubles;
303 array->RelativeOffset = relativeOffset;
304 array->_ElementSize = elementSize;
305
306 vao->NewArrays |= VERT_BIT(attrib);
307 ctx->NewState |= _NEW_ARRAY;
308 }
309
310 /**
311 * Does error checking and updates the format in an attrib array.
312 *
313 * Called by update_array() and VertexAttrib*Format().
314 *
315 * \param func Name of calling function used for error reporting
316 * \param attrib The index of the attribute array
317 * \param legalTypes Bitmask of *_BIT above indicating legal datatypes
318 * \param sizeMin Min allowable size value
319 * \param sizeMax Max allowable size value (may also be BGRA_OR_4)
320 * \param size Components per element (1, 2, 3 or 4)
321 * \param type Datatype of each component (GL_FLOAT, GL_INT, etc)
322 * \param normalized Whether integer types are converted to floats in [-1, 1]
323 * \param integer Integer-valued values (will not be normalized to [-1, 1])
324 * \param doubles Double values not reduced to floats
325 * \param relativeOffset Offset of the first element relative to the binding offset.
326 */
327 static bool
update_array_format(struct gl_context * ctx,const char * func,struct gl_vertex_array_object * vao,GLuint attrib,GLbitfield legalTypesMask,GLint sizeMin,GLint sizeMax,GLint size,GLenum type,GLboolean normalized,GLboolean integer,GLboolean doubles,GLuint relativeOffset)328 update_array_format(struct gl_context *ctx,
329 const char *func,
330 struct gl_vertex_array_object *vao,
331 GLuint attrib, GLbitfield legalTypesMask,
332 GLint sizeMin, GLint sizeMax,
333 GLint size, GLenum type,
334 GLboolean normalized, GLboolean integer, GLboolean doubles,
335 GLuint relativeOffset)
336 {
337 GLbitfield typeBit;
338 GLenum format = GL_RGBA;
339
340 /* at most, one of these bools can be true */
341 assert((int) normalized + (int) integer + (int) doubles <= 1);
342
343 if (ctx->Array.LegalTypesMask == 0 || ctx->Array.LegalTypesMaskAPI != ctx->API) {
344 /* Compute the LegalTypesMask only once, unless the context API has
345 * changed, in which case we want to compute it again. We can't do this
346 * in _mesa_init_varrays() below because extensions are not yet enabled
347 * at that point.
348 */
349 ctx->Array.LegalTypesMask = get_legal_types_mask(ctx);
350 ctx->Array.LegalTypesMaskAPI = ctx->API;
351 }
352
353 legalTypesMask &= ctx->Array.LegalTypesMask;
354
355 if (_mesa_is_gles(ctx) && sizeMax == BGRA_OR_4) {
356 /* BGRA ordering is not supported in ES contexts.
357 */
358 sizeMax = 4;
359 }
360
361 typeBit = type_to_bit(ctx, type);
362 if (typeBit == 0x0 || (typeBit & legalTypesMask) == 0x0) {
363 _mesa_error(ctx, GL_INVALID_ENUM, "%s(type = %s)",
364 func, _mesa_enum_to_string(type));
365 return false;
366 }
367
368 /* Do size parameter checking.
369 * If sizeMax = BGRA_OR_4 it means that size = GL_BGRA is legal and
370 * must be handled specially.
371 */
372 if (ctx->Extensions.EXT_vertex_array_bgra &&
373 sizeMax == BGRA_OR_4 &&
374 size == GL_BGRA) {
375 /* Page 298 of the PDF of the OpenGL 4.3 (Core Profile) spec says:
376 *
377 * "An INVALID_OPERATION error is generated under any of the following
378 * conditions:
379 * ...
380 * • size is BGRA and type is not UNSIGNED_BYTE, INT_2_10_10_10_REV
381 * or UNSIGNED_INT_2_10_10_10_REV;
382 * ...
383 * • size is BGRA and normalized is FALSE;"
384 */
385 bool bgra_error = false;
386
387 if (ctx->Extensions.ARB_vertex_type_2_10_10_10_rev) {
388 if (type != GL_UNSIGNED_INT_2_10_10_10_REV &&
389 type != GL_INT_2_10_10_10_REV &&
390 type != GL_UNSIGNED_BYTE)
391 bgra_error = true;
392 } else if (type != GL_UNSIGNED_BYTE)
393 bgra_error = true;
394
395 if (bgra_error) {
396 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(size=GL_BGRA and type=%s)",
397 func, _mesa_enum_to_string(type));
398 return false;
399 }
400
401 if (!normalized) {
402 _mesa_error(ctx, GL_INVALID_OPERATION,
403 "%s(size=GL_BGRA and normalized=GL_FALSE)", func);
404 return false;
405 }
406
407 format = GL_BGRA;
408 size = 4;
409 }
410 else if (size < sizeMin || size > sizeMax || size > 4) {
411 _mesa_error(ctx, GL_INVALID_VALUE, "%s(size=%d)", func, size);
412 return false;
413 }
414
415 if (ctx->Extensions.ARB_vertex_type_2_10_10_10_rev &&
416 (type == GL_UNSIGNED_INT_2_10_10_10_REV ||
417 type == GL_INT_2_10_10_10_REV) && size != 4) {
418 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(size=%d)", func, size);
419 return false;
420 }
421
422 /* The ARB_vertex_attrib_binding_spec says:
423 *
424 * An INVALID_VALUE error is generated if <relativeoffset> is larger than
425 * the value of MAX_VERTEX_ATTRIB_RELATIVE_OFFSET.
426 */
427 if (relativeOffset > ctx->Const.MaxVertexAttribRelativeOffset) {
428 _mesa_error(ctx, GL_INVALID_VALUE,
429 "%s(relativeOffset=%d > "
430 "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET)",
431 func, relativeOffset);
432 return false;
433 }
434
435 if (ctx->Extensions.ARB_vertex_type_10f_11f_11f_rev &&
436 type == GL_UNSIGNED_INT_10F_11F_11F_REV && size != 3) {
437 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(size=%d)", func, size);
438 return false;
439 }
440
441 _mesa_update_array_format(ctx, vao, attrib, size, type, format,
442 normalized, integer, doubles, relativeOffset,
443 false);
444
445 return true;
446 }
447
448
449 /**
450 * Do error checking and update state for glVertex/Color/TexCoord/...Pointer
451 * functions.
452 *
453 * \param func name of calling function used for error reporting
454 * \param attrib the attribute array index to update
455 * \param legalTypes bitmask of *_BIT above indicating legal datatypes
456 * \param sizeMin min allowable size value
457 * \param sizeMax max allowable size value (may also be BGRA_OR_4)
458 * \param size components per element (1, 2, 3 or 4)
459 * \param type datatype of each component (GL_FLOAT, GL_INT, etc)
460 * \param stride stride between elements, in elements
461 * \param normalized are integer types converted to floats in [-1, 1]?
462 * \param integer integer-valued values (will not be normalized to [-1,1])
463 * \param doubles Double values not reduced to floats
464 * \param ptr the address (or offset inside VBO) of the array data
465 */
466 static void
update_array(struct gl_context * ctx,const char * func,GLuint attrib,GLbitfield legalTypesMask,GLint sizeMin,GLint sizeMax,GLint size,GLenum type,GLsizei stride,GLboolean normalized,GLboolean integer,GLboolean doubles,const GLvoid * ptr)467 update_array(struct gl_context *ctx,
468 const char *func,
469 GLuint attrib, GLbitfield legalTypesMask,
470 GLint sizeMin, GLint sizeMax,
471 GLint size, GLenum type, GLsizei stride,
472 GLboolean normalized, GLboolean integer, GLboolean doubles,
473 const GLvoid *ptr)
474 {
475 struct gl_vertex_array_object *vao = ctx->Array.VAO;
476 struct gl_array_attributes *array;
477 GLsizei effectiveStride;
478
479 /* Page 407 (page 423 of the PDF) of the OpenGL 3.0 spec says:
480 *
481 * "Client vertex arrays - all vertex array attribute pointers must
482 * refer to buffer objects (section 2.9.2). The default vertex array
483 * object (the name zero) is also deprecated. Calling
484 * VertexAttribPointer when no buffer object or no vertex array object
485 * is bound will generate an INVALID_OPERATION error..."
486 *
487 * The check for VBOs is handled below.
488 */
489 if (ctx->API == API_OPENGL_CORE && (vao == ctx->Array.DefaultVAO)) {
490 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(no array object bound)",
491 func);
492 return;
493 }
494
495 if (stride < 0) {
496 _mesa_error( ctx, GL_INVALID_VALUE, "%s(stride=%d)", func, stride );
497 return;
498 }
499
500 if (ctx->API == API_OPENGL_CORE && ctx->Version >= 44 &&
501 stride > ctx->Const.MaxVertexAttribStride) {
502 _mesa_error(ctx, GL_INVALID_VALUE, "%s(stride=%d > "
503 "GL_MAX_VERTEX_ATTRIB_STRIDE)", func, stride);
504 return;
505 }
506
507 /* Page 29 (page 44 of the PDF) of the OpenGL 3.3 spec says:
508 *
509 * "An INVALID_OPERATION error is generated under any of the following
510 * conditions:
511 *
512 * ...
513 *
514 * * any of the *Pointer commands specifying the location and
515 * organization of vertex array data are called while zero is bound
516 * to the ARRAY_BUFFER buffer object binding point (see section
517 * 2.9.6), and the pointer argument is not NULL."
518 */
519 if (ptr != NULL && vao->ARBsemantics &&
520 !_mesa_is_bufferobj(ctx->Array.ArrayBufferObj)) {
521 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-VBO array)", func);
522 return;
523 }
524
525 if (!update_array_format(ctx, func, vao, attrib,
526 legalTypesMask, sizeMin, sizeMax,
527 size, type, normalized, integer, doubles, 0)) {
528 return;
529 }
530
531 /* Reset the vertex attrib binding */
532 vertex_attrib_binding(ctx, vao, attrib, attrib);
533
534 /* The Stride and Ptr fields are not set by update_array_format() */
535 array = &vao->VertexAttrib[attrib];
536 array->Stride = stride;
537 array->Ptr = ptr;
538
539 /* Update the vertex buffer binding */
540 effectiveStride = stride != 0 ? stride : array->_ElementSize;
541 _mesa_bind_vertex_buffer(ctx, vao, attrib,
542 ctx->Array.ArrayBufferObj, (GLintptr) ptr,
543 effectiveStride);
544 }
545
546
547 void GLAPIENTRY
_mesa_VertexPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * ptr)548 _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
549 {
550 GET_CURRENT_CONTEXT(ctx);
551 GLbitfield legalTypes = (ctx->API == API_OPENGLES)
552 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
553 : (SHORT_BIT | INT_BIT | FLOAT_BIT |
554 DOUBLE_BIT | HALF_BIT |
555 UNSIGNED_INT_2_10_10_10_REV_BIT |
556 INT_2_10_10_10_REV_BIT);
557
558 FLUSH_VERTICES(ctx, 0);
559
560 update_array(ctx, "glVertexPointer", VERT_ATTRIB_POS,
561 legalTypes, 2, 4,
562 size, type, stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
563 }
564
565
566 void GLAPIENTRY
_mesa_NormalPointer(GLenum type,GLsizei stride,const GLvoid * ptr)567 _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
568 {
569 GET_CURRENT_CONTEXT(ctx);
570 const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
571 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
572 : (BYTE_BIT | SHORT_BIT | INT_BIT |
573 HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
574 UNSIGNED_INT_2_10_10_10_REV_BIT |
575 INT_2_10_10_10_REV_BIT);
576
577 FLUSH_VERTICES(ctx, 0);
578
579 update_array(ctx, "glNormalPointer", VERT_ATTRIB_NORMAL,
580 legalTypes, 3, 3,
581 3, type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
582 }
583
584
585 void GLAPIENTRY
_mesa_ColorPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * ptr)586 _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
587 {
588 GET_CURRENT_CONTEXT(ctx);
589 const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
590 ? (UNSIGNED_BYTE_BIT | HALF_BIT | FLOAT_BIT | FIXED_ES_BIT)
591 : (BYTE_BIT | UNSIGNED_BYTE_BIT |
592 SHORT_BIT | UNSIGNED_SHORT_BIT |
593 INT_BIT | UNSIGNED_INT_BIT |
594 HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
595 UNSIGNED_INT_2_10_10_10_REV_BIT |
596 INT_2_10_10_10_REV_BIT);
597 const GLint sizeMin = (ctx->API == API_OPENGLES) ? 4 : 3;
598
599 FLUSH_VERTICES(ctx, 0);
600
601 update_array(ctx, "glColorPointer", VERT_ATTRIB_COLOR0,
602 legalTypes, sizeMin, BGRA_OR_4,
603 size, type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
604 }
605
606
607 void GLAPIENTRY
_mesa_FogCoordPointer(GLenum type,GLsizei stride,const GLvoid * ptr)608 _mesa_FogCoordPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
609 {
610 const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT);
611 GET_CURRENT_CONTEXT(ctx);
612
613 FLUSH_VERTICES(ctx, 0);
614
615 update_array(ctx, "glFogCoordPointer", VERT_ATTRIB_FOG,
616 legalTypes, 1, 1,
617 1, type, stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
618 }
619
620
621 void GLAPIENTRY
_mesa_IndexPointer(GLenum type,GLsizei stride,const GLvoid * ptr)622 _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
623 {
624 const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | INT_BIT |
625 FLOAT_BIT | DOUBLE_BIT);
626 GET_CURRENT_CONTEXT(ctx);
627
628 FLUSH_VERTICES(ctx, 0);
629
630 update_array(ctx, "glIndexPointer", VERT_ATTRIB_COLOR_INDEX,
631 legalTypes, 1, 1,
632 1, type, stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
633 }
634
635
636 void GLAPIENTRY
_mesa_SecondaryColorPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * ptr)637 _mesa_SecondaryColorPointer(GLint size, GLenum type,
638 GLsizei stride, const GLvoid *ptr)
639 {
640 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
641 SHORT_BIT | UNSIGNED_SHORT_BIT |
642 INT_BIT | UNSIGNED_INT_BIT |
643 HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
644 UNSIGNED_INT_2_10_10_10_REV_BIT |
645 INT_2_10_10_10_REV_BIT);
646 GET_CURRENT_CONTEXT(ctx);
647
648 FLUSH_VERTICES(ctx, 0);
649
650 update_array(ctx, "glSecondaryColorPointer", VERT_ATTRIB_COLOR1,
651 legalTypes, 3, BGRA_OR_4,
652 size, type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
653 }
654
655
656 void GLAPIENTRY
_mesa_TexCoordPointer(GLint size,GLenum type,GLsizei stride,const GLvoid * ptr)657 _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
658 const GLvoid *ptr)
659 {
660 GET_CURRENT_CONTEXT(ctx);
661 GLbitfield legalTypes = (ctx->API == API_OPENGLES)
662 ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
663 : (SHORT_BIT | INT_BIT |
664 HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
665 UNSIGNED_INT_2_10_10_10_REV_BIT |
666 INT_2_10_10_10_REV_BIT);
667 const GLint sizeMin = (ctx->API == API_OPENGLES) ? 2 : 1;
668 const GLuint unit = ctx->Array.ActiveTexture;
669
670 FLUSH_VERTICES(ctx, 0);
671
672 update_array(ctx, "glTexCoordPointer", VERT_ATTRIB_TEX(unit),
673 legalTypes, sizeMin, 4,
674 size, type, stride, GL_FALSE, GL_FALSE, GL_FALSE,
675 ptr);
676 }
677
678
679 void GLAPIENTRY
_mesa_EdgeFlagPointer(GLsizei stride,const GLvoid * ptr)680 _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
681 {
682 const GLbitfield legalTypes = UNSIGNED_BYTE_BIT;
683 /* this is the same type that glEdgeFlag uses */
684 const GLboolean integer = GL_FALSE;
685 GET_CURRENT_CONTEXT(ctx);
686
687 FLUSH_VERTICES(ctx, 0);
688
689 update_array(ctx, "glEdgeFlagPointer", VERT_ATTRIB_EDGEFLAG,
690 legalTypes, 1, 1,
691 1, GL_UNSIGNED_BYTE, stride, GL_FALSE, integer, GL_FALSE, ptr);
692 }
693
694
695 void GLAPIENTRY
_mesa_PointSizePointerOES(GLenum type,GLsizei stride,const GLvoid * ptr)696 _mesa_PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *ptr)
697 {
698 const GLbitfield legalTypes = (FLOAT_BIT | FIXED_ES_BIT);
699 GET_CURRENT_CONTEXT(ctx);
700
701 FLUSH_VERTICES(ctx, 0);
702
703 if (ctx->API != API_OPENGLES) {
704 _mesa_error(ctx, GL_INVALID_OPERATION,
705 "glPointSizePointer(ES 1.x only)");
706 return;
707 }
708
709 update_array(ctx, "glPointSizePointer", VERT_ATTRIB_POINT_SIZE,
710 legalTypes, 1, 1,
711 1, type, stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
712 }
713
714
715 /**
716 * Set a generic vertex attribute array.
717 * Note that these arrays DO NOT alias the conventional GL vertex arrays
718 * (position, normal, color, fog, texcoord, etc).
719 */
720 void GLAPIENTRY
_mesa_VertexAttribPointer(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid * ptr)721 _mesa_VertexAttribPointer(GLuint index, GLint size, GLenum type,
722 GLboolean normalized,
723 GLsizei stride, const GLvoid *ptr)
724 {
725 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
726 SHORT_BIT | UNSIGNED_SHORT_BIT |
727 INT_BIT | UNSIGNED_INT_BIT |
728 HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
729 FIXED_ES_BIT | FIXED_GL_BIT |
730 UNSIGNED_INT_2_10_10_10_REV_BIT |
731 INT_2_10_10_10_REV_BIT |
732 UNSIGNED_INT_10F_11F_11F_REV_BIT);
733 GET_CURRENT_CONTEXT(ctx);
734
735 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
736 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(index)");
737 return;
738 }
739
740 update_array(ctx, "glVertexAttribPointer", VERT_ATTRIB_GENERIC(index),
741 legalTypes, 1, BGRA_OR_4,
742 size, type, stride, normalized, GL_FALSE, GL_FALSE, ptr);
743 }
744
745
746 /**
747 * GL_EXT_gpu_shader4 / GL 3.0.
748 * Set an integer-valued vertex attribute array.
749 * Note that these arrays DO NOT alias the conventional GL vertex arrays
750 * (position, normal, color, fog, texcoord, etc).
751 */
752 void GLAPIENTRY
_mesa_VertexAttribIPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid * ptr)753 _mesa_VertexAttribIPointer(GLuint index, GLint size, GLenum type,
754 GLsizei stride, const GLvoid *ptr)
755 {
756 const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
757 SHORT_BIT | UNSIGNED_SHORT_BIT |
758 INT_BIT | UNSIGNED_INT_BIT);
759 const GLboolean normalized = GL_FALSE;
760 const GLboolean integer = GL_TRUE;
761 GET_CURRENT_CONTEXT(ctx);
762
763 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
764 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribIPointer(index)");
765 return;
766 }
767
768 update_array(ctx, "glVertexAttribIPointer", VERT_ATTRIB_GENERIC(index),
769 legalTypes, 1, 4,
770 size, type, stride, normalized, integer, GL_FALSE, ptr);
771 }
772
773 void GLAPIENTRY
_mesa_VertexAttribLPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid * ptr)774 _mesa_VertexAttribLPointer(GLuint index, GLint size, GLenum type,
775 GLsizei stride, const GLvoid *ptr)
776 {
777 GET_CURRENT_CONTEXT(ctx);
778 const GLbitfield legalTypes = (DOUBLE_BIT);
779 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
780 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribLPointer(index)");
781 return;
782 }
783
784 update_array(ctx, "glVertexAttribLPointer", VERT_ATTRIB_GENERIC(index),
785 legalTypes, 1, 4,
786 size, type, stride, GL_FALSE, GL_FALSE, GL_TRUE, ptr);
787 }
788
789
790 void
_mesa_enable_vertex_array_attrib(struct gl_context * ctx,struct gl_vertex_array_object * vao,unsigned attrib)791 _mesa_enable_vertex_array_attrib(struct gl_context *ctx,
792 struct gl_vertex_array_object *vao,
793 unsigned attrib)
794 {
795 assert(attrib < ARRAY_SIZE(vao->VertexAttrib));
796
797 if (!vao->VertexAttrib[attrib].Enabled) {
798 /* was disabled, now being enabled */
799 FLUSH_VERTICES(ctx, _NEW_ARRAY);
800 vao->VertexAttrib[attrib].Enabled = GL_TRUE;
801 vao->_Enabled |= VERT_BIT(attrib);
802 vao->NewArrays |= VERT_BIT(attrib);
803 }
804 }
805
806 static void
enable_vertex_array_attrib(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint index,const char * func)807 enable_vertex_array_attrib(struct gl_context *ctx,
808 struct gl_vertex_array_object *vao,
809 GLuint index,
810 const char *func)
811 {
812 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
813 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index)", func);
814 return;
815 }
816
817 _mesa_enable_vertex_array_attrib(ctx, vao, VERT_ATTRIB_GENERIC(index));
818 }
819
820
821 void GLAPIENTRY
_mesa_EnableVertexAttribArray(GLuint index)822 _mesa_EnableVertexAttribArray(GLuint index)
823 {
824 GET_CURRENT_CONTEXT(ctx);
825 enable_vertex_array_attrib(ctx, ctx->Array.VAO, index,
826 "glEnableVertexAttribArray");
827 }
828
829
830 void GLAPIENTRY
_mesa_EnableVertexArrayAttrib(GLuint vaobj,GLuint index)831 _mesa_EnableVertexArrayAttrib(GLuint vaobj, GLuint index)
832 {
833 GET_CURRENT_CONTEXT(ctx);
834 struct gl_vertex_array_object *vao;
835
836 /* The ARB_direct_state_access specification says:
837 *
838 * "An INVALID_OPERATION error is generated by EnableVertexArrayAttrib
839 * and DisableVertexArrayAttrib if <vaobj> is not
840 * [compatibility profile: zero or] the name of an existing vertex
841 * array object."
842 */
843 vao = _mesa_lookup_vao_err(ctx, vaobj, "glEnableVertexArrayAttrib");
844 if (!vao)
845 return;
846
847 enable_vertex_array_attrib(ctx, vao, index, "glEnableVertexArrayAttrib");
848 }
849
850
851 static void
disable_vertex_array_attrib(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint index,const char * func)852 disable_vertex_array_attrib(struct gl_context *ctx,
853 struct gl_vertex_array_object *vao,
854 GLuint index,
855 const char *func)
856 {
857 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
858 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index)", func);
859 return;
860 }
861
862 assert(VERT_ATTRIB_GENERIC(index) < ARRAY_SIZE(vao->VertexAttrib));
863
864 if (vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled) {
865 /* was enabled, now being disabled */
866 FLUSH_VERTICES(ctx, _NEW_ARRAY);
867 vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled = GL_FALSE;
868 vao->_Enabled &= ~VERT_BIT_GENERIC(index);
869 vao->NewArrays |= VERT_BIT_GENERIC(index);
870 }
871 }
872
873
874 void GLAPIENTRY
_mesa_DisableVertexAttribArray(GLuint index)875 _mesa_DisableVertexAttribArray(GLuint index)
876 {
877 GET_CURRENT_CONTEXT(ctx);
878 disable_vertex_array_attrib(ctx, ctx->Array.VAO, index,
879 "glDisableVertexAttribArray");
880 }
881
882
883 void GLAPIENTRY
_mesa_DisableVertexArrayAttrib(GLuint vaobj,GLuint index)884 _mesa_DisableVertexArrayAttrib(GLuint vaobj, GLuint index)
885 {
886 GET_CURRENT_CONTEXT(ctx);
887 struct gl_vertex_array_object *vao;
888
889 /* The ARB_direct_state_access specification says:
890 *
891 * "An INVALID_OPERATION error is generated by EnableVertexArrayAttrib
892 * and DisableVertexArrayAttrib if <vaobj> is not
893 * [compatibility profile: zero or] the name of an existing vertex
894 * array object."
895 */
896 vao = _mesa_lookup_vao_err(ctx, vaobj, "glDisableVertexArrayAttrib");
897 if (!vao)
898 return;
899
900 disable_vertex_array_attrib(ctx, vao, index, "glDisableVertexArrayAttrib");
901 }
902
903
904 /**
905 * Return info for a vertex attribute array (no alias with legacy
906 * vertex attributes (pos, normal, color, etc)). This function does
907 * not handle the 4-element GL_CURRENT_VERTEX_ATTRIB_ARB query.
908 */
909 static GLuint
get_vertex_array_attrib(struct gl_context * ctx,const struct gl_vertex_array_object * vao,GLuint index,GLenum pname,const char * caller)910 get_vertex_array_attrib(struct gl_context *ctx,
911 const struct gl_vertex_array_object *vao,
912 GLuint index, GLenum pname,
913 const char *caller)
914 {
915 const struct gl_array_attributes *array;
916
917 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
918 _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)", caller, index);
919 return 0;
920 }
921
922 assert(VERT_ATTRIB_GENERIC(index) < ARRAY_SIZE(vao->VertexAttrib));
923
924 array = &vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)];
925
926 switch (pname) {
927 case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
928 return array->Enabled;
929 case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
930 return (array->Format == GL_BGRA) ? GL_BGRA : array->Size;
931 case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
932 return array->Stride;
933 case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
934 return array->Type;
935 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
936 return array->Normalized;
937 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB:
938 return vao->BufferBinding[array->BufferBindingIndex].BufferObj->Name;
939 case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
940 if ((_mesa_is_desktop_gl(ctx)
941 && (ctx->Version >= 30 || ctx->Extensions.EXT_gpu_shader4))
942 || _mesa_is_gles3(ctx)) {
943 return array->Integer;
944 }
945 goto error;
946 case GL_VERTEX_ATTRIB_ARRAY_LONG:
947 if (_mesa_is_desktop_gl(ctx)) {
948 return array->Doubles;
949 }
950 goto error;
951 case GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB:
952 if ((_mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_instanced_arrays)
953 || _mesa_is_gles3(ctx)) {
954 return vao->BufferBinding[array->BufferBindingIndex].InstanceDivisor;
955 }
956 goto error;
957 case GL_VERTEX_ATTRIB_BINDING:
958 if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles31(ctx)) {
959 return array->BufferBindingIndex - VERT_ATTRIB_GENERIC0;
960 }
961 goto error;
962 case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
963 if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles31(ctx)) {
964 return array->RelativeOffset;
965 }
966 goto error;
967 default:
968 ; /* fall-through */
969 }
970
971 error:
972 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=0x%x)", caller, pname);
973 return 0;
974 }
975
976
977 static const GLfloat *
get_current_attrib(struct gl_context * ctx,GLuint index,const char * function)978 get_current_attrib(struct gl_context *ctx, GLuint index, const char *function)
979 {
980 if (index == 0) {
981 if (_mesa_attr_zero_aliases_vertex(ctx)) {
982 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(index==0)", function);
983 return NULL;
984 }
985 }
986 else if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
987 _mesa_error(ctx, GL_INVALID_VALUE,
988 "%s(index>=GL_MAX_VERTEX_ATTRIBS)", function);
989 return NULL;
990 }
991
992 assert(VERT_ATTRIB_GENERIC(index) <
993 ARRAY_SIZE(ctx->Array.VAO->VertexAttrib));
994
995 FLUSH_CURRENT(ctx, 0);
996 return ctx->Current.Attrib[VERT_ATTRIB_GENERIC(index)];
997 }
998
999 void GLAPIENTRY
_mesa_GetVertexAttribfv(GLuint index,GLenum pname,GLfloat * params)1000 _mesa_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
1001 {
1002 GET_CURRENT_CONTEXT(ctx);
1003
1004 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
1005 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribfv");
1006 if (v != NULL) {
1007 COPY_4V(params, v);
1008 }
1009 }
1010 else {
1011 params[0] = (GLfloat) get_vertex_array_attrib(ctx, ctx->Array.VAO,
1012 index, pname,
1013 "glGetVertexAttribfv");
1014 }
1015 }
1016
1017
1018 void GLAPIENTRY
_mesa_GetVertexAttribdv(GLuint index,GLenum pname,GLdouble * params)1019 _mesa_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
1020 {
1021 GET_CURRENT_CONTEXT(ctx);
1022
1023 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
1024 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribdv");
1025 if (v != NULL) {
1026 params[0] = (GLdouble) v[0];
1027 params[1] = (GLdouble) v[1];
1028 params[2] = (GLdouble) v[2];
1029 params[3] = (GLdouble) v[3];
1030 }
1031 }
1032 else {
1033 params[0] = (GLdouble) get_vertex_array_attrib(ctx, ctx->Array.VAO,
1034 index, pname,
1035 "glGetVertexAttribdv");
1036 }
1037 }
1038
1039 void GLAPIENTRY
_mesa_GetVertexAttribLdv(GLuint index,GLenum pname,GLdouble * params)1040 _mesa_GetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
1041 {
1042 GET_CURRENT_CONTEXT(ctx);
1043
1044 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
1045 const GLdouble *v =
1046 (const GLdouble *)get_current_attrib(ctx, index,
1047 "glGetVertexAttribLdv");
1048 if (v != NULL) {
1049 params[0] = v[0];
1050 params[1] = v[1];
1051 params[2] = v[2];
1052 params[3] = v[3];
1053 }
1054 }
1055 else {
1056 params[0] = (GLdouble) get_vertex_array_attrib(ctx, ctx->Array.VAO,
1057 index, pname,
1058 "glGetVertexAttribLdv");
1059 }
1060 }
1061
1062 void GLAPIENTRY
_mesa_GetVertexAttribiv(GLuint index,GLenum pname,GLint * params)1063 _mesa_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
1064 {
1065 GET_CURRENT_CONTEXT(ctx);
1066
1067 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
1068 const GLfloat *v = get_current_attrib(ctx, index, "glGetVertexAttribiv");
1069 if (v != NULL) {
1070 /* XXX should floats in[0,1] be scaled to full int range? */
1071 params[0] = (GLint) v[0];
1072 params[1] = (GLint) v[1];
1073 params[2] = (GLint) v[2];
1074 params[3] = (GLint) v[3];
1075 }
1076 }
1077 else {
1078 params[0] = (GLint) get_vertex_array_attrib(ctx, ctx->Array.VAO,
1079 index, pname,
1080 "glGetVertexAttribiv");
1081 }
1082 }
1083
1084
1085 /** GL 3.0 */
1086 void GLAPIENTRY
_mesa_GetVertexAttribIiv(GLuint index,GLenum pname,GLint * params)1087 _mesa_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
1088 {
1089 GET_CURRENT_CONTEXT(ctx);
1090
1091 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
1092 const GLint *v = (const GLint *)
1093 get_current_attrib(ctx, index, "glGetVertexAttribIiv");
1094 if (v != NULL) {
1095 COPY_4V(params, v);
1096 }
1097 }
1098 else {
1099 params[0] = (GLint) get_vertex_array_attrib(ctx, ctx->Array.VAO,
1100 index, pname,
1101 "glGetVertexAttribIiv");
1102 }
1103 }
1104
1105
1106 /** GL 3.0 */
1107 void GLAPIENTRY
_mesa_GetVertexAttribIuiv(GLuint index,GLenum pname,GLuint * params)1108 _mesa_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
1109 {
1110 GET_CURRENT_CONTEXT(ctx);
1111
1112 if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
1113 const GLuint *v = (const GLuint *)
1114 get_current_attrib(ctx, index, "glGetVertexAttribIuiv");
1115 if (v != NULL) {
1116 COPY_4V(params, v);
1117 }
1118 }
1119 else {
1120 params[0] = get_vertex_array_attrib(ctx, ctx->Array.VAO,
1121 index, pname,
1122 "glGetVertexAttribIuiv");
1123 }
1124 }
1125
1126
1127 void GLAPIENTRY
_mesa_GetVertexAttribPointerv(GLuint index,GLenum pname,GLvoid ** pointer)1128 _mesa_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer)
1129 {
1130 GET_CURRENT_CONTEXT(ctx);
1131
1132 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
1133 _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribPointerARB(index)");
1134 return;
1135 }
1136
1137 if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB) {
1138 _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribPointerARB(pname)");
1139 return;
1140 }
1141
1142 assert(VERT_ATTRIB_GENERIC(index) <
1143 ARRAY_SIZE(ctx->Array.VAO->VertexAttrib));
1144
1145 *pointer = (GLvoid *)
1146 ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Ptr;
1147 }
1148
1149
1150 /** ARB_direct_state_access */
1151 void GLAPIENTRY
_mesa_GetVertexArrayIndexediv(GLuint vaobj,GLuint index,GLenum pname,GLint * params)1152 _mesa_GetVertexArrayIndexediv(GLuint vaobj, GLuint index,
1153 GLenum pname, GLint *params)
1154 {
1155 GET_CURRENT_CONTEXT(ctx);
1156 struct gl_vertex_array_object *vao;
1157
1158 /* The ARB_direct_state_access specification says:
1159 *
1160 * "An INVALID_OPERATION error is generated if <vaobj> is not
1161 * [compatibility profile: zero or] the name of an existing
1162 * vertex array object."
1163 */
1164 vao = _mesa_lookup_vao_err(ctx, vaobj, "glGetVertexArrayIndexediv");
1165 if (!vao)
1166 return;
1167
1168 /* The ARB_direct_state_access specification says:
1169 *
1170 * "For GetVertexArrayIndexediv, <pname> must be one of
1171 * VERTEX_ATTRIB_ARRAY_ENABLED, VERTEX_ATTRIB_ARRAY_SIZE,
1172 * VERTEX_ATTRIB_ARRAY_STRIDE, VERTEX_ATTRIB_ARRAY_TYPE,
1173 * VERTEX_ATTRIB_ARRAY_NORMALIZED, VERTEX_ATTRIB_ARRAY_INTEGER,
1174 * VERTEX_ATTRIB_ARRAY_LONG, VERTEX_ATTRIB_ARRAY_DIVISOR, or
1175 * VERTEX_ATTRIB_RELATIVE_OFFSET."
1176 *
1177 * and:
1178 *
1179 * "Add GetVertexArrayIndexediv in 'Get Command' for
1180 * VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
1181 * VERTEX_ATTRIB_BINDING,
1182 * VERTEX_ATTRIB_RELATIVE_OFFSET,
1183 * VERTEX_BINDING_OFFSET, and
1184 * VERTEX_BINDING_STRIDE states"
1185 *
1186 * The only parameter name common to both lists is
1187 * VERTEX_ATTRIB_RELATIVE_OFFSET. Also note that VERTEX_BINDING_BUFFER
1188 * and VERTEX_BINDING_DIVISOR are missing from both lists. It seems
1189 * pretty clear however that the intent is that it should be possible
1190 * to query all vertex attrib and binding states that can be set with
1191 * a DSA function.
1192 */
1193 switch (pname) {
1194 case GL_VERTEX_BINDING_OFFSET:
1195 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset;
1196 break;
1197 case GL_VERTEX_BINDING_STRIDE:
1198 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Stride;
1199 break;
1200 case GL_VERTEX_BINDING_DIVISOR:
1201 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].InstanceDivisor;
1202 break;
1203 case GL_VERTEX_BINDING_BUFFER:
1204 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].BufferObj->Name;
1205 break;
1206 default:
1207 params[0] = get_vertex_array_attrib(ctx, vao, index, pname,
1208 "glGetVertexArrayIndexediv");
1209 break;
1210 }
1211 }
1212
1213
1214 void GLAPIENTRY
_mesa_GetVertexArrayIndexed64iv(GLuint vaobj,GLuint index,GLenum pname,GLint64 * params)1215 _mesa_GetVertexArrayIndexed64iv(GLuint vaobj, GLuint index,
1216 GLenum pname, GLint64 *params)
1217 {
1218 GET_CURRENT_CONTEXT(ctx);
1219 struct gl_vertex_array_object *vao;
1220
1221 /* The ARB_direct_state_access specification says:
1222 *
1223 * "An INVALID_OPERATION error is generated if <vaobj> is not
1224 * [compatibility profile: zero or] the name of an existing
1225 * vertex array object."
1226 */
1227 vao = _mesa_lookup_vao_err(ctx, vaobj, "glGetVertexArrayIndexed64iv");
1228 if (!vao)
1229 return;
1230
1231 /* The ARB_direct_state_access specification says:
1232 *
1233 * "For GetVertexArrayIndexed64iv, <pname> must be
1234 * VERTEX_BINDING_OFFSET."
1235 *
1236 * and:
1237 *
1238 * "An INVALID_ENUM error is generated if <pname> is not one of
1239 * the valid values listed above for the corresponding command."
1240 */
1241 if (pname != GL_VERTEX_BINDING_OFFSET) {
1242 _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexArrayIndexed64iv("
1243 "pname != GL_VERTEX_BINDING_OFFSET)");
1244 return;
1245 }
1246
1247 /* The ARB_direct_state_access specification says:
1248 *
1249 * "An INVALID_VALUE error is generated if <index> is greater than
1250 * or equal to the value of MAX_VERTEX_ATTRIBS."
1251 *
1252 * Since the index refers to a buffer binding in this case, the intended
1253 * limit must be MAX_VERTEX_ATTRIB_BINDINGS. Both limits are currently
1254 * required to be the same, so in practice this doesn't matter.
1255 */
1256 if (index >= ctx->Const.MaxVertexAttribBindings) {
1257 _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexArrayIndexed64iv(index"
1258 "%d >= the value of GL_MAX_VERTEX_ATTRIB_BINDINGS (%d))",
1259 index, ctx->Const.MaxVertexAttribBindings);
1260 return;
1261 }
1262
1263 params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset;
1264 }
1265
1266
1267 void GLAPIENTRY
_mesa_VertexPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid * ptr)1268 _mesa_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
1269 GLsizei count, const GLvoid *ptr)
1270 {
1271 (void) count;
1272 _mesa_VertexPointer(size, type, stride, ptr);
1273 }
1274
1275
1276 void GLAPIENTRY
_mesa_NormalPointerEXT(GLenum type,GLsizei stride,GLsizei count,const GLvoid * ptr)1277 _mesa_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
1278 const GLvoid *ptr)
1279 {
1280 (void) count;
1281 _mesa_NormalPointer(type, stride, ptr);
1282 }
1283
1284
1285 void GLAPIENTRY
_mesa_ColorPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid * ptr)1286 _mesa_ColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count,
1287 const GLvoid *ptr)
1288 {
1289 (void) count;
1290 _mesa_ColorPointer(size, type, stride, ptr);
1291 }
1292
1293
1294 void GLAPIENTRY
_mesa_IndexPointerEXT(GLenum type,GLsizei stride,GLsizei count,const GLvoid * ptr)1295 _mesa_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
1296 const GLvoid *ptr)
1297 {
1298 (void) count;
1299 _mesa_IndexPointer(type, stride, ptr);
1300 }
1301
1302
1303 void GLAPIENTRY
_mesa_TexCoordPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid * ptr)1304 _mesa_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
1305 GLsizei count, const GLvoid *ptr)
1306 {
1307 (void) count;
1308 _mesa_TexCoordPointer(size, type, stride, ptr);
1309 }
1310
1311
1312 void GLAPIENTRY
_mesa_EdgeFlagPointerEXT(GLsizei stride,GLsizei count,const GLboolean * ptr)1313 _mesa_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr)
1314 {
1315 (void) count;
1316 _mesa_EdgeFlagPointer(stride, ptr);
1317 }
1318
1319
1320 void GLAPIENTRY
_mesa_InterleavedArrays(GLenum format,GLsizei stride,const GLvoid * pointer)1321 _mesa_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
1322 {
1323 GET_CURRENT_CONTEXT(ctx);
1324 GLboolean tflag, cflag, nflag; /* enable/disable flags */
1325 GLint tcomps, ccomps, vcomps; /* components per texcoord, color, vertex */
1326 GLenum ctype = 0; /* color type */
1327 GLint coffset = 0, noffset = 0, voffset;/* color, normal, vertex offsets */
1328 const GLint toffset = 0; /* always zero */
1329 GLint defstride; /* default stride */
1330 GLint c, f;
1331
1332 FLUSH_VERTICES(ctx, 0);
1333
1334 f = sizeof(GLfloat);
1335 c = f * ((4 * sizeof(GLubyte) + (f - 1)) / f);
1336
1337 if (stride < 0) {
1338 _mesa_error( ctx, GL_INVALID_VALUE, "glInterleavedArrays(stride)" );
1339 return;
1340 }
1341
1342 switch (format) {
1343 case GL_V2F:
1344 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_FALSE;
1345 tcomps = 0; ccomps = 0; vcomps = 2;
1346 voffset = 0;
1347 defstride = 2*f;
1348 break;
1349 case GL_V3F:
1350 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_FALSE;
1351 tcomps = 0; ccomps = 0; vcomps = 3;
1352 voffset = 0;
1353 defstride = 3*f;
1354 break;
1355 case GL_C4UB_V2F:
1356 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE;
1357 tcomps = 0; ccomps = 4; vcomps = 2;
1358 ctype = GL_UNSIGNED_BYTE;
1359 coffset = 0;
1360 voffset = c;
1361 defstride = c + 2*f;
1362 break;
1363 case GL_C4UB_V3F:
1364 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE;
1365 tcomps = 0; ccomps = 4; vcomps = 3;
1366 ctype = GL_UNSIGNED_BYTE;
1367 coffset = 0;
1368 voffset = c;
1369 defstride = c + 3*f;
1370 break;
1371 case GL_C3F_V3F:
1372 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_FALSE;
1373 tcomps = 0; ccomps = 3; vcomps = 3;
1374 ctype = GL_FLOAT;
1375 coffset = 0;
1376 voffset = 3*f;
1377 defstride = 6*f;
1378 break;
1379 case GL_N3F_V3F:
1380 tflag = GL_FALSE; cflag = GL_FALSE; nflag = GL_TRUE;
1381 tcomps = 0; ccomps = 0; vcomps = 3;
1382 noffset = 0;
1383 voffset = 3*f;
1384 defstride = 6*f;
1385 break;
1386 case GL_C4F_N3F_V3F:
1387 tflag = GL_FALSE; cflag = GL_TRUE; nflag = GL_TRUE;
1388 tcomps = 0; ccomps = 4; vcomps = 3;
1389 ctype = GL_FLOAT;
1390 coffset = 0;
1391 noffset = 4*f;
1392 voffset = 7*f;
1393 defstride = 10*f;
1394 break;
1395 case GL_T2F_V3F:
1396 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_FALSE;
1397 tcomps = 2; ccomps = 0; vcomps = 3;
1398 voffset = 2*f;
1399 defstride = 5*f;
1400 break;
1401 case GL_T4F_V4F:
1402 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_FALSE;
1403 tcomps = 4; ccomps = 0; vcomps = 4;
1404 voffset = 4*f;
1405 defstride = 8*f;
1406 break;
1407 case GL_T2F_C4UB_V3F:
1408 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_FALSE;
1409 tcomps = 2; ccomps = 4; vcomps = 3;
1410 ctype = GL_UNSIGNED_BYTE;
1411 coffset = 2*f;
1412 voffset = c+2*f;
1413 defstride = c+5*f;
1414 break;
1415 case GL_T2F_C3F_V3F:
1416 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_FALSE;
1417 tcomps = 2; ccomps = 3; vcomps = 3;
1418 ctype = GL_FLOAT;
1419 coffset = 2*f;
1420 voffset = 5*f;
1421 defstride = 8*f;
1422 break;
1423 case GL_T2F_N3F_V3F:
1424 tflag = GL_TRUE; cflag = GL_FALSE; nflag = GL_TRUE;
1425 tcomps = 2; ccomps = 0; vcomps = 3;
1426 noffset = 2*f;
1427 voffset = 5*f;
1428 defstride = 8*f;
1429 break;
1430 case GL_T2F_C4F_N3F_V3F:
1431 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_TRUE;
1432 tcomps = 2; ccomps = 4; vcomps = 3;
1433 ctype = GL_FLOAT;
1434 coffset = 2*f;
1435 noffset = 6*f;
1436 voffset = 9*f;
1437 defstride = 12*f;
1438 break;
1439 case GL_T4F_C4F_N3F_V4F:
1440 tflag = GL_TRUE; cflag = GL_TRUE; nflag = GL_TRUE;
1441 tcomps = 4; ccomps = 4; vcomps = 4;
1442 ctype = GL_FLOAT;
1443 coffset = 4*f;
1444 noffset = 8*f;
1445 voffset = 11*f;
1446 defstride = 15*f;
1447 break;
1448 default:
1449 _mesa_error( ctx, GL_INVALID_ENUM, "glInterleavedArrays(format)" );
1450 return;
1451 }
1452
1453 if (stride==0) {
1454 stride = defstride;
1455 }
1456
1457 _mesa_DisableClientState( GL_EDGE_FLAG_ARRAY );
1458 _mesa_DisableClientState( GL_INDEX_ARRAY );
1459 /* XXX also disable secondary color and generic arrays? */
1460
1461 /* Texcoords */
1462 if (tflag) {
1463 _mesa_EnableClientState( GL_TEXTURE_COORD_ARRAY );
1464 _mesa_TexCoordPointer( tcomps, GL_FLOAT, stride,
1465 (GLubyte *) pointer + toffset );
1466 }
1467 else {
1468 _mesa_DisableClientState( GL_TEXTURE_COORD_ARRAY );
1469 }
1470
1471 /* Color */
1472 if (cflag) {
1473 _mesa_EnableClientState( GL_COLOR_ARRAY );
1474 _mesa_ColorPointer( ccomps, ctype, stride,
1475 (GLubyte *) pointer + coffset );
1476 }
1477 else {
1478 _mesa_DisableClientState( GL_COLOR_ARRAY );
1479 }
1480
1481
1482 /* Normals */
1483 if (nflag) {
1484 _mesa_EnableClientState( GL_NORMAL_ARRAY );
1485 _mesa_NormalPointer( GL_FLOAT, stride, (GLubyte *) pointer + noffset );
1486 }
1487 else {
1488 _mesa_DisableClientState( GL_NORMAL_ARRAY );
1489 }
1490
1491 /* Vertices */
1492 _mesa_EnableClientState( GL_VERTEX_ARRAY );
1493 _mesa_VertexPointer( vcomps, GL_FLOAT, stride,
1494 (GLubyte *) pointer + voffset );
1495 }
1496
1497
1498 void GLAPIENTRY
_mesa_LockArraysEXT(GLint first,GLsizei count)1499 _mesa_LockArraysEXT(GLint first, GLsizei count)
1500 {
1501 GET_CURRENT_CONTEXT(ctx);
1502
1503 FLUSH_VERTICES(ctx, 0);
1504
1505 if (MESA_VERBOSE & VERBOSE_API)
1506 _mesa_debug(ctx, "glLockArrays %d %d\n", first, count);
1507
1508 if (first < 0) {
1509 _mesa_error( ctx, GL_INVALID_VALUE, "glLockArraysEXT(first)" );
1510 return;
1511 }
1512 if (count <= 0) {
1513 _mesa_error( ctx, GL_INVALID_VALUE, "glLockArraysEXT(count)" );
1514 return;
1515 }
1516 if (ctx->Array.LockCount != 0) {
1517 _mesa_error( ctx, GL_INVALID_OPERATION, "glLockArraysEXT(reentry)" );
1518 return;
1519 }
1520
1521 ctx->Array.LockFirst = first;
1522 ctx->Array.LockCount = count;
1523
1524 ctx->NewState |= _NEW_ARRAY;
1525 }
1526
1527
1528 void GLAPIENTRY
_mesa_UnlockArraysEXT(void)1529 _mesa_UnlockArraysEXT( void )
1530 {
1531 GET_CURRENT_CONTEXT(ctx);
1532
1533 FLUSH_VERTICES(ctx, 0);
1534
1535 if (MESA_VERBOSE & VERBOSE_API)
1536 _mesa_debug(ctx, "glUnlockArrays\n");
1537
1538 if (ctx->Array.LockCount == 0) {
1539 _mesa_error( ctx, GL_INVALID_OPERATION, "glUnlockArraysEXT(reexit)" );
1540 return;
1541 }
1542
1543 ctx->Array.LockFirst = 0;
1544 ctx->Array.LockCount = 0;
1545 ctx->NewState |= _NEW_ARRAY;
1546 }
1547
1548
1549 /* GL_EXT_multi_draw_arrays */
1550 void GLAPIENTRY
_mesa_MultiDrawArrays(GLenum mode,const GLint * first,const GLsizei * count,GLsizei primcount)1551 _mesa_MultiDrawArrays( GLenum mode, const GLint *first,
1552 const GLsizei *count, GLsizei primcount )
1553 {
1554 GET_CURRENT_CONTEXT(ctx);
1555 GLint i;
1556
1557 FLUSH_VERTICES(ctx, 0);
1558
1559 for (i = 0; i < primcount; i++) {
1560 if (count[i] > 0) {
1561 CALL_DrawArrays(ctx->CurrentDispatch, (mode, first[i], count[i]));
1562 }
1563 }
1564 }
1565
1566
1567 /* GL_IBM_multimode_draw_arrays */
1568 void GLAPIENTRY
_mesa_MultiModeDrawArraysIBM(const GLenum * mode,const GLint * first,const GLsizei * count,GLsizei primcount,GLint modestride)1569 _mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first,
1570 const GLsizei * count,
1571 GLsizei primcount, GLint modestride )
1572 {
1573 GET_CURRENT_CONTEXT(ctx);
1574 GLint i;
1575
1576 FLUSH_VERTICES(ctx, 0);
1577
1578 for ( i = 0 ; i < primcount ; i++ ) {
1579 if ( count[i] > 0 ) {
1580 GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
1581 CALL_DrawArrays(ctx->CurrentDispatch, ( m, first[i], count[i] ));
1582 }
1583 }
1584 }
1585
1586
1587 /* GL_IBM_multimode_draw_arrays */
1588 void GLAPIENTRY
_mesa_MultiModeDrawElementsIBM(const GLenum * mode,const GLsizei * count,GLenum type,const GLvoid * const * indices,GLsizei primcount,GLint modestride)1589 _mesa_MultiModeDrawElementsIBM( const GLenum * mode, const GLsizei * count,
1590 GLenum type, const GLvoid * const * indices,
1591 GLsizei primcount, GLint modestride )
1592 {
1593 GET_CURRENT_CONTEXT(ctx);
1594 GLint i;
1595
1596 FLUSH_VERTICES(ctx, 0);
1597
1598 /* XXX not sure about ARB_vertex_buffer_object handling here */
1599
1600 for ( i = 0 ; i < primcount ; i++ ) {
1601 if ( count[i] > 0 ) {
1602 GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
1603 CALL_DrawElements(ctx->CurrentDispatch, ( m, count[i], type,
1604 indices[i] ));
1605 }
1606 }
1607 }
1608
1609
1610 /**
1611 * GL_NV_primitive_restart and GL 3.1
1612 */
1613 void GLAPIENTRY
_mesa_PrimitiveRestartIndex(GLuint index)1614 _mesa_PrimitiveRestartIndex(GLuint index)
1615 {
1616 GET_CURRENT_CONTEXT(ctx);
1617
1618 if (!ctx->Extensions.NV_primitive_restart && ctx->Version < 31) {
1619 _mesa_error(ctx, GL_INVALID_OPERATION, "glPrimitiveRestartIndexNV()");
1620 return;
1621 }
1622
1623 if (ctx->Array.RestartIndex != index) {
1624 FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
1625 ctx->Array.RestartIndex = index;
1626 }
1627 }
1628
1629
1630 /**
1631 * See GL_ARB_instanced_arrays.
1632 * Note that the instance divisor only applies to generic arrays, not
1633 * the legacy vertex arrays.
1634 */
1635 void GLAPIENTRY
_mesa_VertexAttribDivisor(GLuint index,GLuint divisor)1636 _mesa_VertexAttribDivisor(GLuint index, GLuint divisor)
1637 {
1638 GET_CURRENT_CONTEXT(ctx);
1639
1640 const GLuint genericIndex = VERT_ATTRIB_GENERIC(index);
1641 struct gl_vertex_array_object * const vao = ctx->Array.VAO;
1642
1643 if (!ctx->Extensions.ARB_instanced_arrays) {
1644 _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexAttribDivisor()");
1645 return;
1646 }
1647
1648 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
1649 _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribDivisor(index = %u)",
1650 index);
1651 return;
1652 }
1653
1654 assert(genericIndex < ARRAY_SIZE(vao->VertexAttrib));
1655
1656 /* The ARB_vertex_attrib_binding spec says:
1657 *
1658 * "The command
1659 *
1660 * void VertexAttribDivisor(uint index, uint divisor);
1661 *
1662 * is equivalent to (assuming no errors are generated):
1663 *
1664 * VertexAttribBinding(index, index);
1665 * VertexBindingDivisor(index, divisor);"
1666 */
1667 vertex_attrib_binding(ctx, vao, genericIndex, genericIndex);
1668 vertex_binding_divisor(ctx, vao, genericIndex, divisor);
1669 }
1670
1671
1672 unsigned
_mesa_primitive_restart_index(const struct gl_context * ctx,GLenum ib_type)1673 _mesa_primitive_restart_index(const struct gl_context *ctx, GLenum ib_type)
1674 {
1675 /* From the OpenGL 4.3 core specification, page 302:
1676 * "If both PRIMITIVE_RESTART and PRIMITIVE_RESTART_FIXED_INDEX are
1677 * enabled, the index value determined by PRIMITIVE_RESTART_FIXED_INDEX
1678 * is used."
1679 */
1680 if (ctx->Array.PrimitiveRestartFixedIndex) {
1681 switch (ib_type) {
1682 case GL_UNSIGNED_BYTE:
1683 return 0xff;
1684 case GL_UNSIGNED_SHORT:
1685 return 0xffff;
1686 case GL_UNSIGNED_INT:
1687 return 0xffffffff;
1688 default:
1689 assert(!"_mesa_primitive_restart_index: Invalid index buffer type.");
1690 }
1691 }
1692
1693 return ctx->Array.RestartIndex;
1694 }
1695
1696
1697 /**
1698 * GL_ARB_vertex_attrib_binding
1699 */
1700 static void
vertex_array_vertex_buffer(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint bindingIndex,GLuint buffer,GLintptr offset,GLsizei stride,const char * func)1701 vertex_array_vertex_buffer(struct gl_context *ctx,
1702 struct gl_vertex_array_object *vao,
1703 GLuint bindingIndex, GLuint buffer, GLintptr offset,
1704 GLsizei stride, const char *func)
1705 {
1706 struct gl_buffer_object *vbo;
1707
1708 ASSERT_OUTSIDE_BEGIN_END(ctx);
1709
1710 /* The ARB_vertex_attrib_binding spec says:
1711 *
1712 * "An INVALID_VALUE error is generated if <bindingindex> is greater than
1713 * the value of MAX_VERTEX_ATTRIB_BINDINGS."
1714 */
1715 if (bindingIndex >= ctx->Const.MaxVertexAttribBindings) {
1716 _mesa_error(ctx, GL_INVALID_VALUE,
1717 "%s(bindingindex=%u > "
1718 "GL_MAX_VERTEX_ATTRIB_BINDINGS)",
1719 func, bindingIndex);
1720 return;
1721 }
1722
1723 /* The ARB_vertex_attrib_binding spec says:
1724 *
1725 * "The error INVALID_VALUE is generated if <stride> or <offset>
1726 * are negative."
1727 */
1728 if (offset < 0) {
1729 _mesa_error(ctx, GL_INVALID_VALUE,
1730 "%s(offset=%" PRId64 " < 0)",
1731 func, (int64_t) offset);
1732 return;
1733 }
1734
1735 if (stride < 0) {
1736 _mesa_error(ctx, GL_INVALID_VALUE,
1737 "%s(stride=%d < 0)", func, stride);
1738 return;
1739 }
1740
1741 if (((ctx->API == API_OPENGL_CORE && ctx->Version >= 44) || _mesa_is_gles31(ctx)) &&
1742 stride > ctx->Const.MaxVertexAttribStride) {
1743 _mesa_error(ctx, GL_INVALID_VALUE, "%s(stride=%d > "
1744 "GL_MAX_VERTEX_ATTRIB_STRIDE)", func, stride);
1745 return;
1746 }
1747
1748 if (buffer ==
1749 vao->BufferBinding[VERT_ATTRIB_GENERIC(bindingIndex)].BufferObj->Name) {
1750 vbo = vao->BufferBinding[VERT_ATTRIB_GENERIC(bindingIndex)].BufferObj;
1751 } else if (buffer != 0) {
1752 vbo = _mesa_lookup_bufferobj(ctx, buffer);
1753
1754 if (!vbo && _mesa_is_gles31(ctx)) {
1755 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-gen name)", func);
1756 return;
1757 }
1758 /* From the GL_ARB_vertex_attrib_array spec:
1759 *
1760 * "[Core profile only:]
1761 * An INVALID_OPERATION error is generated if buffer is not zero or a
1762 * name returned from a previous call to GenBuffers, or if such a name
1763 * has since been deleted with DeleteBuffers.
1764 *
1765 * Otherwise, we fall back to the same compat profile behavior as other
1766 * object references (automatically gen it).
1767 */
1768 if (!_mesa_handle_bind_buffer_gen(ctx, buffer, &vbo, func))
1769 return;
1770 } else {
1771 /* The ARB_vertex_attrib_binding spec says:
1772 *
1773 * "If <buffer> is zero, any buffer object attached to this
1774 * bindpoint is detached."
1775 */
1776 vbo = ctx->Shared->NullBufferObj;
1777 }
1778
1779 _mesa_bind_vertex_buffer(ctx, vao, VERT_ATTRIB_GENERIC(bindingIndex),
1780 vbo, offset, stride);
1781 }
1782
1783
1784 void GLAPIENTRY
_mesa_BindVertexBuffer(GLuint bindingIndex,GLuint buffer,GLintptr offset,GLsizei stride)1785 _mesa_BindVertexBuffer(GLuint bindingIndex, GLuint buffer, GLintptr offset,
1786 GLsizei stride)
1787 {
1788 GET_CURRENT_CONTEXT(ctx);
1789
1790 /* The ARB_vertex_attrib_binding spec says:
1791 *
1792 * "An INVALID_OPERATION error is generated if no vertex array object
1793 * is bound."
1794 */
1795 if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) &&
1796 ctx->Array.VAO == ctx->Array.DefaultVAO) {
1797 _mesa_error(ctx, GL_INVALID_OPERATION,
1798 "glBindVertexBuffer(No array object bound)");
1799 return;
1800 }
1801
1802 vertex_array_vertex_buffer(ctx, ctx->Array.VAO, bindingIndex,
1803 buffer, offset, stride, "glBindVertexBuffer");
1804 }
1805
1806
1807 void GLAPIENTRY
_mesa_VertexArrayVertexBuffer(GLuint vaobj,GLuint bindingIndex,GLuint buffer,GLintptr offset,GLsizei stride)1808 _mesa_VertexArrayVertexBuffer(GLuint vaobj, GLuint bindingIndex, GLuint buffer,
1809 GLintptr offset, GLsizei stride)
1810 {
1811 GET_CURRENT_CONTEXT(ctx);
1812 struct gl_vertex_array_object *vao;
1813
1814 /* The ARB_direct_state_access specification says:
1815 *
1816 * "An INVALID_OPERATION error is generated by VertexArrayVertexBuffer
1817 * if <vaobj> is not [compatibility profile: zero or] the name of an
1818 * existing vertex array object."
1819 */
1820 vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayVertexBuffer");
1821 if (!vao)
1822 return;
1823
1824 vertex_array_vertex_buffer(ctx, vao, bindingIndex,
1825 buffer, offset, stride,
1826 "glVertexArrayVertexBuffer");
1827 }
1828
1829
1830 static void
vertex_array_vertex_buffers(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint first,GLsizei count,const GLuint * buffers,const GLintptr * offsets,const GLsizei * strides,const char * func)1831 vertex_array_vertex_buffers(struct gl_context *ctx,
1832 struct gl_vertex_array_object *vao,
1833 GLuint first, GLsizei count, const GLuint *buffers,
1834 const GLintptr *offsets, const GLsizei *strides,
1835 const char *func)
1836 {
1837 GLuint i;
1838
1839 ASSERT_OUTSIDE_BEGIN_END(ctx);
1840
1841 /* The ARB_multi_bind spec says:
1842 *
1843 * "An INVALID_OPERATION error is generated if <first> + <count>
1844 * is greater than the value of MAX_VERTEX_ATTRIB_BINDINGS."
1845 */
1846 if (first + count > ctx->Const.MaxVertexAttribBindings) {
1847 _mesa_error(ctx, GL_INVALID_OPERATION,
1848 "%s(first=%u + count=%d > the value of "
1849 "GL_MAX_VERTEX_ATTRIB_BINDINGS=%u)",
1850 func, first, count, ctx->Const.MaxVertexAttribBindings);
1851 return;
1852 }
1853
1854 if (!buffers) {
1855 /**
1856 * The ARB_multi_bind spec says:
1857 *
1858 * "If <buffers> is NULL, each affected vertex buffer binding point
1859 * from <first> through <first>+<count>-1 will be reset to have no
1860 * bound buffer object. In this case, the offsets and strides
1861 * associated with the binding points are set to default values,
1862 * ignoring <offsets> and <strides>."
1863 */
1864 struct gl_buffer_object *vbo = ctx->Shared->NullBufferObj;
1865
1866 for (i = 0; i < count; i++)
1867 _mesa_bind_vertex_buffer(ctx, vao, VERT_ATTRIB_GENERIC(first + i),
1868 vbo, 0, 16);
1869
1870 return;
1871 }
1872
1873 /* Note that the error semantics for multi-bind commands differ from
1874 * those of other GL commands.
1875 *
1876 * The Issues section in the ARB_multi_bind spec says:
1877 *
1878 * "(11) Typically, OpenGL specifies that if an error is generated by
1879 * a command, that command has no effect. This is somewhat
1880 * unfortunate for multi-bind commands, because it would require
1881 * a first pass to scan the entire list of bound objects for
1882 * errors and then a second pass to actually perform the
1883 * bindings. Should we have different error semantics?
1884 *
1885 * RESOLVED: Yes. In this specification, when the parameters for
1886 * one of the <count> binding points are invalid, that binding
1887 * point is not updated and an error will be generated. However,
1888 * other binding points in the same command will be updated if
1889 * their parameters are valid and no other error occurs."
1890 */
1891
1892 _mesa_begin_bufferobj_lookups(ctx);
1893
1894 for (i = 0; i < count; i++) {
1895 struct gl_buffer_object *vbo;
1896
1897 /* The ARB_multi_bind spec says:
1898 *
1899 * "An INVALID_VALUE error is generated if any value in
1900 * <offsets> or <strides> is negative (per binding)."
1901 */
1902 if (offsets[i] < 0) {
1903 _mesa_error(ctx, GL_INVALID_VALUE,
1904 "%s(offsets[%u]=%" PRId64 " < 0)",
1905 func, i, (int64_t) offsets[i]);
1906 continue;
1907 }
1908
1909 if (strides[i] < 0) {
1910 _mesa_error(ctx, GL_INVALID_VALUE,
1911 "%s(strides[%u]=%d < 0)",
1912 func, i, strides[i]);
1913 continue;
1914 }
1915
1916 if (ctx->API == API_OPENGL_CORE && ctx->Version >= 44 &&
1917 strides[i] > ctx->Const.MaxVertexAttribStride) {
1918 _mesa_error(ctx, GL_INVALID_VALUE,
1919 "%s(strides[%u]=%d > "
1920 "GL_MAX_VERTEX_ATTRIB_STRIDE)", func, i, strides[i]);
1921 continue;
1922 }
1923
1924 if (buffers[i]) {
1925 struct gl_vertex_buffer_binding *binding =
1926 &vao->BufferBinding[VERT_ATTRIB_GENERIC(first + i)];
1927
1928 if (buffers[i] == binding->BufferObj->Name)
1929 vbo = binding->BufferObj;
1930 else
1931 vbo = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, func);
1932
1933 if (!vbo)
1934 continue;
1935 } else {
1936 vbo = ctx->Shared->NullBufferObj;
1937 }
1938
1939 _mesa_bind_vertex_buffer(ctx, vao, VERT_ATTRIB_GENERIC(first + i),
1940 vbo, offsets[i], strides[i]);
1941 }
1942
1943 _mesa_end_bufferobj_lookups(ctx);
1944 }
1945
1946
1947 void GLAPIENTRY
_mesa_BindVertexBuffers(GLuint first,GLsizei count,const GLuint * buffers,const GLintptr * offsets,const GLsizei * strides)1948 _mesa_BindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers,
1949 const GLintptr *offsets, const GLsizei *strides)
1950 {
1951 GET_CURRENT_CONTEXT(ctx);
1952
1953 /* The ARB_vertex_attrib_binding spec says:
1954 *
1955 * "An INVALID_OPERATION error is generated if no
1956 * vertex array object is bound."
1957 */
1958 if (ctx->API == API_OPENGL_CORE &&
1959 ctx->Array.VAO == ctx->Array.DefaultVAO) {
1960 _mesa_error(ctx, GL_INVALID_OPERATION,
1961 "glBindVertexBuffers(No array object bound)");
1962 return;
1963 }
1964
1965 vertex_array_vertex_buffers(ctx, ctx->Array.VAO, first, count,
1966 buffers, offsets, strides,
1967 "glBindVertexBuffers");
1968 }
1969
1970
1971 void GLAPIENTRY
_mesa_VertexArrayVertexBuffers(GLuint vaobj,GLuint first,GLsizei count,const GLuint * buffers,const GLintptr * offsets,const GLsizei * strides)1972 _mesa_VertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count,
1973 const GLuint *buffers,
1974 const GLintptr *offsets, const GLsizei *strides)
1975 {
1976 GET_CURRENT_CONTEXT(ctx);
1977 struct gl_vertex_array_object *vao;
1978
1979 /* The ARB_direct_state_access specification says:
1980 *
1981 * "An INVALID_OPERATION error is generated by VertexArrayVertexBuffer
1982 * if <vaobj> is not [compatibility profile: zero or] the name of an
1983 * existing vertex array object."
1984 */
1985 vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayVertexBuffers");
1986 if (!vao)
1987 return;
1988
1989 vertex_array_vertex_buffers(ctx, vao, first, count,
1990 buffers, offsets, strides,
1991 "glVertexArrayVertexBuffers");
1992 }
1993
1994
1995 static void
vertex_attrib_format(GLuint attribIndex,GLint size,GLenum type,GLboolean normalized,GLboolean integer,GLboolean doubles,GLbitfield legalTypes,GLsizei maxSize,GLuint relativeOffset,const char * func)1996 vertex_attrib_format(GLuint attribIndex, GLint size, GLenum type,
1997 GLboolean normalized, GLboolean integer,
1998 GLboolean doubles, GLbitfield legalTypes,
1999 GLsizei maxSize, GLuint relativeOffset,
2000 const char *func)
2001 {
2002 GET_CURRENT_CONTEXT(ctx);
2003 ASSERT_OUTSIDE_BEGIN_END(ctx);
2004
2005 /* The ARB_vertex_attrib_binding spec says:
2006 *
2007 * "An INVALID_OPERATION error is generated under any of the following
2008 * conditions:
2009 * - if no vertex array object is currently bound (see section 2.10);
2010 * - ..."
2011 *
2012 * This error condition only applies to VertexAttribFormat and
2013 * VertexAttribIFormat in the extension spec, but we assume that this
2014 * is an oversight. In the OpenGL 4.3 (Core Profile) spec, it applies
2015 * to all three functions.
2016 */
2017 if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) &&
2018 ctx->Array.VAO == ctx->Array.DefaultVAO) {
2019 _mesa_error(ctx, GL_INVALID_OPERATION,
2020 "%s(No array object bound)", func);
2021 return;
2022 }
2023
2024 /* The ARB_vertex_attrib_binding spec says:
2025 *
2026 * "The error INVALID_VALUE is generated if index is greater than or equal
2027 * to the value of MAX_VERTEX_ATTRIBS."
2028 */
2029 if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
2030 _mesa_error(ctx, GL_INVALID_VALUE,
2031 "%s(attribindex=%u > "
2032 "GL_MAX_VERTEX_ATTRIBS)",
2033 func, attribIndex);
2034 return;
2035 }
2036
2037 FLUSH_VERTICES(ctx, 0);
2038
2039 update_array_format(ctx, func, ctx->Array.VAO,
2040 VERT_ATTRIB_GENERIC(attribIndex),
2041 legalTypes, 1, maxSize, size, type,
2042 normalized, integer, doubles, relativeOffset);
2043 }
2044
2045
2046 void GLAPIENTRY
_mesa_VertexAttribFormat(GLuint attribIndex,GLint size,GLenum type,GLboolean normalized,GLuint relativeOffset)2047 _mesa_VertexAttribFormat(GLuint attribIndex, GLint size, GLenum type,
2048 GLboolean normalized, GLuint relativeOffset)
2049 {
2050 vertex_attrib_format(attribIndex, size, type, normalized,
2051 GL_FALSE, GL_FALSE, ATTRIB_FORMAT_TYPES_MASK,
2052 BGRA_OR_4, relativeOffset,
2053 "glVertexAttribFormat");
2054 }
2055
2056
2057 void GLAPIENTRY
_mesa_VertexAttribIFormat(GLuint attribIndex,GLint size,GLenum type,GLuint relativeOffset)2058 _mesa_VertexAttribIFormat(GLuint attribIndex, GLint size, GLenum type,
2059 GLuint relativeOffset)
2060 {
2061 vertex_attrib_format(attribIndex, size, type, GL_FALSE,
2062 GL_TRUE, GL_FALSE, ATTRIB_IFORMAT_TYPES_MASK, 4,
2063 relativeOffset, "glVertexAttribIFormat");
2064 }
2065
2066
2067 void GLAPIENTRY
_mesa_VertexAttribLFormat(GLuint attribIndex,GLint size,GLenum type,GLuint relativeOffset)2068 _mesa_VertexAttribLFormat(GLuint attribIndex, GLint size, GLenum type,
2069 GLuint relativeOffset)
2070 {
2071 vertex_attrib_format(attribIndex, size, type, GL_FALSE, GL_FALSE,
2072 GL_TRUE, ATTRIB_LFORMAT_TYPES_MASK, 4,
2073 relativeOffset, "glVertexAttribLFormat");
2074 }
2075
2076
2077 static void
vertex_array_attrib_format(GLuint vaobj,GLuint attribIndex,GLint size,GLenum type,GLboolean normalized,GLboolean integer,GLboolean doubles,GLbitfield legalTypes,GLsizei maxSize,GLuint relativeOffset,const char * func)2078 vertex_array_attrib_format(GLuint vaobj, GLuint attribIndex, GLint size,
2079 GLenum type, GLboolean normalized,
2080 GLboolean integer, GLboolean doubles,
2081 GLbitfield legalTypes, GLsizei maxSize,
2082 GLuint relativeOffset, const char *func)
2083 {
2084 GET_CURRENT_CONTEXT(ctx);
2085 struct gl_vertex_array_object *vao;
2086
2087 ASSERT_OUTSIDE_BEGIN_END(ctx);
2088
2089 /* The ARB_direct_state_access spec says:
2090 *
2091 * "An INVALID_OPERATION error is generated by VertexArrayAttrib*Format
2092 * if <vaobj> is not [compatibility profile: zero or] the name of an
2093 * existing vertex array object."
2094 */
2095 vao = _mesa_lookup_vao_err(ctx, vaobj, func);
2096 if (!vao)
2097 return;
2098
2099 /* The ARB_vertex_attrib_binding spec says:
2100 *
2101 * "The error INVALID_VALUE is generated if index is greater than or equal
2102 * to the value of MAX_VERTEX_ATTRIBS."
2103 */
2104 if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
2105 _mesa_error(ctx, GL_INVALID_VALUE,
2106 "%s(attribindex=%u > GL_MAX_VERTEX_ATTRIBS)",
2107 func, attribIndex);
2108 return;
2109 }
2110
2111 FLUSH_VERTICES(ctx, 0);
2112
2113 update_array_format(ctx, func, vao,
2114 VERT_ATTRIB_GENERIC(attribIndex),
2115 legalTypes, 1, maxSize, size, type, normalized,
2116 integer, doubles, relativeOffset);
2117 }
2118
2119
2120 void GLAPIENTRY
_mesa_VertexArrayAttribFormat(GLuint vaobj,GLuint attribIndex,GLint size,GLenum type,GLboolean normalized,GLuint relativeOffset)2121 _mesa_VertexArrayAttribFormat(GLuint vaobj, GLuint attribIndex, GLint size,
2122 GLenum type, GLboolean normalized,
2123 GLuint relativeOffset)
2124 {
2125 vertex_array_attrib_format(vaobj, attribIndex, size, type, normalized,
2126 GL_FALSE, GL_FALSE, ATTRIB_FORMAT_TYPES_MASK,
2127 BGRA_OR_4, relativeOffset,
2128 "glVertexArrayAttribFormat");
2129 }
2130
2131
2132 void GLAPIENTRY
_mesa_VertexArrayAttribIFormat(GLuint vaobj,GLuint attribIndex,GLint size,GLenum type,GLuint relativeOffset)2133 _mesa_VertexArrayAttribIFormat(GLuint vaobj, GLuint attribIndex,
2134 GLint size, GLenum type,
2135 GLuint relativeOffset)
2136 {
2137 vertex_array_attrib_format(vaobj, attribIndex, size, type, GL_FALSE,
2138 GL_TRUE, GL_FALSE, ATTRIB_IFORMAT_TYPES_MASK,
2139 4, relativeOffset,
2140 "glVertexArrayAttribIFormat");
2141 }
2142
2143
2144 void GLAPIENTRY
_mesa_VertexArrayAttribLFormat(GLuint vaobj,GLuint attribIndex,GLint size,GLenum type,GLuint relativeOffset)2145 _mesa_VertexArrayAttribLFormat(GLuint vaobj, GLuint attribIndex,
2146 GLint size, GLenum type,
2147 GLuint relativeOffset)
2148 {
2149 vertex_array_attrib_format(vaobj, attribIndex, size, type, GL_FALSE,
2150 GL_FALSE, GL_TRUE, ATTRIB_LFORMAT_TYPES_MASK,
2151 4, relativeOffset,
2152 "glVertexArrayAttribLFormat");
2153 }
2154
2155
2156 static void
vertex_array_attrib_binding(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint attribIndex,GLuint bindingIndex,const char * func)2157 vertex_array_attrib_binding(struct gl_context *ctx,
2158 struct gl_vertex_array_object *vao,
2159 GLuint attribIndex, GLuint bindingIndex,
2160 const char *func)
2161 {
2162 ASSERT_OUTSIDE_BEGIN_END(ctx);
2163
2164 /* The ARB_vertex_attrib_binding spec says:
2165 *
2166 * "<attribindex> must be less than the value of MAX_VERTEX_ATTRIBS and
2167 * <bindingindex> must be less than the value of
2168 * MAX_VERTEX_ATTRIB_BINDINGS, otherwise the error INVALID_VALUE
2169 * is generated."
2170 */
2171 if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
2172 _mesa_error(ctx, GL_INVALID_VALUE,
2173 "%s(attribindex=%u >= "
2174 "GL_MAX_VERTEX_ATTRIBS)",
2175 func, attribIndex);
2176 return;
2177 }
2178
2179 if (bindingIndex >= ctx->Const.MaxVertexAttribBindings) {
2180 _mesa_error(ctx, GL_INVALID_VALUE,
2181 "%s(bindingindex=%u >= "
2182 "GL_MAX_VERTEX_ATTRIB_BINDINGS)",
2183 func, bindingIndex);
2184 return;
2185 }
2186
2187 assert(VERT_ATTRIB_GENERIC(attribIndex) < ARRAY_SIZE(vao->VertexAttrib));
2188
2189 vertex_attrib_binding(ctx, vao,
2190 VERT_ATTRIB_GENERIC(attribIndex),
2191 VERT_ATTRIB_GENERIC(bindingIndex));
2192 }
2193
2194
2195 void GLAPIENTRY
_mesa_VertexAttribBinding(GLuint attribIndex,GLuint bindingIndex)2196 _mesa_VertexAttribBinding(GLuint attribIndex, GLuint bindingIndex)
2197 {
2198 GET_CURRENT_CONTEXT(ctx);
2199
2200 /* The ARB_vertex_attrib_binding spec says:
2201 *
2202 * "An INVALID_OPERATION error is generated if no vertex array object
2203 * is bound."
2204 */
2205 if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) &&
2206 ctx->Array.VAO == ctx->Array.DefaultVAO) {
2207 _mesa_error(ctx, GL_INVALID_OPERATION,
2208 "glVertexAttribBinding(No array object bound)");
2209 return;
2210 }
2211
2212 vertex_array_attrib_binding(ctx, ctx->Array.VAO,
2213 attribIndex, bindingIndex,
2214 "glVertexAttribBinding");
2215 }
2216
2217
2218 void GLAPIENTRY
_mesa_VertexArrayAttribBinding(GLuint vaobj,GLuint attribIndex,GLuint bindingIndex)2219 _mesa_VertexArrayAttribBinding(GLuint vaobj, GLuint attribIndex, GLuint bindingIndex)
2220 {
2221 GET_CURRENT_CONTEXT(ctx);
2222 struct gl_vertex_array_object *vao;
2223
2224 /* The ARB_direct_state_access specification says:
2225 *
2226 * "An INVALID_OPERATION error is generated by VertexArrayAttribBinding
2227 * if <vaobj> is not [compatibility profile: zero or] the name of an
2228 * existing vertex array object."
2229 */
2230 vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayAttribBinding");
2231 if (!vao)
2232 return;
2233
2234 vertex_array_attrib_binding(ctx, vao, attribIndex, bindingIndex,
2235 "glVertexArrayAttribBinding");
2236 }
2237
2238
2239 static void
vertex_array_binding_divisor(struct gl_context * ctx,struct gl_vertex_array_object * vao,GLuint bindingIndex,GLuint divisor,const char * func)2240 vertex_array_binding_divisor(struct gl_context *ctx,
2241 struct gl_vertex_array_object *vao,
2242 GLuint bindingIndex, GLuint divisor,
2243 const char *func)
2244 {
2245 ASSERT_OUTSIDE_BEGIN_END(ctx);
2246
2247 if (!ctx->Extensions.ARB_instanced_arrays) {
2248 _mesa_error(ctx, GL_INVALID_OPERATION, "%s()", func);
2249 return;
2250 }
2251
2252 /* The ARB_vertex_attrib_binding spec says:
2253 *
2254 * "An INVALID_VALUE error is generated if <bindingindex> is greater
2255 * than or equal to the value of MAX_VERTEX_ATTRIB_BINDINGS."
2256 */
2257 if (bindingIndex >= ctx->Const.MaxVertexAttribBindings) {
2258 _mesa_error(ctx, GL_INVALID_VALUE,
2259 "%s(bindingindex=%u > "
2260 "GL_MAX_VERTEX_ATTRIB_BINDINGS)",
2261 func, bindingIndex);
2262 return;
2263 }
2264
2265 vertex_binding_divisor(ctx, vao, VERT_ATTRIB_GENERIC(bindingIndex), divisor);
2266 }
2267
2268
2269 void GLAPIENTRY
_mesa_VertexBindingDivisor(GLuint bindingIndex,GLuint divisor)2270 _mesa_VertexBindingDivisor(GLuint bindingIndex, GLuint divisor)
2271 {
2272 GET_CURRENT_CONTEXT(ctx);
2273
2274 /* The ARB_vertex_attrib_binding spec says:
2275 *
2276 * "An INVALID_OPERATION error is generated if no vertex array object
2277 * is bound."
2278 */
2279 if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) &&
2280 ctx->Array.VAO == ctx->Array.DefaultVAO) {
2281 _mesa_error(ctx, GL_INVALID_OPERATION,
2282 "glVertexBindingDivisor(No array object bound)");
2283 return;
2284 }
2285
2286 vertex_array_binding_divisor(ctx, ctx->Array.VAO,
2287 bindingIndex, divisor,
2288 "glVertexBindingDivisor");
2289 }
2290
2291
2292 void GLAPIENTRY
_mesa_VertexArrayBindingDivisor(GLuint vaobj,GLuint bindingIndex,GLuint divisor)2293 _mesa_VertexArrayBindingDivisor(GLuint vaobj, GLuint bindingIndex,
2294 GLuint divisor)
2295 {
2296 struct gl_vertex_array_object *vao;
2297 GET_CURRENT_CONTEXT(ctx);
2298
2299 /* The ARB_direct_state_access specification says:
2300 *
2301 * "An INVALID_OPERATION error is generated by VertexArrayBindingDivisor
2302 * if <vaobj> is not [compatibility profile: zero or] the name of an
2303 * existing vertex array object."
2304 */
2305 vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayBindingDivisor");
2306 if (!vao)
2307 return;
2308
2309 vertex_array_binding_divisor(ctx, vao, bindingIndex, divisor,
2310 "glVertexArrayBindingDivisor");
2311 }
2312
2313
2314 /**
2315 * Copy one client vertex array to another.
2316 */
2317 void
_mesa_copy_client_array(struct gl_context * ctx,struct gl_vertex_array * dst,struct gl_vertex_array * src)2318 _mesa_copy_client_array(struct gl_context *ctx,
2319 struct gl_vertex_array *dst,
2320 struct gl_vertex_array *src)
2321 {
2322 dst->Size = src->Size;
2323 dst->Type = src->Type;
2324 dst->Format = src->Format;
2325 dst->StrideB = src->StrideB;
2326 dst->Ptr = src->Ptr;
2327 dst->Normalized = src->Normalized;
2328 dst->Integer = src->Integer;
2329 dst->Doubles = src->Doubles;
2330 dst->InstanceDivisor = src->InstanceDivisor;
2331 dst->_ElementSize = src->_ElementSize;
2332 _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj);
2333 }
2334
2335 void
_mesa_copy_vertex_attrib_array(struct gl_context * ctx,struct gl_array_attributes * dst,const struct gl_array_attributes * src)2336 _mesa_copy_vertex_attrib_array(struct gl_context *ctx,
2337 struct gl_array_attributes *dst,
2338 const struct gl_array_attributes *src)
2339 {
2340 dst->Size = src->Size;
2341 dst->Type = src->Type;
2342 dst->Format = src->Format;
2343 dst->BufferBindingIndex = src->BufferBindingIndex;
2344 dst->RelativeOffset = src->RelativeOffset;
2345 dst->Format = src->Format;
2346 dst->Integer = src->Integer;
2347 dst->Doubles = src->Doubles;
2348 dst->Normalized = src->Normalized;
2349 dst->Ptr = src->Ptr;
2350 dst->Enabled = src->Enabled;
2351 dst->_ElementSize = src->_ElementSize;
2352 }
2353
2354 void
_mesa_copy_vertex_buffer_binding(struct gl_context * ctx,struct gl_vertex_buffer_binding * dst,const struct gl_vertex_buffer_binding * src)2355 _mesa_copy_vertex_buffer_binding(struct gl_context *ctx,
2356 struct gl_vertex_buffer_binding *dst,
2357 const struct gl_vertex_buffer_binding *src)
2358 {
2359 dst->Offset = src->Offset;
2360 dst->Stride = src->Stride;
2361 dst->InstanceDivisor = src->InstanceDivisor;
2362 dst->_BoundArrays = src->_BoundArrays;
2363
2364 _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj);
2365 }
2366
2367 /**
2368 * Print current vertex object/array info. For debug.
2369 */
2370 void
_mesa_print_arrays(struct gl_context * ctx)2371 _mesa_print_arrays(struct gl_context *ctx)
2372 {
2373 const struct gl_vertex_array_object *vao = ctx->Array.VAO;
2374
2375 fprintf(stderr, "Array Object %u\n", vao->Name);
2376
2377 unsigned i;
2378 for (i = 0; i < VERT_ATTRIB_MAX; ++i) {
2379 const struct gl_array_attributes *array = &vao->VertexAttrib[i];
2380 if (!array->Enabled)
2381 continue;
2382
2383 const struct gl_vertex_buffer_binding *binding =
2384 &vao->BufferBinding[array->BufferBindingIndex];
2385 const struct gl_buffer_object *bo = binding->BufferObj;
2386
2387 fprintf(stderr, " %s: Ptr=%p, Type=%s, Size=%d, ElemSize=%u, "
2388 "Stride=%d, Buffer=%u(Size %lu)\n",
2389 gl_vert_attrib_name((gl_vert_attrib)i),
2390 array->Ptr, _mesa_enum_to_string(array->Type), array->Size,
2391 array->_ElementSize, binding->Stride, bo->Name,
2392 (unsigned long) bo->Size);
2393 }
2394 }
2395
2396
2397 /**
2398 * Initialize vertex array state for given context.
2399 */
2400 void
_mesa_init_varray(struct gl_context * ctx)2401 _mesa_init_varray(struct gl_context *ctx)
2402 {
2403 ctx->Array.DefaultVAO = _mesa_new_vao(ctx, 0);
2404 _mesa_reference_vao(ctx, &ctx->Array.VAO, ctx->Array.DefaultVAO);
2405 ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */
2406
2407 ctx->Array.Objects = _mesa_NewHashTable();
2408 }
2409
2410
2411 /**
2412 * Callback for deleting an array object. Called by _mesa_HashDeleteAll().
2413 */
2414 static void
delete_arrayobj_cb(GLuint id,void * data,void * userData)2415 delete_arrayobj_cb(GLuint id, void *data, void *userData)
2416 {
2417 struct gl_vertex_array_object *vao = (struct gl_vertex_array_object *) data;
2418 struct gl_context *ctx = (struct gl_context *) userData;
2419 _mesa_delete_vao(ctx, vao);
2420 }
2421
2422
2423 /**
2424 * Free vertex array state for given context.
2425 */
2426 void
_mesa_free_varray_data(struct gl_context * ctx)2427 _mesa_free_varray_data(struct gl_context *ctx)
2428 {
2429 _mesa_HashDeleteAll(ctx->Array.Objects, delete_arrayobj_cb, ctx);
2430 _mesa_DeleteHashTable(ctx->Array.Objects);
2431 }
2432