raylib 4.5.0.alpha1

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

@@ -0,0 +1,126 @@
+module Raylib
+  # VrDeviceInfo, Head-Mounted-Display device parameters
+  class VrDeviceInfo < FFI::Struct
+    layout(
+      :hResolution, :int,                 # Horizontal resolution in pixels,
+      :vResolution, :int,                 # Vertical resolution in pixels,
+      :hScreenSize, :float,               # Horizontal size in meters,
+      :vScreenSize, :float,               # Vertical size in meters,
+      :vScreenCenter, :float,             # Screen center in meters,
+      :eyeToScreenDistance, :float,       # Distance between eye and display in meters,
+      :lensSeparationDistance, :float,    # Lens separation distance in meters,
+      :interpupillaryDistance, :float,    # IPD (distance between pupils) in meters,
+      :lensDistortionValues, [:float, 4], # Lens distortion constant parameters,
+      :chromaAbCorrection, [:float, 4],   # Chromatic aberration correction parameters
+    )
+
+    def self.create(h_resolution, v_resolution, h_screen_size, v_screen_size, v_screen_center, eye_to_screen_distance, lens_separation_distance, interpupillary_distance, lens_distortion_values, chroma_ab_correction)
+      new.tap do |instance|
+        instance[:hResolution] = h_resolution
+        instance[:vResolution] = v_resolution
+        instance[:hScreenSize] = h_screen_size
+        instance[:vScreenSize] = v_screen_size
+        instance[:vScreenCenter] = v_screen_center
+        instance[:eyeToScreenDistance] = eye_to_screen_distance
+        instance[:lensSeparationDistance] = lens_separation_distance
+        instance[:interpupillaryDistance] = interpupillary_distance
+        instance[:lensDistortionValues] = lens_distortion_values
+        instance[:chromaAbCorrection] = chroma_ab_correction
+      end
+    end
+
+    def to_s
+      "Raylib::VrDeviceInfo##{object_id} h_resolution=#{h_resolution} v_resolution=#{v_resolution} h_screen_size=#{h_screen_size} v_screen_size=#{v_screen_size} v_screen_center=#{v_screen_center} eye_to_screen_distance=#{eye_to_screen_distance} lens_separation_distance=#{lens_separation_distance} interpupillary_distance=#{interpupillary_distance} lens_distortion_values=#{lens_distortion_values} chroma_ab_correction=#{chroma_ab_correction}"
+    end
+
+    # Horizontal resolution in pixels
+    # @return [Integer] hResolution
+    def h_resolution = self[:hResolution]
+
+    # Sets Horizontal resolution in pixels
+    def h_resolution=(new_h_resolution)
+      self[:hResolution] = new_h_resolution
+    end
+
+    # Vertical resolution in pixels
+    # @return [Integer] vResolution
+    def v_resolution = self[:vResolution]
+
+    # Sets Vertical resolution in pixels
+    def v_resolution=(new_v_resolution)
+      self[:vResolution] = new_v_resolution
+    end
+
+    # Horizontal size in meters
+    # @return [Float] hScreenSize
+    def h_screen_size = self[:hScreenSize]
+
+    # Sets Horizontal size in meters
+    def h_screen_size=(new_h_screen_size)
+      self[:hScreenSize] = new_h_screen_size
+    end
+
+    # Vertical size in meters
+    # @return [Float] vScreenSize
+    def v_screen_size = self[:vScreenSize]
+
+    # Sets Vertical size in meters
+    def v_screen_size=(new_v_screen_size)
+      self[:vScreenSize] = new_v_screen_size
+    end
+
+    # Screen center in meters
+    # @return [Float] vScreenCenter
+    def v_screen_center = self[:vScreenCenter]
+
+    # Sets Screen center in meters
+    def v_screen_center=(new_v_screen_center)
+      self[:vScreenCenter] = new_v_screen_center
+    end
+
+    # Distance between eye and display in meters
+    # @return [Float] eyeToScreenDistance
+    def eye_to_screen_distance = self[:eyeToScreenDistance]
+
+    # Sets Distance between eye and display in meters
+    def eye_to_screen_distance=(new_eye_to_screen_distance)
+      self[:eyeToScreenDistance] = new_eye_to_screen_distance
+    end
+
+    # Lens separation distance in meters
+    # @return [Float] lensSeparationDistance
+    def lens_separation_distance = self[:lensSeparationDistance]
+
+    # Sets Lens separation distance in meters
+    def lens_separation_distance=(new_lens_separation_distance)
+      self[:lensSeparationDistance] = new_lens_separation_distance
+    end
+
+    # IPD (distance between pupils) in meters
+    # @return [Float] interpupillaryDistance
+    def interpupillary_distance = self[:interpupillaryDistance]
+
+    # Sets IPD (distance between pupils) in meters
+    def interpupillary_distance=(new_interpupillary_distance)
+      self[:interpupillaryDistance] = new_interpupillary_distance
+    end
+
+    # Lens distortion constant parameters
+    # @return [float[4]] lensDistortionValues
+    def lens_distortion_values = self[:lensDistortionValues]
+
+    # Sets Lens distortion constant parameters
+    def lens_distortion_values=(new_lens_distortion_values)
+      self[:lensDistortionValues] = new_lens_distortion_values
+    end
+
+    # Chromatic aberration correction parameters
+    # @return [float[4]] chromaAbCorrection
+    def chroma_ab_correction = self[:chromaAbCorrection]
+
+    # Sets Chromatic aberration correction parameters
+    def chroma_ab_correction=(new_chroma_ab_correction)
+      self[:chromaAbCorrection] = new_chroma_ab_correction
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+module Raylib
+  # VrStereoConfig, VR stereo rendering configuration for simulator
+  class VrStereoConfig < FFI::Struct
+    layout(
+      :projection, [Matrix, 2],        # VR projection matrices (per eye),
+      :viewOffset, [Matrix, 2],        # VR view offset matrices (per eye),
+      :leftLensCenter, [:float, 2],    # VR left lens center,
+      :rightLensCenter, [:float, 2],   # VR right lens center,
+      :leftScreenCenter, [:float, 2],  # VR left screen center,
+      :rightScreenCenter, [:float, 2], # VR right screen center,
+      :scale, [:float, 2],             # VR distortion scale,
+      :scaleIn, [:float, 2],           # VR distortion scale in
+    )
+
+    def self.create(projection, view_offset, left_lens_center, right_lens_center, left_screen_center, right_screen_center, scale, scale_in)
+      new.tap do |instance|
+        instance[:projection] = projection
+        instance[:viewOffset] = view_offset
+        instance[:leftLensCenter] = left_lens_center
+        instance[:rightLensCenter] = right_lens_center
+        instance[:leftScreenCenter] = left_screen_center
+        instance[:rightScreenCenter] = right_screen_center
+        instance[:scale] = scale
+        instance[:scaleIn] = scale_in
+      end
+    end
+
+    def to_s
+      "Raylib::VrStereoConfig##{object_id} projection=#{projection} view_offset=#{view_offset} left_lens_center=#{left_lens_center} right_lens_center=#{right_lens_center} left_screen_center=#{left_screen_center} right_screen_center=#{right_screen_center} scale=#{scale} scale_in=#{scale_in}"
+    end
+
+    # VR projection matrices (per eye)
+    # @return [Matrix[2]] projection
+    def projection = self[:projection]
+
+    # Sets VR projection matrices (per eye)
+    def projection=(new_projection)
+      self[:projection] = new_projection
+    end
+
+    # VR view offset matrices (per eye)
+    # @return [Matrix[2]] viewOffset
+    def view_offset = self[:viewOffset]
+
+    # Sets VR view offset matrices (per eye)
+    def view_offset=(new_view_offset)
+      self[:viewOffset] = new_view_offset
+    end
+
+    # VR left lens center
+    # @return [float[2]] leftLensCenter
+    def left_lens_center = self[:leftLensCenter]
+
+    # Sets VR left lens center
+    def left_lens_center=(new_left_lens_center)
+      self[:leftLensCenter] = new_left_lens_center
+    end
+
+    # VR right lens center
+    # @return [float[2]] rightLensCenter
+    def right_lens_center = self[:rightLensCenter]
+
+    # Sets VR right lens center
+    def right_lens_center=(new_right_lens_center)
+      self[:rightLensCenter] = new_right_lens_center
+    end
+
+    # VR left screen center
+    # @return [float[2]] leftScreenCenter
+    def left_screen_center = self[:leftScreenCenter]
+
+    # Sets VR left screen center
+    def left_screen_center=(new_left_screen_center)
+      self[:leftScreenCenter] = new_left_screen_center
+    end
+
+    # VR right screen center
+    # @return [float[2]] rightScreenCenter
+    def right_screen_center = self[:rightScreenCenter]
+
+    # Sets VR right screen center
+    def right_screen_center=(new_right_screen_center)
+      self[:rightScreenCenter] = new_right_screen_center
+    end
+
+    # VR distortion scale
+    # @return [float[2]] scale
+    def scale = self[:scale]
+
+    # Sets VR distortion scale
+    def scale=(new_scale)
+      self[:scale] = new_scale
+    end
+
+    # VR distortion scale in
+    # @return [float[2]] scaleIn
+    def scale_in = self[:scaleIn]
+
+    # Sets VR distortion scale in
+    def scale_in=(new_scale_in)
+      self[:scaleIn] = new_scale_in
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Raylib
+  # Wave, audio wave data
+  class Wave < FFI::Struct
+    layout(
+      :frameCount, :uint, # Total number of frames (considering channels),
+      :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, ...),
+      :data, :pointer,    # Buffer data pointer
+    )
+
+    def self.create(frame_count, sample_rate, sample_size, channels, data)
+      new.tap do |instance|
+        instance[:frameCount] = frame_count
+        instance[:sampleRate] = sample_rate
+        instance[:sampleSize] = sample_size
+        instance[:channels] = channels
+        instance[:data] = data
+      end
+    end
+
+    def to_s
+      "Raylib::Wave##{object_id} frame_count=#{frame_count} sample_rate=#{sample_rate} sample_size=#{sample_size} channels=#{channels} data=#{data}"
+    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
+
+    # 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
+
+    # Buffer data pointer
+    # @return [void *] data
+    def data = self[:data]
+
+    # Sets Buffer data pointer
+    def data=(new_data)
+      self[:data] = new_data
+    end
+  end
+end

data/lib/raylib/core/structs.rb

@@ -0,0 +1,32 @@
+require 'raylib/core/structs/vector2'
+require 'raylib/core/structs/vector3'
+require 'raylib/core/structs/vector4'
+require 'raylib/core/structs/matrix'
+require 'raylib/core/structs/color'
+require 'raylib/core/structs/rectangle'
+require 'raylib/core/structs/image'
+require 'raylib/core/structs/texture'
+require 'raylib/core/structs/render_texture'
+require 'raylib/core/structs/n_patch_info'
+require 'raylib/core/structs/glyph_info'
+require 'raylib/core/structs/font'
+require 'raylib/core/structs/camera3_d'
+require 'raylib/core/structs/camera2_d'
+require 'raylib/core/structs/mesh'
+require 'raylib/core/structs/shader'
+require 'raylib/core/structs/material_map'
+require 'raylib/core/structs/material'
+require 'raylib/core/structs/transform'
+require 'raylib/core/structs/bone_info'
+require 'raylib/core/structs/model'
+require 'raylib/core/structs/model_animation'
+require 'raylib/core/structs/ray'
+require 'raylib/core/structs/ray_collision'
+require 'raylib/core/structs/bounding_box'
+require 'raylib/core/structs/wave'
+require 'raylib/core/structs/audio_stream'
+require 'raylib/core/structs/sound'
+require 'raylib/core/structs/music'
+require 'raylib/core/structs/vr_device_info'
+require 'raylib/core/structs/vr_stereo_config'
+require 'raylib/core/structs/file_path_list'

data/lib/raylib/core.rb

@@ -0,0 +1,5 @@
+require 'raylib/core/enums'
+require 'raylib/core/structs'
+require 'raylib/core/colors'
+require 'raylib/core/callbacks'
+require 'raylib/core/functions'

data/lib/raylib/dsl.rb

@@ -0,0 +1,2 @@
+require 'raylib'
+include Raylib

data/lib/raylib/raymath/functions.rb

@@ -0,0 +1,337 @@
+module Raylib
+  # Clamp float value
+  attach_function :clamp, :Clamp, [:float, :float, :float], :float
+
+  # Calculate linear interpolation between two floats
+  attach_function :lerp, :Lerp, [:float, :float, :float], :float
+
+  # Normalize input value within input range
+  attach_function :normalize, :Normalize, [:float, :float, :float], :float
+
+  # Remap input value within input range to output range
+  attach_function :remap, :Remap, [:float, :float, :float, :float, :float], :float
+
+  # Wrap input value from min to max
+  attach_function :wrap, :Wrap, [:float, :float, :float], :float
+
+  # Check whether two given floats are almost equal
+  attach_function :float_equals, :FloatEquals, [:float, :float], :int
+
+  # Vector with components value 0.0f
+  attach_function :vector2_zero, :Vector2Zero, [], Vector2.by_value
+
+  # Vector with components value 1.0f
+  attach_function :vector2_one, :Vector2One, [], Vector2.by_value
+
+  # Add two vectors (v1 + v2)
+  attach_function :vector2_add, :Vector2Add, [Vector2.by_value, Vector2.by_value], Vector2.by_value
+
+  # Add vector and float value
+  attach_function :vector2_add_value, :Vector2AddValue, [Vector2.by_value, :float], Vector2.by_value
+
+  # Subtract two vectors (v1 - v2)
+  attach_function :vector2_subtract, :Vector2Subtract, [Vector2.by_value, Vector2.by_value], Vector2.by_value
+
+  # Subtract vector by float value
+  attach_function :vector2_subtract_value, :Vector2SubtractValue, [Vector2.by_value, :float], Vector2.by_value
+
+  # Calculate vector length
+  attach_function :vector2_length, :Vector2Length, [Vector2.by_value], :float
+
+  # Calculate vector square length
+  attach_function :vector2_length_sqr, :Vector2LengthSqr, [Vector2.by_value], :float
+
+  # Calculate two vectors dot product
+  attach_function :vector2_dot_product, :Vector2DotProduct, [Vector2.by_value, Vector2.by_value], :float
+
+  # Calculate distance between two vectors
+  attach_function :vector2_distance, :Vector2Distance, [Vector2.by_value, Vector2.by_value], :float
+
+  # Calculate square distance between two vectors
+  attach_function :vector2_distance_sqr, :Vector2DistanceSqr, [Vector2.by_value, Vector2.by_value], :float
+
+  # Calculate angle between two vectors
+  attach_function :vector2_angle, :Vector2Angle, [Vector2.by_value, Vector2.by_value], :float
+
+  # Calculate angle defined by a two vectors line
+  attach_function :vector2_line_angle, :Vector2LineAngle, [Vector2.by_value, Vector2.by_value], :float
+
+  # Scale vector (multiply by value)
+  attach_function :vector2_scale, :Vector2Scale, [Vector2.by_value, :float], Vector2.by_value
+
+  # Multiply vector by vector
+  attach_function :vector2_multiply, :Vector2Multiply, [Vector2.by_value, Vector2.by_value], Vector2.by_value
+
+  # Negate vector
+  attach_function :vector2_negate, :Vector2Negate, [Vector2.by_value], Vector2.by_value
+
+  # Divide vector by vector
+  attach_function :vector2_divide, :Vector2Divide, [Vector2.by_value, Vector2.by_value], Vector2.by_value
+
+  # Normalize provided vector
+  attach_function :vector2_normalize, :Vector2Normalize, [Vector2.by_value], Vector2.by_value
+
+  # Transforms a Vector2 by a given Matrix
+  attach_function :vector2_transform, :Vector2Transform, [Vector2.by_value, Matrix.by_value], Vector2.by_value
+
+  # Calculate linear interpolation between two vectors
+  attach_function :vector2_lerp, :Vector2Lerp, [Vector2.by_value, Vector2.by_value, :float], Vector2.by_value
+
+  # Calculate reflected vector to normal
+  attach_function :vector2_reflect, :Vector2Reflect, [Vector2.by_value, Vector2.by_value], Vector2.by_value
+
+  # Rotate vector by angle
+  attach_function :vector2_rotate, :Vector2Rotate, [Vector2.by_value, :float], Vector2.by_value
+
+  # Move Vector towards target
+  attach_function :vector2_move_towards, :Vector2MoveTowards, [Vector2.by_value, Vector2.by_value, :float], Vector2.by_value
+
+  # Invert the given vector
+  attach_function :vector2_invert, :Vector2Invert, [Vector2.by_value], Vector2.by_value
+
+  # Clamp the components of the vector between min and max values specified by the given vectors
+  attach_function :vector2_clamp, :Vector2Clamp, [Vector2.by_value, Vector2.by_value, Vector2.by_value], Vector2.by_value
+
+  # Clamp the magnitude of the vector between two values
+  attach_function :vector2_clamp_value, :Vector2ClampValue, [Vector2.by_value, :float, :float], Vector2.by_value
+
+  # Check whether two given vectors are almost equal
+  attach_function :vector2_equals, :Vector2Equals, [Vector2.by_value, Vector2.by_value], :int
+
+  # Vector with components value 0.0f
+  attach_function :vector3_zero, :Vector3Zero, [], Vector3.by_value
+
+  # Vector with components value 1.0f
+  attach_function :vector3_one, :Vector3One, [], Vector3.by_value
+
+  # Add two vectors
+  attach_function :vector3_add, :Vector3Add, [Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Add vector and float value
+  attach_function :vector3_add_value, :Vector3AddValue, [Vector3.by_value, :float], Vector3.by_value
+
+  # Subtract two vectors
+  attach_function :vector3_subtract, :Vector3Subtract, [Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Subtract vector by float value
+  attach_function :vector3_subtract_value, :Vector3SubtractValue, [Vector3.by_value, :float], Vector3.by_value
+
+  # Multiply vector by scalar
+  attach_function :vector3_scale, :Vector3Scale, [Vector3.by_value, :float], Vector3.by_value
+
+  # Multiply vector by vector
+  attach_function :vector3_multiply, :Vector3Multiply, [Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Calculate two vectors cross product
+  attach_function :vector3_cross_product, :Vector3CrossProduct, [Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Calculate one vector perpendicular vector
+  attach_function :vector3_perpendicular, :Vector3Perpendicular, [Vector3.by_value], Vector3.by_value
+
+  # Calculate vector length
+  attach_function :vector3_length, :Vector3Length, [Vector3], :float
+
+  # Calculate vector square length
+  attach_function :vector3_length_sqr, :Vector3LengthSqr, [Vector3], :float
+
+  # Calculate two vectors dot product
+  attach_function :vector3_dot_product, :Vector3DotProduct, [Vector3.by_value, Vector3.by_value], :float
+
+  # Calculate distance between two vectors
+  attach_function :vector3_distance, :Vector3Distance, [Vector3.by_value, Vector3.by_value], :float
+
+  # Calculate square distance between two vectors
+  attach_function :vector3_distance_sqr, :Vector3DistanceSqr, [Vector3.by_value, Vector3.by_value], :float
+
+  # Calculate angle between two vectors
+  attach_function :vector3_angle, :Vector3Angle, [Vector3.by_value, Vector3.by_value], :float
+
+  # Negate provided vector (invert direction)
+  attach_function :vector3_negate, :Vector3Negate, [Vector3.by_value], Vector3.by_value
+
+  # Divide vector by vector
+  attach_function :vector3_divide, :Vector3Divide, [Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Normalize provided vector
+  attach_function :vector3_normalize, :Vector3Normalize, [Vector3.by_value], Vector3.by_value
+
+  # Orthonormalize provided vectors
+  attach_function :vector3_ortho_normalize, :Vector3OrthoNormalize, [:pointer, :pointer], :void
+
+  # Transforms a Vector3 by a given Matrix
+  attach_function :vector3_transform, :Vector3Transform, [Vector3.by_value, Matrix.by_value], Vector3.by_value
+
+  # Transform a vector by quaternion rotation
+  attach_function :vector3_rotate_by_quaternion, :Vector3RotateByQuaternion, [Vector3.by_value, Quaternion.by_value], Vector3.by_value
+
+  # Rotates a vector around an axis
+  attach_function :vector3_rotate_by_axis_angle, :Vector3RotateByAxisAngle, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value
+
+  # Calculate linear interpolation between two vectors
+  attach_function :vector3_lerp, :Vector3Lerp, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value
+
+  # Calculate reflected vector to normal
+  attach_function :vector3_reflect, :Vector3Reflect, [Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Get min value for each pair of components
+  attach_function :vector3_min, :Vector3Min, [Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Get max value for each pair of components
+  attach_function :vector3_max, :Vector3Max, [Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c)
+  attach_function :vector3_barycenter, :Vector3Barycenter, [Vector3.by_value, Vector3.by_value, Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Projects a Vector3 from screen space into object space
+  attach_function :vector3_unproject, :Vector3Unproject, [Vector3.by_value, Matrix.by_value, Matrix.by_value], Vector3.by_value
+
+  # Get Vector3 as float array
+  attach_function :vector3_to_float_v, :Vector3ToFloatV, [Vector3.by_value], Float3.by_value
+
+  # Invert the given vector
+  attach_function :vector3_invert, :Vector3Invert, [Vector3.by_value], Vector3.by_value
+
+  # Clamp the components of the vector between min and max values specified by the given vectors
+  attach_function :vector3_clamp, :Vector3Clamp, [Vector3.by_value, Vector3.by_value, Vector3.by_value], Vector3.by_value
+
+  # Clamp the magnitude of the vector between two values
+  attach_function :vector3_clamp_value, :Vector3ClampValue, [Vector3.by_value, :float, :float], Vector3.by_value
+
+  # Check whether two given vectors are almost equal
+  attach_function :vector3_equals, :Vector3Equals, [Vector3.by_value, Vector3.by_value], :int
+
+  # Compute the direction of a refracted ray where v specifies the normalized direction of the incoming ray, n specifies the normalized normal vector of the interface of two optical media, and r specifies the ratio of the refractive index of the medium from where the ray comes to the refractive index of the medium on the other side of the surface
+  attach_function :vector3_refract, :Vector3Refract, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value
+
+  # Compute matrix determinant
+  attach_function :matrix_determinant, :MatrixDeterminant, [Matrix.by_value], :float
+
+  # Get the trace of the matrix (sum of the values along the diagonal)
+  attach_function :matrix_trace, :MatrixTrace, [Matrix.by_value], :float
+
+  # Transposes provided matrix
+  attach_function :matrix_transpose, :MatrixTranspose, [Matrix.by_value], Matrix.by_value
+
+  # Invert provided matrix
+  attach_function :matrix_invert, :MatrixInvert, [Matrix.by_value], Matrix.by_value
+
+  # Get identity matrix
+  attach_function :matrix_identity, :MatrixIdentity, [], Matrix.by_value
+
+  # Add two matrices
+  attach_function :matrix_add, :MatrixAdd, [Matrix.by_value, Matrix.by_value], Matrix.by_value
+
+  # Subtract two matrices (left - right)
+  attach_function :matrix_subtract, :MatrixSubtract, [Matrix.by_value, Matrix.by_value], Matrix.by_value
+
+  # Get two matrix multiplication
+  attach_function :matrix_multiply, :MatrixMultiply, [Matrix.by_value, Matrix.by_value], Matrix.by_value
+
+  # Get translation matrix
+  attach_function :matrix_translate, :MatrixTranslate, [:float, :float, :float], Matrix.by_value
+
+  # Create rotation matrix from axis and angle
+  attach_function :matrix_rotate, :MatrixRotate, [Vector3.by_value, :float], Matrix.by_value
+
+  # Get x-rotation matrix
+  attach_function :matrix_rotate_x, :MatrixRotateX, [:float], Matrix.by_value
+
+  # Get y-rotation matrix
+  attach_function :matrix_rotate_y, :MatrixRotateY, [:float], Matrix.by_value
+
+  # Get z-rotation matrix
+  attach_function :matrix_rotate_z, :MatrixRotateZ, [:float], Matrix.by_value
+
+  # Get xyz-rotation matrix
+  attach_function :matrix_rotate_xyz, :MatrixRotateXYZ, [Vector3.by_value], Matrix.by_value
+
+  # Get zyx-rotation matrix
+  attach_function :matrix_rotate_zyx, :MatrixRotateZYX, [Vector3.by_value], Matrix.by_value
+
+  # Get scaling matrix
+  attach_function :matrix_scale, :MatrixScale, [:float, :float, :float], Matrix.by_value
+
+  # Get perspective projection matrix
+  attach_function :matrix_frustum, :MatrixFrustum, [:double, :double, :double, :double, :double, :double], Matrix.by_value
+
+  # Get perspective projection matrix
+  attach_function :matrix_perspective, :MatrixPerspective, [:double, :double, :double, :double], Matrix.by_value
+
+  # Get orthographic projection matrix
+  attach_function :matrix_ortho, :MatrixOrtho, [:double, :double, :double, :double, :double, :double], Matrix.by_value
+
+  # Get camera look-at matrix (view matrix)
+  attach_function :matrix_look_at, :MatrixLookAt, [Vector3.by_value, Vector3.by_value, Vector3.by_value], Matrix.by_value
+
+  # Get float array of matrix data
+  attach_function :matrix_to_float_v, :MatrixToFloatV, [Matrix.by_value], Float16.by_value
+
+  # Add two quaternions
+  attach_function :quaternion_add, :QuaternionAdd, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value
+
+  # Add quaternion and float value
+  attach_function :quaternion_add_value, :QuaternionAddValue, [Quaternion.by_value, :float], Quaternion.by_value
+
+  # Subtract two quaternions
+  attach_function :quaternion_subtract, :QuaternionSubtract, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value
+
+  # Subtract quaternion and float value
+  attach_function :quaternion_subtract_value, :QuaternionSubtractValue, [Quaternion.by_value, :float], Quaternion.by_value
+
+  # Get identity quaternion
+  attach_function :quaternion_identity, :QuaternionIdentity, [], Quaternion.by_value
+
+  # Computes the length of a quaternion
+  attach_function :quaternion_length, :QuaternionLength, [Quaternion.by_value], :float
+
+  # Normalize provided quaternion
+  attach_function :quaternion_normalize, :QuaternionNormalize, [Quaternion.by_value], Quaternion.by_value
+
+  # Invert provided quaternion
+  attach_function :quaternion_invert, :QuaternionInvert, [Quaternion.by_value], Quaternion.by_value
+
+  # Calculate two quaternion multiplication
+  attach_function :quaternion_multiply, :QuaternionMultiply, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value
+
+  # Scale quaternion by float value
+  attach_function :quaternion_scale, :QuaternionScale, [Quaternion.by_value, :float], Quaternion.by_value
+
+  # Divide two quaternions
+  attach_function :quaternion_divide, :QuaternionDivide, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value
+
+  # Calculate linear interpolation between two quaternions
+  attach_function :quaternion_lerp, :QuaternionLerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value
+
+  # Calculate slerp-optimized interpolation between two quaternions
+  attach_function :quaternion_nlerp, :QuaternionNlerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value
+
+  # Calculates spherical linear interpolation between two quaternions
+  attach_function :quaternion_slerp, :QuaternionSlerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value
+
+  # Calculate quaternion based on the rotation from one vector to another
+  attach_function :quaternion_from_vector3_to_vector3, :QuaternionFromVector3ToVector3, [Vector3.by_value, Vector3.by_value], Quaternion.by_value
+
+  # Get a quaternion for a given rotation matrix
+  attach_function :quaternion_from_matrix, :QuaternionFromMatrix, [Matrix.by_value], Quaternion.by_value
+
+  # Get a matrix for a given quaternion
+  attach_function :quaternion_to_matrix, :QuaternionToMatrix, [Quaternion.by_value], Matrix.by_value
+
+  # Get rotation quaternion for an angle and axis
+  attach_function :quaternion_from_axis_angle, :QuaternionFromAxisAngle, [Vector3.by_value, :float], Quaternion.by_value
+
+  # Get the rotation angle and axis for a given quaternion
+  attach_function :quaternion_to_axis_angle, :QuaternionToAxisAngle, [Quaternion.by_value, :pointer, :pointer], :void
+
+  # Get the quaternion equivalent to Euler angles
+  attach_function :quaternion_from_euler, :QuaternionFromEuler, [:float, :float, :float], Quaternion.by_value
+
+  # Get the Euler angles equivalent to quaternion (roll, pitch, yaw)
+  attach_function :quaternion_to_euler, :QuaternionToEuler, [Quaternion.by_value], Vector3.by_value
+
+  # Transform a quaternion given a transformation matrix
+  attach_function :quaternion_transform, :QuaternionTransform, [Quaternion.by_value, Matrix.by_value], Quaternion.by_value
+
+  # Check whether two given quaternions are almost equal
+  attach_function :quaternion_equals, :QuaternionEquals, [Quaternion.by_value, Quaternion.by_value], :int
+end