rgltf 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e30d63eaf8903a7cfaabafc00da633aedd49748e4bd38eba9ef1a7e11be1f31
+  data.tar.gz: ef22f6e011a834d80afadef1b92a5bc0d4d4a00dbef1a9474b8419759974963d
+SHA512:
+  metadata.gz: f51521619a9818267464db92bdac885e5413658993c8f541abaf11b098bd90197dda30feeac28d32a2f3bb14aa64d994f1bc04f8d8442f15f8e1c0655765adc3
+  data.tar.gz: 10cff90e96095d17856d2133b0dd13bc1ee971b367061beb489a0278840c4809ba241c66130b45deda20120fe862e7e865bc16ec7656034866bf1a70d89a1afa

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,270 @@
+# Rgltf
+
+Rgltf is a dependency-free Ruby library for loading, inspecting, building, and
+writing glTF 2.0 JSON and GLB files. Its primary accessor API returns packed,
+little-endian binary strings suitable for direct GPU upload, while Ruby arrays
+remain available for inspection and CPU-side processing.
+
+## Features
+
+- Load glTF 2.0 JSON and GLB from paths, IO objects, or strings.
+- Resolve external files and data URIs with path-traversal protection.
+- Read interleaved, sparse, normalized, and matrix accessors.
+- Return GPU-ready accessor data without converting it to Ruby objects.
+- Traverse scenes and calculate node world transforms.
+- Build and write GLB, external-resource glTF, and embedded glTF.
+- Validate documents and preserve unknown optional extensions.
+- Parse four commonly used Khronos extensions out of the box.
+
+Ruby 3.1 or newer is required.
+
+## Installation
+
+Add Rgltf to your bundle:
+
+```sh
+bundle add rgltf
+```
+
+Alternatively, add it to your `Gemfile` and run `bundle install`:
+
+```ruby
+gem "rgltf"
+```
+
+For a standalone installation:
+
+```sh
+gem install rgltf
+```
+
+## Usage
+
+Require the gem before using its public API:
+
+```ruby
+require "rgltf"
+```
+
+### Loading documents
+
+```ruby
+document = Rgltf.load("assets/model.glb")
+document = Rgltf.load("assets/model.gltf")
+document = Rgltf.load_glb(binary_string)
+document = Rgltf.load_json(json_string, base_dir: "assets")
+```
+
+External resources are resolved relative to the glTF file. Paths that escape
+the base directory are rejected. Buffers are loaded lazily by default; pass
+`lazy: false` to load them immediately.
+
+Pass `validate: true` to validate while loading:
+
+```ruby
+document = Rgltf.load("assets/model.glb", validate: true)
+```
+
+All public failures inherit from `Rgltf::Error`. Invalid documents raise
+`Rgltf::ValidationError`. Unknown required extensions raise
+`Rgltf::UnsupportedExtensionError`; pass `strict_extensions: false` to record
+a warning instead.
+
+### Reading GPU-ready accessor data
+
+```ruby
+primitive = document.meshes.first.primitives.first
+positions = primitive.attributes.fetch(:POSITION)
+
+gpu_bytes = positions.packed       # frozen ASCII-8BIT String
+format = positions.vertex_format   # for example, :float32x3
+values = positions.to_a            # [[x, y, z], ...]
+indices = primitive.indices.packed_as_u32
+```
+
+`packed` resolves interleaved buffer views, sparse accessors, and matrix column
+padding. It preserves normalized integer components; `to_a` converts normalized
+values to floats. Call `document.release_buffers!` after uploading the data when
+the source buffers are no longer needed.
+
+References in the source JSON are resolved to objects while loading:
+
+```ruby
+document.default_scene.nodes.each(&:traverse)
+
+document.each_mesh_instance do |node, mesh, world_matrix|
+  # world_matrix is a 16-element, column-major Ruby Array
+end
+```
+
+### Building and writing documents
+
+```ruby
+document = Rgltf::Builder.build do |builder|
+  builder.asset(generator: "my exporter")
+
+  positions = builder.accessor(:VEC3, :f32, positions_binary, min_max: true)
+  indices = builder.accessor(:SCALAR, :u16, indices_binary, target: :element_array)
+
+  texture = builder.texture(
+    image: File.binread("albedo.png"),
+    mime_type: "image/png",
+    sampler: {wrap_s: :repeat, mag_filter: :linear}
+  )
+  material = builder.material(
+    name: "body",
+    base_color_texture: texture,
+    metallic_factor: 0.0,
+    roughness_factor: 0.8
+  )
+
+  mesh = builder.mesh(name: "hull") do |mesh_builder|
+    mesh_builder.primitive(
+      attributes: {POSITION: positions},
+      indices: indices,
+      material: material
+    )
+  end
+
+  root = builder.node(name: "root", mesh: mesh)
+  builder.scene(nodes: [root], default: true)
+end
+
+document.write_glb("model.glb")
+document.write_gltf("model.gltf")
+document.write_gltf("embedded.gltf", embed: true)
+```
+
+Builder buffer views are aligned to four bytes. Writer validation is enabled by
+default and can be disabled with `validate: false`.
+
+Use explicit buffer views for interleaved records and create sparse accessors
+without constructing dense base buffers:
+
+```ruby
+view = builder.buffer_view(vertex_records, byte_stride: 24, target: :array_buffer)
+positions = builder.accessor_from_view(
+  :VEC3, :f32, buffer_view: view, count: vertex_count
+)
+normals = builder.accessor_from_view(
+  :VEC3, :f32, buffer_view: view, count: vertex_count, byte_offset: 12
+)
+
+weights = builder.sparse_accessor(
+  :SCALAR, :f32,
+  count: vertex_count,
+  indices: changed_vertex_indices,
+  values: changed_weights_binary,
+  index_component_type: :u16
+)
+```
+
+Texture-info handles retain per-use coordinates, transforms, and extras:
+
+```ruby
+info = builder.texture_info(
+  texture,
+  tex_coord: 1,
+  extensions: {"KHR_texture_transform" => {"offset" => [0.5, 0.0]}}
+)
+material = builder.material(base_color_texture: info, double_sided: true)
+
+builder.extensions_used("KHR_texture_transform")
+builder.extension("VENDOR_scene", {"revision" => 2}, required: true)
+builder.extras("exporter" => "example")
+```
+
+Handles belong to the builder that created them. Passing a handle to another
+builder raises `ArgumentError` before an invalid reference can be emitted.
+
+## Extensions
+
+The default extension registry supports:
+
+- `KHR_materials_unlit`
+- `KHR_texture_transform`, including `TextureInfo#transform.uv_matrix`
+- `KHR_lights_punctual`
+- `KHR_materials_emissive_strength`
+
+Register custom parsers on a separate registry when isolation is needed:
+
+```ruby
+registry = Rgltf::ExtensionRegistry.new
+registry.add("VENDOR_example", MyExtension, on: :material)
+document = Rgltf.load(path, extensions: registry)
+```
+
+Unknown optional extension payloads remain Hash objects, so documents can be
+read and written without losing them. A handler's `serialize` method receives
+the parsed object when writing. Handlers may also implement `decode_primitive`
+to provide external Draco or meshopt decoding.
+
+Handlers that omit defaults should declare the properties they handle, leaving
+newer unknown properties untouched:
+
+```ruby
+def self.serialize(object, doc:)
+  value = object.factor == 1.0 ? {} : {"factor" => object.factor}
+  serialize_properties(value, handled_keys: %w[factor])
+end
+```
+
+## Examples
+
+Runnable examples for building, inspecting, and converting assets are available
+in [`examples/`](examples/README.md).
+
+## Development
+
+Clone the repository and install its dependencies:
+
+```sh
+git clone https://github.com/ydah/rgltf.git
+cd rgltf
+bundle install
+```
+
+Run the unit and property suites:
+
+```sh
+bundle exec rake
+```
+
+Property checks use `prop_check` with shrinking and cover every accessor
+component/type combination plus 100 generated Builder-to-GLB round trips. Replay
+a reported case with:
+
+```sh
+PROP_CHECK_SEED=<seed> bundle exec rspec spec/accessor_property_spec.rb
+```
+
+The Khronos glTF-Sample-Assets corpus is pinned to
+`2bac6f8c57bf471df0d2a1e8a8ec023c7801dddf`:
+
+```sh
+bundle exec rake sample_assets:fetch
+GLTF_SAMPLE_ASSETS="$PWD/tmp/gltf-sample-assets" bundle exec rake sample_assets:verify
+```
+
+Corpus verification covers 334 representations, including 310 fully materialized
+representations and 24 containers that require an external Draco or meshopt
+decoder. It also runs a 30-model feature manifest.
+
+The repository additionally provides:
+
+- `benchmark/sample_assets.rb` for repeatable load and accessor benchmarks.
+- A performance workflow that rejects median regressions greater than 30%.
+- A manual official glTF Validator workflow for GLB and glTF writer output.
+- `spec/fixtures/public_api.json` as the machine-readable public API contract.
+
+## Contributing
+
+Bug reports and pull requests are welcome on
+[GitHub](https://github.com/ydah/rgltf). Please include a focused test for
+behavior changes and ensure `bundle exec rake` passes before submitting a pull
+request.
+
+## License
+
+Rgltf is available as open source under the terms of the
+[MIT License](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+Dir[File.join(__dir__, 'tasks', '*.rake')].each { |path| load path }

data/benchmark/accessors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../lib/rgltf'
+
+vertex_count = Integer(ENV.fetch('VERTEX_COUNT', '1000000'))
+source = Array.new(vertex_count * 3, 1.0).pack('e*')
+document = Rgltf.load_json(
+  {
+    'asset' => { 'version' => '2.0' },
+    'buffers' => [{ 'byteLength' => source.bytesize }],
+    'bufferViews' => [{ 'buffer' => 0, 'byteLength' => source.bytesize }],
+    'accessors' => [{ 'bufferView' => 0, 'componentType' => 5126, 'count' => vertex_count, 'type' => 'VEC3' }]
+  },
+  buffers: [source]
+)
+accessor = document.accessors.first
+
+def measure(label)
+  started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  yield
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+  puts format('%-14s %0.6fs', label, elapsed)
+end
+
+measure('packed') { accessor.packed }
+measure('to_a') { accessor.to_a }

data/benchmark/compare.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'json'
+
+base_path, candidate_path = ARGV
+abort 'usage: ruby benchmark/compare.rb BASE.json CANDIDATE.json' unless candidate_path
+threshold = Float(ENV.fetch('BENCHMARK_THRESHOLD', '0.30'))
+base = JSON.parse(File.read(base_path)).fetch('models')
+candidate = JSON.parse(File.read(candidate_path)).fetch('models')
+regressions = []
+
+candidate.each do |model, metrics|
+  metrics.each do |metric, values|
+    baseline = base.fetch(model).fetch(metric).fetch('median')
+    current = values.fetch('median')
+    change = baseline.zero? ? 0.0 : (current - baseline) / baseline
+    puts format('%-24s %-16s base=%0.6fs candidate=%0.6fs change=%+0.1f%%',
+                model, metric, baseline, current, change * 100)
+    regressions << [model, metric, change] if change > threshold
+  end
+end
+
+unless regressions.empty?
+  regressions.each do |model, metric, change|
+    warn format('regression: %s %s increased by %0.1f%%', model, metric, change * 100)
+  end
+  abort "performance regression exceeded #{(threshold * 100).round}%"
+end

data/benchmark/sample_assets.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'json'
+
+library = ENV.fetch('RGLTF_LIB_PATH', File.expand_path('../lib', __dir__))
+$LOAD_PATH.unshift(library)
+require 'rgltf'
+
+root = ENV.fetch('GLTF_SAMPLE_ASSETS') do
+  abort 'Set GLTF_SAMPLE_ASSETS to a pinned glTF-Sample-Assets checkout'
+end
+iterations = Integer(ENV.fetch('BENCHMARK_ITERATIONS', '5'))
+warmup = Integer(ENV.fetch('BENCHMARK_WARMUP', '1'))
+abort 'BENCHMARK_ITERATIONS must be at least 3' if iterations < 3
+
+def measure
+  started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  value = yield
+  [Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at, value]
+end
+
+def median(values)
+  sorted = values.sort
+  middle = sorted.length / 2
+  return sorted.fetch(middle) if sorted.length.odd?
+
+  (sorted.fetch(middle - 1) + sorted.fetch(middle)) / 2.0
+end
+
+def representation(root, model)
+  path = File.join(root, 'Models', model, 'glTF-Binary', "#{model}.glb")
+  abort "Missing benchmark representation: #{path}" unless File.file?(path)
+
+  path
+end
+
+def run_once(path)
+  GC.start
+  load_seconds, document = measure { Rgltf.load(path, strict_extensions: false) }
+  packed_seconds, = measure { document.accessors.each(&:packed) }
+  { 'load_seconds' => load_seconds, 'packed_seconds' => packed_seconds }
+end
+
+models = %w[NodePerformanceTest BrainStem].to_h do |model|
+  path = representation(root, model)
+  warmup.times { run_once(path) }
+  samples = Array.new(iterations) { run_once(path) }
+  metrics = %w[load_seconds packed_seconds].to_h do |metric|
+    values = samples.map { |sample| sample.fetch(metric) }
+    [metric, { 'median' => median(values), 'samples' => values }]
+  end
+  [model, metrics]
+end
+
+puts JSON.pretty_generate(
+  'schema' => 1,
+  'ruby' => RUBY_DESCRIPTION,
+  'warmup' => warmup,
+  'iterations' => iterations,
+  'models' => models
+)

data/examples/README.md

@@ -0,0 +1,23 @@
+# Examples
+
+Run these scripts from the repository with Bundler. When `rgltf` is installed,
+the same commands work without `bundle exec`.
+
+Build a self-contained triangle GLB:
+
+```sh
+bundle exec ruby examples/build_triangle.rb tmp/triangle.glb
+```
+
+Inspect meshes and GPU-ready accessor data:
+
+```sh
+bundle exec ruby examples/inspect.rb tmp/triangle.glb
+```
+
+Convert between GLB and glTF. Add `--embed` to place binary data in a data URI:
+
+```sh
+bundle exec ruby examples/convert.rb model.glb model.gltf --embed
+bundle exec ruby examples/convert.rb model.gltf model.glb
+```

data/examples/build_triangle.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rgltf'
+
+output = File.expand_path(ARGV.fetch(0, 'triangle.glb'))
+abort 'output must use the .glb extension' unless File.extname(output).downcase == '.glb'
+
+positions = [
+  -0.5, -0.5, 0.0,
+  0.5, -0.5, 0.0,
+  0.0, 0.5, 0.0
+].pack('e*')
+colors = [
+  255, 64, 64, 255,
+  64, 255, 64, 255,
+  64, 64, 255, 255
+].pack('C*')
+indices = [0, 1, 2].pack('S<*')
+
+document = Rgltf::Builder.build do |builder|
+  builder.asset(generator: 'rgltf build_triangle example')
+  position_accessor = builder.accessor(:VEC3, :f32, positions, min_max: true)
+  color_accessor = builder.accessor(:VEC4, :u8, colors, normalized: true)
+  index_accessor = builder.accessor(:SCALAR, :u16, indices, target: :element_array)
+  material = builder.material(name: 'vertex colors', metallic_factor: 0.0, roughness_factor: 1.0)
+
+  mesh = builder.mesh(name: 'triangle') do |mesh_builder|
+    mesh_builder.primitive(
+      attributes: { POSITION: position_accessor, COLOR_0: color_accessor },
+      indices: index_accessor,
+      material: material
+    )
+  end
+
+  node = builder.node(name: 'triangle', mesh: mesh)
+  builder.scene(name: 'main', nodes: [node], default: true)
+end
+
+document.write_glb(output)
+puts "wrote #{output}"

data/examples/convert.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rgltf'
+
+embed = ARGV.delete('--embed')
+input, output = ARGV
+abort 'usage: ruby examples/convert.rb INPUT OUTPUT [--embed]' unless input && output && ARGV.length == 2
+
+input = File.expand_path(input)
+output = File.expand_path(output)
+abort 'input and output must be different files' if input == output
+
+document = Rgltf.load(input, validate: true, strict_extensions: false)
+case File.extname(output).downcase
+when '.glb'
+  abort '--embed only applies to .gltf output' if embed
+  document.write_glb(output)
+when '.gltf'
+  document.write_gltf(output, embed: !embed.nil?)
+else
+  abort 'output must use the .glb or .gltf extension'
+end
+
+puts "wrote #{output}"

data/examples/inspect.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rgltf'
+
+path = ARGV.shift || abort('usage: ruby examples/inspect.rb MODEL.glb|MODEL.gltf')
+abort "unexpected arguments: #{ARGV.join(' ')}" unless ARGV.empty?
+
+document = Rgltf.load(path, validate: true, strict_extensions: false)
+puts "asset version: #{document.asset.version}"
+puts "generator: #{document.asset.generator || '(unspecified)'}"
+puts "scenes: #{document.scenes.length}"
+puts "meshes: #{document.meshes.length}"
+
+document.meshes.each_with_index do |mesh, mesh_index|
+  puts "mesh #{mesh_index}: #{mesh.name || '(unnamed)'}"
+  mesh.primitives.each_with_index do |primitive, primitive_index|
+    puts "  primitive #{primitive_index}: #{primitive.mode}"
+    primitive.attributes.each do |semantic, accessor|
+      puts "    #{semantic}: count=#{accessor.count} format=#{accessor.vertex_format || 'n/a'} " \
+           "bytes=#{accessor.packed.bytesize}"
+    end
+    next unless primitive.indices
+
+    puts "    indices: count=#{primitive.indices.count} " \
+         "u32_bytes=#{primitive.indices.packed_as_u32.bytesize}"
+  end
+end

data/lib/rgltf/accessor_reader.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module AccessorReader
+    COMPONENT_TYPES = {
+      5120 => { sym: :i8, size: 1, pack: 'c', min: -128, max: 127 },
+      5121 => { sym: :u8, size: 1, pack: 'C', min: 0, max: 255 },
+      5122 => { sym: :i16, size: 2, pack: 's<', min: -32_768, max: 32_767 },
+      5123 => { sym: :u16, size: 2, pack: 'S<', min: 0, max: 65_535 },
+      5125 => { sym: :u32, size: 4, pack: 'L<', min: 0, max: 4_294_967_295 },
+      5126 => { sym: :f32, size: 4, pack: 'e' }
+    }.freeze
+    COMPONENTS_BY_SYMBOL = COMPONENT_TYPES.to_h { |number, info| [info[:sym], info.merge(number:)] }.freeze
+    ELEMENT_COUNTS = {
+      'SCALAR' => 1, 'VEC2' => 2, 'VEC3' => 3, 'VEC4' => 4,
+      'MAT2' => 4, 'MAT3' => 9, 'MAT4' => 16
+    }.freeze
+    MATRIX_DIMENSIONS = { 'MAT2' => 2, 'MAT3' => 3, 'MAT4' => 4 }.freeze
+
+    module_function
+
+    def packed(accessor)
+      info = COMPONENTS_BY_SYMBOL.fetch(accessor.component_type)
+      count = ELEMENT_COUNTS.fetch(accessor.type)
+      element_size = info[:size] * count
+      base = if accessor.buffer_view
+               extract(
+                 accessor.buffer_view,
+                 accessor.byte_offset,
+                 accessor.count,
+                 accessor.type,
+                 info[:size],
+                 element_size
+               )
+             else
+               "\0".b * (element_size * accessor.count)
+             end
+
+      return base.freeze unless accessor.sparse
+
+      apply_sparse(base, accessor, element_size).freeze
+    end
+
+    def unpack(accessor, bytes)
+      info = COMPONENTS_BY_SYMBOL.fetch(accessor.component_type)
+      values = bytes.unpack("#{info[:pack]}*")
+      values.map! { |value| normalize(value, accessor.component_type) } if accessor.normalized
+      count = ELEMENT_COUNTS.fetch(accessor.type)
+      count == 1 ? values : values.each_slice(count).to_a
+    end
+
+    def storage_element_size(type, component_size)
+      dimension = MATRIX_DIMENSIONS[type]
+      return ELEMENT_COUNTS.fetch(type) * component_size unless dimension && component_size < 4
+
+      aligned_column_size = align4(dimension * component_size)
+      aligned_column_size * dimension
+    end
+
+    def extract(view, accessor_offset, count, type, component_size, output_element_size)
+      storage_size = storage_element_size(type, component_size)
+      stride = view.byte_stride || storage_size
+      start = view.byte_offset + accessor_offset
+      required = count.zero? ? 0 : (stride * (count - 1)) + storage_size
+      if accessor_offset + required > view.byte_length
+        raise FormatError, "accessor data exceeds bufferView #{view.index}"
+      end
+
+      bytes = view.buffer.bytes
+      raise FormatError, "bufferView #{view.index} exceeds its buffer" if start + required > bytes.bytesize
+
+      if stride == output_element_size && storage_size == output_element_size
+        return bytes.byteslice(start, output_element_size * count).dup
+      end
+
+      output = String.new(capacity: output_element_size * count, encoding: Encoding::BINARY)
+      count.times do |element_index|
+        element_start = start + (element_index * stride)
+        append_element(output, bytes, element_start, type, component_size, storage_size)
+      end
+      output
+    end
+
+    def append_element(output, bytes, start, type, component_size, storage_size)
+      dimension = MATRIX_DIMENSIONS[type]
+      unless dimension && component_size < 4
+        output << bytes.byteslice(start, storage_size)
+        return
+      end
+
+      column_size = dimension * component_size
+      column_stride = align4(column_size)
+      dimension.times { |column| output << bytes.byteslice(start + (column * column_stride), column_size) }
+    end
+
+    def apply_sparse(base, accessor, element_size)
+      sparse = accessor.sparse
+      indices_info = COMPONENTS_BY_SYMBOL.fetch(sparse.indices.component_type)
+      index_bytes = extract(
+        sparse.indices.buffer_view,
+        sparse.indices.byte_offset,
+        sparse.count,
+        'SCALAR',
+        indices_info[:size],
+        indices_info[:size]
+      )
+      indices = index_bytes.unpack("#{indices_info[:pack]}*")
+
+      component_size = COMPONENTS_BY_SYMBOL.fetch(accessor.component_type)[:size]
+      values = extract(
+        sparse.values.buffer_view,
+        sparse.values.byte_offset,
+        sparse.count,
+        accessor.type,
+        component_size,
+        element_size
+      )
+
+      output = base.dup
+      indices.each_with_index do |target, sparse_index|
+        raise FormatError, "sparse accessor index #{target} is out of range" if target >= accessor.count
+
+        output[target * element_size, element_size] = values.byteslice(sparse_index * element_size, element_size)
+      end
+      output
+    end
+
+    def normalize(value, type)
+      case type
+      when :i8 then [value / 127.0, -1.0].max
+      when :u8 then value / 255.0
+      when :i16 then [value / 32_767.0, -1.0].max
+      when :u16 then value / 65_535.0
+      else value
+      end
+    end
+
+    def align4(value)
+      (value + 3) & ~3
+    end
+  end
+end