raylib 4.5.0.alpha1

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

@@ -0,0 +1,49 @@
+module Raylib
+  # MaterialMap
+  class MaterialMap < FFI::Struct
+    layout(
+      :texture, Texture2D, # Material map texture,
+      :color, Color,       # Material map color,
+      :value, :float,      # Material map value
+    )
+
+    def self.create(texture, color, value)
+      new.tap do |instance|
+        instance[:texture] = texture
+        instance[:color] = color
+        instance[:value] = value
+      end
+    end
+
+    def to_s
+      "Raylib::MaterialMap##{object_id} texture=#{texture} color=#{color} value=#{value}"
+    end
+
+    # Material map texture
+    # @return [Texture2D] texture
+    def texture = self[:texture]
+
+    # Sets Material map texture
+    def texture=(new_texture)
+      self[:texture] = new_texture
+    end
+
+    # Material map color
+    # @return [Color] color
+    def color = self[:color]
+
+    # Sets Material map color
+    def color=(new_color)
+      self[:color] = new_color
+    end
+
+    # Material map value
+    # @return [Float] value
+    def value = self[:value]
+
+    # Sets Material map value
+    def value=(new_value)
+      self[:value] = new_value
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+module Raylib
+  # Matrix, 4x4 components, column major, OpenGL style, right-handed
+  class Matrix < FFI::Struct
+    layout(
+      :m0, :float,  # Matrix first row (4 components),
+      :m4, :float,  # Matrix first row (4 components),
+      :m8, :float,  # Matrix first row (4 components),
+      :m12, :float, # Matrix first row (4 components),
+      :m1, :float,  # Matrix second row (4 components),
+      :m5, :float,  # Matrix second row (4 components),
+      :m9, :float,  # Matrix second row (4 components),
+      :m13, :float, # Matrix second row (4 components),
+      :m2, :float,  # Matrix third row (4 components),
+      :m6, :float,  # Matrix third row (4 components),
+      :m10, :float, # Matrix third row (4 components),
+      :m14, :float, # Matrix third row (4 components),
+      :m3, :float,  # Matrix fourth row (4 components),
+      :m7, :float,  # Matrix fourth row (4 components),
+      :m11, :float, # Matrix fourth row (4 components),
+      :m15, :float, # Matrix fourth row (4 components)
+    )
+
+    def self.create(m0, m4, m8, m12, m1, m5, m9, m13, m2, m6, m10, m14, m3, m7, m11, m15)
+      new.tap do |instance|
+        instance[:m0] = m0
+        instance[:m4] = m4
+        instance[:m8] = m8
+        instance[:m12] = m12
+        instance[:m1] = m1
+        instance[:m5] = m5
+        instance[:m9] = m9
+        instance[:m13] = m13
+        instance[:m2] = m2
+        instance[:m6] = m6
+        instance[:m10] = m10
+        instance[:m14] = m14
+        instance[:m3] = m3
+        instance[:m7] = m7
+        instance[:m11] = m11
+        instance[:m15] = m15
+      end
+    end
+
+    def to_s
+      "Raylib::Matrix##{object_id} m0=#{m0} m4=#{m4} m8=#{m8} m12=#{m12} m1=#{m1} m5=#{m5} m9=#{m9} m13=#{m13} m2=#{m2} m6=#{m6} m10=#{m10} m14=#{m14} m3=#{m3} m7=#{m7} m11=#{m11} m15=#{m15}"
+    end
+
+    # Matrix first row (4 components)
+    # @return [Float] m0
+    def m0 = self[:m0]
+
+    # Sets Matrix first row (4 components)
+    def m0=(new_m0)
+      self[:m0] = new_m0
+    end
+
+    # Matrix first row (4 components)
+    # @return [Float] m4
+    def m4 = self[:m4]
+
+    # Sets Matrix first row (4 components)
+    def m4=(new_m4)
+      self[:m4] = new_m4
+    end
+
+    # Matrix first row (4 components)
+    # @return [Float] m8
+    def m8 = self[:m8]
+
+    # Sets Matrix first row (4 components)
+    def m8=(new_m8)
+      self[:m8] = new_m8
+    end
+
+    # Matrix first row (4 components)
+    # @return [Float] m12
+    def m12 = self[:m12]
+
+    # Sets Matrix first row (4 components)
+    def m12=(new_m12)
+      self[:m12] = new_m12
+    end
+
+    # Matrix second row (4 components)
+    # @return [Float] m1
+    def m1 = self[:m1]
+
+    # Sets Matrix second row (4 components)
+    def m1=(new_m1)
+      self[:m1] = new_m1
+    end
+
+    # Matrix second row (4 components)
+    # @return [Float] m5
+    def m5 = self[:m5]
+
+    # Sets Matrix second row (4 components)
+    def m5=(new_m5)
+      self[:m5] = new_m5
+    end
+
+    # Matrix second row (4 components)
+    # @return [Float] m9
+    def m9 = self[:m9]
+
+    # Sets Matrix second row (4 components)
+    def m9=(new_m9)
+      self[:m9] = new_m9
+    end
+
+    # Matrix second row (4 components)
+    # @return [Float] m13
+    def m13 = self[:m13]
+
+    # Sets Matrix second row (4 components)
+    def m13=(new_m13)
+      self[:m13] = new_m13
+    end
+
+    # Matrix third row (4 components)
+    # @return [Float] m2
+    def m2 = self[:m2]
+
+    # Sets Matrix third row (4 components)
+    def m2=(new_m2)
+      self[:m2] = new_m2
+    end
+
+    # Matrix third row (4 components)
+    # @return [Float] m6
+    def m6 = self[:m6]
+
+    # Sets Matrix third row (4 components)
+    def m6=(new_m6)
+      self[:m6] = new_m6
+    end
+
+    # Matrix third row (4 components)
+    # @return [Float] m10
+    def m10 = self[:m10]
+
+    # Sets Matrix third row (4 components)
+    def m10=(new_m10)
+      self[:m10] = new_m10
+    end
+
+    # Matrix third row (4 components)
+    # @return [Float] m14
+    def m14 = self[:m14]
+
+    # Sets Matrix third row (4 components)
+    def m14=(new_m14)
+      self[:m14] = new_m14
+    end
+
+    # Matrix fourth row (4 components)
+    # @return [Float] m3
+    def m3 = self[:m3]
+
+    # Sets Matrix fourth row (4 components)
+    def m3=(new_m3)
+      self[:m3] = new_m3
+    end
+
+    # Matrix fourth row (4 components)
+    # @return [Float] m7
+    def m7 = self[:m7]
+
+    # Sets Matrix fourth row (4 components)
+    def m7=(new_m7)
+      self[:m7] = new_m7
+    end
+
+    # Matrix fourth row (4 components)
+    # @return [Float] m11
+    def m11 = self[:m11]
+
+    # Sets Matrix fourth row (4 components)
+    def m11=(new_m11)
+      self[:m11] = new_m11
+    end
+
+    # Matrix fourth row (4 components)
+    # @return [Float] m15
+    def m15 = self[:m15]
+
+    # Sets Matrix fourth row (4 components)
+    def m15=(new_m15)
+      self[:m15] = new_m15
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+module Raylib
+  # Mesh, vertex data and vao/vbo
+  class Mesh < FFI::Struct
+    layout(
+      :vertexCount, :int,      # Number of vertices stored in arrays,
+      :triangleCount, :int,    # Number of triangles stored (indexed or not),
+      :vertices, :pointer,     # Vertex position (XYZ - 3 components per vertex) (shader-location = 0),
+      :texcoords, :pointer,    # Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1),
+      :texcoords2, :pointer,   # Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5),
+      :normals, :pointer,      # Vertex normals (XYZ - 3 components per vertex) (shader-location = 2),
+      :tangents, :pointer,     # Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4),
+      :colors, :pointer,       # Vertex colors (RGBA - 4 components per vertex) (shader-location = 3),
+      :indices, :pointer,      # Vertex indices (in case vertex data comes indexed),
+      :animVertices, :pointer, # Animated vertex positions (after bones transformations),
+      :animNormals, :pointer,  # Animated normals (after bones transformations),
+      :boneIds, :pointer,      # Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning),
+      :boneWeights, :pointer,  # Vertex bone weight, up to 4 bones influence by vertex (skinning),
+      :vaoId, :uint,           # OpenGL Vertex Array Object id,
+      :vboId, :pointer,        # OpenGL Vertex Buffer Objects id (default vertex data)
+    )
+
+    def self.create(vertex_count, triangle_count, vertices, texcoords, texcoords2, normals, tangents, colors, indices, anim_vertices, anim_normals, bone_ids, bone_weights, vao_id, vbo_id)
+      new.tap do |instance|
+        instance[:vertexCount] = vertex_count
+        instance[:triangleCount] = triangle_count
+        instance[:vertices] = vertices
+        instance[:texcoords] = texcoords
+        instance[:texcoords2] = texcoords2
+        instance[:normals] = normals
+        instance[:tangents] = tangents
+        instance[:colors] = colors
+        instance[:indices] = indices
+        instance[:animVertices] = anim_vertices
+        instance[:animNormals] = anim_normals
+        instance[:boneIds] = bone_ids
+        instance[:boneWeights] = bone_weights
+        instance[:vaoId] = vao_id
+        instance[:vboId] = vbo_id
+      end
+    end
+
+    def to_s
+      "Raylib::Mesh##{object_id} vertex_count=#{vertex_count} triangle_count=#{triangle_count} vertices=#{vertices} texcoords=#{texcoords} texcoords2=#{texcoords2} normals=#{normals} tangents=#{tangents} colors=#{colors} indices=#{indices} anim_vertices=#{anim_vertices} anim_normals=#{anim_normals} bone_ids=#{bone_ids} bone_weights=#{bone_weights} vao_id=#{vao_id} vbo_id=#{vbo_id}"
+    end
+
+    # Number of vertices stored in arrays
+    # @return [Integer] vertexCount
+    def vertex_count = self[:vertexCount]
+
+    # Sets Number of vertices stored in arrays
+    def vertex_count=(new_vertex_count)
+      self[:vertexCount] = new_vertex_count
+    end
+
+    # Number of triangles stored (indexed or not)
+    # @return [Integer] triangleCount
+    def triangle_count = self[:triangleCount]
+
+    # Sets Number of triangles stored (indexed or not)
+    def triangle_count=(new_triangle_count)
+      self[:triangleCount] = new_triangle_count
+    end
+
+    # Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+    # @return [float *] vertices
+    def vertices = self[:vertices]
+
+    # Sets Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+    def vertices=(new_vertices)
+      self[:vertices] = new_vertices
+    end
+
+    # Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+    # @return [float *] texcoords
+    def texcoords = self[:texcoords]
+
+    # Sets Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+    def texcoords=(new_texcoords)
+      self[:texcoords] = new_texcoords
+    end
+
+    # Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5)
+    # @return [float *] texcoords2
+    def texcoords2 = self[:texcoords2]
+
+    # Sets Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5)
+    def texcoords2=(new_texcoords2)
+      self[:texcoords2] = new_texcoords2
+    end
+
+    # Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
+    # @return [float *] normals
+    def normals = self[:normals]
+
+    # Sets Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
+    def normals=(new_normals)
+      self[:normals] = new_normals
+    end
+
+    # Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
+    # @return [float *] tangents
+    def tangents = self[:tangents]
+
+    # Sets Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
+    def tangents=(new_tangents)
+      self[:tangents] = new_tangents
+    end
+
+    # Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+    # @return [unsigned char *] colors
+    def colors = self[:colors]
+
+    # Sets Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+    def colors=(new_colors)
+      self[:colors] = new_colors
+    end
+
+    # Vertex indices (in case vertex data comes indexed)
+    # @return [unsigned short *] indices
+    def indices = self[:indices]
+
+    # Sets Vertex indices (in case vertex data comes indexed)
+    def indices=(new_indices)
+      self[:indices] = new_indices
+    end
+
+    # Animated vertex positions (after bones transformations)
+    # @return [float *] animVertices
+    def anim_vertices = self[:animVertices]
+
+    # Sets Animated vertex positions (after bones transformations)
+    def anim_vertices=(new_anim_vertices)
+      self[:animVertices] = new_anim_vertices
+    end
+
+    # Animated normals (after bones transformations)
+    # @return [float *] animNormals
+    def anim_normals = self[:animNormals]
+
+    # Sets Animated normals (after bones transformations)
+    def anim_normals=(new_anim_normals)
+      self[:animNormals] = new_anim_normals
+    end
+
+    # Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)
+    # @return [unsigned char *] boneIds
+    def bone_ids = self[:boneIds]
+
+    # Sets Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)
+    def bone_ids=(new_bone_ids)
+      self[:boneIds] = new_bone_ids
+    end
+
+    # Vertex bone weight, up to 4 bones influence by vertex (skinning)
+    # @return [float *] boneWeights
+    def bone_weights = self[:boneWeights]
+
+    # Sets Vertex bone weight, up to 4 bones influence by vertex (skinning)
+    def bone_weights=(new_bone_weights)
+      self[:boneWeights] = new_bone_weights
+    end
+
+    # OpenGL Vertex Array Object id
+    # @return [Integer] vaoId
+    def vao_id = self[:vaoId]
+
+    # Sets OpenGL Vertex Array Object id
+    def vao_id=(new_vao_id)
+      self[:vaoId] = new_vao_id
+    end
+
+    # OpenGL Vertex Buffer Objects id (default vertex data)
+    # @return [unsigned int *] vboId
+    def vbo_id = self[:vboId]
+
+    # Sets OpenGL Vertex Buffer Objects id (default vertex data)
+    def vbo_id=(new_vbo_id)
+      self[:vboId] = new_vbo_id
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Raylib
+  # Model, meshes, materials and animation data
+  class Model < FFI::Struct
+    layout(
+      :transform, Matrix,      # Local transform matrix,
+      :meshCount, :int,        # Number of meshes,
+      :materialCount, :int,    # Number of materials,
+      :meshes, :pointer,       # Meshes array,
+      :materials, :pointer,    # Materials array,
+      :meshMaterial, :pointer, # Mesh material number,
+      :boneCount, :int,        # Number of bones,
+      :bones, :pointer,        # Bones information (skeleton),
+      :bindPose, :pointer,     # Bones base transformation (pose)
+    )
+
+    def self.create(transform, mesh_count, material_count, meshes, materials, mesh_material, bone_count, bones, bind_pose)
+      new.tap do |instance|
+        instance[:transform] = transform
+        instance[:meshCount] = mesh_count
+        instance[:materialCount] = material_count
+        instance[:meshes] = meshes
+        instance[:materials] = materials
+        instance[:meshMaterial] = mesh_material
+        instance[:boneCount] = bone_count
+        instance[:bones] = bones
+        instance[:bindPose] = bind_pose
+      end
+    end
+
+    def to_s
+      "Raylib::Model##{object_id} transform=#{transform} mesh_count=#{mesh_count} material_count=#{material_count} meshes=#{meshes} materials=#{materials} mesh_material=#{mesh_material} bone_count=#{bone_count} bones=#{bones} bind_pose=#{bind_pose}"
+    end
+
+    # Local transform matrix
+    # @return [Matrix] transform
+    def transform = self[:transform]
+
+    # Sets Local transform matrix
+    def transform=(new_transform)
+      self[:transform] = new_transform
+    end
+
+    # Number of meshes
+    # @return [Integer] meshCount
+    def mesh_count = self[:meshCount]
+
+    # Sets Number of meshes
+    def mesh_count=(new_mesh_count)
+      self[:meshCount] = new_mesh_count
+    end
+
+    # Number of materials
+    # @return [Integer] materialCount
+    def material_count = self[:materialCount]
+
+    # Sets Number of materials
+    def material_count=(new_material_count)
+      self[:materialCount] = new_material_count
+    end
+
+    # Meshes array
+    # @return [Mesh *] meshes
+    def meshes = self[:meshes]
+
+    # Sets Meshes array
+    def meshes=(new_meshes)
+      self[:meshes] = new_meshes
+    end
+
+    # Materials array
+    # @return [Material *] materials
+    def materials = self[:materials]
+
+    # Sets Materials array
+    def materials=(new_materials)
+      self[:materials] = new_materials
+    end
+
+    # Mesh material number
+    # @return [int *] meshMaterial
+    def mesh_material = self[:meshMaterial]
+
+    # Sets Mesh material number
+    def mesh_material=(new_mesh_material)
+      self[:meshMaterial] = new_mesh_material
+    end
+
+    # Number of bones
+    # @return [Integer] boneCount
+    def bone_count = self[:boneCount]
+
+    # Sets Number of bones
+    def bone_count=(new_bone_count)
+      self[:boneCount] = new_bone_count
+    end
+
+    # Bones information (skeleton)
+    # @return [BoneInfo *] bones
+    def bones = self[:bones]
+
+    # Sets Bones information (skeleton)
+    def bones=(new_bones)
+      self[:bones] = new_bones
+    end
+
+    # Bones base transformation (pose)
+    # @return [Transform *] bindPose
+    def bind_pose = self[:bindPose]
+
+    # Sets Bones base transformation (pose)
+    def bind_pose=(new_bind_pose)
+      self[:bindPose] = new_bind_pose
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Raylib
+  # ModelAnimation
+  class ModelAnimation < FFI::Struct
+    layout(
+      :boneCount, :int,      # Number of bones,
+      :frameCount, :int,     # Number of animation frames,
+      :bones, :pointer,      # Bones information (skeleton),
+      :framePoses, :pointer, # Poses array by frame
+    )
+
+    def self.create(bone_count, frame_count, bones, frame_poses)
+      new.tap do |instance|
+        instance[:boneCount] = bone_count
+        instance[:frameCount] = frame_count
+        instance[:bones] = bones
+        instance[:framePoses] = frame_poses
+      end
+    end
+
+    def to_s
+      "Raylib::ModelAnimation##{object_id} bone_count=#{bone_count} frame_count=#{frame_count} bones=#{bones} frame_poses=#{frame_poses}"
+    end
+
+    # Number of bones
+    # @return [Integer] boneCount
+    def bone_count = self[:boneCount]
+
+    # Sets Number of bones
+    def bone_count=(new_bone_count)
+      self[:boneCount] = new_bone_count
+    end
+
+    # Number of animation frames
+    # @return [Integer] frameCount
+    def frame_count = self[:frameCount]
+
+    # Sets Number of animation frames
+    def frame_count=(new_frame_count)
+      self[:frameCount] = new_frame_count
+    end
+
+    # Bones information (skeleton)
+    # @return [BoneInfo *] bones
+    def bones = self[:bones]
+
+    # Sets Bones information (skeleton)
+    def bones=(new_bones)
+      self[:bones] = new_bones
+    end
+
+    # Poses array by frame
+    # @return [Transform **] framePoses
+    def frame_poses = self[:framePoses]
+
+    # Sets Poses array by frame
+    def frame_poses=(new_frame_poses)
+      self[:framePoses] = new_frame_poses
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Raylib
+  # Music, audio stream, anything longer than ~10 seconds should be streamed
+  class Music < FFI::Struct
+    layout(
+      :stream, AudioStream, # Audio stream,
+      :frameCount, :uint,   # Total number of frames (considering channels),
+      :looping, :bool,      # Music looping enable,
+      :ctxType, :int,       # Type of music context (audio filetype),
+      :ctxData, :pointer,   # Audio context data, depends on type
+    )
+
+    def self.create(stream, frame_count, looping, ctx_type, ctx_data)
+      new.tap do |instance|
+        instance[:stream] = stream
+        instance[:frameCount] = frame_count
+        instance[:looping] = looping
+        instance[:ctxType] = ctx_type
+        instance[:ctxData] = ctx_data
+      end
+    end
+
+    def to_s
+      "Raylib::Music##{object_id} stream=#{stream} frame_count=#{frame_count} looping=#{looping} ctx_type=#{ctx_type} ctx_data=#{ctx_data}"
+    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
+
+    # Music looping enable
+    # @return [bool] looping
+    def looping = self[:looping]
+
+    # Sets Music looping enable
+    def looping=(new_looping)
+      self[:looping] = new_looping
+    end
+
+    # Type of music context (audio filetype)
+    # @return [Integer] ctxType
+    def ctx_type = self[:ctxType]
+
+    # Sets Type of music context (audio filetype)
+    def ctx_type=(new_ctx_type)
+      self[:ctxType] = new_ctx_type
+    end
+
+    # Audio context data, depends on type
+    # @return [void *] ctxData
+    def ctx_data = self[:ctxData]
+
+    # Sets Audio context data, depends on type
+    def ctx_data=(new_ctx_data)
+      self[:ctxData] = new_ctx_data
+    end
+  end
+end