zaniah 0.1.0

data/lib/zaniah/app.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "subscription"
+require_relative "entity"
+require_relative "entity_context"
+require_relative "task_executor"
+
+module Zaniah
+  class App
+    attr_reader :windows, :executor
+
+    def initialize
+      @slots, @generations, @free, @windows, @globals = [], [], [], [], {}
+      @listeners, @effects, @updating, @flushing = {}, [], 0, false
+      @executor = TaskExecutor.new
+    end
+
+    def new_entity
+      id = @free.pop || @slots.length
+      @generations[id] ||= 0
+      entity = Entity.new(id, @generations[id])
+      @slots[id] = yield(EntityContext.new(self, entity))
+      entity
+    rescue Exception
+      @slots[id] = nil if id
+      @free << id if id && !@free.include?(id)
+      raise
+    end
+
+    def read(entity)
+      validate(entity)
+      @slots[entity.id]
+    end
+
+    def update(entity)
+      validate(entity)
+      @updating += 1
+      begin
+        yield(@slots[entity.id], EntityContext.new(self, entity))
+      ensure
+        @updating -= 1
+        flush_effects if @updating.zero?
+      end
+    end
+
+    def release(entity)
+      validate(entity)
+      object = @slots[entity.id]
+      @slots[entity.id] = nil
+      @generations[entity.id] += 1
+      @free << entity.id
+      @listeners.delete_if { |(target, _), _| target == entity }
+      @listeners.each_value { |listeners| listeners.delete_if { |owner, _| owner == entity } }
+      object.dispose if object.respond_to?(:dispose)
+    end
+
+    def entity_count = @slots.length - @free.length
+
+    def global(key, value = (missing = true))
+      missing ? @globals.fetch(key) : @globals[key] = value
+    end
+
+    def listen(kind, target, owner: nil, &callback)
+      validate(target)
+      entry = [owner, callback]
+      list = (@listeners[[target, kind]] ||= [])
+      list << entry
+      Subscription.new { list.delete(entry) }
+    end
+
+    def enqueue(kind, entity, event = nil)
+      @effects << [kind, entity, event]
+      flush_effects if @updating.zero? && !@flushing
+    end
+
+    def flush_effects
+      return if @flushing
+      @flushing = true
+      dirty = false
+      until @effects.empty?
+        effects, @effects = @effects, []
+        notified = {}
+        effects.each do |kind, entity, event|
+          next unless alive?(entity)
+          next if kind == :notify && notified[entity]
+          notified[entity] = true if kind == :notify
+          dirty ||= kind == :notify
+          (@listeners[[entity, kind]] || []).dup.each do |owner, callback|
+            next if owner && !alive?(owner)
+            if owner
+              args = [read(owner), read(entity)]
+              args << event if kind == :emit
+              callback.call(*args, EntityContext.new(self, owner))
+            else
+              callback.call(read(entity), event)
+            end
+          end
+        end
+      end
+      @windows.each(&:request_frame) if dirty
+    ensure
+      @flushing = false
+    end
+
+    def open_window(**options, &render)
+      window = Platform.open_window(**options)
+      @windows << window
+      window.draw(&render) if render
+      window
+    end
+
+    def run
+      until @windows.empty? || @windows.all?(&:closed?)
+        @executor.drain
+        @windows.reject(&:closed?).each(&:tick)
+        @executor.wait(0.05) unless @windows.any?(&:dirty?)
+      end
+    ensure
+      @executor.shutdown
+    end
+
+    def alive?(entity) = @generations[entity.id] == entity.generation && !@free.include?(entity.id) && entity.id < @slots.length
+
+    private
+
+    def validate(entity)
+      raise Error, "entity has been released" unless alive?(entity)
+    end
+  end
+end

data/lib/zaniah/bounds.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Bounds = Data.define(:x, :y, :width, :height) do
+    def right = x + width
+    def bottom = y + height
+    def contains?(point) = point.x >= x && point.y >= y && point.x < right && point.y < bottom
+
+    def intersect(other)
+      left, top = [x, other.x].max, [y, other.y].max
+      Bounds.new(left, top, [[right, other.right].min - left, 0].max,
+        [[bottom, other.bottom].min - top, 0].max)
+    end
+
+    def inset(edges)
+      edges = Edges.all(edges) if edges.is_a?(Numeric)
+      Bounds.new(x + edges.left, y + edges.top,
+        [width - edges.left - edges.right, 0].max,
+        [height - edges.top - edges.bottom, 0].max)
+    end
+  end
+end

data/lib/zaniah/canvas.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Canvas < Element
+    def initialize(&paint)
+      super()
+      @painter = paint
+    end
+
+    def paint(bounds, state, prepaint, cx)
+      super
+      @painter.call(bounds, cx)
+    end
+  end
+end

data/lib/zaniah/color.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Color = Data.define(:r, :g, :b, :a) do
+    def self.parse(value)
+      return value if value.is_a?(self)
+      return new(*value, *(value.length == 3 ? [1.0] : [])) if value.is_a?(Array)
+      hex = value.to_s.delete_prefix("#")
+      hex = hex.chars.map { |character| character * 2 }.join if [3, 4].include?(hex.length)
+      raise ArgumentError, "expected #RGB, #RGBA, #RRGGBB or #RRGGBBAA" unless hex.match?(/\A[0-9a-fA-F]{6}(?:[0-9a-fA-F]{2})?\z/)
+      channels = hex.scan(/../).map { |channel| channel.to_i(16) / 255.0 }
+      channels << 1.0 if channels.length == 3
+      new(*channels)
+    end
+
+    def opacity(value) = Color.new(r, g, b, a * value)
+    def premultiplied = [r * a, g * a, b * a, a]
+    def to_a = [r, g, b, a]
+
+    def mix(other, amount)
+      Color.new(*to_a.zip(Color.parse(other).to_a).map { |x, y| x + (y - x) * amount })
+    end
+
+    def to_hsla
+      max, min = [r, g, b].max, [r, g, b].min
+      delta, lightness = max - min, (max + min) / 2.0
+      return HSLA.new(0, 0, lightness, a) if delta.zero?
+      hue = if max == r then ((g - b) / delta) % 6
+      elsif max == g then (b - r) / delta + 2
+      else (r - g) / delta + 4
+      end
+      HSLA.new(hue / 6.0, delta / (1 - (2 * lightness - 1).abs), lightness, a)
+    end
+  end
+end

data/lib/zaniah/configuration.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Configuration = Struct.new(:font_raster, :shaper, :font_db, :segmenter, keyword_init: true)
+end

data/lib/zaniah/corners.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Corners = Data.define(:top_left, :top_right, :bottom_right, :bottom_left) do
+    def self.all(value) = new(value, value, value, value)
+  end
+end

data/lib/zaniah/data_compat.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Ruby 3.2 added Data; Struct provides the same record operations used here.
+unless defined?(Data)
+  Data = Struct
+  def Data.define(*members, &block)
+    Struct.new(*members) do
+      members.each { |member| undef_method :"#{member}=" }
+      define_method(:initialize) do |*values, **keywords|
+        if keywords.any?
+          raise ArgumentError, "expected either positional or keyword members" unless values.empty? && keywords.keys.sort == members.sort
+          values = members.map { |member| keywords.fetch(member) }
+        end
+        raise ArgumentError, "wrong number of members" unless values.length == members.length
+        super(*values)
+        freeze
+      end
+      define_method(:with) do |**changes|
+        changes.empty? ? self : self.class.new(**to_h.merge(changes))
+      end
+      class_eval(&block) if block
+    end
+  end
+end
+

data/lib/zaniah/device_pixels.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  DevicePixels = Data.define(:value) do
+    def logical(scale) = value / Float(scale)
+  end
+end

data/lib/zaniah/div.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Div < Element; end
+end

data/lib/zaniah/edges.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Edges = Data.define(:top, :right, :bottom, :left) do
+    def self.all(value) = new(value, value, value, value)
+  end
+end

data/lib/zaniah/element.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Element
+    include LengthUnits
+
+    attr_reader :layout_node
+
+    def initialize
+      @style, @children, @handlers = Layout::Style.new, [], {}
+      @background, @border_color, @radius = "#0000", "#0000", 0
+    end
+
+    def child(element)
+      @children << element if element
+      self
+    end
+
+    def children(elements = nil)
+      return @children unless elements
+      elements.each { |element| child(element) }
+      self
+    end
+
+    def style(**properties)
+      @style = @style.merge(**properties)
+      self
+    end
+
+    def key(value) = (@key = value; self)
+    def with_state(&initial) = (@state_initializer = initial; self)
+    def bg(color) = (@background = color; self)
+    def border_color(color) = (@border_color = color; self)
+    def rounded(radius) = (@radius = radius; self)
+    def tooltip(text) = (@tooltip = text.to_s; self)
+    def context_menu(items) = (@context_menu = items; self)
+    def flex = style(display: :flex)
+    def flex_row = style(flex_direction: :row)
+    def flex_col = style(flex_direction: :column)
+    def items_center = style(align_items: :center)
+    def justify_center = style(justify_content: :center)
+    def w_full = style(width: percent(100))
+    def h_full = style(height: percent(100))
+    def flex_1 = style(flex_grow: 1, flex_basis: 0)
+    def overflow_hidden = style(overflow: :hidden)
+
+    {w: :width, h: :height, min_w: :min_width, min_h: :min_height,
+     max_w: :max_width, max_h: :max_height, p: :padding, m: :margin,
+     gap: :gap, border: :border, border_b: :border_bottom}.each do |method, property|
+      define_method(method) { |value| style(**{property => value}) }
+    end
+
+    %i[click hover drag scroll_wheel mouse_down mouse_up].each do |kind|
+      define_method("on_#{kind}") { |&block| @handlers[kind] = block; self }
+    end
+
+    def request_layout(cx)
+      @state = cx.state(@key, &@state_initializer) if @key && @state_initializer
+      @layout_node = Layout::Node.new(style: @style,
+        children: @children.map { |child| child.request_layout(cx) })
+    end
+
+    def prepaint(bounds, _state, cx)
+      unless @handlers.empty? && !@tooltip && !@context_menu
+        cx.dispatcher.hit(bounds) do |event|
+          if event.is_a?(Input::MouseDown) && event.button == :right && @context_menu
+            cx.window.context_menu(@context_menu, position: event.position)
+            next true
+          end
+          cx.window.offer_tooltip(@tooltip, position: event.position) if @tooltip && event.is_a?(Input::MouseMove)
+          kind = case event
+          when Input::MouseDown then @handlers.key?(:mouse_down) ? :mouse_down : :click
+          when Input::MouseMove then @dragging && @handlers.key?(:drag) ? :drag : :hover
+          when Input::MouseUp then :mouse_up
+          when Input::ScrollWheel then :scroll_wheel
+          end
+          handler = @handlers[kind]
+          @dragging = true if event.is_a?(Input::MouseDown) && @handlers[:drag]
+          @dragging = false if event.is_a?(Input::MouseUp)
+          handler&.call(event, cx)
+          @dragging && event.is_a?(Input::MouseDown) ? :capture : !!handler || !!(@tooltip && event.is_a?(Input::MouseMove))
+        end
+      end
+      visit = -> { @children.each { |child| child.prepaint(child.layout_node.bounds, nil, cx) } }
+      @style[:overflow] == :visible ? visit.call : cx.dispatcher.clip(bounds, &visit)
+    end
+
+    def paint(bounds, _state, _prepaint, cx)
+      border = @style[:border].is_a?(Numeric) ? @style[:border] : 0
+      cx.scene.quad(bounds.x, bounds.y, bounds.width, bounds.height,
+        color: @background, radius: @radius, border_width: border, border_color: @border_color)
+      paint_children = -> { @children.each { |child| child.paint(child.layout_node.bounds, nil, nil, cx) unless child.layout_node.style[:display] == :none } }
+      @style[:overflow] == :visible ? paint_children.call : cx.scene.clip(bounds, &paint_children)
+    end
+  end
+end
+
+require_relative "frame_context"
+require_relative "div"
+require_relative "text"
+require_relative "image"
+require_relative "canvas"
+require_relative "overlay"
+require_relative "anchored"
+require_relative "uniform_list"
+require_relative "view"

data/lib/zaniah/entity.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Entity = Data.define(:id, :generation) do
+    def read(app) = app.read(self)
+    def update(app, &block) = app.update(self, &block)
+    def release(app) = app.release(self)
+  end
+end

data/lib/zaniah/entity_context.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class EntityContext
+    attr_reader :app, :entity
+
+    def initialize(app, entity) = (@app, @entity = app, entity)
+    def notify = app.enqueue(:notify, entity)
+    def emit(event) = app.enqueue(:emit, entity, event)
+    def observe(target, &callback) = app.listen(:notify, target, owner: entity, &callback)
+    def subscribe(target, &callback) = app.listen(:emit, target, owner: entity, &callback)
+    def spawn(&block) = app.executor.spawn { block.call(self) }
+    def background(&block) = app.executor.background(&block).await
+    def update(&block) = app.executor.post { block.call(app) }
+    def theme = app.global(:theme)
+  end
+end

data/lib/zaniah/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Error < StandardError; end
+end

data/lib/zaniah/ffi/com.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "library"
+
+module Zaniah
+  module FFI
+    module COM
+      extend self
+      def vcall(this, index, types, result, *values)
+        raise ArgumentError, "null COM interface" if this.to_i.zero?
+        table = Fiddle::Pointer.new(this.to_i)[0, Fiddle::SIZEOF_VOIDP].unpack1("J")
+        address = Fiddle::Pointer.new(table)[index * Fiddle::SIZEOF_VOIDP, Fiddle::SIZEOF_VOIDP].unpack1("J")
+        @functions ||= {}
+        function = @functions[[address, types, result]] ||= Fiddle::Function.new(address, [Fiddle::TYPE_VOIDP, *types], result)
+        function.call(this, *values)
+      end
+      def release(this) = vcall(this, 2, [], Fiddle::TYPE_INT)
+      def check(status)
+        raise Zaniah::Error, "COM failure 0x#{(status & 0xffffffff).to_s(16)}" unless (status & 0x80000000).zero?
+        status
+      end
+    end
+  end
+end

data/lib/zaniah/ffi/library.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module Zaniah
+  module FFI
+    class Library
+      attr_reader :handle
+      def initialize(*candidates)
+        candidates.each do |candidate|
+          begin
+            @handle = Fiddle.dlopen(candidate)
+            break
+          rescue Fiddle::DLError
+            next
+          end
+        end
+        raise LoadError, "native library not found: #{candidates.join(', ')}" unless @handle
+        @functions = {}
+      end
+
+      def fn(name, args, result, need_gvl: true)
+        @functions[[name, args, result, need_gvl]] ||= Fiddle::Function.new(
+          @handle[name.to_s], args, result, name: name.to_s, need_gvl: need_gvl
+        )
+      end
+    end
+  end
+end

data/lib/zaniah/ffi/objc.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "struct"
+
+module Zaniah
+  module FFI
+    module ObjC
+      extend self
+      P = Fiddle::TYPE_VOIDP
+      LIB = Library.new("/usr/lib/libobjc.A.dylib")
+      MESSAGE_SEND = LIB.handle["objc_msgSend"]
+      SCALARS = {void: Fiddle::TYPE_VOID, pointer: P, int: Fiddle::TYPE_INT, uint: Fiddle::TYPE_UINT,
+        long: Fiddle::TYPE_INT64_T, ulong: Fiddle::TYPE_UINT64_T, double: Fiddle::TYPE_DOUBLE,
+        float: Fiddle::TYPE_FLOAT, bool: Fiddle::TYPE_UCHAR}.freeze
+      NO_ARGUMENTS = [].freeze
+      @selectors, @signatures, @closures, @classes = {}, {}, [], {}
+      @signature_lookup = [nil, nil]
+
+      def klass(name)
+        @classes[name] || begin
+          value = LIB.fn(:objc_getClass, [P], P).call(name).to_i
+          @classes[name] = value unless value.zero?
+          value
+        end
+      end
+      def selector(name) = @selectors[name] ||= LIB.fn(:sel_registerName, [P], P).call(name.to_s).to_i
+      def send(receiver, name, *values, args: NO_ARGUMENTS, result: :pointer)
+        raise ArgumentError, "wrong number of native arguments" unless values.length == args.length
+        @signature_lookup[0], @signature_lookup[1] = args, result
+        signature = @signatures[@signature_lookup]
+        unless signature
+          # Fiddle already implements scalar calling conventions. Only aggregate
+          # arguments/returns need the lower-level libffi packing path.
+          signature = if SCALARS.key?(result) && args.all? { |type| SCALARS.key?(type) }
+            Fiddle::Function.new(MESSAGE_SEND, [P, P, *args.map { |type| SCALARS.fetch(type) }],
+              result == :pointer ? Fiddle::TYPE_UINTPTR_T : SCALARS.fetch(result), need_gvl: true)
+          else
+            Struct::Signature.new([:pointer, :pointer, *args], result)
+          end
+          @signatures[[args.dup.freeze, result].freeze] = signature
+        end
+        return signature.call(receiver, selector(name), *values) if signature.is_a?(Fiddle::Function)
+        address = MESSAGE_SEND
+        if RUBY_PLATFORM.include?("x86_64") && [:rect, :region, :clear_color].include?(result)
+          address = LIB.handle["objc_msgSend_stret"]
+        end
+        signature.call(address, receiver, selector(name), *values)
+      end
+      def string(value)
+        bytes = value.to_s.encode(Encoding::UTF_8)
+        send(klass("NSString"), "stringWithUTF8String:", Fiddle::Pointer[bytes + "\0"], args: [:pointer])
+      end
+      def text(object)
+        return "" if object.to_i.zero?
+        pointer = send(object, "UTF8String")
+        pointer.zero? ? "" : Fiddle::Pointer.new(pointer).to_s.force_encoding(Encoding::UTF_8)
+      end
+      def alloc(name) = send(klass(name), "alloc")
+      def new(name) = send(alloc(name), "init")
+      def release(object)
+        send(object, "release", result: :void) unless object.to_i.zero?
+      end
+
+      def subclass(name, parent, protocols: [])
+        found = klass(name)
+        return found unless found.zero?
+        klass = LIB.fn(:objc_allocateClassPair, [P, P, Fiddle::TYPE_SIZE_T], P).call(self.klass(parent), name, 0).to_i
+        protocols.each do |protocol|
+          ptr = LIB.fn(:objc_getProtocol, [P], P).call(protocol)
+          LIB.fn(:class_addProtocol, [P, P], Fiddle::TYPE_BOOL).call(klass, ptr) unless ptr.null?
+        end
+        yield klass
+        LIB.fn(:objc_registerClassPair, [P], Fiddle::TYPE_VOID).call(klass)
+        klass
+      end
+
+      def method(klass, name, args: [], result: :void, encoding:, &block)
+        signature = Struct::Signature.new([:pointer, :pointer, *args], result)
+        closure = signature.closure(&block)
+        @closures << signature
+        ok = LIB.fn(:class_addMethod, [P, P, P, P], Fiddle::TYPE_BOOL).call(klass, selector(name), closure, encoding)
+        raise LoadError, "cannot install #{name}" unless ok
+      end
+    end
+  end
+end

data/lib/zaniah/ffi/struct/signature.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module FFI
+    module Struct
+      class Signature
+        def initialize(arguments, result)
+          @arguments, @result = arguments, result
+          @types = arguments.map { |type| Struct.type(type).to_i }.pack("J*")
+          @cif = Fiddle::Pointer.malloc(256, Fiddle::RUBY_FREE)
+          status = LIB.fn(:ffi_prep_cif, [P, I, I, P, P], I).call(@cif, ABI, arguments.length, Struct.type(result), @types)
+          raise LoadError, "libffi rejected signature (#{status})" unless status.zero?
+        end
+
+        def call(address, *arguments)
+          raise ArgumentError, "wrong number of native arguments" unless arguments.length == @arguments.length
+          values = @arguments.zip(arguments).map { |type, value| Struct.pack(type, value) }
+          pointers = values.map { |value| Fiddle::Pointer[value].to_i }.pack("J*")
+          result = Fiddle::Pointer.malloc(64, Fiddle::RUBY_FREE)
+          LIB.fn(:ffi_call, [P, P, P, P], V).call(@cif, address, result, pointers)
+          Struct.unpack(@result, result)
+        end
+
+        def closure(&block)
+          location = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE)
+          memory = LIB.fn(:ffi_closure_alloc, [Fiddle::TYPE_SIZE_T, P], P).call(256, location)
+          raise NoMemoryError, "ffi_closure_alloc" if memory.null?
+          callback = Fiddle::Closure::BlockCaller.new(V, [P, P, P, P]) do |_cif, result, args, _user|
+            arguments = @arguments.each_with_index.map do |type, index|
+              address = Fiddle::Pointer.new(args)[index * Fiddle::SIZEOF_VOIDP, Fiddle::SIZEOF_VOIDP].unpack1("J")
+              Struct.unpack(type, Fiddle::Pointer.new(address))
+            end
+            bytes = Struct.pack(@result, block.call(*arguments))
+            Fiddle::Pointer.new(result)[0, bytes.bytesize] = bytes unless bytes.empty?
+          end
+          code = location[0, Fiddle::SIZEOF_VOIDP].unpack1("J")
+          status = LIB.fn(:ffi_prep_closure_loc, [P, P, P, P, P], I).call(memory, @cif, callback, 0, code)
+          raise LoadError, "libffi rejected closure (#{status})" unless status.zero?
+          # Objective-C classes outlive Ruby wrappers: retain their IMPs for process lifetime.
+          (@closures ||= []) << [memory, callback]
+          code
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/ffi/struct.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "library"
+
+module Zaniah
+  module FFI
+    # Fiddle's public Function API has scalar types only. libffi itself handles
+    # aggregate arguments/returns, including arm64 homogeneous float aggregates.
+    module Struct
+      extend self
+      P = Fiddle::TYPE_VOIDP
+      I = Fiddle::TYPE_INT
+      V = Fiddle::TYPE_VOID
+      LIB = Library.new("/usr/lib/libffi.dylib", "libffi.so.8", "libffi.so.7", "libffi-8.dll")
+      ABI = if RUBY_PLATFORM.include?("aarch64") || RUBY_PLATFORM.include?("arm64") then 1
+      elsif RUBY_PLATFORM.match?(/mingw|mswin/) then 2
+      else 2
+      end
+      TYPES = {void: ["void", nil], pointer: ["pointer", "J"], int: ["sint32", "i!"],
+               uint: ["uint32", "I!"], long: ["sint64", "q"], ulong: ["uint64", "Q"],
+               double: ["double", "d"], float: ["float", "f"], bool: ["uint8", "C"]}.freeze
+      AGGREGATES = {point: [:double, :double], size: [:double, :double],
+                    rect: [:double, :double, :double, :double], range: [:ulong, :ulong],
+                    region: [:ulong] * 6, scissor: [:ulong] * 4, clear_color: [:double] * 4}.freeze
+
+      def type(name)
+        @types ||= {}
+        @types[name] ||= if TYPES.key?(name)
+          Fiddle::Pointer.new(LIB.handle["ffi_type_#{TYPES.fetch(name)[0]}"])
+        else
+          elements = (AGGREGATES.fetch(name).map { |t| type(t).to_i } << 0).pack("J*")
+          pointer = Fiddle::Pointer.malloc(24, Fiddle::RUBY_FREE)
+          pointer[0, 24] = [0, 0, 13, Fiddle::Pointer[elements].to_i].pack("JSSx4J")
+          (@keep ||= []) << elements
+          pointer
+        end
+      end
+
+      def pack(name, value)
+        return value.pack(AGGREGATES.fetch(name).map { |t| TYPES.fetch(t)[1] }.join) if AGGREGATES.key?(name)
+        format = TYPES.fetch(name)[1]
+        return "" unless format
+        [name == :pointer ? (value.respond_to?(:to_ptr) ? value.to_ptr.to_i : value.to_i) : value].pack(format)
+      end
+
+      def unpack(name, pointer)
+        return nil if name == :void
+        if AGGREGATES.key?(name)
+          format = AGGREGATES.fetch(name).map { |t| TYPES.fetch(t)[1] }.join
+          pointer[0, pack(name, Array.new(AGGREGATES[name].length, 0)).bytesize].unpack(format)
+        else
+          format = TYPES.fetch(name)[1]
+          pointer[0, [0].pack(format).bytesize].unpack1(format)
+        end
+      end
+
+    end
+  end
+end
+
+require_relative "struct/signature"