From 1fe7b1f9724ac38cbddcac6505d3750ef99a2eca Mon Sep 17 00:00:00 2001 From: Samuel Pitoiset Date: Mon, 3 Apr 2017 22:06:27 +0200 Subject: [PATCH] mesa: implement ARB_bindless_texture MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Signed-off-by: Samuel Pitoiset Reviewed-by: Nicolai Hähnle --- src/mesa/main/context.c | 3 + src/mesa/main/dd.h | 17 + src/mesa/main/mtypes.h | 38 ++ src/mesa/main/samplerobj.c | 6 + src/mesa/main/shared.c | 6 + src/mesa/main/texobj.c | 13 + src/mesa/main/texturebindless.c | 852 +++++++++++++++++++++++++++++++++++++++- src/mesa/main/texturebindless.h | 32 ++ 8 files changed, 960 insertions(+), 7 deletions(-) diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c index 9aa6fb6..b801322 100644 --- a/src/mesa/main/context.c +++ b/src/mesa/main/context.c @@ -133,6 +133,7 @@ #include "varray.h" #include "version.h" #include "viewport.h" +#include "texturebindless.h" #include "program/program.h" #include "math/m_matrix.h" #include "main/dispatch.h" /* for _gloffset_COUNT */ @@ -855,6 +856,7 @@ init_attrib_groups(struct gl_context *ctx) _mesa_init_transform_feedback( ctx ); _mesa_init_varray( ctx ); _mesa_init_viewport( ctx ); + _mesa_init_resident_handles( ctx ); if (!_mesa_init_texture( ctx )) return GL_FALSE; @@ -1339,6 +1341,7 @@ _mesa_free_context_data( struct gl_context *ctx ) _mesa_free_transform_feedback(ctx); _mesa_free_performance_monitors(ctx); _mesa_free_performance_queries(ctx); + _mesa_free_resident_handles(ctx); _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL); _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL); diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h index 29fc93f..84ed57f 100644 --- a/src/mesa/main/dd.h +++ b/src/mesa/main/dd.h @@ -1050,6 +1050,23 @@ struct dd_function_table { GLintptr offset, GLsizeiptr size, GLboolean commit); /*@}*/ + + /** + * \name GL_ARB_bindless_texture interface + */ + /*@{*/ + GLuint64 (*NewTextureHandle)(struct gl_context *ctx, + struct gl_texture_object *texObj, + struct gl_sampler_object *sampObj); + void (*DeleteTextureHandle)(struct gl_context *ctx, GLuint64 handle); + void (*MakeTextureHandleResident)(struct gl_context *ctx, GLuint64 handle, + bool resident); + GLuint64 (*NewImageHandle)(struct gl_context *ctx, + struct gl_image_unit *imgObj); + void (*DeleteImageHandle)(struct gl_context *ctx, GLuint64 handle); + void (*MakeImageHandleResident)(struct gl_context *ctx, GLuint64 handle, + GLenum access, bool resident); + /*@}*/ }; diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index 21ddf57..8a80f4f 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -47,6 +47,7 @@ #include "main/formats.h" /* MESA_FORMAT_COUNT */ #include "compiler/glsl/list.h" #include "util/bitscan.h" +#include "util/u_dynarray.h" #ifdef __cplusplus @@ -988,6 +989,10 @@ struct gl_sampler_object GLenum CompareFunc; /**< GL_ARB_shadow */ GLenum sRGBDecode; /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */ GLboolean CubeMapSeamless; /**< GL_AMD_seamless_cubemap_per_texture */ + + /** GL_ARB_bindless_texture */ + struct util_dynarray Handles; + bool HandleAllocated; }; @@ -1052,6 +1057,11 @@ struct gl_texture_object /** GL_ARB_shader_image_load_store */ GLenum ImageFormatCompatibilityType; + + /** GL_ARB_bindless_texture */ + struct util_dynarray SamplerHandles; + struct util_dynarray ImageHandles; + bool HandleAllocated; }; @@ -1404,6 +1414,8 @@ struct gl_buffer_object unsigned MinMaxCacheHitIndices; unsigned MinMaxCacheMissIndices; bool MinMaxCacheDirty; + + bool HandleAllocated; /**< GL_ARB_bindless_texture */ }; @@ -3212,6 +3224,11 @@ struct gl_shared_state /** GL_ARB_sampler_objects */ struct _mesa_HashTable *SamplerObjects; + /* GL_ARB_bindless_texture */ + struct hash_table_u64 *TextureHandles; + struct hash_table_u64 *ImageHandles; + mtx_t HandlesMutex; /**< For texture/image handles safety */ + /** * Some context in this share group was affected by a GPU reset * @@ -4515,6 +4532,19 @@ struct gl_subroutine_index_binding GLuint *IndexPtr; }; +struct gl_texture_handle_object +{ + struct gl_texture_object *texObj; + struct gl_sampler_object *sampObj; + GLuint64 handle; +}; + +struct gl_image_handle_object +{ + struct gl_image_unit imgObj; + GLuint64 handle; +}; + /** * Mesa rendering context. * @@ -4869,6 +4899,14 @@ struct gl_context GLfloat PrimitiveBoundingBox[8]; struct disk_cache *Cache; + + /** + * \name GL_ARB_bindless_texture + */ + /*@{*/ + struct hash_table_u64 *ResidentTextureHandles; + struct hash_table_u64 *ResidentImageHandles; + /*@}*/ }; /** diff --git a/src/mesa/main/samplerobj.c b/src/mesa/main/samplerobj.c index 63beaf1..ee15c68 100644 --- a/src/mesa/main/samplerobj.c +++ b/src/mesa/main/samplerobj.c @@ -38,6 +38,7 @@ #include "main/macros.h" #include "main/mtypes.h" #include "main/samplerobj.h" +#include "main/texturebindless.h" struct gl_sampler_object * @@ -61,6 +62,7 @@ static void delete_sampler_object(struct gl_context *ctx, struct gl_sampler_object *sampObj) { + _mesa_delete_sampler_handles(ctx, sampObj); mtx_destroy(&sampObj->Mutex); free(sampObj->Label); free(sampObj); @@ -132,6 +134,10 @@ _mesa_init_sampler_object(struct gl_sampler_object *sampObj, GLuint name) sampObj->CompareFunc = GL_LEQUAL; sampObj->sRGBDecode = GL_DECODE_EXT; sampObj->CubeMapSeamless = GL_FALSE; + sampObj->HandleAllocated = GL_FALSE; + + /* GL_ARB_bindless_texture */ + _mesa_init_sampler_handles(sampObj); } /** diff --git a/src/mesa/main/shared.c b/src/mesa/main/shared.c index 5344812..6926d40 100644 --- a/src/mesa/main/shared.c +++ b/src/mesa/main/shared.c @@ -39,6 +39,7 @@ #include "shaderapi.h" #include "shaderobj.h" #include "syncobj.h" +#include "texturebindless.h" #include "util/hash_table.h" #include "util/set.h" @@ -84,6 +85,9 @@ _mesa_alloc_shared_state(struct gl_context *ctx) /* GL_ARB_sampler_objects */ shared->SamplerObjects = _mesa_NewHashTable(); + /* GL_ARB_bindless_texture */ + _mesa_init_shared_handles(shared); + /* Allocate the default buffer object */ shared->NullBufferObj = ctx->Driver.NewBufferObject(ctx, 0); @@ -373,6 +377,8 @@ free_shared_state(struct gl_context *ctx, struct gl_shared_state *shared) _mesa_HashDeleteAll(shared->TexObjects, delete_texture_cb, ctx); _mesa_DeleteHashTable(shared->TexObjects); + _mesa_free_shared_handles(shared); + mtx_destroy(&shared->Mutex); mtx_destroy(&shared->TexMutex); diff --git a/src/mesa/main/texobj.c b/src/mesa/main/texobj.c index 868e4eb..1877262 100644 --- a/src/mesa/main/texobj.c +++ b/src/mesa/main/texobj.c @@ -43,6 +43,7 @@ #include "texstate.h" #include "mtypes.h" #include "program/prog_instruction.h" +#include "texturebindless.h" @@ -311,6 +312,7 @@ _mesa_initialize_texture_object( struct gl_context *ctx, obj->DepthMode = ctx->API == API_OPENGL_CORE ? GL_RED : GL_LUMINANCE; obj->StencilSampling = false; obj->Sampler.CubeMapSeamless = GL_FALSE; + obj->Sampler.HandleAllocated = GL_FALSE; obj->Swizzle[0] = GL_RED; obj->Swizzle[1] = GL_GREEN; obj->Swizzle[2] = GL_BLUE; @@ -320,6 +322,9 @@ _mesa_initialize_texture_object( struct gl_context *ctx, obj->BufferObjectFormat = GL_R8; obj->_BufferObjectFormat = MESA_FORMAT_R_UNORM8; obj->ImageFormatCompatibilityType = GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE; + + /* GL_ARB_bindless_texture */ + _mesa_init_texture_handles(obj); } @@ -397,6 +402,9 @@ _mesa_delete_texture_object(struct gl_context *ctx, } } + /* Delete all texture/image handles. */ + _mesa_delete_texture_handles(ctx, texObj); + _mesa_reference_buffer_object(ctx, &texObj->BufferObject, NULL); /* destroy the mutex -- it may have allocated memory (eg on bsd) */ @@ -1461,6 +1469,11 @@ _mesa_DeleteTextures( GLsizei n, const GLuint *textures) */ unbind_texobj_from_image_units(ctx, delObj); + /* Make all handles that reference this texture object non-resident + * in the current context. + */ + _mesa_make_texture_handles_non_resident(ctx, delObj); + _mesa_unlock_texture(ctx, delObj); ctx->NewState |= _NEW_TEXTURE_OBJECT; diff --git a/src/mesa/main/texturebindless.c b/src/mesa/main/texturebindless.c index 4d9c22d..26b0f58 100644 --- a/src/mesa/main/texturebindless.c +++ b/src/mesa/main/texturebindless.c @@ -25,61 +25,899 @@ #include "context.h" #include "enums.h" #include "imports.h" -#include "macros.h" +#include "hash.h" #include "mtypes.h" +#include "shaderimage.h" +#include "teximage.h" #include "texobj.h" #include "texturebindless.h" -#include "util/set.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 , , + * , , and 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; + } + + /* 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) +{ + _mesa_hash_table_u64_destroy(shared->TextureHandles, NULL); + _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 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(GLuint texture) { - return 0; + 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 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 + * 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(GLuint texture, GLuint sampler) { - return 0; + 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 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 + * 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 + * 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(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 is not a valid texture handle, or if 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(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 is not a valid texture + * handle, or if 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(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) { - return 0; + 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 + * is zero or not the name of an existing texture object, if the image for + * does not existing in , or if is FALSE and + * is greater than or equal to the number of layers in the image at + * ." + */ + 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 is not complete or if is TRUE and + * 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(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 is not a valid image handle, or if 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(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 is not a valid image handle, + * or if 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(GLuint64 handle) { - return GL_FALSE; + 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 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(GLuint64 handle) { - return GL_FALSE; + 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 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); } diff --git a/src/mesa/main/texturebindless.h b/src/mesa/main/texturebindless.h index 88b84ce..d584f5c 100644 --- a/src/mesa/main/texturebindless.h +++ b/src/mesa/main/texturebindless.h @@ -31,6 +31,38 @@ extern "C" { #endif /** + * \name Internal functions + */ +/*@{*/ + +void +_mesa_init_resident_handles(struct gl_context *ctx); +void +_mesa_free_resident_handles(struct gl_context *ctx); + +void +_mesa_init_shared_handles(struct gl_shared_state *shared); +void +_mesa_free_shared_handles(struct gl_shared_state *shared); + +void +_mesa_init_texture_handles(struct gl_texture_object *texObj); +void +_mesa_make_texture_handles_non_resident(struct gl_context *ctx, + struct gl_texture_object *texObj); +void +_mesa_delete_texture_handles(struct gl_context *ctx, + struct gl_texture_object *texObj); + +void +_mesa_init_sampler_handles(struct gl_sampler_object *sampObj); +void +_mesa_delete_sampler_handles(struct gl_context *ctx, + struct gl_sampler_object *sampObj); + +/*@}*/ + +/** * \name API functions */ /*@{*/ -- 2.7.4