GPU_texture.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2005 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include <string>
 
#include "BLI_assert.h"
#include "BLI_utildefines.h"
 
#include "GPU_format.hh"
 
namespace blender::gpu {
class VertBuf;
}
 
namespace blender::gpu {
 
/* -------------------------------------------------------------------- */

enum class TextureFormat : uint8_t {
  Invalid = 0,
 
#define DECLARE(a, b, c, blender_enum, d, e, f, g, h) blender_enum = int(DataFormat::blender_enum),
 
#define GPU_TEXTURE_FORMAT_EXPAND(impl) \
  SNORM_8_(impl) \
  SNORM_8_8_(impl) \
  SNORM_8_8_8_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  SNORM_8_8_8_8_(impl) \
\
  SNORM_16_(impl) \
  SNORM_16_16_(impl) \
  SNORM_16_16_16_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  SNORM_16_16_16_16_(impl) \
\
  UNORM_8_(impl) \
  UNORM_8_8_(impl) \
  UNORM_8_8_8_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  UNORM_8_8_8_8_(impl) \
\
  UNORM_16_(impl) \
  UNORM_16_16_(impl) \
  UNORM_16_16_16_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  UNORM_16_16_16_16_(impl) \
\
  SINT_8_(impl) \
  SINT_8_8_(impl) \
  SINT_8_8_8_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  SINT_8_8_8_8_(impl) \
\
  SINT_16_(impl) \
  SINT_16_16_(impl) \
  SINT_16_16_16_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  SINT_16_16_16_16_(impl) \
\
  SINT_32_(impl) \
  SINT_32_32_(impl) \
  SINT_32_32_32_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  SINT_32_32_32_32_(impl) \
\
  UINT_8_(impl) \
  UINT_8_8_(impl) \
  UINT_8_8_8_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  UINT_8_8_8_8_(impl) \
\
  UINT_16_(impl) \
  UINT_16_16_(impl) \
  UINT_16_16_16_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  UINT_16_16_16_16_(impl) \
\
  UINT_32_(impl) \
  UINT_32_32_(impl) \
  UINT_32_32_32_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  UINT_32_32_32_32_(impl) \
\
  SFLOAT_16_(impl) \
  SFLOAT_16_16_(impl) \
  SFLOAT_16_16_16_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  SFLOAT_16_16_16_16_(impl) \
\
  SFLOAT_32_(impl) \
  SFLOAT_32_32_(impl) \
  SFLOAT_32_32_32_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  SFLOAT_32_32_32_32_(impl) \
\
  UNORM_10_10_10_2_(impl) \
  UINT_10_10_10_2_(impl) \
\
  UFLOAT_11_11_10_(impl) \
  UFLOAT_9_9_9_EXP_5_(impl) \
\
  UNORM_16_DEPTH_(impl) \
  SFLOAT_32_DEPTH_(impl) \
  SFLOAT_32_DEPTH_UINT_8_(impl) \
\
  SRGBA_8_8_8_(impl) /* TODO(fclem): Incompatible with metal, to remove. */ \
  SRGBA_8_8_8_8_(impl) \
\
  SNORM_DXT1_(impl) \
  SNORM_DXT3_(impl) \
  SNORM_DXT5_(impl) \
  SRGB_DXT1_(impl) \
  SRGB_DXT3_(impl) \
  SRGB_DXT5_(impl)
 
  GPU_TEXTURE_FORMAT_EXPAND(DECLARE)
 
#undef DECLARE
};
 
inline constexpr DataFormat to_data_format(TextureFormat format)
{
  return DataFormat(int(format));
}

enum class TextureTargetFormat : uint8_t {
  Invalid = 0,
 
#define DECLARE(a, b, c, blender_enum, d, e, f, g, h) \
  blender_enum = int(TextureFormat::blender_enum),
 
#define GPU_TEXTURE_TARGET_FORMAT_EXPAND(impl) \
  UNORM_8_(impl) \
  UNORM_8_8_(impl) \
  UNORM_8_8_8_8_(impl) \
\
  UNORM_16_(impl) \
  UNORM_16_16_(impl) \
  UNORM_16_16_16_16_(impl) \
\
  SINT_8_(impl) \
  SINT_8_8_(impl) \
  SINT_8_8_8_8_(impl) \
\
  SINT_16_(impl) \
  SINT_16_16_(impl) \
  SINT_16_16_16_16_(impl) \
\
  SINT_32_(impl) \
  SINT_32_32_(impl) \
  SINT_32_32_32_32_(impl) \
\
  UINT_8_(impl) \
  UINT_8_8_(impl) \
  UINT_8_8_8_8_(impl) \
\
  UINT_16_(impl) \
  UINT_16_16_(impl) \
  UINT_16_16_16_16_(impl) \
\
  UINT_32_(impl) \
  UINT_32_32_(impl) \
  UINT_32_32_32_32_(impl) \
\
  SFLOAT_16_(impl) \
  SFLOAT_16_16_(impl) \
  SFLOAT_16_16_16_16_(impl) \
\
  SFLOAT_32_(impl) \
  SFLOAT_32_32_(impl) \
  SFLOAT_32_32_32_32_(impl) \
\
  UNORM_10_10_10_2_(impl) \
  UINT_10_10_10_2_(impl) \
\
  UFLOAT_11_11_10_(impl) \
\
  UNORM_16_DEPTH_(impl) \
  SFLOAT_32_DEPTH_(impl) \
  SFLOAT_32_DEPTH_UINT_8_(impl) \
\
  SRGBA_8_8_8_8_(impl)
 
  GPU_TEXTURE_TARGET_FORMAT_EXPAND(DECLARE)
 
#undef DECLARE
};
 
inline constexpr TextureFormat to_texture_format(TextureTargetFormat format)
{
  return TextureFormat(int(format));
}

enum class TextureWriteFormat : uint8_t {
  Invalid = 0,
 
#define DECLARE(a, b, c, blender_enum, d, e, f, g, h) \
  blender_enum = int(TextureFormat::blender_enum),
 
#define GPU_TEXTURE_WRITE_FORMAT_EXPAND(impl) \
  UNORM_8_(impl) \
  UNORM_8_8_(impl) \
  UNORM_8_8_8_8_(impl) \
\
  UNORM_16_(impl) \
  UNORM_16_16_(impl) \
  UNORM_16_16_16_16_(impl) \
\
  SINT_8_(impl) \
  SINT_8_8_(impl) \
  SINT_8_8_8_8_(impl) \
\
  SINT_16_(impl) \
  SINT_16_16_(impl) \
  SINT_16_16_16_16_(impl) \
\
  SINT_32_(impl) \
  SINT_32_32_(impl) \
  SINT_32_32_32_32_(impl) \
\
  UINT_8_(impl) \
  UINT_8_8_(impl) \
  UINT_8_8_8_8_(impl) \
\
  UINT_16_(impl) \
  UINT_16_16_(impl) \
  UINT_16_16_16_16_(impl) \
\
  UINT_32_(impl) \
  UINT_32_32_(impl) \
  UINT_32_32_32_32_(impl) \
\
  SFLOAT_16_(impl) \
  SFLOAT_16_16_(impl) \
  SFLOAT_16_16_16_16_(impl) \
\
  SFLOAT_32_(impl) \
  SFLOAT_32_32_(impl) \
  SFLOAT_32_32_32_32_(impl) \
\
  UNORM_10_10_10_2_(impl) \
  UINT_10_10_10_2_(impl) \
\
  UFLOAT_11_11_10_(impl)
 
  GPU_TEXTURE_WRITE_FORMAT_EXPAND(DECLARE)
 
#undef DECLARE
};
 
inline constexpr TextureFormat to_texture_format(TextureWriteFormat format)
{
  return TextureFormat(int(format));
}

 
}  // namespace blender::gpu
 
/* -------------------------------------------------------------------- */

enum GPUSamplerFiltering {
  GPU_SAMPLER_FILTERING_DEFAULT = 0,
  GPU_SAMPLER_FILTERING_LINEAR = (1 << 0),
  GPU_SAMPLER_FILTERING_MIPMAP = (1 << 1),
  GPU_SAMPLER_FILTERING_ANISOTROPIC = (1 << 2),
};
 
ENUM_OPERATORS(GPUSamplerFiltering, GPU_SAMPLER_FILTERING_ANISOTROPIC)
 

static const int GPU_SAMPLER_FILTERING_TYPES_COUNT = (GPU_SAMPLER_FILTERING_LINEAR |
                                                      GPU_SAMPLER_FILTERING_MIPMAP |
                                                      GPU_SAMPLER_FILTERING_ANISOTROPIC) +
                                                     1;

enum GPUSamplerExtendMode {
  GPU_SAMPLER_EXTEND_MODE_EXTEND = 0,
  GPU_SAMPLER_EXTEND_MODE_REPEAT,
  GPU_SAMPLER_EXTEND_MODE_MIRRORED_REPEAT,
  GPU_SAMPLER_EXTEND_MODE_CLAMP_TO_BORDER,
};
 
#define GPU_SAMPLER_EXTEND_MODES_COUNT (GPU_SAMPLER_EXTEND_MODE_CLAMP_TO_BORDER + 1)

enum GPUSamplerCustomType {
  GPU_SAMPLER_CUSTOM_COMPARE = 0,
  GPU_SAMPLER_CUSTOM_ICON,
};
 
#define GPU_SAMPLER_CUSTOM_TYPES_COUNT (GPU_SAMPLER_CUSTOM_ICON + 1)

enum GPUSamplerStateType {
  GPU_SAMPLER_STATE_TYPE_PARAMETERS = 0,
  GPU_SAMPLER_STATE_TYPE_CUSTOM,
  GPU_SAMPLER_STATE_TYPE_INTERNAL,
};

struct GPUSamplerState {
  GPUSamplerFiltering filtering : 8;
  GPUSamplerExtendMode extend_x : 4;
  GPUSamplerExtendMode extend_yz : 4;
  GPUSamplerCustomType custom_type : 8;
  GPUSamplerStateType type : 8;

  static constexpr GPUSamplerState default_sampler()
  {
    return {GPU_SAMPLER_FILTERING_DEFAULT,
            GPU_SAMPLER_EXTEND_MODE_EXTEND,
            GPU_SAMPLER_EXTEND_MODE_EXTEND,
            GPU_SAMPLER_CUSTOM_COMPARE,
            GPU_SAMPLER_STATE_TYPE_PARAMETERS};
  }

  static constexpr GPUSamplerState internal_sampler()
  {
    return {GPU_SAMPLER_FILTERING_DEFAULT,
            GPU_SAMPLER_EXTEND_MODE_EXTEND,
            GPU_SAMPLER_EXTEND_MODE_EXTEND,
            GPU_SAMPLER_CUSTOM_COMPARE,
            GPU_SAMPLER_STATE_TYPE_INTERNAL};
  }

  static constexpr GPUSamplerState icon_sampler()
  {
    return {GPU_SAMPLER_FILTERING_DEFAULT,
            GPU_SAMPLER_EXTEND_MODE_EXTEND,
            GPU_SAMPLER_EXTEND_MODE_EXTEND,
            GPU_SAMPLER_CUSTOM_ICON,
            GPU_SAMPLER_STATE_TYPE_CUSTOM};
  }

  static constexpr GPUSamplerState compare_sampler()
  {
    return {GPU_SAMPLER_FILTERING_DEFAULT,
            GPU_SAMPLER_EXTEND_MODE_EXTEND,
            GPU_SAMPLER_EXTEND_MODE_EXTEND,
            GPU_SAMPLER_CUSTOM_COMPARE,
            GPU_SAMPLER_STATE_TYPE_CUSTOM};
  }

  void enable_filtering_flag(GPUSamplerFiltering filtering_flags)
  {
    this->filtering = this->filtering | filtering_flags;
  }

  void disable_filtering_flag(GPUSamplerFiltering filtering_flags)
  {
    this->filtering = this->filtering & ~filtering_flags;
  }

  void set_filtering_flag_from_test(GPUSamplerFiltering filtering_flags, bool test)
  {
    if (test) {
      this->enable_filtering_flag(filtering_flags);
    }
    else {
      this->disable_filtering_flag(filtering_flags);
    }
  }
 
  std::string to_string() const
  {
    if (this->type == GPU_SAMPLER_STATE_TYPE_INTERNAL) {
      return "internal";
    }
 
    if (this->type == GPU_SAMPLER_STATE_TYPE_CUSTOM) {
      switch (this->custom_type) {
        case GPU_SAMPLER_CUSTOM_COMPARE:
          return "compare";
          break;
        case GPU_SAMPLER_CUSTOM_ICON:
          return "icon";
          break;
        default:
          BLI_assert_unreachable();
          return "";
      }
    }
 
    /* The sampler state is of type PARAMETERS, so serialize the parameters. */
    BLI_assert(this->type == GPU_SAMPLER_STATE_TYPE_PARAMETERS);
    std::string serialized_parameters;
 
    if (this->filtering & GPU_SAMPLER_FILTERING_LINEAR) {
      serialized_parameters += "linear-filter_";
    }
 
    if (this->filtering & GPU_SAMPLER_FILTERING_MIPMAP) {
      serialized_parameters += "mipmap_";
    }
 
    if (this->filtering & GPU_SAMPLER_FILTERING_ANISOTROPIC) {
      serialized_parameters += "anisotropic_";
    }
 
    switch (this->extend_x) {
      case GPU_SAMPLER_EXTEND_MODE_EXTEND:
        serialized_parameters += "extend-x_";
        break;
      case GPU_SAMPLER_EXTEND_MODE_REPEAT:
        serialized_parameters += "repeat-x_";
        break;
      case GPU_SAMPLER_EXTEND_MODE_MIRRORED_REPEAT:
        serialized_parameters += "mirrored-repeat-x_";
        break;
      case GPU_SAMPLER_EXTEND_MODE_CLAMP_TO_BORDER:
        serialized_parameters += "clamp-to-border-x_";
        break;
      default:
        BLI_assert_unreachable();
    }
 
    switch (this->extend_yz) {
      case GPU_SAMPLER_EXTEND_MODE_EXTEND:
        serialized_parameters += "extend-y_";
        break;
      case GPU_SAMPLER_EXTEND_MODE_REPEAT:
        serialized_parameters += "repeat-y_";
        break;
      case GPU_SAMPLER_EXTEND_MODE_MIRRORED_REPEAT:
        serialized_parameters += "mirrored-repeat-y_";
        break;
      case GPU_SAMPLER_EXTEND_MODE_CLAMP_TO_BORDER:
        serialized_parameters += "clamp-to-border-y_";
        break;
      default:
        BLI_assert_unreachable();
    }
 
    switch (this->extend_yz) {
      case GPU_SAMPLER_EXTEND_MODE_EXTEND:
        serialized_parameters += "extend-z";
        break;
      case GPU_SAMPLER_EXTEND_MODE_REPEAT:
        serialized_parameters += "repeat-z";
        break;
      case GPU_SAMPLER_EXTEND_MODE_MIRRORED_REPEAT:
        serialized_parameters += "mirrored-repeat-z";
        break;
      case GPU_SAMPLER_EXTEND_MODE_CLAMP_TO_BORDER:
        serialized_parameters += "clamp-to-border-z";
        break;
      default:
        BLI_assert_unreachable();
    }
 
    return serialized_parameters;
  }
 
  uint32_t as_uint() const
  {
    uint32_t value = filtering;
    value = (value << 4) | extend_x;
    value = (value << 4) | extend_yz;
    value = (value << 8) | custom_type;
    value = (value << 8) | type;
    return value;
  }
 
  bool operator==(GPUSamplerState const &rhs) const
  {
    return this->filtering == rhs.filtering && this->extend_x == rhs.extend_x &&
           this->extend_yz == rhs.extend_yz && this->custom_type == rhs.custom_type &&
           this->type == rhs.type;
  }
};

 
/* -------------------------------------------------------------------- */

/* TODO(fclem): Replace by gpu::DataFormat. */
enum eGPUDataFormat {
  GPU_DATA_FLOAT,
  GPU_DATA_HALF_FLOAT,
  GPU_DATA_INT,
  GPU_DATA_UINT,
  GPU_DATA_UBYTE,
  /* GPU_DATA_UINT_24_8_DEPRECATED is deprecated since Blender 5.0. It is still here as python
   * add-ons can still use it. */
  GPU_DATA_UINT_24_8_DEPRECATED,
  GPU_DATA_10_11_11_REV,
  GPU_DATA_2_10_10_10_REV,
};

enum eGPUTextureUsage {
  /* Whether texture is sampled or read during a shader. */
  GPU_TEXTURE_USAGE_SHADER_READ = (1 << 0),
  /* Whether the texture is written to by a shader using imageStore. */
  GPU_TEXTURE_USAGE_SHADER_WRITE = (1 << 1),
  /* Whether a texture is used as an attachment in a frame-buffer. */
  GPU_TEXTURE_USAGE_ATTACHMENT = (1 << 2),
  /* Whether a texture is used to create a texture view utilizing a different texture format to the
   * source textures format. This includes the use of stencil views. */
  GPU_TEXTURE_USAGE_FORMAT_VIEW = (1 << 3),
  /* Whether the texture needs to be read from by the CPU. */
  GPU_TEXTURE_USAGE_HOST_READ = (1 << 4),
  /* When used, the texture will not have any backing storage and can solely exist as a virtual
   * frame-buffer attachment. */
  GPU_TEXTURE_USAGE_MEMORYLESS = (1 << 5),
  /* Whether a texture can support atomic operations. */
  GPU_TEXTURE_USAGE_ATOMIC = (1 << 6),
  /* Whether a texture can be exported to other instances/processes. */
  GPU_TEXTURE_USAGE_MEMORY_EXPORT = (1 << 7),
  /* Create a texture whose usage cannot be defined prematurely.
   * This is unoptimized and should not be used. */
  GPU_TEXTURE_USAGE_GENERAL = (0xFF & (~(GPU_TEXTURE_USAGE_MEMORYLESS | GPU_TEXTURE_USAGE_ATOMIC |
                                         GPU_TEXTURE_USAGE_MEMORY_EXPORT))),
};
 
ENUM_OPERATORS(eGPUTextureUsage, GPU_TEXTURE_USAGE_GENERAL);

 
/* -------------------------------------------------------------------- */
 
namespace blender::gpu {
class Texture;
}  // namespace blender::gpu

blender::gpu::Texture *GPU_texture_create_1d(const char *name,
                                             int width,
                                             int mip_len,
                                             blender::gpu::TextureFormat format,
                                             eGPUTextureUsage usage,
                                             const float *data);
blender::gpu::Texture *GPU_texture_create_1d_array(const char *name,
                                                   int width,
                                                   int layer_len,
                                                   int mip_len,
                                                   blender::gpu::TextureFormat format,
                                                   eGPUTextureUsage usage,
                                                   const float *data);
blender::gpu::Texture *GPU_texture_create_2d(const char *name,
                                             int width,
                                             int height,
                                             int mip_len,
                                             blender::gpu::TextureFormat format,
                                             eGPUTextureUsage usage,
                                             const float *data);
blender::gpu::Texture *GPU_texture_create_2d_array(const char *name,
                                                   int width,
                                                   int height,
                                                   int layer_len,
                                                   int mip_len,
                                                   blender::gpu::TextureFormat format,
                                                   eGPUTextureUsage usage,
                                                   const float *data);
blender::gpu::Texture *GPU_texture_create_3d(const char *name,
                                             int width,
                                             int height,
                                             int depth,
                                             int mip_len,
                                             blender::gpu::TextureFormat format,
                                             eGPUTextureUsage usage,
                                             const void *data);
blender::gpu::Texture *GPU_texture_create_cube(const char *name,
                                               int width,
                                               int mip_len,
                                               blender::gpu::TextureFormat format,
                                               eGPUTextureUsage usage,
                                               const float *data);
blender::gpu::Texture *GPU_texture_create_cube_array(const char *name,
                                                     int width,
                                                     int layer_len,
                                                     int mip_len,
                                                     blender::gpu::TextureFormat format,
                                                     eGPUTextureUsage usage,
                                                     const float *data);
blender::gpu::Texture *GPU_texture_create_compressed_2d(const char *name,
                                                        int width,
                                                        int height,
                                                        int mip_len,
                                                        blender::gpu::TextureFormat format,
                                                        eGPUTextureUsage usage,
                                                        const void *data);

blender::gpu::Texture *GPU_texture_create_from_vertbuf(const char *name,
                                                       blender::gpu::VertBuf *vertex_buf);

blender::gpu::Texture *GPU_texture_create_error(int dimension, bool array);

 
/* -------------------------------------------------------------------- */

void GPU_texture_ref(blender::gpu::Texture *texture);

void GPU_texture_free(blender::gpu::Texture *texture);
 
#define GPU_TEXTURE_FREE_SAFE(texture) \
  do { \
    if (texture != nullptr) { \
      GPU_texture_free(texture); \
      texture = nullptr; \
    } \
  } while (0)

 
/* -------------------------------------------------------------------- */

blender::gpu::Texture *GPU_texture_create_view(const char *name,
                                               blender::gpu::Texture *source_texture,
                                               blender::gpu::TextureFormat view_format,
                                               int mip_start,
                                               int mip_len,
                                               int layer_start,
                                               int layer_len,
                                               bool cube_as_array,
                                               bool use_stencil);

 
/* -------------------------------------------------------------------- */

void GPU_unpack_row_length_set(uint len);

void GPU_texture_update(blender::gpu::Texture *texture,
                        eGPUDataFormat data_format,
                        const void *data);

void GPU_texture_update_sub(blender::gpu::Texture *texture,
                            eGPUDataFormat data_format,
                            const void *pixels,
                            int offset_x,
                            int offset_y,
                            int offset_z,
                            int width,
                            int height,
                            int depth);

void GPU_texture_update_mipmap(blender::gpu::Texture *texture,
                               int mip_level,
                               eGPUDataFormat data_format,
                               const void *pixels);

void GPU_texture_clear(blender::gpu::Texture *texture,
                       eGPUDataFormat data_format,
                       const void *data);

void GPU_texture_copy(blender::gpu::Texture *dst, blender::gpu::Texture *src);

void GPU_texture_update_mipmap_chain(blender::gpu::Texture *texture);

void *GPU_texture_read(blender::gpu::Texture *texture, eGPUDataFormat data_format, int mip_level);

 
/* -------------------------------------------------------------------- */

void GPU_texture_bind(blender::gpu::Texture *texture, int unit);
void GPU_texture_bind_ex(blender::gpu::Texture *texture, GPUSamplerState state, int unit);
void GPU_texture_unbind(blender::gpu::Texture *texture);
void GPU_texture_unbind_all();

void GPU_texture_image_bind(blender::gpu::Texture *texture, int unit);
void GPU_texture_image_unbind(blender::gpu::Texture *texture);
void GPU_texture_image_unbind_all();

 
/* -------------------------------------------------------------------- */

void GPU_texture_compare_mode(blender::gpu::Texture *texture, bool use_compare);

void GPU_texture_filter_mode(blender::gpu::Texture *texture, bool use_filter);

void GPU_texture_mipmap_mode(blender::gpu::Texture *texture, bool use_mipmap, bool use_filter);

void GPU_texture_anisotropic_filter(blender::gpu::Texture *texture, bool use_aniso);

void GPU_texture_extend_mode_x(blender::gpu::Texture *texture, GPUSamplerExtendMode extend_mode);

void GPU_texture_extend_mode_y(blender::gpu::Texture *texture, GPUSamplerExtendMode extend_mode);

void GPU_texture_extend_mode(blender::gpu::Texture *texture, GPUSamplerExtendMode extend_mode);

void GPU_texture_swizzle_set(blender::gpu::Texture *texture, const char swizzle[4]);

 
/* -------------------------------------------------------------------- */

int GPU_texture_dimensions(const blender::gpu::Texture *texture);

int GPU_texture_width(const blender::gpu::Texture *texture);

int GPU_texture_height(const blender::gpu::Texture *texture);

int GPU_texture_depth(const blender::gpu::Texture *texture);

int GPU_texture_layer_count(const blender::gpu::Texture *texture);

int GPU_texture_mip_count(const blender::gpu::Texture *texture);

blender::gpu::TextureFormat GPU_texture_format(const blender::gpu::Texture *texture);

eGPUTextureUsage GPU_texture_usage(const blender::gpu::Texture *texture);

bool GPU_texture_is_array(const blender::gpu::Texture *texture);

bool GPU_texture_is_cube(const blender::gpu::Texture *texture);

bool GPU_texture_has_depth_format(const blender::gpu::Texture *texture);

bool GPU_texture_has_stencil_format(const blender::gpu::Texture *texture);

bool GPU_texture_has_integer_format(const blender::gpu::Texture *texture);

bool GPU_texture_has_float_format(const blender::gpu::Texture *texture);

bool GPU_texture_has_normalized_format(const blender::gpu::Texture *texture);

bool GPU_texture_has_signed_format(const blender::gpu::Texture *texture);

void GPU_texture_get_mipmap_size(blender::gpu::Texture *texture, int mip_level, int *r_size);

 
/* -------------------------------------------------------------------- */

int GPU_texture_original_width(const blender::gpu::Texture *texture);
int GPU_texture_original_height(const blender::gpu::Texture *texture);
void GPU_texture_original_size_set(blender::gpu::Texture *texture, int width, int height);

#ifndef GPU_NO_USE_PY_REFERENCES
void **GPU_texture_py_reference_get(blender::gpu::Texture *texture);
void GPU_texture_py_reference_set(blender::gpu::Texture *texture, void **py_ref);
#endif

 
/* -------------------------------------------------------------------- */

size_t GPU_texture_component_len(blender::gpu::TextureFormat format);

size_t GPU_texture_dataformat_size(eGPUDataFormat data_format);

const char *GPU_texture_format_name(blender::gpu::TextureFormat format);

unsigned int GPU_texture_memory_usage_get();

void GPU_samplers_update();

 
/* -------------------------------------------------------------------- */

struct GPUPixelBuffer;

GPUPixelBuffer *GPU_pixel_buffer_create(size_t byte_size);

void GPU_pixel_buffer_free(GPUPixelBuffer *pixel_buf);

void *GPU_pixel_buffer_map(GPUPixelBuffer *pixel_buf);

void GPU_pixel_buffer_unmap(GPUPixelBuffer *pixel_buf);

size_t GPU_pixel_buffer_size(GPUPixelBuffer *pixel_buf);

struct GPUPixelBufferNativeHandle {
  int64_t handle = 0;
  size_t size = 0;
};
 
GPUPixelBufferNativeHandle GPU_pixel_buffer_get_native_handle(GPUPixelBuffer *pixel_buf);

void GPU_texture_update_sub_from_pixel_buffer(blender::gpu::Texture *texture,
                                              eGPUDataFormat data_format,
                                              GPUPixelBuffer *pixel_buf,
                                              int offset_x,
                                              int offset_y,
                                              int offset_z,
                                              int width,
                                              int height,
                                              int depth);