X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_texture.c;h=af2052db2435d02bb918bc8a767395ad8448d595;hb=733422e53c8758ce3f63db2109929339259681d8;hp=62c2900aeb10210d341cfb8d8a6ca9a83a523f17;hpb=7cd256ce7e4bad680bb77d033cf5dd662abab2dd;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c index 62c2900aeb1..af2052db243 100644 --- a/src/mesa/state_tracker/st_cb_texture.c +++ b/src/mesa/state_tracker/st_cb_texture.c @@ -53,11 +53,13 @@ #include "state_tracker/st_cb_flush.h" #include "state_tracker/st_cb_texture.h" #include "state_tracker/st_cb_bufferobjects.h" +#include "state_tracker/st_cb_memoryobjects.h" #include "state_tracker/st_format.h" #include "state_tracker/st_pbo.h" #include "state_tracker/st_texture.h" #include "state_tracker/st_gen_mipmap.h" #include "state_tracker/st_atom.h" +#include "state_tracker/st_sampler_view.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" @@ -153,6 +155,8 @@ st_NewTextureObject(struct gl_context * ctx, GLuint name, GLenum target) DBG("%s\n", __func__); _mesa_initialize_texture_object(ctx, &obj->base, name, target); + obj->needs_validation = true; + return &obj->base; } @@ -176,6 +180,8 @@ static void st_FreeTextureImageBuffer(struct gl_context *ctx, struct gl_texture_image *texImage) { + struct st_context *st = st_context(ctx); + struct st_texture_object *stObj = st_texture_object(texImage->TexObject); struct st_texture_image *stImage = st_texture_image(texImage); DBG("%s\n", __func__); @@ -192,6 +198,11 @@ st_FreeTextureImageBuffer(struct gl_context *ctx, free(stImage->etc_data); stImage->etc_data = NULL; } + + /* if the texture image is being deallocated, the structure of the + * texture is changing so we'll likely need a new sampler view. + */ + st_texture_release_all_sampler_views(st, stObj); } bool @@ -489,7 +500,8 @@ guess_and_alloc_texture(struct st_context *st, const struct gl_texture_image *firstImage; GLuint lastLevel, width, height, depth; GLuint bindings; - GLuint ptWidth, ptHeight, ptDepth, ptLayers; + unsigned ptWidth; + uint16_t ptHeight, ptDepth, ptLayers; enum pipe_format fmt; bool guessed_box = false; @@ -597,6 +609,8 @@ st_AllocTextureImageBuffer(struct gl_context *ctx, assert(!stImage->pt); /* xxx this might be wrong */ + stObj->needs_validation = true; + etc_fallback_allocate(st, stImage); /* Look if the parent texture object has space for this image */ @@ -641,7 +655,8 @@ st_AllocTextureImageBuffer(struct gl_context *ctx, enum pipe_format format = st_mesa_format_to_pipe_format(st, texImage->TexFormat); GLuint bindings = default_bindings(st, format); - GLuint ptWidth, ptHeight, ptDepth, ptLayers; + unsigned ptWidth; + uint16_t ptHeight, ptDepth, ptLayers; st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth, @@ -1130,13 +1145,11 @@ try_pbo_upload_common(struct gl_context *ctx, struct cso_context *cso = st->cso_context; struct pipe_context *pipe = st->pipe; bool success = false; + void *fs; - /* Create fragment shader */ - if (!st->pbo.upload_fs) { - st->pbo.upload_fs = st_pbo_create_upload_fs(st); - if (!st->pbo.upload_fs) - return false; - } + fs = st_pbo_get_upload_fs(st, src_format, surface->format); + if (!fs) + return false; cso_save_state(cso, (CSO_BIT_FRAGMENT_SAMPLER_VIEWS | CSO_BIT_FRAGMENT_SAMPLERS | @@ -1149,9 +1162,15 @@ try_pbo_upload_common(struct gl_context *ctx, CSO_BIT_RASTERIZER | CSO_BIT_STREAM_OUTPUTS | CSO_BIT_PAUSE_QUERIES | + CSO_BIT_SAMPLE_MASK | + CSO_BIT_MIN_SAMPLES | + CSO_BIT_RENDER_CONDITION | CSO_BITS_ALL_SHADERS)); cso_save_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT); + cso_set_sample_mask(cso, ~0); + cso_set_min_samples(cso, 1); + cso_set_render_condition(cso, NULL, FALSE, 0); /* Set up the sampler_view */ { @@ -1209,7 +1228,7 @@ try_pbo_upload_common(struct gl_context *ctx, } /* Set up the fragment shader */ - cso_set_fragment_shader_handle(cso, st->pbo.upload_fs); + cso_set_fragment_shader_handle(cso, fs); success = st_pbo_draw(st, addr, surface->width, surface->height); @@ -1820,8 +1839,9 @@ st_GetTexSubImage(struct gl_context * ctx, mesa_format mesa_format; GLenum gl_target = texImage->TexObject->Target; enum pipe_texture_target pipe_target; + unsigned dims; struct pipe_blit_info blit; - unsigned bind = PIPE_BIND_TRANSFER_READ; + unsigned bind; struct pipe_transfer *tex_xfer; ubyte *map = NULL; boolean done = FALSE; @@ -1885,9 +1905,9 @@ st_GetTexSubImage(struct gl_context * ctx, } if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL) - bind |= PIPE_BIND_DEPTH_STENCIL; + bind = PIPE_BIND_DEPTH_STENCIL; else - bind |= PIPE_BIND_RENDER_TARGET; + bind = PIPE_BIND_RENDER_TARGET; /* GetTexImage only returns a single face for cubemaps. */ if (gl_target == GL_TEXTURE_CUBE_MAP) { @@ -2008,6 +2028,7 @@ st_GetTexSubImage(struct gl_context * ctx, } mesa_format = st_pipe_format_to_mesa_format(dst_format); + dims = _mesa_get_texture_dimensions(gl_target); /* copy/pack data into user buffer */ if (_mesa_format_matches_format_and_type(mesa_format, format, type, @@ -2017,39 +2038,31 @@ st_GetTexSubImage(struct gl_context * ctx, GLuint row, slice; for (slice = 0; slice < depth; slice++) { - if (gl_target == GL_TEXTURE_1D_ARRAY) { - /* 1D array textures. - * We need to convert gallium coords to GL coords. - */ - void *dest = _mesa_image_address3d(&ctx->Pack, pixels, - width, depth, format, - type, 0, slice, 0); - memcpy(dest, map, bytesPerRow); - } - else { - ubyte *slice_map = map; + ubyte *slice_map = map; - for (row = 0; row < height; row++) { - void *dest = _mesa_image_address3d(&ctx->Pack, pixels, - width, height, format, - type, slice, row, 0); - memcpy(dest, slice_map, bytesPerRow); - slice_map += tex_xfer->stride; - } + for (row = 0; row < height; row++) { + void *dest = _mesa_image_address(dims, &ctx->Pack, pixels, + width, height, format, type, + slice, row, 0); + + memcpy(dest, slice_map, bytesPerRow); + + slice_map += tex_xfer->stride; } + map += tex_xfer->layer_stride; } } else { /* format translation via floats */ - GLuint row, slice; + GLuint slice; GLfloat *rgba; uint32_t dstMesaFormat; int dstStride, srcStride; assert(util_format_is_compressed(src->format)); - rgba = malloc(width * 4 * sizeof(GLfloat)); + rgba = malloc(width * height * 4 * sizeof(GLfloat)); if (!rgba) { goto end; } @@ -2061,37 +2074,24 @@ st_GetTexSubImage(struct gl_context * ctx, dstStride = _mesa_image_row_stride(&ctx->Pack, width, format, type); srcStride = 4 * width * sizeof(GLfloat); for (slice = 0; slice < depth; slice++) { - if (gl_target == GL_TEXTURE_1D_ARRAY) { - /* 1D array textures. - * We need to convert gallium coords to GL coords. - */ - void *dest = _mesa_image_address3d(&ctx->Pack, pixels, - width, depth, format, - type, 0, slice, 0); - - /* get float[4] rgba row from surface */ - pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, 1, - dst_format, rgba); - - _mesa_format_convert(dest, dstMesaFormat, dstStride, - rgba, RGBA32_FLOAT, srcStride, - width, 1, NULL); - } - else { - for (row = 0; row < height; row++) { - void *dest = _mesa_image_address3d(&ctx->Pack, pixels, - width, height, format, - type, slice, row, 0); - - /* get float[4] rgba row from surface */ - pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1, - dst_format, rgba); - - _mesa_format_convert(dest, dstMesaFormat, dstStride, - rgba, RGBA32_FLOAT, srcStride, - width, 1, NULL); - } + void *dest = _mesa_image_address(dims, &ctx->Pack, pixels, + width, height, format, type, + slice, 0, 0); + + /* get float[4] rgba row from surface */ + pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, height, + dst_format, rgba); + + _mesa_format_convert(dest, dstMesaFormat, dstStride, + rgba, RGBA32_FLOAT, srcStride, + width, height, NULL); + + /* Handle byte swapping if required */ + if (ctx->Pack.SwapBytes) { + _mesa_swap_bytes_2d_image(format, type, &ctx->Pack, + width, height, dest, dest); } + map += tex_xfer->layer_stride; } @@ -2397,7 +2397,7 @@ copy_image_data_to_texture(struct st_context *st, { /* debug checks */ { - const struct gl_texture_image *dstImage = + const struct gl_texture_image MAYBE_UNUSED *dstImage = stObj->base.Image[stImage->base.Face][dstLevel]; assert(dstImage); assert(dstImage->Width == stImage->base.Width); @@ -2441,7 +2441,8 @@ copy_image_data_to_texture(struct st_context *st, GLboolean st_finalize_texture(struct gl_context *ctx, struct pipe_context *pipe, - struct gl_texture_object *tObj) + struct gl_texture_object *tObj, + GLuint cubeMapFace) { struct st_context *st = st_context(ctx); struct st_texture_object *stObj = st_texture_object(tObj); @@ -2449,7 +2450,8 @@ st_finalize_texture(struct gl_context *ctx, GLuint face; const struct st_texture_image *firstImage; enum pipe_format firstImageFormat; - GLuint ptWidth, ptHeight, ptDepth, ptLayers, ptNumSamples; + unsigned ptWidth; + uint16_t ptHeight, ptDepth, ptLayers, ptNumSamples; if (tObj->Immutable) return GL_TRUE; @@ -2468,26 +2470,19 @@ st_finalize_texture(struct gl_context *ctx, stObj->lastLevel = stObj->base._MaxLevel; } - if (tObj->Target == GL_TEXTURE_BUFFER) { - struct st_buffer_object *st_obj = st_buffer_object(tObj->BufferObject); - - if (!st_obj) { - pipe_resource_reference(&stObj->pt, NULL); - st_texture_release_all_sampler_views(st, stObj); - return GL_TRUE; - } + firstImage = st_texture_image_const(stObj->base.Image[cubeMapFace][stObj->base.BaseLevel]); + assert(firstImage); - if (st_obj->buffer != stObj->pt) { - pipe_resource_reference(&stObj->pt, st_obj->buffer); - st_texture_release_all_sampler_views(st, stObj); - } + /* Skip the loop over images in the common case of no images having + * changed. But if the GL_BASE_LEVEL or GL_MAX_LEVEL change to something we + * haven't looked at, then we do need to look at those new images. + */ + if (!stObj->needs_validation && + stObj->base.BaseLevel >= stObj->validated_first_level && + stObj->lastLevel <= stObj->validated_last_level) { return GL_TRUE; - } - firstImage = st_texture_image_const(_mesa_base_tex_image(&stObj->base)); - assert(firstImage); - /* If both firstImage and stObj point to a texture which can contain * all active images, favour firstImage. Note that because of the * completeness requirement, we know that the image dimensions @@ -2511,7 +2506,8 @@ st_finalize_texture(struct gl_context *ctx, /* Find size of level=0 Gallium mipmap image, plus number of texture layers */ { - GLuint width, height, depth; + unsigned width; + uint16_t height, depth; st_gl_texture_dims_to_pipe_dims(stObj->base.Target, firstImage->base.Width2, @@ -2548,6 +2544,18 @@ st_finalize_texture(struct gl_context *ctx, stObj->base.Target == GL_TEXTURE_CUBE_MAP_ARRAY) ptHeight = ptWidth; } + + /* At this point, the texture may be incomplete (mismatched cube + * face sizes, for example). If that's the case, give up, but + * don't return GL_FALSE as that would raise an incorrect + * GL_OUT_OF_MEMORY error. See Piglit fbo-incomplete-texture-03 test. + */ + if (!stObj->base._BaseComplete) { + _mesa_test_texobj_completeness(ctx, &stObj->base); + if (!stObj->base._BaseComplete) { + return TRUE; + } + } } ptNumSamples = firstImage->base.NumSamples; @@ -2633,26 +2641,92 @@ st_finalize_texture(struct gl_context *ctx, } } + stObj->validated_first_level = stObj->base.BaseLevel; + stObj->validated_last_level = stObj->lastLevel; + stObj->needs_validation = false; + return GL_TRUE; } +/** + * Allocate a new pipe_resource object + * width0, height0, depth0 are the dimensions of the level 0 image + * (the highest resolution). last_level indicates how many mipmap levels + * to allocate storage for. For non-mipmapped textures, this will be zero. + */ +static struct pipe_resource * +st_texture_create_from_memory(struct st_context *st, + struct st_memory_object *memObj, + GLuint64 offset, + enum pipe_texture_target target, + enum pipe_format format, + GLuint last_level, + GLuint width0, + GLuint height0, + GLuint depth0, + GLuint layers, + GLuint nr_samples, + GLuint bind ) +{ + struct pipe_resource pt, *newtex; + struct pipe_screen *screen = st->pipe->screen; + + assert(target < PIPE_MAX_TEXTURE_TYPES); + assert(width0 > 0); + assert(height0 > 0); + assert(depth0 > 0); + if (target == PIPE_TEXTURE_CUBE) + assert(layers == 6); + + DBG("%s target %d format %s last_level %d\n", __func__, + (int) target, util_format_name(format), last_level); + + assert(format); + assert(screen->is_format_supported(screen, format, target, 0, + PIPE_BIND_SAMPLER_VIEW)); + + memset(&pt, 0, sizeof(pt)); + pt.target = target; + pt.format = format; + pt.last_level = last_level; + pt.width0 = width0; + pt.height0 = height0; + pt.depth0 = depth0; + pt.array_size = layers; + pt.usage = PIPE_USAGE_DEFAULT; + pt.bind = bind; + /* only set this for OpenGL textures, not renderbuffers */ + pt.flags = PIPE_RESOURCE_FLAG_TEXTURING_MORE_LIKELY; + pt.nr_samples = nr_samples; + + newtex = screen->resource_from_memobj(screen, &pt, memObj->memory, offset); + + assert(!newtex || pipe_is_referenced(&newtex->reference)); + + return newtex; +} /** - * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory - * for a whole mipmap stack. + * Allocate texture memory for a whole mipmap stack. + * Note: for multisample textures if the requested sample count is not + * supported, we search for the next higher supported sample count. */ static GLboolean -st_AllocTextureStorage(struct gl_context *ctx, - struct gl_texture_object *texObj, - GLsizei levels, GLsizei width, - GLsizei height, GLsizei depth) +st_texture_storage(struct gl_context *ctx, + struct gl_texture_object *texObj, + GLsizei levels, GLsizei width, + GLsizei height, GLsizei depth, + struct gl_memory_object *memObj, + GLuint64 offset) { const GLuint numFaces = _mesa_num_tex_faces(texObj->Target); struct gl_texture_image *texImage = texObj->Image[0][0]; struct st_context *st = st_context(ctx); struct st_texture_object *stObj = st_texture_object(texObj); + struct st_memory_object *smObj = st_memory_object(memObj); struct pipe_screen *screen = st->pipe->screen; - GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings; + unsigned ptWidth, bindings; + uint16_t ptHeight, ptDepth, ptLayers; enum pipe_format fmt; GLint level; GLuint num_samples = texImage->NumSamples; @@ -2666,11 +2740,15 @@ st_AllocTextureStorage(struct gl_context *ctx, bindings = default_bindings(st, fmt); /* Raise the sample count if the requested one is unsupported. */ - if (num_samples > 1) { + if (num_samples > 0) { + enum pipe_texture_target ptarget = gl_target_to_pipe(texObj->Target); boolean found = FALSE; + /* start the query with at least two samples */ + num_samples = MAX2(num_samples, 2); + for (; num_samples <= ctx->Const.MaxSamples; num_samples++) { - if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D, + if (screen->is_format_supported(screen, fmt, ptarget, num_samples, PIPE_BIND_SAMPLER_VIEW)) { /* Update the sample count in gl_texture_image as well. */ @@ -2689,15 +2767,31 @@ st_AllocTextureStorage(struct gl_context *ctx, width, height, depth, &ptWidth, &ptHeight, &ptDepth, &ptLayers); - stObj->pt = st_texture_create(st, - gl_target_to_pipe(texObj->Target), - fmt, - levels - 1, - ptWidth, - ptHeight, - ptDepth, - ptLayers, num_samples, - bindings); + if (smObj) { + stObj->pt = st_texture_create_from_memory(st, + smObj, + offset, + gl_target_to_pipe(texObj->Target), + fmt, + levels - 1, + ptWidth, + ptHeight, + ptDepth, + ptLayers, num_samples, + bindings); + } + else { + stObj->pt = st_texture_create(st, + gl_target_to_pipe(texObj->Target), + fmt, + levels - 1, + ptWidth, + ptHeight, + ptDepth, + ptLayers, num_samples, + bindings); + } + if (!stObj->pt) return GL_FALSE; @@ -2713,9 +2807,29 @@ st_AllocTextureStorage(struct gl_context *ctx, } } + /* The texture is in a validated state, so no need to check later. */ + stObj->needs_validation = false; + stObj->validated_first_level = 0; + stObj->validated_last_level = levels - 1; + return GL_TRUE; } +/** + * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory + * for a whole mipmap stack. + */ +static GLboolean +st_AllocTextureStorage(struct gl_context *ctx, + struct gl_texture_object *texObj, + GLsizei levels, GLsizei width, + GLsizei height, GLsizei depth) +{ + return st_texture_storage(ctx, texObj, levels, + width, height, depth, + NULL, 0); +} + static GLboolean st_TestProxyTexImage(struct gl_context *ctx, GLenum target, @@ -2778,6 +2892,7 @@ st_TextureView(struct gl_context *ctx, struct gl_texture_object *texObj, struct gl_texture_object *origTexObj) { + struct st_context *st = st_context(ctx); struct st_texture_object *orig = st_texture_object(origTexObj); struct st_texture_object *tex = st_texture_object(texObj); struct gl_texture_image *image = texObj->Image[0][0]; @@ -2805,9 +2920,55 @@ st_TextureView(struct gl_context *ctx, tex->lastLevel = numLevels - 1; + /* free texture sampler views. They need to be recreated when we + * change the texture view parameters. + */ + st_texture_release_all_sampler_views(st, tex); + + /* The texture is in a validated state, so no need to check later. */ + tex->needs_validation = false; + tex->validated_first_level = 0; + tex->validated_last_level = numLevels - 1; + return GL_TRUE; } + +/** + * Find the mipmap level in 'pt' which matches the level described by + * 'texImage'. + */ +static unsigned +find_mipmap_level(const struct gl_texture_image *texImage, + const struct pipe_resource *pt) +{ + const GLenum target = texImage->TexObject->Target; + GLint texWidth = texImage->Width; + GLint texHeight = texImage->Height; + GLint texDepth = texImage->Depth; + unsigned level, w; + uint16_t h, d, layers; + + st_gl_texture_dims_to_pipe_dims(target, texWidth, texHeight, texDepth, + &w, &h, &d, &layers); + + for (level = 0; level <= pt->last_level; level++) { + if (u_minify(pt->width0, level) == w && + u_minify(pt->height0, level) == h && + u_minify(pt->depth0, level) == d) { + return level; + } + } + + /* If we get here, there must be some sort of inconsistency between + * the Mesa texture object/images and the gallium resource. + */ + debug_printf("Inconsistent textures in find_mipmap_level()\n"); + + return texImage->Level; +} + + static void st_ClearTexSubImage(struct gl_context *ctx, struct gl_texture_image *texImage, @@ -2816,11 +2977,12 @@ st_ClearTexSubImage(struct gl_context *ctx, const void *clearValue) { static const char zeros[16] = {0}; + struct gl_texture_object *texObj = texImage->TexObject; struct st_texture_image *stImage = st_texture_image(texImage); struct pipe_resource *pt = stImage->pt; struct st_context *st = st_context(ctx); struct pipe_context *pipe = st->pipe; - unsigned level = texImage->Level; + unsigned level; struct pipe_box box; if (!pt) @@ -2831,14 +2993,156 @@ st_ClearTexSubImage(struct gl_context *ctx, u_box_3d(xoffset, yoffset, zoffset + texImage->Face, width, height, depth, &box); - if (texImage->TexObject->Immutable) { - level += texImage->TexObject->MinLevel; - box.z += texImage->TexObject->MinLayer; + if (texObj->Immutable) { + /* The texture object has to be consistent (no "loose", per-image + * gallium resources). If this texture is a view into another + * texture, we have to apply the MinLevel/Layer offsets. If this is + * not a texture view, the offsets will be zero. + */ + assert(stImage->pt == st_texture_object(texObj)->pt); + level = texImage->Level + texObj->MinLevel; + box.z += texObj->MinLayer; + } + else { + /* Texture level sizes may be inconsistent. We my have "loose", + * per-image gallium resources. The texImage->Level may not match + * the gallium resource texture level. + */ + level = find_mipmap_level(texImage, pt); } + assert(level <= pt->last_level); + pipe->clear_texture(pipe, pt, level, &box, clearValue ? clearValue : zeros); } + +/** + * Called via the glTexParam*() function, but only when some texture object + * state has actually changed. + */ +static void +st_TexParameter(struct gl_context *ctx, + struct gl_texture_object *texObj, GLenum pname) +{ + struct st_context *st = st_context(ctx); + struct st_texture_object *stObj = st_texture_object(texObj); + + switch (pname) { + case GL_TEXTURE_BASE_LEVEL: + case GL_TEXTURE_MAX_LEVEL: + case GL_DEPTH_TEXTURE_MODE: + case GL_DEPTH_STENCIL_TEXTURE_MODE: + case GL_TEXTURE_SRGB_DECODE_EXT: + case GL_TEXTURE_SWIZZLE_R: + case GL_TEXTURE_SWIZZLE_G: + case GL_TEXTURE_SWIZZLE_B: + case GL_TEXTURE_SWIZZLE_A: + case GL_TEXTURE_SWIZZLE_RGBA: + case GL_TEXTURE_BUFFER_SIZE: + case GL_TEXTURE_BUFFER_OFFSET: + /* changing any of these texture parameters means we must create + * new sampler views. + */ + st_texture_release_all_sampler_views(st, stObj); + break; + default: + ; /* nothing */ + } +} + +static GLboolean +st_SetTextureStorageForMemoryObject(struct gl_context *ctx, + struct gl_texture_object *texObj, + struct gl_memory_object *memObj, + GLsizei levels, GLsizei width, + GLsizei height, GLsizei depth, + GLuint64 offset) +{ + return st_texture_storage(ctx, texObj, levels, + width, height, depth, + memObj, offset); +} + +static GLuint64 +st_NewTextureHandle(struct gl_context *ctx, struct gl_texture_object *texObj, + struct gl_sampler_object *sampObj) +{ + struct st_context *st = st_context(ctx); + struct st_texture_object *stObj = st_texture_object(texObj); + struct pipe_context *pipe = st->pipe; + struct pipe_sampler_view *view; + struct pipe_sampler_state sampler = {0}; + + if (texObj->Target != GL_TEXTURE_BUFFER) { + if (!st_finalize_texture(ctx, pipe, texObj, 0)) + return 0; + + st_convert_sampler(st, texObj, sampObj, 0, &sampler); + view = st_get_texture_sampler_view_from_stobj(st, stObj, sampObj, 0); + } else { + view = st_get_buffer_sampler_view_from_stobj(st, stObj); + } + + return pipe->create_texture_handle(pipe, view, &sampler); +} + + +static void +st_DeleteTextureHandle(struct gl_context *ctx, GLuint64 handle) +{ + struct st_context *st = st_context(ctx); + struct pipe_context *pipe = st->pipe; + + pipe->delete_texture_handle(pipe, handle); +} + + +static void +st_MakeTextureHandleResident(struct gl_context *ctx, GLuint64 handle, + bool resident) +{ + struct st_context *st = st_context(ctx); + struct pipe_context *pipe = st->pipe; + + pipe->make_texture_handle_resident(pipe, handle, resident); +} + + +static GLuint64 +st_NewImageHandle(struct gl_context *ctx, struct gl_image_unit *imgObj) +{ + struct st_context *st = st_context(ctx); + struct pipe_context *pipe = st->pipe; + struct pipe_image_view image; + + st_convert_image(st, imgObj, &image); + + return pipe->create_image_handle(pipe, &image); +} + + +static void +st_DeleteImageHandle(struct gl_context *ctx, GLuint64 handle) +{ + struct st_context *st = st_context(ctx); + struct pipe_context *pipe = st->pipe; + + pipe->delete_image_handle(pipe, handle); +} + + +static void +st_MakeImageHandleResident(struct gl_context *ctx, GLuint64 handle, + GLenum access, bool resident) +{ + struct st_context *st = st_context(ctx); + struct pipe_context *pipe = st->pipe; + + pipe->make_image_handle_resident(pipe, handle, access, resident); +} + + void st_init_texture_functions(struct dd_function_table *functions) { @@ -2871,4 +3175,17 @@ st_init_texture_functions(struct dd_function_table *functions) functions->AllocTextureStorage = st_AllocTextureStorage; functions->TextureView = st_TextureView; functions->ClearTexSubImage = st_ClearTexSubImage; + + functions->TexParameter = st_TexParameter; + + /* bindless functions */ + functions->NewTextureHandle = st_NewTextureHandle; + functions->DeleteTextureHandle = st_DeleteTextureHandle; + functions->MakeTextureHandleResident = st_MakeTextureHandleResident; + functions->NewImageHandle = st_NewImageHandle; + functions->DeleteImageHandle = st_DeleteImageHandle; + functions->MakeImageHandleResident = st_MakeImageHandleResident; + + /* external object functions */ + functions->SetTextureStorageForMemoryObject = st_SetTextureStorageForMemoryObject; }