rgltf 1.0.0

data/lib/rgltf/validation/buffers.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Validation
+    class Buffers < Rule
+      TARGETS = [34_962, 34_963].freeze
+
+      def validate
+        validate_buffers
+        validate_views
+      end
+
+      private
+
+      def validate_buffers
+        array('buffers').each_with_index do |raw, index|
+          buffer = object(raw, "buffers/#{index}")
+          if buffer.key?('uri') && (!buffer['uri'].is_a?(String) || buffer['uri'].empty?)
+            error(:invalid_buffer_uri, "buffers/#{index}/uri", 'must be a non-empty string')
+          end
+          length = buffer['byteLength']
+          context.non_negative_integer(length, "buffers/#{index}/byteLength", minimum: 1)
+          validate_raw_resource(buffer, index)
+          next unless length.is_a?(Integer) && length.positive?
+
+          bytes = context.bytes_for_buffer(index)
+          if bytes && bytes.bytesize < length
+            error(:buffer_too_short, "buffers/#{index}", 'resolved bytes are shorter than byteLength')
+          end
+        end
+      end
+
+      def validate_raw_resource(buffer, index)
+        return if context.document || index.zero? || buffer['uri'].is_a?(String)
+        return if required_meshopt_target?(buffer, index)
+
+        error(:missing_buffer, "buffers/#{index}", "buffer #{index} has no URI or GLB BIN chunk")
+      end
+
+      def required_meshopt_target?(buffer, index)
+        names = Buffer.const_get(:MESHOPT_EXTENSIONS, false)
+        required = @json['extensionsRequired']
+        return false unless required.is_a?(Array)
+
+        required_names = names & required
+        return true if required_names.any? { |name| buffer.dig('extensions', name, 'fallback') == true }
+
+        array('bufferViews').any? do |view|
+          next false unless view.is_a?(Hash) && view['buffer'] == index
+
+          extensions = view['extensions']
+          extensions.is_a?(Hash) && required_names.any? { |name| extensions[name].is_a?(Hash) }
+        end
+      end
+
+      def validate_views
+        array('bufferViews').each_with_index do |raw, index|
+          view = object(raw, "bufferViews/#{index}")
+          path = "bufferViews/#{index}"
+          reference('buffers', view['buffer'], "#{path}/buffer", required: true)
+          offset = view.fetch('byteOffset', 0)
+          length = view['byteLength']
+          context.non_negative_integer(offset, "#{path}/byteOffset")
+          context.non_negative_integer(length, "#{path}/byteLength", minimum: 1)
+          validate_stride(view['byteStride'], "#{path}/byteStride") if view.key?('byteStride')
+          validate_target(view['target'], "#{path}/target") if view.key?('target')
+          validate_range(view, offset, length, path)
+        end
+      end
+
+      def validate_stride(stride, path)
+        return if stride.is_a?(Integer) && stride.between?(4, 252) && (stride % 4).zero?
+
+        error(:invalid_byte_stride, path, 'must be 4..252 and divisible by 4')
+      end
+
+      def validate_target(target, path)
+        return if TARGETS.include?(target)
+
+        error(:invalid_buffer_view_target, path, 'must be ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER')
+      end
+
+      def validate_range(view, offset, length, path)
+        return unless offset.is_a?(Integer) && offset >= 0 && length.is_a?(Integer) && length >= 1
+        return unless view['buffer'].is_a?(Integer)
+
+        buffer = array('buffers')[view['buffer']]
+        return unless buffer.is_a?(Hash) && buffer['byteLength'].is_a?(Integer)
+        return if offset + length <= buffer['byteLength']
+
+        error(:buffer_view_out_of_bounds, path, 'byte range exceeds buffer byteLength')
+      end
+    end
+  end
+end

data/lib/rgltf/validation/cameras.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Validation
+    class Cameras < Rule
+      def validate
+        array('cameras').each_with_index { |raw, index| validate_camera(object(raw, "cameras/#{index}"), index) }
+      end
+
+      private
+
+      def validate_camera(camera, index)
+        path = "cameras/#{index}"
+        case camera['type']
+        when 'perspective'
+          if camera.key?('orthographic')
+            error(:camera_projection_conflict, path,
+                  'must not define orthographic for a perspective camera')
+          end
+          validate_perspective(object(camera['perspective'], "#{path}/perspective"), path)
+        when 'orthographic'
+          if camera.key?('perspective')
+            error(:camera_projection_conflict, path,
+                  'must not define perspective for an orthographic camera')
+          end
+          validate_orthographic(object(camera['orthographic'], "#{path}/orthographic"), path)
+        else error(:invalid_camera_type, "#{path}/type", 'must be perspective or orthographic')
+        end
+      end
+
+      def validate_perspective(camera, path)
+        positive(camera['yfov'], "#{path}/perspective/yfov")
+        if finite?(camera['yfov']) && camera['yfov'] >= Math::PI
+          warning(:unusual_camera_yfov, "#{path}/perspective/yfov", 'is at least PI radians')
+        end
+        positive(camera['znear'], "#{path}/perspective/znear")
+        positive(camera['aspectRatio'], "#{path}/perspective/aspectRatio") if camera.key?('aspectRatio')
+        return unless camera.key?('zfar')
+
+        positive(camera['zfar'], "#{path}/perspective/zfar")
+        return unless finite?(camera['zfar']) && finite?(camera['znear']) && camera['zfar'] <= camera['znear']
+
+        error(:invalid_camera_range, "#{path}/perspective/zfar", 'must be greater than znear')
+      end
+
+      def validate_orthographic(camera, path)
+        %w[xmag ymag].each { |key| nonzero_magnitude(camera[key], "#{path}/orthographic/#{key}") }
+        %w[znear zfar].each do |key|
+          unless finite?(camera[key])
+            error(:invalid_camera_value, "#{path}/orthographic/#{key}",
+                  'must be a finite number')
+          end
+        end
+        return unless finite?(camera['zfar']) && finite?(camera['znear']) && camera['zfar'] <= camera['znear']
+
+        error(:invalid_camera_range, "#{path}/orthographic/zfar", 'must be greater than znear')
+      end
+
+      def positive(value, path, upper: nil)
+        valid = finite?(value) && value.positive? && (!upper || value < upper)
+        return if valid
+
+        error(:invalid_camera_value, path,
+              upper ? "must be greater than zero and less than #{upper}" : 'must be greater than zero')
+      end
+
+      def nonzero_magnitude(value, path)
+        unless finite?(value) && !value.zero?
+          error(:invalid_camera_value, path, 'must be a non-zero finite number')
+          return
+        end
+        warning(:negative_camera_magnitude, path, 'negative magnification mirrors the camera axis') if value.negative?
+      end
+    end
+  end
+end

data/lib/rgltf/validation/context.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Validation
+    class Context
+      attr_reader :json, :document, :errors, :warnings
+
+      def initialize(json, document: nil)
+        @json = json.is_a?(Hash) ? json : {}
+        @document = document
+        @errors = []
+        @warnings = []
+        error(:invalid_document, '', 'glTF root must be an object') unless json.is_a?(Hash)
+      end
+
+      def array(key)
+        value = json[key]
+        return [] if value.nil?
+        return value if value.is_a?(Array)
+
+        error(:invalid_type, key, 'must be an array')
+        []
+      end
+
+      def object(value, path)
+        return value if value.is_a?(Hash)
+
+        error(:invalid_type, path, 'must be an object')
+        {}
+      end
+
+      def reference(collection, value, path, required: false)
+        if value.nil?
+          error(:missing_reference, path, 'is required') if required
+          return false
+        end
+        return true if value.is_a?(Integer) && value >= 0 && value < array(collection).length
+
+        error(:invalid_reference, path, "must reference an existing #{collection} entry")
+        false
+      end
+
+      def non_negative_integer(value, path, minimum: 0)
+        return true if value.is_a?(Integer) && value >= minimum
+
+        error(:invalid_integer, path, "must be an integer greater than or equal to #{minimum}")
+        false
+      end
+
+      def finite_number?(value)
+        value.is_a?(Numeric) && (!value.respond_to?(:finite?) || value.finite?)
+      rescue StandardError
+        false
+      end
+
+      def numeric_array(value, length, path)
+        unless value.is_a?(Array) && value.length == length && value.all? { |entry| finite_number?(entry) }
+          error(:invalid_numeric_array, path, "must contain exactly #{length} finite numbers")
+          return false
+        end
+        true
+      end
+
+      def error(code, path, message)
+        issue = Validator::Issue.new(code:, path:, message:)
+        errors << issue unless errors.include?(issue)
+      end
+
+      def warning(code, path, message)
+        issue = Validator::Issue.new(code:, path:, message:)
+        warnings << issue unless warnings.include?(issue)
+      end
+
+      def bytes_for_buffer(index)
+        return unless document
+
+        buffer = document.buffers[index]
+        return if buffer&.send(:meshopt_decode_target?)
+
+        buffer&.bytes
+      rescue Error => e
+        error(:missing_buffer, "buffers/#{index}", e.message)
+        nil
+      end
+
+      def bytes_for_image(index)
+        return unless document
+
+        document.images[index]&.bytes
+      rescue Error => e
+        error(:missing_image, "images/#{index}", e.message)
+        nil
+      end
+
+      def meshopt_decode_target_accessor?(index)
+        accessors = json['accessors']
+        accessor = accessors[index] if accessors.is_a?(Array) && index.is_a?(Integer)
+        return false unless accessor.is_a?(Hash)
+
+        views = json['bufferViews']
+        view = views[accessor['bufferView']] if views.is_a?(Array) && accessor['bufferView'].is_a?(Integer)
+        return false unless view.is_a?(Hash) && view['buffer'].is_a?(Integer)
+
+        extensions = view['extensions']
+        meshopt_extensions = Buffer.const_get(:MESHOPT_EXTENSIONS, false)
+        required_extensions = document ? document.extensions_required : json.fetch('extensionsRequired', [])
+        required_extensions = [] unless required_extensions.is_a?(Array)
+        required = meshopt_extensions & required_extensions
+        extensions.is_a?(Hash) && required.any? { |name| extensions[name].is_a?(Hash) }
+      end
+
+      private :meshopt_decode_target_accessor?
+    end
+
+    class Rule
+      def initialize(context)
+        @context = context
+        @json = context.json
+      end
+
+      private
+
+      attr_reader :context
+
+      def array(key) = context.array(key)
+      def object(value, path) = context.object(value, path)
+      def error(code, path, message) = context.error(code, path, message)
+      def warning(code, path, message) = context.warning(code, path, message)
+      def reference(collection, value, path, required: false) = context.reference(collection, value, path, required:)
+      def finite?(value) = context.finite_number?(value)
+    end
+  end
+end

data/lib/rgltf/validation/images_materials.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Validation
+    class ImagesMaterials < Rule
+      IMAGE_SIGNATURES = {
+        'image/png' => "\x89PNG\r\n\x1A\n".b,
+        'image/jpeg' => "\xFF\xD8\xFF".b,
+        'image/webp' => 'RIFF'.b,
+        'image/ktx2' => "\xABKTX 20\xBB\r\n\x1A\n".b
+      }.freeze
+      FILTERS = [9728, 9729, 9984, 9985, 9986, 9987].freeze
+      WRAPS = [33_071, 33_648, 10_497].freeze
+
+      def validate
+        validate_images
+        validate_samplers
+        validate_textures
+        array('materials').each_with_index { |raw, index| validate_material(object(raw, "materials/#{index}"), index) }
+      end
+
+      private
+
+      def validate_images
+        array('images').each_with_index do |raw, index|
+          image = object(raw, "images/#{index}")
+          path = "images/#{index}"
+          uri = image.key?('uri')
+          view = image.key?('bufferView')
+          error(:image_source_missing, path, 'must define exactly one of uri or bufferView') unless uri ^ view
+          if uri && (!image['uri'].is_a?(String) || image['uri'].empty?)
+            error(:invalid_type, "#{path}/uri",
+                  'must be a non-empty string')
+          end
+          reference('bufferViews', image['bufferView'], "#{path}/bufferView") if view
+          buffer_view = array('bufferViews')[image['bufferView']] if image['bufferView'].is_a?(Integer)
+          if buffer_view.is_a?(Hash) && buffer_view.key?('target')
+            error(:image_buffer_view_target, "#{path}/bufferView", 'image bufferView must not define target')
+          end
+          mime = image['mimeType']
+          error(:image_mime_missing, "#{path}/mimeType", 'is required with bufferView images') if view && mime.nil?
+          if mime && !allowed_mimes.include?(mime)
+            error(:invalid_image_mime, "#{path}/mimeType",
+                  'contains a MIME type unavailable to this document')
+          end
+          validate_image_signature(index, mime, path) if allowed_mimes.include?(mime)
+        end
+      end
+
+      def validate_image_signature(index, mime, path)
+        bytes = context.bytes_for_image(index)
+        return unless bytes
+        return if bytes.start_with?(IMAGE_SIGNATURES[mime])
+
+        error(:image_mime_mismatch, path, "bytes do not match #{mime}")
+      end
+
+      def allowed_mimes
+        @allowed_mimes ||= begin
+          values = %w[image/png image/jpeg]
+          values << 'image/webp' if array('extensionsUsed').include?('EXT_texture_webp')
+          values << 'image/ktx2' if array('extensionsUsed').include?('KHR_texture_basisu')
+          values
+        end
+      end
+
+      def validate_samplers
+        array('samplers').each_with_index do |raw, index|
+          sampler = object(raw, "samplers/#{index}")
+          check_enum(sampler, 'magFilter', [9728, 9729], "samplers/#{index}")
+          check_enum(sampler, 'minFilter', FILTERS, "samplers/#{index}")
+          check_enum(sampler, 'wrapS', WRAPS, "samplers/#{index}")
+          check_enum(sampler, 'wrapT', WRAPS, "samplers/#{index}")
+        end
+      end
+
+      def validate_textures
+        array('textures').each_with_index do |raw, index|
+          texture = object(raw, "textures/#{index}")
+          reference('samplers', texture['sampler'], "textures/#{index}/sampler") if texture.key?('sampler')
+          reference('images', texture['source'], "textures/#{index}/source") if texture.key?('source')
+        end
+      end
+
+      def validate_material(material, index)
+        path = "materials/#{index}"
+        pbr = object(material.fetch('pbrMetallicRoughness', {}), "#{path}/pbrMetallicRoughness")
+        factor(pbr, 'baseColorFactor', 4, "#{path}/pbrMetallicRoughness")
+        unit(pbr, 'metallicFactor', "#{path}/pbrMetallicRoughness")
+        unit(pbr, 'roughnessFactor', "#{path}/pbrMetallicRoughness")
+        factor(material, 'emissiveFactor', 3, path)
+        %w[baseColorTexture metallicRoughnessTexture].each do |key|
+          texture_info(pbr[key], "#{path}/pbrMetallicRoughness/#{key}") if pbr[key]
+        end
+        texture_info(material['normalTexture'], "#{path}/normalTexture") if material['normalTexture']
+        texture_info(material['occlusionTexture'], "#{path}/occlusionTexture") if material['occlusionTexture']
+        texture_info(material['emissiveTexture'], "#{path}/emissiveTexture") if material['emissiveTexture']
+        validate_material_options(material, path)
+        scale = material.dig('normalTexture', 'scale') if material['normalTexture'].is_a?(Hash)
+        return unless !scale.nil? && !finite?(scale)
+
+        error(:invalid_normal_scale, "#{path}/normalTexture/scale",
+              'must be a finite number')
+      end
+
+      def validate_material_options(material, path)
+        alpha = material.fetch('alphaMode', 'OPAQUE')
+        error(:invalid_alpha_mode, "#{path}/alphaMode", 'must be OPAQUE, MASK, or BLEND') unless %w[OPAQUE MASK
+                                                                                                    BLEND].include?(alpha)
+        cutoff = material['alphaCutoff']
+        if cutoff && (!finite?(cutoff) || cutoff.negative?)
+          error(:invalid_alpha_cutoff, "#{path}/alphaCutoff",
+                'must be non-negative')
+        end
+        if cutoff && alpha != 'MASK'
+          warning(:unused_alpha_cutoff, "#{path}/alphaCutoff",
+                  'has no effect unless alphaMode is MASK')
+        end
+        sided = material['doubleSided']
+        error(:invalid_boolean, "#{path}/doubleSided", 'must be boolean') if material.key?('doubleSided') && ![true,
+                                                                                                               false].include?(sided)
+      end
+
+      def texture_info(raw, path)
+        info = object(raw, path)
+        reference('textures', info['index'], "#{path}/index", required: true)
+        tex_coord = info.fetch('texCoord', 0)
+        context.non_negative_integer(tex_coord, "#{path}/texCoord")
+        unit(info, 'strength', path) if info.key?('strength')
+      end
+
+      def factor(owner, key, length, path)
+        return unless owner.key?(key)
+        return unless context.numeric_array(owner[key], length, "#{path}/#{key}")
+        return if owner[key].all? { |value| value.between?(0, 1) }
+
+        error(:factor_out_of_range, "#{path}/#{key}", 'components must be between 0 and 1')
+      end
+
+      def unit(owner, key, path)
+        return unless owner.key?(key)
+
+        value = owner[key]
+        return if finite?(value) && value.between?(0, 1)
+
+        error(:factor_out_of_range, "#{path}/#{key}", 'must be between 0 and 1')
+      end
+
+      def check_enum(owner, key, values, path)
+        return unless owner.key?(key)
+
+        return if values.include?(owner[key])
+
+        error(:invalid_sampler_value, "#{path}/#{key}",
+              'contains an unsupported value')
+      end
+    end
+  end
+end

data/lib/rgltf/validation/meshes.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Validation
+    class Meshes < Rule
+      BUILTIN = /\A(?:POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)\z/
+      CUSTOM = /\A_[A-Z0-9_]+\z/
+      MORPH = %w[POSITION NORMAL TANGENT].freeze
+
+      def validate
+        array('meshes').each_with_index { |raw, index| validate_mesh(object(raw, "meshes/#{index}"), index) }
+      end
+
+      private
+
+      def validate_mesh(mesh, mesh_index)
+        primitives = mesh['primitives']
+        unless primitives.is_a?(Array) && !primitives.empty?
+          error(:mesh_primitives_missing, "meshes/#{mesh_index}/primitives", 'must be a non-empty array')
+          return
+        end
+        target_counts = primitives.each_with_index.map do |raw, primitive_index|
+          validate_primitive(object(raw, "meshes/#{mesh_index}/primitives/#{primitive_index}"), mesh_index,
+                             primitive_index)
+        end
+        if target_counts.uniq.length > 1
+          error(:inconsistent_morph_targets, "meshes/#{mesh_index}/primitives",
+                'all primitives must have the same target count')
+        end
+        validate_weights(mesh['weights'], target_counts.first, "meshes/#{mesh_index}/weights") if mesh.key?('weights')
+      end
+
+      def validate_primitive(primitive, mesh_index, primitive_index)
+        path = "meshes/#{mesh_index}/primitives/#{primitive_index}"
+        mode = primitive.fetch('mode', 4)
+        unless mode.is_a?(Integer) && mode.between?(
+          0, 6
+        )
+          error(:invalid_primitive_mode, "#{path}/mode",
+                'must be between 0 and 6')
+        end
+        reference('materials', primitive['material'], "#{path}/material") if primitive.key?('material')
+        attributes = primitive['attributes']
+        unless attributes.is_a?(Hash) && !attributes.empty?
+          error(:primitive_attributes_missing, "#{path}/attributes", 'must be a non-empty object')
+          attributes = {}
+        end
+        counts = attributes.filter_map do |semantic, accessor_index|
+          validate_attribute(semantic, accessor_index, "#{path}/attributes/#{semantic}")
+        end
+        if counts.uniq.length > 1
+          error(:attribute_count_mismatch, "#{path}/attributes",
+                'all attribute accessors must have equal count')
+        end
+        vertex_count = counts.first
+        if primitive.key?('indices')
+          compressed = primitive.dig('extensions', 'KHR_draco_mesh_compression').is_a?(Hash)
+          validate_indices(primitive['indices'], vertex_count, "#{path}/indices", compressed:)
+        end
+        targets = primitive.fetch('targets', [])
+        unless targets.is_a?(Array)
+          error(:invalid_type, "#{path}/targets", 'must be an array')
+          return 0
+        end
+        targets.each_with_index do |target, index|
+          validate_target(object(target, "#{path}/targets/#{index}"), vertex_count, "#{path}/targets/#{index}")
+        end
+        targets.length
+      end
+
+      def validate_attribute(semantic, accessor_index, path)
+        unless semantic.is_a?(String) && (BUILTIN.match?(semantic) || CUSTOM.match?(semantic))
+          error(:invalid_attribute_semantic, path, 'is not a valid attribute semantic')
+        end
+        return unless reference('accessors', accessor_index, path, required: true)
+
+        accessor = array('accessors')[accessor_index]
+        validate_semantic_type(semantic, accessor, path) if accessor.is_a?(Hash) && BUILTIN.match?(semantic.to_s)
+        validate_view_target(accessor, 34_962, path) if accessor.is_a?(Hash)
+        validate_vertex_alignment(accessor, path) if accessor.is_a?(Hash)
+        accessor['count'] if accessor.is_a?(Hash)
+      end
+
+      def validate_semantic_type(semantic, accessor, path)
+        type = accessor['type']
+        component = accessor['componentType']
+        normalized = accessor.fetch('normalized', false)
+        valid = case semantic
+                when 'POSITION', 'NORMAL' then type == 'VEC3' && component == 5126
+                when 'TANGENT' then type == 'VEC4' && component == 5126
+                when /\ATEXCOORD_/ then type == 'VEC2' && (component == 5126 || ([5121,
+                                                                                  5123].include?(component) && normalized))
+                when /\ACOLOR_/ then %w[VEC3
+                                        VEC4].include?(type) && (component == 5126 || ([5121,
+                                                                                        5123].include?(component) && normalized))
+                when /\AJOINTS_/ then type == 'VEC4' && [5121, 5123].include?(component) && !normalized
+                when /\AWEIGHTS_/ then type == 'VEC4' && (component == 5126 || ([5121,
+                                                                                 5123].include?(component) && normalized))
+                end
+        valid ||= quantized_attribute?(semantic, type, component, normalized)
+        unless valid
+          error(:invalid_attribute_accessor, path,
+                "accessor type or componentType is invalid for #{semantic}")
+        end
+        return unless semantic == 'POSITION' && (!accessor['min'] || !accessor['max'])
+
+        warning(:position_min_max_missing, path, 'POSITION accessor should define min and max')
+      end
+
+      def validate_indices(accessor_index, vertex_count, path, compressed: false)
+        return unless reference('accessors', accessor_index, path, required: true)
+
+        accessor = array('accessors')[accessor_index]
+        return unless accessor.is_a?(Hash)
+
+        unless accessor['type'] == 'SCALAR' && [5121, 5123,
+                                                5125].include?(accessor['componentType']) && !accessor.fetch(
+                                                  'normalized', false
+                                                )
+          error(:invalid_indices_accessor, path, 'must be a SCALAR unsigned integer accessor')
+        end
+        validate_view_target(accessor, 34_963, path)
+        return if compressed
+
+        maximum = accessor['max']&.first
+        maximum ||= decoded_index_max(accessor_index, path)
+        return unless vertex_count.is_a?(Integer) && finite?(maximum) && maximum >= vertex_count
+
+        error(:index_out_of_range, path, 'index maximum must be less than vertex count')
+      end
+
+      def decoded_index_max(accessor_index, path)
+        document = context.document
+        return unless document && document.accessors[accessor_index]
+        return if context.send(:meshopt_decode_target_accessor?, accessor_index)
+
+        document.accessors[accessor_index].to_a.max
+      rescue Error => e
+        error(:indices_unreadable, path, e.message)
+        nil
+      end
+
+      def validate_target(target, vertex_count, path)
+        error(:empty_morph_target, path, 'must contain at least one attribute') if target.empty?
+        target.each do |semantic, accessor_index|
+          unless MORPH.include?(semantic)
+            error(:invalid_morph_semantic, "#{path}/#{semantic}",
+                  'must be POSITION, NORMAL, or TANGENT')
+          end
+          next unless reference('accessors', accessor_index, "#{path}/#{semantic}", required: true)
+
+          accessor = array('accessors')[accessor_index]
+          next unless accessor.is_a?(Hash)
+
+          valid = accessor['type'] == 'VEC3' && accessor['componentType'] == 5126
+          valid ||= quantized_attribute?(
+            semantic,
+            accessor['type'],
+            accessor['componentType'],
+            accessor.fetch('normalized', false),
+            morph: true
+          )
+          error(:invalid_morph_accessor, "#{path}/#{semantic}", 'must be a VEC3 FLOAT accessor') unless valid
+          if vertex_count.is_a?(Integer) && accessor['count'] != vertex_count
+            error(:morph_count_mismatch, "#{path}/#{semantic}",
+                  'count must match primitive attributes')
+          end
+        end
+      end
+
+      def validate_weights(weights, target_count, path)
+        unless weights.is_a?(Array) && weights.all? { |weight| finite?(weight) }
+          error(:invalid_mesh_weights, path, 'must be an array of finite numbers')
+          return
+        end
+        return unless target_count && weights.length != target_count
+
+        error(:mesh_weights_count_mismatch, path,
+              'count must equal morph target count')
+      end
+
+      def validate_view_target(accessor, expected, path)
+        view = array('bufferViews')[accessor['bufferView']] if accessor['bufferView'].is_a?(Integer)
+        return unless view.is_a?(Hash) && view.key?('target') && view['target'] != expected
+
+        error(:buffer_view_target_mismatch, path, 'bufferView target is incompatible with accessor use')
+      end
+
+      def validate_vertex_alignment(accessor, path)
+        view = array('bufferViews')[accessor['bufferView']] if accessor['bufferView'].is_a?(Integer)
+        return unless view.is_a?(Hash)
+
+        absolute = view.fetch('byteOffset', 0)
+        offset = accessor.fetch('byteOffset', 0)
+        return unless absolute.is_a?(Integer) && offset.is_a?(Integer)
+        return if ((absolute + offset) % 4).zero?
+
+        error(:vertex_attribute_misaligned, path, 'vertex attribute absolute offset must be divisible by 4')
+      end
+
+      def quantized_attribute?(semantic, type, component, normalized, morph: false)
+        return false unless array('extensionsUsed').include?('KHR_mesh_quantization')
+
+        case semantic
+        when 'POSITION' then type == 'VEC3' && [5120, 5121, 5122, 5123].include?(component)
+        when 'NORMAL' then type == 'VEC3' && [5120, 5122].include?(component) && normalized
+        when 'TANGENT' then type == (morph ? 'VEC3' : 'VEC4') && [5120, 5122].include?(component) && normalized
+        when /\ATEXCOORD_/ then type == 'VEC2' && [5120, 5121, 5122, 5123].include?(component)
+        else false
+        end
+      end
+    end
+  end
+end