e370d04c31d675ebf797bc4c803a90e4adda9d0d
[mesa.git] / src / mesa / main / bufferobj.c
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 /**
28 * \file bufferobj.c
29 * \brief Functions for the GL_ARB_vertex/pixel_buffer_object extensions.
30 * \author Brian Paul, Ian Romanick
31 */
32
33 #include <stdbool.h>
34 #include <inttypes.h> /* for PRId64 macro */
35 #include "util/debug.h"
36 #include "glheader.h"
37 #include "enums.h"
38 #include "hash.h"
39 #include "imports.h"
40 #include "context.h"
41 #include "bufferobj.h"
42 #include "externalobjects.h"
43 #include "mtypes.h"
44 #include "teximage.h"
45 #include "glformats.h"
46 #include "texstore.h"
47 #include "transformfeedback.h"
48 #include "varray.h"
49 #include "util/u_atomic.h"
50
51
52 /* Debug flags */
53 /*#define VBO_DEBUG*/
54 /*#define BOUNDS_CHECK*/
55
56
57 /**
58 * We count the number of buffer modification calls to check for
59 * inefficient buffer use. This is the number of such calls before we
60 * issue a warning.
61 */
62 #define BUFFER_WARNING_CALL_COUNT 4
63
64
65 /**
66 * Helper to warn of possible performance issues, such as frequently
67 * updating a buffer created with GL_STATIC_DRAW. Called via the macro
68 * below.
69 */
70 static void
71 buffer_usage_warning(struct gl_context *ctx, GLuint *id, const char *fmt, ...)
72 {
73 va_list args;
74
75 va_start(args, fmt);
76 _mesa_gl_vdebugf(ctx, id,
77 MESA_DEBUG_SOURCE_API,
78 MESA_DEBUG_TYPE_PERFORMANCE,
79 MESA_DEBUG_SEVERITY_MEDIUM,
80 fmt, args);
81 va_end(args);
82 }
83
84 #define BUFFER_USAGE_WARNING(CTX, FMT, ...) \
85 do { \
86 static GLuint id = 0; \
87 buffer_usage_warning(CTX, &id, FMT, ##__VA_ARGS__); \
88 } while (0)
89
90
91 /**
92 * Used as a placeholder for buffer objects between glGenBuffers() and
93 * glBindBuffer() so that glIsBuffer() can work correctly.
94 */
95 static struct gl_buffer_object DummyBufferObject;
96
97
98 /**
99 * Return pointer to address of a buffer object target.
100 * \param ctx the GL context
101 * \param target the buffer object target to be retrieved.
102 * \return pointer to pointer to the buffer object bound to \c target in the
103 * specified context or \c NULL if \c target is invalid.
104 */
105 static inline struct gl_buffer_object **
106 get_buffer_target(struct gl_context *ctx, GLenum target)
107 {
108 /* Other targets are only supported in desktop OpenGL and OpenGL ES 3.0.
109 */
110 if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx)
111 && target != GL_ARRAY_BUFFER && target != GL_ELEMENT_ARRAY_BUFFER)
112 return NULL;
113
114 switch (target) {
115 case GL_ARRAY_BUFFER_ARB:
116 if (ctx->Array.ArrayBufferObj)
117 ctx->Array.ArrayBufferObj->UsageHistory |= USAGE_ARRAY_BUFFER;
118 return &ctx->Array.ArrayBufferObj;
119 case GL_ELEMENT_ARRAY_BUFFER_ARB:
120 if (ctx->Array.VAO->IndexBufferObj)
121 ctx->Array.VAO->IndexBufferObj->UsageHistory
122 |= USAGE_ELEMENT_ARRAY_BUFFER;
123 return &ctx->Array.VAO->IndexBufferObj;
124 case GL_PIXEL_PACK_BUFFER_EXT:
125 return &ctx->Pack.BufferObj;
126 case GL_PIXEL_UNPACK_BUFFER_EXT:
127 return &ctx->Unpack.BufferObj;
128 case GL_COPY_READ_BUFFER:
129 return &ctx->CopyReadBuffer;
130 case GL_COPY_WRITE_BUFFER:
131 return &ctx->CopyWriteBuffer;
132 case GL_QUERY_BUFFER:
133 if (_mesa_has_ARB_query_buffer_object(ctx))
134 return &ctx->QueryBuffer;
135 break;
136 case GL_DRAW_INDIRECT_BUFFER:
137 if ((_mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_draw_indirect) ||
138 _mesa_is_gles31(ctx)) {
139 return &ctx->DrawIndirectBuffer;
140 }
141 break;
142 case GL_PARAMETER_BUFFER_ARB:
143 if (_mesa_has_ARB_indirect_parameters(ctx)) {
144 return &ctx->ParameterBuffer;
145 }
146 break;
147 case GL_DISPATCH_INDIRECT_BUFFER:
148 if (_mesa_has_compute_shaders(ctx)) {
149 return &ctx->DispatchIndirectBuffer;
150 }
151 break;
152 case GL_TRANSFORM_FEEDBACK_BUFFER:
153 if (ctx->Extensions.EXT_transform_feedback) {
154 return &ctx->TransformFeedback.CurrentBuffer;
155 }
156 break;
157 case GL_TEXTURE_BUFFER:
158 if (_mesa_has_ARB_texture_buffer_object(ctx) ||
159 _mesa_has_OES_texture_buffer(ctx)) {
160 return &ctx->Texture.BufferObject;
161 }
162 break;
163 case GL_UNIFORM_BUFFER:
164 if (ctx->Extensions.ARB_uniform_buffer_object) {
165 return &ctx->UniformBuffer;
166 }
167 break;
168 case GL_SHADER_STORAGE_BUFFER:
169 if (ctx->Extensions.ARB_shader_storage_buffer_object) {
170 return &ctx->ShaderStorageBuffer;
171 }
172 break;
173 case GL_ATOMIC_COUNTER_BUFFER:
174 if (ctx->Extensions.ARB_shader_atomic_counters) {
175 return &ctx->AtomicBuffer;
176 }
177 break;
178 case GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD:
179 if (ctx->Extensions.AMD_pinned_memory) {
180 return &ctx->ExternalVirtualMemoryBuffer;
181 }
182 break;
183 default:
184 return NULL;
185 }
186 return NULL;
187 }
188
189
190 /**
191 * Get the buffer object bound to the specified target in a GL context.
192 * \param ctx the GL context
193 * \param target the buffer object target to be retrieved.
194 * \param error the GL error to record if target is illegal.
195 * \return pointer to the buffer object bound to \c target in the
196 * specified context or \c NULL if \c target is invalid.
197 */
198 static inline struct gl_buffer_object *
199 get_buffer(struct gl_context *ctx, const char *func, GLenum target,
200 GLenum error)
201 {
202 struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);
203
204 if (!bufObj) {
205 _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", func);
206 return NULL;
207 }
208
209 if (!_mesa_is_bufferobj(*bufObj)) {
210 _mesa_error(ctx, error, "%s(no buffer bound)", func);
211 return NULL;
212 }
213
214 return *bufObj;
215 }
216
217
218 /**
219 * Convert a GLbitfield describing the mapped buffer access flags
220 * into one of GL_READ_WRITE, GL_READ_ONLY, or GL_WRITE_ONLY.
221 */
222 static GLenum
223 simplified_access_mode(struct gl_context *ctx, GLbitfield access)
224 {
225 const GLbitfield rwFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
226 if ((access & rwFlags) == rwFlags)
227 return GL_READ_WRITE;
228 if ((access & GL_MAP_READ_BIT) == GL_MAP_READ_BIT)
229 return GL_READ_ONLY;
230 if ((access & GL_MAP_WRITE_BIT) == GL_MAP_WRITE_BIT)
231 return GL_WRITE_ONLY;
232
233 /* Otherwise, AccessFlags is zero (the default state).
234 *
235 * Table 2.6 on page 31 (page 44 of the PDF) of the OpenGL 1.5 spec says:
236 *
237 * Name Type Initial Value Legal Values
238 * ... ... ... ...
239 * BUFFER_ACCESS enum READ_WRITE READ_ONLY, WRITE_ONLY
240 * READ_WRITE
241 *
242 * However, table 6.8 in the GL_OES_mapbuffer extension says:
243 *
244 * Get Value Type Get Command Value Description
245 * --------- ---- ----------- ----- -----------
246 * BUFFER_ACCESS_OES Z1 GetBufferParameteriv WRITE_ONLY_OES buffer map flag
247 *
248 * The difference is because GL_OES_mapbuffer only supports mapping buffers
249 * write-only.
250 */
251 assert(access == 0);
252
253 return _mesa_is_gles(ctx) ? GL_WRITE_ONLY : GL_READ_WRITE;
254 }
255
256
257 /**
258 * Test if the buffer is mapped, and if so, if the mapped range overlaps the
259 * given range.
260 * The regions do not overlap if and only if the end of the given
261 * region is before the mapped region or the start of the given region
262 * is after the mapped region.
263 *
264 * \param obj Buffer object target on which to operate.
265 * \param offset Offset of the first byte of the subdata range.
266 * \param size Size, in bytes, of the subdata range.
267 * \return true if ranges overlap, false otherwise
268 *
269 */
270 static bool
271 bufferobj_range_mapped(const struct gl_buffer_object *obj,
272 GLintptr offset, GLsizeiptr size)
273 {
274 if (_mesa_bufferobj_mapped(obj, MAP_USER)) {
275 const GLintptr end = offset + size;
276 const GLintptr mapEnd = obj->Mappings[MAP_USER].Offset +
277 obj->Mappings[MAP_USER].Length;
278
279 if (!(end <= obj->Mappings[MAP_USER].Offset || offset >= mapEnd)) {
280 return true;
281 }
282 }
283 return false;
284 }
285
286
287 /**
288 * Tests the subdata range parameters and sets the GL error code for
289 * \c glBufferSubDataARB, \c glGetBufferSubDataARB and
290 * \c glClearBufferSubData.
291 *
292 * \param ctx GL context.
293 * \param bufObj The buffer object.
294 * \param offset Offset of the first byte of the subdata range.
295 * \param size Size, in bytes, of the subdata range.
296 * \param mappedRange If true, checks if an overlapping range is mapped.
297 * If false, checks if buffer is mapped.
298 * \param caller Name of calling function for recording errors.
299 * \return false if error, true otherwise
300 *
301 * \sa glBufferSubDataARB, glGetBufferSubDataARB, glClearBufferSubData
302 */
303 static bool
304 buffer_object_subdata_range_good(struct gl_context *ctx,
305 const struct gl_buffer_object *bufObj,
306 GLintptr offset, GLsizeiptr size,
307 bool mappedRange, const char *caller)
308 {
309 if (size < 0) {
310 _mesa_error(ctx, GL_INVALID_VALUE, "%s(size < 0)", caller);
311 return false;
312 }
313
314 if (offset < 0) {
315 _mesa_error(ctx, GL_INVALID_VALUE, "%s(offset < 0)", caller);
316 return false;
317 }
318
319 if (offset + size > bufObj->Size) {
320 _mesa_error(ctx, GL_INVALID_VALUE,
321 "%s(offset %lu + size %lu > buffer size %lu)", caller,
322 (unsigned long) offset,
323 (unsigned long) size,
324 (unsigned long) bufObj->Size);
325 return false;
326 }
327
328 if (bufObj->Mappings[MAP_USER].AccessFlags & GL_MAP_PERSISTENT_BIT)
329 return true;
330
331 if (mappedRange) {
332 if (bufferobj_range_mapped(bufObj, offset, size)) {
333 _mesa_error(ctx, GL_INVALID_OPERATION,
334 "%s(range is mapped without persistent bit)",
335 caller);
336 return false;
337 }
338 }
339 else {
340 if (_mesa_bufferobj_mapped(bufObj, MAP_USER)) {
341 _mesa_error(ctx, GL_INVALID_OPERATION,
342 "%s(buffer is mapped without persistent bit)",
343 caller);
344 return false;
345 }
346 }
347
348 return true;
349 }
350
351
352 /**
353 * Test the format and type parameters and set the GL error code for
354 * \c glClearBufferData, \c glClearNamedBufferData, \c glClearBufferSubData
355 * and \c glClearNamedBufferSubData.
356 *
357 * \param ctx GL context.
358 * \param internalformat Format to which the data is to be converted.
359 * \param format Format of the supplied data.
360 * \param type Type of the supplied data.
361 * \param caller Name of calling function for recording errors.
362 * \return If internalformat, format and type are legal the mesa_format
363 * corresponding to internalformat, otherwise MESA_FORMAT_NONE.
364 *
365 * \sa glClearBufferData, glClearNamedBufferData, glClearBufferSubData and
366 * glClearNamedBufferSubData.
367 */
368 static mesa_format
369 validate_clear_buffer_format(struct gl_context *ctx,
370 GLenum internalformat,
371 GLenum format, GLenum type,
372 const char *caller)
373 {
374 mesa_format mesaFormat;
375 GLenum errorFormatType;
376
377 mesaFormat = _mesa_validate_texbuffer_format(ctx, internalformat);
378 if (mesaFormat == MESA_FORMAT_NONE) {
379 _mesa_error(ctx, GL_INVALID_ENUM,
380 "%s(invalid internalformat)", caller);
381 return MESA_FORMAT_NONE;
382 }
383
384 /* NOTE: not mentioned in ARB_clear_buffer_object but according to
385 * EXT_texture_integer there is no conversion between integer and
386 * non-integer formats
387 */
388 if (_mesa_is_enum_format_signed_int(format) !=
389 _mesa_is_format_integer_color(mesaFormat)) {
390 _mesa_error(ctx, GL_INVALID_OPERATION,
391 "%s(integer vs non-integer)", caller);
392 return MESA_FORMAT_NONE;
393 }
394
395 if (!_mesa_is_color_format(format)) {
396 _mesa_error(ctx, GL_INVALID_VALUE,
397 "%s(format is not a color format)", caller);
398 return MESA_FORMAT_NONE;
399 }
400
401 errorFormatType = _mesa_error_check_format_and_type(ctx, format, type);
402 if (errorFormatType != GL_NO_ERROR) {
403 _mesa_error(ctx, GL_INVALID_VALUE,
404 "%s(invalid format or type)", caller);
405 return MESA_FORMAT_NONE;
406 }
407
408 return mesaFormat;
409 }
410
411
412 /**
413 * Convert user-specified clear value to the specified internal format.
414 *
415 * \param ctx GL context.
416 * \param internalformat Format to which the data is converted.
417 * \param clearValue Points to the converted clear value.
418 * \param format Format of the supplied data.
419 * \param type Type of the supplied data.
420 * \param data Data which is to be converted to internalformat.
421 * \param caller Name of calling function for recording errors.
422 * \return true if data could be converted, false otherwise.
423 *
424 * \sa glClearBufferData, glClearBufferSubData
425 */
426 static bool
427 convert_clear_buffer_data(struct gl_context *ctx,
428 mesa_format internalformat,
429 GLubyte *clearValue, GLenum format, GLenum type,
430 const GLvoid *data, const char *caller)
431 {
432 GLenum internalformatBase = _mesa_get_format_base_format(internalformat);
433
434 if (_mesa_texstore(ctx, 1, internalformatBase, internalformat,
435 0, &clearValue, 1, 1, 1,
436 format, type, data, &ctx->Unpack)) {
437 return true;
438 }
439 else {
440 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", caller);
441 return false;
442 }
443 }
444
445
446 /**
447 * Allocate and initialize a new buffer object.
448 *
449 * Default callback for the \c dd_function_table::NewBufferObject() hook.
450 */
451 static struct gl_buffer_object *
452 _mesa_new_buffer_object(struct gl_context *ctx, GLuint name)
453 {
454 struct gl_buffer_object *obj = MALLOC_STRUCT(gl_buffer_object);
455 if (!obj)
456 return NULL;
457
458 _mesa_initialize_buffer_object(ctx, obj, name);
459 return obj;
460 }
461
462
463 /**
464 * Delete a buffer object.
465 *
466 * Default callback for the \c dd_function_table::DeleteBuffer() hook.
467 */
468 void
469 _mesa_delete_buffer_object(struct gl_context *ctx,
470 struct gl_buffer_object *bufObj)
471 {
472 (void) ctx;
473
474 vbo_delete_minmax_cache(bufObj);
475 _mesa_align_free(bufObj->Data);
476
477 /* assign strange values here to help w/ debugging */
478 bufObj->RefCount = -1000;
479 bufObj->Name = ~0;
480
481 simple_mtx_destroy(&bufObj->MinMaxCacheMutex);
482 free(bufObj->Label);
483 free(bufObj);
484 }
485
486
487
488 /**
489 * Set ptr to bufObj w/ reference counting.
490 * This is normally only called from the _mesa_reference_buffer_object() macro
491 * when there's a real pointer change.
492 */
493 void
494 _mesa_reference_buffer_object_(struct gl_context *ctx,
495 struct gl_buffer_object **ptr,
496 struct gl_buffer_object *bufObj)
497 {
498 if (*ptr) {
499 /* Unreference the old buffer */
500 struct gl_buffer_object *oldObj = *ptr;
501
502 if (p_atomic_dec_zero(&oldObj->RefCount)) {
503 assert(ctx->Driver.DeleteBuffer);
504 ctx->Driver.DeleteBuffer(ctx, oldObj);
505 }
506
507 *ptr = NULL;
508 }
509 assert(!*ptr);
510
511 if (bufObj) {
512 /* reference new buffer */
513 p_atomic_inc(&bufObj->RefCount);
514 *ptr = bufObj;
515 }
516 }
517
518
519 /**
520 * Get the value of MESA_NO_MINMAX_CACHE.
521 */
522 static bool
523 get_no_minmax_cache()
524 {
525 static bool read = false;
526 static bool disable = false;
527
528 if (!read) {
529 disable = env_var_as_boolean("MESA_NO_MINMAX_CACHE", false);
530 read = true;
531 }
532
533 return disable;
534 }
535
536
537 /**
538 * Initialize a buffer object to default values.
539 */
540 void
541 _mesa_initialize_buffer_object(struct gl_context *ctx,
542 struct gl_buffer_object *obj,
543 GLuint name)
544 {
545 memset(obj, 0, sizeof(struct gl_buffer_object));
546 obj->RefCount = 1;
547 obj->Name = name;
548 obj->Usage = GL_STATIC_DRAW_ARB;
549
550 simple_mtx_init(&obj->MinMaxCacheMutex, mtx_plain);
551 if (get_no_minmax_cache())
552 obj->UsageHistory |= USAGE_DISABLE_MINMAX_CACHE;
553 }
554
555
556
557 /**
558 * Callback called from _mesa_HashWalk()
559 */
560 static void
561 count_buffer_size(GLuint key, void *data, void *userData)
562 {
563 const struct gl_buffer_object *bufObj =
564 (const struct gl_buffer_object *) data;
565 GLuint *total = (GLuint *) userData;
566
567 (void) key;
568 *total = *total + bufObj->Size;
569 }
570
571
572 /**
573 * Compute total size (in bytes) of all buffer objects for the given context.
574 * For debugging purposes.
575 */
576 GLuint
577 _mesa_total_buffer_object_memory(struct gl_context *ctx)
578 {
579 GLuint total = 0;
580
581 _mesa_HashWalk(ctx->Shared->BufferObjects, count_buffer_size, &total);
582
583 return total;
584 }
585
586
587 /**
588 * Allocate space for and store data in a buffer object. Any data that was
589 * previously stored in the buffer object is lost. If \c data is \c NULL,
590 * memory will be allocated, but no copy will occur.
591 *
592 * This is the default callback for \c dd_function_table::BufferData()
593 * Note that all GL error checking will have been done already.
594 *
595 * \param ctx GL context.
596 * \param target Buffer object target on which to operate.
597 * \param size Size, in bytes, of the new data store.
598 * \param data Pointer to the data to store in the buffer object. This
599 * pointer may be \c NULL.
600 * \param usage Hints about how the data will be used.
601 * \param bufObj Object to be used.
602 *
603 * \return GL_TRUE for success, GL_FALSE for failure
604 * \sa glBufferDataARB, dd_function_table::BufferData.
605 */
606 static GLboolean
607 buffer_data_fallback(struct gl_context *ctx, GLenum target, GLsizeiptrARB size,
608 const GLvoid *data, GLenum usage, GLenum storageFlags,
609 struct gl_buffer_object *bufObj)
610 {
611 void * new_data;
612
613 (void) target;
614
615 _mesa_align_free( bufObj->Data );
616
617 new_data = _mesa_align_malloc( size, ctx->Const.MinMapBufferAlignment );
618 if (new_data) {
619 bufObj->Data = (GLubyte *) new_data;
620 bufObj->Size = size;
621 bufObj->Usage = usage;
622 bufObj->StorageFlags = storageFlags;
623
624 if (data) {
625 memcpy( bufObj->Data, data, size );
626 }
627
628 return GL_TRUE;
629 }
630 else {
631 return GL_FALSE;
632 }
633 }
634
635
636 /**
637 * Replace data in a subrange of buffer object. If the data range
638 * specified by \c size + \c offset extends beyond the end of the buffer or
639 * if \c data is \c NULL, no copy is performed.
640 *
641 * This is the default callback for \c dd_function_table::BufferSubData()
642 * Note that all GL error checking will have been done already.
643 *
644 * \param ctx GL context.
645 * \param offset Offset of the first byte to be modified.
646 * \param size Size, in bytes, of the data range.
647 * \param data Pointer to the data to store in the buffer object.
648 * \param bufObj Object to be used.
649 *
650 * \sa glBufferSubDataARB, dd_function_table::BufferSubData.
651 */
652 static void
653 buffer_sub_data_fallback(struct gl_context *ctx, GLintptrARB offset,
654 GLsizeiptrARB size, const GLvoid *data,
655 struct gl_buffer_object *bufObj)
656 {
657 (void) ctx;
658
659 /* this should have been caught in _mesa_BufferSubData() */
660 assert(size + offset <= bufObj->Size);
661
662 if (bufObj->Data) {
663 memcpy( (GLubyte *) bufObj->Data + offset, data, size );
664 }
665 }
666
667
668 /**
669 * Retrieve data from a subrange of buffer object. If the data range
670 * specified by \c size + \c offset extends beyond the end of the buffer or
671 * if \c data is \c NULL, no copy is performed.
672 *
673 * This is the default callback for \c dd_function_table::GetBufferSubData()
674 * Note that all GL error checking will have been done already.
675 *
676 * \param ctx GL context.
677 * \param target Buffer object target on which to operate.
678 * \param offset Offset of the first byte to be fetched.
679 * \param size Size, in bytes, of the data range.
680 * \param data Destination for data
681 * \param bufObj Object to be used.
682 *
683 * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData.
684 */
685 static void
686 buffer_get_subdata(struct gl_context *ctx, GLintptrARB offset,
687 GLsizeiptrARB size, GLvoid *data,
688 struct gl_buffer_object *bufObj )
689 {
690 (void) ctx;
691
692 if (bufObj->Data && ((GLsizeiptrARB) (size + offset) <= bufObj->Size)) {
693 memcpy( data, (GLubyte *) bufObj->Data + offset, size );
694 }
695 }
696
697
698 /**
699 * Clear a subrange of the buffer object with copies of the supplied data.
700 * If data is NULL the buffer is filled with zeros.
701 *
702 * This is the default callback for \c dd_function_table::ClearBufferSubData()
703 * Note that all GL error checking will have been done already.
704 *
705 * \param ctx GL context.
706 * \param offset Offset of the first byte to be cleared.
707 * \param size Size, in bytes, of the to be cleared range.
708 * \param clearValue Source of the data.
709 * \param clearValueSize Size, in bytes, of the supplied data.
710 * \param bufObj Object to be cleared.
711 *
712 * \sa glClearBufferSubData, glClearBufferData and
713 * dd_function_table::ClearBufferSubData.
714 */
715 void
716 _mesa_ClearBufferSubData_sw(struct gl_context *ctx,
717 GLintptr offset, GLsizeiptr size,
718 const GLvoid *clearValue,
719 GLsizeiptr clearValueSize,
720 struct gl_buffer_object *bufObj)
721 {
722 GLsizeiptr i;
723 GLubyte *dest;
724
725 assert(ctx->Driver.MapBufferRange);
726 dest = ctx->Driver.MapBufferRange(ctx, offset, size,
727 GL_MAP_WRITE_BIT |
728 GL_MAP_INVALIDATE_RANGE_BIT,
729 bufObj, MAP_INTERNAL);
730
731 if (!dest) {
732 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClearBuffer[Sub]Data");
733 return;
734 }
735
736 if (clearValue == NULL) {
737 /* Clear with zeros, per the spec */
738 memset(dest, 0, size);
739 ctx->Driver.UnmapBuffer(ctx, bufObj, MAP_INTERNAL);
740 return;
741 }
742
743 for (i = 0; i < size/clearValueSize; ++i) {
744 memcpy(dest, clearValue, clearValueSize);
745 dest += clearValueSize;
746 }
747
748 ctx->Driver.UnmapBuffer(ctx, bufObj, MAP_INTERNAL);
749 }
750
751
752 /**
753 * Default fallback for \c dd_function_table::MapBufferRange().
754 * Called via glMapBufferRange().
755 */
756 static void *
757 map_buffer_range_fallback(struct gl_context *ctx, GLintptr offset,
758 GLsizeiptr length, GLbitfield access,
759 struct gl_buffer_object *bufObj,
760 gl_map_buffer_index index)
761 {
762 (void) ctx;
763 assert(!_mesa_bufferobj_mapped(bufObj, index));
764 /* Just return a direct pointer to the data */
765 bufObj->Mappings[index].Pointer = bufObj->Data + offset;
766 bufObj->Mappings[index].Length = length;
767 bufObj->Mappings[index].Offset = offset;
768 bufObj->Mappings[index].AccessFlags = access;
769 return bufObj->Mappings[index].Pointer;
770 }
771
772
773 /**
774 * Default fallback for \c dd_function_table::FlushMappedBufferRange().
775 * Called via glFlushMappedBufferRange().
776 */
777 static void
778 flush_mapped_buffer_range_fallback(struct gl_context *ctx,
779 GLintptr offset, GLsizeiptr length,
780 struct gl_buffer_object *obj,
781 gl_map_buffer_index index)
782 {
783 (void) ctx;
784 (void) offset;
785 (void) length;
786 (void) obj;
787 (void) index;
788 /* no-op */
789 }
790
791
792 /**
793 * Default callback for \c dd_function_table::UnmapBuffer().
794 *
795 * The input parameters will have been already tested for errors.
796 *
797 * \sa glUnmapBufferARB, dd_function_table::UnmapBuffer
798 */
799 static GLboolean
800 unmap_buffer_fallback(struct gl_context *ctx, struct gl_buffer_object *bufObj,
801 gl_map_buffer_index index)
802 {
803 (void) ctx;
804 /* XXX we might assert here that bufObj->Pointer is non-null */
805 bufObj->Mappings[index].Pointer = NULL;
806 bufObj->Mappings[index].Length = 0;
807 bufObj->Mappings[index].Offset = 0;
808 bufObj->Mappings[index].AccessFlags = 0x0;
809 return GL_TRUE;
810 }
811
812
813 /**
814 * Default fallback for \c dd_function_table::CopyBufferSubData().
815 * Called via glCopyBufferSubData().
816 */
817 static void
818 copy_buffer_sub_data_fallback(struct gl_context *ctx,
819 struct gl_buffer_object *src,
820 struct gl_buffer_object *dst,
821 GLintptr readOffset, GLintptr writeOffset,
822 GLsizeiptr size)
823 {
824 GLubyte *srcPtr, *dstPtr;
825
826 if (src == dst) {
827 srcPtr = dstPtr = ctx->Driver.MapBufferRange(ctx, 0, src->Size,
828 GL_MAP_READ_BIT |
829 GL_MAP_WRITE_BIT, src,
830 MAP_INTERNAL);
831
832 if (!srcPtr)
833 return;
834
835 srcPtr += readOffset;
836 dstPtr += writeOffset;
837 } else {
838 srcPtr = ctx->Driver.MapBufferRange(ctx, readOffset, size,
839 GL_MAP_READ_BIT, src,
840 MAP_INTERNAL);
841 dstPtr = ctx->Driver.MapBufferRange(ctx, writeOffset, size,
842 (GL_MAP_WRITE_BIT |
843 GL_MAP_INVALIDATE_RANGE_BIT), dst,
844 MAP_INTERNAL);
845 }
846
847 /* Note: the src and dst regions will never overlap. Trying to do so
848 * would generate GL_INVALID_VALUE earlier.
849 */
850 if (srcPtr && dstPtr)
851 memcpy(dstPtr, srcPtr, size);
852
853 ctx->Driver.UnmapBuffer(ctx, src, MAP_INTERNAL);
854 if (dst != src)
855 ctx->Driver.UnmapBuffer(ctx, dst, MAP_INTERNAL);
856 }
857
858
859
860 /**
861 * Initialize the state associated with buffer objects
862 */
863 void
864 _mesa_init_buffer_objects( struct gl_context *ctx )
865 {
866 GLuint i;
867
868 memset(&DummyBufferObject, 0, sizeof(DummyBufferObject));
869 simple_mtx_init(&DummyBufferObject.MinMaxCacheMutex, mtx_plain);
870 DummyBufferObject.RefCount = 1000*1000*1000; /* never delete */
871
872 _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj,
873 ctx->Shared->NullBufferObj);
874
875 _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer,
876 ctx->Shared->NullBufferObj);
877 _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer,
878 ctx->Shared->NullBufferObj);
879
880 _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer,
881 ctx->Shared->NullBufferObj);
882
883 _mesa_reference_buffer_object(ctx, &ctx->ShaderStorageBuffer,
884 ctx->Shared->NullBufferObj);
885
886 _mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer,
887 ctx->Shared->NullBufferObj);
888
889 _mesa_reference_buffer_object(ctx, &ctx->DrawIndirectBuffer,
890 ctx->Shared->NullBufferObj);
891
892 _mesa_reference_buffer_object(ctx, &ctx->ParameterBuffer,
893 ctx->Shared->NullBufferObj);
894
895 _mesa_reference_buffer_object(ctx, &ctx->DispatchIndirectBuffer,
896 ctx->Shared->NullBufferObj);
897
898 _mesa_reference_buffer_object(ctx, &ctx->QueryBuffer,
899 ctx->Shared->NullBufferObj);
900
901 for (i = 0; i < MAX_COMBINED_UNIFORM_BUFFERS; i++) {
902 _mesa_reference_buffer_object(ctx,
903 &ctx->UniformBufferBindings[i].BufferObject,
904 ctx->Shared->NullBufferObj);
905 ctx->UniformBufferBindings[i].Offset = -1;
906 ctx->UniformBufferBindings[i].Size = -1;
907 }
908
909 for (i = 0; i < MAX_COMBINED_SHADER_STORAGE_BUFFERS; i++) {
910 _mesa_reference_buffer_object(ctx,
911 &ctx->ShaderStorageBufferBindings[i].BufferObject,
912 ctx->Shared->NullBufferObj);
913 ctx->ShaderStorageBufferBindings[i].Offset = -1;
914 ctx->ShaderStorageBufferBindings[i].Size = -1;
915 }
916
917 for (i = 0; i < MAX_COMBINED_ATOMIC_BUFFERS; i++) {
918 _mesa_reference_buffer_object(ctx,
919 &ctx->AtomicBufferBindings[i].BufferObject,
920 ctx->Shared->NullBufferObj);
921 ctx->AtomicBufferBindings[i].Offset = 0;
922 ctx->AtomicBufferBindings[i].Size = 0;
923 }
924 }
925
926
927 void
928 _mesa_free_buffer_objects( struct gl_context *ctx )
929 {
930 GLuint i;
931
932 _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
933
934 _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer, NULL);
935 _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer, NULL);
936
937 _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, NULL);
938
939 _mesa_reference_buffer_object(ctx, &ctx->ShaderStorageBuffer, NULL);
940
941 _mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer, NULL);
942
943 _mesa_reference_buffer_object(ctx, &ctx->DrawIndirectBuffer, NULL);
944
945 _mesa_reference_buffer_object(ctx, &ctx->ParameterBuffer, NULL);
946
947 _mesa_reference_buffer_object(ctx, &ctx->DispatchIndirectBuffer, NULL);
948
949 _mesa_reference_buffer_object(ctx, &ctx->QueryBuffer, NULL);
950
951 for (i = 0; i < MAX_COMBINED_UNIFORM_BUFFERS; i++) {
952 _mesa_reference_buffer_object(ctx,
953 &ctx->UniformBufferBindings[i].BufferObject,
954 NULL);
955 }
956
957 for (i = 0; i < MAX_COMBINED_SHADER_STORAGE_BUFFERS; i++) {
958 _mesa_reference_buffer_object(ctx,
959 &ctx->ShaderStorageBufferBindings[i].BufferObject,
960 NULL);
961 }
962
963 for (i = 0; i < MAX_COMBINED_ATOMIC_BUFFERS; i++) {
964 _mesa_reference_buffer_object(ctx,
965 &ctx->AtomicBufferBindings[i].BufferObject,
966 NULL);
967 }
968
969 }
970
971 bool
972 _mesa_handle_bind_buffer_gen(struct gl_context *ctx,
973 GLuint buffer,
974 struct gl_buffer_object **buf_handle,
975 const char *caller)
976 {
977 struct gl_buffer_object *buf = *buf_handle;
978
979 if (!buf && (ctx->API == API_OPENGL_CORE)) {
980 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-gen name)", caller);
981 return false;
982 }
983
984 if (!buf || buf == &DummyBufferObject) {
985 /* If this is a new buffer object id, or one which was generated but
986 * never used before, allocate a buffer object now.
987 */
988 buf = ctx->Driver.NewBufferObject(ctx, buffer);
989 if (!buf) {
990 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", caller);
991 return false;
992 }
993 _mesa_HashInsert(ctx->Shared->BufferObjects, buffer, buf);
994 *buf_handle = buf;
995 }
996
997 return true;
998 }
999
1000 /**
1001 * Bind the specified target to buffer for the specified context.
1002 * Called by glBindBuffer() and other functions.
1003 */
1004 static void
1005 bind_buffer_object(struct gl_context *ctx,
1006 struct gl_buffer_object **bindTarget, GLuint buffer)
1007 {
1008 struct gl_buffer_object *oldBufObj;
1009 struct gl_buffer_object *newBufObj = NULL;
1010
1011 assert(bindTarget);
1012
1013 /* Get pointer to old buffer object (to be unbound) */
1014 oldBufObj = *bindTarget;
1015 if (oldBufObj && oldBufObj->Name == buffer && !oldBufObj->DeletePending)
1016 return; /* rebinding the same buffer object- no change */
1017
1018 /*
1019 * Get pointer to new buffer object (newBufObj)
1020 */
1021 if (buffer == 0) {
1022 /* The spec says there's not a buffer object named 0, but we use
1023 * one internally because it simplifies things.
1024 */
1025 newBufObj = ctx->Shared->NullBufferObj;
1026 }
1027 else {
1028 /* non-default buffer object */
1029 newBufObj = _mesa_lookup_bufferobj(ctx, buffer);
1030 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
1031 &newBufObj, "glBindBuffer"))
1032 return;
1033 }
1034
1035 /* record usage history */
1036 if (bindTarget == &ctx->Pack.BufferObj) {
1037 newBufObj->UsageHistory |= USAGE_PIXEL_PACK_BUFFER;
1038 }
1039
1040 /* bind new buffer */
1041 _mesa_reference_buffer_object(ctx, bindTarget, newBufObj);
1042 }
1043
1044
1045 /**
1046 * Update the default buffer objects in the given context to reference those
1047 * specified in the shared state and release those referencing the old
1048 * shared state.
1049 */
1050 void
1051 _mesa_update_default_objects_buffer_objects(struct gl_context *ctx)
1052 {
1053 /* Bind the NullBufferObj to remove references to those
1054 * in the shared context hash table.
1055 */
1056 bind_buffer_object(ctx, &ctx->Array.ArrayBufferObj, 0);
1057 bind_buffer_object(ctx, &ctx->Array.VAO->IndexBufferObj, 0);
1058 bind_buffer_object(ctx, &ctx->Pack.BufferObj, 0);
1059 bind_buffer_object(ctx, &ctx->Unpack.BufferObj, 0);
1060 }
1061
1062
1063
1064 /**
1065 * Return the gl_buffer_object for the given ID.
1066 * Always return NULL for ID 0.
1067 */
1068 struct gl_buffer_object *
1069 _mesa_lookup_bufferobj(struct gl_context *ctx, GLuint buffer)
1070 {
1071 if (buffer == 0)
1072 return NULL;
1073 else
1074 return (struct gl_buffer_object *)
1075 _mesa_HashLookup(ctx->Shared->BufferObjects, buffer);
1076 }
1077
1078
1079 struct gl_buffer_object *
1080 _mesa_lookup_bufferobj_locked(struct gl_context *ctx, GLuint buffer)
1081 {
1082 if (buffer == 0)
1083 return NULL;
1084 else
1085 return (struct gl_buffer_object *)
1086 _mesa_HashLookupLocked(ctx->Shared->BufferObjects, buffer);
1087 }
1088
1089 /**
1090 * A convenience function for direct state access functions that throws
1091 * GL_INVALID_OPERATION if buffer is not the name of an existing
1092 * buffer object.
1093 */
1094 struct gl_buffer_object *
1095 _mesa_lookup_bufferobj_err(struct gl_context *ctx, GLuint buffer,
1096 const char *caller)
1097 {
1098 struct gl_buffer_object *bufObj;
1099
1100 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
1101 if (!bufObj || bufObj == &DummyBufferObject) {
1102 _mesa_error(ctx, GL_INVALID_OPERATION,
1103 "%s(non-existent buffer object %u)", caller, buffer);
1104 return NULL;
1105 }
1106
1107 return bufObj;
1108 }
1109
1110
1111 /**
1112 * Look up a buffer object for a multi-bind function.
1113 *
1114 * Unlike _mesa_lookup_bufferobj(), this function also takes care
1115 * of generating an error if the buffer ID is not zero or the name
1116 * of an existing buffer object.
1117 *
1118 * If the buffer ID refers to an existing buffer object, a pointer
1119 * to the buffer object is returned. If the ID is zero, a pointer
1120 * to the shared NullBufferObj is returned. If the ID is not zero
1121 * and does not refer to a valid buffer object, this function
1122 * returns NULL.
1123 *
1124 * This function assumes that the caller has already locked the
1125 * hash table mutex by calling
1126 * _mesa_HashLockMutex(ctx->Shared->BufferObjects).
1127 */
1128 struct gl_buffer_object *
1129 _mesa_multi_bind_lookup_bufferobj(struct gl_context *ctx,
1130 const GLuint *buffers,
1131 GLuint index, const char *caller)
1132 {
1133 struct gl_buffer_object *bufObj;
1134
1135 if (buffers[index] != 0) {
1136 bufObj = _mesa_lookup_bufferobj_locked(ctx, buffers[index]);
1137
1138 /* The multi-bind functions don't create the buffer objects
1139 when they don't exist. */
1140 if (bufObj == &DummyBufferObject)
1141 bufObj = NULL;
1142 } else
1143 bufObj = ctx->Shared->NullBufferObj;
1144
1145 if (!bufObj) {
1146 /* The ARB_multi_bind spec says:
1147 *
1148 * "An INVALID_OPERATION error is generated if any value
1149 * in <buffers> is not zero or the name of an existing
1150 * buffer object (per binding)."
1151 */
1152 _mesa_error(ctx, GL_INVALID_OPERATION,
1153 "%s(buffers[%u]=%u is not zero or the name "
1154 "of an existing buffer object)",
1155 caller, index, buffers[index]);
1156 }
1157
1158 return bufObj;
1159 }
1160
1161
1162 /**
1163 * If *ptr points to obj, set ptr = the Null/default buffer object.
1164 * This is a helper for buffer object deletion.
1165 * The GL spec says that deleting a buffer object causes it to get
1166 * unbound from all arrays in the current context.
1167 */
1168 static void
1169 unbind(struct gl_context *ctx,
1170 struct gl_vertex_array_object *vao, unsigned index,
1171 struct gl_buffer_object *obj)
1172 {
1173 if (vao->BufferBinding[index].BufferObj == obj) {
1174 _mesa_bind_vertex_buffer(ctx, vao, index, ctx->Shared->NullBufferObj,
1175 vao->BufferBinding[index].Offset,
1176 vao->BufferBinding[index].Stride);
1177 }
1178 }
1179
1180
1181 /**
1182 * Plug default/fallback buffer object functions into the device
1183 * driver hooks.
1184 */
1185 void
1186 _mesa_init_buffer_object_functions(struct dd_function_table *driver)
1187 {
1188 /* GL_ARB_vertex/pixel_buffer_object */
1189 driver->NewBufferObject = _mesa_new_buffer_object;
1190 driver->DeleteBuffer = _mesa_delete_buffer_object;
1191 driver->BufferData = buffer_data_fallback;
1192 driver->BufferSubData = buffer_sub_data_fallback;
1193 driver->GetBufferSubData = buffer_get_subdata;
1194 driver->UnmapBuffer = unmap_buffer_fallback;
1195
1196 /* GL_ARB_clear_buffer_object */
1197 driver->ClearBufferSubData = _mesa_ClearBufferSubData_sw;
1198
1199 /* GL_ARB_map_buffer_range */
1200 driver->MapBufferRange = map_buffer_range_fallback;
1201 driver->FlushMappedBufferRange = flush_mapped_buffer_range_fallback;
1202
1203 /* GL_ARB_copy_buffer */
1204 driver->CopyBufferSubData = copy_buffer_sub_data_fallback;
1205 }
1206
1207
1208 void
1209 _mesa_buffer_unmap_all_mappings(struct gl_context *ctx,
1210 struct gl_buffer_object *bufObj)
1211 {
1212 for (int i = 0; i < MAP_COUNT; i++) {
1213 if (_mesa_bufferobj_mapped(bufObj, i)) {
1214 ctx->Driver.UnmapBuffer(ctx, bufObj, i);
1215 assert(bufObj->Mappings[i].Pointer == NULL);
1216 bufObj->Mappings[i].AccessFlags = 0;
1217 }
1218 }
1219 }
1220
1221
1222 /**********************************************************************/
1223 /* API Functions */
1224 /**********************************************************************/
1225
1226 void GLAPIENTRY
1227 _mesa_BindBuffer_no_error(GLenum target, GLuint buffer)
1228 {
1229 GET_CURRENT_CONTEXT(ctx);
1230
1231 struct gl_buffer_object **bindTarget = get_buffer_target(ctx, target);
1232 bind_buffer_object(ctx, bindTarget, buffer);
1233 }
1234
1235
1236 void GLAPIENTRY
1237 _mesa_BindBuffer(GLenum target, GLuint buffer)
1238 {
1239 GET_CURRENT_CONTEXT(ctx);
1240
1241 if (MESA_VERBOSE & VERBOSE_API) {
1242 _mesa_debug(ctx, "glBindBuffer(%s, %u)\n",
1243 _mesa_enum_to_string(target), buffer);
1244 }
1245
1246 struct gl_buffer_object **bindTarget = get_buffer_target(ctx, target);
1247 if (!bindTarget) {
1248 _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target %s)",
1249 _mesa_enum_to_string(target));
1250 return;
1251 }
1252
1253 bind_buffer_object(ctx, bindTarget, buffer);
1254 }
1255
1256 /**
1257 * Binds a buffer object to a binding point.
1258 *
1259 * The caller is responsible for validating the offset,
1260 * flushing the vertices and updating NewDriverState.
1261 */
1262 static void
1263 set_buffer_binding(struct gl_context *ctx,
1264 struct gl_buffer_binding *binding,
1265 struct gl_buffer_object *bufObj,
1266 GLintptr offset,
1267 GLsizeiptr size,
1268 bool autoSize, gl_buffer_usage usage)
1269 {
1270 _mesa_reference_buffer_object(ctx, &binding->BufferObject, bufObj);
1271
1272 binding->Offset = offset;
1273 binding->Size = size;
1274 binding->AutomaticSize = autoSize;
1275
1276 /* If this is a real buffer object, mark it has having been used
1277 * at some point as an atomic counter buffer.
1278 */
1279 if (size >= 0)
1280 bufObj->UsageHistory |= usage;
1281 }
1282
1283 static void
1284 set_buffer_multi_binding(struct gl_context *ctx,
1285 const GLuint *buffers,
1286 int idx,
1287 const char *caller,
1288 struct gl_buffer_binding *binding,
1289 GLintptr offset,
1290 GLsizeiptr size,
1291 bool range,
1292 gl_buffer_usage usage)
1293 {
1294 struct gl_buffer_object *bufObj;
1295 if (binding->BufferObject && binding->BufferObject->Name == buffers[idx])
1296 bufObj = binding->BufferObject;
1297 else
1298 bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, idx, caller);
1299
1300 if (bufObj) {
1301 if (bufObj == ctx->Shared->NullBufferObj)
1302 set_buffer_binding(ctx, binding, bufObj, -1, -1, !range, usage);
1303 else
1304 set_buffer_binding(ctx, binding, bufObj, offset, size, !range, usage);
1305 }
1306 }
1307
1308 static void
1309 bind_buffer(struct gl_context *ctx,
1310 struct gl_buffer_binding *binding,
1311 struct gl_buffer_object *bufObj,
1312 GLintptr offset,
1313 GLsizeiptr size,
1314 GLboolean autoSize,
1315 uint64_t driver_state,
1316 gl_buffer_usage usage)
1317 {
1318 if (binding->BufferObject == bufObj &&
1319 binding->Offset == offset &&
1320 binding->Size == size &&
1321 binding->AutomaticSize == autoSize) {
1322 return;
1323 }
1324
1325 FLUSH_VERTICES(ctx, 0);
1326 ctx->NewDriverState |= driver_state;
1327
1328 set_buffer_binding(ctx, binding, bufObj, offset, size, autoSize, usage);
1329 }
1330
1331 /**
1332 * Binds a buffer object to a uniform buffer binding point.
1333 *
1334 * Unlike set_buffer_binding(), this function also flushes vertices
1335 * and updates NewDriverState. It also checks if the binding
1336 * has actually changed before updating it.
1337 */
1338 static void
1339 bind_uniform_buffer(struct gl_context *ctx,
1340 GLuint index,
1341 struct gl_buffer_object *bufObj,
1342 GLintptr offset,
1343 GLsizeiptr size,
1344 GLboolean autoSize)
1345 {
1346 bind_buffer(ctx, &ctx->UniformBufferBindings[index],
1347 bufObj, offset, size, autoSize,
1348 ctx->DriverFlags.NewUniformBuffer,
1349 USAGE_UNIFORM_BUFFER);
1350 }
1351
1352 /**
1353 * Binds a buffer object to a shader storage buffer binding point.
1354 *
1355 * Unlike set_ssbo_binding(), this function also flushes vertices
1356 * and updates NewDriverState. It also checks if the binding
1357 * has actually changed before updating it.
1358 */
1359 static void
1360 bind_shader_storage_buffer(struct gl_context *ctx,
1361 GLuint index,
1362 struct gl_buffer_object *bufObj,
1363 GLintptr offset,
1364 GLsizeiptr size,
1365 GLboolean autoSize)
1366 {
1367 bind_buffer(ctx, &ctx->ShaderStorageBufferBindings[index],
1368 bufObj, offset, size, autoSize,
1369 ctx->DriverFlags.NewShaderStorageBuffer,
1370 USAGE_SHADER_STORAGE_BUFFER);
1371 }
1372
1373 /**
1374 * Binds a buffer object to an atomic buffer binding point.
1375 *
1376 * Unlike set_atomic_binding(), this function also flushes vertices
1377 * and updates NewDriverState. It also checks if the binding
1378 * has actually changed before updating it.
1379 */
1380 static void
1381 bind_atomic_buffer(struct gl_context *ctx, unsigned index,
1382 struct gl_buffer_object *bufObj, GLintptr offset,
1383 GLsizeiptr size, GLboolean autoSize)
1384 {
1385 bind_buffer(ctx, &ctx->AtomicBufferBindings[index],
1386 bufObj, offset, size, autoSize,
1387 ctx->DriverFlags.NewAtomicBuffer,
1388 USAGE_ATOMIC_COUNTER_BUFFER);
1389 }
1390
1391 /**
1392 * Bind a buffer object to a uniform block binding point.
1393 * As above, but offset = 0.
1394 */
1395 static void
1396 bind_buffer_base_uniform_buffer(struct gl_context *ctx,
1397 GLuint index,
1398 struct gl_buffer_object *bufObj)
1399 {
1400 if (index >= ctx->Const.MaxUniformBufferBindings) {
1401 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferBase(index=%d)", index);
1402 return;
1403 }
1404
1405 _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, bufObj);
1406
1407 if (bufObj == ctx->Shared->NullBufferObj)
1408 bind_uniform_buffer(ctx, index, bufObj, -1, -1, GL_TRUE);
1409 else
1410 bind_uniform_buffer(ctx, index, bufObj, 0, 0, GL_TRUE);
1411 }
1412
1413 /**
1414 * Bind a buffer object to a shader storage block binding point.
1415 * As above, but offset = 0.
1416 */
1417 static void
1418 bind_buffer_base_shader_storage_buffer(struct gl_context *ctx,
1419 GLuint index,
1420 struct gl_buffer_object *bufObj)
1421 {
1422 if (index >= ctx->Const.MaxShaderStorageBufferBindings) {
1423 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferBase(index=%d)", index);
1424 return;
1425 }
1426
1427 _mesa_reference_buffer_object(ctx, &ctx->ShaderStorageBuffer, bufObj);
1428
1429 if (bufObj == ctx->Shared->NullBufferObj)
1430 bind_shader_storage_buffer(ctx, index, bufObj, -1, -1, GL_TRUE);
1431 else
1432 bind_shader_storage_buffer(ctx, index, bufObj, 0, 0, GL_TRUE);
1433 }
1434
1435 /**
1436 * Bind a buffer object to a shader storage block binding point.
1437 * As above, but offset = 0.
1438 */
1439 static void
1440 bind_buffer_base_atomic_buffer(struct gl_context *ctx,
1441 GLuint index,
1442 struct gl_buffer_object *bufObj)
1443 {
1444 if (index >= ctx->Const.MaxAtomicBufferBindings) {
1445 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferBase(index=%d)", index);
1446 return;
1447 }
1448
1449 _mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer, bufObj);
1450
1451 if (bufObj == ctx->Shared->NullBufferObj)
1452 bind_atomic_buffer(ctx, index, bufObj, -1, -1, GL_TRUE);
1453 else
1454 bind_atomic_buffer(ctx, index, bufObj, 0, 0, GL_TRUE);
1455 }
1456
1457 /**
1458 * Delete a set of buffer objects.
1459 *
1460 * \param n Number of buffer objects to delete.
1461 * \param ids Array of \c n buffer object IDs.
1462 */
1463 static void
1464 delete_buffers(struct gl_context *ctx, GLsizei n, const GLuint *ids)
1465 {
1466 FLUSH_VERTICES(ctx, 0);
1467
1468 _mesa_HashLockMutex(ctx->Shared->BufferObjects);
1469
1470 for (GLsizei i = 0; i < n; i++) {
1471 struct gl_buffer_object *bufObj =
1472 _mesa_lookup_bufferobj_locked(ctx, ids[i]);
1473 if (bufObj) {
1474 struct gl_vertex_array_object *vao = ctx->Array.VAO;
1475 GLuint j;
1476
1477 assert(bufObj->Name == ids[i] || bufObj == &DummyBufferObject);
1478
1479 _mesa_buffer_unmap_all_mappings(ctx, bufObj);
1480
1481 /* unbind any vertex pointers bound to this buffer */
1482 for (j = 0; j < ARRAY_SIZE(vao->BufferBinding); j++) {
1483 unbind(ctx, vao, j, bufObj);
1484 }
1485
1486 if (ctx->Array.ArrayBufferObj == bufObj) {
1487 bind_buffer_object(ctx, &ctx->Array.ArrayBufferObj, 0);
1488 }
1489 if (vao->IndexBufferObj == bufObj) {
1490 bind_buffer_object(ctx, &vao->IndexBufferObj, 0);
1491 }
1492
1493 /* unbind ARB_draw_indirect binding point */
1494 if (ctx->DrawIndirectBuffer == bufObj) {
1495 bind_buffer_object(ctx, &ctx->DrawIndirectBuffer, 0);
1496 }
1497
1498 /* unbind ARB_indirect_parameters binding point */
1499 if (ctx->ParameterBuffer == bufObj) {
1500 bind_buffer_object(ctx, &ctx->ParameterBuffer, 0);
1501 }
1502
1503 /* unbind ARB_compute_shader binding point */
1504 if (ctx->DispatchIndirectBuffer == bufObj) {
1505 bind_buffer_object(ctx, &ctx->DispatchIndirectBuffer, 0);
1506 }
1507
1508 /* unbind ARB_copy_buffer binding points */
1509 if (ctx->CopyReadBuffer == bufObj) {
1510 bind_buffer_object(ctx, &ctx->CopyReadBuffer, 0);
1511 }
1512 if (ctx->CopyWriteBuffer == bufObj) {
1513 bind_buffer_object(ctx, &ctx->CopyWriteBuffer, 0);
1514 }
1515
1516 /* unbind transform feedback binding points */
1517 if (ctx->TransformFeedback.CurrentBuffer == bufObj) {
1518 bind_buffer_object(ctx, &ctx->TransformFeedback.CurrentBuffer, 0);
1519 }
1520 for (j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
1521 if (ctx->TransformFeedback.CurrentObject->Buffers[j] == bufObj) {
1522 _mesa_bind_buffer_base_transform_feedback(ctx,
1523 ctx->TransformFeedback.CurrentObject,
1524 j, ctx->Shared->NullBufferObj,
1525 false);
1526 }
1527 }
1528
1529 /* unbind UBO binding points */
1530 for (j = 0; j < ctx->Const.MaxUniformBufferBindings; j++) {
1531 if (ctx->UniformBufferBindings[j].BufferObject == bufObj) {
1532 bind_buffer_base_uniform_buffer(ctx, j,
1533 ctx->Shared->NullBufferObj);
1534 }
1535 }
1536
1537 if (ctx->UniformBuffer == bufObj) {
1538 bind_buffer_object(ctx, &ctx->UniformBuffer, 0);
1539 }
1540
1541 /* unbind SSBO binding points */
1542 for (j = 0; j < ctx->Const.MaxShaderStorageBufferBindings; j++) {
1543 if (ctx->ShaderStorageBufferBindings[j].BufferObject == bufObj) {
1544 bind_buffer_base_shader_storage_buffer(ctx, j,
1545 ctx->Shared->NullBufferObj);
1546 }
1547 }
1548
1549 if (ctx->ShaderStorageBuffer == bufObj) {
1550 bind_buffer_object(ctx, &ctx->ShaderStorageBuffer, 0);
1551 }
1552
1553 /* unbind Atomci Buffer binding points */
1554 for (j = 0; j < ctx->Const.MaxAtomicBufferBindings; j++) {
1555 if (ctx->AtomicBufferBindings[j].BufferObject == bufObj) {
1556 bind_buffer_base_atomic_buffer(ctx, j,
1557 ctx->Shared->NullBufferObj);
1558 }
1559 }
1560
1561 if (ctx->AtomicBuffer == bufObj) {
1562 bind_buffer_object(ctx, &ctx->AtomicBuffer, 0);
1563 }
1564
1565 /* unbind any pixel pack/unpack pointers bound to this buffer */
1566 if (ctx->Pack.BufferObj == bufObj) {
1567 bind_buffer_object(ctx, &ctx->Pack.BufferObj, 0);
1568 }
1569 if (ctx->Unpack.BufferObj == bufObj) {
1570 bind_buffer_object(ctx, &ctx->Unpack.BufferObj, 0);
1571 }
1572
1573 if (ctx->Texture.BufferObject == bufObj) {
1574 bind_buffer_object(ctx, &ctx->Texture.BufferObject, 0);
1575 }
1576
1577 if (ctx->ExternalVirtualMemoryBuffer == bufObj) {
1578 bind_buffer_object(ctx, &ctx->ExternalVirtualMemoryBuffer, 0);
1579 }
1580
1581 /* unbind query buffer binding point */
1582 if (ctx->QueryBuffer == bufObj) {
1583 bind_buffer_object(ctx, &ctx->QueryBuffer, 0);
1584 }
1585
1586 /* The ID is immediately freed for re-use */
1587 _mesa_HashRemoveLocked(ctx->Shared->BufferObjects, ids[i]);
1588 /* Make sure we do not run into the classic ABA problem on bind.
1589 * We don't want to allow re-binding a buffer object that's been
1590 * "deleted" by glDeleteBuffers().
1591 *
1592 * The explicit rebinding to the default object in the current context
1593 * prevents the above in the current context, but another context
1594 * sharing the same objects might suffer from this problem.
1595 * The alternative would be to do the hash lookup in any case on bind
1596 * which would introduce more runtime overhead than this.
1597 */
1598 bufObj->DeletePending = GL_TRUE;
1599 _mesa_reference_buffer_object(ctx, &bufObj, NULL);
1600 }
1601 }
1602
1603 _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
1604 }
1605
1606
1607 void GLAPIENTRY
1608 _mesa_DeleteBuffers_no_error(GLsizei n, const GLuint *ids)
1609 {
1610 GET_CURRENT_CONTEXT(ctx);
1611 delete_buffers(ctx, n, ids);
1612 }
1613
1614
1615 void GLAPIENTRY
1616 _mesa_DeleteBuffers(GLsizei n, const GLuint *ids)
1617 {
1618 GET_CURRENT_CONTEXT(ctx);
1619
1620 if (n < 0) {
1621 _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteBuffersARB(n)");
1622 return;
1623 }
1624
1625 delete_buffers(ctx, n, ids);
1626 }
1627
1628
1629 /**
1630 * This is the implementation for glGenBuffers and glCreateBuffers. It is not
1631 * exposed to the rest of Mesa to encourage the use of nameless buffers in
1632 * driver internals.
1633 */
1634 static void
1635 create_buffers(struct gl_context *ctx, GLsizei n, GLuint *buffers, bool dsa)
1636 {
1637 GLuint first;
1638 struct gl_buffer_object *buf;
1639
1640 if (!buffers)
1641 return;
1642
1643 /*
1644 * This must be atomic (generation and allocation of buffer object IDs)
1645 */
1646 _mesa_HashLockMutex(ctx->Shared->BufferObjects);
1647
1648 first = _mesa_HashFindFreeKeyBlock(ctx->Shared->BufferObjects, n);
1649
1650 /* Insert the ID and pointer into the hash table. If non-DSA, insert a
1651 * DummyBufferObject. Otherwise, create a new buffer object and insert
1652 * it.
1653 */
1654 for (int i = 0; i < n; i++) {
1655 buffers[i] = first + i;
1656 if (dsa) {
1657 assert(ctx->Driver.NewBufferObject);
1658 buf = ctx->Driver.NewBufferObject(ctx, buffers[i]);
1659 if (!buf) {
1660 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCreateBuffers");
1661 _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
1662 return;
1663 }
1664 }
1665 else
1666 buf = &DummyBufferObject;
1667
1668 _mesa_HashInsertLocked(ctx->Shared->BufferObjects, buffers[i], buf);
1669 }
1670
1671 _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
1672 }
1673
1674
1675 static void
1676 create_buffers_err(struct gl_context *ctx, GLsizei n, GLuint *buffers, bool dsa)
1677 {
1678 const char *func = dsa ? "glCreateBuffers" : "glGenBuffers";
1679
1680 if (MESA_VERBOSE & VERBOSE_API)
1681 _mesa_debug(ctx, "%s(%d)\n", func, n);
1682
1683 if (n < 0) {
1684 _mesa_error(ctx, GL_INVALID_VALUE, "%s(n %d < 0)", func, n);
1685 return;
1686 }
1687
1688 create_buffers(ctx, n, buffers, dsa);
1689 }
1690
1691 /**
1692 * Generate a set of unique buffer object IDs and store them in \c buffers.
1693 *
1694 * \param n Number of IDs to generate.
1695 * \param buffers Array of \c n locations to store the IDs.
1696 */
1697 void GLAPIENTRY
1698 _mesa_GenBuffers_no_error(GLsizei n, GLuint *buffers)
1699 {
1700 GET_CURRENT_CONTEXT(ctx);
1701 create_buffers(ctx, n, buffers, false);
1702 }
1703
1704
1705 void GLAPIENTRY
1706 _mesa_GenBuffers(GLsizei n, GLuint *buffers)
1707 {
1708 GET_CURRENT_CONTEXT(ctx);
1709 create_buffers_err(ctx, n, buffers, false);
1710 }
1711
1712 /**
1713 * Create a set of buffer objects and store their unique IDs in \c buffers.
1714 *
1715 * \param n Number of IDs to generate.
1716 * \param buffers Array of \c n locations to store the IDs.
1717 */
1718 void GLAPIENTRY
1719 _mesa_CreateBuffers_no_error(GLsizei n, GLuint *buffers)
1720 {
1721 GET_CURRENT_CONTEXT(ctx);
1722 create_buffers(ctx, n, buffers, true);
1723 }
1724
1725
1726 void GLAPIENTRY
1727 _mesa_CreateBuffers(GLsizei n, GLuint *buffers)
1728 {
1729 GET_CURRENT_CONTEXT(ctx);
1730 create_buffers_err(ctx, n, buffers, true);
1731 }
1732
1733
1734 /**
1735 * Determine if ID is the name of a buffer object.
1736 *
1737 * \param id ID of the potential buffer object.
1738 * \return \c GL_TRUE if \c id is the name of a buffer object,
1739 * \c GL_FALSE otherwise.
1740 */
1741 GLboolean GLAPIENTRY
1742 _mesa_IsBuffer(GLuint id)
1743 {
1744 struct gl_buffer_object *bufObj;
1745 GET_CURRENT_CONTEXT(ctx);
1746 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
1747
1748 bufObj = _mesa_lookup_bufferobj(ctx, id);
1749
1750 return bufObj && bufObj != &DummyBufferObject;
1751 }
1752
1753
1754 static bool
1755 validate_buffer_storage(struct gl_context *ctx,
1756 struct gl_buffer_object *bufObj, GLsizeiptr size,
1757 GLbitfield flags, const char *func)
1758 {
1759 if (size <= 0) {
1760 _mesa_error(ctx, GL_INVALID_VALUE, "%s(size <= 0)", func);
1761 return false;
1762 }
1763
1764 GLbitfield valid_flags = GL_MAP_READ_BIT |
1765 GL_MAP_WRITE_BIT |
1766 GL_MAP_PERSISTENT_BIT |
1767 GL_MAP_COHERENT_BIT |
1768 GL_DYNAMIC_STORAGE_BIT |
1769 GL_CLIENT_STORAGE_BIT;
1770
1771 if (ctx->Extensions.ARB_sparse_buffer)
1772 valid_flags |= GL_SPARSE_STORAGE_BIT_ARB;
1773
1774 if (flags & ~valid_flags) {
1775 _mesa_error(ctx, GL_INVALID_VALUE, "%s(invalid flag bits set)", func);
1776 return false;
1777 }
1778
1779 /* The Errors section of the GL_ARB_sparse_buffer spec says:
1780 *
1781 * "INVALID_VALUE is generated by BufferStorage if <flags> contains
1782 * SPARSE_STORAGE_BIT_ARB and <flags> also contains any combination of
1783 * MAP_READ_BIT or MAP_WRITE_BIT."
1784 */
1785 if (flags & GL_SPARSE_STORAGE_BIT_ARB &&
1786 flags & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) {
1787 _mesa_error(ctx, GL_INVALID_VALUE, "%s(SPARSE_STORAGE and READ/WRITE)", func);
1788 return false;
1789 }
1790
1791 if (flags & GL_MAP_PERSISTENT_BIT &&
1792 !(flags & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT))) {
1793 _mesa_error(ctx, GL_INVALID_VALUE,
1794 "%s(PERSISTENT and flags!=READ/WRITE)", func);
1795 return false;
1796 }
1797
1798 if (flags & GL_MAP_COHERENT_BIT && !(flags & GL_MAP_PERSISTENT_BIT)) {
1799 _mesa_error(ctx, GL_INVALID_VALUE,
1800 "%s(COHERENT and flags!=PERSISTENT)", func);
1801 return false;
1802 }
1803
1804 if (bufObj->Immutable || bufObj->HandleAllocated) {
1805 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(immutable)", func);
1806 return false;
1807 }
1808
1809 return true;
1810 }
1811
1812
1813 static void
1814 buffer_storage(struct gl_context *ctx, struct gl_buffer_object *bufObj,
1815 struct gl_memory_object *memObj, GLenum target,
1816 GLsizeiptr size, const GLvoid *data, GLbitfield flags,
1817 GLuint64 offset, const char *func)
1818 {
1819 GLboolean res;
1820
1821 /* Unmap the existing buffer. We'll replace it now. Not an error. */
1822 _mesa_buffer_unmap_all_mappings(ctx, bufObj);
1823
1824 FLUSH_VERTICES(ctx, 0);
1825
1826 bufObj->Written = GL_TRUE;
1827 bufObj->Immutable = GL_TRUE;
1828 bufObj->MinMaxCacheDirty = true;
1829
1830 if (memObj) {
1831 assert(ctx->Driver.BufferDataMem);
1832 res = ctx->Driver.BufferDataMem(ctx, target, size, memObj, offset,
1833 GL_DYNAMIC_DRAW, bufObj);
1834 }
1835 else {
1836 assert(ctx->Driver.BufferData);
1837 res = ctx->Driver.BufferData(ctx, target, size, data, GL_DYNAMIC_DRAW,
1838 flags, bufObj);
1839 }
1840
1841 if (!res) {
1842 if (target == GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD) {
1843 /* Even though the interaction between AMD_pinned_memory and
1844 * glBufferStorage is not described in the spec, Graham Sellers
1845 * said that it should behave the same as glBufferData.
1846 */
1847 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", func);
1848 }
1849 else {
1850 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
1851 }
1852 }
1853 }
1854
1855
1856 static ALWAYS_INLINE void
1857 inlined_buffer_storage(GLenum target, GLuint buffer, GLsizeiptr size,
1858 const GLvoid *data, GLbitfield flags,
1859 GLuint memory, GLuint64 offset,
1860 bool dsa, bool mem, bool no_error, const char *func)
1861 {
1862 GET_CURRENT_CONTEXT(ctx);
1863 struct gl_buffer_object *bufObj;
1864 struct gl_memory_object *memObj = NULL;
1865
1866 if (mem) {
1867 if (!no_error) {
1868 if (!ctx->Extensions.EXT_memory_object) {
1869 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
1870 return;
1871 }
1872
1873 /* From the EXT_external_objects spec:
1874 *
1875 * "An INVALID_VALUE error is generated by BufferStorageMemEXT and
1876 * NamedBufferStorageMemEXT if <memory> is 0, or ..."
1877 */
1878 if (memory == 0) {
1879 _mesa_error(ctx, GL_INVALID_VALUE, "%s(memory == 0)", func);
1880 }
1881 }
1882
1883 memObj = _mesa_lookup_memory_object(ctx, memory);
1884 if (!memObj)
1885 return;
1886
1887 /* From the EXT_external_objects spec:
1888 *
1889 * "An INVALID_OPERATION error is generated if <memory> names a
1890 * valid memory object which has no associated memory."
1891 */
1892 if (!no_error && !memObj->Immutable) {
1893 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(no associated memory)",
1894 func);
1895 return;
1896 }
1897 }
1898
1899 if (dsa) {
1900 if (no_error) {
1901 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
1902 } else {
1903 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, func);
1904 if (!bufObj)
1905 return;
1906 }
1907 } else {
1908 if (no_error) {
1909 struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
1910 bufObj = *bufObjPtr;
1911 } else {
1912 bufObj = get_buffer(ctx, func, target, GL_INVALID_OPERATION);
1913 if (!bufObj)
1914 return;
1915 }
1916 }
1917
1918 if (no_error || validate_buffer_storage(ctx, bufObj, size, flags, func))
1919 buffer_storage(ctx, bufObj, memObj, target, size, data, flags, offset, func);
1920 }
1921
1922
1923 void GLAPIENTRY
1924 _mesa_BufferStorage_no_error(GLenum target, GLsizeiptr size,
1925 const GLvoid *data, GLbitfield flags)
1926 {
1927 inlined_buffer_storage(target, 0, size, data, flags, GL_NONE, 0,
1928 false, false, true, "glBufferStorage");
1929 }
1930
1931
1932 void GLAPIENTRY
1933 _mesa_BufferStorage(GLenum target, GLsizeiptr size, const GLvoid *data,
1934 GLbitfield flags)
1935 {
1936 inlined_buffer_storage(target, 0, size, data, flags, GL_NONE, 0,
1937 false, false, false, "glBufferStorage");
1938 }
1939
1940 void GLAPIENTRY
1941 _mesa_NamedBufferStorageEXT(GLuint buffer, GLsizeiptr size,
1942 const GLvoid *data, GLbitfield flags)
1943 {
1944 GET_CURRENT_CONTEXT(ctx);
1945
1946 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
1947 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
1948 &bufObj, "glNamedBufferStorageEXT"))
1949 return;
1950
1951 inlined_buffer_storage(GL_NONE, buffer, size, data, flags, GL_NONE, 0,
1952 true, false, false, "glNamedBufferStorageEXT");
1953 }
1954
1955
1956 void GLAPIENTRY
1957 _mesa_BufferStorageMemEXT(GLenum target, GLsizeiptr size,
1958 GLuint memory, GLuint64 offset)
1959 {
1960 inlined_buffer_storage(target, 0, size, NULL, 0, memory, offset,
1961 false, true, false, "glBufferStorageMemEXT");
1962 }
1963
1964
1965 void GLAPIENTRY
1966 _mesa_BufferStorageMemEXT_no_error(GLenum target, GLsizeiptr size,
1967 GLuint memory, GLuint64 offset)
1968 {
1969 inlined_buffer_storage(target, 0, size, NULL, 0, memory, offset,
1970 false, true, true, "glBufferStorageMemEXT");
1971 }
1972
1973
1974 void GLAPIENTRY
1975 _mesa_NamedBufferStorage_no_error(GLuint buffer, GLsizeiptr size,
1976 const GLvoid *data, GLbitfield flags)
1977 {
1978 /* In direct state access, buffer objects have an unspecified target
1979 * since they are not required to be bound.
1980 */
1981 inlined_buffer_storage(GL_NONE, buffer, size, data, flags, GL_NONE, 0,
1982 true, false, true, "glNamedBufferStorage");
1983 }
1984
1985
1986 void GLAPIENTRY
1987 _mesa_NamedBufferStorage(GLuint buffer, GLsizeiptr size, const GLvoid *data,
1988 GLbitfield flags)
1989 {
1990 /* In direct state access, buffer objects have an unspecified target
1991 * since they are not required to be bound.
1992 */
1993 inlined_buffer_storage(GL_NONE, buffer, size, data, flags, GL_NONE, 0,
1994 true, false, false, "glNamedBufferStorage");
1995 }
1996
1997 void GLAPIENTRY
1998 _mesa_NamedBufferStorageMemEXT(GLuint buffer, GLsizeiptr size,
1999 GLuint memory, GLuint64 offset)
2000 {
2001 inlined_buffer_storage(GL_NONE, buffer, size, GL_NONE, 0, memory, offset,
2002 true, true, false, "glNamedBufferStorageMemEXT");
2003 }
2004
2005
2006 void GLAPIENTRY
2007 _mesa_NamedBufferStorageMemEXT_no_error(GLuint buffer, GLsizeiptr size,
2008 GLuint memory, GLuint64 offset)
2009 {
2010 inlined_buffer_storage(GL_NONE, buffer, size, GL_NONE, 0, memory, offset,
2011 true, true, true, "glNamedBufferStorageMemEXT");
2012 }
2013
2014
2015 static ALWAYS_INLINE void
2016 buffer_data(struct gl_context *ctx, struct gl_buffer_object *bufObj,
2017 GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage,
2018 const char *func, bool no_error)
2019 {
2020 bool valid_usage;
2021
2022 if (MESA_VERBOSE & VERBOSE_API) {
2023 _mesa_debug(ctx, "%s(%s, %ld, %p, %s)\n",
2024 func,
2025 _mesa_enum_to_string(target),
2026 (long int) size, data,
2027 _mesa_enum_to_string(usage));
2028 }
2029
2030 if (!no_error) {
2031 if (size < 0) {
2032 _mesa_error(ctx, GL_INVALID_VALUE, "%s(size < 0)", func);
2033 return;
2034 }
2035
2036 switch (usage) {
2037 case GL_STREAM_DRAW_ARB:
2038 valid_usage = (ctx->API != API_OPENGLES);
2039 break;
2040 case GL_STATIC_DRAW_ARB:
2041 case GL_DYNAMIC_DRAW_ARB:
2042 valid_usage = true;
2043 break;
2044 case GL_STREAM_READ_ARB:
2045 case GL_STREAM_COPY_ARB:
2046 case GL_STATIC_READ_ARB:
2047 case GL_STATIC_COPY_ARB:
2048 case GL_DYNAMIC_READ_ARB:
2049 case GL_DYNAMIC_COPY_ARB:
2050 valid_usage = _mesa_is_desktop_gl(ctx) || _mesa_is_gles3(ctx);
2051 break;
2052 default:
2053 valid_usage = false;
2054 break;
2055 }
2056
2057 if (!valid_usage) {
2058 _mesa_error(ctx, GL_INVALID_ENUM, "%s(invalid usage: %s)", func,
2059 _mesa_enum_to_string(usage));
2060 return;
2061 }
2062
2063 if (bufObj->Immutable || bufObj->HandleAllocated) {
2064 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(immutable)", func);
2065 return;
2066 }
2067 }
2068
2069 /* Unmap the existing buffer. We'll replace it now. Not an error. */
2070 _mesa_buffer_unmap_all_mappings(ctx, bufObj);
2071
2072 FLUSH_VERTICES(ctx, 0);
2073
2074 bufObj->Written = GL_TRUE;
2075 bufObj->MinMaxCacheDirty = true;
2076
2077 #ifdef VBO_DEBUG
2078 printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",
2079 bufObj->Name, size, data, usage);
2080 #endif
2081
2082 #ifdef BOUNDS_CHECK
2083 size += 100;
2084 #endif
2085
2086 assert(ctx->Driver.BufferData);
2087 if (!ctx->Driver.BufferData(ctx, target, size, data, usage,
2088 GL_MAP_READ_BIT |
2089 GL_MAP_WRITE_BIT |
2090 GL_DYNAMIC_STORAGE_BIT,
2091 bufObj)) {
2092 if (target == GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD) {
2093 if (!no_error) {
2094 /* From GL_AMD_pinned_memory:
2095 *
2096 * INVALID_OPERATION is generated by BufferData if <target> is
2097 * EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, and the store cannot be
2098 * mapped to the GPU address space.
2099 */
2100 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", func);
2101 }
2102 } else {
2103 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
2104 }
2105 }
2106 }
2107
2108 static void
2109 buffer_data_error(struct gl_context *ctx, struct gl_buffer_object *bufObj,
2110 GLenum target, GLsizeiptr size, const GLvoid *data,
2111 GLenum usage, const char *func)
2112 {
2113 buffer_data(ctx, bufObj, target, size, data, usage, func, false);
2114 }
2115
2116 static void
2117 buffer_data_no_error(struct gl_context *ctx, struct gl_buffer_object *bufObj,
2118 GLenum target, GLsizeiptr size, const GLvoid *data,
2119 GLenum usage, const char *func)
2120 {
2121 buffer_data(ctx, bufObj, target, size, data, usage, func, true);
2122 }
2123
2124 void
2125 _mesa_buffer_data(struct gl_context *ctx, struct gl_buffer_object *bufObj,
2126 GLenum target, GLsizeiptr size, const GLvoid *data,
2127 GLenum usage, const char *func)
2128 {
2129 buffer_data_error(ctx, bufObj, target, size, data, usage, func);
2130 }
2131
2132 void GLAPIENTRY
2133 _mesa_BufferData_no_error(GLenum target, GLsizeiptr size, const GLvoid *data,
2134 GLenum usage)
2135 {
2136 GET_CURRENT_CONTEXT(ctx);
2137
2138 struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);
2139 buffer_data_no_error(ctx, *bufObj, target, size, data, usage,
2140 "glBufferData");
2141 }
2142
2143 void GLAPIENTRY
2144 _mesa_BufferData(GLenum target, GLsizeiptr size,
2145 const GLvoid *data, GLenum usage)
2146 {
2147 GET_CURRENT_CONTEXT(ctx);
2148 struct gl_buffer_object *bufObj;
2149
2150 bufObj = get_buffer(ctx, "glBufferData", target, GL_INVALID_OPERATION);
2151 if (!bufObj)
2152 return;
2153
2154 _mesa_buffer_data(ctx, bufObj, target, size, data, usage,
2155 "glBufferData");
2156 }
2157
2158 void GLAPIENTRY
2159 _mesa_NamedBufferData_no_error(GLuint buffer, GLsizeiptr size,
2160 const GLvoid *data, GLenum usage)
2161 {
2162 GET_CURRENT_CONTEXT(ctx);
2163
2164 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2165 buffer_data_no_error(ctx, bufObj, GL_NONE, size, data, usage,
2166 "glNamedBufferData");
2167 }
2168
2169 void GLAPIENTRY
2170 _mesa_NamedBufferData(GLuint buffer, GLsizeiptr size, const GLvoid *data,
2171 GLenum usage)
2172 {
2173 GET_CURRENT_CONTEXT(ctx);
2174 struct gl_buffer_object *bufObj;
2175
2176 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, "glNamedBufferData");
2177 if (!bufObj)
2178 return;
2179
2180 /* In direct state access, buffer objects have an unspecified target since
2181 * they are not required to be bound.
2182 */
2183 _mesa_buffer_data(ctx, bufObj, GL_NONE, size, data, usage,
2184 "glNamedBufferData");
2185 }
2186
2187 void GLAPIENTRY
2188 _mesa_NamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const GLvoid *data,
2189 GLenum usage)
2190 {
2191 GET_CURRENT_CONTEXT(ctx);
2192 struct gl_buffer_object *bufObj;
2193
2194 if (!buffer) {
2195 _mesa_error(ctx, GL_INVALID_OPERATION,
2196 "glNamedBufferDataEXT(buffer=0)");
2197 return;
2198 }
2199
2200 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2201 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
2202 &bufObj, "glNamedBufferDataEXT"))
2203 return;
2204
2205 _mesa_buffer_data(ctx, bufObj, GL_NONE, size, data, usage,
2206 "glNamedBufferDataEXT");
2207 }
2208
2209 static bool
2210 validate_buffer_sub_data(struct gl_context *ctx,
2211 struct gl_buffer_object *bufObj,
2212 GLintptr offset, GLsizeiptr size,
2213 const char *func)
2214 {
2215 if (!buffer_object_subdata_range_good(ctx, bufObj, offset, size,
2216 true, func)) {
2217 /* error already recorded */
2218 return false;
2219 }
2220
2221 if (bufObj->Immutable &&
2222 !(bufObj->StorageFlags & GL_DYNAMIC_STORAGE_BIT)) {
2223 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", func);
2224 return false;
2225 }
2226
2227 if ((bufObj->Usage == GL_STATIC_DRAW ||
2228 bufObj->Usage == GL_STATIC_COPY) &&
2229 bufObj->NumSubDataCalls >= BUFFER_WARNING_CALL_COUNT - 1) {
2230 /* If the application declared the buffer as static draw/copy or stream
2231 * draw, it should not be frequently modified with glBufferSubData.
2232 */
2233 BUFFER_USAGE_WARNING(ctx,
2234 "using %s(buffer %u, offset %u, size %u) to "
2235 "update a %s buffer",
2236 func, bufObj->Name, offset, size,
2237 _mesa_enum_to_string(bufObj->Usage));
2238 }
2239
2240 return true;
2241 }
2242
2243
2244 /**
2245 * Implementation for glBufferSubData and glNamedBufferSubData.
2246 *
2247 * \param ctx GL context.
2248 * \param bufObj The buffer object.
2249 * \param offset Offset of the first byte of the subdata range.
2250 * \param size Size, in bytes, of the subdata range.
2251 * \param data The data store.
2252 * \param func Name of calling function for recording errors.
2253 *
2254 */
2255 void
2256 _mesa_buffer_sub_data(struct gl_context *ctx, struct gl_buffer_object *bufObj,
2257 GLintptr offset, GLsizeiptr size, const GLvoid *data)
2258 {
2259 if (size == 0)
2260 return;
2261
2262 bufObj->NumSubDataCalls++;
2263 bufObj->Written = GL_TRUE;
2264 bufObj->MinMaxCacheDirty = true;
2265
2266 assert(ctx->Driver.BufferSubData);
2267 ctx->Driver.BufferSubData(ctx, offset, size, data, bufObj);
2268 }
2269
2270
2271 static ALWAYS_INLINE void
2272 buffer_sub_data(GLenum target, GLuint buffer, GLintptr offset,
2273 GLsizeiptr size, const GLvoid *data,
2274 bool dsa, bool no_error, const char *func)
2275 {
2276 GET_CURRENT_CONTEXT(ctx);
2277 struct gl_buffer_object *bufObj;
2278
2279 if (dsa) {
2280 if (no_error) {
2281 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2282 } else {
2283 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, func);
2284 if (!bufObj)
2285 return;
2286 }
2287 } else {
2288 if (no_error) {
2289 struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
2290 bufObj = *bufObjPtr;
2291 } else {
2292 bufObj = get_buffer(ctx, func, target, GL_INVALID_OPERATION);
2293 if (!bufObj)
2294 return;
2295 }
2296 }
2297
2298 if (no_error || validate_buffer_sub_data(ctx, bufObj, offset, size, func))
2299 _mesa_buffer_sub_data(ctx, bufObj, offset, size, data);
2300 }
2301
2302
2303 void GLAPIENTRY
2304 _mesa_BufferSubData_no_error(GLenum target, GLintptr offset,
2305 GLsizeiptr size, const GLvoid *data)
2306 {
2307 buffer_sub_data(target, 0, offset, size, data, false, true,
2308 "glBufferSubData");
2309 }
2310
2311
2312 void GLAPIENTRY
2313 _mesa_BufferSubData(GLenum target, GLintptr offset,
2314 GLsizeiptr size, const GLvoid *data)
2315 {
2316 buffer_sub_data(target, 0, offset, size, data, false, false,
2317 "glBufferSubData");
2318 }
2319
2320 void GLAPIENTRY
2321 _mesa_NamedBufferSubData_no_error(GLuint buffer, GLintptr offset,
2322 GLsizeiptr size, const GLvoid *data)
2323 {
2324 buffer_sub_data(0, buffer, offset, size, data, true, true,
2325 "glNamedBufferSubData");
2326 }
2327
2328 void GLAPIENTRY
2329 _mesa_NamedBufferSubData(GLuint buffer, GLintptr offset,
2330 GLsizeiptr size, const GLvoid *data)
2331 {
2332 buffer_sub_data(0, buffer, offset, size, data, true, false,
2333 "glNamedBufferSubData");
2334 }
2335
2336 void GLAPIENTRY
2337 _mesa_NamedBufferSubDataEXT(GLuint buffer, GLintptr offset,
2338 GLsizeiptr size, const GLvoid *data)
2339 {
2340 GET_CURRENT_CONTEXT(ctx);
2341 struct gl_buffer_object *bufObj;
2342
2343 if (!buffer) {
2344 _mesa_error(ctx, GL_INVALID_OPERATION,
2345 "glNamedBufferSubDataEXT(buffer=0)");
2346 return;
2347 }
2348
2349 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2350 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
2351 &bufObj, "glNamedBufferSubDataEXT"))
2352 return;
2353
2354 if (validate_buffer_sub_data(ctx, bufObj, offset, size,
2355 "glNamedBufferSubDataEXT")) {
2356 _mesa_buffer_sub_data(ctx, bufObj, offset, size, data);
2357 }
2358 }
2359
2360
2361 void GLAPIENTRY
2362 _mesa_GetBufferSubData(GLenum target, GLintptr offset,
2363 GLsizeiptr size, GLvoid *data)
2364 {
2365 GET_CURRENT_CONTEXT(ctx);
2366 struct gl_buffer_object *bufObj;
2367
2368 bufObj = get_buffer(ctx, "glGetBufferSubData", target,
2369 GL_INVALID_OPERATION);
2370 if (!bufObj)
2371 return;
2372
2373 if (!buffer_object_subdata_range_good(ctx, bufObj, offset, size, false,
2374 "glGetBufferSubData")) {
2375 return;
2376 }
2377
2378 assert(ctx->Driver.GetBufferSubData);
2379 ctx->Driver.GetBufferSubData(ctx, offset, size, data, bufObj);
2380 }
2381
2382 void GLAPIENTRY
2383 _mesa_GetNamedBufferSubData(GLuint buffer, GLintptr offset,
2384 GLsizeiptr size, GLvoid *data)
2385 {
2386 GET_CURRENT_CONTEXT(ctx);
2387 struct gl_buffer_object *bufObj;
2388
2389 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer,
2390 "glGetNamedBufferSubData");
2391 if (!bufObj)
2392 return;
2393
2394 if (!buffer_object_subdata_range_good(ctx, bufObj, offset, size, false,
2395 "glGetNamedBufferSubData")) {
2396 return;
2397 }
2398
2399 assert(ctx->Driver.GetBufferSubData);
2400 ctx->Driver.GetBufferSubData(ctx, offset, size, data, bufObj);
2401 }
2402
2403
2404 void GLAPIENTRY
2405 _mesa_GetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset,
2406 GLsizeiptr size, GLvoid *data)
2407 {
2408 GET_CURRENT_CONTEXT(ctx);
2409 struct gl_buffer_object *bufObj;
2410
2411 if (!buffer) {
2412 _mesa_error(ctx, GL_INVALID_OPERATION,
2413 "glGetNamedBufferSubDataEXT(buffer=0)");
2414 return;
2415 }
2416
2417 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2418 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
2419 &bufObj, "glGetNamedBufferSubDataEXT"))
2420 return;
2421
2422 if (!buffer_object_subdata_range_good(ctx, bufObj, offset, size, false,
2423 "glGetNamedBufferSubDataEXT")) {
2424 return;
2425 }
2426
2427 assert(ctx->Driver.GetBufferSubData);
2428 ctx->Driver.GetBufferSubData(ctx, offset, size, data, bufObj);
2429 }
2430
2431 /**
2432 * \param subdata true if caller is *SubData, false if *Data
2433 */
2434 static ALWAYS_INLINE void
2435 clear_buffer_sub_data(struct gl_context *ctx, struct gl_buffer_object *bufObj,
2436 GLenum internalformat, GLintptr offset, GLsizeiptr size,
2437 GLenum format, GLenum type, const GLvoid *data,
2438 const char *func, bool subdata, bool no_error)
2439 {
2440 mesa_format mesaFormat;
2441 GLubyte clearValue[MAX_PIXEL_BYTES];
2442 GLsizeiptr clearValueSize;
2443
2444 /* This checks for disallowed mappings. */
2445 if (!no_error && !buffer_object_subdata_range_good(ctx, bufObj, offset, size,
2446 subdata, func)) {
2447 return;
2448 }
2449
2450 if (no_error) {
2451 mesaFormat = _mesa_get_texbuffer_format(ctx, internalformat);
2452 } else {
2453 mesaFormat = validate_clear_buffer_format(ctx, internalformat,
2454 format, type, func);
2455 }
2456
2457 if (mesaFormat == MESA_FORMAT_NONE)
2458 return;
2459
2460 clearValueSize = _mesa_get_format_bytes(mesaFormat);
2461 if (!no_error &&
2462 (offset % clearValueSize != 0 || size % clearValueSize != 0)) {
2463 _mesa_error(ctx, GL_INVALID_VALUE,
2464 "%s(offset or size is not a multiple of "
2465 "internalformat size)", func);
2466 return;
2467 }
2468
2469 /* Bail early. Negative size has already been checked. */
2470 if (size == 0)
2471 return;
2472
2473 bufObj->MinMaxCacheDirty = true;
2474
2475 if (data == NULL) {
2476 /* clear to zeros, per the spec */
2477 ctx->Driver.ClearBufferSubData(ctx, offset, size,
2478 NULL, clearValueSize, bufObj);
2479 return;
2480 }
2481
2482 if (!convert_clear_buffer_data(ctx, mesaFormat, clearValue,
2483 format, type, data, func)) {
2484 return;
2485 }
2486
2487 ctx->Driver.ClearBufferSubData(ctx, offset, size,
2488 clearValue, clearValueSize, bufObj);
2489 }
2490
2491 static void
2492 clear_buffer_sub_data_error(struct gl_context *ctx,
2493 struct gl_buffer_object *bufObj,
2494 GLenum internalformat, GLintptr offset,
2495 GLsizeiptr size, GLenum format, GLenum type,
2496 const GLvoid *data, const char *func, bool subdata)
2497 {
2498 clear_buffer_sub_data(ctx, bufObj, internalformat, offset, size, format,
2499 type, data, func, subdata, false);
2500 }
2501
2502
2503 static void
2504 clear_buffer_sub_data_no_error(struct gl_context *ctx,
2505 struct gl_buffer_object *bufObj,
2506 GLenum internalformat, GLintptr offset,
2507 GLsizeiptr size, GLenum format, GLenum type,
2508 const GLvoid *data, const char *func,
2509 bool subdata)
2510 {
2511 clear_buffer_sub_data(ctx, bufObj, internalformat, offset, size, format,
2512 type, data, func, subdata, true);
2513 }
2514
2515
2516 void GLAPIENTRY
2517 _mesa_ClearBufferData_no_error(GLenum target, GLenum internalformat,
2518 GLenum format, GLenum type, const GLvoid *data)
2519 {
2520 GET_CURRENT_CONTEXT(ctx);
2521
2522 struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);
2523 clear_buffer_sub_data_no_error(ctx, *bufObj, internalformat, 0,
2524 (*bufObj)->Size, format, type, data,
2525 "glClearBufferData", false);
2526 }
2527
2528
2529 void GLAPIENTRY
2530 _mesa_ClearBufferData(GLenum target, GLenum internalformat, GLenum format,
2531 GLenum type, const GLvoid *data)
2532 {
2533 GET_CURRENT_CONTEXT(ctx);
2534 struct gl_buffer_object *bufObj;
2535
2536 bufObj = get_buffer(ctx, "glClearBufferData", target, GL_INVALID_VALUE);
2537 if (!bufObj)
2538 return;
2539
2540 clear_buffer_sub_data_error(ctx, bufObj, internalformat, 0, bufObj->Size,
2541 format, type, data, "glClearBufferData", false);
2542 }
2543
2544
2545 void GLAPIENTRY
2546 _mesa_ClearNamedBufferData_no_error(GLuint buffer, GLenum internalformat,
2547 GLenum format, GLenum type,
2548 const GLvoid *data)
2549 {
2550 GET_CURRENT_CONTEXT(ctx);
2551
2552 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2553 clear_buffer_sub_data_no_error(ctx, bufObj, internalformat, 0, bufObj->Size,
2554 format, type, data, "glClearNamedBufferData",
2555 false);
2556 }
2557
2558
2559 void GLAPIENTRY
2560 _mesa_ClearNamedBufferData(GLuint buffer, GLenum internalformat,
2561 GLenum format, GLenum type, const GLvoid *data)
2562 {
2563 GET_CURRENT_CONTEXT(ctx);
2564 struct gl_buffer_object *bufObj;
2565
2566 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, "glClearNamedBufferData");
2567 if (!bufObj)
2568 return;
2569
2570 clear_buffer_sub_data_error(ctx, bufObj, internalformat, 0, bufObj->Size,
2571 format, type, data, "glClearNamedBufferData",
2572 false);
2573 }
2574
2575
2576 void GLAPIENTRY
2577 _mesa_ClearBufferSubData_no_error(GLenum target, GLenum internalformat,
2578 GLintptr offset, GLsizeiptr size,
2579 GLenum format, GLenum type,
2580 const GLvoid *data)
2581 {
2582 GET_CURRENT_CONTEXT(ctx);
2583
2584 struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);
2585 clear_buffer_sub_data_no_error(ctx, *bufObj, internalformat, offset, size,
2586 format, type, data, "glClearBufferSubData",
2587 true);
2588 }
2589
2590
2591 void GLAPIENTRY
2592 _mesa_ClearBufferSubData(GLenum target, GLenum internalformat,
2593 GLintptr offset, GLsizeiptr size,
2594 GLenum format, GLenum type,
2595 const GLvoid *data)
2596 {
2597 GET_CURRENT_CONTEXT(ctx);
2598 struct gl_buffer_object *bufObj;
2599
2600 bufObj = get_buffer(ctx, "glClearBufferSubData", target, GL_INVALID_VALUE);
2601 if (!bufObj)
2602 return;
2603
2604 clear_buffer_sub_data_error(ctx, bufObj, internalformat, offset, size,
2605 format, type, data, "glClearBufferSubData",
2606 true);
2607 }
2608
2609
2610 void GLAPIENTRY
2611 _mesa_ClearNamedBufferSubData_no_error(GLuint buffer, GLenum internalformat,
2612 GLintptr offset, GLsizeiptr size,
2613 GLenum format, GLenum type,
2614 const GLvoid *data)
2615 {
2616 GET_CURRENT_CONTEXT(ctx);
2617
2618 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2619 clear_buffer_sub_data_no_error(ctx, bufObj, internalformat, offset, size,
2620 format, type, data,
2621 "glClearNamedBufferSubData", true);
2622 }
2623
2624
2625 void GLAPIENTRY
2626 _mesa_ClearNamedBufferSubData(GLuint buffer, GLenum internalformat,
2627 GLintptr offset, GLsizeiptr size,
2628 GLenum format, GLenum type,
2629 const GLvoid *data)
2630 {
2631 GET_CURRENT_CONTEXT(ctx);
2632 struct gl_buffer_object *bufObj;
2633
2634 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer,
2635 "glClearNamedBufferSubData");
2636 if (!bufObj)
2637 return;
2638
2639 clear_buffer_sub_data_error(ctx, bufObj, internalformat, offset, size,
2640 format, type, data, "glClearNamedBufferSubData",
2641 true);
2642 }
2643
2644 static GLboolean
2645 unmap_buffer(struct gl_context *ctx, struct gl_buffer_object *bufObj)
2646 {
2647 GLboolean status = ctx->Driver.UnmapBuffer(ctx, bufObj, MAP_USER);
2648 bufObj->Mappings[MAP_USER].AccessFlags = 0;
2649 assert(bufObj->Mappings[MAP_USER].Pointer == NULL);
2650 assert(bufObj->Mappings[MAP_USER].Offset == 0);
2651 assert(bufObj->Mappings[MAP_USER].Length == 0);
2652
2653 return status;
2654 }
2655
2656 static GLboolean
2657 validate_and_unmap_buffer(struct gl_context *ctx,
2658 struct gl_buffer_object *bufObj,
2659 const char *func)
2660 {
2661 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
2662
2663 if (!_mesa_bufferobj_mapped(bufObj, MAP_USER)) {
2664 _mesa_error(ctx, GL_INVALID_OPERATION,
2665 "%s(buffer is not mapped)", func);
2666 return GL_FALSE;
2667 }
2668
2669 #ifdef BOUNDS_CHECK
2670 if (bufObj->Access != GL_READ_ONLY_ARB) {
2671 GLubyte *buf = (GLubyte *) bufObj->Pointer;
2672 GLuint i;
2673 /* check that last 100 bytes are still = magic value */
2674 for (i = 0; i < 100; i++) {
2675 GLuint pos = bufObj->Size - i - 1;
2676 if (buf[pos] != 123) {
2677 _mesa_warning(ctx, "Out of bounds buffer object write detected"
2678 " at position %d (value = %u)\n",
2679 pos, buf[pos]);
2680 }
2681 }
2682 }
2683 #endif
2684
2685 #ifdef VBO_DEBUG
2686 if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) {
2687 GLuint i, unchanged = 0;
2688 GLubyte *b = (GLubyte *) bufObj->Pointer;
2689 GLint pos = -1;
2690 /* check which bytes changed */
2691 for (i = 0; i < bufObj->Size - 1; i++) {
2692 if (b[i] == (i & 0xff) && b[i+1] == ((i+1) & 0xff)) {
2693 unchanged++;
2694 if (pos == -1)
2695 pos = i;
2696 }
2697 }
2698 if (unchanged) {
2699 printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n",
2700 bufObj->Name, unchanged, bufObj->Size, pos);
2701 }
2702 }
2703 #endif
2704
2705 return unmap_buffer(ctx, bufObj);
2706 }
2707
2708 GLboolean GLAPIENTRY
2709 _mesa_UnmapBuffer_no_error(GLenum target)
2710 {
2711 GET_CURRENT_CONTEXT(ctx);
2712 struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
2713 struct gl_buffer_object *bufObj = *bufObjPtr;
2714
2715 return unmap_buffer(ctx, bufObj);
2716 }
2717
2718 GLboolean GLAPIENTRY
2719 _mesa_UnmapBuffer(GLenum target)
2720 {
2721 GET_CURRENT_CONTEXT(ctx);
2722 struct gl_buffer_object *bufObj;
2723
2724 bufObj = get_buffer(ctx, "glUnmapBuffer", target, GL_INVALID_OPERATION);
2725 if (!bufObj)
2726 return GL_FALSE;
2727
2728 return validate_and_unmap_buffer(ctx, bufObj, "glUnmapBuffer");
2729 }
2730
2731 GLboolean GLAPIENTRY
2732 _mesa_UnmapNamedBufferEXT_no_error(GLuint buffer)
2733 {
2734 GET_CURRENT_CONTEXT(ctx);
2735 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2736
2737 return unmap_buffer(ctx, bufObj);
2738 }
2739
2740 GLboolean GLAPIENTRY
2741 _mesa_UnmapNamedBufferEXT(GLuint buffer)
2742 {
2743 GET_CURRENT_CONTEXT(ctx);
2744 struct gl_buffer_object *bufObj;
2745
2746 if (!buffer) {
2747 _mesa_error(ctx, GL_INVALID_OPERATION,
2748 "glUnmapNamedBufferEXT(buffer=0)");
2749 return GL_FALSE;
2750 }
2751
2752 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, "glUnmapNamedBuffer");
2753 if (!bufObj)
2754 return GL_FALSE;
2755
2756 return validate_and_unmap_buffer(ctx, bufObj, "glUnmapNamedBuffer");
2757 }
2758
2759
2760 static bool
2761 get_buffer_parameter(struct gl_context *ctx,
2762 struct gl_buffer_object *bufObj, GLenum pname,
2763 GLint64 *params, const char *func)
2764 {
2765 switch (pname) {
2766 case GL_BUFFER_SIZE_ARB:
2767 *params = bufObj->Size;
2768 break;
2769 case GL_BUFFER_USAGE_ARB:
2770 *params = bufObj->Usage;
2771 break;
2772 case GL_BUFFER_ACCESS_ARB:
2773 *params = simplified_access_mode(ctx,
2774 bufObj->Mappings[MAP_USER].AccessFlags);
2775 break;
2776 case GL_BUFFER_MAPPED_ARB:
2777 *params = _mesa_bufferobj_mapped(bufObj, MAP_USER);
2778 break;
2779 case GL_BUFFER_ACCESS_FLAGS:
2780 if (!ctx->Extensions.ARB_map_buffer_range)
2781 goto invalid_pname;
2782 *params = bufObj->Mappings[MAP_USER].AccessFlags;
2783 break;
2784 case GL_BUFFER_MAP_OFFSET:
2785 if (!ctx->Extensions.ARB_map_buffer_range)
2786 goto invalid_pname;
2787 *params = bufObj->Mappings[MAP_USER].Offset;
2788 break;
2789 case GL_BUFFER_MAP_LENGTH:
2790 if (!ctx->Extensions.ARB_map_buffer_range)
2791 goto invalid_pname;
2792 *params = bufObj->Mappings[MAP_USER].Length;
2793 break;
2794 case GL_BUFFER_IMMUTABLE_STORAGE:
2795 if (!ctx->Extensions.ARB_buffer_storage)
2796 goto invalid_pname;
2797 *params = bufObj->Immutable;
2798 break;
2799 case GL_BUFFER_STORAGE_FLAGS:
2800 if (!ctx->Extensions.ARB_buffer_storage)
2801 goto invalid_pname;
2802 *params = bufObj->StorageFlags;
2803 break;
2804 default:
2805 goto invalid_pname;
2806 }
2807
2808 return true;
2809
2810 invalid_pname:
2811 _mesa_error(ctx, GL_INVALID_ENUM, "%s(invalid pname: %s)", func,
2812 _mesa_enum_to_string(pname));
2813 return false;
2814 }
2815
2816 void GLAPIENTRY
2817 _mesa_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
2818 {
2819 GET_CURRENT_CONTEXT(ctx);
2820 struct gl_buffer_object *bufObj;
2821 GLint64 parameter;
2822
2823 bufObj = get_buffer(ctx, "glGetBufferParameteriv", target,
2824 GL_INVALID_OPERATION);
2825 if (!bufObj)
2826 return;
2827
2828 if (!get_buffer_parameter(ctx, bufObj, pname, &parameter,
2829 "glGetBufferParameteriv"))
2830 return; /* Error already recorded. */
2831
2832 *params = (GLint) parameter;
2833 }
2834
2835 void GLAPIENTRY
2836 _mesa_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
2837 {
2838 GET_CURRENT_CONTEXT(ctx);
2839 struct gl_buffer_object *bufObj;
2840 GLint64 parameter;
2841
2842 bufObj = get_buffer(ctx, "glGetBufferParameteri64v", target,
2843 GL_INVALID_OPERATION);
2844 if (!bufObj)
2845 return;
2846
2847 if (!get_buffer_parameter(ctx, bufObj, pname, &parameter,
2848 "glGetBufferParameteri64v"))
2849 return; /* Error already recorded. */
2850
2851 *params = parameter;
2852 }
2853
2854 void GLAPIENTRY
2855 _mesa_GetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params)
2856 {
2857 GET_CURRENT_CONTEXT(ctx);
2858 struct gl_buffer_object *bufObj;
2859 GLint64 parameter;
2860
2861 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer,
2862 "glGetNamedBufferParameteriv");
2863 if (!bufObj)
2864 return;
2865
2866 if (!get_buffer_parameter(ctx, bufObj, pname, &parameter,
2867 "glGetNamedBufferParameteriv"))
2868 return; /* Error already recorded. */
2869
2870 *params = (GLint) parameter;
2871 }
2872
2873 void GLAPIENTRY
2874 _mesa_GetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint *params)
2875 {
2876 GET_CURRENT_CONTEXT(ctx);
2877 struct gl_buffer_object *bufObj;
2878 GLint64 parameter;
2879
2880 if (!buffer) {
2881 _mesa_error(ctx, GL_INVALID_OPERATION,
2882 "glGetNamedBufferParameterivEXT: buffer=0");
2883 return;
2884 }
2885
2886 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2887 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
2888 &bufObj, "glGetNamedBufferParameterivEXT"))
2889 return;
2890
2891 if (!get_buffer_parameter(ctx, bufObj, pname, &parameter,
2892 "glGetNamedBufferParameterivEXT"))
2893 return; /* Error already recorded. */
2894
2895 *params = (GLint) parameter;
2896 }
2897
2898 void GLAPIENTRY
2899 _mesa_GetNamedBufferParameteri64v(GLuint buffer, GLenum pname,
2900 GLint64 *params)
2901 {
2902 GET_CURRENT_CONTEXT(ctx);
2903 struct gl_buffer_object *bufObj;
2904 GLint64 parameter;
2905
2906 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer,
2907 "glGetNamedBufferParameteri64v");
2908 if (!bufObj)
2909 return;
2910
2911 if (!get_buffer_parameter(ctx, bufObj, pname, &parameter,
2912 "glGetNamedBufferParameteri64v"))
2913 return; /* Error already recorded. */
2914
2915 *params = parameter;
2916 }
2917
2918
2919 void GLAPIENTRY
2920 _mesa_GetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
2921 {
2922 GET_CURRENT_CONTEXT(ctx);
2923 struct gl_buffer_object *bufObj;
2924
2925 if (pname != GL_BUFFER_MAP_POINTER) {
2926 _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointerv(pname != "
2927 "GL_BUFFER_MAP_POINTER)");
2928 return;
2929 }
2930
2931 bufObj = get_buffer(ctx, "glGetBufferPointerv", target,
2932 GL_INVALID_OPERATION);
2933 if (!bufObj)
2934 return;
2935
2936 *params = bufObj->Mappings[MAP_USER].Pointer;
2937 }
2938
2939 void GLAPIENTRY
2940 _mesa_GetNamedBufferPointerv(GLuint buffer, GLenum pname, GLvoid **params)
2941 {
2942 GET_CURRENT_CONTEXT(ctx);
2943 struct gl_buffer_object *bufObj;
2944
2945 if (pname != GL_BUFFER_MAP_POINTER) {
2946 _mesa_error(ctx, GL_INVALID_ENUM, "glGetNamedBufferPointerv(pname != "
2947 "GL_BUFFER_MAP_POINTER)");
2948 return;
2949 }
2950
2951 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer,
2952 "glGetNamedBufferPointerv");
2953 if (!bufObj)
2954 return;
2955
2956 *params = bufObj->Mappings[MAP_USER].Pointer;
2957 }
2958
2959 void GLAPIENTRY
2960 _mesa_GetNamedBufferPointervEXT(GLuint buffer, GLenum pname, GLvoid **params)
2961 {
2962 GET_CURRENT_CONTEXT(ctx);
2963 struct gl_buffer_object *bufObj;
2964
2965 if (!buffer) {
2966 _mesa_error(ctx, GL_INVALID_OPERATION,
2967 "glGetNamedBufferPointervEXT(buffer=0)");
2968 return;
2969 }
2970 if (pname != GL_BUFFER_MAP_POINTER) {
2971 _mesa_error(ctx, GL_INVALID_ENUM, "glGetNamedBufferPointervEXT(pname != "
2972 "GL_BUFFER_MAP_POINTER)");
2973 return;
2974 }
2975
2976 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
2977 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
2978 &bufObj, "glGetNamedBufferPointervEXT"))
2979 return;
2980
2981 *params = bufObj->Mappings[MAP_USER].Pointer;
2982 }
2983
2984 static void
2985 copy_buffer_sub_data(struct gl_context *ctx, struct gl_buffer_object *src,
2986 struct gl_buffer_object *dst, GLintptr readOffset,
2987 GLintptr writeOffset, GLsizeiptr size, const char *func)
2988 {
2989 if (_mesa_check_disallowed_mapping(src)) {
2990 _mesa_error(ctx, GL_INVALID_OPERATION,
2991 "%s(readBuffer is mapped)", func);
2992 return;
2993 }
2994
2995 if (_mesa_check_disallowed_mapping(dst)) {
2996 _mesa_error(ctx, GL_INVALID_OPERATION,
2997 "%s(writeBuffer is mapped)", func);
2998 return;
2999 }
3000
3001 if (readOffset < 0) {
3002 _mesa_error(ctx, GL_INVALID_VALUE,
3003 "%s(readOffset %d < 0)", func, (int) readOffset);
3004 return;
3005 }
3006
3007 if (writeOffset < 0) {
3008 _mesa_error(ctx, GL_INVALID_VALUE,
3009 "%s(writeOffset %d < 0)", func, (int) writeOffset);
3010 return;
3011 }
3012
3013 if (size < 0) {
3014 _mesa_error(ctx, GL_INVALID_VALUE,
3015 "%s(size %d < 0)", func, (int) size);
3016 return;
3017 }
3018
3019 if (readOffset + size > src->Size) {
3020 _mesa_error(ctx, GL_INVALID_VALUE,
3021 "%s(readOffset %d + size %d > src_buffer_size %d)", func,
3022 (int) readOffset, (int) size, (int) src->Size);
3023 return;
3024 }
3025
3026 if (writeOffset + size > dst->Size) {
3027 _mesa_error(ctx, GL_INVALID_VALUE,
3028 "%s(writeOffset %d + size %d > dst_buffer_size %d)", func,
3029 (int) writeOffset, (int) size, (int) dst->Size);
3030 return;
3031 }
3032
3033 if (src == dst) {
3034 if (readOffset + size <= writeOffset) {
3035 /* OK */
3036 }
3037 else if (writeOffset + size <= readOffset) {
3038 /* OK */
3039 }
3040 else {
3041 /* overlapping src/dst is illegal */
3042 _mesa_error(ctx, GL_INVALID_VALUE,
3043 "%s(overlapping src/dst)", func);
3044 return;
3045 }
3046 }
3047
3048 dst->MinMaxCacheDirty = true;
3049
3050 ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset, size);
3051 }
3052
3053 void GLAPIENTRY
3054 _mesa_CopyBufferSubData_no_error(GLenum readTarget, GLenum writeTarget,
3055 GLintptr readOffset, GLintptr writeOffset,
3056 GLsizeiptr size)
3057 {
3058 GET_CURRENT_CONTEXT(ctx);
3059
3060 struct gl_buffer_object **src_ptr = get_buffer_target(ctx, readTarget);
3061 struct gl_buffer_object *src = *src_ptr;
3062
3063 struct gl_buffer_object **dst_ptr = get_buffer_target(ctx, writeTarget);
3064 struct gl_buffer_object *dst = *dst_ptr;
3065
3066 dst->MinMaxCacheDirty = true;
3067 ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset,
3068 size);
3069 }
3070
3071 void GLAPIENTRY
3072 _mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
3073 GLintptr readOffset, GLintptr writeOffset,
3074 GLsizeiptr size)
3075 {
3076 GET_CURRENT_CONTEXT(ctx);
3077 struct gl_buffer_object *src, *dst;
3078
3079 src = get_buffer(ctx, "glCopyBufferSubData", readTarget,
3080 GL_INVALID_OPERATION);
3081 if (!src)
3082 return;
3083
3084 dst = get_buffer(ctx, "glCopyBufferSubData", writeTarget,
3085 GL_INVALID_OPERATION);
3086 if (!dst)
3087 return;
3088
3089 copy_buffer_sub_data(ctx, src, dst, readOffset, writeOffset, size,
3090 "glCopyBufferSubData");
3091 }
3092
3093 void GLAPIENTRY
3094 _mesa_NamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer,
3095 GLintptr readOffset, GLintptr writeOffset,
3096 GLsizeiptr size)
3097 {
3098 GET_CURRENT_CONTEXT(ctx);
3099 struct gl_buffer_object *src, *dst;
3100
3101 src = _mesa_lookup_bufferobj(ctx, readBuffer);
3102 if (!_mesa_handle_bind_buffer_gen(ctx, readBuffer,
3103 &src,
3104 "glNamedCopyBufferSubDataEXT"))
3105 return;
3106
3107 dst = _mesa_lookup_bufferobj(ctx, writeBuffer);
3108 if (!_mesa_handle_bind_buffer_gen(ctx, writeBuffer,
3109 &dst,
3110 "glNamedCopyBufferSubDataEXT"))
3111 return;
3112
3113 copy_buffer_sub_data(ctx, src, dst, readOffset, writeOffset, size,
3114 "glNamedCopyBufferSubDataEXT");
3115 }
3116
3117 void GLAPIENTRY
3118 _mesa_CopyNamedBufferSubData_no_error(GLuint readBuffer, GLuint writeBuffer,
3119 GLintptr readOffset,
3120 GLintptr writeOffset, GLsizeiptr size)
3121 {
3122 GET_CURRENT_CONTEXT(ctx);
3123
3124 struct gl_buffer_object *src = _mesa_lookup_bufferobj(ctx, readBuffer);
3125 struct gl_buffer_object *dst = _mesa_lookup_bufferobj(ctx, writeBuffer);
3126
3127 dst->MinMaxCacheDirty = true;
3128 ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset,
3129 size);
3130 }
3131
3132 void GLAPIENTRY
3133 _mesa_CopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer,
3134 GLintptr readOffset, GLintptr writeOffset,
3135 GLsizeiptr size)
3136 {
3137 GET_CURRENT_CONTEXT(ctx);
3138 struct gl_buffer_object *src, *dst;
3139
3140 src = _mesa_lookup_bufferobj_err(ctx, readBuffer,
3141 "glCopyNamedBufferSubData");
3142 if (!src)
3143 return;
3144
3145 dst = _mesa_lookup_bufferobj_err(ctx, writeBuffer,
3146 "glCopyNamedBufferSubData");
3147 if (!dst)
3148 return;
3149
3150 copy_buffer_sub_data(ctx, src, dst, readOffset, writeOffset, size,
3151 "glCopyNamedBufferSubData");
3152 }
3153
3154 static bool
3155 validate_map_buffer_range(struct gl_context *ctx,
3156 struct gl_buffer_object *bufObj, GLintptr offset,
3157 GLsizeiptr length, GLbitfield access,
3158 const char *func)
3159 {
3160 GLbitfield allowed_access;
3161
3162 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, false);
3163
3164 if (offset < 0) {
3165 _mesa_error(ctx, GL_INVALID_VALUE,
3166 "%s(offset %ld < 0)", func, (long) offset);
3167 return false;
3168 }
3169
3170 if (length < 0) {
3171 _mesa_error(ctx, GL_INVALID_VALUE,
3172 "%s(length %ld < 0)", func, (long) length);
3173 return false;
3174 }
3175
3176 /* Page 38 of the PDF of the OpenGL ES 3.0 spec says:
3177 *
3178 * "An INVALID_OPERATION error is generated for any of the following
3179 * conditions:
3180 *
3181 * * <length> is zero."
3182 *
3183 * Additionally, page 94 of the PDF of the OpenGL 4.5 core spec
3184 * (30.10.2014) also says this, so it's no longer allowed for desktop GL,
3185 * either.
3186 */
3187 if (length == 0) {
3188 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(length = 0)", func);
3189 return false;
3190 }
3191
3192 allowed_access = GL_MAP_READ_BIT |
3193 GL_MAP_WRITE_BIT |
3194 GL_MAP_INVALIDATE_RANGE_BIT |
3195 GL_MAP_INVALIDATE_BUFFER_BIT |
3196 GL_MAP_FLUSH_EXPLICIT_BIT |
3197 GL_MAP_UNSYNCHRONIZED_BIT;
3198
3199 if (ctx->Extensions.ARB_buffer_storage) {
3200 allowed_access |= GL_MAP_PERSISTENT_BIT |
3201 GL_MAP_COHERENT_BIT;
3202 }
3203
3204 if (access & ~allowed_access) {
3205 /* generate an error if any bits other than those allowed are set */
3206 _mesa_error(ctx, GL_INVALID_VALUE,
3207 "%s(access has undefined bits set)", func);
3208 return false;
3209 }
3210
3211 if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) {
3212 _mesa_error(ctx, GL_INVALID_OPERATION,
3213 "%s(access indicates neither read or write)", func);
3214 return false;
3215 }
3216
3217 if ((access & GL_MAP_READ_BIT) &&
3218 (access & (GL_MAP_INVALIDATE_RANGE_BIT |
3219 GL_MAP_INVALIDATE_BUFFER_BIT |
3220 GL_MAP_UNSYNCHRONIZED_BIT))) {
3221 _mesa_error(ctx, GL_INVALID_OPERATION,
3222 "%s(read access with disallowed bits)", func);
3223 return false;
3224 }
3225
3226 if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) &&
3227 ((access & GL_MAP_WRITE_BIT) == 0)) {
3228 _mesa_error(ctx, GL_INVALID_OPERATION,
3229 "%s(access has flush explicit without write)", func);
3230 return false;
3231 }
3232
3233 if (access & GL_MAP_READ_BIT &&
3234 !(bufObj->StorageFlags & GL_MAP_READ_BIT)) {
3235 _mesa_error(ctx, GL_INVALID_OPERATION,
3236 "%s(buffer does not allow read access)", func);
3237 return false;
3238 }
3239
3240 if (access & GL_MAP_WRITE_BIT &&
3241 !(bufObj->StorageFlags & GL_MAP_WRITE_BIT)) {
3242 _mesa_error(ctx, GL_INVALID_OPERATION,
3243 "%s(buffer does not allow write access)", func);
3244 return false;
3245 }
3246
3247 if (access & GL_MAP_COHERENT_BIT &&
3248 !(bufObj->StorageFlags & GL_MAP_COHERENT_BIT)) {
3249 _mesa_error(ctx, GL_INVALID_OPERATION,
3250 "%s(buffer does not allow coherent access)", func);
3251 return false;
3252 }
3253
3254 if (access & GL_MAP_PERSISTENT_BIT &&
3255 !(bufObj->StorageFlags & GL_MAP_PERSISTENT_BIT)) {
3256 _mesa_error(ctx, GL_INVALID_OPERATION,
3257 "%s(buffer does not allow persistent access)", func);
3258 return false;
3259 }
3260
3261 if (offset + length > bufObj->Size) {
3262 _mesa_error(ctx, GL_INVALID_VALUE,
3263 "%s(offset %lu + length %lu > buffer_size %lu)", func,
3264 (unsigned long) offset, (unsigned long) length,
3265 (unsigned long) bufObj->Size);
3266 return false;
3267 }
3268
3269 if (_mesa_bufferobj_mapped(bufObj, MAP_USER)) {
3270 _mesa_error(ctx, GL_INVALID_OPERATION,
3271 "%s(buffer already mapped)", func);
3272 return false;
3273 }
3274
3275 if (access & GL_MAP_WRITE_BIT) {
3276 bufObj->NumMapBufferWriteCalls++;
3277 if ((bufObj->Usage == GL_STATIC_DRAW ||
3278 bufObj->Usage == GL_STATIC_COPY) &&
3279 bufObj->NumMapBufferWriteCalls >= BUFFER_WARNING_CALL_COUNT) {
3280 BUFFER_USAGE_WARNING(ctx,
3281 "using %s(buffer %u, offset %u, length %u) to "
3282 "update a %s buffer",
3283 func, bufObj->Name, offset, length,
3284 _mesa_enum_to_string(bufObj->Usage));
3285 }
3286 }
3287
3288 return true;
3289 }
3290
3291 static void *
3292 map_buffer_range(struct gl_context *ctx, struct gl_buffer_object *bufObj,
3293 GLintptr offset, GLsizeiptr length, GLbitfield access,
3294 const char *func)
3295 {
3296 if (!bufObj->Size) {
3297 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s(buffer size = 0)", func);
3298 return NULL;
3299 }
3300
3301 assert(ctx->Driver.MapBufferRange);
3302 void *map = ctx->Driver.MapBufferRange(ctx, offset, length, access, bufObj,
3303 MAP_USER);
3304 if (!map) {
3305 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s(map failed)", func);
3306 }
3307 else {
3308 /* The driver callback should have set all these fields.
3309 * This is important because other modules (like VBO) might call
3310 * the driver function directly.
3311 */
3312 assert(bufObj->Mappings[MAP_USER].Pointer == map);
3313 assert(bufObj->Mappings[MAP_USER].Length == length);
3314 assert(bufObj->Mappings[MAP_USER].Offset == offset);
3315 assert(bufObj->Mappings[MAP_USER].AccessFlags == access);
3316 }
3317
3318 if (access & GL_MAP_WRITE_BIT) {
3319 bufObj->Written = GL_TRUE;
3320 bufObj->MinMaxCacheDirty = true;
3321 }
3322
3323 #ifdef VBO_DEBUG
3324 if (strstr(func, "Range") == NULL) { /* If not MapRange */
3325 printf("glMapBuffer(%u, sz %ld, access 0x%x)\n",
3326 bufObj->Name, bufObj->Size, access);
3327 /* Access must be write only */
3328 if ((access & GL_MAP_WRITE_BIT) && (!(access & ~GL_MAP_WRITE_BIT))) {
3329 GLuint i;
3330 GLubyte *b = (GLubyte *) bufObj->Pointer;
3331 for (i = 0; i < bufObj->Size; i++)
3332 b[i] = i & 0xff;
3333 }
3334 }
3335 #endif
3336
3337 #ifdef BOUNDS_CHECK
3338 if (strstr(func, "Range") == NULL) { /* If not MapRange */
3339 GLubyte *buf = (GLubyte *) bufObj->Pointer;
3340 GLuint i;
3341 /* buffer is 100 bytes larger than requested, fill with magic value */
3342 for (i = 0; i < 100; i++) {
3343 buf[bufObj->Size - i - 1] = 123;
3344 }
3345 }
3346 #endif
3347
3348 return map;
3349 }
3350
3351 void * GLAPIENTRY
3352 _mesa_MapBufferRange_no_error(GLenum target, GLintptr offset,
3353 GLsizeiptr length, GLbitfield access)
3354 {
3355 GET_CURRENT_CONTEXT(ctx);
3356
3357 struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
3358 struct gl_buffer_object *bufObj = *bufObjPtr;
3359
3360 return map_buffer_range(ctx, bufObj, offset, length, access,
3361 "glMapBufferRange");
3362 }
3363
3364 void * GLAPIENTRY
3365 _mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
3366 GLbitfield access)
3367 {
3368 GET_CURRENT_CONTEXT(ctx);
3369 struct gl_buffer_object *bufObj;
3370
3371 if (!ctx->Extensions.ARB_map_buffer_range) {
3372 _mesa_error(ctx, GL_INVALID_OPERATION,
3373 "glMapBufferRange(ARB_map_buffer_range not supported)");
3374 return NULL;
3375 }
3376
3377 bufObj = get_buffer(ctx, "glMapBufferRange", target, GL_INVALID_OPERATION);
3378 if (!bufObj)
3379 return NULL;
3380
3381 if (!validate_map_buffer_range(ctx, bufObj, offset, length, access,
3382 "glMapBufferRange"))
3383 return NULL;
3384
3385 return map_buffer_range(ctx, bufObj, offset, length, access,
3386 "glMapBufferRange");
3387 }
3388
3389 void * GLAPIENTRY
3390 _mesa_MapNamedBufferRange_no_error(GLuint buffer, GLintptr offset,
3391 GLsizeiptr length, GLbitfield access)
3392 {
3393 GET_CURRENT_CONTEXT(ctx);
3394 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
3395
3396 return map_buffer_range(ctx, bufObj, offset, length, access,
3397 "glMapNamedBufferRange");
3398 }
3399
3400 static void *
3401 map_named_buffer_range(GLuint buffer, GLintptr offset, GLsizeiptr length,
3402 GLbitfield access, bool dsa_ext, const char *func)
3403 {
3404 GET_CURRENT_CONTEXT(ctx);
3405 struct gl_buffer_object *bufObj = NULL;
3406
3407 if (!ctx->Extensions.ARB_map_buffer_range) {
3408 _mesa_error(ctx, GL_INVALID_OPERATION,
3409 "%s(ARB_map_buffer_range not supported)", func);
3410 return NULL;
3411 }
3412
3413 if (dsa_ext) {
3414 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
3415 if (!_mesa_handle_bind_buffer_gen(ctx, buffer, &bufObj, func))
3416 return NULL;
3417 } else {
3418 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, func);
3419 if (!bufObj)
3420 return NULL;
3421 }
3422
3423 if (!validate_map_buffer_range(ctx, bufObj, offset, length, access, func))
3424 return NULL;
3425
3426 return map_buffer_range(ctx, bufObj, offset, length, access, func);
3427 }
3428
3429 void * GLAPIENTRY
3430 _mesa_MapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length,
3431 GLbitfield access)
3432 {
3433 GET_CURRENT_CONTEXT(ctx);
3434 if (!buffer) {
3435 _mesa_error(ctx, GL_INVALID_OPERATION,
3436 "glMapNamedBufferRangeEXT(buffer=0)");
3437 return NULL;
3438 }
3439 return map_named_buffer_range(buffer, offset, length, access, true,
3440 "glMapNamedBufferRangeEXT");
3441 }
3442
3443 void * GLAPIENTRY
3444 _mesa_MapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length,
3445 GLbitfield access)
3446 {
3447 return map_named_buffer_range(buffer, offset, length, access, false,
3448 "glMapNamedBufferRange");
3449 }
3450
3451 /**
3452 * Converts GLenum access from MapBuffer and MapNamedBuffer into
3453 * flags for input to map_buffer_range.
3454 *
3455 * \return true if the type of requested access is permissible.
3456 */
3457 static bool
3458 get_map_buffer_access_flags(struct gl_context *ctx, GLenum access,
3459 GLbitfield *flags)
3460 {
3461 switch (access) {
3462 case GL_READ_ONLY_ARB:
3463 *flags = GL_MAP_READ_BIT;
3464 return _mesa_is_desktop_gl(ctx);
3465 case GL_WRITE_ONLY_ARB:
3466 *flags = GL_MAP_WRITE_BIT;
3467 return true;
3468 case GL_READ_WRITE_ARB:
3469 *flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
3470 return _mesa_is_desktop_gl(ctx);
3471 default:
3472 *flags = 0;
3473 return false;
3474 }
3475 }
3476
3477 void * GLAPIENTRY
3478 _mesa_MapBuffer_no_error(GLenum target, GLenum access)
3479 {
3480 GET_CURRENT_CONTEXT(ctx);
3481
3482 GLbitfield accessFlags;
3483 get_map_buffer_access_flags(ctx, access, &accessFlags);
3484
3485 struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
3486 struct gl_buffer_object *bufObj = *bufObjPtr;
3487
3488 return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
3489 "glMapBuffer");
3490 }
3491
3492 void * GLAPIENTRY
3493 _mesa_MapBuffer(GLenum target, GLenum access)
3494 {
3495 GET_CURRENT_CONTEXT(ctx);
3496 struct gl_buffer_object *bufObj;
3497 GLbitfield accessFlags;
3498
3499 if (!get_map_buffer_access_flags(ctx, access, &accessFlags)) {
3500 _mesa_error(ctx, GL_INVALID_ENUM, "glMapBuffer(invalid access)");
3501 return NULL;
3502 }
3503
3504 bufObj = get_buffer(ctx, "glMapBuffer", target, GL_INVALID_OPERATION);
3505 if (!bufObj)
3506 return NULL;
3507
3508 if (!validate_map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
3509 "glMapBuffer"))
3510 return NULL;
3511
3512 return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
3513 "glMapBuffer");
3514 }
3515
3516 void * GLAPIENTRY
3517 _mesa_MapNamedBuffer_no_error(GLuint buffer, GLenum access)
3518 {
3519 GET_CURRENT_CONTEXT(ctx);
3520
3521 GLbitfield accessFlags;
3522 get_map_buffer_access_flags(ctx, access, &accessFlags);
3523
3524 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
3525
3526 return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
3527 "glMapNamedBuffer");
3528 }
3529
3530 void * GLAPIENTRY
3531 _mesa_MapNamedBuffer(GLuint buffer, GLenum access)
3532 {
3533 GET_CURRENT_CONTEXT(ctx);
3534 struct gl_buffer_object *bufObj;
3535 GLbitfield accessFlags;
3536
3537 if (!get_map_buffer_access_flags(ctx, access, &accessFlags)) {
3538 _mesa_error(ctx, GL_INVALID_ENUM, "glMapNamedBuffer(invalid access)");
3539 return NULL;
3540 }
3541
3542 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, "glMapNamedBuffer");
3543 if (!bufObj)
3544 return NULL;
3545
3546 if (!validate_map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
3547 "glMapNamedBuffer"))
3548 return NULL;
3549
3550 return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
3551 "glMapNamedBuffer");
3552 }
3553
3554 void * GLAPIENTRY
3555 _mesa_MapNamedBufferEXT(GLuint buffer, GLenum access)
3556 {
3557 GET_CURRENT_CONTEXT(ctx);
3558
3559 GLbitfield accessFlags;
3560 if (!buffer) {
3561 _mesa_error(ctx, GL_INVALID_OPERATION,
3562 "glMapNamedBufferEXT(buffer=0)");
3563 return NULL;
3564 }
3565 if (!get_map_buffer_access_flags(ctx, access, &accessFlags)) {
3566 _mesa_error(ctx, GL_INVALID_ENUM, "glMapNamedBufferEXT(invalid access)");
3567 return NULL;
3568 }
3569
3570 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
3571 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
3572 &bufObj, "glMapNamedBufferEXT"))
3573 return NULL;
3574
3575 if (!validate_map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
3576 "glMapNamedBufferEXT"))
3577 return NULL;
3578
3579 return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
3580 "glMapNamedBufferEXT");
3581 }
3582
3583 static void
3584 flush_mapped_buffer_range(struct gl_context *ctx,
3585 struct gl_buffer_object *bufObj,
3586 GLintptr offset, GLsizeiptr length,
3587 const char *func)
3588 {
3589 if (!ctx->Extensions.ARB_map_buffer_range) {
3590 _mesa_error(ctx, GL_INVALID_OPERATION,
3591 "%s(ARB_map_buffer_range not supported)", func);
3592 return;
3593 }
3594
3595 if (offset < 0) {
3596 _mesa_error(ctx, GL_INVALID_VALUE,
3597 "%s(offset %ld < 0)", func, (long) offset);
3598 return;
3599 }
3600
3601 if (length < 0) {
3602 _mesa_error(ctx, GL_INVALID_VALUE,
3603 "%s(length %ld < 0)", func, (long) length);
3604 return;
3605 }
3606
3607 if (!_mesa_bufferobj_mapped(bufObj, MAP_USER)) {
3608 /* buffer is not mapped */
3609 _mesa_error(ctx, GL_INVALID_OPERATION,
3610 "%s(buffer is not mapped)", func);
3611 return;
3612 }
3613
3614 if ((bufObj->Mappings[MAP_USER].AccessFlags &
3615 GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {
3616 _mesa_error(ctx, GL_INVALID_OPERATION,
3617 "%s(GL_MAP_FLUSH_EXPLICIT_BIT not set)", func);
3618 return;
3619 }
3620
3621 if (offset + length > bufObj->Mappings[MAP_USER].Length) {
3622 _mesa_error(ctx, GL_INVALID_VALUE,
3623 "%s(offset %ld + length %ld > mapped length %ld)", func,
3624 (long) offset, (long) length,
3625 (long) bufObj->Mappings[MAP_USER].Length);
3626 return;
3627 }
3628
3629 assert(bufObj->Mappings[MAP_USER].AccessFlags & GL_MAP_WRITE_BIT);
3630
3631 if (ctx->Driver.FlushMappedBufferRange)
3632 ctx->Driver.FlushMappedBufferRange(ctx, offset, length, bufObj,
3633 MAP_USER);
3634 }
3635
3636 void GLAPIENTRY
3637 _mesa_FlushMappedBufferRange_no_error(GLenum target, GLintptr offset,
3638 GLsizeiptr length)
3639 {
3640 GET_CURRENT_CONTEXT(ctx);
3641 struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
3642 struct gl_buffer_object *bufObj = *bufObjPtr;
3643
3644 if (ctx->Driver.FlushMappedBufferRange)
3645 ctx->Driver.FlushMappedBufferRange(ctx, offset, length, bufObj,
3646 MAP_USER);
3647 }
3648
3649 void GLAPIENTRY
3650 _mesa_FlushMappedBufferRange(GLenum target, GLintptr offset,
3651 GLsizeiptr length)
3652 {
3653 GET_CURRENT_CONTEXT(ctx);
3654 struct gl_buffer_object *bufObj;
3655
3656 bufObj = get_buffer(ctx, "glFlushMappedBufferRange", target,
3657 GL_INVALID_OPERATION);
3658 if (!bufObj)
3659 return;
3660
3661 flush_mapped_buffer_range(ctx, bufObj, offset, length,
3662 "glFlushMappedBufferRange");
3663 }
3664
3665 void GLAPIENTRY
3666 _mesa_FlushMappedNamedBufferRange_no_error(GLuint buffer, GLintptr offset,
3667 GLsizeiptr length)
3668 {
3669 GET_CURRENT_CONTEXT(ctx);
3670 struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
3671
3672 if (ctx->Driver.FlushMappedBufferRange)
3673 ctx->Driver.FlushMappedBufferRange(ctx, offset, length, bufObj,
3674 MAP_USER);
3675 }
3676
3677 void GLAPIENTRY
3678 _mesa_FlushMappedNamedBufferRange(GLuint buffer, GLintptr offset,
3679 GLsizeiptr length)
3680 {
3681 GET_CURRENT_CONTEXT(ctx);
3682 struct gl_buffer_object *bufObj;
3683
3684 bufObj = _mesa_lookup_bufferobj_err(ctx, buffer,
3685 "glFlushMappedNamedBufferRange");
3686 if (!bufObj)
3687 return;
3688
3689 flush_mapped_buffer_range(ctx, bufObj, offset, length,
3690 "glFlushMappedNamedBufferRange");
3691 }
3692
3693 void GLAPIENTRY
3694 _mesa_FlushMappedNamedBufferRangeEXT(GLuint buffer, GLintptr offset,
3695 GLsizeiptr length)
3696 {
3697 GET_CURRENT_CONTEXT(ctx);
3698 struct gl_buffer_object *bufObj;
3699
3700 if (!buffer) {
3701 _mesa_error(ctx, GL_INVALID_OPERATION,
3702 "glFlushMappedNamedBufferRangeEXT(buffer=0)");
3703 return;
3704 }
3705
3706 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
3707 if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
3708 &bufObj, "glFlushMappedNamedBufferRangeEXT"))
3709 return;
3710
3711 flush_mapped_buffer_range(ctx, bufObj, offset, length,
3712 "glFlushMappedNamedBufferRangeEXT");
3713 }
3714
3715 static void
3716 bind_buffer_range_uniform_buffer(struct gl_context *ctx, GLuint index,
3717 struct gl_buffer_object *bufObj,
3718 GLintptr offset, GLsizeiptr size)
3719 {
3720 if (bufObj == ctx->Shared->NullBufferObj) {
3721 offset = -1;
3722 size = -1;
3723 }
3724
3725 _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, bufObj);
3726 bind_uniform_buffer(ctx, index, bufObj, offset, size, GL_FALSE);
3727 }
3728
3729 /**
3730 * Bind a region of a buffer object to a uniform block binding point.
3731 * \param index the uniform buffer binding point index
3732 * \param bufObj the buffer object
3733 * \param offset offset to the start of buffer object region
3734 * \param size size of the buffer object region
3735 */
3736 static void
3737 bind_buffer_range_uniform_buffer_err(struct gl_context *ctx, GLuint index,
3738 struct gl_buffer_object *bufObj,
3739 GLintptr offset, GLsizeiptr size)
3740 {
3741 if (index >= ctx->Const.MaxUniformBufferBindings) {
3742 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(index=%d)", index);
3743 return;
3744 }
3745
3746 if (offset & (ctx->Const.UniformBufferOffsetAlignment - 1)) {
3747 _mesa_error(ctx, GL_INVALID_VALUE,
3748 "glBindBufferRange(offset misaligned %d/%d)", (int) offset,
3749 ctx->Const.UniformBufferOffsetAlignment);
3750 return;
3751 }
3752
3753 bind_buffer_range_uniform_buffer(ctx, index, bufObj, offset, size);
3754 }
3755
3756 static void
3757 bind_buffer_range_shader_storage_buffer(struct gl_context *ctx,
3758 GLuint index,
3759 struct gl_buffer_object *bufObj,
3760 GLintptr offset,
3761 GLsizeiptr size)
3762 {
3763 if (bufObj == ctx->Shared->NullBufferObj) {
3764 offset = -1;
3765 size = -1;
3766 }
3767
3768 _mesa_reference_buffer_object(ctx, &ctx->ShaderStorageBuffer, bufObj);
3769 bind_shader_storage_buffer(ctx, index, bufObj, offset, size, GL_FALSE);
3770 }
3771
3772 /**
3773 * Bind a region of a buffer object to a shader storage block binding point.
3774 * \param index the shader storage buffer binding point index
3775 * \param bufObj the buffer object
3776 * \param offset offset to the start of buffer object region
3777 * \param size size of the buffer object region
3778 */
3779 static void
3780 bind_buffer_range_shader_storage_buffer_err(struct gl_context *ctx,
3781 GLuint index,
3782 struct gl_buffer_object *bufObj,
3783 GLintptr offset, GLsizeiptr size)
3784 {
3785 if (index >= ctx->Const.MaxShaderStorageBufferBindings) {
3786 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(index=%d)", index);
3787 return;
3788 }
3789
3790 if (offset & (ctx->Const.ShaderStorageBufferOffsetAlignment - 1)) {
3791 _mesa_error(ctx, GL_INVALID_VALUE,
3792 "glBindBufferRange(offset misaligned %d/%d)", (int) offset,
3793 ctx->Const.ShaderStorageBufferOffsetAlignment);
3794 return;
3795 }
3796
3797 bind_buffer_range_shader_storage_buffer(ctx, index, bufObj, offset, size);
3798 }
3799
3800 static void
3801 bind_buffer_range_atomic_buffer(struct gl_context *ctx, GLuint index,
3802 struct gl_buffer_object *bufObj,
3803 GLintptr offset, GLsizeiptr size)
3804 {
3805 if (bufObj == ctx->Shared->NullBufferObj) {
3806 offset = -1;
3807 size = -1;
3808 }
3809
3810 _mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer, bufObj);
3811 bind_atomic_buffer(ctx, index, bufObj, offset, size, GL_FALSE);
3812 }
3813
3814 /**
3815 * Bind a region of a buffer object to an atomic storage block binding point.
3816 * \param index the shader storage buffer binding point index
3817 * \param bufObj the buffer object
3818 * \param offset offset to the start of buffer object region
3819 * \param size size of the buffer object region
3820 */
3821 static void
3822 bind_buffer_range_atomic_buffer_err(struct gl_context *ctx,
3823 GLuint index,
3824 struct gl_buffer_object *bufObj,
3825 GLintptr offset, GLsizeiptr size)
3826 {
3827 if (index >= ctx->Const.MaxAtomicBufferBindings) {
3828 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(index=%d)", index);
3829 return;
3830 }
3831
3832 if (offset & (ATOMIC_COUNTER_SIZE - 1)) {
3833 _mesa_error(ctx, GL_INVALID_VALUE,
3834 "glBindBufferRange(offset misaligned %d/%d)", (int) offset,
3835 ATOMIC_COUNTER_SIZE);
3836 return;
3837 }
3838
3839 bind_buffer_range_atomic_buffer(ctx, index, bufObj, offset, size);
3840 }
3841
3842 static inline bool
3843 bind_buffers_check_offset_and_size(struct gl_context *ctx,
3844 GLuint index,
3845 const GLintptr *offsets,
3846 const GLsizeiptr *sizes)
3847 {
3848 if (offsets[index] < 0) {
3849 /* The ARB_multi_bind spec says:
3850 *
3851 * "An INVALID_VALUE error is generated by BindBuffersRange if any
3852 * value in <offsets> is less than zero (per binding)."
3853 */
3854 _mesa_error(ctx, GL_INVALID_VALUE,
3855 "glBindBuffersRange(offsets[%u]=%" PRId64 " < 0)",
3856 index, (int64_t) offsets[index]);
3857 return false;
3858 }
3859
3860 if (sizes[index] <= 0) {
3861 /* The ARB_multi_bind spec says:
3862 *
3863 * "An INVALID_VALUE error is generated by BindBuffersRange if any
3864 * value in <sizes> is less than or equal to zero (per binding)."
3865 */
3866 _mesa_error(ctx, GL_INVALID_VALUE,
3867 "glBindBuffersRange(sizes[%u]=%" PRId64 " <= 0)",
3868 index, (int64_t) sizes[index]);
3869 return false;
3870 }
3871
3872 return true;
3873 }
3874
3875 static bool
3876 error_check_bind_uniform_buffers(struct gl_context *ctx,
3877 GLuint first, GLsizei count,
3878 const char *caller)
3879 {
3880 if (!ctx->Extensions.ARB_uniform_buffer_object) {
3881 _mesa_error(ctx, GL_INVALID_ENUM,
3882 "%s(target=GL_UNIFORM_BUFFER)", caller);
3883 return false;
3884 }
3885
3886 /* The ARB_multi_bind_spec says:
3887 *
3888 * "An INVALID_OPERATION error is generated if <first> + <count> is
3889 * greater than the number of target-specific indexed binding points,
3890 * as described in section 6.7.1."
3891 */
3892 if (first + count > ctx->Const.MaxUniformBufferBindings) {
3893 _mesa_error(ctx, GL_INVALID_OPERATION,
3894 "%s(first=%u + count=%d > the value of "
3895 "GL_MAX_UNIFORM_BUFFER_BINDINGS=%u)",
3896 caller, first, count,
3897 ctx->Const.MaxUniformBufferBindings);
3898 return false;
3899 }
3900
3901 return true;
3902 }
3903
3904 static bool
3905 error_check_bind_shader_storage_buffers(struct gl_context *ctx,
3906 GLuint first, GLsizei count,
3907 const char *caller)
3908 {
3909 if (!ctx->Extensions.ARB_shader_storage_buffer_object) {
3910 _mesa_error(ctx, GL_INVALID_ENUM,
3911 "%s(target=GL_SHADER_STORAGE_BUFFER)", caller);
3912 return false;
3913 }
3914
3915 /* The ARB_multi_bind_spec says:
3916 *
3917 * "An INVALID_OPERATION error is generated if <first> + <count> is
3918 * greater than the number of target-specific indexed binding points,
3919 * as described in section 6.7.1."
3920 */
3921<