riggle 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10165b0961011c1131d41f088a51b4651cc45f0e0b43856f9ddbfa8d0eb1ec0a
-  data.tar.gz: c45457d6149866e9df109cd34e1c1818ce3e498ab7317e899474fcbabcd1f31e
+  metadata.gz: 4362a3d5e336c120434204e5c9fed8cf5f265c038d8c561dd305c8771c117f4c
+  data.tar.gz: b27d5a75da38eed92d5dbc0d537ed7bbb5b35c10c80954994668a567691725cc
 SHA512:
-  metadata.gz: d7a587bbc0341247630217f64ff503788a8b79f238c2c87650ccd0fc3e0862eb2a45f40655ddc99d1b760dae1eb9f3e4f822ab66e393657595af960d9a319e7a
-  data.tar.gz: 52d6f667a99962f7e6e9449a6ccebe1fdd220983de2383ade21ed9f9fab1b814981c29eb20c4e8b999c92c2852fa2cca0d320d546be32d8fe32ed8f77d332884
+  metadata.gz: 0d631d1a338a434473e9e4251952ecd8d5adc5b999a9fc39b8fcb237b661dc8d07ffc5221f4c58b789b48ea84b9e3f5b61282dd3b14b7ede012b560ad90083e9
+  data.tar.gz: 86d7d89d4c17d67570e53b82bed9f8c6dbc91ed45bc6d21893485ccad2dbec0da0d88a78a969458f726a4eb58cc7f62a7557c96b12da2f54ab52ad546ee1fed2

data/.yamllint

@@ -0,0 +1,16 @@
+extends: default
+ignore: |
+  build/
+  node_modules/
+  runtime/build/
+  tmp/
+  **/*.dSYM/**
+
+rules:
+  comments:
+    min-spaces-from-content: 1
+  document-start: disable
+  line-length:
+    max: 200
+  truthy:
+    check-keys: false

data/CHANGELOG.md

@@ -2,9 +2,12 @@
 
 ## [Unreleased]
 
-## [0.1.1] - 2026-09-25
+## [0.1.2] - 2026-09-26
+
+- Correct blended dual quaternion transforms during skinning.
+- Reject invalid glTF node, skin, accessor, and buffer references with clear errors.
 
-- Correct the gem author and license attribution.
+## [0.1.1] - 2026-09-25
 
 ## [0.1.0] - 2026-09-23
 

data/lib/riggle/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Riggle
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/riggle.rb

@@ -190,9 +190,7 @@ module Riggle
     def apply(primitive, skin, scene, method: :lbs)
       raise ArgumentError, "unknown skinning method: #{method}" unless %i[lbs dqs].include?(method.to_sym)
       return primitive.positions.dup unless skin
-      matrices = skin.joints.map.with_index do |joint, index|
-        scene.world_matrix(joint) * (skin.inverse_bind_matrices&.[](index) || Mat4.identity)
-      end
+      matrices = joint_matrices(primitive, skin, scene)
       return apply_dual_quaternions(primitive, matrices) if method.to_sym == :dqs && matrices.all? { |matrix| rigid_transform?(matrix) }
       return apply_linear_blend(primitive, matrices)
     end
@@ -202,15 +200,25 @@ module Riggle
       return nil unless primitive.normals
       return primitive.normals.map(&:dup) unless skin
 
-      matrices = skin.joints.map.with_index do |joint, index|
-        scene.world_matrix(joint) * (skin.inverse_bind_matrices&.[](index) || Mat4.identity)
-      end
+      matrices = joint_matrices(primitive, skin, scene)
       if method.to_sym == :dqs && matrices.all? { |matrix| rigid_transform?(matrix) }
         return apply_dual_quaternion_normals(primitive, matrices)
       end
       apply_linear_blend_normals(primitive, matrices)
     end
 
+    def joint_matrices(primitive, skin, scene)
+      primitive.joints&.each do |indices|
+        indices.each do |index|
+          raise ArgumentError, "invalid skin joint index: #{index}" unless index.is_a?(Integer) && index >= 0 && index < skin.joints.length
+        end
+      end
+      skin.joints.map.with_index do |joint, index|
+        scene.world_matrix(joint) * (skin.inverse_bind_matrices&.[](index) || Mat4.identity)
+      end
+    end
+    private_class_method :joint_matrices
+
     def apply_linear_blend(primitive, matrices)
       primitive.positions.each_with_index.map do |position, index|
         joints = primitive.joints&.[](index) || [0]
@@ -361,8 +369,10 @@ module Riggle
     private_class_method :dual_quaternion
 
     def transform_dual_quaternion(point, real, dual)
-      real = quaternion_normalize(real)
-      dual = quaternion_scale(dual, 1.0 / Math.sqrt(real.sum { |value| value * value }))
+      length = Math.sqrt(real.sum { |value| value * value })
+      return point if length.zero?
+      real = quaternion_scale(real, 1.0 / length)
+      dual = quaternion_scale(dual, 1.0 / length)
       rotated = quaternion_multiply(quaternion_multiply(real, [point.x, point.y, point.z, 0.0]), quaternion_conjugate(real))
       translation = quaternion_multiply(dual, quaternion_conjugate(real)).first(3).map { |value| value * 2 }
       Vec3.new(x: rotated[0] + translation[0], y: rotated[1] + translation[1], z: rotated[2] + translation[2])
@@ -417,7 +427,10 @@ module Riggle
     end
 
     def world_matrix(node)
-      node = @nodes[node] if node.is_a?(Integer)
+      if node.is_a?(Integer)
+        raise ArgumentError, "invalid node index: #{node}" unless node >= 0 && node < @nodes.length
+        node = @nodes[node]
+      end
       index = @nodes.index(node)
       raise ArgumentError, "node is not part of the scene" unless index
       parent = @nodes.find { |candidate| candidate.children.to_a.include?(index) }
@@ -427,8 +440,8 @@ module Riggle
 
     def apply_pose!(pose)
       pose.each do |index, values|
+        raise ArgumentError, "invalid node index: #{index}" unless index.is_a?(Integer) && index >= 0 && index < @nodes.length
         node = @nodes[index]
-        raise ArgumentError, "invalid node index: #{index}" unless node
         values.each do |key, value|
           node[key] = case key.to_sym
           when :translation, :scale then Vec3.new(x: value[0], y: value[1], z: value[2])
@@ -556,11 +569,26 @@ module Riggle
       json, binary = document(path)
       raise UnsupportedError, "glTF 2.x is required" unless json.dig("asset", "version").to_s.match?(/\A2\./)
       raise UnsupportedError, "required glTF extensions are not supported" unless json.fetch("extensionsRequired", []).empty?
+      reference = lambda do |items, index, kind|
+        raise ArgumentError, "invalid glTF #{kind} index" unless index.is_a?(Integer) && index.between?(0, items.length - 1)
+
+        items[index]
+      end
       buffers = json.fetch("buffers", []).map { |buffer| buffer_data(buffer, binary, base_dir) }
       views = json.fetch("bufferViews", [])
+      views.each do |view|
+        index = view.fetch("buffer")
+        raise ArgumentError, "invalid glTF buffer view" unless index.is_a?(Integer) && index.between?(0, buffers.length - 1)
+
+        offset = view.fetch("byteOffset", 0)
+        length = view.fetch("byteLength")
+        raise ArgumentError, "invalid glTF buffer view" unless offset.is_a?(Integer) && offset >= 0 && length.is_a?(Integer) && length >= 0 && offset + length <= buffers[index].bytesize
+      end
+      view_at = ->(index) { reference.call(views, index, "buffer view") }
+      accessors = json.fetch("accessors", [])
       access = lambda do |index|
-        definition = json.fetch("accessors")[index]
-        view = definition["bufferView"] && views[definition["bufferView"]]
+        definition = reference.call(accessors, index, "accessor")
+        view = view_at.call(definition["bufferView"]) if definition.key?("bufferView")
         count = definition["count"]
         components = COMPONENTS.fetch(definition["type"])
         format = FORMATS.fetch(definition["componentType"])
@@ -568,12 +596,16 @@ module Riggle
         read_values = lambda do |buffer_view, byte_offset, value_count, value_format, value_size, value_components|
           raw = buffers.fetch(buffer_view.fetch("buffer"))
           view_start = buffer_view.fetch("byteOffset", 0)
+          view_length = buffer_view.fetch("byteLength")
+          raise ArgumentError, "invalid glTF accessor byte offset" unless byte_offset.is_a?(Integer) && byte_offset >= 0
+          raise ArgumentError, "invalid glTF accessor count" unless value_count.is_a?(Integer) && value_count >= 0
+
           start = view_start + byte_offset
-          view_end = view_start + buffer_view.fetch("byteLength")
+          view_end = view_start + view_length
           stride = buffer_view["byteStride"] || value_size
-          raise ArgumentError, "invalid glTF accessor stride" if stride < value_size
+          raise ArgumentError, "invalid glTF accessor stride" unless stride.is_a?(Integer) && stride >= value_size
           needed = value_count.zero? ? 0 : (value_count - 1) * stride + value_size
-          raise ArgumentError, "glTF accessor exceeds buffer view" if start + needed > view_end || start + needed > raw.bytesize
+          raise ArgumentError, "glTF accessor exceeds buffer view" if start + needed > view_end
           Array.new(value_count) { |item| raw.byteslice(start + item * stride, value_size).unpack(value_format * value_components) }
         end
         values = if view
@@ -587,11 +619,11 @@ module Riggle
         if sparse
           sparse_count = sparse.fetch("count")
           raise ArgumentError, "sparse accessor count exceeds accessor count" if sparse_count > count
-          index_view = views.fetch(sparse.fetch("indices").fetch("bufferView"))
+          index_view = view_at.call(sparse.fetch("indices").fetch("bufferView"))
           index_component = sparse.fetch("indices").fetch("componentType")
           index_format = { 5121 => "C", 5123 => "S<", 5125 => "L<" }.fetch(index_component) { raise ArgumentError, "invalid sparse index component type" }
           index_values = read_values.call(index_view, sparse["indices"].fetch("byteOffset", 0), sparse_count, index_format, format_size(index_format), 1).map(&:first)
-          value_view = views.fetch(sparse.fetch("values").fetch("bufferView"))
+          value_view = view_at.call(sparse.fetch("values").fetch("bufferView"))
           sparse_values = read_values.call(value_view, sparse["values"].fetch("byteOffset", 0), sparse_count, format, item_size, components)
           index_values.each_with_index do |target, sparse_index|
             raise ArgumentError, "sparse accessor index is out of range" if target >= count
@@ -626,7 +658,7 @@ module Riggle
       end
       image_refs = json.fetch("images", []).each_with_index.map do |image, index|
         next image_refs[index] if image["uri"]
-        view = views.fetch(image.fetch("bufferView"))
+        view = view_at.call(image.fetch("bufferView"))
         raw = buffers.fetch(view.fetch("buffer")).byteslice(view.fetch("byteOffset", 0), view.fetch("byteLength"))
         image_refs[index].tap do |reference|
           if load_images
@@ -635,10 +667,10 @@ module Riggle
           end
         end
       end
-      textures = json.fetch("textures", []).map { |texture| image_refs[texture["source"]] }
+      textures = json.fetch("textures", []).map { |texture| reference.call(image_refs, texture["source"], "image") }
       materials = json.fetch("materials", []).map do |material|
         pbr = material["pbrMetallicRoughness"] || {}
-        texture = pbr["baseColorTexture"] && textures[pbr["baseColorTexture"]["index"]]
+        texture = pbr["baseColorTexture"] && reference.call(textures, pbr["baseColorTexture"]["index"], "texture")
         Material.new(name: material["name"], base_color_factor: pbr["baseColorFactor"] || [1, 1, 1, 1], base_color_texture: texture, emissive: material["emissiveFactor"] || [0, 0, 0], alpha_mode: material["alphaMode"] || "OPAQUE")
       end
       meshes = json.fetch("meshes", []).map do |mesh|
@@ -658,29 +690,56 @@ module Riggle
             joints: attributes["JOINTS_0"] && access.call(attributes["JOINTS_0"]),
             weights: attributes["WEIGHTS_0"] && access.call(attributes["WEIGHTS_0"]),
             indices: primitive["indices"] ? access.call(primitive["indices"]) : (0...position_values.length).to_a,
-            material: materials[primitive["material"] || 0]
+            material: primitive.key?("material") ? reference.call(materials, primitive["material"], "material") : nil
           )
         end
         Mesh.new(name: mesh["name"], primitives: primitives)
       end
-      nodes = json.fetch("nodes", []).map do |node|
+      node_definitions = json.fetch("nodes", [])
+      skin_definitions = json.fetch("skins", [])
+      parent_counts = Array.new(node_definitions.length, 0)
+      node_definitions.each do |node|
+        (node["children"] || []).each do |child|
+          reference.call(node_definitions, child, "node")
+          parent_counts[child] += 1
+          raise ArgumentError, "invalid glTF node hierarchy: multiple parents" if parent_counts[child] > 1
+        end
+      end
+      roots = parent_counts.each_index.select { |index| parent_counts[index].zero? }
+      visited = 0
+      until roots.empty?
+        visited += 1
+        (node_definitions[roots.pop]["children"] || []).each do |child|
+          parent_counts[child] -= 1
+          roots << child if parent_counts[child].zero?
+        end
+      end
+      raise ArgumentError, "invalid glTF node hierarchy: cycle" unless visited == node_definitions.length
+
+      nodes = node_definitions.map do |node|
+        children = node["children"] || []
+        reference.call(skin_definitions, node["skin"], "skin") if node.key?("skin")
         translation = node["translation"] || [0, 0, 0]
         rotation = node["rotation"] || [0, 0, 0, 1]
         scale = node["scale"] || [1, 1, 1]
         matrix = node["matrix"]&.each_slice(4)&.to_a
-        Node.new(name: node["name"], children: node["children"] || [], mesh: node["mesh"] && meshes[node["mesh"]], translation: Vec3.new(x: translation[0], y: translation[1], z: translation[2]), rotation: Quat.new(x: rotation[0], y: rotation[1], z: rotation[2], w: rotation[3]), scale: Vec3.new(x: scale[0], y: scale[1], z: scale[2]), matrix: matrix && Mat4.new(matrix.transpose.flatten), skin: node["skin"])
+        Node.new(name: node["name"], children: children, mesh: node.key?("mesh") ? reference.call(meshes, node["mesh"], "mesh") : nil, translation: Vec3.new(x: translation[0], y: translation[1], z: translation[2]), rotation: Quat.new(x: rotation[0], y: rotation[1], z: rotation[2], w: rotation[3]), scale: Vec3.new(x: scale[0], y: scale[1], z: scale[2]), matrix: matrix && Mat4.new(matrix.transpose.flatten), skin: node["skin"])
       end
-      skins = json.fetch("skins", []).map do |skin|
+      skins = skin_definitions.map do |skin|
+        joints = skin.fetch("joints")
+        joints.each { |index| reference.call(nodes, index, "node") }
+        reference.call(nodes, skin["skeleton"], "node") if skin.key?("skeleton")
         inverse_bind_matrices = if skin["inverseBindMatrices"]
           access.call(skin["inverseBindMatrices"]).map { |value| Mat4.new(value.each_slice(4).to_a.transpose.flatten) }
         end
-        Skin.new(joints: skin.fetch("joints"), inverse_bind_matrices: inverse_bind_matrices, skeleton: skin["skeleton"])
+        Skin.new(joints: joints, inverse_bind_matrices: inverse_bind_matrices, skeleton: skin["skeleton"])
       end
       animations = json.fetch("animations", []).map do |animation|
         samplers = animation.fetch("samplers")
         channels = animation.fetch("channels").map do |channel|
-          sampler = samplers.fetch(channel.fetch("sampler"))
+          sampler = reference.call(samplers, channel.fetch("sampler"), "animation sampler")
           target = channel.fetch("target")
+          reference.call(nodes, target.fetch("node"), "node")
           Channel.new(node_index: target.fetch("node"), path: target.fetch("path"), times: access.call(sampler.fetch("input")), values: access.call(sampler.fetch("output")), interpolation: sampler.fetch("interpolation", "LINEAR"))
         end
         Animation.new(name: animation["name"], channels: channels)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: riggle
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Yudai Takada
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-25 00:00:00.000000000 Z
+date: 2026-09-26 00:00:00.000000000 Z
 dependencies: []
 description: Small scene models, materials, animation data, and mesh accessors.
 email:
@@ -17,6 +17,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codespellignore"
+- ".yamllint"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md