assimp-ruby 1.0.0

data/lib/assimp/material_copier.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Assimp
+  class MaterialCopier
+    PROPERTY_FLOAT = 0x1
+    PROPERTY_DOUBLE = 0x2
+    PROPERTY_STRING = 0x3
+    PROPERTY_INTEGER = 0x4
+    PROPERTY_BUFFER = 0x5
+
+    TEXTURE_TYPES = {
+      diffuse: 1, specular: 2, ambient: 3, emissive: 4, height: 5, normals: 6,
+      shininess: 7, opacity: 8, displacement: 9, lightmap: 10, reflection: 11,
+      base_color: 12, normal_camera: 13, emission_color: 14, metalness: 15,
+      roughness: 16, ao: 17, unknown: 18, sheen: 19, clearcoat: 20, transmission: 21
+    }.freeze
+    WRAP_MODES = { 0 => :wrap, 1 => :clamp, 2 => :mirror, 3 => :decal }.freeze
+
+    def initialize(native: Native, embedded_textures: [])
+      @native = native
+      @embedded_texture_indices = embedded_texture_indices(embedded_textures)
+    end
+
+    def copy(pointer)
+      properties = copy_properties(pointer)
+      textures = copy_textures(pointer)
+      shininess = scalar(properties, "$mat.shininess")
+      Material.new(
+        name: properties.fetch(["?mat.name", 0, 0], ""),
+        base_color: color(properties, "$clr.base") || color(properties, "$clr.diffuse") || [1.0, 1.0, 1.0, 1.0],
+        metallic: scalar(properties, "$mat.metallicFactor") || texture_default(textures, :metalness, 0.0),
+        roughness: scalar(properties, "$mat.roughnessFactor") ||
+                   texture_default(textures, :roughness, roughness_from(shininess)),
+        shininess:,
+        opacity: scalar(properties, "$mat.opacity") || 1.0,
+        two_sided: (scalar(properties, "$mat.twosided") || 0).to_i != 0,
+        textures:,
+        properties:
+      )
+    end
+
+    private
+
+    def copy_properties(pointer)
+      material = Native::Material.new(pointer)
+      NativeReader.pointers(material[:properties], material[:num_properties]).each_with_object({}) do |property_pointer, result|
+        property = Native::MaterialProperty.new(property_pointer)
+        key = [property[:key].to_s.freeze, property[:semantic], property[:index]].freeze
+        result[key] = decode_property(property)
+      end.freeze
+    end
+
+    def decode_property(property)
+      pointer = property[:data]
+      length = property[:data_length]
+      case property[:type]
+      when PROPERTY_FLOAT then collapse(pointer.read_array_of_float(length / FFI.type_size(:float)))
+      when PROPERTY_DOUBLE then collapse(pointer.read_array_of_double(length / FFI.type_size(:double)))
+      when PROPERTY_STRING then Native::StringValue.new(pointer).to_s.freeze
+      when PROPERTY_INTEGER then collapse(pointer.read_array_of_int(length / FFI.type_size(:int)))
+      when PROPERTY_BUFFER then NativeReader.bytes(pointer, length)
+      else NativeReader.bytes(pointer, length)
+      end
+    end
+
+    def collapse(values)
+      return values.first if values.one?
+
+      values.freeze
+    end
+
+    def scalar(properties, key)
+      value = properties[[key, 0, 0]]
+      value.is_a?(Array) ? value.first : value
+    end
+
+    def color(properties, key)
+      value = properties[[key, 0, 0]]
+      return unless value
+
+      values = Array(value).map(&:to_f)
+      values << 1.0 if values.length == 3
+      values.first(4).freeze
+    end
+
+    def texture_default(textures, type, fallback)
+      textures.key?([type, 0]) ? 1.0 : fallback
+    end
+
+    def roughness_from(shininess)
+      return 1.0 unless shininess
+
+      Math.sqrt(2.0 / (shininess.to_f + 2.0)).clamp(0.0, 1.0)
+    end
+
+    def copy_textures(material_pointer)
+      TEXTURE_TYPES.each_with_object({}) do |(name, type), result|
+        @native.aiGetMaterialTextureCount(material_pointer, type).times do |index|
+          reference = copy_texture(material_pointer, type, index)
+          result[[name, index].freeze] = reference if reference
+        end
+      end.freeze
+    end
+
+    def copy_texture(material, type, index)
+      path = Native::StringValue.new
+      mapping = FFI::MemoryPointer.new(:int)
+      uv_index = FFI::MemoryPointer.new(:uint)
+      blend = FFI::MemoryPointer.new(:float)
+      operation = FFI::MemoryPointer.new(:int)
+      modes = FFI::MemoryPointer.new(:int, 2)
+      flags = FFI::MemoryPointer.new(:uint)
+      status = @native.aiGetMaterialTexture(
+        material, type, index, path, mapping, uv_index, blend, operation, modes, flags
+      )
+      return unless status.zero?
+
+      texture_path = path.to_s.freeze
+      TextureRef.new(
+        path: texture_path,
+        embedded_index: embedded_index(texture_path),
+        uv_index: uv_index.read_uint,
+        wrap: modes.read_array_of_int(2).map { |mode| WRAP_MODES.fetch(mode, :unknown) }.freeze
+      )
+    end
+
+    def embedded_texture_indices(textures)
+      textures.each_with_index.each_with_object({}) do |(texture, index), result|
+        next if texture.filename.empty?
+
+        normalized = texture.filename.tr("\\", "/")
+        result[texture.filename] = index
+        result[normalized] = index
+        result[File.basename(normalized)] = index
+      end.freeze
+    end
+
+    def embedded_index(path)
+      direct = /\A\*(\d+)\z/.match(path)
+      return Integer(direct[1]) if direct
+
+      normalized = path.tr("\\", "/")
+      @embedded_texture_indices[path] ||
+        @embedded_texture_indices[normalized] ||
+        @embedded_texture_indices[File.basename(normalized)]
+    end
+  end
+end

data/lib/assimp/math.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Assimp
+  Vec3 = Data.define(:x, :y, :z) do
+    def to_a
+      [x, y, z]
+    end
+  end
+
+  Quat = Data.define(:x, :y, :z, :w) do
+    def to_a
+      [x, y, z, w]
+    end
+  end
+
+  AABB = Data.define(:min, :max)
+
+  module Matrix
+    IDENTITY = [
+      1.0, 0.0, 0.0, 0.0,
+      0.0, 1.0, 0.0, 0.0,
+      0.0, 0.0, 1.0, 0.0,
+      0.0, 0.0, 0.0, 1.0
+    ].freeze
+
+    module_function
+
+    def multiply(left, right)
+      Array.new(16) do |offset|
+        column = offset / 4
+        row = offset % 4
+        4.times.sum { |index| left[(index * 4) + row] * right[(column * 4) + index] }
+      end.freeze
+    end
+  end
+end

data/lib/assimp/mesh.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Assimp
+  Bone = Data.define(:name, :offset_matrix, :weights)
+
+  class Mesh
+    attr_reader :name, :material_index, :primitive, :positions, :normals, :tangents,
+                :uv_sets, :colors, :indices, :bones, :vertex_count, :aabb
+
+    def initialize(name:, material_index:, primitive:, positions:, normals:, tangents:, uv_sets:,
+                   colors:, indices:, bones:, vertex_count:, aabb:)
+      @name = String(name).dup.freeze
+      @material_index = Integer(material_index)
+      @primitive = primitive.to_sym
+      @vertex_count = Integer(vertex_count)
+      @positions = packed(positions, @vertex_count * 12, :positions)
+      @normals = optional_packed(normals, @vertex_count * 12, :normals)
+      @tangents = optional_packed(tangents, @vertex_count * 16, :tangents)
+      @uv_sets = uv_sets.map.with_index { |data, index| packed(data, @vertex_count * 8, :"uv#{index}") }.freeze
+      @colors = optional_packed(colors, @vertex_count * 16, :colors)
+      @indices = packed_multiple(indices, 4, :indices)
+      @bones = bones.freeze
+      @aabb = aabb
+      freeze
+    end
+
+    def index_count
+      indices.bytesize / 4
+    end
+
+    private
+
+    def optional_packed(value, expected_size, field)
+      value && packed(value, expected_size, field)
+    end
+
+    def packed(value, expected_size, field)
+      data = String(value).dup.force_encoding(Encoding::BINARY).freeze
+      return data if data.bytesize == expected_size
+
+      raise ArgumentError, "#{field} has #{data.bytesize} bytes, expected #{expected_size}"
+    end
+
+    def packed_multiple(value, component_size, field)
+      data = String(value).dup.force_encoding(Encoding::BINARY).freeze
+      return data if (data.bytesize % component_size).zero?
+
+      raise ArgumentError, "#{field} byte size must be a multiple of #{component_size}"
+    end
+  end
+end

data/lib/assimp/mesh_copier.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Assimp
+  class MeshCopier
+    VECTOR_SIZE = Native::Vector3D.size
+    UV_BATCH_SIZE = 1024
+    PRIMITIVES = {
+      0x1 => :points,
+      0x2 => :lines,
+      0x4 => :triangles,
+      0x8 => :polygons
+    }.freeze
+
+    def initialize(native: Native)
+      @bone_type = native.version[1].zero? ? Native::LegacyBone : Native::Bone
+    end
+
+    def copy(pointer)
+      source = Native::Mesh.new(pointer)
+      vertex_count = source[:num_vertices]
+      positions = NativeReader.bytes(source[:vertices], VECTOR_SIZE * vertex_count)
+      normals = optional_vectors(source[:normals], vertex_count)
+
+      Mesh.new(
+        name: source[:name].to_s,
+        material_index: source[:material_index],
+        primitive: primitive(source[:primitive_types]),
+        positions:,
+        normals:,
+        tangents: copy_tangents(source, normals, vertex_count),
+        uv_sets: copy_uv_sets(source, vertex_count),
+        colors: optional_colors(source[:colors][0], vertex_count),
+        indices: copy_indices(source, vertex_count),
+        bones: copy_bones(source),
+        vertex_count:,
+        aabb: bounds(positions, vertex_count)
+      )
+    end
+
+    private
+
+    def optional_vectors(pointer, count)
+      return nil if pointer.null?
+
+      NativeReader.bytes(pointer, VECTOR_SIZE * count)
+    end
+
+    def optional_colors(pointer, count)
+      return nil if pointer.null?
+
+      NativeReader.bytes(pointer, Native::Color4D.size * count)
+    end
+
+    def primitive(flags)
+      geometry_flags = flags & 0x0f
+      return PRIMITIVES.fetch(geometry_flags) if PRIMITIVES.key?(geometry_flags)
+      return :unknown if geometry_flags.zero?
+
+      :mixed
+    end
+
+    def copy_uv_sets(source, vertex_count)
+      (0...8).filter_map do |set_index|
+        pointer = source[:texture_coords][set_index]
+        next if pointer.null?
+
+        extract_uv(pointer, vertex_count)
+      end
+    end
+
+    def extract_uv(pointer, vertex_count)
+      output = String.new(capacity: vertex_count * 8, encoding: Encoding::BINARY)
+      (0...vertex_count).step(UV_BATCH_SIZE) do |start|
+        count = [UV_BATCH_SIZE, vertex_count - start].min
+        values = pointer.get_array_of_float(start * VECTOR_SIZE, count * 3)
+        output << values.each_slice(3).flat_map { |x, y, _z| [x, y] }.pack("e*")
+      end
+      output.freeze
+    end
+
+    def copy_tangents(source, normals, vertex_count)
+      tangents = source[:tangents]
+      bitangents = source[:bitangents]
+      return nil if tangents.null? || bitangents.null?
+
+      normal_values = normals&.unpack("e*")
+      tangent_values = tangents.read_array_of_float(vertex_count * 3)
+      bitangent_values = bitangents.read_array_of_float(vertex_count * 3)
+      values = vertex_count.times.flat_map do |index|
+        offset = index * 3
+        tangent = tangent_values.slice(offset, 3)
+        normal = normal_values&.slice(offset, 3)
+        bitangent = bitangent_values.slice(offset, 3)
+        tangent << handedness(normal, tangent, bitangent)
+      end
+      values.pack("e*").freeze
+    end
+
+    def handedness(normal, tangent, bitangent)
+      return 1.0 unless normal
+
+      cross_x = (normal[1] * tangent[2]) - (normal[2] * tangent[1])
+      cross_y = (normal[2] * tangent[0]) - (normal[0] * tangent[2])
+      cross_z = (normal[0] * tangent[1]) - (normal[1] * tangent[0])
+      dot = (cross_x * bitangent[0]) + (cross_y * bitangent[1]) + (cross_z * bitangent[2])
+      dot.negative? ? -1.0 : 1.0
+    end
+
+    def copy_indices(source, vertex_count)
+      values = source[:num_faces].times.flat_map do |face_index|
+        face = NativeReader.struct_at(source[:faces], Native::Face, face_index)
+        indices = face[:indices].read_array_of_uint(face[:num_indices])
+        invalid = indices.find { |index| index >= vertex_count }
+        raise ImportError, "mesh face references vertex #{invalid}, but has #{vertex_count} vertices" if invalid
+
+        indices
+      end
+      values.pack("L<*").freeze
+    end
+
+    def copy_bones(source)
+      NativeReader.pointers(source[:bones], source[:num_bones]).map do |pointer|
+        bone = @bone_type.new(pointer)
+        weights = bone[:num_weights].times.map do |index|
+          weight = NativeReader.struct_at(bone[:weights], Native::VertexWeight, index)
+          [weight[:vertex_id], weight[:weight]].freeze
+        end.freeze
+        Bone.new(
+          name: bone[:name].to_s.freeze,
+          offset_matrix: bone[:offset_matrix].to_column_major.freeze,
+          weights:
+        )
+      end.freeze
+    end
+
+    def bounds(positions, vertex_count)
+      return AABB.new(min: Vec3.new(0.0, 0.0, 0.0), max: Vec3.new(0.0, 0.0, 0.0)) if vertex_count.zero?
+
+      minimum = [Float::INFINITY, Float::INFINITY, Float::INFINITY]
+      maximum = [-Float::INFINITY, -Float::INFINITY, -Float::INFINITY]
+      positions.unpack("e*").each_slice(3) do |values|
+        3.times do |axis|
+          minimum[axis] = values[axis] if values[axis] < minimum[axis]
+          maximum[axis] = values[axis] if values[axis] > maximum[axis]
+        end
+      end
+      AABB.new(min: Vec3.new(*minimum), max: Vec3.new(*maximum))
+    end
+  end
+end