cglm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: da66e89ef19c691d7411dfb2ced1dd6d840767d85b0d886f21e291c9082f454a
+  data.tar.gz: 621578f7a74416574e6b39265780eeefe4913bb1e396e8382646cf1f1fc99cf6
+SHA512:
+  metadata.gz: 7a9ef4ac1b5d70e37009cc916fe0e29d63d6a41fc7cb62d60786f54996202a5449f46dfb4604b737f6ff5676ba12ec4ea734a15de0f0134eeccfe6512aacaeaf
+  data.tar.gz: cd4dc6182bdb554f06a44d4a4448a06e56945c31b81f79a4219c8fcb4a08d7eb59a00b6f6760501736ebf1f480d55f4b9fbe8a31ab032aa8e259490fd62bd483

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/ext/cglm/cglm-*
+/ext/cglm/cglm-*.tar.gz
+.DS_Store

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.0
+before_install: gem install bundler -v 1.17.1

data/.yardopts

@@ -0,0 +1,2 @@
+--markup=markdown
+--markup-provider=redcarpet

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in cglm.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    cglm (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    docile (1.3.1)
+    github-markup (3.0.1)
+    json (2.1.0)
+    minitest (5.11.3)
+    rake (10.5.0)
+    rake-compiler (1.0.5)
+      rake
+    redcarpet (3.4.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    yard (0.9.16)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  cglm!
+  github-markup
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  rake-compiler
+  redcarpet
+  simplecov
+  yard (~> 0.9)
+
+BUNDLED WITH
+   1.17.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Colin MacKenzie IV
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+# CGLM
+
+Ruby bindings for [CGLM](https://github.com/recp/cglm), a high performance math library for OpenGL.
+
+[CGLM](https://github.com/recp/cglm) provides support for SIMD on CPUs that support it in order to deliver better performance. This requires the variables to be aligned to 8-, 16- and 32-byte boundaries, but this gem automatically handles this requirement so you don't have to think about that.
+
+[CGLM](https://github.com/recp/cglm) sports the following features:
+
+* general purpose matrix operations (mat4, mat3)
+* general purpose vector operations (cross, dot, rotate, proj, angle...)
+* affine transforms
+* matrix decomposition (extract rotation, scaling factor)
+* optimized affine transform matrices (mul, rigid-body inverse)
+* camera (lookat)
+* projections (ortho, perspective)
+* quaternions
+* euler angles / yaw-pitch-roll to matrix
+* extract euler angles
+* frustum (extract view frustum planes, corners...)
+* bounding box (AABB in Frustum (culling), crop, merge...)
+* project, unproject
+
+(Note: A few other features are available in the original C library, such as optional in-lining of all functions, which don't really translate to Ruby gems -- although such features are used by the code for the gem itself.)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cglm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cglm
+
+## Usage
+
+Include the `CGLM` module, or use the classes it defines directly:
+
+```ruby
+include CGLM
+
+a = Vec3.new
+b = Vec3.new([1, 0, 0])
+
+proj = Mat4.perspective(fovy: Math::PI / 4, aspect: 640.0 / 480.0)
+view = Mat4.rotate(Vec3.new([0, 1, 0], PI_4)
+model = Mat4.translate(Vec3.new([34, 57, 36]))
+
+mvp = proj * view * model
+```
+
+This gem provides two basic variants for almost every operation. Let's use `Vec3#add` as an example. You can use the intuitive syntax:
+
+```ruby
+result = a + b
+```
+
+This will work just fine, returning a new `Vec3`. Or, in performance-critical situations, you may wish to directly specify a destination to place the result in:
+
+```ruby
+result = Vec3.new
+loop do
+  # avoid allocating a new Vec3 by reusing result
+  a.add(b, result)
+end
+```
+
+The second syntax is perhaps a little less intuitive, but avoids creation of extra objects (because you specify them yourself), so you can more easily control your memory and garbage collection costs.
+
+There are too many methods to list here, so you are encouraged to check out the [project documentation](https://www.rubydoc.info/github/sinisterchipmunk/cglm-ruby).
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sinisterchipmunk/cglm-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("cglm") do |ext|
+  ext.lib_dir = "lib/cglm"
+end
+
+task :default => [:clobber, :compile, :test]
+
+require 'yard'
+desc 'generate documentation'
+YARD::Rake::YardocTask.new(:doc)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cglm"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cglm.gemspec

@@ -0,0 +1,46 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cglm/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cglm"
+  spec.version       = CGLM::VERSION
+  spec.authors       = ["Colin MacKenzie IV"]
+  spec.email         = ["sinisterchipmunk@gmail.com"]
+
+  spec.summary       = %q{CGLM bindings for Ruby}
+  spec.homepage      = "https://github.com/sinisterchipmunk/cglm-ruby"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/sinisterchipmunk/cglm-ruby"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/cglm/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "yard", "~> 0.9"
+  spec.add_development_dependency 'redcarpet'
+  spec.add_development_dependency 'github-markup'
+  spec.add_development_dependency 'simplecov'
+end

data/ext/cglm/extconf.rb

@@ -0,0 +1,50 @@
+require "mkmf"
+require 'fileutils'
+require 'rubygems/package'
+require 'zlib'
+
+#CGLM_VERSION = '0.5.0'
+CGLM_VERSION = '89f64f079477b1af15f47e6b96db52c767acb057'
+cglm_source_url = "https://github.com/recp/cglm/archive/#{CGLM_VERSION}.tar.gz"
+cglm_tar_gz = File.expand_path("cglm-#{CGLM_VERSION}.tar.gz", __dir__)
+cglm_dir = File.expand_path("cglm-#{CGLM_VERSION}", __dir__)
+
+# fetch cglm unless it's already on the file system
+unless File.exist?(cglm_dir)
+  require 'open-uri'
+  # save tarfile
+  open(cglm_tar_gz, 'wb') do |file|
+    file << open(cglm_source_url, 'rb').read
+  end
+
+  # extract tarfile
+  FileUtils.rm_rf cglm_dir if File.directory?(cglm_dir)
+  FileUtils.mkdir_p cglm_dir
+  tar_extract = Gem::Package::TarReader.new(Zlib::GzipReader.open(cglm_tar_gz))
+  tar_extract.rewind # The extract has to be rewinded after every iteration
+  tar_extract.each do |entry|
+    full_path = File.expand_path(entry.full_name, __dir__)
+    if entry.directory?
+      FileUtils.mkdir_p full_path
+    else
+      FileUtils.mkdir_p File.dirname(full_path)
+      File.open(full_path, 'wb') { |file| file << entry.read }
+    end
+  end
+  tar_extract.close
+end
+
+$INCFLAGS << " -I#{cglm_dir}/include"
+
+require 'fiddle'
+%w(
+  SIZEOF_VOIDP SIZEOF_CHAR SIZEOF_SHORT SIZEOF_INT SIZEOF_LONG SIZEOF_LONG_LONG
+  SIZEOF_FLOAT SIZEOF_DOUBLE SIZEOF_SIZE_T SIZEOF_SSIZE_T SIZEOF_PTRDIFF_T
+  SIZEOF_INTPTR_T SIZEOF_UINTPTR_T
+).each do |const_name|
+  if Fiddle.constants.include?(const_name.to_sym)
+    $CFLAGS << " -DHAVE_#{const_name}=1 -D#{const_name}=#{Fiddle.const_get(const_name.to_sym)}"
+  end
+end
+
+create_makefile("cglm/cglm")

data/ext/cglm/rb_cglm.c

@@ -0,0 +1,79 @@
+#include "rb_cglm.h"
+
+VALUE rb_cFiddle     = Qnil,
+      rb_cPointer    = Qnil,
+      rb_mCGLM       = Qnil,
+      rb_cCGLMBase   = Qnil,
+      rb_cVectorType = Qnil,
+      rb_cMat3       = Qnil,
+      rb_cMat4       = Qnil,
+      rb_cVec3       = Qnil,
+      rb_cVec4       = Qnil,
+      rb_cAABB       = Qnil,
+      rb_mEuler      = Qnil,
+      rb_cQuat       = Qnil,
+      rb_cFrustum    = Qnil,
+      rb_cSphere     = Qnil,
+      rb_cPlane      = Qnil;
+
+VALUE rb_cglm_alloc_type(VALUE self, VALUE klass) {
+  VALUE rsize  = rb_funcall(klass, rb_intern("size"), 0);
+  VALUE ralign = rb_funcall(klass, rb_intern("alignment"), 0);
+  size_t size  = NUM2SIZET(rsize);
+  size_t align = NUM2SIZET(ralign);
+  void *addr = ALIGNED_ALLOC(align, size);
+  if (!addr)
+    rb_raise(rb_eRuntimeError, "could not allocate %zu bytes with %zu alignment", size, align);
+  return rb_funcall(rb_cPointer, rb_intern("new"), 2, PTR2NUM(addr), rsize);
+}
+
+void Init_cglm(void) {
+  rb_cFiddle     = rb_const_get(rb_cObject, rb_intern("Fiddle"));
+  rb_cPointer    = rb_const_get(rb_cFiddle, rb_intern("Pointer"));
+  rb_mCGLM       = rb_define_module("CGLM");
+  rb_mEuler      = rb_define_module_under(rb_mCGLM, "Euler");
+  rb_cCGLMBase   = rb_define_class_under(rb_mCGLM, "Base",       rb_cObject);
+  rb_cMat3       = rb_define_class_under(rb_mCGLM, "Mat3",       rb_cCGLMBase);
+  rb_cMat4       = rb_define_class_under(rb_mCGLM, "Mat4",       rb_cCGLMBase);
+  rb_cCGLMBase   = rb_define_class_under(rb_mCGLM, "Base",       rb_cObject);
+  rb_cVectorType = rb_define_class_under(rb_mCGLM, "VectorType", rb_cCGLMBase);
+  rb_cAABB       = rb_define_class_under(rb_mCGLM, "AABB",       rb_cCGLMBase);
+  rb_cVec3       = rb_define_class_under(rb_mCGLM, "Vec3",       rb_cVectorType);
+  rb_cVec4       = rb_define_class_under(rb_mCGLM, "Vec4",       rb_cVectorType);
+  rb_cFrustum    = rb_define_class_under(rb_mCGLM, "Frustum",    rb_cObject);
+  rb_cSphere     = rb_define_class_under(rb_mCGLM, "Sphere",     rb_cVec4);
+  rb_cQuat       = rb_define_class_under(rb_mCGLM, "Quat",       rb_cVec4);
+  rb_cPlane      = rb_define_class_under(rb_mCGLM, "Plane",      rb_cVec4);
+
+  rb_define_const(rb_mCGLM, "E" ,              DBL2NUM(GLM_E));
+  rb_define_const(rb_mCGLM, "LOG2E",           DBL2NUM(GLM_LOG2E));
+  rb_define_const(rb_mCGLM, "LOG10E",          DBL2NUM(GLM_LOG10E));
+  rb_define_const(rb_mCGLM, "LN2",             DBL2NUM(GLM_LN2));
+  rb_define_const(rb_mCGLM, "LN10",            DBL2NUM(GLM_LN10));
+  rb_define_const(rb_mCGLM, "PI",              DBL2NUM(GLM_PI));
+  rb_define_const(rb_mCGLM, "PI_2",            DBL2NUM(GLM_PI_2));
+  rb_define_const(rb_mCGLM, "PI_4",            DBL2NUM(GLM_PI_4));
+  rb_define_const(rb_mCGLM, "ONE_OVER_PI",     DBL2NUM(GLM_1_PI));
+  rb_define_const(rb_mCGLM, "TWO_OVER_PI",     DBL2NUM(GLM_2_PI));
+  rb_define_const(rb_mCGLM, "TWO_OVER_SQRTPI", DBL2NUM(GLM_2_SQRTPI));
+  rb_define_const(rb_mCGLM, "SQRT2",           DBL2NUM(GLM_SQRT2));
+  rb_define_const(rb_mCGLM, "SQRT1_2",         DBL2NUM(GLM_SQRT1_2));
+
+  rb_define_singleton_method(rb_mCGLM, "alloc", rb_cglm_alloc_type, 1);
+
+  Init_cglm_affine();
+  Init_cglm_box();
+  Init_cglm_cam();
+  Init_cglm_color();
+  Init_cglm_ease();
+  Init_cglm_euler();
+  Init_cglm_frustum();
+  Init_cglm_mat3();
+  Init_cglm_mat4();
+  Init_cglm_plane();
+  Init_cglm_project();
+  Init_cglm_quat();
+  Init_cglm_sphere();
+  Init_cglm_vec3();
+  Init_cglm_vec4();
+}

data/ext/cglm/rb_cglm.h

@@ -0,0 +1,169 @@
+#ifndef RB_CGLM_H
+#define RB_CGLM_H 1
+
+#include "ruby.h"
+#include <errno.h>
+
+// Based on unit test results I think the FLT_EPSILON that is used for fuzzy
+// equality by CGLM may be too strict. This HACK works around the issue.
+#include <float.h>
+#undef FLT_EPSILON
+#define FLT_EPSILON 0.00001
+
+#include "cglm/cglm.h"
+
+#ifdef __MINGW32__
+#include <stdlib.h>
+#include <intrin.h>
+#include <malloc.h>
+#include <winsock2.h>
+#include <windows.h>
+#define drand48() (((double)rand()) / RAND_MAX)
+#endif // __MINGW32__
+#undef GLM_VEC3_ONE_INIT
+#undef GLM_VEC3_ZERO_INIT
+#undef GLM_VEC3_ONE
+#undef GLM_VEC3_ZERO
+#undef GLM_YUP
+#undef GLM_ZUP
+#undef GLM_XUP
+#undef GLM_VEC4_ONE
+#undef GLM_VEC4_BLACK
+#undef GLM_VEC4_ZERO
+#define GLM_VEC3_ONE_INIT   {1.0f, 1.0f, 1.0f}
+#define GLM_VEC3_ZERO_INIT  {0.0f, 0.0f, 0.0f}
+#define GLM_VEC3_ONE  GLM_VEC3_ONE_INIT
+#define GLM_VEC3_ZERO GLM_VEC3_ZERO_INIT
+#define GLM_YUP  {0.0f, 1.0f, 0.0f}
+#define GLM_ZUP  {0.0f, 0.0f, 1.0f}
+#define GLM_XUP  {1.0f, 0.0f, 0.0f}
+#define GLM_VEC4_ONE        GLM_VEC4_ONE_INIT
+#define GLM_VEC4_BLACK      GLM_VEC4_BLACK_INIT
+#define GLM_VEC4_ZERO       GLM_VEC4_ZERO_INIT
+
+#if SIZEOF_VOIDP == SIZEOF_LONG
+# define PTR2NUM(x)   (LONG2NUM((long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+#else
+# define PTR2NUM(x)   (LL2NUM((LONG_LONG)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULL(x)))
+#endif
+
+#define CHECK_RANGE(val, min, max)  \
+        if (NUM2INT(val) < min || NUM2INT(val) > max) \
+          rb_raise(rb_eRangeError, "index %d out of bounds (%d..%d)", NUM2INT(val), min, max);
+
+void Init_cglm_affine();
+void Init_cglm_box();
+void Init_cglm_cam();
+void Init_cglm_color();
+void Init_cglm_ease();
+void Init_cglm_euler();
+void Init_cglm_frustum();
+void Init_cglm_io();
+void Init_cglm_mat3();
+void Init_cglm_mat4();
+void Init_cglm_plane();
+void Init_cglm_project();
+void Init_cglm_quat();
+void Init_cglm_sphere();
+void Init_cglm_vec3();
+void Init_cglm_vec4();
+
+#define VEC3_ALIGNMENT  8
+#define VEC4_ALIGNMENT 16
+#define AABB_ALIGNMENT  8
+#define QUAT_ALIGNMENT 16
+#ifdef __AVX__
+#define MAT4_ALIGNMENT 32
+#define MAT3_ALIGNMENT 32
+#else
+#define MAT4_ALIGNMENT 16
+#define MAT3_ALIGNMENT 16
+#endif
+#define PLANE_ALIGNMENT VEC4_ALIGNMENT
+
+extern VALUE rb_cFiddle, rb_cPointer, rb_mCGLM, rb_cCGLMBase, rb_cVectorType,
+             rb_cMat4, rb_cVec3, rb_cVec4, rb_cAABB, rb_mEuler, rb_cQuat,
+             rb_cFrustum, rb_cMat3, rb_cSphere, rb_cPlane;
+
+typedef struct { vec3 corners[2]; } aabb;
+typedef struct { vec4 planes[6];  } frustum;
+typedef vec4 quat;
+typedef vec4 plane;
+
+static inline size_t vec3_size()  { return sizeof(vec3);  }
+static inline size_t vec4_size()  { return sizeof(vec4);  }
+static inline size_t aabb_size()  { return sizeof(aabb);  }
+static inline size_t mat4_size()  { return sizeof(mat4);  }
+static inline size_t mat3_size()  { return sizeof(mat4);  }
+static inline size_t quat_size()  { return sizeof(mat4);  }
+static inline size_t plane_size() { return sizeof(plane); }
+
+#define PTR2FIDDLE(addr, size) rb_funcall(rb_cPointer, rb_intern("new"), 2, PTR2NUM(addr), SIZET2NUM(size))
+
+static inline VALUE CGLM_NEW(VALUE klass, size_t size, void *addr) {
+  VALUE kw = rb_hash_new();
+  VALUE ptr = PTR2FIDDLE(addr, size);
+  rb_hash_aset(kw, ID2SYM(rb_intern("addr")), ptr);
+  return rb_funcall(klass, rb_intern("new"), 1, kw);
+}
+
+static inline void *__aligned_alloc(size_t align, size_t size) {
+  void *mem = NULL;
+#ifdef __MINGW32__
+  mem = _aligned_malloc(size, align);
+  int err = 0;
+  if (!mem) err = ENOMEM;
+#else
+  int err = posix_memalign(&mem, align, size);
+#endif
+  switch(err) {
+    case EINVAL:
+      rb_raise(rb_eRuntimeError, "Alignment %zu was not a power of two, or was not a multiple of sizeof(void *) == %zu", align, sizeof(void *));
+    case ENOMEM:
+      rb_raise(rb_eRuntimeError, "Insufficient memory");
+  }
+  return mem;
+}
+
+#define ALIGNED_ALLOC(align, size) __aligned_alloc(align, size)
+
+#define VEC3_NEW(addr)  CGLM_NEW(rb_cVec3,  vec3_size(),  addr)
+#define VEC4_NEW(addr)  CGLM_NEW(rb_cVec4,  vec4_size(),  addr)
+#define MAT4_NEW(addr)  CGLM_NEW(rb_cMat4,  mat4_size(),  addr)
+#define MAT3_NEW(addr)  CGLM_NEW(rb_cMat3,  mat3_size(),  addr)
+#define AABB_NEW(addr)  CGLM_NEW(rb_cAABB,  aabb_size(),  addr)
+#define QUAT_NEW(addr)  CGLM_NEW(rb_cQuat,  quat_size(),  addr)
+#define PLANE_NEW(addr) CGLM_NEW(rb_cPlane, plane_size(), addr);
+
+#define ALLOC_VEC3  ALIGNED_ALLOC(VEC3_ALIGNMENT,  sizeof(vec3))
+#define ALLOC_VEC4  ALIGNED_ALLOC(VEC4_ALIGNMENT,  sizeof(vec4))
+#define ALLOC_AABB  ALIGNED_ALLOC(AABB_ALIGNMENT,  sizeof(aabb))
+#define ALLOC_QUAT  ALIGNED_ALLOC(QUAT_ALIGNMENT,  sizeof(quat))
+#define ALLOC_MAT4  ALIGNED_ALLOC(MAT4_ALIGNMENT,  sizeof(mat4))
+#define ALLOC_MAT3  ALIGNED_ALLOC(MAT3_ALIGNMENT,  sizeof(mat3))
+#define ALLOC_PLANE ALIGNED_ALLOC(PLANE_ALIGNMENT, sizeof(plane))
+
+// #define VAL2ADDR(val) NUM2PTR(rb_funcall(rb_ivar_get(val, rb_intern("@addr")), rb_intern("to_i"), 0))
+
+static inline void *VAL2ADDR(VALUE val, size_t min_size) {
+  VALUE addr = rb_funcall(val, rb_intern("addr"), 0);
+  VALUE size = rb_funcall(addr, rb_intern("size"), 0);
+  if (min_size > NUM2SIZET(size))
+    rb_raise(rb_eArgError, "memory store (size %zu) is not large enough to be converted into the requested type (size %zu)", NUM2SIZET(size), min_size);
+  return NUM2PTR(rb_funcall(addr, rb_intern("to_i"), 0));
+}
+
+#define VAL2VEC3(val)    (*((vec3    *)(VAL2ADDR(val, sizeof(vec3)    ))))
+#define VAL2VEC4(val)    (*((vec4    *)(VAL2ADDR(val, sizeof(vec4)    ))))
+#define VAL2MAT4(val)    (*((mat4    *)(VAL2ADDR(val, sizeof(mat4)    ))))
+#define VAL2MAT3(val)    (*((mat3    *)(VAL2ADDR(val, sizeof(mat3)    ))))
+#define VAL2AABB(val)    (*((aabb    *)(VAL2ADDR(val, sizeof(aabb)    ))))
+#define VAL2QUAT(val)    (*((quat    *)(VAL2ADDR(val, sizeof(quat)    ))))
+#define VAL2FRUSTUM(val) (*((frustum *)(VAL2ADDR(val, sizeof(frustum) ))))
+#define VAL2PLANE(val)   (*((plane   *)(VAL2ADDR(val, sizeof(plane)   ))))
+
+#define NUM2FLT(val) ((float) NUM2DBL(val))
+
+#endif /* CGLM_H */