/* * Copyright © 2017 Valve Corporation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #include "glheader.h" #include "context.h" #include "enums.h" #include "imports.h" #include "hash.h" #include "mtypes.h" #include "shaderimage.h" #include "teximage.h" #include "texobj.h" #include "texturebindless.h" #include "util/hash_table.h" /** * Return the gl_texture_handle_object for a given 64-bit handle. */ static struct gl_texture_handle_object * lookup_texture_handle(struct gl_context *ctx, GLuint64 id) { struct gl_texture_handle_object *texHandleObj; mtx_lock(&ctx->Shared->HandlesMutex); texHandleObj = (struct gl_texture_handle_object *) _mesa_hash_table_u64_search(ctx->Shared->TextureHandles, id); mtx_unlock(&ctx->Shared->HandlesMutex); return texHandleObj; } /** * Return the gl_image_handle_object for a given 64-bit handle. */ static struct gl_image_handle_object * lookup_image_handle(struct gl_context *ctx, GLuint64 id) { struct gl_image_handle_object *imgHandleObj; mtx_lock(&ctx->Shared->HandlesMutex); imgHandleObj = (struct gl_image_handle_object *) _mesa_hash_table_u64_search(ctx->Shared->ImageHandles, id); mtx_unlock(&ctx->Shared->HandlesMutex); return imgHandleObj; } /** * Delete a texture handle in the shared state. */ static void delete_texture_handle(struct gl_context *ctx, GLuint64 id) { mtx_lock(&ctx->Shared->HandlesMutex); _mesa_hash_table_u64_remove(ctx->Shared->TextureHandles, id); mtx_unlock(&ctx->Shared->HandlesMutex); ctx->Driver.DeleteTextureHandle(ctx, id); } /** * Delete an image handle in the shared state. */ static void delete_image_handle(struct gl_context *ctx, GLuint64 id) { mtx_lock(&ctx->Shared->HandlesMutex); _mesa_hash_table_u64_remove(ctx->Shared->ImageHandles, id); mtx_unlock(&ctx->Shared->HandlesMutex); ctx->Driver.DeleteImageHandle(ctx, id); } /** * Return TRUE if the texture handle is resident in the current context. */ static inline bool is_texture_handle_resident(struct gl_context *ctx, GLuint64 handle) { return _mesa_hash_table_u64_search(ctx->ResidentTextureHandles, handle) != NULL; } /** * Return TRUE if the image handle is resident in the current context. */ static inline bool is_image_handle_resident(struct gl_context *ctx, GLuint64 handle) { return _mesa_hash_table_u64_search(ctx->ResidentImageHandles, handle) != NULL; } /** * Make a texture handle resident/non-resident in the current context. */ static void make_texture_handle_resident(struct gl_context *ctx, struct gl_texture_handle_object *texHandleObj, bool resident) { struct gl_sampler_object *sampObj = NULL; struct gl_texture_object *texObj = NULL; GLuint64 handle = texHandleObj->handle; if (resident) { assert(!is_texture_handle_resident(ctx, handle)); _mesa_hash_table_u64_insert(ctx->ResidentTextureHandles, handle, texHandleObj); ctx->Driver.MakeTextureHandleResident(ctx, handle, GL_TRUE); /* Reference the texture object (and the separate sampler if needed) to * be sure it won't be deleted until it is not bound anywhere and there * are no handles using the object that are resident in any context. */ _mesa_reference_texobj(&texObj, texHandleObj->texObj); if (texHandleObj->sampObj) _mesa_reference_sampler_object(ctx, &sampObj, texHandleObj->sampObj); } else { assert(is_texture_handle_resident(ctx, handle)); _mesa_hash_table_u64_remove(ctx->ResidentTextureHandles, handle); ctx->Driver.MakeTextureHandleResident(ctx, handle, GL_FALSE); /* Unreference the texture object but keep the pointer intact, if * refcount hits zero, the texture and all handles will be deleted. */ texObj = texHandleObj->texObj; _mesa_reference_texobj(&texObj, NULL); /* Unreference the separate sampler object but keep the pointer intact, * if refcount hits zero, the sampler and all handles will be deleted. */ if (texHandleObj->sampObj) { sampObj = texHandleObj->sampObj; _mesa_reference_sampler_object(ctx, &sampObj, NULL); } } } /** * Make an image handle resident/non-resident in the current context. */ static void make_image_handle_resident(struct gl_context *ctx, struct gl_image_handle_object *imgHandleObj, GLenum access, bool resident) { struct gl_texture_object *texObj = NULL; GLuint64 handle = imgHandleObj->handle; if (resident) { assert(!is_image_handle_resident(ctx, handle)); _mesa_hash_table_u64_insert(ctx->ResidentImageHandles, handle, imgHandleObj); ctx->Driver.MakeImageHandleResident(ctx, handle, access, GL_TRUE); /* Reference the texture object to be sure it won't be deleted until it * is not bound anywhere and there are no handles using the object that * are resident in any context. */ _mesa_reference_texobj(&texObj, imgHandleObj->imgObj.TexObj); } else { assert(is_image_handle_resident(ctx, handle)); _mesa_hash_table_u64_remove(ctx->ResidentImageHandles, handle); ctx->Driver.MakeImageHandleResident(ctx, handle, access, GL_FALSE); /* Unreference the texture object but keep the pointer intact, if * refcount hits zero, the texture and all handles will be deleted. */ texObj = imgHandleObj->imgObj.TexObj; _mesa_reference_texobj(&texObj, NULL); } } static struct gl_texture_handle_object * find_texhandleobj(struct gl_texture_object *texObj, struct gl_sampler_object *sampObj) { util_dynarray_foreach(&texObj->SamplerHandles, struct gl_texture_handle_object *, texHandleObj) { if ((*texHandleObj)->sampObj == sampObj) return *texHandleObj; } return NULL; } static GLuint64 get_texture_handle(struct gl_context *ctx, struct gl_texture_object *texObj, struct gl_sampler_object *sampObj) { bool separate_sampler = &texObj->Sampler != sampObj; struct gl_texture_handle_object *texHandleObj; GLuint64 handle; /* The ARB_bindless_texture spec says: * * "The handle for each texture or texture/sampler pair is unique; the same * handle will be returned if GetTextureHandleARB is called multiple times * for the same texture or if GetTextureSamplerHandleARB is called multiple * times for the same texture/sampler pair." */ mtx_lock(&ctx->Shared->HandlesMutex); texHandleObj = find_texhandleobj(texObj, separate_sampler ? sampObj : NULL); if (texHandleObj) { mtx_unlock(&ctx->Shared->HandlesMutex); return texHandleObj->handle; } /* Request a new texture handle from the driver. */ handle = ctx->Driver.NewTextureHandle(ctx, texObj, sampObj); if (!handle) { mtx_unlock(&ctx->Shared->HandlesMutex); _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexture*HandleARB()"); return 0; } texHandleObj = CALLOC_STRUCT(gl_texture_handle_object); if (!texHandleObj) { mtx_unlock(&ctx->Shared->HandlesMutex); _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexture*HandleARB()"); return 0; } /* Store the handle into the texture object. */ texHandleObj->texObj = texObj; texHandleObj->sampObj = separate_sampler ? sampObj : NULL; texHandleObj->handle = handle; util_dynarray_append(&texObj->SamplerHandles, struct gl_texture_handle_object *, texHandleObj); if (separate_sampler) { /* Store the handle into the separate sampler if needed. */ util_dynarray_append(&sampObj->Handles, struct gl_texture_handle_object *, texHandleObj); } /* When referenced by one or more handles, texture objects are immutable. */ texObj->HandleAllocated = true; if (texObj->Target == GL_TEXTURE_BUFFER) texObj->BufferObject->HandleAllocated = true; sampObj->HandleAllocated = true; /* Store the handle in the shared state for all contexts. */ _mesa_hash_table_u64_insert(ctx->Shared->TextureHandles, handle, texHandleObj); mtx_unlock(&ctx->Shared->HandlesMutex); return handle; } static struct gl_image_handle_object * find_imghandleobj(struct gl_texture_object *texObj, GLint level, GLboolean layered, GLint layer, GLenum format) { util_dynarray_foreach(&texObj->ImageHandles, struct gl_image_handle_object *, imgHandleObj) { struct gl_image_unit *u = &(*imgHandleObj)->imgObj; if (u->TexObj == texObj && u->Level == level && u->Layered == layered && u->Layer == layer && u->Format == format) return *imgHandleObj; } return NULL; } static GLuint64 get_image_handle(struct gl_context *ctx, struct gl_texture_object *texObj, GLint level, GLboolean layered, GLint layer, GLenum format) { struct gl_image_handle_object *imgHandleObj; struct gl_image_unit imgObj; GLuint64 handle; /* The ARB_bindless_texture spec says: * * "The handle returned for each combination of <texture>, <level>, * <layered>, <layer>, and <format> is unique; the same handle will be * returned if GetImageHandleARB is called multiple times with the same * parameters." */ mtx_lock(&ctx->Shared->HandlesMutex); imgHandleObj = find_imghandleobj(texObj, level, layered, layer, format); if (imgHandleObj) { mtx_unlock(&ctx->Shared->HandlesMutex); return imgHandleObj->handle; } imgObj.TexObj = texObj; /* weak reference */ imgObj.Level = level; imgObj.Access = GL_READ_WRITE; imgObj.Format = format; imgObj._ActualFormat = _mesa_get_shader_image_format(format); if (_mesa_tex_target_is_layered(texObj->Target)) { imgObj.Layered = layered; imgObj.Layer = layer; imgObj._Layer = (imgObj.Layered ? 0 : imgObj.Layer); } else { imgObj.Layered = GL_FALSE; imgObj.Layer = 0; imgObj._Layer = 0; } /* Request a new image handle from the driver. */ handle = ctx->Driver.NewImageHandle(ctx, &imgObj); if (!handle) { mtx_unlock(&ctx->Shared->HandlesMutex); _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetImageHandleARB()"); return 0; } imgHandleObj = CALLOC_STRUCT(gl_image_handle_object); if (!imgHandleObj) { mtx_unlock(&ctx->Shared->HandlesMutex); _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetImageHandleARB()"); return 0; } /* Store the handle into the texture object. */ memcpy(&imgHandleObj->imgObj, &imgObj, sizeof(struct gl_image_unit)); imgHandleObj->handle = handle; util_dynarray_append(&texObj->ImageHandles, struct gl_image_handle_object *, imgHandleObj); /* When referenced by one or more handles, texture objects are immutable. */ texObj->HandleAllocated = true; if (texObj->Target == GL_TEXTURE_BUFFER) texObj->BufferObject->HandleAllocated = true; texObj->Sampler.HandleAllocated = true; /* Store the handle in the shared state for all contexts. */ _mesa_hash_table_u64_insert(ctx->Shared->ImageHandles, handle, imgHandleObj); mtx_unlock(&ctx->Shared->HandlesMutex); return handle; } /** * Init/free per-context resident handles. */ void _mesa_init_resident_handles(struct gl_context *ctx) { ctx->ResidentTextureHandles = _mesa_hash_table_u64_create(NULL); ctx->ResidentImageHandles = _mesa_hash_table_u64_create(NULL); } void _mesa_free_resident_handles(struct gl_context *ctx) { _mesa_hash_table_u64_destroy(ctx->ResidentTextureHandles, NULL); _mesa_hash_table_u64_destroy(ctx->ResidentImageHandles, NULL); } /** * Init/free shared allocated handles. */ void _mesa_init_shared_handles(struct gl_shared_state *shared) { shared->TextureHandles = _mesa_hash_table_u64_create(NULL); shared->ImageHandles = _mesa_hash_table_u64_create(NULL); mtx_init(&shared->HandlesMutex, mtx_recursive); } void _mesa_free_shared_handles(struct gl_shared_state *shared) { if (shared->TextureHandles) _mesa_hash_table_u64_destroy(shared->TextureHandles, NULL); if (shared->ImageHandles) _mesa_hash_table_u64_destroy(shared->ImageHandles, NULL); mtx_destroy(&shared->HandlesMutex); } /** * Init/free texture/image handles per-texture object. */ void _mesa_init_texture_handles(struct gl_texture_object *texObj) { util_dynarray_init(&texObj->SamplerHandles, NULL); util_dynarray_init(&texObj->ImageHandles, NULL); } void _mesa_make_texture_handles_non_resident(struct gl_context *ctx, struct gl_texture_object *texObj) { mtx_lock(&ctx->Shared->HandlesMutex); /* Texture handles */ util_dynarray_foreach(&texObj->SamplerHandles, struct gl_texture_handle_object *, texHandleObj) { if (is_texture_handle_resident(ctx, (*texHandleObj)->handle)) make_texture_handle_resident(ctx, *texHandleObj, false); } /* Image handles */ util_dynarray_foreach(&texObj->ImageHandles, struct gl_image_handle_object *, imgHandleObj) { if (is_image_handle_resident(ctx, (*imgHandleObj)->handle)) make_image_handle_resident(ctx, *imgHandleObj, GL_READ_ONLY, false); } mtx_unlock(&ctx->Shared->HandlesMutex); } void _mesa_delete_texture_handles(struct gl_context *ctx, struct gl_texture_object *texObj) { /* Texture handles */ util_dynarray_foreach(&texObj->SamplerHandles, struct gl_texture_handle_object *, texHandleObj) { struct gl_sampler_object *sampObj = (*texHandleObj)->sampObj; if (sampObj) { /* Delete the handle in the separate sampler object. */ util_dynarray_delete_unordered(&sampObj->Handles, struct gl_texture_handle_object *, *texHandleObj); } delete_texture_handle(ctx, (*texHandleObj)->handle); free(*texHandleObj); } util_dynarray_fini(&texObj->SamplerHandles); /* Image handles */ util_dynarray_foreach(&texObj->ImageHandles, struct gl_image_handle_object *, imgHandleObj) { delete_image_handle(ctx, (*imgHandleObj)->handle); free(*imgHandleObj); } util_dynarray_fini(&texObj->ImageHandles); } /** * Init/free texture handles per-sampler object. */ void _mesa_init_sampler_handles(struct gl_sampler_object *sampObj) { util_dynarray_init(&sampObj->Handles, NULL); } void _mesa_delete_sampler_handles(struct gl_context *ctx, struct gl_sampler_object *sampObj) { util_dynarray_foreach(&sampObj->Handles, struct gl_texture_handle_object *, texHandleObj) { struct gl_texture_object *texObj = (*texHandleObj)->texObj; /* Delete the handle in the texture object. */ util_dynarray_delete_unordered(&texObj->SamplerHandles, struct gl_texture_handle_object *, *texHandleObj); delete_texture_handle(ctx, (*texHandleObj)->handle); free(*texHandleObj); } util_dynarray_fini(&sampObj->Handles); } static GLboolean is_sampler_border_color_valid(struct gl_sampler_object *samp) { static const GLfloat valid_float_border_colors[4][4] = { { 0.0, 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0, 1.0 }, { 1.0, 1.0, 1.0, 0.0 }, { 1.0, 1.0, 1.0, 1.0 }, }; static const GLint valid_integer_border_colors[4][4] = { { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { 1, 1, 1, 0 }, { 1, 1, 1, 1 }, }; size_t size = sizeof(samp->BorderColor.ui); /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION is generated if the border color (taken from * the embedded sampler for GetTextureHandleARB or from the <sampler> for * GetTextureSamplerHandleARB) is not one of the following allowed values. * If the texture's base internal format is signed or unsigned integer, * allowed values are (0,0,0,0), (0,0,0,1), (1,1,1,0), and (1,1,1,1). If * the base internal format is not integer, allowed values are * (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 * (1.0,1.0,1.0,1.0)." */ if (!memcmp(samp->BorderColor.f, valid_float_border_colors[0], size) || !memcmp(samp->BorderColor.f, valid_float_border_colors[1], size) || !memcmp(samp->BorderColor.f, valid_float_border_colors[2], size) || !memcmp(samp->BorderColor.f, valid_float_border_colors[3], size)) return GL_TRUE; if (!memcmp(samp->BorderColor.ui, valid_integer_border_colors[0], size) || !memcmp(samp->BorderColor.ui, valid_integer_border_colors[1], size) || !memcmp(samp->BorderColor.ui, valid_integer_border_colors[2], size) || !memcmp(samp->BorderColor.ui, valid_integer_border_colors[3], size)) return GL_TRUE; return GL_FALSE; } GLuint64 GLAPIENTRY _mesa_GetTextureHandleARB_no_error(GLuint texture) { struct gl_texture_object *texObj; GET_CURRENT_CONTEXT(ctx); texObj = _mesa_lookup_texture(ctx, texture); if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) _mesa_test_texobj_completeness(ctx, texObj); return get_texture_handle(ctx, texObj, &texObj->Sampler); } GLuint64 GLAPIENTRY _mesa_GetTextureHandleARB(GLuint texture) { struct gl_texture_object *texObj = NULL; GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTextureHandleARB(unsupported)"); return 0; } /* The ARB_bindless_texture spec says: * * "The error INVALID_VALUE is generated by GetTextureHandleARB or * GetTextureSamplerHandleARB if <texture> is zero or not the name of an * existing texture object." */ if (texture > 0) texObj = _mesa_lookup_texture(ctx, texture); if (!texObj) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetTextureHandleARB(texture)"); return 0; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION is generated by GetTextureHandleARB or * GetTextureSamplerHandleARB if the texture object specified by <texture> * is not complete." */ if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) { _mesa_test_texobj_completeness(ctx, texObj); if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTextureHandleARB(incomplete texture)"); return 0; } } if (!is_sampler_border_color_valid(&texObj->Sampler)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTextureHandleARB(invalid border color)"); return 0; } return get_texture_handle(ctx, texObj, &texObj->Sampler); } GLuint64 GLAPIENTRY _mesa_GetTextureSamplerHandleARB_no_error(GLuint texture, GLuint sampler) { struct gl_texture_object *texObj; struct gl_sampler_object *sampObj; GET_CURRENT_CONTEXT(ctx); texObj = _mesa_lookup_texture(ctx, texture); sampObj = _mesa_lookup_samplerobj(ctx, sampler); if (!_mesa_is_texture_complete(texObj, sampObj)) _mesa_test_texobj_completeness(ctx, texObj); return get_texture_handle(ctx, texObj, sampObj); } GLuint64 GLAPIENTRY _mesa_GetTextureSamplerHandleARB(GLuint texture, GLuint sampler) { struct gl_texture_object *texObj = NULL; struct gl_sampler_object *sampObj; GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTextureSamplerHandleARB(unsupported)"); return 0; } /* The ARB_bindless_texture spec says: * * "The error INVALID_VALUE is generated by GetTextureHandleARB or * GetTextureSamplerHandleARB if <texture> is zero or not the name of an * existing texture object." */ if (texture > 0) texObj = _mesa_lookup_texture(ctx, texture); if (!texObj) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetTextureSamplerHandleARB(texture)"); return 0; } /* The ARB_bindless_texture spec says: * * "The error INVALID_VALUE is generated by GetTextureSamplerHandleARB if * <sampler> is zero or is not the name of an existing sampler object." */ sampObj = _mesa_lookup_samplerobj(ctx, sampler); if (!sampObj) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetTextureSamplerHandleARB(sampler)"); return 0; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION is generated by GetTextureHandleARB or * GetTextureSamplerHandleARB if the texture object specified by <texture> * is not complete." */ if (!_mesa_is_texture_complete(texObj, sampObj)) { _mesa_test_texobj_completeness(ctx, texObj); if (!_mesa_is_texture_complete(texObj, sampObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTextureSamplerHandleARB(incomplete texture)"); return 0; } } if (!is_sampler_border_color_valid(sampObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTextureSamplerHandleARB(invalid border color)"); return 0; } return get_texture_handle(ctx, texObj, sampObj); } void GLAPIENTRY _mesa_MakeTextureHandleResidentARB_no_error(GLuint64 handle) { struct gl_texture_handle_object *texHandleObj; GET_CURRENT_CONTEXT(ctx); texHandleObj = lookup_texture_handle(ctx, handle); make_texture_handle_resident(ctx, texHandleObj, true); } void GLAPIENTRY _mesa_MakeTextureHandleResidentARB(GLuint64 handle) { struct gl_texture_handle_object *texHandleObj; GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeTextureHandleResidentARB(unsupported)"); return; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION is generated by MakeTextureHandleResidentARB * if <handle> is not a valid texture handle, or if <handle> is already * resident in the current GL context." */ texHandleObj = lookup_texture_handle(ctx, handle); if (!texHandleObj) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeTextureHandleResidentARB(handle)"); return; } if (is_texture_handle_resident(ctx, handle)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeTextureHandleResidentARB(already resident)"); return; } make_texture_handle_resident(ctx, texHandleObj, true); } void GLAPIENTRY _mesa_MakeTextureHandleNonResidentARB_no_error(GLuint64 handle) { struct gl_texture_handle_object *texHandleObj; GET_CURRENT_CONTEXT(ctx); texHandleObj = lookup_texture_handle(ctx, handle); make_texture_handle_resident(ctx, texHandleObj, false); } void GLAPIENTRY _mesa_MakeTextureHandleNonResidentARB(GLuint64 handle) { struct gl_texture_handle_object *texHandleObj; GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeTextureHandleNonResidentARB(unsupported)"); return; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION is generated by * MakeTextureHandleNonResidentARB if <handle> is not a valid texture * handle, or if <handle> is not resident in the current GL context." */ texHandleObj = lookup_texture_handle(ctx, handle); if (!texHandleObj) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeTextureHandleNonResidentARB(handle)"); return; } if (!is_texture_handle_resident(ctx, handle)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeTextureHandleNonResidentARB(not resident)"); return; } make_texture_handle_resident(ctx, texHandleObj, false); } GLuint64 GLAPIENTRY _mesa_GetImageHandleARB_no_error(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) { struct gl_texture_object *texObj; GET_CURRENT_CONTEXT(ctx); texObj = _mesa_lookup_texture(ctx, texture); if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) _mesa_test_texobj_completeness(ctx, texObj); return get_image_handle(ctx, texObj, level, layered, layer, format); } GLuint64 GLAPIENTRY _mesa_GetImageHandleARB(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) { struct gl_texture_object *texObj = NULL; GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx) || !_mesa_has_ARB_shader_image_load_store(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetImageHandleARB(unsupported)"); return 0; } /* The ARB_bindless_texture spec says: * * "The error INVALID_VALUE is generated by GetImageHandleARB if <texture> * is zero or not the name of an existing texture object, if the image for * <level> does not existing in <texture>, or if <layered> is FALSE and * <layer> is greater than or equal to the number of layers in the image at * <level>." */ if (texture > 0) texObj = _mesa_lookup_texture(ctx, texture); if (!texObj) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetImageHandleARB(texture)"); return 0; } if (level < 0 || level >= _mesa_max_texture_levels(ctx, texObj->Target)) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetImageHandleARB(level)"); return 0; } if (!layered && layer > _mesa_get_texture_layers(texObj, level)) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetImageHandleARB(layer)"); return 0; } if (!_mesa_is_shader_image_format_supported(ctx, format)) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetImageHandleARB(format)"); return 0; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION is generated by GetImageHandleARB if the * texture object <texture> is not complete or if <layered> is TRUE and * <texture> is not a three-dimensional, one-dimensional array, two * dimensional array, cube map, or cube map array texture." */ if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) { _mesa_test_texobj_completeness(ctx, texObj); if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetImageHandleARB(incomplete texture)"); return 0; } } if (layered && !_mesa_tex_target_is_layered(texObj->Target)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetImageHandleARB(not layered)"); return 0; } return get_image_handle(ctx, texObj, level, layered, layer, format); } void GLAPIENTRY _mesa_MakeImageHandleResidentARB_no_error(GLuint64 handle, GLenum access) { struct gl_image_handle_object *imgHandleObj; GET_CURRENT_CONTEXT(ctx); imgHandleObj = lookup_image_handle(ctx, handle); make_image_handle_resident(ctx, imgHandleObj, access, true); } void GLAPIENTRY _mesa_MakeImageHandleResidentARB(GLuint64 handle, GLenum access) { struct gl_image_handle_object *imgHandleObj; GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx) || !_mesa_has_ARB_shader_image_load_store(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeImageHandleResidentARB(unsupported)"); return; } if (access != GL_READ_ONLY && access != GL_WRITE_ONLY && access != GL_READ_WRITE) { _mesa_error(ctx, GL_INVALID_ENUM, "glMakeImageHandleResidentARB(access)"); return; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION is generated by MakeImageHandleResidentARB * if <handle> is not a valid image handle, or if <handle> is already * resident in the current GL context." */ imgHandleObj = lookup_image_handle(ctx, handle); if (!imgHandleObj) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeImageHandleResidentARB(handle)"); return; } if (is_image_handle_resident(ctx, handle)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeImageHandleResidentARB(already resident)"); return; } make_image_handle_resident(ctx, imgHandleObj, access, true); } void GLAPIENTRY _mesa_MakeImageHandleNonResidentARB_no_error(GLuint64 handle) { struct gl_image_handle_object *imgHandleObj; GET_CURRENT_CONTEXT(ctx); imgHandleObj = lookup_image_handle(ctx, handle); make_image_handle_resident(ctx, imgHandleObj, GL_READ_ONLY, false); } void GLAPIENTRY _mesa_MakeImageHandleNonResidentARB(GLuint64 handle) { struct gl_image_handle_object *imgHandleObj; GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx) || !_mesa_has_ARB_shader_image_load_store(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeImageHandleNonResidentARB(unsupported)"); return; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION is generated by * MakeImageHandleNonResidentARB if <handle> is not a valid image handle, * or if <handle> is not resident in the current GL context." */ imgHandleObj = lookup_image_handle(ctx, handle); if (!imgHandleObj) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeImageHandleNonResidentARB(handle)"); return; } if (!is_image_handle_resident(ctx, handle)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMakeImageHandleNonResidentARB(not resident)"); return; } make_image_handle_resident(ctx, imgHandleObj, GL_READ_ONLY, false); } GLboolean GLAPIENTRY _mesa_IsTextureHandleResidentARB_no_error(GLuint64 handle) { GET_CURRENT_CONTEXT(ctx); return is_texture_handle_resident(ctx, handle); } GLboolean GLAPIENTRY _mesa_IsTextureHandleResidentARB(GLuint64 handle) { GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glIsTextureHandleResidentARB(unsupported)"); return GL_FALSE; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION will be generated by * IsTextureHandleResidentARB and IsImageHandleResidentARB if <handle> is * not a valid texture or image handle, respectively." */ if (!lookup_texture_handle(ctx, handle)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glIsTextureHandleResidentARB(handle)"); return GL_FALSE; } return is_texture_handle_resident(ctx, handle); } GLboolean GLAPIENTRY _mesa_IsImageHandleResidentARB_no_error(GLuint64 handle) { GET_CURRENT_CONTEXT(ctx); return is_image_handle_resident(ctx, handle); } GLboolean GLAPIENTRY _mesa_IsImageHandleResidentARB(GLuint64 handle) { GET_CURRENT_CONTEXT(ctx); if (!_mesa_has_ARB_bindless_texture(ctx) || !_mesa_has_ARB_shader_image_load_store(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glIsImageHandleResidentARB(unsupported)"); return GL_FALSE; } /* The ARB_bindless_texture spec says: * * "The error INVALID_OPERATION will be generated by * IsTextureHandleResidentARB and IsImageHandleResidentARB if <handle> is * not a valid texture or image handle, respectively." */ if (!lookup_image_handle(ctx, handle)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glIsImageHandleResidentARB(handle)"); return GL_FALSE; } return is_image_handle_resident(ctx, handle); }