rugl 0.1.0

data/lib/rugl/command_compiler.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Rugl
+  class CommandCompiler
+    STATE_KEYS = %i[
+      depth blend stencil scissor cull polygon_offset color_mask
+      front_face line_width dither sample viewport
+    ].freeze
+
+    def initialize(context)
+      @context = context
+    end
+
+    def compile(opts)
+      validate_command_opts!(opts)
+
+      program = get_or_create_program(opts.fetch(:vert), opts.fetch(:frag))
+      attributes = compile_attributes(opts[:attributes] || {}, program)
+      uniforms = compile_uniforms(opts[:uniforms] || {}, program)
+      elements = opts[:elements]
+      state = compile_state(opts)
+
+      draw_params = {
+        count: opts[:count],
+        primitive: opts.fetch(:primitive, :triangles),
+        offset: opts.fetch(:offset, 0),
+        instances: opts[:instances]
+      }
+
+      vao = create_vao(attributes, elements)
+
+      Command.new(
+        context: @context,
+        program: program,
+        vao: vao,
+        attributes: attributes,
+        uniforms: uniforms,
+        elements: elements,
+        state: state,
+        draw_params: draw_params,
+        framebuffer: opts[:framebuffer]
+      )
+    end
+
+    private
+
+    def validate_command_opts!(opts)
+      raise CommandError, "command options must be a Hash" unless opts.is_a?(Hash)
+      raise CommandError, "command requires :vert shader source" if opts[:vert].to_s.empty?
+      raise CommandError, "command requires :frag shader source" if opts[:frag].to_s.empty?
+    end
+
+    def get_or_create_program(vert_source, frag_source)
+      key = [vert_source.hash, frag_source.hash]
+      @context.shader_cache[key] ||= Program.new(
+        gl: @context.gl,
+        vert_source: vert_source,
+        frag_source: frag_source,
+        debug: @context.debug
+      )
+    end
+
+    def compile_attributes(raw_attributes, program)
+      raw_attributes.each_with_object({}) do |(name, entry), compiled|
+        compiled[name.to_sym] = compile_single_attribute(name.to_sym, entry, program)
+      end
+    end
+
+    def compile_single_attribute(name, entry, program)
+      location = program.attribute_location(name)
+
+      case entry
+      when Resources::Buffer
+        {
+          location: location,
+          buffer: entry,
+          source: entry,
+          dynamic: false,
+          size: infer_attribute_size(entry),
+          type: entry.type,
+          stride: 0,
+          offset: 0,
+          divisor: nil,
+          normalized: false
+        }
+      when Hash
+        buffer_source = entry.fetch(:buffer, entry[:value])
+        raise CommandError, "Attribute #{name} is missing :buffer" if buffer_source.nil?
+
+        dynamic = Dynamic.dynamic?(buffer_source)
+        {
+          location: location,
+          buffer: dynamic ? nil : buffer_source,
+          source: buffer_source,
+          dynamic: dynamic,
+          size: entry.fetch(:size, infer_attribute_size(buffer_source)),
+          type: entry.fetch(:type, infer_attribute_type(buffer_source)),
+          stride: entry.fetch(:stride, 0),
+          offset: entry.fetch(:offset, 0),
+          divisor: entry[:divisor],
+          normalized: entry.fetch(:normalized, false)
+        }
+      else
+        raise CommandError, "Attribute #{name} must be a Buffer or Hash definition"
+      end
+    end
+
+    def compile_uniforms(raw_uniforms, program)
+      uniform_types = program.uniform_types
+
+      raw_uniforms.each_with_object({}) do |(name, value), compiled|
+        uniform_name = name.to_sym
+        type = uniform_types.fetch(uniform_name, infer_uniform_type(value))
+        compiled[uniform_name] = {
+          value: value,
+          type: type,
+          location: program.uniform_location(uniform_name)
+        }
+      end
+    end
+
+    def compile_state(opts)
+      STATE_KEYS.each_with_object({}) do |key, state|
+        state[key] = opts[key] if opts.key?(key)
+      end
+    end
+
+    def create_vao(attributes, elements)
+      vao = Resources::Vao.new(@context)
+      vao.bind
+
+      attributes.each_value do |spec|
+        next if spec[:dynamic]
+
+        vao.setup_attribute(
+          location: spec[:location],
+          buffer: spec[:buffer],
+          size: spec[:size],
+          type: spec[:type],
+          stride: spec[:stride],
+          offset: spec[:offset],
+          divisor: spec[:divisor],
+          normalized: spec[:normalized]
+        )
+      end
+
+      elements&.bind
+      vao.unbind
+      vao
+    end
+
+    def infer_attribute_size(buffer_like)
+      return 2 unless buffer_like.respond_to?(:length)
+
+      length = buffer_like.length.to_i
+      return 1 if length <= 1
+      return 2 if (length % 2).zero?
+      return 3 if (length % 3).zero?
+      return 4 if (length % 4).zero?
+
+      1
+    end
+
+    def infer_attribute_type(buffer_like)
+      return :float unless buffer_like.respond_to?(:type)
+
+      buffer_like.type
+    end
+
+    def infer_uniform_type(value)
+      return :sampler2D if value.is_a?(Resources::Texture)
+
+      return :int if value.is_a?(Integer)
+      return :float if value.is_a?(Numeric)
+      return :bool if value == true || value == false
+
+      if value.is_a?(Array)
+        case value.length
+        when 2 then :vec2
+        when 3 then :vec3
+        when 4 then :vec4
+        when 9 then :mat3
+        when 16 then :mat4
+        else
+          :float
+        end
+      else
+        :float
+      end
+    end
+  end
+end

data/lib/rugl/context.rb

@@ -0,0 +1,500 @@
+# frozen_string_literal: true
+
+module Rugl
+  class Context
+    class NoopStateManager
+      def apply(_command_state, context:, props:)
+        {}
+      end
+
+      def restore(_previous_state)
+        nil
+      end
+    end
+
+    attr_reader :window, :debug, :state_manager, :shader_cache, :tick, :pixel_ratio, :gl, :glfw
+
+    def initialize(
+      width: nil,
+      height: nil,
+      title: "Rugl",
+      pixel_ratio: 1.0,
+      debug: true,
+      version: [4, 1],
+      profile: :core,
+      samples: nil,
+      window: nil,
+      gl: nil,
+      glfw: nil,
+      state_manager: nil,
+      auto_init: true,
+      **_opts
+    )
+      @width = width
+      @height = height
+      @title = title
+      @pixel_ratio = pixel_ratio
+      @debug = debug
+      @version = version
+      @profile = profile
+      @samples = samples
+      @window = window
+      @gl = gl
+      @glfw = glfw
+      @state_manager = state_manager || default_state_manager
+      @resources = []
+      @shader_cache = {}
+      @scope_stack = []
+      @start_time = monotonic_time
+      @tick = 0
+      @running = false
+      @destroyed = false
+      @compiler = nil
+
+      setup_default_window if auto_init
+    end
+
+    def command(opts)
+      @compiler ||= CommandCompiler.new(self)
+      @compiler.compile(opts)
+    end
+
+    def frame(max_frames: nil, &block)
+      raise ArgumentError, "frame requires a block" unless block
+      raise ContextError, "Context already destroyed" if destroyed?
+
+      cancel = -> { @running = false }
+      @running = true
+      frames = 0
+      frame_limit = max_frames || default_frame_limit
+
+      while @running
+        break if frame_limit && frames >= frame_limit
+        break if window_should_close?
+
+        poll_events
+        @tick += 1
+        block.call(build_context)
+        swap_buffers
+        frames += 1
+      end
+
+      cancel
+    end
+
+    def clear(color: nil, depth: nil, stencil: nil)
+      return unless @gl
+
+      mask = 0
+
+      if color
+        r, g, b, a = normalize_color(color)
+        gl_call(:ClearColor, r, g, b, a)
+        mask |= gl_const(:COLOR_BUFFER_BIT)
+      end
+
+      unless depth.nil?
+        if gl_respond_to?(:ClearDepth)
+          gl_call(:ClearDepth, depth.to_f)
+        elsif gl_respond_to?(:ClearDepthf)
+          gl_call(:ClearDepthf, depth.to_f)
+        end
+        mask |= gl_const(:DEPTH_BUFFER_BIT)
+      end
+
+      unless stencil.nil?
+        gl_call(:ClearStencil, stencil.to_i) if gl_respond_to?(:ClearStencil)
+        mask |= gl_const(:STENCIL_BUFFER_BIT)
+      end
+
+      gl_call(:Clear, mask) if mask.positive? && gl_respond_to?(:Clear)
+      Util.check_gl_error!(gl: @gl, debug: @debug, message: "clear")
+      nil
+    end
+
+    def read(x: 0, y: 0, width: nil, height: nil)
+      read_width, read_height = width_height_or_framebuffer(width, height)
+      byte_length = [read_width * read_height * 4, 0].max
+      buffer = "\0" * byte_length
+      return buffer if @gl.nil?
+
+      return buffer unless gl_respond_to?(:ReadPixels)
+
+      gl_call(
+        :ReadPixels,
+        x.to_i,
+        y.to_i,
+        read_width,
+        read_height,
+        gl_const(:RGBA),
+        gl_const(:UNSIGNED_BYTE),
+        buffer
+      )
+      buffer
+    end
+
+    def destroy
+      return if @destroyed
+
+      @resources.dup.each do |resource|
+        next if !resource.respond_to?(:destroyed?) || resource.destroyed?
+
+        warn "[Rugl] Resource leak detected: #{resource.class}##{resource.respond_to?(:id) ? resource.id : "unknown"}" # rubocop:disable Style/GlobalStdStream
+        resource.destroy if resource.respond_to?(:destroy)
+      end
+
+      if @window && @glfw
+        glfw_call(:DestroyWindow, @window) if glfw_respond_to?(:DestroyWindow)
+      end
+      glfw_call(:Terminate) if @glfw && glfw_respond_to?(:Terminate)
+
+      @destroyed = true
+      @window = nil
+      @running = false
+      nil
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def limits
+      {
+        max_texture_size: query_integer(:MAX_TEXTURE_SIZE),
+        max_viewport_dims: query_integer_array(:MAX_VIEWPORT_DIMS, size: 2),
+        max_vertex_attribs: query_integer(:MAX_VERTEX_ATTRIBS),
+        version: query_version
+      }
+    end
+
+    def has_extension?(name)
+      return false if @gl.nil?
+
+      extension_name = name.to_s
+      return false if extension_name.empty?
+
+      if gl_respond_to?(:GetStringi)
+        count = query_integer(:NUM_EXTENSIONS)
+        return false if count.nil?
+
+        count.times do |index|
+          ext = gl_call(:GetStringi, gl_const(:EXTENSIONS), index)
+          return true if ext.to_s == extension_name
+        end
+        return false
+      end
+
+      return false unless gl_respond_to?(:GetString)
+
+      all_extensions = gl_call(:GetString, gl_const(:EXTENSIONS)).to_s.split
+      all_extensions.include?(extension_name)
+    end
+
+    def current_context
+      build_context
+    end
+
+    def push_scope(state:, props:)
+      @scope_stack << { state: state || {}, props: props || {} }
+    end
+
+    def pop_scope
+      @scope_stack.pop
+    end
+
+    def current_scope_props
+      @scope_stack.each_with_object({}) do |entry, merged|
+        merged.merge!(entry[:props])
+      end
+    end
+
+    def register_resource(resource)
+      @resources << resource
+      resource
+    end
+
+    def unregister_resource(resource)
+      @resources.delete(resource)
+      resource
+    end
+
+    def buffer(source)
+      Resources::Buffer.new(self, source)
+    end
+
+    def elements(source)
+      Resources::Elements.new(self, source)
+    end
+
+    def texture(source = {})
+      Resources::Texture.new(self, source)
+    end
+
+    def renderbuffer(opts)
+      Resources::Renderbuffer.new(self, opts)
+    end
+
+    def framebuffer(opts)
+      Resources::Framebuffer.new(self, opts)
+    end
+
+    def call_gl(name, *args)
+      return nil unless @gl
+
+      Util.gl_call(@gl, name, *args)
+    end
+
+    def gl_supports?(name)
+      return false unless @gl
+
+      snake_name = Util.underscore(name)
+      @gl.respond_to?(name) || @gl.respond_to?(snake_name)
+    end
+
+    def gl_constant(name)
+      Util.gl_const(name, gl: @gl)
+    end
+
+    private
+
+    def default_state_manager
+      return NoopStateManager.new unless defined?(StateManager)
+
+      StateManager.new(gl: @gl)
+    end
+
+    def setup_default_window
+      @gl ||= load_gl_backend
+      @glfw ||= load_glfw_backend
+      return if @window
+      return unless @glfw
+
+      init_glfw
+      create_window
+      make_context_current
+      load_gl_functions
+    end
+
+    def init_glfw
+      return unless glfw_respond_to?(:Init)
+
+      initialized = glfw_call(:Init)
+      raise ContextError, "Failed to initialize GLFW" if initialized == false
+
+      set_window_hints
+    end
+
+    def set_window_hints
+      return unless glfw_respond_to?(:WindowHint)
+
+      major, minor = @version
+      hint(:CONTEXT_VERSION_MAJOR, major)
+      hint(:CONTEXT_VERSION_MINOR, minor)
+      hint(:OPENGL_FORWARD_COMPAT, 1)
+      hint(:OPENGL_PROFILE, profile_constant(@profile))
+      hint(:SAMPLES, @samples) if @samples
+    end
+
+    def hint(name, value)
+      return unless glfw_has_constant?(name)
+
+      glfw_call(:WindowHint, glfw_const(name), value)
+    end
+
+    def profile_constant(profile)
+      case profile&.to_sym
+      when :core
+        glfw_const(:OPENGL_CORE_PROFILE)
+      when :compatibility
+        glfw_const(:OPENGL_COMPAT_PROFILE)
+      else
+        glfw_const(:OPENGL_CORE_PROFILE)
+      end
+    rescue ArgumentError
+      0
+    end
+
+    def create_window
+      return unless glfw_respond_to?(:CreateWindow)
+
+      width = @width || 800
+      height = @height || 600
+      @window = glfw_call(:CreateWindow, width, height, @title, nil, nil)
+      raise ContextError, "Failed to create GLFW window" if @window.nil?
+    end
+
+    def make_context_current
+      return unless @window
+      return unless glfw_respond_to?(:MakeContextCurrent)
+
+      glfw_call(:MakeContextCurrent, @window)
+    end
+
+    def load_gl_functions
+      return unless @gl
+
+      # Supports both `GL.load_lib` and `GL.LoadFunctions` style backends.
+      if @gl.respond_to?(:load_lib)
+        @gl.load_lib
+      elsif @gl.respond_to?(:LoadFunctions)
+        @gl.LoadFunctions
+      end
+    end
+
+    def default_frame_limit
+      return nil if @window
+
+      1
+    end
+
+    def poll_events
+      return unless @glfw && glfw_respond_to?(:PollEvents)
+
+      glfw_call(:PollEvents)
+    end
+
+    def swap_buffers
+      return unless @window
+      return unless @glfw && glfw_respond_to?(:SwapBuffers)
+
+      glfw_call(:SwapBuffers, @window)
+    end
+
+    def window_should_close?
+      return false unless @window
+      return false unless @glfw && glfw_respond_to?(:WindowShouldClose)
+
+      glfw_call(:WindowShouldClose, @window) == true
+    end
+
+    def build_context
+      framebuffer_width, framebuffer_height = framebuffer_size
+      viewport_width, viewport_height = viewport_size
+      {
+        tick: @tick,
+        time: monotonic_time - @start_time,
+        viewport_width: viewport_width,
+        viewport_height: viewport_height,
+        framebuffer_width: framebuffer_width,
+        framebuffer_height: framebuffer_height,
+        drawing_buffer_width: framebuffer_width,
+        drawing_buffer_height: framebuffer_height,
+        pixel_ratio: @pixel_ratio
+      }
+    end
+
+    def viewport_size
+      return [@width || 0, @height || 0] unless @window && @glfw
+      return [@width || 0, @height || 0] unless glfw_respond_to?(:GetWindowSize)
+
+      glfw_call(:GetWindowSize, @window)
+    rescue StandardError
+      [@width || 0, @height || 0]
+    end
+
+    def framebuffer_size
+      return [@width || 0, @height || 0] unless @window && @glfw
+      return [@width || 0, @height || 0] unless glfw_respond_to?(:GetFramebufferSize)
+
+      glfw_call(:GetFramebufferSize, @window)
+    rescue StandardError
+      [@width || 0, @height || 0]
+    end
+
+    def width_height_or_framebuffer(width, height)
+      fb_width, fb_height = framebuffer_size
+      [
+        (width || fb_width).to_i,
+        (height || fb_height).to_i
+      ]
+    end
+
+    def normalize_color(color)
+      values = Array(color).map(&:to_f)
+      raise ArgumentError, "Color must include at least 4 elements" if values.length < 4
+
+      values[0, 4]
+    end
+
+    def query_integer(const_name)
+      return nil unless @gl
+      return nil unless gl_respond_to?(:GetIntegerv)
+
+      storage = [0]
+      gl_call(:GetIntegerv, gl_const(const_name), storage)
+      storage.first
+    rescue StandardError
+      nil
+    end
+
+    def query_integer_array(const_name, size:)
+      return nil unless @gl
+      return nil unless gl_respond_to?(:GetIntegerv)
+
+      storage = Array.new(size, 0)
+      gl_call(:GetIntegerv, gl_const(const_name), storage)
+      storage
+    rescue StandardError
+      nil
+    end
+
+    def query_version
+      return nil unless @gl
+      return nil unless gl_respond_to?(:GetString)
+
+      gl_call(:GetString, gl_const(:VERSION)).to_s
+    rescue StandardError
+      nil
+    end
+
+    def gl_call(name, *args)
+      Util.gl_call(@gl, name, *args)
+    end
+
+    def gl_respond_to?(name)
+      snake_name = Util.underscore(name)
+      @gl && (@gl.respond_to?(name) || @gl.respond_to?(snake_name))
+    end
+
+    def gl_const(name)
+      Util.gl_const(name, gl: @gl)
+    end
+
+    def glfw_call(name, *args)
+      Util.gl_call(@glfw, name, *args)
+    end
+
+    def glfw_respond_to?(name)
+      snake_name = Util.underscore(name)
+      @glfw && (@glfw.respond_to?(name) || @glfw.respond_to?(snake_name))
+    end
+
+    def glfw_const(name)
+      raise ArgumentError, "GLFW backend is not available" unless @glfw
+
+      return @glfw.const_get(name) if @glfw.const_defined?(name)
+
+      raise ArgumentError, "Unknown GLFW constant #{name}"
+    end
+
+    def glfw_has_constant?(name)
+      @glfw&.const_defined?(name)
+    end
+
+    def load_gl_backend
+      Backends::OpenGLBindingsGL.load
+    rescue LoadError, StandardError
+      nil
+    end
+
+    def load_glfw_backend
+      Backends::OpenGLBindingsGLFW.load
+    rescue LoadError, StandardError
+      nil
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end