raylib 4.5.0.alpha1

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

@@ -0,0 +1,82 @@
+module Raylib
+  # NPatchInfo, n-patch layout info
+  class NPatchInfo < FFI::Struct
+    layout(
+      :source, Rectangle, # Texture source rectangle,
+      :left, :int,        # Left border offset,
+      :top, :int,         # Top border offset,
+      :right, :int,       # Right border offset,
+      :bottom, :int,      # Bottom border offset,
+      :layout, :int,      # Layout of the n-patch: 3x3, 1x3 or 3x1
+    )
+
+    def self.create(source, left, top, right, bottom, layout)
+      new.tap do |instance|
+        instance[:source] = source
+        instance[:left] = left
+        instance[:top] = top
+        instance[:right] = right
+        instance[:bottom] = bottom
+        instance[:layout] = layout
+      end
+    end
+
+    def to_s
+      "Raylib::NPatchInfo##{object_id} source=#{source} left=#{left} top=#{top} right=#{right} bottom=#{bottom} layout=#{layout}"
+    end
+
+    # Texture source rectangle
+    # @return [Rectangle] source
+    def source = self[:source]
+
+    # Sets Texture source rectangle
+    def source=(new_source)
+      self[:source] = new_source
+    end
+
+    # Left border offset
+    # @return [Integer] left
+    def left = self[:left]
+
+    # Sets Left border offset
+    def left=(new_left)
+      self[:left] = new_left
+    end
+
+    # Top border offset
+    # @return [Integer] top
+    def top = self[:top]
+
+    # Sets Top border offset
+    def top=(new_top)
+      self[:top] = new_top
+    end
+
+    # Right border offset
+    # @return [Integer] right
+    def right = self[:right]
+
+    # Sets Right border offset
+    def right=(new_right)
+      self[:right] = new_right
+    end
+
+    # Bottom border offset
+    # @return [Integer] bottom
+    def bottom = self[:bottom]
+
+    # Sets Bottom border offset
+    def bottom=(new_bottom)
+      self[:bottom] = new_bottom
+    end
+
+    # Layout of the n-patch: 3x3, 1x3 or 3x1
+    # @return [Integer] layout
+    def layout = self[:layout]
+
+    # Sets Layout of the n-patch: 3x3, 1x3 or 3x1
+    def layout=(new_layout)
+      self[:layout] = new_layout
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Raylib
+  # Ray, ray for raycasting
+  class Ray < FFI::Struct
+    layout(
+      :position, Vector3,  # Ray position (origin),
+      :direction, Vector3, # Ray direction
+    )
+
+    def self.create(position, direction)
+      new.tap do |instance|
+        instance[:position] = position
+        instance[:direction] = direction
+      end
+    end
+
+    def to_s
+      "Raylib::Ray##{object_id} position=#{position} direction=#{direction}"
+    end
+
+    # Ray position (origin)
+    # @return [Vector3] position
+    def position = self[:position]
+
+    # Sets Ray position (origin)
+    def position=(new_position)
+      self[:position] = new_position
+    end
+
+    # Ray direction
+    # @return [Vector3] direction
+    def direction = self[:direction]
+
+    # Sets Ray direction
+    def direction=(new_direction)
+      self[:direction] = new_direction
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Raylib
+  # RayCollision, ray hit information
+  class RayCollision < FFI::Struct
+    layout(
+      :hit, :bool,       # Did the ray hit something?,
+      :distance, :float, # Distance to the nearest hit,
+      :point, Vector3,   # Point of the nearest hit,
+      :normal, Vector3,  # Surface normal of hit
+    )
+
+    def self.create(hit, distance, point, normal)
+      new.tap do |instance|
+        instance[:hit] = hit
+        instance[:distance] = distance
+        instance[:point] = point
+        instance[:normal] = normal
+      end
+    end
+
+    def to_s
+      "Raylib::RayCollision##{object_id} hit=#{hit} distance=#{distance} point=#{point} normal=#{normal}"
+    end
+
+    # Did the ray hit something?
+    # @return [bool] hit
+    def hit = self[:hit]
+
+    # Sets Did the ray hit something?
+    def hit=(new_hit)
+      self[:hit] = new_hit
+    end
+
+    # Distance to the nearest hit
+    # @return [Float] distance
+    def distance = self[:distance]
+
+    # Sets Distance to the nearest hit
+    def distance=(new_distance)
+      self[:distance] = new_distance
+    end
+
+    # Point of the nearest hit
+    # @return [Vector3] point
+    def point = self[:point]
+
+    # Sets Point of the nearest hit
+    def point=(new_point)
+      self[:point] = new_point
+    end
+
+    # Surface normal of hit
+    # @return [Vector3] normal
+    def normal = self[:normal]
+
+    # Sets Surface normal of hit
+    def normal=(new_normal)
+      self[:normal] = new_normal
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Raylib
+  # Rectangle, 4 components
+  class Rectangle < FFI::Struct
+    layout(
+      :x, :float,      # Rectangle top-left corner position x,
+      :y, :float,      # Rectangle top-left corner position y,
+      :width, :float,  # Rectangle width,
+      :height, :float, # Rectangle height
+    )
+
+    def self.create(x, y, width, height)
+      new.tap do |instance|
+        instance[:x] = x
+        instance[:y] = y
+        instance[:width] = width
+        instance[:height] = height
+      end
+    end
+
+    def to_s
+      "Raylib::Rectangle##{object_id} x=#{x} y=#{y} width=#{width} height=#{height}"
+    end
+
+    # Rectangle top-left corner position x
+    # @return [Float] x
+    def x = self[:x]
+
+    # Sets Rectangle top-left corner position x
+    def x=(new_x)
+      self[:x] = new_x
+    end
+
+    # Rectangle top-left corner position y
+    # @return [Float] y
+    def y = self[:y]
+
+    # Sets Rectangle top-left corner position y
+    def y=(new_y)
+      self[:y] = new_y
+    end
+
+    # Rectangle width
+    # @return [Float] width
+    def width = self[:width]
+
+    # Sets Rectangle width
+    def width=(new_width)
+      self[:width] = new_width
+    end
+
+    # Rectangle height
+    # @return [Float] height
+    def height = self[:height]
+
+    # Sets Rectangle height
+    def height=(new_height)
+      self[:height] = new_height
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Raylib
+  # RenderTexture, fbo for texture rendering
+  class RenderTexture < FFI::Struct
+    layout(
+      :id, :uint,        # OpenGL framebuffer object id,
+      :texture, Texture, # Color buffer attachment texture,
+      :depth, Texture,   # Depth buffer attachment texture
+    )
+
+    def self.create(id, texture, depth)
+      new.tap do |instance|
+        instance[:id] = id
+        instance[:texture] = texture
+        instance[:depth] = depth
+      end
+    end
+
+    def to_s
+      "Raylib::RenderTexture##{object_id} id=#{id} texture=#{texture} depth=#{depth}"
+    end
+
+    # OpenGL framebuffer object id
+    # @return [Integer] id
+    def id = self[:id]
+
+    # Sets OpenGL framebuffer object id
+    def id=(new_id)
+      self[:id] = new_id
+    end
+
+    # Color buffer attachment texture
+    # @return [Texture] texture
+    def texture = self[:texture]
+
+    # Sets Color buffer attachment texture
+    def texture=(new_texture)
+      self[:texture] = new_texture
+    end
+
+    # Depth buffer attachment texture
+    # @return [Texture] depth
+    def depth = self[:depth]
+
+    # Sets Depth buffer attachment texture
+    def depth=(new_depth)
+      self[:depth] = new_depth
+    end
+  end
+
+  # RenderTexture2D, same as RenderTexture
+  RenderTexture2D = RenderTexture
+end

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

@@ -0,0 +1,38 @@
+module Raylib
+  # Shader
+  class Shader < FFI::Struct
+    layout(
+      :id, :uint,      # Shader program id,
+      :locs, :pointer, # Shader locations array (RL_MAX_SHADER_LOCATIONS)
+    )
+
+    def self.create(id, locs)
+      new.tap do |instance|
+        instance[:id] = id
+        instance[:locs] = locs
+      end
+    end
+
+    def to_s
+      "Raylib::Shader##{object_id} id=#{id} locs=#{locs}"
+    end
+
+    # Shader program id
+    # @return [Integer] id
+    def id = self[:id]
+
+    # Sets Shader program id
+    def id=(new_id)
+      self[:id] = new_id
+    end
+
+    # Shader locations array (RL_MAX_SHADER_LOCATIONS)
+    # @return [int *] locs
+    def locs = self[:locs]
+
+    # Sets Shader locations array (RL_MAX_SHADER_LOCATIONS)
+    def locs=(new_locs)
+      self[:locs] = new_locs
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Raylib
+  # Sound
+  class Sound < FFI::Struct
+    layout(
+      :stream, AudioStream, # Audio stream,
+      :frameCount, :uint,   # Total number of frames (considering channels)
+    )
+
+    def self.create(stream, frame_count)
+      new.tap do |instance|
+        instance[:stream] = stream
+        instance[:frameCount] = frame_count
+      end
+    end
+
+    def to_s
+      "Raylib::Sound##{object_id} stream=#{stream} frame_count=#{frame_count}"
+    end
+
+    # Audio stream
+    # @return [AudioStream] stream
+    def stream = self[:stream]
+
+    # Sets Audio stream
+    def stream=(new_stream)
+      self[:stream] = new_stream
+    end
+
+    # Total number of frames (considering channels)
+    # @return [Integer] frameCount
+    def frame_count = self[:frameCount]
+
+    # Sets Total number of frames (considering channels)
+    def frame_count=(new_frame_count)
+      self[:frameCount] = new_frame_count
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Raylib
+  # Texture, tex data stored in GPU memory (VRAM)
+  class Texture < FFI::Struct
+    layout(
+      :id, :uint,     # OpenGL texture id,
+      :width, :int,   # Texture base width,
+      :height, :int,  # Texture base height,
+      :mipmaps, :int, # Mipmap levels, 1 by default,
+      :format, :int,  # Data format (PixelFormat type)
+    )
+
+    def self.create(id, width, height, mipmaps, format)
+      new.tap do |instance|
+        instance[:id] = id
+        instance[:width] = width
+        instance[:height] = height
+        instance[:mipmaps] = mipmaps
+        instance[:format] = format
+      end
+    end
+
+    def to_s
+      "Raylib::Texture##{object_id} id=#{id} width=#{width} height=#{height} mipmaps=#{mipmaps} format=#{format}"
+    end
+
+    # OpenGL texture id
+    # @return [Integer] id
+    def id = self[:id]
+
+    # Sets OpenGL texture id
+    def id=(new_id)
+      self[:id] = new_id
+    end
+
+    # Texture base width
+    # @return [Integer] width
+    def width = self[:width]
+
+    # Sets Texture base width
+    def width=(new_width)
+      self[:width] = new_width
+    end
+
+    # Texture base height
+    # @return [Integer] height
+    def height = self[:height]
+
+    # Sets Texture 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
+
+  # Texture2D, same as Texture
+  Texture2D = Texture
+
+  # TextureCubemap, same as Texture
+  TextureCubemap = Texture
+end

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

@@ -0,0 +1,49 @@
+module Raylib
+  # Transform, vertex transformation data
+  class Transform < FFI::Struct
+    layout(
+      :translation, Vector3, # Translation,
+      :rotation, Quaternion, # Rotation,
+      :scale, Vector3,       # Scale
+    )
+
+    def self.create(translation, rotation, scale)
+      new.tap do |instance|
+        instance[:translation] = translation
+        instance[:rotation] = rotation
+        instance[:scale] = scale
+      end
+    end
+
+    def to_s
+      "Raylib::Transform##{object_id} translation=#{translation} rotation=#{rotation} scale=#{scale}"
+    end
+
+    # Translation
+    # @return [Vector3] translation
+    def translation = self[:translation]
+
+    # Sets Translation
+    def translation=(new_translation)
+      self[:translation] = new_translation
+    end
+
+    # Rotation
+    # @return [Quaternion] rotation
+    def rotation = self[:rotation]
+
+    # Sets Rotation
+    def rotation=(new_rotation)
+      self[:rotation] = new_rotation
+    end
+
+    # Scale
+    # @return [Vector3] scale
+    def scale = self[:scale]
+
+    # Sets Scale
+    def scale=(new_scale)
+      self[:scale] = new_scale
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Raylib
+  # Vector2, 2 components
+  class Vector2 < FFI::Struct
+    layout(
+      :x, :float, # Vector x component,
+      :y, :float, # Vector y component
+    )
+
+    def self.create(x, y)
+      new.tap do |instance|
+        instance[:x] = x
+        instance[:y] = y
+      end
+    end
+
+    def to_s
+      "Raylib::Vector2##{object_id} x=#{x} y=#{y}"
+    end
+
+    # Vector x component
+    # @return [Float] x
+    def x = self[:x]
+
+    # Sets Vector x component
+    def x=(new_x)
+      self[:x] = new_x
+    end
+
+    # Vector y component
+    # @return [Float] y
+    def y = self[:y]
+
+    # Sets Vector y component
+    def y=(new_y)
+      self[:y] = new_y
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Raylib
+  # Vector3, 3 components
+  class Vector3 < FFI::Struct
+    layout(
+      :x, :float, # Vector x component,
+      :y, :float, # Vector y component,
+      :z, :float, # Vector z component
+    )
+
+    def self.create(x, y, z)
+      new.tap do |instance|
+        instance[:x] = x
+        instance[:y] = y
+        instance[:z] = z
+      end
+    end
+
+    def to_s
+      "Raylib::Vector3##{object_id} x=#{x} y=#{y} z=#{z}"
+    end
+
+    # Vector x component
+    # @return [Float] x
+    def x = self[:x]
+
+    # Sets Vector x component
+    def x=(new_x)
+      self[:x] = new_x
+    end
+
+    # Vector y component
+    # @return [Float] y
+    def y = self[:y]
+
+    # Sets Vector y component
+    def y=(new_y)
+      self[:y] = new_y
+    end
+
+    # Vector z component
+    # @return [Float] z
+    def z = self[:z]
+
+    # Sets Vector z component
+    def z=(new_z)
+      self[:z] = new_z
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Raylib
+  # Vector4, 4 components
+  class Vector4 < FFI::Struct
+    layout(
+      :x, :float, # Vector x component,
+      :y, :float, # Vector y component,
+      :z, :float, # Vector z component,
+      :w, :float, # Vector w component
+    )
+
+    def self.create(x, y, z, w)
+      new.tap do |instance|
+        instance[:x] = x
+        instance[:y] = y
+        instance[:z] = z
+        instance[:w] = w
+      end
+    end
+
+    def to_s
+      "Raylib::Vector4##{object_id} x=#{x} y=#{y} z=#{z} w=#{w}"
+    end
+
+    # Vector x component
+    # @return [Float] x
+    def x = self[:x]
+
+    # Sets Vector x component
+    def x=(new_x)
+      self[:x] = new_x
+    end
+
+    # Vector y component
+    # @return [Float] y
+    def y = self[:y]
+
+    # Sets Vector y component
+    def y=(new_y)
+      self[:y] = new_y
+    end
+
+    # Vector z component
+    # @return [Float] z
+    def z = self[:z]
+
+    # Sets Vector z component
+    def z=(new_z)
+      self[:z] = new_z
+    end
+
+    # Vector w component
+    # @return [Float] w
+    def w = self[:w]
+
+    # Sets Vector w component
+    def w=(new_w)
+      self[:w] = new_w
+    end
+  end
+
+  # Quaternion, 4 components (Vector4 alias)
+  Quaternion = Vector4
+end