#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"
DBG("%s\n", __func__);
_mesa_initialize_texture_object(ctx, &obj->base, name, target);
+ obj->needs_validation = true;
+
return &obj->base;
}
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__);
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
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;
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 */
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,
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 |
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 */
{
}
/* 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);
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;
}
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) {
}
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,
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;
}
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;
}
{
/* 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);
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);
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;
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
/* 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,
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;
}
}
+ 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;
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. */
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;
}
}
+ /* 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,
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];
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,
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)
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)
{
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;
}
projects / mesa.git / blobdiff