raylib 4.5.0.alpha1

data/lib/raylib/core/structs/audio_stream.rb

@@ -0,0 +1,71 @@
+module Raylib
+  # AudioStream, custom audio stream
+  class AudioStream < FFI::Struct
+    layout(
+      :buffer, :pointer,    # Pointer to internal data used by the audio system,
+      :processor, :pointer, # Pointer to internal data processor, useful for audio effects,
+      :sampleRate, :uint,   # Frequency (samples per second),
+      :sampleSize, :uint,   # Bit depth (bits per sample): 8, 16, 32 (24 not supported),
+      :channels, :uint,     # Number of channels (1-mono, 2-stereo, ...)
+    )
+
+    def self.create(buffer, processor, sample_rate, sample_size, channels)
+      new.tap do |instance|
+        instance[:buffer] = buffer
+        instance[:processor] = processor
+        instance[:sampleRate] = sample_rate
+        instance[:sampleSize] = sample_size
+        instance[:channels] = channels
+      end
+    end
+
+    def to_s
+      "Raylib::AudioStream##{object_id} buffer=#{buffer} processor=#{processor} sample_rate=#{sample_rate} sample_size=#{sample_size} channels=#{channels}"
+    end
+
+    # Pointer to internal data used by the audio system
+    # @return [rAudioBuffer *] buffer
+    def buffer = self[:buffer]
+
+    # Sets Pointer to internal data used by the audio system
+    def buffer=(new_buffer)
+      self[:buffer] = new_buffer
+    end
+
+    # Pointer to internal data processor, useful for audio effects
+    # @return [rAudioProcessor *] processor
+    def processor = self[:processor]
+
+    # Sets Pointer to internal data processor, useful for audio effects
+    def processor=(new_processor)
+      self[:processor] = new_processor
+    end
+
+    # Frequency (samples per second)
+    # @return [Integer] sampleRate
+    def sample_rate = self[:sampleRate]
+
+    # Sets Frequency (samples per second)
+    def sample_rate=(new_sample_rate)
+      self[:sampleRate] = new_sample_rate
+    end
+
+    # Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+    # @return [Integer] sampleSize
+    def sample_size = self[:sampleSize]
+
+    # Sets Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+    def sample_size=(new_sample_size)
+      self[:sampleSize] = new_sample_size
+    end
+
+    # Number of channels (1-mono, 2-stereo, ...)
+    # @return [Integer] channels
+    def channels = self[:channels]
+
+    # Sets Number of channels (1-mono, 2-stereo, ...)
+    def channels=(new_channels)
+      self[:channels] = new_channels
+    end
+  end
+end

data/lib/raylib/core/structs/bone_info.rb

@@ -0,0 +1,38 @@
+module Raylib
+  # Bone, skeletal animation bone
+  class BoneInfo < FFI::Struct
+    layout(
+      :name, [:char, 32], # Bone name,
+      :parent, :int,      # Bone parent
+    )
+
+    def self.create(name, parent)
+      new.tap do |instance|
+        instance[:name] = name
+        instance[:parent] = parent
+      end
+    end
+
+    def to_s
+      "Raylib::BoneInfo##{object_id} name=#{name} parent=#{parent}"
+    end
+
+    # Bone name
+    # @return [char[32]] name
+    def name = self[:name]
+
+    # Sets Bone name
+    def name=(new_name)
+      self[:name] = new_name
+    end
+
+    # Bone parent
+    # @return [Integer] parent
+    def parent = self[:parent]
+
+    # Sets Bone parent
+    def parent=(new_parent)
+      self[:parent] = new_parent
+    end
+  end
+end

data/lib/raylib/core/structs/bounding_box.rb

@@ -0,0 +1,38 @@
+module Raylib
+  # BoundingBox
+  class BoundingBox < FFI::Struct
+    layout(
+      :min, Vector3, # Minimum vertex box-corner,
+      :max, Vector3, # Maximum vertex box-corner
+    )
+
+    def self.create(min, max)
+      new.tap do |instance|
+        instance[:min] = min
+        instance[:max] = max
+      end
+    end
+
+    def to_s
+      "Raylib::BoundingBox##{object_id} min=#{min} max=#{max}"
+    end
+
+    # Minimum vertex box-corner
+    # @return [Vector3] min
+    def min = self[:min]
+
+    # Sets Minimum vertex box-corner
+    def min=(new_min)
+      self[:min] = new_min
+    end
+
+    # Maximum vertex box-corner
+    # @return [Vector3] max
+    def max = self[:max]
+
+    # Sets Maximum vertex box-corner
+    def max=(new_max)
+      self[:max] = new_max
+    end
+  end
+end

data/lib/raylib/core/structs/camera2_d.rb

@@ -0,0 +1,60 @@
+module Raylib
+  # Camera2D, defines position/orientation in 2d space
+  class Camera2D < FFI::Struct
+    layout(
+      :offset, Vector2,  # Camera offset (displacement from target),
+      :target, Vector2,  # Camera target (rotation and zoom origin),
+      :rotation, :float, # Camera rotation in degrees,
+      :zoom, :float,     # Camera zoom (scaling), should be 1.0f by default
+    )
+
+    def self.create(offset, target, rotation, zoom)
+      new.tap do |instance|
+        instance[:offset] = offset
+        instance[:target] = target
+        instance[:rotation] = rotation
+        instance[:zoom] = zoom
+      end
+    end
+
+    def to_s
+      "Raylib::Camera2D##{object_id} offset=#{offset} target=#{target} rotation=#{rotation} zoom=#{zoom}"
+    end
+
+    # Camera offset (displacement from target)
+    # @return [Vector2] offset
+    def offset = self[:offset]
+
+    # Sets Camera offset (displacement from target)
+    def offset=(new_offset)
+      self[:offset] = new_offset
+    end
+
+    # Camera target (rotation and zoom origin)
+    # @return [Vector2] target
+    def target = self[:target]
+
+    # Sets Camera target (rotation and zoom origin)
+    def target=(new_target)
+      self[:target] = new_target
+    end
+
+    # Camera rotation in degrees
+    # @return [Float] rotation
+    def rotation = self[:rotation]
+
+    # Sets Camera rotation in degrees
+    def rotation=(new_rotation)
+      self[:rotation] = new_rotation
+    end
+
+    # Camera zoom (scaling), should be 1.0f by default
+    # @return [Float] zoom
+    def zoom = self[:zoom]
+
+    # Sets Camera zoom (scaling), should be 1.0f by default
+    def zoom=(new_zoom)
+      self[:zoom] = new_zoom
+    end
+  end
+end

data/lib/raylib/core/structs/camera3_d.rb

@@ -0,0 +1,74 @@
+module Raylib
+  # Camera, defines position/orientation in 3d space
+  class Camera3D < FFI::Struct
+    layout(
+      :position, Vector3, # Camera position,
+      :target, Vector3,   # Camera target it looks-at,
+      :up, Vector3,       # Camera up vector (rotation over its axis),
+      :fovy, :float,      # Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic,
+      :projection, :int,  # Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
+    )
+
+    def self.create(position, target, up, fovy, projection)
+      new.tap do |instance|
+        instance[:position] = position
+        instance[:target] = target
+        instance[:up] = up
+        instance[:fovy] = fovy
+        instance[:projection] = projection
+      end
+    end
+
+    def to_s
+      "Raylib::Camera3D##{object_id} position=#{position} target=#{target} up=#{up} fovy=#{fovy} projection=#{projection}"
+    end
+
+    # Camera position
+    # @return [Vector3] position
+    def position = self[:position]
+
+    # Sets Camera position
+    def position=(new_position)
+      self[:position] = new_position
+    end
+
+    # Camera target it looks-at
+    # @return [Vector3] target
+    def target = self[:target]
+
+    # Sets Camera target it looks-at
+    def target=(new_target)
+      self[:target] = new_target
+    end
+
+    # Camera up vector (rotation over its axis)
+    # @return [Vector3] up
+    def up = self[:up]
+
+    # Sets Camera up vector (rotation over its axis)
+    def up=(new_up)
+      self[:up] = new_up
+    end
+
+    # Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic
+    # @return [Float] fovy
+    def fovy = self[:fovy]
+
+    # Sets Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic
+    def fovy=(new_fovy)
+      self[:fovy] = new_fovy
+    end
+
+    # Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
+    # @return [Integer] projection
+    def projection = self[:projection]
+
+    # Sets Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
+    def projection=(new_projection)
+      self[:projection] = new_projection
+    end
+  end
+
+  # Camera type fallback, defaults to Camera3D
+  Camera = Camera3D
+end

data/lib/raylib/core/structs/color.rb

@@ -0,0 +1,60 @@
+module Raylib
+  # Color, 4 components, R8G8B8A8 (32bit)
+  class Color < FFI::Struct
+    layout(
+      :r, :uchar, # Color red value,
+      :g, :uchar, # Color green value,
+      :b, :uchar, # Color blue value,
+      :a, :uchar, # Color alpha value
+    )
+
+    def self.create(r, g, b, a)
+      new.tap do |instance|
+        instance[:r] = r
+        instance[:g] = g
+        instance[:b] = b
+        instance[:a] = a
+      end
+    end
+
+    def to_s
+      "Raylib::Color##{object_id} r=#{r} g=#{g} b=#{b} a=#{a}"
+    end
+
+    # Color red value
+    # @return [unsigned char] r
+    def r = self[:r]
+
+    # Sets Color red value
+    def r=(new_r)
+      self[:r] = new_r
+    end
+
+    # Color green value
+    # @return [unsigned char] g
+    def g = self[:g]
+
+    # Sets Color green value
+    def g=(new_g)
+      self[:g] = new_g
+    end
+
+    # Color blue value
+    # @return [unsigned char] b
+    def b = self[:b]
+
+    # Sets Color blue value
+    def b=(new_b)
+      self[:b] = new_b
+    end
+
+    # Color alpha value
+    # @return [unsigned char] a
+    def a = self[:a]
+
+    # Sets Color alpha value
+    def a=(new_a)
+      self[:a] = new_a
+    end
+  end
+end

data/lib/raylib/core/structs/file_path_list.rb

@@ -0,0 +1,51 @@
+module Raylib
+  # File path list
+  class FilePathList < FFI::Struct
+    layout(
+      :capacity, :uint, # Filepaths max entries,
+      :count, :uint,    # Filepaths entries count,
+      :paths, :pointer, # Filepaths entries
+    )
+
+    def self.create(capacity, count, paths)
+      new.tap do |instance|
+        instance[:capacity] = capacity
+        instance[:count] = count
+        instance[:paths] = paths
+      end
+    end
+
+    def to_s
+      "Raylib::FilePathList##{object_id} capacity=#{capacity} count=#{count} paths=#{paths}"
+    end
+
+    # Filepaths max entries
+    # @return [Integer] capacity
+    def capacity = self[:capacity]
+
+    # Sets Filepaths max entries
+    def capacity=(new_capacity)
+      self[:capacity] = new_capacity
+    end
+
+    # Filepaths entries count
+    # @return [Integer] count
+    def count = self[:count]
+
+    # Sets Filepaths entries count
+    def count=(new_count)
+      self[:count] = new_count
+    end
+
+    # Filepaths entries
+    # @return [Array<String>] paths
+    def paths
+      self[:paths].get_array_of_string(0, count)
+    end
+
+    # Sets Filepaths entries
+    def paths=(new_paths)
+      self[:paths] = new_paths
+    end
+  end
+end

data/lib/raylib/core/structs/font.rb

@@ -0,0 +1,82 @@
+module Raylib
+  # Font, font texture and GlyphInfo array data
+  class Font < FFI::Struct
+    layout(
+      :baseSize, :int,     # Base size (default chars height),
+      :glyphCount, :int,   # Number of glyph characters,
+      :glyphPadding, :int, # Padding around the glyph characters,
+      :texture, Texture2D, # Texture atlas containing the glyphs,
+      :recs, :pointer,     # Rectangles in texture for the glyphs,
+      :glyphs, :pointer,   # Glyphs info data
+    )
+
+    def self.create(base_size, glyph_count, glyph_padding, texture, recs, glyphs)
+      new.tap do |instance|
+        instance[:baseSize] = base_size
+        instance[:glyphCount] = glyph_count
+        instance[:glyphPadding] = glyph_padding
+        instance[:texture] = texture
+        instance[:recs] = recs
+        instance[:glyphs] = glyphs
+      end
+    end
+
+    def to_s
+      "Raylib::Font##{object_id} base_size=#{base_size} glyph_count=#{glyph_count} glyph_padding=#{glyph_padding} texture=#{texture} recs=#{recs} glyphs=#{glyphs}"
+    end
+
+    # Base size (default chars height)
+    # @return [Integer] baseSize
+    def base_size = self[:baseSize]
+
+    # Sets Base size (default chars height)
+    def base_size=(new_base_size)
+      self[:baseSize] = new_base_size
+    end
+
+    # Number of glyph characters
+    # @return [Integer] glyphCount
+    def glyph_count = self[:glyphCount]
+
+    # Sets Number of glyph characters
+    def glyph_count=(new_glyph_count)
+      self[:glyphCount] = new_glyph_count
+    end
+
+    # Padding around the glyph characters
+    # @return [Integer] glyphPadding
+    def glyph_padding = self[:glyphPadding]
+
+    # Sets Padding around the glyph characters
+    def glyph_padding=(new_glyph_padding)
+      self[:glyphPadding] = new_glyph_padding
+    end
+
+    # Texture atlas containing the glyphs
+    # @return [Texture2D] texture
+    def texture = self[:texture]
+
+    # Sets Texture atlas containing the glyphs
+    def texture=(new_texture)
+      self[:texture] = new_texture
+    end
+
+    # Rectangles in texture for the glyphs
+    # @return [Rectangle *] recs
+    def recs = self[:recs]
+
+    # Sets Rectangles in texture for the glyphs
+    def recs=(new_recs)
+      self[:recs] = new_recs
+    end
+
+    # Glyphs info data
+    # @return [GlyphInfo *] glyphs
+    def glyphs = self[:glyphs]
+
+    # Sets Glyphs info data
+    def glyphs=(new_glyphs)
+      self[:glyphs] = new_glyphs
+    end
+  end
+end

data/lib/raylib/core/structs/glyph_info.rb

@@ -0,0 +1,71 @@
+module Raylib
+  # GlyphInfo, font characters glyphs info
+  class GlyphInfo < FFI::Struct
+    layout(
+      :value, :int,    # Character value (Unicode),
+      :offsetX, :int,  # Character offset X when drawing,
+      :offsetY, :int,  # Character offset Y when drawing,
+      :advanceX, :int, # Character advance position X,
+      :image, Image,   # Character image data
+    )
+
+    def self.create(value, offset_x, offset_y, advance_x, image)
+      new.tap do |instance|
+        instance[:value] = value
+        instance[:offsetX] = offset_x
+        instance[:offsetY] = offset_y
+        instance[:advanceX] = advance_x
+        instance[:image] = image
+      end
+    end
+
+    def to_s
+      "Raylib::GlyphInfo##{object_id} value=#{value} offset_x=#{offset_x} offset_y=#{offset_y} advance_x=#{advance_x} image=#{image}"
+    end
+
+    # Character value (Unicode)
+    # @return [Integer] value
+    def value = self[:value]
+
+    # Sets Character value (Unicode)
+    def value=(new_value)
+      self[:value] = new_value
+    end
+
+    # Character offset X when drawing
+    # @return [Integer] offsetX
+    def offset_x = self[:offsetX]
+
+    # Sets Character offset X when drawing
+    def offset_x=(new_offset_x)
+      self[:offsetX] = new_offset_x
+    end
+
+    # Character offset Y when drawing
+    # @return [Integer] offsetY
+    def offset_y = self[:offsetY]
+
+    # Sets Character offset Y when drawing
+    def offset_y=(new_offset_y)
+      self[:offsetY] = new_offset_y
+    end
+
+    # Character advance position X
+    # @return [Integer] advanceX
+    def advance_x = self[:advanceX]
+
+    # Sets Character advance position X
+    def advance_x=(new_advance_x)
+      self[:advanceX] = new_advance_x
+    end
+
+    # Character image data
+    # @return [Image] image
+    def image = self[:image]
+
+    # Sets Character image data
+    def image=(new_image)
+      self[:image] = new_image
+    end
+  end
+end

data/lib/raylib/core/structs/image.rb

@@ -0,0 +1,71 @@
+module Raylib
+  # Image, pixel data stored in CPU memory (RAM)
+  class Image < FFI::Struct
+    layout(
+      :data, :pointer, # Image raw data,
+      :width, :int,    # Image base width,
+      :height, :int,   # Image base height,
+      :mipmaps, :int,  # Mipmap levels, 1 by default,
+      :format, :int,   # Data format (PixelFormat type)
+    )
+
+    def self.create(data, width, height, mipmaps, format)
+      new.tap do |instance|
+        instance[:data] = data
+        instance[:width] = width
+        instance[:height] = height
+        instance[:mipmaps] = mipmaps
+        instance[:format] = format
+      end
+    end
+
+    def to_s
+      "Raylib::Image##{object_id} data=#{data} width=#{width} height=#{height} mipmaps=#{mipmaps} format=#{format}"
+    end
+
+    # Image raw data
+    # @return [void *] data
+    def data = self[:data]
+
+    # Sets Image raw data
+    def data=(new_data)
+      self[:data] = new_data
+    end
+
+    # Image base width
+    # @return [Integer] width
+    def width = self[:width]
+
+    # Sets Image base width
+    def width=(new_width)
+      self[:width] = new_width
+    end
+
+    # Image base height
+    # @return [Integer] height
+    def height = self[:height]
+
+    # Sets Image base height
+    def height=(new_height)
+      self[:height] = new_height
+    end
+
+    # Mipmap levels, 1 by default
+    # @return [Integer] mipmaps
+    def mipmaps = self[:mipmaps]
+
+    # Sets Mipmap levels, 1 by default
+    def mipmaps=(new_mipmaps)
+      self[:mipmaps] = new_mipmaps
+    end
+
+    # Data format (PixelFormat type)
+    # @return [Integer] format
+    def format = self[:format]
+
+    # Sets Data format (PixelFormat type)
+    def format=(new_format)
+      self[:format] = new_format
+    end
+  end
+end

data/lib/raylib/core/structs/material.rb

@@ -0,0 +1,49 @@
+module Raylib
+  # Material, includes shader and maps
+  class Material < FFI::Struct
+    layout(
+      :shader, Shader,      # Material shader,
+      :maps, :pointer,      # Material maps array (MAX_MATERIAL_MAPS),
+      :params, [:float, 4], # Material generic parameters (if required)
+    )
+
+    def self.create(shader, maps, params)
+      new.tap do |instance|
+        instance[:shader] = shader
+        instance[:maps] = maps
+        instance[:params] = params
+      end
+    end
+
+    def to_s
+      "Raylib::Material##{object_id} shader=#{shader} maps=#{maps} params=#{params}"
+    end
+
+    # Material shader
+    # @return [Shader] shader
+    def shader = self[:shader]
+
+    # Sets Material shader
+    def shader=(new_shader)
+      self[:shader] = new_shader
+    end
+
+    # Material maps array (MAX_MATERIAL_MAPS)
+    # @return [MaterialMap *] maps
+    def maps = self[:maps]
+
+    # Sets Material maps array (MAX_MATERIAL_MAPS)
+    def maps=(new_maps)
+      self[:maps] = new_maps
+    end
+
+    # Material generic parameters (if required)
+    # @return [float[4]] params
+    def params = self[:params]
+
+    # Sets Material generic parameters (if required)
+    def params=(new_params)
+      self[:params] = new_params
+    end
+  end
+end