glslkit 0.1.0.pre

data/lib/glslkit/preprocessor.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "digest"
+require_relative "errors"
+require_relative "source"
+require_relative "source_map"
+require_relative "reflection"
+
+module Glslkit
+  class Preprocessor
+    INCLUDE_PATTERN = /\A[ \t]*#[ \t]*include[ \t]*(?:"([^"]+)"|<([^>]+)>)[ \t]*\z/
+    VERSION_PATTERN = /\A[ \t]*#[ \t]*version\b/
+    EXTENSION_PATTERN = /\A[ \t]*#[ \t]*extension\b/
+    PRAGMA_ONCE_PATTERN = /\A[ \t]*#[ \t]*pragma[ \t]+once[ \t]*\z/
+
+    def initialize(resolver:, line_directives: true)
+      @resolver = resolver
+      @line_directives = line_directives
+    end
+
+    def process(entry_request)
+      run = Run.new
+      canonical_path, content = @resolver.read(entry_request, from: nil)
+      expand(run, canonical_path, content)
+
+      header = []
+      header << run.version if run.version
+      header.concat(run.extensions)
+
+      code = "#{(header + run.body).join("\n")}\n"
+
+      # segmentsはbody基準(ヘッダを含まない)の行番号で溜めてあるので、
+      # ヘッダの行数だけ一括でずらしてからSourceMapに登録する。ヘッダの
+      # 行数はexpand()完了まで確定しない(#versionがどのファイルで見つかる
+      # かは走査してみないと分からない)ため、この2段階が必要になる。
+      run.segments.each do |body_line, file_index, source_line|
+        run.source_map.add_segment(output_line: header.size + body_line, file_index: file_index, source_line: source_line)
+      end
+
+      Source.new(
+        code: code,
+        source_map: run.source_map,
+        reflection: Reflection.new(code),
+        digest: Digest.hexdigest(code)
+      )
+    end
+
+    private
+
+    # トップレベルの#process呼び出し1回分の間で共有される可変状態。
+    class Run
+      attr_accessor :version
+      attr_reader :source_map, :extensions, :body, :ancestor_stack, :segments
+
+      def initialize
+        @source_map = SourceMap.new
+        @extensions = []
+        @extension_set = Set.new
+        @pragma_once_seen = Set.new
+        @ancestor_stack = []
+        @body = []
+        @segments = [] # [body_relative_output_line, file_index, source_line]
+      end
+
+      def pragma_once?(canonical_path)
+        @pragma_once_seen.include?(canonical_path)
+      end
+
+      def mark_pragma_once(canonical_path)
+        @pragma_once_seen << canonical_path
+      end
+
+      def add_extension(value)
+        return if @extension_set.include?(value)
+
+        @extension_set << value
+        @extensions << value
+      end
+    end
+    private_constant :Run
+
+    def expand(run, canonical_path, content)
+      if run.ancestor_stack.include?(canonical_path)
+        chain = (run.ancestor_stack + [canonical_path]).join(" -> ")
+        raise CircularIncludeError, chain
+      end
+
+      file_index = run.source_map.index_for(canonical_path)
+      run.ancestor_stack.push(canonical_path)
+      needs_marker = true
+
+      content.each_line.with_index(1) do |raw_line, lineno|
+        line = raw_line.chomp
+
+        case line
+        when PRAGMA_ONCE_PATTERN
+          run.mark_pragma_once(canonical_path)
+          needs_marker = true
+        when VERSION_PATTERN
+          value = line.strip
+          if run.version && run.version != value
+            raise VersionConflictError, "#{run.version.inspect} vs #{value.inspect} (in #{canonical_path})"
+          end
+          run.version = value
+          needs_marker = true
+        when EXTENSION_PATTERN
+          run.add_extension(line.strip)
+          needs_marker = true
+        when INCLUDE_PATTERN
+          request = $1 || $2
+          from = canonical_path if $1 # `<>` never resolves relative to the includer
+          child_canonical, child_content = @resolver.read(request, from: from)
+          expand(run, child_canonical, child_content) unless run.pragma_once?(child_canonical)
+          needs_marker = true
+        else
+          if needs_marker
+            run.body << "#line #{lineno} #{file_index}" if @line_directives
+            # line_directivesの値に関わらず区間は必ず記録する(§8.1の決定事項:
+            # テキストの#lineは描画に過ぎず、位置情報の正はこちらが持つ)。
+            run.segments << [run.body.size + 1, file_index, lineno]
+            needs_marker = false
+          end
+          run.body << line
+        end
+      end
+
+      run.ancestor_stack.pop
+    end
+  end
+end

data/lib/glslkit/program.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Glslkit
+  # ValidatorとManifest.buildが共有する薄い値オブジェクト(§8.3)。
+  # sourcesはマージ前の Glslkit::Source をそのまま保持する — E006(同一ステージ内の
+  # 重複宣言)はマージ後のデータからは検出できないため、生のReflectionへの
+  # アクセスが必要になる。
+  class Program
+    STAGES = %i[vertex fragment].freeze
+
+    attr_reader :name, :sources
+
+    def initialize(name:, sources:)
+      unless sources.is_a?(Hash) && !sources.empty? && (sources.keys - STAGES).empty?
+        raise ArgumentError, "sources must be a non-empty Hash with only :vertex and/or :fragment keys"
+      end
+
+      @name = name
+      @sources = sources
+    end
+
+    def vertex
+      sources[:vertex]
+    end
+
+    def fragment
+      sources[:fragment]
+    end
+  end
+end

data/lib/glslkit/reflection.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "strscan"
+require_relative "types"
+require_relative "errors"
+
+module Glslkit
+  # 平坦化済み(#include展開後)のGLSLをスキャンして、トップレベルの
+  # in/out/uniform宣言を抽出する。これは意図的に本格的なパーサにはしていない:
+  # コメントと、プリプロセッサディレクティブ行(#version, #line, #ifdefなど、
+  # glslkit自身のPreprocessorが残しうるもの全般)を除去し、{}のネスト深度を
+  # 追跡して深度0の宣言以外(関数本体、ブロック本体)をスキップし、深度0の
+  # `;`区切り文を1つずつ正規表現でマッチさせる。struct定義、uniform blockの
+  # メンバリスト、const/ローカル宣言は意図的にそれ以上パースしない。
+  #
+  # 各宣言は`output_line`(渡されたcodeの中での行番号)を保持する(§8.1)。
+  # ただしこれはあくまで「渡されたcode文字列の中の行番号」であり、元ファイルの
+  # 行番号ではない。元ファイルへの変換はGlslkit::SourceMap#resolveの役目で、
+  # ReflectionはSourceMapの存在を知らない(責務を分離するため)。
+  class Reflection
+    Attribute = Struct.new(:name, :type, :location, :array_size, :output_line, keyword_init: true)
+    Uniform = Struct.new(:name, :type, :array_size, :setter, :matrix, :sampler, :output_line, keyword_init: true)
+    UniformBlock = Struct.new(:name, :layout, :binding, :output_line, keyword_init: true)
+    Output = Struct.new(:name, :type, :location, :output_line, keyword_init: true)
+
+    IDENT = /[A-Za-z_]\w*/
+    PRECISION = /(?:highp|mediump|lowp)\s+/
+    ARRAY_SUFFIX = /(?:\s*\[\s*(\d+)\s*\])?/
+    LAYOUT_PREFIX = /(?:layout\s*\(([^)]*)\)\s*)?/
+
+    UNIFORM_BLOCK_PATTERN = /\A#{LAYOUT_PREFIX}uniform\s+(#{IDENT})\s*\{/
+    UNIFORM_PATTERN = /\Auniform\s+#{PRECISION}?(#{IDENT})\s+(#{IDENT})#{ARRAY_SUFFIX}\z/
+    ATTRIBUTE_PATTERN = /\A#{LAYOUT_PREFIX}in\s+#{PRECISION}?(#{IDENT})\s+(#{IDENT})#{ARRAY_SUFFIX}\z/
+    OUTPUT_PATTERN = /\A#{LAYOUT_PREFIX}out\s+#{PRECISION}?(#{IDENT})\s+(#{IDENT})#{ARRAY_SUFFIX}\z/
+
+    attr_reader :attributes, :uniforms, :uniform_blocks, :outputs
+
+    def initialize(code)
+      @attributes = []
+      @uniforms = []
+      @uniform_blocks = []
+      @outputs = []
+
+      split_top_level_statements(strip_noise(code)).each do |statement, output_line|
+        classify(statement.strip, output_line)
+      end
+    end
+
+    private
+
+    # コメント・ディレクティブ行を除去するが、行数は必ず保つ(§8.1)。
+    # split_top_level_statements が数える行番号は、この除去後のテキストに
+    # 対して数える(=コメント除去前後で行数が変わらないことが前提)。
+    def strip_noise(code)
+      without_comments = code.gsub(%r{//[^\n]*|/\*.*?\*/}m) do |match|
+        newlines = match.count("\n")
+        newlines.positive? ? ("\n" * newlines) : " "
+      end
+      without_comments.gsub(/^[ \t]*#.*$/, "")
+    end
+
+    # 波括弧の深度が0の時に現れた`;`だけで分割する。これにより関数本体や
+    # uniform blockのメンバリスト内の`;`が文の終端として扱われることはない。
+    # 深度0に戻る`}`の直後に`;`が続かない場合(つまりuniform blockではなく
+    # 関数/制御構文の本体である場合)は、それまで溜めていたものを破棄する。
+    #
+    # 各要素は [文の本体, 文の(先頭の空白を除いた)開始行番号] のペア。
+    def split_top_level_statements(code)
+      scanner = StringScanner.new(code)
+      statements = []
+      buffer = +""
+      depth = 0
+      line = 1
+
+      until scanner.eos?
+        chunk = scanner.scan_until(/[{};]/)
+        break if chunk.nil?
+
+        buffer << chunk
+        line += chunk.count("\n")
+
+        case chunk[-1]
+        when "{"
+          depth += 1
+        when "}"
+          depth -= 1
+          buffer = +"" if depth.zero? && !scanner.check(/[ \t\r\n]*;/)
+        when ";"
+          if depth.zero?
+            statements << statement_with_start_line(buffer[0..-2], line)
+            buffer = +""
+          end
+        end
+      end
+
+      statements
+    end
+
+    # rawの末尾(;を除いた部分)がline行目で終わっているとして、rawの
+    # 先頭の空白(改行含む)を除いた実内容が何行目から始まるかを逆算する。
+    def statement_with_start_line(raw, end_line)
+      leading_whitespace = raw[/\A\s*/]
+      start_line = end_line - raw.count("\n") + leading_whitespace.count("\n")
+      [raw, start_line]
+    end
+
+    def classify(statement, output_line)
+      return if statement.empty?
+
+      case statement
+      when UNIFORM_BLOCK_PATTERN
+        add_uniform_block($~, output_line)
+      when UNIFORM_PATTERN
+        add_uniform($~, output_line)
+      when ATTRIBUTE_PATTERN
+        add_attribute($~, output_line)
+      when OUTPUT_PATTERN
+        add_output($~, output_line)
+      end
+    end
+
+    def add_uniform_block(match, output_line)
+      layout_body = match[1]
+      @uniform_blocks << UniformBlock.new(
+        name: match[2],
+        layout: packing_layout(layout_body),
+        binding: qualifier_value(layout_body, "binding"),
+        output_line: output_line
+      )
+    end
+
+    def add_uniform(match, output_line)
+      type = match[1]
+      @uniforms << Uniform.new(
+        name: match[2],
+        type: type,
+        array_size: (match[3] || 1).to_i,
+        setter: Types.setter_for(type),
+        matrix: Types.matrix?(type),
+        sampler: Types.sampler?(type),
+        output_line: output_line
+      )
+    end
+
+    def add_attribute(match, output_line)
+      @attributes << Attribute.new(
+        name: match[3],
+        type: match[2],
+        location: qualifier_value(match[1], "location"),
+        array_size: (match[4] || 1).to_i,
+        output_line: output_line
+      )
+    end
+
+    def add_output(match, output_line)
+      @outputs << Output.new(
+        name: match[3],
+        type: match[2],
+        location: qualifier_value(match[1], "location"),
+        output_line: output_line
+      )
+    end
+
+    def qualifier_value(layout_body, key)
+      return nil unless layout_body
+
+      m = layout_body.match(/\b#{key}\s*=\s*(\d+)/)
+      m && m[1].to_i
+    end
+
+    def packing_layout(layout_body)
+      return "shared" unless layout_body
+
+      m = layout_body.match(/\b(std140|std430|shared|packed)\b/)
+      m ? m[1] : "shared"
+    end
+  end
+end

data/lib/glslkit/resolver.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Glslkit
+  # #include のリクエストを解決するダックタイピングのインタフェース。継承を
+  # 強制するものではない — 下の Glslkit::Resolvers::FileSystem と ::Hash は
+  # 単にこれと同じメソッド形状を実装しているだけ。Railsや将来のruby.wasm側の
+  # resolverも同じ形状に合わせればよい。
+  #
+  #   read(request, from:) -> [canonical_path, content]
+  #
+  #     request        - #include の後に書かれた文字列。例 "common/math.glsl"
+  #     from            - 呼び出し元(includeした側)のcanonical_path。
+  #                       エントリポイントではnil (`#include <...>` の場合も
+  #                       常にnilを渡し、相対探索を完全にスキップさせる)
+  #     canonical_path  - 解決したファイルを表す、load_path相対の安定した
+  #                       識別子 (循環検出、#pragma once、
+  #                       Glslkit::SourceMap#files で使う)
+  #
+  #   requestが解決できない場合は Glslkit::IncludeNotFound を raise すること。
+  module Resolver
+  end
+end

data/lib/glslkit/resolvers/file_system.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Glslkit
+  module Resolvers
+    # ディスク上のload_paths群に対して#includeのリクエストを解決する。
+    # canonical_pathは常に、マッチしたload_pathからの相対パスとして表現される
+    # (例 "common/math.glsl")。絶対パスになることはない —
+    # この結果を元に作られるマニフェストはブラウザに配信されるものなので、
+    # ローカルの絶対パスを漏らしてはならない。
+    class FileSystem
+      def initialize(load_paths:)
+        @load_paths = load_paths.map { |path| File.expand_path(path) }
+        @absolute_paths = {} # canonical_path => 絶対パス。相対探索のためのキャッシュ
+      end
+
+      def read(request, from: nil)
+        absolute = resolve_absolute_path(request, from)
+        canonical = canonicalize(absolute)
+        @absolute_paths[canonical] = absolute
+        [canonical, File.read(absolute)]
+      end
+
+      private
+
+      def resolve_absolute_path(request, from)
+        candidates = []
+        candidates << File.expand_path(File.join(File.dirname(@absolute_paths.fetch(from)), request)) if from
+        @load_paths.each { |load_path| candidates << File.expand_path(File.join(load_path, request)) }
+
+        candidates.each do |candidate|
+          next unless within_any_load_path?(candidate)
+          return candidate if File.file?(candidate)
+        end
+
+        # 存在確認より先に境界チェックを行う(escapeしているのにたまたま存在
+        # しないrequestに対してIncludeNotFoundを出すのではなく)。これにより
+        # PathTraversalErrorの判定が、load_paths外に実際に何が存在するかに
+        # 依存しなくなる。
+        if candidates.any? { |candidate| !within_any_load_path?(candidate) }
+          raise PathTraversalError, "#include #{request.inspect} escapes the configured load_paths"
+        end
+
+        raise IncludeNotFound, "could not resolve #include #{request.inspect}"
+      end
+
+      def within_any_load_path?(candidate)
+        @load_paths.any? { |load_path| within?(load_path, candidate) }
+      end
+
+      def within?(load_path, candidate)
+        candidate == load_path || candidate.start_with?("#{load_path}#{File::SEPARATOR}")
+      end
+
+      def canonicalize(absolute)
+        load_path = @load_paths.find { |lp| within?(lp, absolute) }
+        absolute.delete_prefix("#{load_path}#{File::SEPARATOR}")
+      end
+    end
+  end
+end

data/lib/glslkit/resolvers/hash.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Glslkit
+  module Resolvers
+    # {request => content} というフラットなHashを直接引くだけ。ファイル
+    # システムを持たないwasm側ランタイムやテストで使う。`from`はインタ
+    # フェースの形を合わせるために受け取るが無視する。ディレクトリ構造が
+    # 存在しないため、相対解決のしようがない。
+    class Hash
+      def initialize(files)
+        @files = files
+      end
+
+      def read(request, from: nil)
+        content = @files[request]
+        raise IncludeNotFound, "no such include: #{request.inspect}" unless content
+
+        [request, content]
+      end
+    end
+  end
+end

data/lib/glslkit/runtime.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# マニフェストの読み込みと SourceMap の復元だけに必要な、狭い入口(M8g)。
+# ruby.wasm 上の消費側(glslkit-webgl 等)からはこちらを require すること。
+#
+# `glslkit/preprocessor` / `glslkit/reflection` / `glslkit/minifier` /
+# `glslkit/digest` は意図的にロードしない。ビルド用途(前処理・解析・
+# digest計算)は従来通り `require "glslkit"`(core/lib/glslkit.rb)を使うこと。
+#
+# `glslkit/diagnostic` は例外(M11d、Context#reload_programの戻り値が使う)。
+# stdlib依存も他ファイルへのrequireも無いプレーンなStructなので、狭い入口の
+# 制約(File/Dir/digestを持ち込まない)を破らない。
+require_relative "errors"
+require_relative "types"
+require_relative "source_map"
+require_relative "manifest"
+require_relative "diagnostic"
+
+module Glslkit
+end

data/lib/glslkit/source.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Glslkit
+  Source = Struct.new(:code, :source_map, :reflection, :digest, keyword_init: true)
+end

data/lib/glslkit/source_map.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Glslkit
+  # 出力される `#line <n> <index>` ディレクティブで使われるファイル
+  # インデックスを、各インデックスが指すcanonical_pathに逆引きする。
+  #
+  # あわせて「平坦化後の出力行 → (元ファイル, 元の行)」の区間マッピングを
+  # 保持する(§8.1)。テキスト上の`#line`ディレクティブはこのマッピングを
+  # 人間/GLSLコンパイラ向けに描画したものに過ぎず、`line_directives: false`
+  # で抑止されていてもこちらは常に記録される。
+  class SourceMap
+    class UnsupportedVersionError < StandardError; end
+
+    Segment = Struct.new(:output_line, :file_index, :source_line)
+    private_constant :Segment
+
+    # spec/schema/source-map-v1.json に対応するHashから復元する(M8g)。
+    # `segments` は `output_line` 昇順であることを前提にする(`to_h` は
+    # 常にソート済みで出力する)。ソートされていない入力を渡した場合の
+    # `resolve` の結果は未定義— 呼び出し側で保証すること。
+    def self.from_h(hash)
+      version = hash.fetch("version")
+      raise UnsupportedVersionError, "unsupported source map version: #{version.inspect}" unless version == 1
+
+      source_map = new
+      hash.fetch("files").each { |path| source_map.index_for(path) }
+      hash.fetch("segments").each do |output_line, file_index, source_line|
+        source_map.add_segment(output_line: output_line, file_index: file_index, source_line: source_line)
+      end
+      source_map
+    end
+
+    def initialize
+      @files = []
+      @index_by_path = {}
+      @segments = []
+    end
+
+    attr_reader :files
+
+    # spec/schema/source-map-v1.json に対応するHashを返す。`segments` は
+    # 呼び出し順(=Preprocessorがoutput_line昇順で呼ぶ順)を信頼せず、
+    # 明示的に `output_line` 昇順にソートしてから出力する。
+    def to_h
+      {
+        "version" => 1,
+        "files" => @files,
+        "segments" => @segments.sort_by(&:output_line).map { |s| [s.output_line, s.file_index, s.source_line] }
+      }
+    end
+
+    def index_for(path)
+      @index_by_path[path] ||= begin
+        @files << path
+        @files.size - 1
+      end
+    end
+
+    # output_line以降、次のadd_segment呼び出しまで(または出力の終わりまで)は
+    # file_indexのファイルのsource_line以降に1対1で対応する、という区間を
+    # 登録する。呼び出し順はoutput_line昇順であること(Preprocessorはこの順で
+    # 呼ぶ)。
+    def add_segment(output_line:, file_index:, source_line:)
+      @segments << Segment.new(output_line, file_index, source_line)
+    end
+
+    # output_lineが属する区間を二分探索し、[canonical_path, source_line]を
+    # 返す。どの区間にも属さない(記録前の行、または区間が1つも無い)場合はnil。
+    def resolve(output_line)
+      segment = segment_for(output_line)
+      return nil unless segment
+
+      [@files[segment.file_index], segment.source_line + (output_line - segment.output_line)]
+    end
+
+    private
+
+    def segment_for(output_line)
+      return nil if @segments.empty?
+
+      index = @segments.bsearch_index { |segment| segment.output_line > output_line }
+      index = @segments.size if index.nil?
+      return nil if index.zero?
+
+      @segments[index - 1]
+    end
+  end
+end

data/lib/glslkit/types.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Glslkit
+  # GLSLの型名をWebGL2のsetterに対応付ける唯一の正。wasm側のWebGL
+  # バインディングはこのテーブルを自前で再実装するのではなく、
+  # Types.setter_for("mat4") 等を呼び出すことを想定している。
+  module Types
+    NON_MATRIX_SETTERS = {
+      "float" => "uniform1fv",
+      "vec2" => "uniform2fv",
+      "vec3" => "uniform3fv",
+      "vec4" => "uniform4fv",
+      "int" => "uniform1iv",
+      "bool" => "uniform1iv",
+      "ivec2" => "uniform2iv",
+      "bvec2" => "uniform2iv",
+      "ivec3" => "uniform3iv",
+      "bvec3" => "uniform3iv",
+      "ivec4" => "uniform4iv",
+      "bvec4" => "uniform4iv",
+      "uint" => "uniform1uiv",
+      "uvec2" => "uniform2uiv",
+      "uvec3" => "uniform3uiv",
+      "uvec4" => "uniform4uiv"
+    }.freeze
+
+    MATRIX_SETTERS = {
+      "mat2" => "uniformMatrix2fv",
+      "mat3" => "uniformMatrix3fv",
+      "mat4" => "uniformMatrix4fv",
+      "mat2x3" => "uniformMatrix2x3fv",
+      "mat2x4" => "uniformMatrix2x4fv",
+      "mat3x2" => "uniformMatrix3x2fv",
+      "mat3x4" => "uniformMatrix3x4fv",
+      "mat4x2" => "uniformMatrix4x2fv",
+      "mat4x3" => "uniformMatrix4x3fv"
+    }.freeze
+
+    SAMPLER_TYPES = %w[
+      sampler2D sampler3D samplerCube sampler2DArray
+      isampler2D isampler3D isamplerCube isampler2DArray
+      usampler2D usampler3D usamplerCube usampler2DArray
+      sampler2DShadow samplerCubeShadow sampler2DArrayShadow
+    ].freeze
+
+    # 1要素あたりの成分数(§8.5)。setterに渡す配列の期待長(= components * array_size)の
+    # 算出に使う。
+    NON_MATRIX_COMPONENTS = {
+      "float" => 1, "int" => 1, "bool" => 1, "uint" => 1,
+      "vec2" => 2, "ivec2" => 2, "bvec2" => 2, "uvec2" => 2,
+      "vec3" => 3, "ivec3" => 3, "bvec3" => 3, "uvec3" => 3,
+      "vec4" => 4, "ivec4" => 4, "bvec4" => 4, "uvec4" => 4
+    }.freeze
+
+    # matCxR は C列R行の行列(GLSL仕様)。成分数は C * R。
+    MATRIX_COMPONENTS = {
+      "mat2" => 4, "mat3" => 9, "mat4" => 16,
+      "mat2x3" => 6, "mat2x4" => 8,
+      "mat3x2" => 6, "mat3x4" => 12,
+      "mat4x2" => 8, "mat4x3" => 12
+    }.freeze
+
+    ENTRIES = {
+      **NON_MATRIX_SETTERS.to_h { |type, setter|
+        [type, {setter: setter, matrix: false, sampler: false, components: NON_MATRIX_COMPONENTS.fetch(type)}]
+      },
+      **MATRIX_SETTERS.to_h { |type, setter|
+        [type, {setter: setter, matrix: true, sampler: false, components: MATRIX_COMPONENTS.fetch(type)}]
+      },
+      **SAMPLER_TYPES.to_h { |type| [type, {setter: "uniform1iv", matrix: false, sampler: true, components: 1}] }
+    }.freeze
+
+    module_function
+
+    def setter_for(type)
+      entry_for(type)[:setter]
+    end
+
+    def matrix?(type)
+      entry_for(type)[:matrix]
+    end
+
+    def sampler?(type)
+      entry_for(type)[:sampler]
+    end
+
+    def components_for(type)
+      entry_for(type)[:components]
+    end
+
+    def entry_for(type)
+      ENTRIES.fetch(type) { raise UnknownTypeError, "unknown GLSL type: #{type.inspect}" }
+    end
+  end
+end