assimp-ffi 0.1.0

data/lib/assimp/mesh.rb

@@ -0,0 +1,250 @@
+module Assimp
+
+  MAX_FACE_INDICES = 0x7fff
+  MAX_BONE_WEIGHTS = 0x7fffffff
+  MAX_VERTICES = 0x7fffffff
+  MAX_FACES = 0x7fffffff
+  MAX_NUMBER_OF_COLOR_SETS = 0x8
+  MAX_NUMBER_OF_TEXTURECOORDS = 0x8
+
+  class Face < FFI::Struct
+    extend StructAccessors
+    layout :num_indices, :uint,
+           :indices, :pointer #:uint[num_indices]
+
+    struct_attr_accessor :num_indices
+
+    struct_array_attr_accessor [:indices, :uint]
+
+  end
+
+  class VertexWeight < FFI::Struct
+    extend StructAccessors
+
+    layout :vertex_id, :uint,
+           :weight, :float
+
+    struct_attr_accessor :vertex_id,
+                         :weight
+  end
+
+  class Bone < FFI::Struct
+    extend StructAccessors
+
+    layout :name, String,
+           :num_weights, :uint,
+           :weights, :pointer, #VertexWeight[num_weights]
+           :offset_matrix, Matrix4x4
+
+    struct_attr_accessor :name,
+                         :num_weights,
+                         :offset_matrix
+
+    struct_array_attr_accessor [:weights, VertexWeight]
+
+  end
+
+  PrimitiveType = bitmask(:primitive_type, [
+    :POINT,
+    :LINE,
+    :TRIANGLE,
+    :POLYGON
+  ])
+
+  class AnimMesh < FFI::Struct
+    extend StructAccessors
+
+    layout :vertices, :pointer, #Vector3D[]
+           :normals, :pointer, #Vector3D[]
+           :tangents, :pointer, #Vector3D[]
+           :bitangents, :pointer, #Vector3D[]
+           :colors, [:pointer, MAX_NUMBER_OF_COLOR_SETS], #Color4D[num_vertices]
+           :texture_coords, [:pointer, MAX_NUMBER_OF_TEXTURECOORDS], #Vector3D[num_vertices]
+           :num_vertices, :uint,
+           :weight, :float
+
+    struct_attr_accessor :num_vertices,
+                         :weight
+
+    struct_array_attr_accessor [:vertices, Vector3D],
+                               [:normals, Vector3D, :num_vertices],
+                               [:tangents, Vector3D, :num_vertices],
+                               [:bitangents, Vector3D, :num_vertices]
+
+    def colors
+      cs = self[:colors].to_a
+      cs.collect { |c_ptr|
+        if c_ptr.null?
+          nil
+        else
+          s = Color4D.size
+          num_vertices.times.collect { |i|
+            Color4D::new(c_ptr+i*s)
+          }
+        end
+      }
+    end
+
+    def set_colors(index, colors)
+      @colors = [nil]*MAX_NUMBER_OF_COLOR_SETS unless @colors
+      raise "Invalid colors index #{index}!" if index < 0 || index >= MAX_NUMBER_OF_COLOR_SETS
+      unless colors && colors.length > 0
+        @colors[index] = nil
+        return self
+      end
+      raise "Invalid colors count: #{colors.length}!" if num_vertices != colors.length
+      ptr = FFI::MemoryPointer::new(Assimp::Color4D, num_vertices)
+      s = Assimp::Color4D.size
+      colors.each_with_index { |v, i|
+        ptr.put_array_of_uint8(i*s, v.pointer.read_array_of_uint8(s))
+      }
+      @colors[index] = ptr
+      self
+    end
+
+    def texture_coords
+      tcs = self[:texture_coords].to_a
+      tcs.collect { |tc_ptr|
+        if tc_ptr.null?
+          nil
+        else
+          s = Vector3D.size
+          num_vertices.times.collect { |i|
+            Vector3D::new(tc_ptr+i*s)
+          }
+        end
+      }
+    end
+
+    def set_texture_coords(index, uvs)
+      @texture_coords = [nil]*MAX_NUMBER_OF_TEXTURECOORDS unless @texture_coords
+      raise "Invalid texture_coords index #{index}!" if index < 0 || index >= MAX_NUMBER_OF_TEXTURECOORDS
+      unless uvs && uvs.length > 0
+        @texture_coords[index] = nil
+        return self
+      end
+      raise "Invalid texture_coords count: #{uvs.length}!" if num_vertices != uvs.length
+      ptr = FFI::MemoryPointer::new(Assimp::Vector3D, num_vertices)
+      s = Assimp::Vector3D.size
+      uvs.each_with_index { |v, i|
+        ptr.put_array_of_uint8(i*s, v.pointer.read_array_of_uint8(s))
+      }
+      @texture_coords[index] = ptr
+      self
+    end
+
+  end
+
+  MorphingMethod = enum(:morphing_method, [
+    :VERTEX_BLEND, 1,
+    :MORPH_NORMALIZED, 2,
+    :MORPH_RELATIVE, 3
+  ])
+
+  class Mesh < FFI::Struct
+    extend StructAccessors
+
+    layout :primitive_types, PrimitiveType,
+           :num_vertices, :uint,
+           :num_faces, :uint,
+           :vertices, :pointer, #Vector3D[num_vertices]
+           :normals, :pointer, #Vector3D[num_vertices]
+           :tangents, :pointer, #Vector3D[num_vertices]
+           :bitangents, :pointer, #Vector3D[num_vertices]
+           :colors, [:pointer, MAX_NUMBER_OF_COLOR_SETS], #Color4D[num_vertices]
+           :texture_coords, [:pointer, MAX_NUMBER_OF_TEXTURECOORDS], #Vector3D[num_vertices]
+           :num_uv_components, [:uint, MAX_NUMBER_OF_TEXTURECOORDS],
+           :faces, :pointer, #Face[num_faces]
+           :num_bones, :uint,
+           :bones, :pointer, #Bone*[num_bones]
+           :material_index, :uint,
+           :name, String,
+           :num_anim_meshes, :uint,
+           :anim_meshes, :pointer, #AnimMesh*[num_anim_meshes]
+           :method, MorphingMethod
+
+    struct_attr_accessor :name,
+                         :primitive_types,
+                         :num_vertices,
+                         :num_faces,
+                         :num_uv_components,
+                         :num_bones,
+                         :material_index,
+                         :num_anim_meshes,
+                         :method
+
+    struct_array_attr_accessor [:vertices, Vector3D],
+                               [:normals, Vector3D, :num_vertices],
+                               [:tangents, Vector3D, :num_vertices],
+                               [:bitangents, Vector3D, :num_vertices],
+                               [:faces, Face]
+
+    struct_ref_array_attr_accessor [:bones, Bone],
+                                   [:anim_meshes, AnimMesh]
+
+    def colors
+      cs = self[:colors].to_a
+      cs.collect { |c_ptr|
+        if c_ptr.null?
+          nil
+        else
+          s = Color4D.size
+          num_vertices.times.collect { |i|
+            Color4D::new(c_ptr+i*s)
+          }
+        end
+      }
+    end
+
+    def set_colors(index, colors)
+      @colors = [nil]*MAX_NUMBER_OF_COLOR_SETS unless @colors
+      raise "Invalid colors index #{index}!" if index < 0 || index >= MAX_NUMBER_OF_COLOR_SETS
+      unless colors && colors.length > 0
+        @colors[index] = nil
+        return self
+      end
+      raise "Invalid colors count: #{colors.length}!" if num_vertices != colors.length
+      ptr = FFI::MemoryPointer::new(Assimp::Color4D, num_vertices)
+      s = Assimp::Color4D.size
+      colors.each_with_index { |v, i|
+        ptr.put_array_of_uint8(i*s, v.pointer.read_array_of_uint8(s))
+      }
+      @colors[index] = ptr
+      self[:colors][index] = ptr
+      self
+    end
+
+    def texture_coords
+      tcs = self[:texture_coords].to_a
+      tcs.collect { |tc_ptr|
+        if tc_ptr.null?
+          nil
+        else
+          s = Vector3D.size
+          num_vertices.times.collect { |i|
+            Vector3D::new(tc_ptr+i*s)
+          }
+        end
+      }
+    end
+
+    def set_texture_coords(index, uvs)
+      @texture_coords = [nil]*MAX_NUMBER_OF_TEXTURECOORDS unless @texture_coords
+      raise "Invalid texture_coords index #{index}!" if index < 0 || index >= MAX_NUMBER_OF_TEXTURECOORDS
+      unless uvs && uvs.length > 0
+        @texture_coords[index] = nil
+        return self
+      end
+      raise "Invalid texture_coords count: #{uvs.length}!" if num_vertices != uvs.length
+      ptr = FFI::MemoryPointer::new(Assimp::Vector3D, num_vertices)
+      s = Assimp::Vector3D.size
+      uvs.each_with_index { |v, i|
+        ptr.put_array_of_uint8(i*s, v.pointer.read_array_of_uint8(s))
+      }
+      @texture_coords[index] = ptr
+      self[:texture_coords][index] = ptr
+      self
+    end
+
+  end
+end

data/lib/assimp/metadata.rb

@@ -0,0 +1,53 @@
+module Assimp
+
+  MetadataType = enum(:metadata_type, [
+    :BOOL,
+    :INT32,
+    :UINT64,
+    :FLOAT,
+    :DOUBLE,
+    :AISTRING,
+    :AIVECTOR3D
+  ])
+
+  class MetadataEntry < FFI::Struct
+    extend StructAccessors
+    layout :type, MetadataType,
+           :data, :pointer
+    struct_attr_accessor :type
+
+    def data
+      d = self[:data]
+      case type
+      when :BOOL
+        d.read_uint != 0
+      when :INT32
+        d.read_int
+      when :UINT64
+        d.read(find_type(:uint64))
+      when :FLOAT
+        d.read_float
+      when :DOUBLE
+        d.read_double
+      when :AISTRING
+        s = d.read_uint
+        self[:data].get_string(4, s)
+      when :AIVECTOR3D
+        Vector3D::new(d)
+      else
+        raise "Unknown MetadataType : #{type}!"
+      end
+    end
+  end
+
+  class Metadata < FFI::Struct
+    extend StructAccessors
+    layout :num_properties, :uint,
+           :keys, :pointer, #String[num_properties]
+           :values, :pointer #MetadataEntry[num_properties]
+    struct_attr_accessor :num_properties
+    struct_array_attr_accessor [:values, MetadataEntry, :num_properties],
+                               [:keys, String, :num_properties]
+  end
+
+end

data/lib/assimp/postprocess.rb

@@ -0,0 +1,81 @@
+module Assimp
+
+  PostProcessSteps = bitmask(:post_process_steps, [
+    :CalcTangentSpace,
+    :JoinIdenticalVertices,
+    :MakeLeftHanded,
+    :Triangulate,
+    :RemoveComponent,
+    :GenNormals,
+    :GenSmoothNormals,
+    :SplitLargeMeshes,
+    :PreTransformVertices,
+    :LimitBoneWeights,
+    :ValidateDataStructure,
+    :ImproveCacheLocality,
+    :RemoveRedundantMaterials,
+    :FixInfacingNormals,
+    :SortByPType, 15,
+    :FindDegenerates,
+    :FindInvalidData,
+    :GenUVCoords,
+    :TransformUVCoords,
+    :FindInstances,
+    :OptimizeMeshes,
+    :OptimizeGraph,
+    :FlipUVs,
+    :FlipWindingOrder,
+    :SplitByBoneCount,
+    :Debone,
+    :GlobalScale
+  ])
+
+  ProcessPreset_ConvertToLeftHanded = Assimp::PostProcessSteps[
+    :MakeLeftHanded,
+    :FlipUVs,
+    :FlipWindingOrder
+  ]
+
+  ProcessPreset_TargetRealtime_Fast = Assimp::PostProcessSteps[
+    :CalcTangentSpace,
+    :GenNormals,
+    :JoinIdenticalVertices,
+    :Triangulate,
+    :GenUVCoords,
+    :SortByPType 
+  ]
+
+  ProcessPreset_TargetRealtime_Quality = Assimp::PostProcessSteps[
+    :CalcTangentSpace,
+    :GenSmoothNormals,
+    :JoinIdenticalVertices,
+    :ImproveCacheLocality,
+    :LimitBoneWeights,
+    :RemoveRedundantMaterials,
+    :SplitLargeMeshes,
+    :Triangulate,
+    :GenUVCoords,
+    :SortByPType,
+    :FindDegenerates,
+    :FindInvalidData
+  ]
+
+  ProcessPreset_TargetRealtime_MaxQuality = Assimp::PostProcessSteps[
+    :CalcTangentSpace,
+    :GenSmoothNormals,
+    :JoinIdenticalVertices,
+    :ImproveCacheLocality,
+    :LimitBoneWeights,
+    :RemoveRedundantMaterials,
+    :SplitLargeMeshes,
+    :Triangulate,
+    :GenUVCoords,
+    :SortByPType,
+    :FindDegenerates,
+    :FindInvalidData,
+    :FindInstances,
+    :ValidateDataStructure,
+    :OptimizeMeshes
+  ]
+ 
+end

data/lib/assimp/quaternion.rb

@@ -0,0 +1,47 @@
+module Assimp
+
+  class Quaternion < FFI::Struct
+    extend StructAccessors
+    layout :w, :ai_real,
+           :x, :ai_real,
+           :y, :ai_real,
+           :z, :ai_real
+    struct_attr_accessor :w, :x, :y, :z
+
+    def to_s
+      "{#{w}, #{x}, #{y}, #{z}}"
+    end
+
+    def conjugate
+      q = Quaternion::new
+      q.w = w
+      q.x = -x
+      q.y = -y
+      q.z = -z
+      q
+    end
+
+    def *(other)
+      if other.kind_of?(Quaternion)
+        q = Quaternion::new
+        q.w = w*other.w - x*other.x - y*other.y - z*other.z
+        q.x = w*other.x + x*other.w + y*other.z - z*other.y
+        q.y = w*other.y + y*other.w + z*other.x - x*other.z
+        q.z = w*other.z + z*other.w + x*other.y - y*other.x
+        q
+      elsif other.kind_of?(Vector3D)
+        v = Vector3D::new
+        q2 = Quaternion::new
+        q2.x = other.x
+        q2.y = other.y
+        q2.z = other.z
+        r = self * q2 * conjugate
+        v.set(r.x, r.y, r.z)
+      else
+        "Unsupported operand: #{other.inspect}!"
+      end
+    end
+
+  end
+
+end

data/lib/assimp/scene.rb

@@ -0,0 +1,168 @@
+module Assimp
+
+  class Node < FFI::Struct
+    extend StructAccessors
+
+    layout :name, String,
+           :transformation, Matrix4x4,
+           :parent, :pointer, #Node or null,
+           :num_children, :uint,
+           :children, :pointer, #Node*[num_chidren]
+           :num_meshes, :uint,
+           :meshes, :pointer, #uint[num_meshes]
+           :meta_data, :pointer #Metadata.ptr
+
+    struct_attr_accessor :name,
+                         :transformation,
+                         :num_children,
+                         :num_meshes
+
+    struct_ref_array_attr_accessor [:children, Node]
+
+    struct_array_attr_accessor [:meshes, :uint]
+
+    def parent
+      ptr = self[:parent]
+      return nil if ptr.null?
+      Node::new(ptr)
+    end
+
+    def parent=(other)
+      if other.kind_of? FFI::Pointer
+        self[:parent] = other
+      elsif other.kind_of? Node
+        self[:parent] = other.pointer
+      else
+        raise ArgumentError::new("Argument should be a Node!")
+      end
+      other
+    end
+
+    def each_node(&block)
+      if block then
+        block.call self
+        children.each { |c|
+          c.each_node(&block)
+        }
+        return self
+      else
+        to_enum(:each_node)
+      end
+    end
+
+    def meta_data
+      p = self[:meta_data]
+      return nil if p.null?
+      Metadata::new(p)
+    end
+
+  end
+
+  SceneFlags = bitmask(:scene_flags, [
+    :INCOMPLETE,
+    :VALIDATED,
+    :VALIDATION_WARNING,
+    :NON_VERBOSE_FORMAT,
+    :FLAGS_TERRAIN,
+    :FLAGS_ALLOW_SHARED
+  ])
+
+  class Scene < FFI::ManagedStruct
+    extend StructAccessors
+
+    layout :flags, SceneFlags,
+           :root_node, Node.ptr,
+           :num_meshes, :uint,
+           :meshes, :pointer, #Mesh*[num_meshes]
+           :num_materials, :uint,
+           :materials, :pointer, #Material*[num_materials]
+           :num_animations, :uint,
+           :animations, :pointer, #Animation*[num_animations]
+           :num_textures, :uint,
+           :textures, :pointer, #Texture*[num_textures]
+           :num_lights, :uint,
+           :lights, :pointer, #Light*[num_lights]
+           :num_cameras, :uint,
+           :cameras, :pointer, #Camera*[num_cameras]
+           :private, :pointer #void * really...
+
+    struct_attr_accessor :flags,
+                         :root_node,
+                         :num_meshes,
+                         :num_materials,
+                         :num_animations,
+                         :num_textures,
+                         :num_lights,
+                         :num_cameras,
+                         :private
+
+    struct_ref_array_attr_accessor [:meshes, Mesh],
+                                   [:materials, Material],
+                                   [:animations, Animation],
+                                   [:textures, Texture],
+                                   [:lights, Light],
+                                   [:cameras, Camera]
+
+    def self.inherited(klass)
+      klass.instance_variable_set(:@layout, @layout)
+    end
+
+    def self.release(ptr)
+      Assimp::aiReleaseImport(ptr)
+    end
+
+    def each_node(&block)
+      if block then
+        node = root_node
+        node.each_node(&block)
+        return self
+      else
+        to_enum(:each_obj)
+      end
+    end
+
+    def apply_post_processing(steps)
+      ptr = Assimp::aiApplyPostProcessing(self, steps)
+      raise "Post processing failed!" if ptr.null?
+      self
+    end
+
+    def memory_requirements
+      m = Assimp::MemoryInfo::new
+      Assimp::aiGetMemoryRequirements(self, m)
+      m
+    end
+
+    def copy
+      m = FFI::MemoryPointer::new(:pointer)
+      Assimp::aiCopyScene(self, m)
+      ptr = m.read_pointer
+      raise "Could not copy scene: #{Assimp::LogStream::error_string}" if ptr.null?
+      Assimp::SceneCopy::new(ptr)
+    end
+
+    def export(format_id, file_name, preprocessing: 0, io: nil)
+      if io
+        Assimp::aiExportSceneEx(self, format_id, file_name, io, preprocessing)
+      else
+        Assimp::aiExportScene(self, format_id, file_name, preprocessing)
+      end
+    end
+
+    def export_to_blob(format_id, preprocessing: 0)
+      ptr = Assimp::aiExportSceneToBlob(self, format_id, preprocessing)
+      raise "Could not export scene: #{Assimp::LogStream::error_string}" if ptr.null?
+      Assimp::ExportDataBlob::new(FFI::AutoPointer::new(ptr, Assimp::ExportDataBlob::method(:releaser)))
+    end
+
+  end
+
+  class SceneCopy < Scene
+
+    def self.release(ptr)
+      Assimp::aiFreeScene(ptr)
+    end
+
+  end
+
+end

data/lib/assimp/texture.rb

@@ -0,0 +1,31 @@
+module Assimp
+
+  class Texel < FFI::Struct
+    extend StructAccessors
+    pack 1
+    layout :b, :uchar,
+           :g, :uchar,
+           :r, :uchar,
+           :a, :uchar
+    struct_attr_accessor :b, :g, :r, :a
+    def to_s
+      "[#{r}, #{g}, #{b}, #{a}]"
+    end
+  end
+
+  class Texture < FFI::Struct
+    extend StructAccessors
+    layout :width, :uint,
+           :height, :uint,
+           :format_hint, [:char, 9],
+           :data, :pointer #Texel[width*height]
+    struct_attr_accessor :width,
+                         :height
+
+    def format_hint
+      self[:format_hint].to_a.pack("U*")
+    end
+
+  end
+
+end