Antra::Raylib::Textures

src, colored by tint, blended over dst by its alpha (raylib: ColorAlphaBlend).

Example:

Textures.color_alpha_blend(:white, Textures.fade(:black, 0.5), :white)   # about [127, 127, 127, 255]

color made brighter (factor up to 1) or darker (down to -1) (raylib: ColorBrightness).

Example:

Textures.color_brightness([100, 100, 100], -0.5)   # => [50, 50, 50, 255]

color with more (contrast up to 1) or less (down to -1) contrast (raylib: ColorContrast).

The color for four numbers from 0 to 1, [r, g, b, a] (raylib: ColorFromNormalized).

Example:

Textures.color_from_normalized([1, 0, 0.2, 1])   # => [255, 0, 51, 255]

Returns the color a fraction t (0..1, clamped) of the way from from to to, as [r, g, b, a] (raylib: ColorLerp).

Example:

Textures.color_lerp(:black, :white, 0.5)   # => [127, 127, 127, 255]

A color as four numbers from 0 to 1, [r, g, b, a] (raylib: ColorNormalize) - e.g. for a shader's vec4.

Example:

Textures.color_normalize([255, 0, 51, 255])   # => [1, 0, 0.2, 1]

color multiplied with tint (raylib: ColorTint).

Example:

Textures.color_tint(:white, [255, 0, 0])   # => [255, 0, 0, 255]

Converts a color to its hexadecimal value 0xRRGGBBAA (raylib: ColorToInt).

Example:

Textures.color_to_hex([255, 0, 0, 128])   # => 4278190208 (0xff000080)

Converts a color to hue (0..360 degrees), saturation and value (0..1), [h, s, v] (raylib: ColorToHSV).

Example:

Textures.color_to_hsv([255, 0, 0])   # => [0, 1, 1]

Uploads an image with the six faces of a cube as a cubemap texture, for skyboxes; layout: how the faces are arranged: :auto (default), :line_vertical, :line_horizontal, :cross_three_by_four, :cross_four_by_three (raylib: LoadTextureCubemap). %Ok[texture] or %Err[...].

Example:

val sky = Textures.cubemap_from_image(app, Textures.load_image(app, "skybox.png").!).!

Draws a texture that stretches without distorting its borders - a button or a panel - into dest (raylib: DrawTextureNPatch). The patch names the part source: of the texture and its fixed borders left:, top:, right:, bottom: (all 0); layout: is :nine_patch (default, 3x3), :three_patch_vertical or :three_patch_horizontal. Options: origin:, rotation:, tint:. Returns app.

Example:

val ninepatch = Textures.load_texture(app, "ninepatch_button.png").!
Textures.draw_npatch(app, ninepatch, [source: [0, 0, 64, 64], left: 12, top: 40, right: 12, bottom: 12],
                     [100, 100, 200, 120])

Draws a render texture from render_texture upright at pos [x, y] (OpenGL stores it upside down; raylib: DrawTextureRec with a flipped source); returns app.

Example:

val target = Textures.render_texture(app, 160, 100).!
Core.with_target(app, target) |app| -> Shapes.circle(app, [80, 50], 30, :red)
Textures.draw_target(app, target, [0, 0], [tint: :white])

Draws a texture with its top-left corner at [x, y], colored by tint: (:white = unchanged) (raylib: DrawTextureV); returns app.

Example:

val bunny = Textures.load_texture(app, "raybunny.png").!
Textures.draw_texture(app, bunny, [10, 10])
Textures.draw_texture(app, bunny, [50, 10], [tint: Textures.fade(:white, 0.5)])

Draws a texture at pos [x, y], rotated by rotation: degrees around its top-left corner and scaled by scale:, colored by tint: (raylib: DrawTextureEx); returns app.

Example:

val bunny = Textures.load_texture(app, "raybunny.png").!
Textures.draw_texture_ex(app, bunny, [100, 50], [rotation: 45, scale: 2])

Draws the part source of a texture stretched into the rectangle dest, rotated by rotation: degrees around origin: (relative to dest), colored by tint: (raylib: DrawTexturePro); returns app.

Example:

val bunny = Textures.load_texture(app, "raybunny.png").!
# 64x64 on screen, spinning around its center at [160, 100]
Textures.draw_texture_pro(app, bunny, [0, 0, 32, 32], [160, 100, 64, 64], [origin: [32, 32], rotation: 30])

Draws the part source [x, y, w, h] of a texture at pos - one frame of a sprite sheet; a negative width or height mirrors it (raylib: DrawTextureRec). Returns app.

Example:

val sheet = Textures.load_texture(app, "cubicmap_atlas.png").!
Textures.draw_texture_rec(app, sheet, [0, 0, 128, 128], [10, 10])

Saves an image; the format comes from the file extension (.png, .bmp, .qoi, ...) (raylib: ExportImage): %Ok[path] or %Err[...].

Example:

val img = Textures.image_checked(app, 64, 64, 8, 8, :black, :white)
Textures.export_image(app, img, "checker.png").!

Returns color as [r, g, b, a] with its alpha scaled by alpha (0..1) (raylib: Fade).

Example:

Textures.fade(:red, 0.5)       # => [230, 41, 55, 127]

Converts a hexadecimal 0xRRGGBBAA value to [r, g, b, a] (raylib: GetColor).

Example:

Textures.hex(0xff000080)       # => [255, 0, 0, 128]

Converts hue (0..360 degrees), saturation and value (0..1) to [r, g, b, a] (raylib: ColorFromHSV).

Example:

Textures.hsv(0, 1, 1)          # => [255, 0, 0, 255]

The rectangle [x, y, w, h] around the pixels whose alpha is above threshold (0..1) (raylib: GetImageAlphaBorder).

Paints every pixel whose alpha is at most threshold (0..1) with color (raylib: ImageAlphaClear). Returns the image.

Crops away the border whose alpha is at most threshold (0..1) (raylib: ImageAlphaCrop). Returns the image.

Example:

img = Textures.image_alpha_crop(app, img, 0)

Uses the brightness of mask as the image's alpha channel (raylib: ImageAlphaMask). Returns the image.

Example:

img = Textures.image_alpha_mask(app, img, Textures.load_image(app, "mask.png").!)

Multiplies the color channels by the alpha channel (raylib: ImageAlphaPremultiply). Returns the image.

The pixel data of frame index (0-based, wrapping around) of an animation from load_image_anim, as a ByteString in the image's pixel format - for update_texture (raylib: the frames lie one after another in the image data).

Example:

val anim = Textures.load_image_anim(app, "scarfy_run.gif").!
val texture = Textures.texture_from_image(app, anim.image)
Textures.update_texture(app, texture, Textures.image_anim_frame(app, anim, 3))

Blurs an image by size pixels (raylib: ImageBlurGaussian). Returns the image.

Example:

img = Textures.image_blur(app, img, 4)

Changes the brightness by brightness (-255..255) (raylib: ImageColorBrightness). Returns the image.

Generates cellular (Worley) noise with cells of tile_size pixels (raylib: GenImageCellular).

Example:

val cells = Textures.image_cellular(app, 128, 128, 16)

Returns a new grayscale image from one channel, :r, :g, :b or :a (raylib: ImageFromChannel).

Example:

val alpha = Textures.image_channel(app, img, :a)

Generates a checkerboard image with cx x cy squares in colors c1 and c2 (raylib: GenImageChecked).

Example:

val board = Textures.image_checked(app, 64, 64, 8, 8, :black, :white)

Draws a filled circle into an image (raylib: ImageDrawCircleV). Returns the image.

Example:

val dot = Textures.image_circle(app, Textures.image_color(app, 32, 32, :blank), [16, 16], 12, :red)

Draws a circle fading from inner to outer into an image (raylib: ImageDrawCircleGradient). Returns the image.

Draws a circle outline into an image (raylib: ImageDrawCircleLinesV). Returns the image.

Fills an image with color (raylib: ImageClearBackground). Returns the image.

Generates a width x height image filled with one color (raylib: GenImageColor).

Example:

val red = Textures.image_color(app, 16, 16, :red)

Returns the image's pixels as %RaylibCapture{width:, height:, rgba:} with RGBA bytes (width * height * 4, top row first) (raylib: LoadImageColors); Core.pixel reads single pixels from it.

Example:

val px = Textures.image_colors(app, Textures.image_color(app, 2, 2, :red))
Core.pixel(px, [1, 1])         # => [230, 41, 55, 255]

Changes the contrast by contrast (-100..100) (raylib: ImageColorContrast). Returns the image.

Applies a square convolution kernel, a flat list of n x n numbers (raylib: ImageKernelConvolution). Returns the image.

Example:

val sharpen = [0, -1, 0, -1, 5, -1, 0, -1, 0]
img = Textures.image_convolve(app, img, sharpen)

Returns an independent copy of an image (raylib: ImageCopy).

Example:

val backup = Textures.image_copy(app, img)

Returns a new image from the part r [x, y, w, h] of image (raylib: ImageFromImage); the original stays as it is.

Example:

val atlas = Textures.load_image(app, "cubicmap_atlas.png").!
val tile = Textures.image_crop(app, atlas, [0, 0, 128, 128])
tile.width                     # => 128

Reduces an image to [r, g, b, a] bits per channel with Floyd-Steinberg dithering (raylib: ImageDither). Returns the image.

Example:

img = Textures.image_dither(app, img, [4, 4, 4, 4])

Draws the image source_image into image at pos - all of it, or the part source: [x, y, w, h] - scaled by scale:, rotated by rotation: degrees, colored by tint: (raylib: ImageDrawImageEx, ImageDrawImagePro). Returns the image.

Example:

canvas = Textures.image_draw(app, canvas, logo, [10, 10], [scale: 0.5])

Draws the part source of source_image stretched into the rectangle dest of image, rotated by rotation: degrees around origin: (raylib: ImageDrawImagePro). Returns the image.

Writes text into an image at pos, size pixels high (raylib: ImageDrawText). Options: font: from Text.load_font (raylib's default font), spacing: between the letters (default font: size / 10, others: 1), rotation: in degrees (0) around origin: ([0, 0], relative to pos) - drawn as a text image (raylib: ImageTextEx + ImageDrawImagePro; raylib 6.2's ImageDrawTextPro draws nothing). Returns the image.

Example:

img = Textures.image_draw_text(app, img, "42", [4, 4], 20, :black)
img = Textures.image_draw_text(app, img, "tilted", [30, 30], 20, :maroon, [rotation: 30])

Mirrors an image, :vertical (upside down - e.g. one read back from a render texture, which OpenGL stores bottom row first) or :horizontal (raylib: ImageFlipVertical, ImageFlipHorizontal). Returns the image.

Example:

val canvas = Textures.render_texture(app, 320, 200).!
val image = Textures.image_flip(app, Textures.image_from_texture(app, canvas.texture), :vertical)

Converts an image to another pixel format: :grayscale, :gray_alpha, :r5g6b5, :r8g8b8, :r5g5b5a1, :r4g4b4a4, :r8g8b8a8, :r32, :r32g32b32, :r32g32b32a32, :r16, :r16g16b16, :r16g16b16a16 (raylib: ImageFormat). Returns the image.

Example:

img = Textures.image_format(app, img, :grayscale)

Decodes an image from bytes in memory, a ByteString holding a file of type file_type (".png", ".qoi", ...) (raylib: LoadImageFromMemory): %Ok[image] or %Err[...].

Example:

import Antra::Bytes

val img = Textures.image_from_bytes(app, Bytes.from_file("icon.png").!, ".png").!

Renders text into a new image just big enough for it, with raylib's default font (raylib: ImageText) or a font: from Text.load_font with spacing: (1) between the letters (raylib: ImageTextEx).

Example:

val label = Textures.image_from_text(app, "Hello", 20, :maroon)

Reads a texture back from the GPU into a new image (raylib: LoadImageFromTexture).

Example:

val tex = Textures.texture_from_image(app, Textures.image_color(app, 8, 4, :gold))
val img = Textures.image_from_texture(app, tex)
[img.width, img.height]        # => [8, 4]

Generates a linear gradient image from from to to; angle: in degrees (0 = top to bottom) (raylib: GenImageGradientLinear).

Example:

val sky = Textures.image_gradient(app, 320, 200, :skyblue, :white)
val side = Textures.image_gradient(app, 320, 200, :red, :blue, [angle: 90])

Generates a radial gradient image; density (0..1) is how far inner reaches before it fades to outer (raylib: GenImageGradientRadial).

Example:

val glow = Textures.image_gradient_radial(app, 64, 64, 0, :white, :black)

Generates a square gradient image; density (0..1) is how far inner reaches (raylib: GenImageGradientSquare).

Example:

val frame = Textures.image_gradient_square(app, 64, 64, 0.5, :gold, :brown)

Turns the colors into shades of gray (raylib: ImageColorGrayscale). Returns the image.

Inverts the colors (raylib: ImageColorInvert). Returns the image.

Draws a line into an image, one pixel wide (raylib: ImageDrawLineV) or thick: pixels (raylib: ImageDrawLineEx). Returns the image.

Example:

img = Textures.image_line(app, img, [0, 0], [31, 31], :red, [thick: 2])

Draws one-pixel lines through a list of points into an image (raylib: ImageDrawLineStrip). Returns the image.

Computes all mipmap levels of an image (raylib: ImageMipmaps). Returns the image.

The different colors of an image, at most max of them, as [r, g, b, a] (raylib: LoadImagePalette).

Example:

Textures.image_palette(app, Textures.image_color(app, 4, 4, :red), 8)   # => [[230, 41, 55, 255]]

Generates Perlin noise starting at [offset_x, offset_y], zoomed by scale (raylib: GenImagePerlinNoise).

Example:

val clouds = Textures.image_perlin_noise(app, 128, 128, [0, 0], 4)

The color [r, g, b, a] of the pixel at [x, y] (raylib: GetImageColor).

Example:

Textures.image_pixel(app, Textures.image_color(app, 4, 4, :red), [1, 2])   # => [230, 41, 55, 255]

Sets one pixel [x, y] of an image (raylib: ImageDrawPixelV). Returns the image.

Draws a filled rectangle [x, y, w, h] into an image (raylib: ImageDrawRectangleRec). Returns the image.

Example:

my img = Textures.image_color(app, 32, 32, :white)
img = Textures.image_rect(app, img, [8, 8, 16, 16], :blue)

Draws a rectangle filled with a gradient into an image, like Shapes.rect_gradient: from from to to (direction: :vertical or :horizontal) or one color per corner, [top_left, bottom_left, bottom_right, top_right] (raylib: ImageDrawRectangleGradientEx). Returns the image.

Draws a rectangle outline into an image, thick: (1) pixels wide (raylib: ImageDrawRectangleLinesEx). Returns the image.

Draws a rectangle rotated by rotation degrees around origin into an image (raylib: ImageDrawRectanglePro). Returns the image.

Replaces every pixel of color with replacement (raylib: ImageColorReplace). Returns the image.

Example:

img = Textures.image_replace_color(app, img, :white, :blank)

Scales an image to width x height: smooth with filter: :bicubic (default, raylib: ImageResize) or blocky with :nearest, for pixel art (raylib: ImageResizeNN). Returns the image.

Example:

img = Textures.image_resize(app, img, 64, 64, [filter: :nearest])

Changes an image's canvas to width x height, keeping the pixels at offset: ([0, 0]) and filling the rest with fill: (:blank) (raylib: ImageResizeCanvas). Returns the image.

Example:

img = Textures.image_resize_canvas(app, img, 64, 64, [offset: [16, 16], fill: :white])

Rotates an image by degrees (positive = clockwise); the image grows to hold the rotated corners and fills the rest with zero bytes (transparent, or black in an image without alpha) (raylib: ImageRotate). Returns the image.

Example:

my logo = Textures.load_image(app, "raylib_logo.png").!
logo = Textures.image_rotate(app, logo, 90)

Multiplies every pixel with color (raylib: ImageColorTint). Returns the image.

Encodes an image as a file of type file_type (".png", ".qoi", ...) in memory (raylib: ExportImageToMemory): %Ok[bytes] with a ByteString, or %Err[...].

Example:

val png = Textures.image_to_bytes(app, img, ".png").!

Grows an image to the next power-of-two size, filling the new pixels with fill (raylib: ImageToPOT). Returns the image.

Draws a filled triangle into an image; corners in counter-clockwise order (raylib: ImageDrawTriangle). Returns the image.

Draws a triangle fan (the first point is the center) into an image (raylib: ImageDrawTriangleFan). Returns the image.

Draws a triangle whose colors blend from corner to corner into an image (raylib: ImageDrawTriangleGradient). Returns the image.

Draws a triangle outline into an image (raylib: ImageDrawTriangleLines). Returns the image.

Draws a triangle strip into an image (raylib: ImageDrawTriangleStrip). Returns the image.

Generates black and white noise; factor (0..1) is the share of white pixels (raylib: GenImageWhiteNoise).

Example:

val noise = Textures.image_white_noise(app, 64, 64, 0.5)

Loads an image file (PNG, JPG, BMP, TGA, GIF, QOI, ...) into CPU memory (raylib: LoadImage): %Ok[image] or %Err[...] when it cannot be loaded. Free it with unload_image.

Example:

val img = Textures.load_image(app, "raybunny.png").!
[img.width, img.height]        # => [32, 32]

Loads all frames of an animated GIF (raylib: LoadImageAnim): %Ok[%{image:, frames:}] or %Err[...]. The image has the size of one frame; its pixel data holds all frames one after another (RGBA, each width * height * 4 bytes). Show frame i by updating a texture with the pixels at image.data plus i * width * height * 4.

Example:

val %{image:, frames:} = Textures.load_image_anim(app, "scarfy_run.gif").!

Loads raw pixel data from a file: width x height pixels in format (:r8g8b8a8, :grayscale, ... - see image_format), after header: (0) bytes (raylib: LoadImageRaw). %Ok[image] or %Err[...].

Example:

val img = Textures.load_image_raw(app, "fudesumi.raw", 384, 512, :r8g8b8a8).!

Loads an image file straight into a GPU texture (raylib: LoadTexture): %Ok[texture] or %Err[...]. Free it with unload_texture.

Example:

val bunny = Textures.load_texture(app, "raybunny.png").!
Textures.draw_texture(app, bunny, [10, 10])

Creates an off-screen drawing target of width x height pixels, with format: (see image_format) for its color buffer (raylib: LoadRenderTexture, LoadRenderTextureEx): %Ok[target] or %Err[...]. Draw into it with Core.with_target, show it with draw_target.

Example:

val target = Textures.render_texture(app, 160, 100).!
Core.with_target(app, target) |app| -> Core.clear(app, :skyblue)
Textures.draw_target(app, target, [80, 50])

Sets how a texture is scaled: :point (sharp pixels, for pixel art), :bilinear or :trilinear (raylib: SetTextureFilter); returns app.

Example:

val bunny = Textures.load_texture(app, "raybunny.png").!
Textures.texture_filter(app, bunny, :bilinear)

Uploads an image to the GPU as a texture (raylib: LoadTextureFromImage); the image can be unloaded afterwards.

Example:

val img = Textures.image_checked(app, 64, 64, 8, 8, :black, :white)
val tex = Textures.texture_from_image(app, img)
Textures.unload_image(app, img)

Generates the mipmaps of a texture on the GPU, for smooth scaling down with :trilinear (raylib: GenTextureMipmaps). Returns the updated texture.

Example:

tex = Textures.texture_mipmaps(app, tex)
Textures.texture_filter(app, tex, :trilinear)

Sets what a texture shows outside its 0..1 coordinates: :repeat, :clamp, :mirror_repeat or :mirror_clamp (raylib: SetTextureWrap); returns app.

Example:

val tiles = Textures.load_texture(app, "texel_checker.png").!
Textures.texture_wrap(app, tiles, :repeat)

Frees an image (raylib: UnloadImage); returns app.

Frees a render texture (raylib: UnloadRenderTexture); returns app.

Frees a texture (raylib: UnloadTexture); returns app.

Replaces the pixels of a texture with pixels, a ByteString in the texture's format - RGBA bytes (width * height * 4, top row first) for a texture made from a generated image (raylib: UpdateTexture); with rect: [x, y, w, h] only that part (raylib: UpdateTextureRec). Returns app. For pictures computed pixel by pixel every frame.

Example:

import Antra::Bytes
val tex = Textures.texture_from_image(app, Textures.image_color(app, 2, 1, :black))
Textures.update_texture(app, tex, Bytes.from_list([255, 0, 0, 255, 0, 0, 255, 255]))