rgltf 1.0.0

data/lib/rgltf/properties/accessor.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Accessor < Properties::Base
+    COMPONENT_TYPES = AccessorReader::COMPONENT_TYPES
+    ELEMENT_COUNTS = AccessorReader::ELEMENT_COUNTS
+
+    attr_reader :buffer_view, :byte_offset, :component_type, :normalized,
+                :count, :type, :min, :max, :sparse
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :accessor)
+      @buffer_view = optional_reference(document, :buffer_views, json['bufferView'], "accessors/#{index}/bufferView")
+      @byte_offset = json.fetch('byteOffset', 0)
+      @component_type = COMPONENT_TYPES.fetch(json.fetch('componentType'))[:sym]
+      @normalized = json.fetch('normalized', false)
+      @count = json.fetch('count')
+      @type = json.fetch('type')
+      ELEMENT_COUNTS.fetch(@type)
+      @min = json['min']
+      @max = json['max']
+      @sparse = json['sparse'] && Sparse.new(json['sparse'], document:, accessor_index: index)
+    rescue KeyError => e
+      raise FormatError, "invalid accessor #{index}: #{e.message}"
+    end
+
+    def packed
+      @packed ||= AccessorReader.packed(self)
+    end
+
+    def vertex_format
+      component_count = ELEMENT_COUNTS.fetch(type)
+      return nil unless component_count.between?(1, 4)
+
+      prefix = if normalized
+                 { i8: 'snorm8', u8: 'unorm8', i16: 'snorm16', u16: 'unorm16' }[component_type]
+               else
+                 { i8: 'sint8', u8: 'uint8', i16: 'sint16', u16: 'uint16', u32: 'uint32',
+                   f32: 'float32' }[component_type]
+               end
+      return nil unless prefix
+
+      return nil if %i[i8 u8 i16 u16].include?(component_type) && ![2, 4].include?(component_count)
+
+      component_count == 1 ? prefix.to_sym : :"#{prefix}x#{component_count}"
+    end
+
+    def to_a
+      AccessorReader.unpack(self, packed)
+    end
+
+    def each_element
+      return enum_for(:each_element) unless block_given?
+
+      to_a.each do |element|
+        element.is_a?(Array) ? yield(*element) : yield(element)
+      end
+      self
+    end
+
+    def elements
+      enum_for(:each_element)
+    end
+
+    def packed_as_u32
+      unless type == 'SCALAR' && %i[u8 u16 u32].include?(component_type)
+        raise UnsupportedError, 'packed_as_u32 requires a SCALAR unsigned integer accessor'
+      end
+
+      @packed_as_u32 ||= begin
+        directive = AccessorReader::COMPONENTS_BY_SYMBOL.fetch(component_type).fetch(:pack)
+        packed.unpack("#{directive}*").pack('L<*').freeze
+      end
+    end
+
+    def release!
+      @packed = nil
+      @packed_as_u32 = nil
+    end
+
+    def nested_properties
+      sparse ? [sparse] : []
+    end
+
+    private
+
+    def optional_reference(document, collection, value, path)
+      value.nil? ? nil : document.fetch_reference(collection, value, path)
+    end
+  end
+
+  class Accessor
+    class Sparse < Properties::Base
+      attr_reader :count, :indices, :values
+
+      def initialize(json, document:, accessor_index:)
+        super(json, document:, owner_type: :accessor_sparse)
+        @count = json.fetch('count')
+        @indices = Indices.new(json.fetch('indices'), document:, accessor_index:)
+        @values = Values.new(json.fetch('values'), document:, accessor_index:)
+      rescue KeyError => e
+        raise FormatError, "invalid sparse accessor #{accessor_index}: #{e.message}"
+      end
+
+      def nested_properties
+        [indices, values]
+      end
+
+      class Indices < Properties::Base
+        attr_reader :buffer_view, :byte_offset, :component_type
+
+        def initialize(json, document:, accessor_index:)
+          super(json, document:, owner_type: :accessor_sparse_indices)
+          @buffer_view = document.fetch_reference(
+            :buffer_views,
+            json.fetch('bufferView'),
+            "accessors/#{accessor_index}/sparse/indices/bufferView"
+          )
+          @byte_offset = json.fetch('byteOffset', 0)
+          type = AccessorReader::COMPONENT_TYPES.fetch(json.fetch('componentType'))[:sym]
+          raise FormatError, 'sparse indices must be unsigned integers' unless %i[u8 u16 u32].include?(type)
+
+          @component_type = type
+        end
+      end
+
+      class Values < Properties::Base
+        attr_reader :buffer_view, :byte_offset
+
+        def initialize(json, document:, accessor_index:)
+          super(json, document:, owner_type: :accessor_sparse_values)
+          @buffer_view = document.fetch_reference(
+            :buffer_views,
+            json.fetch('bufferView'),
+            "accessors/#{accessor_index}/sparse/values/bufferView"
+          )
+          @byte_offset = json.fetch('byteOffset', 0)
+        end
+      end
+    end
+  end
+end

data/lib/rgltf/properties/animation.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Animation < Properties::Base
+    attr_reader :channels, :samplers
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :animation)
+      @samplers = json.fetch('samplers').each_with_index.map do |sampler, sampler_index|
+        AnimationSampler.new(sampler, document:, animation_index: index, index: sampler_index)
+      end.freeze
+      @channels = json.fetch('channels').each_with_index.map do |channel, channel_index|
+        Channel.new(channel, document:, animation: self, animation_index: index, index: channel_index)
+      end.freeze
+    rescue KeyError => e
+      raise FormatError, "invalid animation #{index}: #{e.message}"
+    end
+
+    def nested_properties
+      [*channels, *samplers]
+    end
+
+    class Channel < Properties::Base
+      TARGET_PATHS = %w[translation rotation scale weights].freeze
+      attr_reader :sampler, :target
+
+      def initialize(json, document:, animation:, animation_index:, index:)
+        super(json, document:, index:, owner_type: :animation_channel)
+        @sampler = animation.samplers.fetch(json.fetch('sampler'))
+        @target = Target.new(json.fetch('target'), document:, animation_index:, channel_index: index)
+      rescue IndexError, KeyError => e
+        raise FormatError, "invalid animation channel: #{e.message}"
+      end
+
+      def target_node
+        target.node
+      end
+
+      def target_path
+        target.path
+      end
+
+      def nested_properties
+        [target]
+      end
+
+      class Target < Properties::Base
+        attr_reader :node, :path
+
+        def initialize(json, document:, animation_index:, channel_index:)
+          super(json, document:, owner_type: :animation_target)
+          @node = optional_node(json['node'], document, animation_index, channel_index)
+          @path = json.fetch('path').to_sym
+          return if Channel::TARGET_PATHS.include?(json['path']) && node
+          return if animation_pointer?(json)
+
+          raise FormatError, "invalid animation target #{json.inspect}"
+        end
+
+        private
+
+        def optional_node(value, document, animation_index, channel_index)
+          return if value.nil?
+
+          document.fetch_reference(
+            :nodes, value, "animations/#{animation_index}/channels/#{channel_index}/target/node"
+          )
+        end
+
+        def animation_pointer?(json)
+          json['path'] == 'pointer' && json.dig('extensions', 'KHR_animation_pointer').is_a?(Hash)
+        end
+      end
+    end
+
+    class AnimationSampler < Properties::Base
+      INTERPOLATIONS = { 'LINEAR' => :linear, 'STEP' => :step, 'CUBICSPLINE' => :cubicspline }.freeze
+      attr_reader :input, :output, :interpolation
+
+      def initialize(json, document:, animation_index:, index:)
+        super(json, document:, index:, owner_type: :animation_sampler)
+        @input = document.fetch_reference(:accessors, json.fetch('input'),
+                                          "animations/#{animation_index}/samplers/#{index}/input")
+        @output = document.fetch_reference(:accessors, json.fetch('output'),
+                                           "animations/#{animation_index}/samplers/#{index}/output")
+        @interpolation = INTERPOLATIONS.fetch(json.fetch('interpolation', 'LINEAR'))
+      rescue KeyError => e
+        raise FormatError, "invalid animation sampler: #{e.message}"
+      end
+
+      def duration
+        input.max&.first || 0.0
+      end
+    end
+  end
+end

data/lib/rgltf/properties/asset.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Asset < Properties::Base
+    attr_reader :copyright, :generator, :version, :min_version
+
+    def initialize(json, document:)
+      super(json, document:, owner_type: :asset)
+      @copyright = json['copyright']
+      @generator = json['generator']
+      @version = json['version']
+      @min_version = json['minVersion']
+    end
+  end
+end

data/lib/rgltf/properties/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rgltf
+  module Properties
+    class Base
+      attr_reader :name, :extensions, :extras, :index, :owner_type, :source_json
+
+      def initialize(json, document:, index: nil, owner_type: nil)
+        @document = document
+        @source_json = json
+        @index = index
+        @name = json['name']
+        @extras = json['extras']
+        @raw_extensions = json.fetch('extensions', {})
+        @extensions = {}
+        @owner_type = owner_type
+      end
+
+      def extension(name)
+        extensions[name]
+      end
+
+      def parse_extensions!
+        return self if @extensions_parsed
+
+        @extensions = @raw_extensions.each_with_object({}) do |(name, value), parsed|
+          parsed[name] = @document.extension_registry.parse(
+            name,
+            value,
+            on: @owner_type,
+            owner: self,
+            doc: @document
+          )
+        end.freeze
+        @extensions_parsed = true
+        nested_properties.each(&:parse_extensions!)
+        self
+      end
+
+      def nested_properties
+        []
+      end
+    end
+  end
+end

data/lib/rgltf/properties/buffer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Buffer < Properties::Base
+    MESHOPT_EXTENSIONS = %w[EXT_meshopt_compression KHR_meshopt_compression].freeze
+    private_constant :MESHOPT_EXTENSIONS
+
+    attr_reader :uri, :byte_length
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :buffer)
+      @uri = json['uri']
+      @byte_length = json.fetch('byteLength')
+    end
+
+    def bytes
+      @document.buffer_resolver.resolve(self)
+    end
+
+    def meshopt_decode_target?
+      return false if uri || !index&.positive?
+      return false if @document.buffer_resolver.send(:supplied?, index)
+
+      meshopt_fallback? || referenced_as_meshopt_target?
+    end
+
+    def meshopt_fallback?
+      required_meshopt_extensions.any? do |name|
+        source_json.dig('extensions', name, 'fallback') == true
+      end
+    end
+
+    def referenced_as_meshopt_target?
+      @document.raw_json.fetch('bufferViews', []).any? do |view|
+        next false unless view.is_a?(Hash) && view['buffer'] == index
+
+        extensions = view['extensions']
+        extensions.is_a?(Hash) && required_meshopt_extensions.any? { |name| extensions[name].is_a?(Hash) }
+      end
+    end
+
+    def required_meshopt_extensions
+      required = @document.extensions_required
+      required.is_a?(Array) ? MESHOPT_EXTENSIONS & required : []
+    end
+
+    private :meshopt_decode_target?, :meshopt_fallback?, :referenced_as_meshopt_target?,
+            :required_meshopt_extensions
+  end
+end

data/lib/rgltf/properties/buffer_view.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class BufferView < Properties::Base
+    TARGETS = { 34_962 => :array_buffer, 34_963 => :element_array_buffer }.freeze
+
+    attr_reader :buffer, :byte_offset, :byte_length, :byte_stride, :target
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :buffer_view)
+      @buffer = document.fetch_reference(:buffers, json.fetch('buffer'), "bufferViews/#{index}/buffer")
+      @byte_offset = json.fetch('byteOffset', 0)
+      @byte_length = json.fetch('byteLength')
+      @byte_stride = json['byteStride']
+      @target = TARGETS.fetch(json['target'], json['target'])
+    end
+  end
+end

data/lib/rgltf/properties/camera.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Camera < Properties::Base
+    attr_reader :type, :perspective, :orthographic
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :camera)
+      @type = json.fetch('type').to_sym
+      case @type
+      when :perspective
+        @perspective = Perspective.new(json.fetch('perspective'), document:)
+      when :orthographic
+        @orthographic = Orthographic.new(json.fetch('orthographic'), document:)
+      else
+        raise FormatError, "camera #{index} has invalid type #{@type.inspect}"
+      end
+    rescue KeyError => e
+      raise FormatError, "invalid camera #{index}: #{e.message}"
+    end
+
+    def nested_properties
+      [perspective || orthographic]
+    end
+
+    class Perspective < Properties::Base
+      attr_reader :aspect_ratio, :yfov, :zfar, :znear
+
+      def initialize(json, document:)
+        super(json, document:, owner_type: :camera_perspective)
+        @aspect_ratio = json['aspectRatio']
+        @yfov = json.fetch('yfov')
+        @zfar = json['zfar']
+        @znear = json.fetch('znear')
+      end
+    end
+
+    class Orthographic < Properties::Base
+      attr_reader :xmag, :ymag, :zfar, :znear
+
+      def initialize(json, document:)
+        super(json, document:, owner_type: :camera_orthographic)
+        @xmag = json.fetch('xmag')
+        @ymag = json.fetch('ymag')
+        @zfar = json.fetch('zfar')
+        @znear = json.fetch('znear')
+      end
+    end
+  end
+end

data/lib/rgltf/properties/image.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Image < Properties::Base
+    attr_reader :mime_type, :buffer_view
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :image)
+      @source_uri = json['uri']
+      @mime_type = json['mimeType']
+      @buffer_view = if json['bufferView'].nil?
+                       nil
+                     else
+                       document.fetch_reference(:buffer_views, json['bufferView'], "images/#{index}/bufferView")
+                     end
+    end
+
+    def uri
+      @source_uri unless @source_uri&.start_with?('data:')
+    end
+
+    def source?
+      buffer_view || @source_uri
+    end
+
+    def bytes
+      @bytes ||= begin
+        data = if buffer_view
+                 buffer_view.buffer.bytes.byteslice(buffer_view.byte_offset, buffer_view.byte_length)
+               elsif @source_uri
+                 @document.buffer_resolver.resolve_resource(@source_uri)
+               else
+                 raise MissingResourceError, "image #{index} has neither uri nor bufferView"
+               end
+        raise FormatError, "image #{index} could not be read" unless data
+        if buffer_view && data.bytesize != buffer_view.byte_length
+          raise FormatError, "image #{index} exceeds its buffer"
+        end
+
+        data.b.freeze
+      end
+    end
+
+    def release!
+      @bytes = nil
+    end
+  end
+end

data/lib/rgltf/properties/material.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class TextureInfo < Properties::Base
+    attr_reader :texture, :tex_coord
+
+    def initialize(json, document:, owner_type: :texture_info)
+      super
+      @texture = document.fetch_reference(:textures, json.fetch('index'), 'textureInfo/index')
+      @tex_coord = json.fetch('texCoord', 0)
+    rescue KeyError => e
+      raise FormatError, "invalid textureInfo: #{e.message}"
+    end
+
+    def transform
+      extension('KHR_texture_transform')
+    end
+  end
+
+  class NormalTextureInfo < TextureInfo
+    attr_reader :scale
+
+    def initialize(json, document:)
+      super
+      @scale = json.fetch('scale', 1.0)
+    end
+  end
+
+  class OcclusionTextureInfo < TextureInfo
+    attr_reader :strength
+
+    def initialize(json, document:)
+      super
+      @strength = json.fetch('strength', 1.0)
+    end
+  end
+
+  class PbrMetallicRoughness < Properties::Base
+    attr_reader :base_color_factor, :base_color_texture, :metallic_factor,
+                :roughness_factor, :metallic_roughness_texture
+
+    def initialize(json, document:)
+      super(json, document:, owner_type: :pbr_metallic_roughness)
+      @base_color_factor = json.fetch('baseColorFactor', [1.0, 1.0, 1.0, 1.0]).freeze
+      @base_color_texture = texture_info(json['baseColorTexture'], document)
+      @metallic_factor = json.fetch('metallicFactor', 1.0)
+      @roughness_factor = json.fetch('roughnessFactor', 1.0)
+      @metallic_roughness_texture = texture_info(json['metallicRoughnessTexture'], document)
+    end
+
+    def nested_properties
+      [base_color_texture, metallic_roughness_texture].compact
+    end
+
+    private
+
+    def texture_info(value, document)
+      TextureInfo.new(value, document:) if value
+    end
+  end
+
+  class Material < Properties::Base
+    ALPHA_MODES = { 'OPAQUE' => :opaque, 'MASK' => :mask, 'BLEND' => :blend }.freeze
+
+    attr_reader :pbr, :normal_texture, :occlusion_texture, :emissive_texture,
+                :emissive_factor, :alpha_mode, :alpha_cutoff, :double_sided
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :material)
+      @pbr = PbrMetallicRoughness.new(json.fetch('pbrMetallicRoughness', {}), document:)
+      @normal_texture = NormalTextureInfo.new(json['normalTexture'], document:) if json['normalTexture']
+      @occlusion_texture = OcclusionTextureInfo.new(json['occlusionTexture'], document:) if json['occlusionTexture']
+      @emissive_texture = TextureInfo.new(json['emissiveTexture'], document:) if json['emissiveTexture']
+      @emissive_factor = json.fetch('emissiveFactor', [0.0, 0.0, 0.0]).freeze
+      @alpha_mode = ALPHA_MODES.fetch(json.fetch('alphaMode', 'OPAQUE'))
+      @alpha_cutoff = json.fetch('alphaCutoff', 0.5)
+      @alpha_cutoff_explicit = json.key?('alphaCutoff')
+      @double_sided = json.fetch('doubleSided', false)
+    rescue KeyError => e
+      raise FormatError, "invalid material #{index}: #{e.message}"
+    end
+
+    def unlit?
+      extensions.key?('KHR_materials_unlit')
+    end
+
+    def alpha_cutoff_explicit?
+      @alpha_cutoff_explicit
+    end
+
+    def nested_properties
+      [pbr, normal_texture, occlusion_texture, emissive_texture].compact
+    end
+  end
+end

data/lib/rgltf/properties/mesh.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Rgltf
+  class Primitive < Properties::Base
+    MODES = {
+      0 => :points, 1 => :lines, 2 => :line_loop, 3 => :line_strip,
+      4 => :triangles, 5 => :triangle_strip, 6 => :triangle_fan
+    }.freeze
+
+    attr_reader :attributes, :indices, :material, :mode, :targets
+
+    def initialize(json, document:, mesh_index:, index:)
+      super(json, document:, index:, owner_type: :primitive)
+      @attributes = json.fetch('attributes').to_h do |semantic, accessor_index|
+        [semantic.to_sym, document.fetch_reference(
+          :accessors,
+          accessor_index,
+          "meshes/#{mesh_index}/primitives/#{index}/attributes/#{semantic}"
+        )]
+      end.freeze
+      @indices = optional_reference(document, :accessors, json['indices'],
+                                    "meshes/#{mesh_index}/primitives/#{index}/indices")
+      @material = optional_reference(document, :materials, json['material'],
+                                     "meshes/#{mesh_index}/primitives/#{index}/material")
+      @mode = MODES.fetch(json.fetch('mode', 4))
+      @targets = json.fetch('targets', []).each_with_index.map do |target, target_index|
+        target.to_h do |semantic, accessor_index|
+          [semantic.to_sym, document.fetch_reference(
+            :accessors,
+            accessor_index,
+            "meshes/#{mesh_index}/primitives/#{index}/targets/#{target_index}/#{semantic}"
+          )]
+        end.freeze
+      end.freeze
+    rescue KeyError => e
+      raise FormatError, "invalid mesh primitive: #{e.message}"
+    end
+
+    private
+
+    def optional_reference(document, collection, value, path)
+      value.nil? ? nil : document.fetch_reference(collection, value, path)
+    end
+  end
+
+  class Mesh < Properties::Base
+    attr_reader :primitives, :weights
+
+    def initialize(json, document:, index:)
+      super(json, document:, index:, owner_type: :mesh)
+      @primitives = json.fetch('primitives').each_with_index.map do |primitive, primitive_index|
+        Primitive.new(primitive, document:, mesh_index: index, index: primitive_index)
+      end.freeze
+      @weights = json['weights']&.freeze
+    rescue KeyError => e
+      raise FormatError, "invalid mesh #{index}: #{e.message}"
+    end
+
+    def nested_properties
+      primitives
+    end
+
+    def replace_primitives!(values)
+      @primitives = values.freeze
+    end
+  end
+end