assimp-ffi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2f350f15b0e5131cd2404dadc2a26aad6d818abf3eab0fb7766e47e99eef6cd
+  data.tar.gz: d28e89aefa90d07b6a0e04812d0590b7fd117ac5b3cc933920d549e0813b521c
+SHA512:
+  metadata.gz: f13d6c65bc8a7074c0e9b1b471d2667707ab14f20890bfb951e703bb77f2d17e4c765252884ff0ac2c226e72680bd47273d7715f1f13de2fe33f5a7b8b5c379c
+  data.tar.gz: 61796c36f6d41e14e116a1e3c5d831e2534175298ab7af5eeead0bf31dfb619253f154a62d0b14bb1403dd8aa3ba1f293a04079448a50e7f5d6371eaf4e23fd9

data/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2019, Brice Videau
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,2 @@
+# assimp-ruby
+Open Asset Import Library ruby bindings

data/assimp.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'assimp-ffi'
+  s.version = "0.1.0"
+  s.author = "Brice Videau"
+  s.email = "brice.videau@imag.fr"
+  s.homepage = "https://github.com/Kerilk/assimp-ruby"
+  s.summary = "Open Asset Import Library bindings"
+  s.description = "FFI bindings of Assimp (Open Asset Import Library bindings) for version 4.1.0 onward"
+  s.files = Dir['assimp.gemspec', 'LICENSE', 'README.md', 'lib/**/*']
+  s.has_rdoc = false
+  s.license = 'BSD-2-Clause'
+  s.required_ruby_version = '>= 2.1.0'
+  s.add_dependency 'ffi', '~> 1.9', '>=1.9.19'
+end

data/lib/assimp/anim.rb

@@ -0,0 +1,131 @@
+module Assimp
+
+  class VectorKey < FFI::Struct
+    extend StructAccessors
+    layout :time, :double,
+           :value, Vector3D
+    struct_attr_accessor :time,
+                         :value
+  end
+
+  class QuatKey < FFI::Struct
+    extend StructAccessors
+    layout :time, :double,
+           :value, Quaternion
+    struct_attr_accessor :time,
+                         :value
+  end
+
+  class MeshKey < FFI::Struct
+    extend StructAccessors
+    layout :time, :double,
+           :value, :uint
+    struct_attr_accessor :time,
+                         :value
+  end
+
+  class MeshMorphKey < FFI::Struct
+    extend StructAccessors
+    layout :time, :double,
+           :values, :pointer, #uint[num_values_and_weights]
+           :weights, :pointer, #double[num_values_and_weights]
+           :num_values_and_weights, :uint
+    struct_attr_accessor :time,
+                         :num_values_and_weights
+    struct_array_attr_accessor [:values, :uint, :num_values_and_weights],
+                               [:weights, :double, :num_values_and_weights]
+  end
+
+  AnimBehaviour = enum(:anim_behavior, [
+    :DEFAULT,
+    :CONSTANT,
+    :LINEAR,
+    :REPEAT
+  ])
+
+  class NodeAnim < FFI::Struct
+    extend StructAccessors
+    layout :node_name, String,
+           :num_position_keys, :uint,
+           :position_keys, :pointer, #VectorKey
+           :num_rotation_keys, :uint,
+           :rotation_keys, :pointer, #QuatKey
+           :num_scaling_keys, :uint,
+           :scaling_keys, :pointer, #VectorKey
+           :pre_state, AnimBehaviour,
+           :post_state, AnimBehaviour
+    struct_attr_accessor :node_name,
+                         :num_position_keys,
+                         :num_rotation_keys,
+                         :num_scaling_keys,
+                         :pre_state,
+                         :post_state
+
+    struct_array_attr_accessor [:position_keys, VectorKey],
+                               [:rotation_keys, QuatKey],
+                               [:scaling_keys, VectorKey]
+
+    def to_s
+      node_name
+    end
+
+  end
+
+  class MeshAnim < FFI::Struct
+    extend StructAccessors
+    layout :name, String,
+           :num_keys, :uint,
+           :keys, :pointer #MeshKey
+    struct_attr_accessor :name,
+                         :num_keys
+    struct_array_attr_accessor [:keys, MeshKey]
+
+    def to_s
+      name
+    end
+
+  end
+
+  class MeshMorphAnim < FFI::Struct
+    extend StructAccessors
+    layout :name, String,
+           :num_keys, :uint,
+           :keys, :pointer #MeshMorphKey
+    struct_attr_accessor :name,
+                         :num_keys
+    struct_array_attr_accessor [:keys, MeshMorphKey]
+
+    def to_s
+      name
+    end
+
+  end
+
+  class Animation < FFI::Struct
+    extend StructAccessors
+    layout :name, String,
+           :duration, :double,
+           :ticks_per_second, :double,
+           :num_channels, :uint,
+           :channels, :pointer, #NodeAnim*
+           :num_mesh_channels, :uint,
+           :mesh_channels, :pointer, #MeshAnim*
+           :num_morph_mesh_channels, :uint,
+           :morph_mesh_channels, :pointer #MeshMorphAnim*
+    struct_attr_accessor :name,
+                         :duration,
+                         :ticks_per_second,
+                         :num_channels,
+                         :num_mesh_channels,
+                         :num_morph_mesh_channels
+    struct_ref_array_attr_accessor [:channels, NodeAnim],
+                                   [:mesh_channels, MeshAnim],
+                                   [:morph_mesh_channels, MeshMorphAnim]
+
+    def to_s
+      name
+    end
+
+  end
+
+end

data/lib/assimp/base.rb

@@ -0,0 +1,197 @@
+module Assimp
+  extend FFI::Library
+  ffi_lib 'assimp'
+
+  class String < FFI::Struct
+  end
+
+  module StructAccessors
+
+    def self.extended(mod)
+      mod.instance_variable_set(:@__has_ref, false)
+    end
+
+    def has_ref?
+      @__has_ref
+    end
+
+    def struct_attr_reader(*args)
+      args.each { |attr|
+        raise "Invalid attribute #{attr.inspect}!" unless @layout.members.include?(attr)
+        if @layout[attr].type.kind_of?( FFI::StructByValue ) && @layout[attr].type.struct_class == Assimp::String
+          define_method(attr) { self[attr].data }
+        else
+          define_method(attr) { self[attr] }
+        end
+      }
+    end
+
+    def struct_attr_writer(*args)
+      args.each { |attr|
+        raise "Invalid attribute #{attr.inspect}!" unless @layout.members.include?(attr)
+        if @layout[attr].type.kind_of?( FFI::StructByValue ) && @layout[attr].type.struct_class == Assimp::String
+          define_method(attr.to_s+"=") { |o| self[attr].data = o }
+        elsif @layout[attr].type.kind_of?( FFI::StructByValue ) && @layout[attr].type.struct_class.has_ref?
+          @__has_ref = true
+          define_method(attr.to_s+"=") { |o| self.instance_variable_set(:"@#{attr}", o); self[attr] = o }
+        else
+          define_method(attr.to_s+"=") { |o| self[attr] = o }
+        end
+      }
+    end
+
+    def struct_attr_accessor(*args)
+      struct_attr_reader(*args)
+      struct_attr_writer(*args)
+    end
+
+    def struct_array_attr_reader(*args)
+      args.each { |attr, klass, count|
+        raise "Invalid attribute #{attr.inspect}!" unless @layout.members.include?(attr)
+        t = nil
+        s = nil
+        if klass.kind_of? Symbol
+          t = Assimp::find_type(klass)
+          s = t.size
+          define_method(attr) do
+            n = ( count ? self[count] : self[:"num_#{attr}"] )
+            p = self[attr]
+            if n == 0 || p.null?
+              []
+            else
+              n.times.collect { |i|
+                p.get(t, i*s) 
+              }
+            end
+          end
+        elsif klass.kind_of?(Class) && klass < FFI::Struct
+          s = klass.size
+          define_method(attr) do
+            n = ( count ? self[count] : self[:"num_#{attr}"] )
+            p = self[attr]
+            if n == 0 || p.null?
+              []
+            else
+              n.times.collect { |i|
+                klass.new(p+i*s)
+              }
+            end
+          end
+        else
+          raise "Invalid type: #{klass.inspect} for #{attr.inspect}!"
+        end
+      }
+    end
+
+    def struct_array_attr_writer(*args)
+      args.each { |attr, klass, count|
+        raise "Invalid attribute #{attr.inspect}!" unless @layout.members.include?(attr)
+        @__has_ref = true
+        t = nil
+        s = nil
+        if klass.kind_of? Symbol
+          t = Assimp::find_type(klass)
+          s = t.size
+          define_method(:"#{attr}=") do |values|
+            values = [] if values.nil?
+            if count
+              self[count] = values.length
+            else
+              self[:"num_#{attr}"] = values.length
+            end
+            ptr = (values.length == 0 ? nil : FFI::MemoryPointer::new(t, values.length))
+            values.each_with_index { |v, i|
+              ptr.put(t, i*s, v)
+            }
+            self.instance_variable_set(:"@#{attr}", ptr)
+            self[attr] = ptr
+            values
+          end
+        elsif klass.kind_of?(Class) && klass < FFI::Struct
+          s = klass.size
+          k = klass
+          define_method(:"#{attr}=") do |values|
+            values = [] if values.nil?
+            if count
+              self[count] = values.length
+            else
+              self[:"num_#{attr}"] = values.length
+            end
+            ptr = (values.length == 0 ? nil : FFI::MemoryPointer::new(klass, values.length))
+            values.each_with_index { |v, i|
+              ptr.put_array_of_uint8(i*s, v.pointer.read_array_of_uint8(s))
+            }
+            if k.has_ref?
+              self.instance_variable_set(:"@#{attr}", [ptr, values])
+            else
+              self.instance_variable_set(:"@#{attr}", ptr)
+            end
+            self[attr] = ptr
+            values
+          end
+        else
+          raise "Invalid type: #{klass.inspect} for #{attr.inspect}!"
+        end
+      }
+    end
+
+    def struct_array_attr_checker(*args)
+      args.each { |attr, klass, count|
+        raise "Invalid attribute #{attr.inspect}!" unless @layout.members.include?(attr)
+        define_method(:"#{attr}?") do
+          ! self[attr].null?
+        end
+      }
+    end
+
+    def struct_array_attr_accessor(*args)
+      struct_array_attr_reader(*args)
+      struct_array_attr_writer(*args)
+      struct_array_attr_checker(*args)
+    end
+
+    def struct_ref_array_attr_reader(*args)
+      args.each { |attr, klass, count|
+        raise "Invalid attribute #{attr.inspect}!" unless @layout.members.include?(attr)
+        define_method(attr) do
+          n = ( count ? self[count] : self[:"num_#{attr}"] )
+          p = self[attr]
+          if n == 0 || p.null?
+            []
+          else
+            ptrs = p.read_array_of_pointer(self[:"num_#{attr}"])
+            ptrs.collect { |ptr| ptr.null? ? nil : klass::new(ptr) }
+          end
+        end
+      }
+    end
+
+    def struct_ref_array_attr_writer(*args)
+      args.each { |attr, klass, count|
+        raise "Invalid attribute #{attr.inspect}!" unless @layout.members.include?(attr)
+        @__has_ref = true
+        define_method(:"#{attr}=") do |values|
+          values = [] if values.nil?
+          if count
+            self[count] = values.length
+          else
+            self[:"num_#{attr}"] = values.length
+          end
+          ptr = (values.length == 0 ? nil : FFI::MemoryPointer::new(:pointer, values.length))
+          ptr.write_array_of_pointer(values.collect(&:pointer)) if ptr
+          self.instance_variable_set(:"@#{attr}", [ptr, values.dup])
+          self[attr] = ptr
+          values
+        end
+      }
+    end
+
+    def struct_ref_array_attr_accessor(*args)
+      struct_ref_array_attr_reader(*args)
+      struct_ref_array_attr_writer(*args)
+      struct_array_attr_checker(*args)
+    end
+
+  end
+
+end

data/lib/assimp/camera.rb

@@ -0,0 +1,25 @@
+module Assimp
+
+  class Camera < FFI::Struct
+    extend StructAccessors
+    layout :name, String,
+           :position, Vector3D,
+           :up, Vector3D,
+           :look_at, Vector3D,
+           :horizontal_fov, :float,
+           :clip_plane_near, :float,
+           :aspect, :float
+    struct_attr_accessor :name,
+                         :position,
+                         :up,
+                         :look_at,
+                         :horizontal_fov,
+                         :clip_plane_near,
+                         :aspect
+    def to_s
+      name
+    end
+
+  end
+
+end

data/lib/assimp/color4.rb

@@ -0,0 +1,24 @@
+module Assimp
+
+  class Color4D < FFI::Struct
+    extend StructAccessors
+    layout :r, :ai_real,
+           :g, :ai_real,
+           :b, :ai_real,
+           :a, :ai_real
+    struct_attr_accessor :r, :g, :b, :a
+
+    def set(r, g, b, a)
+      self.r = r
+      self.g = g
+      self.b = b
+      self.a = a
+      self
+    end
+
+    def to_s
+      "[#{r}, #{g}, #{b}, #{a}]"
+    end
+  end
+
+end

data/lib/assimp/config.rb

@@ -0,0 +1,34 @@
+module Assimp
+
+  Components = bitmask(:components, [
+    :NORMALS, 1,
+    :TANGENTS_AND_BITANGENTS,
+    :COLORS,
+    :TEXCOORDS,
+    :BONEWEIGHTS,
+    :ANIMATIONS,
+    :TEXTURES,
+    :LIGHTS,
+    :CAMERAS,
+    :MESHES,
+    :MATERIALS,
+    :COLORS0, 20,
+    :COLORS1,
+    :COLORS2,
+    :COLORS3,
+    :COLORS4,
+    :TEXCOORDS0, 25,
+    :TEXCOORDS1,
+    :TEXCOORDS2,
+    :TEXCOORDS3,
+    :TEXCOORDS4,
+    :TEXCOORDS5,
+    :TEXCOORDS6,
+  ])
+
+  UVTRAFO_SCALING = 0x1
+  UVTRAFO_ROTATION = 0x2
+  UVTRAFO_TRANSLATION = 0x4
+  UVTRAFO_ALL = UVTRAFO_SCALING | UVTRAFO_ROTATION | UVTRAFO_TRANSLATION
+
+end

data/lib/assimp/defs.rb

@@ -0,0 +1,25 @@
+module Assimp
+
+  if ENV["ASSIMP_DOUBLE_PRECISION"]
+    typedef :double, :ai_real
+    typedef :long_long, :ai_int
+    typedef :ulong_long, :ai_uint
+  else
+    typedef :float, :ai_real
+    typedef :int, :ai_int
+    typedef :uint, :ai_uint
+  end
+
+  MATH_PI = 3.141592653589793238462643383279
+  MATH_TWO_PI = MATH_PI * 2.0
+  MATH_HALF_PI = MATH_PI * 0.5
+
+  def deg_to_rad(x)
+    x * 0.0174532925
+  end
+
+  def rad_to_deg(x)
+    x * 57.2957795
+  end
+
+end

data/lib/assimp/export.rb

@@ -0,0 +1,58 @@
+module Assimp
+
+  class ExportFormatDesc < FFI::ManagedStruct
+    extend StructAccessors
+    layout :id, :string,
+           :description, :string,
+           :file_extension, :string
+    struct_attr_reader :id,
+                       :description,
+                       :file_extension
+
+    def self.release(ptr)
+      Assimp::aiReleaseExportFormatDescription(ptr)
+    end
+
+  end
+
+  attach_function :aiGetExportFormatCount, [], :size_t
+  attach_function :aiGetExportFormatDescription, [:size_t], ExportFormatDesc.ptr
+  attach_function :aiReleaseExportFormatDescription, [ExportFormatDesc.ptr], :void
+
+  def self.export_format_descriptions
+    count = Assimp::aiGetExportFormatCount
+    count.times.collect { |i|
+      Assimp::aiGetExportFormatDescription(i)
+    }
+  end
+
+  attach_function :aiCopyScene, [Scene.ptr, :pointer], :void
+  attach_function :aiFreeScene, [Scene.ptr], :void
+  attach_function :aiExportScene, [Scene.ptr, :string, :string, PostProcessSteps], Return
+  attach_function :aiExportSceneEx, [Scene.ptr, :string, :string, FileIO.ptr, PostProcessSteps], Return
+
+  class ExportDataBlob < FFI::Struct
+    extend StructAccessors
+    layout :size, :size_t,
+           :data, :pointer,
+           :name, String,
+           :next, ExportDataBlob.ptr
+    struct_attr_reader :size,
+                       :data,
+                       :name,
+                       :next
+    
+    def to_s
+      name
+    end
+
+    def self.releaser(ptr)
+      Assimp::aiReleaseExportBlob(ptr)
+    end
+
+  end
+
+  attach_function :aiExportSceneToBlob, [Scene.ptr, :string, PostProcessSteps], :pointer #ExportDataBlob.ptr
+  attach_function :aiReleaseExportBlob, [ExportDataBlob.ptr], :void
+
+end

data/lib/assimp/fileio.rb

@@ -0,0 +1,48 @@
+module Assimp
+
+  class FileIO < FFI::Struct
+  end
+
+  class File < FFI::Struct
+  end
+
+  callback :file_write_proc, [File.ptr, :string, :size_t, :size_t], :size_t
+  callback :file_read_proc, [File.ptr, :string, :size_t, :size_t], :size_t
+  callback :file_tell_proc, [File.ptr], :size_t
+  callback :file_flush_proc, [File.ptr], :void
+  callback :file_seek, [File.ptr, :size_t, Origin], Return
+
+  callback :file_open_proc, [FileIO.ptr, :string, :string], File.ptr
+  callback :file_close_proc, [FileIO.ptr, File.ptr], :void
+
+  typedef :pointer, :user_data #byte
+
+  class FileIO
+    extend StructAccessors
+    layout :open_proc, :file_open_proc,
+           :close_proc, :file_close_proc,
+           :user_data, :user_data
+    struct_attr_accessor :open_proc,
+                         :close_proc
+    struct_attr_reader :user_data
+  end
+
+  class File
+    extend StructAccessors
+    layout :read_proc, :file_read_proc,
+           :write_proc, :file_write_proc,
+           :tell_proc, :file_tell_proc,
+           :file_size_proc, :file_tell_proc,
+           :seek_proc, :file_seek,
+           :flush_proc, :file_flush_proc,
+           :user_data, :user_data
+    struct_attr_accessor :read_proc,
+                         :write_proc,
+                         :tell_proc,
+                         :file_size_proc,
+                         :seek_proc,
+                         :flush_proc
+    struct_attr_reader :user_data
+  end
+
+end