class `SF::Texture`
inherits `Reference` #

Image living on the graphics card that can be used for drawing

SF::Texture stores pixels that can be drawn, with a sprite for example. A texture lives in the graphics card memory, therefore it is very fast to draw a texture to a render target, or copy a render target to a texture (the graphics card can access both directly).

Being stored in the graphics card memory has some drawbacks. A texture cannot be manipulated as freely as a SF::Image, you need to prepare the pixels first and then upload them to the texture in a single operation (see Texture.update).

SF::Texture makes it easy to convert from/to SF::Image, but keep in mind that these calls require transfers between the graphics card and the central memory, therefore they are slow operations.

A texture can be loaded from an image, but also directly from a file/memory/stream. The necessary shortcuts are defined so that you don't need an image first for the most common cases. However, if you want to perform some modifications on the pixels before creating the final texture, you can load your file to a SF::Image, do whatever you need with the pixels, and then call Texture.load_from_image.

Since they live in the graphics card memory, the pixels of a texture cannot be accessed without a slow copy first. And they cannot be accessed individually. Therefore, if you need to read the texture's pixels (like for pixel-perfect collisions), it is recommended to store the collision information separately, for example in an array of booleans.

Like SF::Image, SF::Texture can handle a unique internal representation of pixels, which is RGBA 32 bits. This means that a pixel must be composed of 8 bits red, green, blue and alpha channels -- just like a SF::Color.

Usage example:

# This example shows the most common use of SF::Texture:
# drawing a sprite

# Load a texture from a file
texture = SF::Texture.from_file("texture.png")

# Assign it to a sprite
sprite = SF::Sprite.new(texture)

# Draw the textured sprite
window.draw sprite

# This example shows another common use of SF::Texture:
# streaming real-time data, like video frames

# Create an empty texture
texture = SF::Texture.new(640, 480)

# Create a sprite that will display the texture
sprite = SF::Sprite.new(texture)

# The main loop
loop do
  # [...]

  # update the texture
  pixels = (...).to_unsafe # get a fresh chunk of pixels (the next frame of a movie, for example)
  texture.update(pixels)

  # draw it
  window.draw sprite

  # [...]
end

Like SF::Shader that can be used as a raw OpenGL shader, SF::Texture can also be used directly as a raw texture for custom OpenGL geometry.

SF::Texture.bind(texture)
# [... render OpenGL geometry ...]
SF::Texture.bind(nil)

Included modules

SF::GlResource

Constructors#

`.from_file(*args, **kwargs) : self`#

Shorthand for texture = Texture.new; texture.load_from_file(...); texture

Raises InitError on failure

class SF::Texture inherits Reference #

Included modules

Constructors#

.from_file(*args, **kwargs) : self#

.from_image(*args, **kwargs) : self#

.from_memory(*args, **kwargs) : self#

.from_stream(*args, **kwargs) : self#

.new#

.new(*args, **kwargs) : self#

Class methods#

.bind(texture : Texture | Nil, coordinate_type : Texture::CoordinateType = Normalized)#

.maximum_size : Int32#

Methods#

#copy_to_image : Image#

#create(width : Int, height : Int) : Bool#

#dup : Texture#

#finalize#

#generate_mipmap : Bool#

#load_from_file(filename : String, area : IntRect = IntRect.new()) : Bool#

#load_from_image(image : Image, area : IntRect = IntRect.new()) : Bool#

#load_from_memory(data : Slice, area : IntRect = IntRect.new()) : Bool#

#load_from_stream(stream : InputStream, area : IntRect = IntRect.new()) : Bool#

#native_handle : Int32#

#repeated=(repeated : Bool)#

#repeated? : Bool#

#size : Vector2u#

#smooth=(smooth : Bool)#

#smooth? : Bool#

#srgb=(s_rgb : Bool)#

#srgb? : Bool#

#swap(right : Texture)#

#update(pixels : Pointer(UInt8), width : Int, height : Int, x : Int, y : Int)#

#update(texture : Texture, x : Int, y : Int)#

#update(image : Image, x : Int, y : Int)#

#update(window : Window, x : Int, y : Int)#

#update(pixels : Pointer(UInt8))#

#update(texture : Texture)#

#update(image : Image)#

#update(window : Window)#

class `SF::Texture`
inherits `Reference` #

`.from_file(*args, **kwargs) : self`#

`.from_image(*args, **kwargs) : self`#

`.from_memory(*args, **kwargs) : self`#

`.from_stream(*args, **kwargs) : self`#

`.new`#

`.new(*args, **kwargs) : self`#

`.bind(texture : Texture | Nil, coordinate_type : Texture::CoordinateType = Normalized)`#

`.maximum_size : Int32`#

`#copy_to_image : Image`#

`#create(width : Int, height : Int) : Bool`#

`#dup : Texture`#

`#finalize`#

`#generate_mipmap : Bool`#

`#load_from_file(filename : String, area : IntRect = IntRect.new()) : Bool`#

`#load_from_image(image : Image, area : IntRect = IntRect.new()) : Bool`#

`#load_from_memory(data : Slice, area : IntRect = IntRect.new()) : Bool`#

`#load_from_stream(stream : InputStream, area : IntRect = IntRect.new()) : Bool`#

`#native_handle : Int32`#

`#repeated=(repeated : Bool)`#

`#repeated? : Bool`#

`#size : Vector2u`#

`#smooth=(smooth : Bool)`#

`#smooth? : Bool`#

`#srgb=(s_rgb : Bool)`#

`#srgb? : Bool`#

`#swap(right : Texture)`#

`#update(pixels : Pointer(UInt8), width : Int, height : Int, x : Int, y : Int)`#

`#update(texture : Texture, x : Int, y : Int)`#

`#update(image : Image, x : Int, y : Int)`#

`#update(window : Window, x : Int, y : Int)`#

`#update(pixels : Pointer(UInt8))`#

`#update(texture : Texture)`#

`#update(image : Image)`#

`#update(window : Window)`#