#![allow(
clippy::too_many_arguments,
clippy::let_and_return,
clippy::from_over_into
)]
use super::{Bitmap, Context, PixelFormat, Texture, TextureLoader};
use std::fmt;
// @short_description: Functions for creating and manipulating rectangle
// textures for use with non-normalized coordinates.
//
// These functions allow low-level "rectangle" textures to be allocated.
// These textures are never constrained to power-of-two sizes but they
// also don't support having a mipmap and can only be wrapped with
// %PIPELINE_WRAP_MODE_CLAMP_TO_EDGE.
//
// The most notable difference between rectangle textures and 2D
// textures is that rectangle textures are sampled using un-normalized
// texture coordinates, so instead of using coordinates (0,0) and
// (1,1) to map to the top-left and bottom right corners of the
// texture you would instead use (0,0) and (width,height).
//
// The use of non-normalized coordinates can be particularly
// convenient when writing glsl shaders that use a texture as a lookup
// table since you don't need to upload separate uniforms to map
// normalized coordinates to texels.
//
// If you want to sample from a rectangle texture from GLSL you should
// use the sampler2DRect sampler type.
//
// Applications wanting to use #TextureRectangle should first check
// for the %FEATURE_ID_TEXTURE_RECTANGLE feature using
// has_feature().
// @extends Object, @implements Texture;
pub struct TextureRectangle {
// Texture _parent;
// The internal format of the texture represented as a
// PixelFormat */
// PixelFormat internal_format;
// TODO: factor out these OpenGL specific members into some form
// of driver private state. */
// The internal format of the GL texture represented as a GL enum */
// GLenum gl_format;
// The texture object number */
// GLuint gl_texture;
// GLenum gl_legacy_texobj_min_filter;
// GLenum gl_legacy_texobj_mag_filter;
// GLint gl_legacy_texobj_wrap_mode_s;
// GLint gl_legacy_texobj_wrap_mode_t;
// Bool is_foreign;
}
impl TextureRectangle {
// texture_rectangle_new_from_bitmap:
// @bitmap: A #Bitmap
//
// Allocates a new #TextureRectangle texture which will be
// initialized with the pixel data from @bitmap. This texture is a
// low-level texture that the GPU can sample from directly unlike
// high-level textures such as #Texture2DSliced and
// #AtlasTexture.
//
// Unlike for #Texture2D textures, coordinates for
// #TextureRectangle textures should not be normalized. So instead
// of using the coordinate (1, 1) to sample the bottom right corner of
// a rectangle texture you would use (@width, @height) where @width
// and @height are the width and height of the texture.
//
// If you want to sample from a rectangle texture from GLSL you
// should use the sampler2DRect sampler type.
//
// Applications wanting to use #TextureRectangle should
// first check for the %FEATURE_ID_TEXTURE_RECTANGLE feature
// using has_feature().
//
// The storage for the texture is not allocated before this function
// returns. You can call texture_allocate() to explicitly
// allocate the underlying storage or preferably let
// automatically allocate storage lazily when it may know more about
// how the texture is going to be used and can optimize how it is
// allocated.
//
// Return value: (transfer full): A pointer to a new
// #TextureRectangle texture.
// Since: 2.0
// Stability: unstable
pub fn from_bitmap(bitmap: &Bitmap) -> TextureRectangle {
// _RETURN_VAL_IF_FAIL (is_bitmap (bmp), NULL);
// TODO: fix bitmap
let loader = TextureLoader::Bitmap {
bitmap: bitmap.clone(),
can_convert_in_place: false, // TODO add api for this
height: 0,
depth: 0,
};
Self::create_base(
&Context::global(),
bitmap.width(),
bitmap.height(),
bitmap.format(),
&loader,
)
}
// texture_rectangle_new_from_foreign:
// @ctx: A #Context
// @gl_handle: A GL handle for a GL_TEXTURE_RECTANGLE texture object
// @width: Width of the foreign GL texture
// @height: Height of the foreign GL texture
// @format: The format of the texture
//
// Wraps an existing GL_TEXTURE_RECTANGLE texture object as a
// #TextureRectangle. This can be used for integrating with
// software using OpenGL directly.
//
// Unlike for #Texture2D textures, coordinates for
// #TextureRectangle textures should not be normalized. So instead
// of using the coordinate (1, 1) to sample the bottom right corner of
// a rectangle texture you would use (@width, @height) where @width
// and @height are the width and height of the texture.
//
// The results are undefined for passing an invalid @gl_handle
// or if @width or @height don't have the correct texture
// geometry.
//
// If you want to sample from a rectangle texture from GLSL you
// should use the sampler2DRect sampler type.
//
// Applications wanting to use #TextureRectangle should
// first check for the %FEATURE_ID_TEXTURE_RECTANGLE feature
// using has_feature().
//
// The texture is still configurable until it has been allocated so
// for example you can declare whether the texture is premultiplied
// with texture_set_premultiplied().
//
// Return value: (transfer full): A new #TextureRectangle texture
pub fn from_foreign(
context: &Context,
gl_handle: u32,
width: u32,
height: u32,
format: PixelFormat,
) -> TextureRectangle {
// NOTE: width, height and internal format are not queriable in
// GLES, hence such a fn prototype. Also in the case of full
// opengl the user may be creating a texture for a
// texture_from_pixmap object where glTexImage2D may not have been
// called and the texture_from_pixmap spec doesn't clarify that it
// is reliable to query back the size from OpenGL.
// Assert that it is a valid GL texture object
// _RETURN_VAL_IF_FAIL (ctx->glIsTexture (gl_handle), NULL);
// Validate width and height
// _RETURN_VAL_IF_FAIL (width > 0 && height > 0, NULL);
let loader = TextureLoader::GlForeign {
format,
gl_handle,
height,
width,
};
Self::create_base(context, width, height, format, &loader)
}
// texture_rectangle_new_with_size:
// @ctx: A #Context pointer
// @width: The texture width to allocate
// @height: The texture height to allocate
//
// Creates a new #TextureRectangle texture with a given @width,
// and @height. This texture is a low-level texture that the GPU can
// sample from directly unlike high-level textures such as
// #Texture2DSliced and #AtlasTexture.
//
// Unlike for #Texture2D textures, coordinates for
// #TextureRectangle textures should not be normalized. So instead
// of using the coordinate (1, 1) to sample the bottom right corner of
// a rectangle texture you would use (@width, @height) where @width
// and @height are the width and height of the texture.
//
// If you want to sample from a rectangle texture from GLSL you
// should use the sampler2DRect sampler type.
//
// Applications wanting to use #TextureRectangle should
// first check for the %FEATURE_ID_TEXTURE_RECTANGLE feature
// using has_feature().
//
// The storage for the texture is not allocated before this function
// returns. You can call texture_allocate() to explicitly
// allocate the underlying storage or preferably let
// automatically allocate storage lazily when it may know more about
// how the texture is going to be used and can optimize how it is
// allocated.
//
// Returns value: (transfer full): A pointer to a new #TextureRectangle
// object with no storage allocated yet.
//
// Since: 1.10
// Stability: unstable
pub fn with_size(context: &Context, width: u32, height: u32) -> TextureRectangle {
let loader = TextureLoader::Sized {
depth: 0,
width,
height,
};
Self::create_base(context, width, height, PixelFormat::Rgba8888Pre, &loader)
}
fn create_base(
context: &Context,
width: u32,
height: u32,
internal_format: PixelFormat,
loader: &TextureLoader,
) -> Self {
unimplemented!()
}
}
impl fmt::Display for TextureRectangle {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "TextureRectangle")
}
}