2 * Copyright © 2017 Valve Corporation.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
30 #include "shaderimage.h"
33 #include "texturebindless.h"
35 #include "util/hash_table.h"
38 * Return the gl_texture_handle_object for a given 64-bit handle.
40 static struct gl_texture_handle_object
*
41 lookup_texture_handle(struct gl_context
*ctx
, GLuint64 id
)
43 struct gl_texture_handle_object
*texHandleObj
;
45 mtx_lock(&ctx
->Shared
->HandlesMutex
);
46 texHandleObj
= (struct gl_texture_handle_object
*)
47 _mesa_hash_table_u64_search(ctx
->Shared
->TextureHandles
, id
);
48 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
54 * Return the gl_image_handle_object for a given 64-bit handle.
56 static struct gl_image_handle_object
*
57 lookup_image_handle(struct gl_context
*ctx
, GLuint64 id
)
59 struct gl_image_handle_object
*imgHandleObj
;
61 mtx_lock(&ctx
->Shared
->HandlesMutex
);
62 imgHandleObj
= (struct gl_image_handle_object
*)
63 _mesa_hash_table_u64_search(ctx
->Shared
->ImageHandles
, id
);
64 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
70 * Delete a texture handle in the shared state.
73 delete_texture_handle(struct gl_context
*ctx
, GLuint64 id
)
75 mtx_lock(&ctx
->Shared
->HandlesMutex
);
76 _mesa_hash_table_u64_remove(ctx
->Shared
->TextureHandles
, id
);
77 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
79 ctx
->Driver
.DeleteTextureHandle(ctx
, id
);
83 * Delete an image handle in the shared state.
86 delete_image_handle(struct gl_context
*ctx
, GLuint64 id
)
88 mtx_lock(&ctx
->Shared
->HandlesMutex
);
89 _mesa_hash_table_u64_remove(ctx
->Shared
->ImageHandles
, id
);
90 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
92 ctx
->Driver
.DeleteImageHandle(ctx
, id
);
96 * Return TRUE if the texture handle is resident in the current context.
99 is_texture_handle_resident(struct gl_context
*ctx
, GLuint64 handle
)
101 return _mesa_hash_table_u64_search(ctx
->ResidentTextureHandles
,
106 * Return TRUE if the image handle is resident in the current context.
109 is_image_handle_resident(struct gl_context
*ctx
, GLuint64 handle
)
111 return _mesa_hash_table_u64_search(ctx
->ResidentImageHandles
,
116 * Make a texture handle resident/non-resident in the current context.
119 make_texture_handle_resident(struct gl_context
*ctx
,
120 struct gl_texture_handle_object
*texHandleObj
,
123 struct gl_sampler_object
*sampObj
= NULL
;
124 struct gl_texture_object
*texObj
= NULL
;
125 GLuint64 handle
= texHandleObj
->handle
;
128 assert(!is_texture_handle_resident(ctx
, handle
));
130 _mesa_hash_table_u64_insert(ctx
->ResidentTextureHandles
, handle
,
133 ctx
->Driver
.MakeTextureHandleResident(ctx
, handle
, GL_TRUE
);
135 /* Reference the texture object (and the separate sampler if needed) to
136 * be sure it won't be deleted until it is not bound anywhere and there
137 * are no handles using the object that are resident in any context.
139 _mesa_reference_texobj(&texObj
, texHandleObj
->texObj
);
140 if (texHandleObj
->sampObj
)
141 _mesa_reference_sampler_object(ctx
, &sampObj
, texHandleObj
->sampObj
);
143 assert(is_texture_handle_resident(ctx
, handle
));
145 _mesa_hash_table_u64_remove(ctx
->ResidentTextureHandles
, handle
);
147 ctx
->Driver
.MakeTextureHandleResident(ctx
, handle
, GL_FALSE
);
149 /* Unreference the texture object but keep the pointer intact, if
150 * refcount hits zero, the texture and all handles will be deleted.
152 texObj
= texHandleObj
->texObj
;
153 _mesa_reference_texobj(&texObj
, NULL
);
155 /* Unreference the separate sampler object but keep the pointer intact,
156 * if refcount hits zero, the sampler and all handles will be deleted.
158 if (texHandleObj
->sampObj
) {
159 sampObj
= texHandleObj
->sampObj
;
160 _mesa_reference_sampler_object(ctx
, &sampObj
, NULL
);
166 * Make an image handle resident/non-resident in the current context.
169 make_image_handle_resident(struct gl_context
*ctx
,
170 struct gl_image_handle_object
*imgHandleObj
,
171 GLenum access
, bool resident
)
173 struct gl_texture_object
*texObj
= NULL
;
174 GLuint64 handle
= imgHandleObj
->handle
;
177 assert(!is_image_handle_resident(ctx
, handle
));
179 _mesa_hash_table_u64_insert(ctx
->ResidentImageHandles
, handle
,
182 ctx
->Driver
.MakeImageHandleResident(ctx
, handle
, access
, GL_TRUE
);
184 /* Reference the texture object to be sure it won't be deleted until it
185 * is not bound anywhere and there are no handles using the object that
186 * are resident in any context.
188 _mesa_reference_texobj(&texObj
, imgHandleObj
->imgObj
.TexObj
);
190 assert(is_image_handle_resident(ctx
, handle
));
192 _mesa_hash_table_u64_remove(ctx
->ResidentImageHandles
, handle
);
194 ctx
->Driver
.MakeImageHandleResident(ctx
, handle
, access
, GL_FALSE
);
196 /* Unreference the texture object but keep the pointer intact, if
197 * refcount hits zero, the texture and all handles will be deleted.
199 texObj
= imgHandleObj
->imgObj
.TexObj
;
200 _mesa_reference_texobj(&texObj
, NULL
);
204 static struct gl_texture_handle_object
*
205 find_texhandleobj(struct gl_texture_object
*texObj
,
206 struct gl_sampler_object
*sampObj
)
208 util_dynarray_foreach(&texObj
->SamplerHandles
,
209 struct gl_texture_handle_object
*, texHandleObj
) {
210 if ((*texHandleObj
)->sampObj
== sampObj
)
211 return *texHandleObj
;
217 get_texture_handle(struct gl_context
*ctx
, struct gl_texture_object
*texObj
,
218 struct gl_sampler_object
*sampObj
)
220 bool separate_sampler
= &texObj
->Sampler
!= sampObj
;
221 struct gl_texture_handle_object
*texHandleObj
;
224 /* The ARB_bindless_texture spec says:
226 * "The handle for each texture or texture/sampler pair is unique; the same
227 * handle will be returned if GetTextureHandleARB is called multiple times
228 * for the same texture or if GetTextureSamplerHandleARB is called multiple
229 * times for the same texture/sampler pair."
231 mtx_lock(&ctx
->Shared
->HandlesMutex
);
232 texHandleObj
= find_texhandleobj(texObj
, separate_sampler
? sampObj
: NULL
);
234 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
235 return texHandleObj
->handle
;
238 /* Request a new texture handle from the driver. */
239 handle
= ctx
->Driver
.NewTextureHandle(ctx
, texObj
, sampObj
);
241 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
242 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glGetTexture*HandleARB()");
246 texHandleObj
= CALLOC_STRUCT(gl_texture_handle_object
);
248 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
249 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glGetTexture*HandleARB()");
253 /* Store the handle into the texture object. */
254 texHandleObj
->texObj
= texObj
;
255 texHandleObj
->sampObj
= separate_sampler
? sampObj
: NULL
;
256 texHandleObj
->handle
= handle
;
257 util_dynarray_append(&texObj
->SamplerHandles
,
258 struct gl_texture_handle_object
*, texHandleObj
);
260 if (separate_sampler
) {
261 /* Store the handle into the separate sampler if needed. */
262 util_dynarray_append(&sampObj
->Handles
,
263 struct gl_texture_handle_object
*, texHandleObj
);
266 /* When referenced by one or more handles, texture objects are immutable. */
267 texObj
->HandleAllocated
= true;
268 if (texObj
->Target
== GL_TEXTURE_BUFFER
)
269 texObj
->BufferObject
->HandleAllocated
= true;
270 sampObj
->HandleAllocated
= true;
272 /* Store the handle in the shared state for all contexts. */
273 _mesa_hash_table_u64_insert(ctx
->Shared
->TextureHandles
, handle
,
275 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
280 static struct gl_image_handle_object
*
281 find_imghandleobj(struct gl_texture_object
*texObj
, GLint level
,
282 GLboolean layered
, GLint layer
, GLenum format
)
284 util_dynarray_foreach(&texObj
->ImageHandles
,
285 struct gl_image_handle_object
*, imgHandleObj
) {
286 struct gl_image_unit
*u
= &(*imgHandleObj
)->imgObj
;
288 if (u
->TexObj
== texObj
&& u
->Level
== level
&& u
->Layered
== layered
&&
289 u
->Layer
== layer
&& u
->Format
== format
)
290 return *imgHandleObj
;
296 get_image_handle(struct gl_context
*ctx
, struct gl_texture_object
*texObj
,
297 GLint level
, GLboolean layered
, GLint layer
, GLenum format
)
299 struct gl_image_handle_object
*imgHandleObj
;
300 struct gl_image_unit imgObj
;
303 /* The ARB_bindless_texture spec says:
305 * "The handle returned for each combination of <texture>, <level>,
306 * <layered>, <layer>, and <format> is unique; the same handle will be
307 * returned if GetImageHandleARB is called multiple times with the same
310 mtx_lock(&ctx
->Shared
->HandlesMutex
);
311 imgHandleObj
= find_imghandleobj(texObj
, level
, layered
, layer
, format
);
313 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
314 return imgHandleObj
->handle
;
317 imgObj
.TexObj
= texObj
; /* weak reference */
318 imgObj
.Level
= level
;
319 imgObj
.Access
= GL_READ_WRITE
;
320 imgObj
.Format
= format
;
321 imgObj
._ActualFormat
= _mesa_get_shader_image_format(format
);
323 if (_mesa_tex_target_is_layered(texObj
->Target
)) {
324 imgObj
.Layered
= layered
;
325 imgObj
.Layer
= layer
;
326 imgObj
._Layer
= (imgObj
.Layered
? 0 : imgObj
.Layer
);
328 imgObj
.Layered
= GL_FALSE
;
332 /* Request a new image handle from the driver. */
333 handle
= ctx
->Driver
.NewImageHandle(ctx
, &imgObj
);
335 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
336 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glGetImageHandleARB()");
340 imgHandleObj
= CALLOC_STRUCT(gl_image_handle_object
);
342 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
343 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glGetImageHandleARB()");
347 /* Store the handle into the texture object. */
348 memcpy(&imgHandleObj
->imgObj
, &imgObj
, sizeof(struct gl_image_unit
));
349 imgHandleObj
->handle
= handle
;
350 util_dynarray_append(&texObj
->ImageHandles
,
351 struct gl_image_handle_object
*, imgHandleObj
);
353 /* When referenced by one or more handles, texture objects are immutable. */
354 texObj
->HandleAllocated
= true;
355 if (texObj
->Target
== GL_TEXTURE_BUFFER
)
356 texObj
->BufferObject
->HandleAllocated
= true;
357 texObj
->Sampler
.HandleAllocated
= true;
359 /* Store the handle in the shared state for all contexts. */
360 _mesa_hash_table_u64_insert(ctx
->Shared
->ImageHandles
, handle
, imgHandleObj
);
361 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
367 * Init/free per-context resident handles.
370 _mesa_init_resident_handles(struct gl_context
*ctx
)
372 ctx
->ResidentTextureHandles
= _mesa_hash_table_u64_create(NULL
);
373 ctx
->ResidentImageHandles
= _mesa_hash_table_u64_create(NULL
);
377 _mesa_free_resident_handles(struct gl_context
*ctx
)
379 _mesa_hash_table_u64_destroy(ctx
->ResidentTextureHandles
, NULL
);
380 _mesa_hash_table_u64_destroy(ctx
->ResidentImageHandles
, NULL
);
384 * Init/free shared allocated handles.
387 _mesa_init_shared_handles(struct gl_shared_state
*shared
)
389 shared
->TextureHandles
= _mesa_hash_table_u64_create(NULL
);
390 shared
->ImageHandles
= _mesa_hash_table_u64_create(NULL
);
391 mtx_init(&shared
->HandlesMutex
, mtx_recursive
);
395 _mesa_free_shared_handles(struct gl_shared_state
*shared
)
397 if (shared
->TextureHandles
)
398 _mesa_hash_table_u64_destroy(shared
->TextureHandles
, NULL
);
400 if (shared
->ImageHandles
)
401 _mesa_hash_table_u64_destroy(shared
->ImageHandles
, NULL
);
403 mtx_destroy(&shared
->HandlesMutex
);
407 * Init/free texture/image handles per-texture object.
410 _mesa_init_texture_handles(struct gl_texture_object
*texObj
)
412 util_dynarray_init(&texObj
->SamplerHandles
, NULL
);
413 util_dynarray_init(&texObj
->ImageHandles
, NULL
);
417 _mesa_make_texture_handles_non_resident(struct gl_context
*ctx
,
418 struct gl_texture_object
*texObj
)
420 mtx_lock(&ctx
->Shared
->HandlesMutex
);
422 /* Texture handles */
423 util_dynarray_foreach(&texObj
->SamplerHandles
,
424 struct gl_texture_handle_object
*, texHandleObj
) {
425 if (is_texture_handle_resident(ctx
, (*texHandleObj
)->handle
))
426 make_texture_handle_resident(ctx
, *texHandleObj
, false);
430 util_dynarray_foreach(&texObj
->ImageHandles
,
431 struct gl_image_handle_object
*, imgHandleObj
) {
432 if (is_image_handle_resident(ctx
, (*imgHandleObj
)->handle
))
433 make_image_handle_resident(ctx
, *imgHandleObj
, GL_READ_ONLY
, false);
436 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
440 _mesa_delete_texture_handles(struct gl_context
*ctx
,
441 struct gl_texture_object
*texObj
)
443 /* Texture handles */
444 util_dynarray_foreach(&texObj
->SamplerHandles
,
445 struct gl_texture_handle_object
*, texHandleObj
) {
446 struct gl_sampler_object
*sampObj
= (*texHandleObj
)->sampObj
;
449 /* Delete the handle in the separate sampler object. */
450 util_dynarray_delete_unordered(&sampObj
->Handles
,
451 struct gl_texture_handle_object
*,
454 delete_texture_handle(ctx
, (*texHandleObj
)->handle
);
457 util_dynarray_fini(&texObj
->SamplerHandles
);
460 util_dynarray_foreach(&texObj
->ImageHandles
,
461 struct gl_image_handle_object
*, imgHandleObj
) {
462 delete_image_handle(ctx
, (*imgHandleObj
)->handle
);
465 util_dynarray_fini(&texObj
->ImageHandles
);
469 * Init/free texture handles per-sampler object.
472 _mesa_init_sampler_handles(struct gl_sampler_object
*sampObj
)
474 util_dynarray_init(&sampObj
->Handles
, NULL
);
478 _mesa_delete_sampler_handles(struct gl_context
*ctx
,
479 struct gl_sampler_object
*sampObj
)
481 util_dynarray_foreach(&sampObj
->Handles
,
482 struct gl_texture_handle_object
*, texHandleObj
) {
483 struct gl_texture_object
*texObj
= (*texHandleObj
)->texObj
;
485 /* Delete the handle in the texture object. */
486 util_dynarray_delete_unordered(&texObj
->SamplerHandles
,
487 struct gl_texture_handle_object
*,
490 delete_texture_handle(ctx
, (*texHandleObj
)->handle
);
493 util_dynarray_fini(&sampObj
->Handles
);
497 is_sampler_border_color_valid(struct gl_sampler_object
*samp
)
499 static const GLfloat valid_float_border_colors
[4][4] = {
500 { 0.0, 0.0, 0.0, 0.0 },
501 { 0.0, 0.0, 0.0, 1.0 },
502 { 1.0, 1.0, 1.0, 0.0 },
503 { 1.0, 1.0, 1.0, 1.0 },
505 static const GLint valid_integer_border_colors
[4][4] = {
511 size_t size
= sizeof(samp
->BorderColor
.ui
);
513 /* The ARB_bindless_texture spec says:
515 * "The error INVALID_OPERATION is generated if the border color (taken from
516 * the embedded sampler for GetTextureHandleARB or from the <sampler> for
517 * GetTextureSamplerHandleARB) is not one of the following allowed values.
518 * If the texture's base internal format is signed or unsigned integer,
519 * allowed values are (0,0,0,0), (0,0,0,1), (1,1,1,0), and (1,1,1,1). If
520 * the base internal format is not integer, allowed values are
521 * (0.0,0.0,0.0,0.0), (0.0,0.0,0.0,1.0), (1.0,1.0,1.0,0.0), and
522 * (1.0,1.0,1.0,1.0)."
524 if (!memcmp(samp
->BorderColor
.f
, valid_float_border_colors
[0], size
) ||
525 !memcmp(samp
->BorderColor
.f
, valid_float_border_colors
[1], size
) ||
526 !memcmp(samp
->BorderColor
.f
, valid_float_border_colors
[2], size
) ||
527 !memcmp(samp
->BorderColor
.f
, valid_float_border_colors
[3], size
))
530 if (!memcmp(samp
->BorderColor
.ui
, valid_integer_border_colors
[0], size
) ||
531 !memcmp(samp
->BorderColor
.ui
, valid_integer_border_colors
[1], size
) ||
532 !memcmp(samp
->BorderColor
.ui
, valid_integer_border_colors
[2], size
) ||
533 !memcmp(samp
->BorderColor
.ui
, valid_integer_border_colors
[3], size
))
540 _mesa_GetTextureHandleARB_no_error(GLuint texture
)
542 struct gl_texture_object
*texObj
;
544 GET_CURRENT_CONTEXT(ctx
);
546 texObj
= _mesa_lookup_texture(ctx
, texture
);
547 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
))
548 _mesa_test_texobj_completeness(ctx
, texObj
);
550 return get_texture_handle(ctx
, texObj
, &texObj
->Sampler
);
554 _mesa_GetTextureHandleARB(GLuint texture
)
556 struct gl_texture_object
*texObj
= NULL
;
558 GET_CURRENT_CONTEXT(ctx
);
560 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
561 _mesa_error(ctx
, GL_INVALID_OPERATION
,
562 "glGetTextureHandleARB(unsupported)");
566 /* The ARB_bindless_texture spec says:
568 * "The error INVALID_VALUE is generated by GetTextureHandleARB or
569 * GetTextureSamplerHandleARB if <texture> is zero or not the name of an
570 * existing texture object."
573 texObj
= _mesa_lookup_texture(ctx
, texture
);
576 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetTextureHandleARB(texture)");
580 /* The ARB_bindless_texture spec says:
582 * "The error INVALID_OPERATION is generated by GetTextureHandleARB or
583 * GetTextureSamplerHandleARB if the texture object specified by <texture>
586 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
)) {
587 _mesa_test_texobj_completeness(ctx
, texObj
);
588 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
)) {
589 _mesa_error(ctx
, GL_INVALID_OPERATION
,
590 "glGetTextureHandleARB(incomplete texture)");
595 if (!is_sampler_border_color_valid(&texObj
->Sampler
)) {
596 _mesa_error(ctx
, GL_INVALID_OPERATION
,
597 "glGetTextureHandleARB(invalid border color)");
601 return get_texture_handle(ctx
, texObj
, &texObj
->Sampler
);
605 _mesa_GetTextureSamplerHandleARB_no_error(GLuint texture
, GLuint sampler
)
607 struct gl_texture_object
*texObj
;
608 struct gl_sampler_object
*sampObj
;
610 GET_CURRENT_CONTEXT(ctx
);
612 texObj
= _mesa_lookup_texture(ctx
, texture
);
613 sampObj
= _mesa_lookup_samplerobj(ctx
, sampler
);
615 if (!_mesa_is_texture_complete(texObj
, sampObj
))
616 _mesa_test_texobj_completeness(ctx
, texObj
);
618 return get_texture_handle(ctx
, texObj
, sampObj
);
622 _mesa_GetTextureSamplerHandleARB(GLuint texture
, GLuint sampler
)
624 struct gl_texture_object
*texObj
= NULL
;
625 struct gl_sampler_object
*sampObj
;
627 GET_CURRENT_CONTEXT(ctx
);
629 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
630 _mesa_error(ctx
, GL_INVALID_OPERATION
,
631 "glGetTextureSamplerHandleARB(unsupported)");
635 /* The ARB_bindless_texture spec says:
637 * "The error INVALID_VALUE is generated by GetTextureHandleARB or
638 * GetTextureSamplerHandleARB if <texture> is zero or not the name of an
639 * existing texture object."
642 texObj
= _mesa_lookup_texture(ctx
, texture
);
645 _mesa_error(ctx
, GL_INVALID_VALUE
,
646 "glGetTextureSamplerHandleARB(texture)");
650 /* The ARB_bindless_texture spec says:
652 * "The error INVALID_VALUE is generated by GetTextureSamplerHandleARB if
653 * <sampler> is zero or is not the name of an existing sampler object."
655 sampObj
= _mesa_lookup_samplerobj(ctx
, sampler
);
657 _mesa_error(ctx
, GL_INVALID_VALUE
,
658 "glGetTextureSamplerHandleARB(sampler)");
662 /* The ARB_bindless_texture spec says:
664 * "The error INVALID_OPERATION is generated by GetTextureHandleARB or
665 * GetTextureSamplerHandleARB if the texture object specified by <texture>
668 if (!_mesa_is_texture_complete(texObj
, sampObj
)) {
669 _mesa_test_texobj_completeness(ctx
, texObj
);
670 if (!_mesa_is_texture_complete(texObj
, sampObj
)) {
671 _mesa_error(ctx
, GL_INVALID_OPERATION
,
672 "glGetTextureSamplerHandleARB(incomplete texture)");
677 if (!is_sampler_border_color_valid(sampObj
)) {
678 _mesa_error(ctx
, GL_INVALID_OPERATION
,
679 "glGetTextureSamplerHandleARB(invalid border color)");
683 return get_texture_handle(ctx
, texObj
, sampObj
);
687 _mesa_MakeTextureHandleResidentARB_no_error(GLuint64 handle
)
689 struct gl_texture_handle_object
*texHandleObj
;
691 GET_CURRENT_CONTEXT(ctx
);
693 texHandleObj
= lookup_texture_handle(ctx
, handle
);
694 make_texture_handle_resident(ctx
, texHandleObj
, true);
698 _mesa_MakeTextureHandleResidentARB(GLuint64 handle
)
700 struct gl_texture_handle_object
*texHandleObj
;
702 GET_CURRENT_CONTEXT(ctx
);
704 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
705 _mesa_error(ctx
, GL_INVALID_OPERATION
,
706 "glMakeTextureHandleResidentARB(unsupported)");
710 /* The ARB_bindless_texture spec says:
712 * "The error INVALID_OPERATION is generated by MakeTextureHandleResidentARB
713 * if <handle> is not a valid texture handle, or if <handle> is already
714 * resident in the current GL context."
716 texHandleObj
= lookup_texture_handle(ctx
, handle
);
718 _mesa_error(ctx
, GL_INVALID_OPERATION
,
719 "glMakeTextureHandleResidentARB(handle)");
723 if (is_texture_handle_resident(ctx
, handle
)) {
724 _mesa_error(ctx
, GL_INVALID_OPERATION
,
725 "glMakeTextureHandleResidentARB(already resident)");
729 make_texture_handle_resident(ctx
, texHandleObj
, true);
733 _mesa_MakeTextureHandleNonResidentARB_no_error(GLuint64 handle
)
735 struct gl_texture_handle_object
*texHandleObj
;
737 GET_CURRENT_CONTEXT(ctx
);
739 texHandleObj
= lookup_texture_handle(ctx
, handle
);
740 make_texture_handle_resident(ctx
, texHandleObj
, false);
744 _mesa_MakeTextureHandleNonResidentARB(GLuint64 handle
)
746 struct gl_texture_handle_object
*texHandleObj
;
748 GET_CURRENT_CONTEXT(ctx
);
750 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
751 _mesa_error(ctx
, GL_INVALID_OPERATION
,
752 "glMakeTextureHandleNonResidentARB(unsupported)");
756 /* The ARB_bindless_texture spec says:
758 * "The error INVALID_OPERATION is generated by
759 * MakeTextureHandleNonResidentARB if <handle> is not a valid texture
760 * handle, or if <handle> is not resident in the current GL context."
762 texHandleObj
= lookup_texture_handle(ctx
, handle
);
764 _mesa_error(ctx
, GL_INVALID_OPERATION
,
765 "glMakeTextureHandleNonResidentARB(handle)");
769 if (!is_texture_handle_resident(ctx
, handle
)) {
770 _mesa_error(ctx
, GL_INVALID_OPERATION
,
771 "glMakeTextureHandleNonResidentARB(not resident)");
775 make_texture_handle_resident(ctx
, texHandleObj
, false);
779 _mesa_GetImageHandleARB_no_error(GLuint texture
, GLint level
, GLboolean layered
,
780 GLint layer
, GLenum format
)
782 struct gl_texture_object
*texObj
;
784 GET_CURRENT_CONTEXT(ctx
);
786 texObj
= _mesa_lookup_texture(ctx
, texture
);
787 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
))
788 _mesa_test_texobj_completeness(ctx
, texObj
);
790 return get_image_handle(ctx
, texObj
, level
, layered
, layer
, format
);
794 _mesa_GetImageHandleARB(GLuint texture
, GLint level
, GLboolean layered
,
795 GLint layer
, GLenum format
)
797 struct gl_texture_object
*texObj
= NULL
;
799 GET_CURRENT_CONTEXT(ctx
);
801 if (!_mesa_has_ARB_bindless_texture(ctx
) ||
802 !_mesa_has_ARB_shader_image_load_store(ctx
)) {
803 _mesa_error(ctx
, GL_INVALID_OPERATION
,
804 "glGetImageHandleARB(unsupported)");
808 /* The ARB_bindless_texture spec says:
810 * "The error INVALID_VALUE is generated by GetImageHandleARB if <texture>
811 * is zero or not the name of an existing texture object, if the image for
812 * <level> does not existing in <texture>, or if <layered> is FALSE and
813 * <layer> is greater than or equal to the number of layers in the image at
817 texObj
= _mesa_lookup_texture(ctx
, texture
);
820 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetImageHandleARB(texture)");
824 if (level
< 0 || level
>= _mesa_max_texture_levels(ctx
, texObj
->Target
)) {
825 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetImageHandleARB(level)");
829 if (!layered
&& layer
> _mesa_get_texture_layers(texObj
, level
)) {
830 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetImageHandleARB(layer)");
834 if (!_mesa_is_shader_image_format_supported(ctx
, format
)) {
835 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetImageHandleARB(format)");
839 /* The ARB_bindless_texture spec says:
841 * "The error INVALID_OPERATION is generated by GetImageHandleARB if the
842 * texture object <texture> is not complete or if <layered> is TRUE and
843 * <texture> is not a three-dimensional, one-dimensional array, two
844 * dimensional array, cube map, or cube map array texture."
846 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
)) {
847 _mesa_test_texobj_completeness(ctx
, texObj
);
848 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
)) {
849 _mesa_error(ctx
, GL_INVALID_OPERATION
,
850 "glGetImageHandleARB(incomplete texture)");
855 if (layered
&& !_mesa_tex_target_is_layered(texObj
->Target
)) {
856 _mesa_error(ctx
, GL_INVALID_OPERATION
,
857 "glGetImageHandleARB(not layered)");
861 return get_image_handle(ctx
, texObj
, level
, layered
, layer
, format
);
865 _mesa_MakeImageHandleResidentARB_no_error(GLuint64 handle
, GLenum access
)
867 struct gl_image_handle_object
*imgHandleObj
;
869 GET_CURRENT_CONTEXT(ctx
);
871 imgHandleObj
= lookup_image_handle(ctx
, handle
);
872 make_image_handle_resident(ctx
, imgHandleObj
, access
, true);
876 _mesa_MakeImageHandleResidentARB(GLuint64 handle
, GLenum access
)
878 struct gl_image_handle_object
*imgHandleObj
;
880 GET_CURRENT_CONTEXT(ctx
);
882 if (!_mesa_has_ARB_bindless_texture(ctx
) ||
883 !_mesa_has_ARB_shader_image_load_store(ctx
)) {
884 _mesa_error(ctx
, GL_INVALID_OPERATION
,
885 "glMakeImageHandleResidentARB(unsupported)");
889 if (access
!= GL_READ_ONLY
&&
890 access
!= GL_WRITE_ONLY
&&
891 access
!= GL_READ_WRITE
) {
892 _mesa_error(ctx
, GL_INVALID_ENUM
,
893 "glMakeImageHandleResidentARB(access)");
897 /* The ARB_bindless_texture spec says:
899 * "The error INVALID_OPERATION is generated by MakeImageHandleResidentARB
900 * if <handle> is not a valid image handle, or if <handle> is already
901 * resident in the current GL context."
903 imgHandleObj
= lookup_image_handle(ctx
, handle
);
905 _mesa_error(ctx
, GL_INVALID_OPERATION
,
906 "glMakeImageHandleResidentARB(handle)");
910 if (is_image_handle_resident(ctx
, handle
)) {
911 _mesa_error(ctx
, GL_INVALID_OPERATION
,
912 "glMakeImageHandleResidentARB(already resident)");
916 make_image_handle_resident(ctx
, imgHandleObj
, access
, true);
920 _mesa_MakeImageHandleNonResidentARB_no_error(GLuint64 handle
)
922 struct gl_image_handle_object
*imgHandleObj
;
924 GET_CURRENT_CONTEXT(ctx
);
926 imgHandleObj
= lookup_image_handle(ctx
, handle
);
927 make_image_handle_resident(ctx
, imgHandleObj
, GL_READ_ONLY
, false);
931 _mesa_MakeImageHandleNonResidentARB(GLuint64 handle
)
933 struct gl_image_handle_object
*imgHandleObj
;
935 GET_CURRENT_CONTEXT(ctx
);
937 if (!_mesa_has_ARB_bindless_texture(ctx
) ||
938 !_mesa_has_ARB_shader_image_load_store(ctx
)) {
939 _mesa_error(ctx
, GL_INVALID_OPERATION
,
940 "glMakeImageHandleNonResidentARB(unsupported)");
944 /* The ARB_bindless_texture spec says:
946 * "The error INVALID_OPERATION is generated by
947 * MakeImageHandleNonResidentARB if <handle> is not a valid image handle,
948 * or if <handle> is not resident in the current GL context."
950 imgHandleObj
= lookup_image_handle(ctx
, handle
);
952 _mesa_error(ctx
, GL_INVALID_OPERATION
,
953 "glMakeImageHandleNonResidentARB(handle)");
957 if (!is_image_handle_resident(ctx
, handle
)) {
958 _mesa_error(ctx
, GL_INVALID_OPERATION
,
959 "glMakeImageHandleNonResidentARB(not resident)");
963 make_image_handle_resident(ctx
, imgHandleObj
, GL_READ_ONLY
, false);
967 _mesa_IsTextureHandleResidentARB_no_error(GLuint64 handle
)
969 GET_CURRENT_CONTEXT(ctx
);
970 return is_texture_handle_resident(ctx
, handle
);
974 _mesa_IsTextureHandleResidentARB(GLuint64 handle
)
976 GET_CURRENT_CONTEXT(ctx
);
978 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
979 _mesa_error(ctx
, GL_INVALID_OPERATION
,
980 "glIsTextureHandleResidentARB(unsupported)");
984 /* The ARB_bindless_texture spec says:
986 * "The error INVALID_OPERATION will be generated by
987 * IsTextureHandleResidentARB and IsImageHandleResidentARB if <handle> is
988 * not a valid texture or image handle, respectively."
990 if (!lookup_texture_handle(ctx
, handle
)) {
991 _mesa_error(ctx
, GL_INVALID_OPERATION
,
992 "glIsTextureHandleResidentARB(handle)");
996 return is_texture_handle_resident(ctx
, handle
);
1000 _mesa_IsImageHandleResidentARB_no_error(GLuint64 handle
)
1002 GET_CURRENT_CONTEXT(ctx
);
1003 return is_image_handle_resident(ctx
, handle
);
1006 GLboolean GLAPIENTRY
1007 _mesa_IsImageHandleResidentARB(GLuint64 handle
)
1009 GET_CURRENT_CONTEXT(ctx
);
1011 if (!_mesa_has_ARB_bindless_texture(ctx
) ||
1012 !_mesa_has_ARB_shader_image_load_store(ctx
)) {
1013 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1014 "glIsImageHandleResidentARB(unsupported)");
1018 /* The ARB_bindless_texture spec says:
1020 * "The error INVALID_OPERATION will be generated by
1021 * IsTextureHandleResidentARB and IsImageHandleResidentARB if <handle> is
1022 * not a valid texture or image handle, respectively."
1024 if (!lookup_image_handle(ctx
, handle
)) {
1025 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1026 "glIsImageHandleResidentARB(handle)");
1030 return is_image_handle_resident(ctx
, handle
);