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
;
333 /* Request a new image handle from the driver. */
334 handle
= ctx
->Driver
.NewImageHandle(ctx
, &imgObj
);
336 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
337 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glGetImageHandleARB()");
341 imgHandleObj
= CALLOC_STRUCT(gl_image_handle_object
);
343 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
344 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glGetImageHandleARB()");
348 /* Store the handle into the texture object. */
349 memcpy(&imgHandleObj
->imgObj
, &imgObj
, sizeof(struct gl_image_unit
));
350 imgHandleObj
->handle
= handle
;
351 util_dynarray_append(&texObj
->ImageHandles
,
352 struct gl_image_handle_object
*, imgHandleObj
);
354 /* When referenced by one or more handles, texture objects are immutable. */
355 texObj
->HandleAllocated
= true;
356 if (texObj
->Target
== GL_TEXTURE_BUFFER
)
357 texObj
->BufferObject
->HandleAllocated
= true;
358 texObj
->Sampler
.HandleAllocated
= true;
360 /* Store the handle in the shared state for all contexts. */
361 _mesa_hash_table_u64_insert(ctx
->Shared
->ImageHandles
, handle
, imgHandleObj
);
362 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
368 * Init/free per-context resident handles.
371 _mesa_init_resident_handles(struct gl_context
*ctx
)
373 ctx
->ResidentTextureHandles
= _mesa_hash_table_u64_create(NULL
);
374 ctx
->ResidentImageHandles
= _mesa_hash_table_u64_create(NULL
);
378 _mesa_free_resident_handles(struct gl_context
*ctx
)
380 _mesa_hash_table_u64_destroy(ctx
->ResidentTextureHandles
, NULL
);
381 _mesa_hash_table_u64_destroy(ctx
->ResidentImageHandles
, NULL
);
385 * Init/free shared allocated handles.
388 _mesa_init_shared_handles(struct gl_shared_state
*shared
)
390 shared
->TextureHandles
= _mesa_hash_table_u64_create(NULL
);
391 shared
->ImageHandles
= _mesa_hash_table_u64_create(NULL
);
392 mtx_init(&shared
->HandlesMutex
, mtx_recursive
);
396 _mesa_free_shared_handles(struct gl_shared_state
*shared
)
398 if (shared
->TextureHandles
)
399 _mesa_hash_table_u64_destroy(shared
->TextureHandles
, NULL
);
401 if (shared
->ImageHandles
)
402 _mesa_hash_table_u64_destroy(shared
->ImageHandles
, NULL
);
404 mtx_destroy(&shared
->HandlesMutex
);
408 * Init/free texture/image handles per-texture object.
411 _mesa_init_texture_handles(struct gl_texture_object
*texObj
)
413 util_dynarray_init(&texObj
->SamplerHandles
, NULL
);
414 util_dynarray_init(&texObj
->ImageHandles
, NULL
);
418 _mesa_make_texture_handles_non_resident(struct gl_context
*ctx
,
419 struct gl_texture_object
*texObj
)
421 mtx_lock(&ctx
->Shared
->HandlesMutex
);
423 /* Texture handles */
424 util_dynarray_foreach(&texObj
->SamplerHandles
,
425 struct gl_texture_handle_object
*, texHandleObj
) {
426 if (is_texture_handle_resident(ctx
, (*texHandleObj
)->handle
))
427 make_texture_handle_resident(ctx
, *texHandleObj
, false);
431 util_dynarray_foreach(&texObj
->ImageHandles
,
432 struct gl_image_handle_object
*, imgHandleObj
) {
433 if (is_image_handle_resident(ctx
, (*imgHandleObj
)->handle
))
434 make_image_handle_resident(ctx
, *imgHandleObj
, GL_READ_ONLY
, false);
437 mtx_unlock(&ctx
->Shared
->HandlesMutex
);
441 _mesa_delete_texture_handles(struct gl_context
*ctx
,
442 struct gl_texture_object
*texObj
)
444 /* Texture handles */
445 util_dynarray_foreach(&texObj
->SamplerHandles
,
446 struct gl_texture_handle_object
*, texHandleObj
) {
447 struct gl_sampler_object
*sampObj
= (*texHandleObj
)->sampObj
;
450 /* Delete the handle in the separate sampler object. */
451 util_dynarray_delete_unordered(&sampObj
->Handles
,
452 struct gl_texture_handle_object
*,
455 delete_texture_handle(ctx
, (*texHandleObj
)->handle
);
458 util_dynarray_fini(&texObj
->SamplerHandles
);
461 util_dynarray_foreach(&texObj
->ImageHandles
,
462 struct gl_image_handle_object
*, imgHandleObj
) {
463 delete_image_handle(ctx
, (*imgHandleObj
)->handle
);
466 util_dynarray_fini(&texObj
->ImageHandles
);
470 * Init/free texture handles per-sampler object.
473 _mesa_init_sampler_handles(struct gl_sampler_object
*sampObj
)
475 util_dynarray_init(&sampObj
->Handles
, NULL
);
479 _mesa_delete_sampler_handles(struct gl_context
*ctx
,
480 struct gl_sampler_object
*sampObj
)
482 util_dynarray_foreach(&sampObj
->Handles
,
483 struct gl_texture_handle_object
*, texHandleObj
) {
484 struct gl_texture_object
*texObj
= (*texHandleObj
)->texObj
;
486 /* Delete the handle in the texture object. */
487 util_dynarray_delete_unordered(&texObj
->SamplerHandles
,
488 struct gl_texture_handle_object
*,
491 delete_texture_handle(ctx
, (*texHandleObj
)->handle
);
494 util_dynarray_fini(&sampObj
->Handles
);
498 is_sampler_border_color_valid(struct gl_sampler_object
*samp
)
500 static const GLfloat valid_float_border_colors
[4][4] = {
501 { 0.0, 0.0, 0.0, 0.0 },
502 { 0.0, 0.0, 0.0, 1.0 },
503 { 1.0, 1.0, 1.0, 0.0 },
504 { 1.0, 1.0, 1.0, 1.0 },
506 static const GLint valid_integer_border_colors
[4][4] = {
512 size_t size
= sizeof(samp
->BorderColor
.ui
);
514 /* The ARB_bindless_texture spec says:
516 * "The error INVALID_OPERATION is generated if the border color (taken from
517 * the embedded sampler for GetTextureHandleARB or from the <sampler> for
518 * GetTextureSamplerHandleARB) is not one of the following allowed values.
519 * If the texture's base internal format is signed or unsigned integer,
520 * allowed values are (0,0,0,0), (0,0,0,1), (1,1,1,0), and (1,1,1,1). If
521 * the base internal format is not integer, allowed values are
522 * (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
523 * (1.0,1.0,1.0,1.0)."
525 if (!memcmp(samp
->BorderColor
.f
, valid_float_border_colors
[0], size
) ||
526 !memcmp(samp
->BorderColor
.f
, valid_float_border_colors
[1], size
) ||
527 !memcmp(samp
->BorderColor
.f
, valid_float_border_colors
[2], size
) ||
528 !memcmp(samp
->BorderColor
.f
, valid_float_border_colors
[3], size
))
531 if (!memcmp(samp
->BorderColor
.ui
, valid_integer_border_colors
[0], size
) ||
532 !memcmp(samp
->BorderColor
.ui
, valid_integer_border_colors
[1], size
) ||
533 !memcmp(samp
->BorderColor
.ui
, valid_integer_border_colors
[2], size
) ||
534 !memcmp(samp
->BorderColor
.ui
, valid_integer_border_colors
[3], size
))
541 _mesa_GetTextureHandleARB_no_error(GLuint texture
)
543 struct gl_texture_object
*texObj
;
545 GET_CURRENT_CONTEXT(ctx
);
547 texObj
= _mesa_lookup_texture(ctx
, texture
);
548 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
))
549 _mesa_test_texobj_completeness(ctx
, texObj
);
551 return get_texture_handle(ctx
, texObj
, &texObj
->Sampler
);
555 _mesa_GetTextureHandleARB(GLuint texture
)
557 struct gl_texture_object
*texObj
= NULL
;
559 GET_CURRENT_CONTEXT(ctx
);
561 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
562 _mesa_error(ctx
, GL_INVALID_OPERATION
,
563 "glGetTextureHandleARB(unsupported)");
567 /* The ARB_bindless_texture spec says:
569 * "The error INVALID_VALUE is generated by GetTextureHandleARB or
570 * GetTextureSamplerHandleARB if <texture> is zero or not the name of an
571 * existing texture object."
574 texObj
= _mesa_lookup_texture(ctx
, texture
);
577 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetTextureHandleARB(texture)");
581 /* The ARB_bindless_texture spec says:
583 * "The error INVALID_OPERATION is generated by GetTextureHandleARB or
584 * GetTextureSamplerHandleARB if the texture object specified by <texture>
587 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
)) {
588 _mesa_test_texobj_completeness(ctx
, texObj
);
589 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
)) {
590 _mesa_error(ctx
, GL_INVALID_OPERATION
,
591 "glGetTextureHandleARB(incomplete texture)");
596 if (!is_sampler_border_color_valid(&texObj
->Sampler
)) {
597 _mesa_error(ctx
, GL_INVALID_OPERATION
,
598 "glGetTextureHandleARB(invalid border color)");
602 return get_texture_handle(ctx
, texObj
, &texObj
->Sampler
);
606 _mesa_GetTextureSamplerHandleARB_no_error(GLuint texture
, GLuint sampler
)
608 struct gl_texture_object
*texObj
;
609 struct gl_sampler_object
*sampObj
;
611 GET_CURRENT_CONTEXT(ctx
);
613 texObj
= _mesa_lookup_texture(ctx
, texture
);
614 sampObj
= _mesa_lookup_samplerobj(ctx
, sampler
);
616 if (!_mesa_is_texture_complete(texObj
, sampObj
))
617 _mesa_test_texobj_completeness(ctx
, texObj
);
619 return get_texture_handle(ctx
, texObj
, sampObj
);
623 _mesa_GetTextureSamplerHandleARB(GLuint texture
, GLuint sampler
)
625 struct gl_texture_object
*texObj
= NULL
;
626 struct gl_sampler_object
*sampObj
;
628 GET_CURRENT_CONTEXT(ctx
);
630 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
631 _mesa_error(ctx
, GL_INVALID_OPERATION
,
632 "glGetTextureSamplerHandleARB(unsupported)");
636 /* The ARB_bindless_texture spec says:
638 * "The error INVALID_VALUE is generated by GetTextureHandleARB or
639 * GetTextureSamplerHandleARB if <texture> is zero or not the name of an
640 * existing texture object."
643 texObj
= _mesa_lookup_texture(ctx
, texture
);
646 _mesa_error(ctx
, GL_INVALID_VALUE
,
647 "glGetTextureSamplerHandleARB(texture)");
651 /* The ARB_bindless_texture spec says:
653 * "The error INVALID_VALUE is generated by GetTextureSamplerHandleARB if
654 * <sampler> is zero or is not the name of an existing sampler object."
656 sampObj
= _mesa_lookup_samplerobj(ctx
, sampler
);
658 _mesa_error(ctx
, GL_INVALID_VALUE
,
659 "glGetTextureSamplerHandleARB(sampler)");
663 /* The ARB_bindless_texture spec says:
665 * "The error INVALID_OPERATION is generated by GetTextureHandleARB or
666 * GetTextureSamplerHandleARB if the texture object specified by <texture>
669 if (!_mesa_is_texture_complete(texObj
, sampObj
)) {
670 _mesa_test_texobj_completeness(ctx
, texObj
);
671 if (!_mesa_is_texture_complete(texObj
, sampObj
)) {
672 _mesa_error(ctx
, GL_INVALID_OPERATION
,
673 "glGetTextureSamplerHandleARB(incomplete texture)");
678 if (!is_sampler_border_color_valid(sampObj
)) {
679 _mesa_error(ctx
, GL_INVALID_OPERATION
,
680 "glGetTextureSamplerHandleARB(invalid border color)");
684 return get_texture_handle(ctx
, texObj
, sampObj
);
688 _mesa_MakeTextureHandleResidentARB_no_error(GLuint64 handle
)
690 struct gl_texture_handle_object
*texHandleObj
;
692 GET_CURRENT_CONTEXT(ctx
);
694 texHandleObj
= lookup_texture_handle(ctx
, handle
);
695 make_texture_handle_resident(ctx
, texHandleObj
, true);
699 _mesa_MakeTextureHandleResidentARB(GLuint64 handle
)
701 struct gl_texture_handle_object
*texHandleObj
;
703 GET_CURRENT_CONTEXT(ctx
);
705 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
706 _mesa_error(ctx
, GL_INVALID_OPERATION
,
707 "glMakeTextureHandleResidentARB(unsupported)");
711 /* The ARB_bindless_texture spec says:
713 * "The error INVALID_OPERATION is generated by MakeTextureHandleResidentARB
714 * if <handle> is not a valid texture handle, or if <handle> is already
715 * resident in the current GL context."
717 texHandleObj
= lookup_texture_handle(ctx
, handle
);
719 _mesa_error(ctx
, GL_INVALID_OPERATION
,
720 "glMakeTextureHandleResidentARB(handle)");
724 if (is_texture_handle_resident(ctx
, handle
)) {
725 _mesa_error(ctx
, GL_INVALID_OPERATION
,
726 "glMakeTextureHandleResidentARB(already resident)");
730 make_texture_handle_resident(ctx
, texHandleObj
, true);
734 _mesa_MakeTextureHandleNonResidentARB_no_error(GLuint64 handle
)
736 struct gl_texture_handle_object
*texHandleObj
;
738 GET_CURRENT_CONTEXT(ctx
);
740 texHandleObj
= lookup_texture_handle(ctx
, handle
);
741 make_texture_handle_resident(ctx
, texHandleObj
, false);
745 _mesa_MakeTextureHandleNonResidentARB(GLuint64 handle
)
747 struct gl_texture_handle_object
*texHandleObj
;
749 GET_CURRENT_CONTEXT(ctx
);
751 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
752 _mesa_error(ctx
, GL_INVALID_OPERATION
,
753 "glMakeTextureHandleNonResidentARB(unsupported)");
757 /* The ARB_bindless_texture spec says:
759 * "The error INVALID_OPERATION is generated by
760 * MakeTextureHandleNonResidentARB if <handle> is not a valid texture
761 * handle, or if <handle> is not resident in the current GL context."
763 texHandleObj
= lookup_texture_handle(ctx
, handle
);
765 _mesa_error(ctx
, GL_INVALID_OPERATION
,
766 "glMakeTextureHandleNonResidentARB(handle)");
770 if (!is_texture_handle_resident(ctx
, handle
)) {
771 _mesa_error(ctx
, GL_INVALID_OPERATION
,
772 "glMakeTextureHandleNonResidentARB(not resident)");
776 make_texture_handle_resident(ctx
, texHandleObj
, false);
780 _mesa_GetImageHandleARB_no_error(GLuint texture
, GLint level
, GLboolean layered
,
781 GLint layer
, GLenum format
)
783 struct gl_texture_object
*texObj
;
785 GET_CURRENT_CONTEXT(ctx
);
787 texObj
= _mesa_lookup_texture(ctx
, texture
);
788 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
))
789 _mesa_test_texobj_completeness(ctx
, texObj
);
791 return get_image_handle(ctx
, texObj
, level
, layered
, layer
, format
);
795 _mesa_GetImageHandleARB(GLuint texture
, GLint level
, GLboolean layered
,
796 GLint layer
, GLenum format
)
798 struct gl_texture_object
*texObj
= NULL
;
800 GET_CURRENT_CONTEXT(ctx
);
802 if (!_mesa_has_ARB_bindless_texture(ctx
) ||
803 !_mesa_has_ARB_shader_image_load_store(ctx
)) {
804 _mesa_error(ctx
, GL_INVALID_OPERATION
,
805 "glGetImageHandleARB(unsupported)");
809 /* The ARB_bindless_texture spec says:
811 * "The error INVALID_VALUE is generated by GetImageHandleARB if <texture>
812 * is zero or not the name of an existing texture object, if the image for
813 * <level> does not existing in <texture>, or if <layered> is FALSE and
814 * <layer> is greater than or equal to the number of layers in the image at
818 texObj
= _mesa_lookup_texture(ctx
, texture
);
821 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetImageHandleARB(texture)");
825 if (level
< 0 || level
>= _mesa_max_texture_levels(ctx
, texObj
->Target
)) {
826 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetImageHandleARB(level)");
830 if (!layered
&& layer
> _mesa_get_texture_layers(texObj
, level
)) {
831 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetImageHandleARB(layer)");
835 if (!_mesa_is_shader_image_format_supported(ctx
, format
)) {
836 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetImageHandleARB(format)");
840 /* The ARB_bindless_texture spec says:
842 * "The error INVALID_OPERATION is generated by GetImageHandleARB if the
843 * texture object <texture> is not complete or if <layered> is TRUE and
844 * <texture> is not a three-dimensional, one-dimensional array, two
845 * dimensional array, cube map, or cube map array texture."
847 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
)) {
848 _mesa_test_texobj_completeness(ctx
, texObj
);
849 if (!_mesa_is_texture_complete(texObj
, &texObj
->Sampler
)) {
850 _mesa_error(ctx
, GL_INVALID_OPERATION
,
851 "glGetImageHandleARB(incomplete texture)");
856 if (layered
&& !_mesa_tex_target_is_layered(texObj
->Target
)) {
857 _mesa_error(ctx
, GL_INVALID_OPERATION
,
858 "glGetImageHandleARB(not layered)");
862 return get_image_handle(ctx
, texObj
, level
, layered
, layer
, format
);
866 _mesa_MakeImageHandleResidentARB_no_error(GLuint64 handle
, GLenum access
)
868 struct gl_image_handle_object
*imgHandleObj
;
870 GET_CURRENT_CONTEXT(ctx
);
872 imgHandleObj
= lookup_image_handle(ctx
, handle
);
873 make_image_handle_resident(ctx
, imgHandleObj
, access
, true);
877 _mesa_MakeImageHandleResidentARB(GLuint64 handle
, GLenum access
)
879 struct gl_image_handle_object
*imgHandleObj
;
881 GET_CURRENT_CONTEXT(ctx
);
883 if (!_mesa_has_ARB_bindless_texture(ctx
) ||
884 !_mesa_has_ARB_shader_image_load_store(ctx
)) {
885 _mesa_error(ctx
, GL_INVALID_OPERATION
,
886 "glMakeImageHandleResidentARB(unsupported)");
890 if (access
!= GL_READ_ONLY
&&
891 access
!= GL_WRITE_ONLY
&&
892 access
!= GL_READ_WRITE
) {
893 _mesa_error(ctx
, GL_INVALID_ENUM
,
894 "glMakeImageHandleResidentARB(access)");
898 /* The ARB_bindless_texture spec says:
900 * "The error INVALID_OPERATION is generated by MakeImageHandleResidentARB
901 * if <handle> is not a valid image handle, or if <handle> is already
902 * resident in the current GL context."
904 imgHandleObj
= lookup_image_handle(ctx
, handle
);
906 _mesa_error(ctx
, GL_INVALID_OPERATION
,
907 "glMakeImageHandleResidentARB(handle)");
911 if (is_image_handle_resident(ctx
, handle
)) {
912 _mesa_error(ctx
, GL_INVALID_OPERATION
,
913 "glMakeImageHandleResidentARB(already resident)");
917 make_image_handle_resident(ctx
, imgHandleObj
, access
, true);
921 _mesa_MakeImageHandleNonResidentARB_no_error(GLuint64 handle
)
923 struct gl_image_handle_object
*imgHandleObj
;
925 GET_CURRENT_CONTEXT(ctx
);
927 imgHandleObj
= lookup_image_handle(ctx
, handle
);
928 make_image_handle_resident(ctx
, imgHandleObj
, GL_READ_ONLY
, false);
932 _mesa_MakeImageHandleNonResidentARB(GLuint64 handle
)
934 struct gl_image_handle_object
*imgHandleObj
;
936 GET_CURRENT_CONTEXT(ctx
);
938 if (!_mesa_has_ARB_bindless_texture(ctx
) ||
939 !_mesa_has_ARB_shader_image_load_store(ctx
)) {
940 _mesa_error(ctx
, GL_INVALID_OPERATION
,
941 "glMakeImageHandleNonResidentARB(unsupported)");
945 /* The ARB_bindless_texture spec says:
947 * "The error INVALID_OPERATION is generated by
948 * MakeImageHandleNonResidentARB if <handle> is not a valid image handle,
949 * or if <handle> is not resident in the current GL context."
951 imgHandleObj
= lookup_image_handle(ctx
, handle
);
953 _mesa_error(ctx
, GL_INVALID_OPERATION
,
954 "glMakeImageHandleNonResidentARB(handle)");
958 if (!is_image_handle_resident(ctx
, handle
)) {
959 _mesa_error(ctx
, GL_INVALID_OPERATION
,
960 "glMakeImageHandleNonResidentARB(not resident)");
964 make_image_handle_resident(ctx
, imgHandleObj
, GL_READ_ONLY
, false);
968 _mesa_IsTextureHandleResidentARB_no_error(GLuint64 handle
)
970 GET_CURRENT_CONTEXT(ctx
);
971 return is_texture_handle_resident(ctx
, handle
);
975 _mesa_IsTextureHandleResidentARB(GLuint64 handle
)
977 GET_CURRENT_CONTEXT(ctx
);
979 if (!_mesa_has_ARB_bindless_texture(ctx
)) {
980 _mesa_error(ctx
, GL_INVALID_OPERATION
,
981 "glIsTextureHandleResidentARB(unsupported)");
985 /* The ARB_bindless_texture spec says:
987 * "The error INVALID_OPERATION will be generated by
988 * IsTextureHandleResidentARB and IsImageHandleResidentARB if <handle> is
989 * not a valid texture or image handle, respectively."
991 if (!lookup_texture_handle(ctx
, handle
)) {
992 _mesa_error(ctx
, GL_INVALID_OPERATION
,
993 "glIsTextureHandleResidentARB(handle)");
997 return is_texture_handle_resident(ctx
, handle
);
1000 GLboolean GLAPIENTRY
1001 _mesa_IsImageHandleResidentARB_no_error(GLuint64 handle
)
1003 GET_CURRENT_CONTEXT(ctx
);
1004 return is_image_handle_resident(ctx
, handle
);
1007 GLboolean GLAPIENTRY
1008 _mesa_IsImageHandleResidentARB(GLuint64 handle
)
1010 GET_CURRENT_CONTEXT(ctx
);
1012 if (!_mesa_has_ARB_bindless_texture(ctx
) ||
1013 !_mesa_has_ARB_shader_image_load_store(ctx
)) {
1014 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1015 "glIsImageHandleResidentARB(unsupported)");
1019 /* The ARB_bindless_texture spec says:
1021 * "The error INVALID_OPERATION will be generated by
1022 * IsTextureHandleResidentARB and IsImageHandleResidentARB if <handle> is
1023 * not a valid texture or image handle, respectively."
1025 if (!lookup_image_handle(ctx
, handle
)) {
1026 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1027 "glIsImageHandleResidentARB(handle)");
1031 return is_image_handle_resident(ctx
, handle
);