cglm 0.1.0

data/lib/cglm.rb

@@ -0,0 +1,26 @@
+require "cglm/version"
+
+class Numeric
+  def to_radians
+    self * Math::PI / 180.0
+  end
+
+  def to_degrees
+    self * 180.0 / Math::PI
+  end
+end
+
+module CGLM
+  require 'cglm/base'
+  require 'cglm/vector_type'
+  require 'cglm/aabb'
+  require 'cglm/vec3'
+  require 'cglm/vec4'
+  require 'cglm/mat3'
+  require 'cglm/mat4'
+  require 'cglm/quat'
+  require 'cglm/frustum'
+  require 'cglm/plane'
+end
+
+require "cglm/cglm"

data/lib/cglm/aabb.rb

@@ -0,0 +1,4 @@
+module CGLM
+  class AABB < Base
+  end
+end

data/lib/cglm/base.rb

@@ -0,0 +1,38 @@
+require 'fiddle'
+
+module CGLM
+  class Base
+    attr_accessor :addr
+    alias to_ptr addr
+
+    def initialize(addr: CGLM.alloc(self.class).tap { |ptr|
+      # Init malloc'd values to 0; there is a PR to fiddle for this, then we
+      # can delete this code. https://github.com/ruby/fiddle/pull/14
+      ptr[0, self.class.size] = "\x00".b * self.class.size
+    })
+      # Even if addr is present, but points to NULL, this is a problem that
+      # will lead to segfaults. If not present, `nil.to_i == 0`.
+      raise ArgumentError, 'BUG: object initialized without a backing store?' if addr.to_i == 0
+      self.addr = addr
+    end
+
+    def copy_to(other)
+      size = addr.size > other.addr.size ? other.addr.size : addr.size
+      other.addr[0, size] = addr[0, size]
+    end
+
+    def dup(other = nil)
+      if other
+        copy_to other
+      else
+        super()
+      end
+    end
+
+    def initialize_dup(other)
+      super
+      @addr = CGLM.alloc(self.class)
+      other.copy_to(self)
+    end
+  end
+end

data/lib/cglm/frustum.rb

@@ -0,0 +1,9 @@
+module CGLM
+  class Frustum
+    attr_accessor :matrix
+
+    def initialize(matrix = Mat4.identity)
+      @matrix = matrix
+    end
+  end
+end

data/lib/cglm/mat3.rb

@@ -0,0 +1,27 @@
+module CGLM
+  class Mat3 < Base
+    # Performs multiplication with `other` and returns the result.
+    #
+    # * `other` is a Mat3 or Vec3.
+    def *(other)
+      case other
+      when Mat3    then mul_mat3(other)
+      when Vec3    then mul_vec3(other)
+      when Numeric then mul_scalar(other)
+      else raise ArgumentError, "Don't know how to multiply Mat3 with object: #{other.inspect}"
+      end
+    end
+
+    def to_a
+      3.times.map { |i| self[i].to_a }
+    end
+
+    def inspect
+      vals = to_a
+      longest_val_size = vals.flatten.reduce(0) { |a, v| a < v.to_s.size ? v.to_s.size : a }
+      vals.map! { |row| row.map { |val| val.to_s.rjust(longest_val_size) }.join(', ') }
+      left = "#<#{self.class}@#{addr.to_i.to_s(16)} ["
+      left + vals.join(",\n" + (" " * left.size)) + "]>"
+    end
+  end
+end

data/lib/cglm/mat4.rb

@@ -0,0 +1,46 @@
+module CGLM
+  class Mat4 < Base
+    def initialize(initial_values = nil, **args)
+      super(**args)
+      case initial_values
+      when Mat3
+        initial_values.to_a.each_with_index { |row, i| self[i] = row }
+      when Mat4
+        addr[0, self.class.size] = initial_values.addr[0, self.class.size]
+      when Array
+        initial_values.each_with_index do |row, i|
+          self[i] = row
+        end
+      when nil
+      else
+        raise ArgumentError, 'initial values should be a Mat4, a Mat3 or an array of Array/Vec3/Vec4'
+      end
+    end
+
+    def to_a
+      4.times.map { |i| self[i].to_a }
+    end
+
+    def inspect
+      vals = to_a
+      longest_val_size = vals.flatten.reduce(0) { |a, v| a < v.to_s.size ? v.to_s.size : a }
+      vals.map! { |row| row.map { |val| val.to_s.rjust(longest_val_size) }.join(', ') }
+      left = "#<#{self.class}@#{addr.to_i.to_s(16)} ["
+      left + vals.join(",\n" + (" " * left.size)) + "]>"
+    end
+
+    # Performs multiplication with `other` and returns the result.
+    #
+    # * `other` is a Mat3 or Vec3.
+    def *(other)
+      case other
+      when Mat4    then mul_mat4(other)
+      when Mat3    then mul_mat3(other)
+      when Vec3    then mul_vec3(other)
+      when Vec4    then mul_vec4(other)
+      when Numeric then mul_scalar(other)
+      else raise ArgumentError, "Don't know how to multiply Mat4 with object: #{other.inspect}"
+      end
+    end
+  end
+end

data/lib/cglm/plane.rb

@@ -0,0 +1,9 @@
+module CGLM
+  class Plane < Vec4
+    # Returns a new Vec4 representing a plane with the given normal (a Vec3)
+    # and distance (a number).
+    def initialize(normal, distance)
+      super [*normal, distance]
+    end
+  end
+end

data/lib/cglm/quat.rb

@@ -0,0 +1,10 @@
+module CGLM
+  class Quat < Vec4
+    def *(other)
+      case other
+      when Quat then mul_quat(other)
+      else Quat.new(super)
+      end
+    end
+  end
+end

data/lib/cglm/sphere.rb

@@ -0,0 +1,11 @@
+module CGLM
+  # Sphere Representation in cglm: `[center.x, center.y, center.z, radius]`
+  #
+  # You could use this representation or you can convert it to Vec4 before
+  # calling any function.
+  class Sphere < Vec4
+    def radius
+      self[3]
+    end
+  end
+end

data/lib/cglm/vec3.rb

@@ -0,0 +1,88 @@
+module CGLM
+  class Vec3 < VectorType
+    def to_a
+      [self[0], self[1], self[2]]
+    end
+
+    def inspect
+      "#<#{self.class}@#{addr.to_i.to_s(16)} #{to_a.inspect}>"
+    end
+
+    def ==(other)
+      case other
+      when VectorType then equals_vec3(other)
+      when Numeric    then equals_scalar(other)
+      else false
+      end
+    end
+
+    # Returns true if the given value is very close to this Vec3. If `other`
+    # is a scalar (number), each component in this vector must be very close
+    # to the scalar. If it's a vector, it must be a Vec3 or Vec4 and each
+    # component of this Vec3 must be very close to the corresponding component
+    # of `other`. See #equalish_vec3 and #equalish_scalar.
+    def =~(other)
+      case other
+      when VectorType then equalish_vec3(other)
+      when Numeric    then equalish_scalar(other)
+      else false
+      end
+    end
+
+    def +(other)
+      case other
+      when VectorType then add_vec3(other)
+      when Numeric    then add_scalar(other)
+      else false
+      end
+    end
+
+    def -(other)
+      case other
+      when VectorType then sub_vec3(other)
+      when Numeric    then sub_scalar(other)
+      else false
+      end
+    end
+
+    def *(other)
+      case other
+      when VectorType then mul_vec3(other)
+      when Numeric    then mul_scalar(other)
+      else false
+      end
+    end
+
+    def /(other)
+      case other
+      when VectorType then div_vec3(other)
+      when Numeric    then div_scalar(other)
+      else false
+      end
+    end
+
+    def addadd(other, dest)
+      case other
+      when VectorType then addadd_vec3(other, dest)
+      when Numeric    then addadd_scalar(other, dest)
+      else false
+      end
+    end
+
+    def subadd(other, dest)
+      case other
+      when VectorType then subadd_vec3(other, dest)
+      when Numeric    then subadd_scalar(other, dest)
+      else false
+      end
+    end
+
+    def muladd(other, dest)
+      case other
+      when VectorType then muladd_vec3(other, dest)
+      when Numeric    then muladd_scalar(other, dest)
+      else false
+      end
+    end
+  end
+end

data/lib/cglm/vec4.rb

@@ -0,0 +1,104 @@
+module CGLM
+  class Vec4 < VectorType
+    def to_a
+      [self[0], self[1], self[2], self[3]]
+    end
+
+    def inspect
+      "#<#{self.class}@#{addr.to_i.to_s(16)} #{to_a.inspect}>"
+    end
+
+    def ==(other)
+      case other
+      when VectorType then equals_vec4(other)
+      when Numeric    then equals_scalar(other)
+      else false
+      end
+    end
+
+    # Returns true if the given value is very close to this Vec4. If `other`
+    # is a scalar (number), each component in this vector must be very close
+    # to the scalar. If it's a vector, it must be a Vec4 and each component
+    # of this Vec4 must be very close to the corresponding component of
+    # `other`. See #equalish_vec4 and #equalish_scalar.
+    def =~(other)
+      case other
+      when VectorType then equalish_vec4(other)
+      when Numeric    then equalish_scalar(other)
+      else false
+      end
+    end
+
+    def +(other)
+      case other
+      when VectorType then add_vec4(other)
+      when Numeric    then add_scalar(other)
+      else false
+      end
+    end
+
+    def -(other)
+      case other
+      when VectorType then sub_vec4(other)
+      when Numeric    then sub_scalar(other)
+      else false
+      end
+    end
+
+    def *(other)
+      case other
+      when VectorType then mul_vec4(other)
+      when Numeric    then mul_scalar(other)
+      else false
+      end
+    end
+
+    def /(other)
+      case other
+      when VectorType then div_vec4(other)
+      when Numeric    then div_scalar(other)
+      else false
+      end
+    end
+
+    def addadd(other, dest)
+      case other
+      when VectorType then addadd_vec4(other, dest)
+      when Numeric    then addadd_scalar(other, dest)
+      else false
+      end
+    end
+
+    def subadd(other, dest)
+      case other
+      when VectorType then subadd_vec4(other, dest)
+      when Numeric    then subadd_scalar(other, dest)
+      else false
+      end
+    end
+
+    def muladd(other, dest)
+      case other
+      when VectorType then muladd_vec4(other, dest)
+      when Numeric    then muladd_scalar(other, dest)
+      else false
+      end
+    end
+
+    def clamp(min, max, *extra)
+      case min
+      when VectorType then clamp_vec4(min, max, *extra)
+      when Numeric    then clamp_scalar(min, max, *extra)
+      else raise ArgumentError, 'need Vec4 or'
+      end
+    end
+
+    def clamp!(min, max)
+      case min
+      when VectorType then clamp_vec4!(min, max)
+      when Numeric    then clamp_scalar!(min, max)
+      else raise ArgumentError, 'need Vec4 or Scalar'
+      end
+    end
+  end
+end

data/lib/cglm/vector_type.rb

@@ -0,0 +1,17 @@
+module CGLM
+  class VectorType < Base
+    def initialize(initial = nil, **args)
+      super(**args)
+      case initial
+      when Array
+        initial.each_with_index { |v, i| self[i] = v; break if i >= 3 }
+      when Quat, Vec3, Vec4
+        size = initial.class.size > self.class.size ? self.class.size : initial.class.size
+        addr[0, size] = initial.addr[0, size]
+      when nil
+      else
+        raise ArgumentError, 'initial values must be an Array, Quat, Vec3 or Vec4'
+      end
+    end
+  end
+end

data/lib/cglm/version.rb

@@ -0,0 +1,3 @@
+module CGLM
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: cglm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Colin MacKenzie IV
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- sinisterchipmunk@gmail.com
+executables: []
+extensions:
+- ext/cglm/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cglm.gemspec
+- ext/cglm/extconf.rb
+- ext/cglm/rb_cglm.c
+- ext/cglm/rb_cglm.h
+- ext/cglm/rb_cglm_aabb.c
+- ext/cglm/rb_cglm_affine.c
+- ext/cglm/rb_cglm_cam.c
+- ext/cglm/rb_cglm_color.c
+- ext/cglm/rb_cglm_ease.c
+- ext/cglm/rb_cglm_euler.c
+- ext/cglm/rb_cglm_frustum.c
+- ext/cglm/rb_cglm_mat3.c
+- ext/cglm/rb_cglm_mat4.c
+- ext/cglm/rb_cglm_plane.c
+- ext/cglm/rb_cglm_project.c
+- ext/cglm/rb_cglm_quat.c
+- ext/cglm/rb_cglm_sphere.c
+- ext/cglm/rb_cglm_vec3.c
+- ext/cglm/rb_cglm_vec4.c
+- lib/cglm.rb
+- lib/cglm/aabb.rb
+- lib/cglm/base.rb
+- lib/cglm/frustum.rb
+- lib/cglm/mat3.rb
+- lib/cglm/mat4.rb
+- lib/cglm/plane.rb
+- lib/cglm/quat.rb
+- lib/cglm/sphere.rb
+- lib/cglm/vec3.rb
+- lib/cglm/vec4.rb
+- lib/cglm/vector_type.rb
+- lib/cglm/version.rb
+homepage: https://github.com/sinisterchipmunk/cglm-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/sinisterchipmunk/cglm-ruby
+  source_code_uri: https://github.com/sinisterchipmunk/cglm-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: CGLM bindings for Ruby
+test_files: []