rgltf 1.0.0

data/lib/rgltf/properties/node.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Matrix4
+    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 |index|
+        row = index % 4
+        column = index / 4
+        4.times.sum { |inner| left[(inner * 4) + row] * right[(column * 4) + inner] }
+      end.freeze
+    end
+
+    def from_trs(translation, rotation, scale)
+      x, y, z, w = rotation
+      sx, sy, sz = scale
+      xx = x * x
+      yy = y * y
+      zz = z * z
+      xy = x * y
+      xz = x * z
+      yz = y * z
+      xw = x * w
+      yw = y * w
+      zw = z * w
+      [
+        (1.0 - (2.0 * (yy + zz))) * sx, (2.0 * (xy + zw)) * sx, (2.0 * (xz - yw)) * sx, 0.0,
+        (2.0 * (xy - zw)) * sy, (1.0 - (2.0 * (xx + zz))) * sy, (2.0 * (yz + xw)) * sy, 0.0,
+        (2.0 * (xz + yw)) * sz, (2.0 * (yz - xw)) * sz, (1.0 - (2.0 * (xx + yy))) * sz, 0.0,
+        translation[0], translation[1], translation[2], 1.0
+      ].freeze
+    end
+  end
+
+  class Node < Properties::Base
+    IDENTITY = Matrix4::IDENTITY
+
+    attr_reader :children, :mesh, :skin, :camera, :translation, :rotation,
+                :scale, :weights
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :node)
+      @child_indices = json.fetch('children', [])
+      @mesh_index = json['mesh']
+      @skin_index = json['skin']
+      @camera_index = json['camera']
+      @translation = json.fetch('translation', [0.0, 0.0, 0.0]).freeze
+      @rotation = json.fetch('rotation', [0.0, 0.0, 0.0, 1.0]).freeze
+      @scale = json.fetch('scale', [1.0, 1.0, 1.0]).freeze
+      @weights = json['weights']&.freeze
+      @matrix = json['matrix']&.freeze
+      return unless @matrix && (json.key?('translation') || json.key?('rotation') || json.key?('scale'))
+
+      raise FormatError, "node #{index} cannot define both matrix and TRS"
+    end
+
+    def resolve_references!
+      @children = @child_indices.each_with_index.map do |child_index, child_position|
+        @document.fetch_reference(:nodes, child_index, "nodes/#{index}/children/#{child_position}")
+      end.freeze
+      @mesh = optional_reference(:meshes, @mesh_index, "nodes/#{index}/mesh")
+      @skin = optional_reference(:skins, @skin_index, "nodes/#{index}/skin")
+      @camera = optional_reference(:cameras, @camera_index, "nodes/#{index}/camera")
+      self
+    end
+
+    def matrix
+      @matrix || (@computed_matrix ||= Matrix4.from_trs(translation, rotation, scale))
+    end
+
+    def trs?
+      @matrix.nil?
+    end
+
+    def traverse(&block)
+      return enum_for(:traverse) unless block
+
+      traverse_guarded({}, &block)
+      self
+    end
+
+    def world_matrix(parent_matrix = IDENTITY)
+      Matrix4.multiply(parent_matrix, matrix)
+    end
+
+    class << self
+      def install_larb_conversion!
+        return false unless defined?(::Larb::Mat4)
+        return true if public_method_defined?(:to_larb, false)
+
+        define_method(:to_larb) { ::Larb::Mat4.new(matrix) }
+        public :to_larb
+        true
+      end
+    end
+
+    private_class_method :install_larb_conversion!
+    install_larb_conversion!
+
+    private
+
+    def method_missing(name, ...)
+      return public_send(name, ...) if name == :to_larb && self.class.send(:install_larb_conversion!)
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      return true if name == :to_larb && self.class.send(:install_larb_conversion!)
+
+      super
+    end
+
+    def traverse_guarded(visiting, &block)
+      raise FormatError, "node hierarchy contains a cycle at node #{index}" if visiting[object_id]
+
+      visiting[object_id] = true
+      block.call(self)
+      children.each { |child| child.send(:traverse_guarded, visiting, &block) }
+      visiting.delete(object_id)
+    end
+
+    def optional_reference(collection, value, path)
+      value.nil? ? nil : @document.fetch_reference(collection, value, path)
+    end
+  end
+end

data/lib/rgltf/properties/sampler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Sampler < Properties::Base
+    FILTERS = {
+      9728 => :nearest,
+      9729 => :linear,
+      9984 => :nearest_mipmap_nearest,
+      9985 => :linear_mipmap_nearest,
+      9986 => :nearest_mipmap_linear,
+      9987 => :linear_mipmap_linear
+    }.freeze
+    WRAPS = { 33_071 => :clamp_to_edge, 33_648 => :mirrored_repeat, 10_497 => :repeat }.freeze
+
+    attr_reader :mag_filter, :min_filter, :wrap_s, :wrap_t
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :sampler)
+      @mag_filter = convert(FILTERS, json['magFilter'], 'magFilter')
+      @min_filter = convert(FILTERS, json['minFilter'], 'minFilter')
+      @wrap_s = convert(WRAPS, json.fetch('wrapS', 10_497), 'wrapS')
+      @wrap_t = convert(WRAPS, json.fetch('wrapT', 10_497), 'wrapT')
+    end
+
+    private
+
+    def convert(table, value, property)
+      return nil if value.nil?
+
+      table.fetch(value)
+    rescue KeyError
+      raise FormatError, "sampler #{index} has invalid #{property} #{value.inspect}"
+    end
+  end
+end

data/lib/rgltf/properties/scene.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Scene < Properties::Base
+    attr_reader :nodes
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :scene)
+      @nodes = json.fetch('nodes', []).each_with_index.map do |node_index, node_position|
+        document.fetch_reference(:nodes, node_index, "scenes/#{index}/nodes/#{node_position}")
+      end.freeze
+    end
+  end
+end

data/lib/rgltf/properties/skin.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Skin < Properties::Base
+    attr_reader :joints, :inverse_bind_matrices, :skeleton
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :skin)
+      @joints = json.fetch('joints').each_with_index.map do |node_index, joint_index|
+        document.fetch_reference(:nodes, node_index, "skins/#{index}/joints/#{joint_index}")
+      end.freeze
+      @inverse_bind_matrices = optional_reference(document, :accessors, json['inverseBindMatrices'],
+                                                  "skins/#{index}/inverseBindMatrices")
+      @skeleton = optional_reference(document, :nodes, json['skeleton'], "skins/#{index}/skeleton")
+    rescue KeyError => e
+      raise FormatError, "invalid skin #{index}: #{e.message}"
+    end
+
+    private
+
+    def optional_reference(document, collection, value, path)
+      value.nil? ? nil : document.fetch_reference(collection, value, path)
+    end
+  end
+end

data/lib/rgltf/properties/texture.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Texture < Properties::Base
+    attr_reader :sampler, :source
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :texture)
+      @sampler = optional_reference(document, :samplers, json['sampler'], "textures/#{index}/sampler")
+      @source = optional_reference(document, :images, json['source'], "textures/#{index}/source")
+    end
+
+    private
+
+    def optional_reference(document, collection, value, path)
+      value.nil? ? nil : document.fetch_reference(collection, value, path)
+    end
+  end
+end

data/lib/rgltf/properties.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'properties/base'
+require_relative 'properties/asset'
+require_relative 'properties/buffer'
+require_relative 'properties/buffer_view'
+require_relative 'properties/accessor'
+require_relative 'properties/image'
+require_relative 'properties/sampler'
+require_relative 'properties/texture'
+require_relative 'properties/material'
+require_relative 'properties/mesh'
+require_relative 'properties/camera'
+require_relative 'properties/node'
+require_relative 'properties/skin'
+require_relative 'properties/animation'
+require_relative 'properties/scene'

data/lib/rgltf/validation/accessors.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Validation
+    class Accessors < Rule
+      COMPONENTS = AccessorReader::COMPONENT_TYPES.freeze
+      TYPES = AccessorReader::ELEMENT_COUNTS.freeze
+      UNSIGNED = [5121, 5123, 5125].freeze
+
+      def validate
+        array('accessors').each_with_index { |raw, index| validate_accessor(object(raw, "accessors/#{index}"), index) }
+      end
+
+      private
+
+      def validate_accessor(accessor, index)
+        path = "accessors/#{index}"
+        component = accessor['componentType']
+        type = accessor['type']
+        count = accessor['count']
+        validate_enum(COMPONENTS, component, "#{path}/componentType", :invalid_component_type)
+        validate_enum(TYPES, type, "#{path}/type", :invalid_accessor_type)
+        context.non_negative_integer(count, "#{path}/count", minimum: 1)
+        offset = accessor.fetch('byteOffset', 0)
+        context.non_negative_integer(offset, "#{path}/byteOffset")
+        if !accessor.key?('bufferView') && accessor.key?('byteOffset') && offset != 0
+          error(:accessor_offset_without_buffer_view, "#{path}/byteOffset", 'must be zero without bufferView')
+        end
+        validate_normalized(accessor, path, component)
+        validate_min_max(accessor, path, type)
+        has_view = reference('bufferViews', accessor['bufferView'], "#{path}/bufferView") if accessor.key?('bufferView')
+        unless accessor.key?('bufferView') || accessor.key?('sparse') || draco_accessor?(index)
+          error(:accessor_data_missing, path, 'must define bufferView or sparse')
+        end
+        validate_view(accessor, path, component, type, count, offset) if has_view
+        validate_sparse(accessor['sparse'], path, component, type, count) if accessor.key?('sparse')
+      end
+
+      def validate_enum(table, value, path, code)
+        error(code, path, 'contains an unsupported value') unless table.key?(value)
+      end
+
+      def validate_normalized(accessor, path, component)
+        value = accessor['normalized']
+        error(:invalid_normalized, "#{path}/normalized", 'must be boolean') if accessor.key?('normalized') && ![true,
+                                                                                                                false].include?(value)
+        return unless value && ![5120, 5121, 5122, 5123].include?(component)
+
+        error(:invalid_normalized_type, "#{path}/normalized", 'is only valid for 8-bit and 16-bit integers')
+      end
+
+      def validate_min_max(accessor, path, type)
+        size = TYPES[type]
+        %w[min max].each do |key|
+          next unless accessor.key?(key) && size
+
+          context.numeric_array(accessor[key], size, "#{path}/#{key}")
+        end
+        return unless size && accessor['min'].is_a?(Array) && accessor['max'].is_a?(Array)
+        return unless accessor['min'].length == size && accessor['max'].length == size
+
+        accessor['min'].zip(accessor['max']).each_with_index do |(minimum, maximum), component_index|
+          next unless finite?(minimum) && finite?(maximum) && minimum > maximum
+
+          error(:invalid_accessor_bounds, "#{path}/min/#{component_index}", 'must not exceed max')
+        end
+      end
+
+      def validate_view(accessor, path, component, type, count, offset)
+        unless COMPONENTS.key?(component) && TYPES.key?(type) && count.is_a?(Integer) && count >= 1 && offset.is_a?(Integer) && offset >= 0
+          return
+        end
+
+        view = array('bufferViews')[accessor['bufferView']]
+        return unless view.is_a?(Hash)
+
+        info = COMPONENTS[component]
+        absolute = view.fetch('byteOffset', 0).to_i + offset
+        unless (absolute % info[:size]).zero?
+          error(:accessor_misaligned, "#{path}/byteOffset",
+                'absolute offset must align to component size')
+        end
+        storage_size = AccessorReader.storage_element_size(type, info[:size])
+        stride = view['byteStride'] || storage_size
+        if stride.is_a?(Integer) && stride < storage_size
+          error(:invalid_byte_stride, "bufferViews/#{accessor['bufferView']}/byteStride",
+                'must not be smaller than an accessor element')
+        end
+        return unless view['byteLength'].is_a?(Integer) && stride.is_a?(Integer)
+
+        required = offset + (stride * (count - 1)) + storage_size
+        error(:accessor_out_of_bounds, path, 'data exceeds bufferView byteLength') if required > view['byteLength']
+      end
+
+      def validate_sparse(raw, path, component, type, accessor_count)
+        sparse = object(raw, "#{path}/sparse")
+        count = sparse['count']
+        context.non_negative_integer(count, "#{path}/sparse/count", minimum: 1)
+        if count.is_a?(Integer) && accessor_count.is_a?(Integer) && count > accessor_count
+          error(:invalid_sparse_count, "#{path}/sparse/count", 'must not exceed accessor count')
+        end
+        indices = object(sparse['indices'], "#{path}/sparse/indices")
+        values = object(sparse['values'], "#{path}/sparse/values")
+        validate_sparse_indices(indices, path, count, accessor_count)
+        validate_sparse_values(values, path, count, component, type)
+      end
+
+      def validate_sparse_indices(indices, path, count, accessor_count)
+        view_ok = reference('bufferViews', indices['bufferView'], "#{path}/sparse/indices/bufferView", required: true)
+        type = indices['componentType']
+        unless UNSIGNED.include?(type)
+          error(:invalid_sparse_index_type, "#{path}/sparse/indices/componentType",
+                'must be an unsigned integer type')
+        end
+        offset = indices.fetch('byteOffset', 0)
+        context.non_negative_integer(offset, "#{path}/sparse/indices/byteOffset")
+        unless view_ok && UNSIGNED.include?(type) && offset.is_a?(Integer) && offset >= 0 && count.is_a?(Integer) && count >= 1
+          return
+        end
+
+        view = array('bufferViews')[indices['bufferView']]
+        if view.is_a?(Hash) && view.key?('byteStride')
+          error(:sparse_buffer_view_stride, "#{path}/sparse/indices/bufferView",
+                'bufferView must not define byteStride')
+        end
+        size = COMPONENTS[type][:size]
+        check_sparse_range(view, offset, count * size, "#{path}/sparse/indices")
+        absolute = view.fetch('byteOffset', 0).to_i + offset
+        unless (absolute % size).zero?
+          error(:sparse_indices_misaligned, "#{path}/sparse/indices/byteOffset",
+                'absolute offset must align to component size')
+        end
+        validate_sparse_order(indices['bufferView'], view, offset, count, type, accessor_count, path)
+      end
+
+      def validate_sparse_values(values, path, count, component, type)
+        view_ok = reference('bufferViews', values['bufferView'], "#{path}/sparse/values/bufferView", required: true)
+        offset = values.fetch('byteOffset', 0)
+        context.non_negative_integer(offset, "#{path}/sparse/values/byteOffset")
+        unless view_ok && COMPONENTS.key?(component) && TYPES.key?(type) && offset.is_a?(Integer) && offset >= 0 && count.is_a?(Integer) && count >= 1
+          return
+        end
+
+        view = array('bufferViews')[values['bufferView']]
+        if view.is_a?(Hash) && view.key?('byteStride')
+          error(:sparse_buffer_view_stride, "#{path}/sparse/values/bufferView",
+                'bufferView must not define byteStride')
+        end
+        size = COMPONENTS[component][:size]
+        element_size = AccessorReader.storage_element_size(type, size)
+        check_sparse_range(view, offset, count * element_size, "#{path}/sparse/values")
+        absolute = view.fetch('byteOffset', 0).to_i + offset
+        return if (absolute % size).zero?
+
+        error(:sparse_values_misaligned, "#{path}/sparse/values/byteOffset",
+              'absolute offset must align to component size')
+      end
+
+      def check_sparse_range(view, offset, length, path)
+        return unless view.is_a?(Hash) && view['byteLength'].is_a?(Integer)
+
+        error(:sparse_out_of_bounds, path, 'data exceeds bufferView byteLength') if offset + length > view['byteLength']
+      end
+
+      def validate_sparse_order(view_index, view, offset, count, type, accessor_count, path)
+        bytes = buffer_view_bytes(view_index, view)
+        return unless bytes && bytes.bytesize >= offset + (count * COMPONENTS[type][:size])
+
+        values = bytes.byteslice(offset, count * COMPONENTS[type][:size]).unpack("#{COMPONENTS[type][:pack]}*")
+        values.each_with_index do |value, index|
+          if accessor_count.is_a?(Integer) && value >= accessor_count
+            error(:sparse_index_out_of_range, "#{path}/sparse/indices/#{index}",
+                  'must be less than accessor count')
+          end
+          next if index.zero? || value > values[index - 1]
+
+          error(:sparse_indices_not_strictly_increasing, "#{path}/sparse/indices/#{index}",
+                'indices must be strictly increasing')
+        end
+      end
+
+      def buffer_view_bytes(_view_index, view)
+        buffer_index = view['buffer']
+        bytes = context.bytes_for_buffer(buffer_index) if buffer_index.is_a?(Integer)
+        bytes&.byteslice(view.fetch('byteOffset', 0), view['byteLength'])
+      rescue TypeError
+        nil
+      end
+
+      def draco_accessor?(accessor_index)
+        return false unless array('extensionsUsed').include?('KHR_draco_mesh_compression')
+
+        array('meshes').any? do |mesh|
+          next false unless mesh.is_a?(Hash) && mesh['primitives'].is_a?(Array)
+
+          mesh['primitives'].any? do |primitive|
+            next false unless primitive.is_a?(Hash) && primitive.dig('extensions', 'KHR_draco_mesh_compression')
+
+            primitive['indices'] == accessor_index || primitive.fetch('attributes', {}).value?(accessor_index)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rgltf/validation/animations.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Validation
+    class Animations < Rule
+      PATHS = %w[translation rotation scale weights].freeze
+      INTERPOLATIONS = %w[LINEAR STEP CUBICSPLINE].freeze
+
+      def validate
+        array('animations').each_with_index do |raw, index|
+          validate_animation(object(raw, "animations/#{index}"), index)
+        end
+      end
+
+      private
+
+      def validate_animation(animation, animation_index)
+        path = "animations/#{animation_index}"
+        samplers = animation['samplers']
+        channels = animation['channels']
+        validate_non_empty_array(samplers, "#{path}/samplers")
+        validate_non_empty_array(channels, "#{path}/channels")
+        samplers = [] unless samplers.is_a?(Array)
+        channels = [] unless channels.is_a?(Array)
+        samplers.each_with_index do |raw, index|
+          validate_sampler(object(raw, "#{path}/samplers/#{index}"), animation_index, index)
+        end
+        targets = channels.each_with_index.map do |raw, index|
+          validate_channel(object(raw, "#{path}/channels/#{index}"), samplers, animation_index, index)
+        end.compact
+        duplicates = targets.select { |target| targets.count(target) > 1 }.uniq
+        duplicates.each do |target|
+          error(:duplicate_animation_target, "#{path}/channels", "contains duplicate target #{target.join('/')}")
+        end
+      end
+
+      def validate_non_empty_array(value, path)
+        return if value.is_a?(Array) && !value.empty?
+
+        error(:invalid_animation_collection, path,
+              'must be a non-empty array')
+      end
+
+      def validate_sampler(sampler, animation_index, sampler_index)
+        path = "animations/#{animation_index}/samplers/#{sampler_index}"
+        input_ok = reference('accessors', sampler['input'], "#{path}/input", required: true)
+        reference('accessors', sampler['output'], "#{path}/output", required: true)
+        interpolation = sampler.fetch('interpolation', 'LINEAR')
+        unless INTERPOLATIONS.include?(interpolation)
+          error(:invalid_interpolation, "#{path}/interpolation",
+                'must be LINEAR, STEP, or CUBICSPLINE')
+        end
+        validate_input(sampler['input'], path) if input_ok
+      end
+
+      def validate_input(index, path)
+        accessor = array('accessors')[index]
+        return unless accessor.is_a?(Hash)
+
+        valid = accessor['componentType'] == 5126 && accessor['type'] == 'SCALAR' && !accessor.fetch('normalized',
+                                                                                                     false)
+        error(:invalid_animation_input, "#{path}/input", 'must be a non-normalized SCALAR FLOAT accessor') unless valid
+        unless accessor['min'] && accessor['max']
+          warning(:animation_input_bounds_missing, "#{path}/input",
+                  'input accessor should define min and max')
+        end
+        if accessor['min'].is_a?(Array) && finite?(accessor['min'].first) && accessor['min'].first.negative?
+          error(:negative_animation_time, "#{path}/input", 'time values must be non-negative')
+        end
+        validate_input_order(index, path)
+      end
+
+      def validate_input_order(index, path)
+        document = context.document
+        return unless document && document.accessors[index]
+        return if context.send(:meshopt_decode_target_accessor?, index)
+
+        values = document.accessors[index].to_a
+        if values.first&.negative?
+          error(:negative_animation_time, "#{path}/input",
+                'time values must be non-negative')
+        end
+        values.each_cons(2) do |previous, current|
+          unless current > previous
+            error(:animation_input_not_increasing, "#{path}/input", 'time values must be strictly increasing')
+            break
+          end
+        end
+      rescue Error => e
+        error(:animation_input_unreadable, "#{path}/input", e.message)
+      end
+
+      def validate_channel(channel, samplers, animation_index, channel_index)
+        path = "animations/#{animation_index}/channels/#{channel_index}"
+        sampler_index = channel['sampler']
+        unless sampler_index.is_a?(Integer) && sampler_index >= 0 && sampler_index < samplers.length
+          error(:invalid_animation_sampler_reference, "#{path}/sampler", 'must reference an animation sampler')
+          return
+        end
+        target = object(channel['target'], "#{path}/target")
+        target_path = target['path']
+        if animation_pointer?(target)
+          validate_pointer(target, path)
+          validate_output(samplers[sampler_index], 'pointer', nil, path)
+          return nil
+        end
+
+        node_ok = reference('nodes', target['node'], "#{path}/target/node", required: true)
+        unless PATHS.include?(target_path)
+          error(:invalid_animation_path, "#{path}/target/path",
+                'contains an unsupported path')
+        end
+        validate_output(samplers[sampler_index], target_path, target['node'], path) if PATHS.include?(target_path)
+        [target['node'], target_path] if node_ok && PATHS.include?(target_path)
+      end
+
+      def validate_output(sampler_raw, target_path, node_index, path)
+        sampler = sampler_raw.is_a?(Hash) ? sampler_raw : {}
+        output = array('accessors')[sampler['output']] if sampler['output'].is_a?(Integer)
+        input = array('accessors')[sampler['input']] if sampler['input'].is_a?(Integer)
+        return unless output.is_a?(Hash)
+
+        valid = animation_component_valid?(output, target_path) && output_type_valid?(output['type'], target_path)
+        unless valid
+          error(:invalid_animation_output, "#{path}/sampler/output",
+                "accessor type is invalid for #{target_path}")
+        end
+        return unless input.is_a?(Hash) && input['count'].is_a?(Integer) && output['count'].is_a?(Integer)
+
+        multiplier = sampler.fetch('interpolation', 'LINEAR') == 'CUBICSPLINE' ? 3 : 1
+        if target_path == 'weights'
+          target_count = morph_target_count(node_index)
+          unless target_count
+            error(:animation_weights_without_morph_targets, "#{path}/target/path",
+                  'weights require a mesh with morph targets')
+          end
+          multiplier *= target_count || 1
+        end
+        expected = input['count'] * multiplier
+        return unless output['count'] != expected
+
+        error(:animation_output_count_mismatch, "#{path}/sampler/output", "count must be #{expected}")
+      end
+
+      def output_type_valid?(type, target_path)
+        case target_path
+        when 'translation', 'scale' then type == 'VEC3'
+        when 'rotation' then type == 'VEC4'
+        when 'weights' then type == 'SCALAR'
+        when 'pointer' then AccessorReader::ELEMENT_COUNTS.key?(type)
+        end
+      end
+
+      def animation_component_valid?(accessor, target_path)
+        return AccessorReader::COMPONENT_TYPES.key?(accessor['componentType']) if target_path == 'pointer'
+        return true if accessor['componentType'] == 5126 && !accessor.fetch('normalized', false)
+        return false unless array('extensionsUsed').include?('KHR_mesh_quantization')
+
+        [5120, 5121, 5122, 5123].include?(accessor['componentType']) && accessor['normalized'] == true
+      end
+
+      def animation_pointer?(target)
+        target['path'] == 'pointer' &&
+          array('extensionsUsed').include?('KHR_animation_pointer') &&
+          target.dig('extensions', 'KHR_animation_pointer').is_a?(Hash)
+      end
+
+      def validate_pointer(target, path)
+        pointer = target.dig('extensions', 'KHR_animation_pointer', 'pointer')
+        return if pointer.is_a?(String) && pointer.start_with?('/') && pointer.length > 1
+
+        error(:invalid_animation_pointer, "#{path}/target/extensions/KHR_animation_pointer/pointer",
+              'must be a non-empty JSON pointer')
+      end
+
+      def morph_target_count(node_index)
+        node = array('nodes')[node_index] if node_index.is_a?(Integer)
+        mesh = array('meshes')[node['mesh']] if node.is_a?(Hash) && node['mesh'].is_a?(Integer)
+        targets = mesh&.dig('primitives', 0, 'targets')
+        targets.length if targets.is_a?(Array) && !targets.empty?
+      end
+    end
+  end
+end