rbgl 0.1.0

data/examples/triangle_basic.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+
+include Larb
+include RBGL::Engine
+
+ctx = Context.new(width: 320, height: 240)
+
+pipeline = Pipeline.create do
+  vertex do |input, _uniforms, output|
+    output.position = input.position.to_vec4
+    output.color = input.color
+  end
+
+  fragment do |input, _uniforms, output|
+    output.color = input.color
+  end
+end
+
+layout = VertexLayout.position_color
+vertices = VertexBuffer.from_array(layout, [
+  { position: Vec3[0.0, 0.5, 0.0], color: Color.red },
+  { position: Vec3[-0.5, -0.5, 0.0], color: Color.green },
+  { position: Vec3[0.5, -0.5, 0.0], color: Color.blue }
+])
+
+ctx.clear(color: Color.from_hex("#1a1a2e"))
+ctx.bind_pipeline(pipeline)
+ctx.bind_vertex_buffer(vertices)
+ctx.draw_arrays(:triangles, 0, 3)
+
+File.write("hello_triangle.ppm", ctx.framebuffer.to_ppm)
+puts "Rendered to hello_triangle.ppm"

data/examples/triangle_window.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+
+include Larb
+include RBGL::Engine
+
+window = RBGL::GUI::Window.new(
+  width: 320,
+  height: 240,
+  title: "Hello Triangle - Window",
+  backend: :auto
+)
+
+pipeline = Pipeline.create do
+  vertex do |input, uniforms, output|
+    angle = uniforms.time || 0
+    pos = input.position
+
+    rotated_x = pos.x * Math.cos(angle) - pos.y * Math.sin(angle)
+    rotated_y = pos.x * Math.sin(angle) + pos.y * Math.cos(angle)
+
+    output.position = Vec4[rotated_x, rotated_y, pos.z, 1.0]
+    output.color = input.color
+  end
+
+  fragment do |input, _uniforms, output|
+    output.color = input.color
+  end
+end
+
+layout = VertexLayout.position_color
+vertices = VertexBuffer.from_array(layout, [
+  { position: Vec3[0.0, 0.5, 0.0], color: Color.red },
+  { position: Vec3[-0.5, -0.5, 0.0], color: Color.green },
+  { position: Vec3[0.5, -0.5, 0.0], color: Color.blue }
+])
+
+time = 0.0
+
+window.on(:key_press) do |event|
+  puts "Key: #{event.key}"
+  window.stop if event.key == 12 || event.key == "q" || event.key == "Escape"
+end
+
+window.on(:mouse_move) do |event|
+  puts "Mouse: #{event.x}, #{event.y}" if event.x && event.y
+end
+
+puts "Spinning triangle - Press 'q' or Escape to quit"
+
+window.run do |ctx, dt|
+  time += dt
+
+  ctx.clear(color: Color.from_hex("#1a1a2e"))
+  ctx.bind_pipeline(pipeline)
+  ctx.bind_vertex_buffer(vertices)
+  ctx.set_uniform(:time, time)
+  ctx.draw_arrays(:triangles, 0, 3)
+end

data/examples/window_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+
+puts "Creating window..."
+
+window = RBGL::GUI::Window.new(
+  width: 320,
+  height: 240,
+  title: "Simple Test",
+  backend: :cocoa
+)
+
+puts "Window created, starting render loop..."
+
+frame = 0
+window.run do |ctx, dt|
+  frame += 1
+
+  # Simple red background
+  ctx.clear(color: Larb::Color.red)
+
+  if frame % 60 == 0
+    puts "Frame: #{frame}, FPS: #{window.fps.round(1)}"
+  end
+
+  # Exit after 5 seconds
+  if frame > 300
+    puts "Stopping..."
+    window.stop
+  end
+end
+
+puts "Done"

data/lib/rbgl/engine/buffer.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class VertexAttribute
+      attr_reader :name, :size, :offset
+
+      def initialize(name, size, offset = 0)
+        @name = name.to_sym
+        @size = size
+        @offset = offset
+      end
+    end
+
+    class VertexLayout
+      attr_reader :attributes, :stride
+
+      def initialize(&block)
+        @attributes = {}
+        @offset = 0
+        instance_eval(&block) if block_given?
+        @stride = @offset
+      end
+
+      def attribute(name, size)
+        @attributes[name.to_sym] = VertexAttribute.new(name, size, @offset)
+        @offset += size
+      end
+
+      def self.position_only
+        new { attribute :position, 3 }
+      end
+
+      def self.position_color
+        new do
+          attribute :position, 3
+          attribute :color, 4
+        end
+      end
+
+      def self.position_normal_uv
+        new do
+          attribute :position, 3
+          attribute :normal, 3
+          attribute :uv, 2
+        end
+      end
+
+      def self.position_normal_uv_color
+        new do
+          attribute :position, 3
+          attribute :normal, 3
+          attribute :uv, 2
+          attribute :color, 4
+        end
+      end
+    end
+
+    class VertexBuffer
+      attr_reader :data, :layout, :vertex_count
+
+      def initialize(layout)
+        @layout = layout
+        @data = []
+        @vertex_count = 0
+      end
+
+      def add_vertex(**attributes)
+        vertex_data = []
+        @layout.attributes.each do |name, attr|
+          value = attributes[name]
+          raise "Missing attribute: #{name}" unless value
+
+          case value
+          when Larb::Vec2
+            vertex_data.concat([value.x, value.y])
+          when Larb::Vec3
+            vertex_data.concat([value.x, value.y, value.z])
+          when Larb::Vec4
+            vertex_data.concat([value.x, value.y, value.z, value.w])
+          when Larb::Color
+            vertex_data.concat(value.to_a)
+          when Array
+            vertex_data.concat(value)
+          when Numeric
+            vertex_data << value.to_f
+          end
+        end
+        @data.concat(vertex_data)
+        @vertex_count += 1
+        self
+      end
+
+      def add_vertices(*vertices)
+        vertices.each { |v| add_vertex(**v) }
+        self
+      end
+
+      def get_vertex(index)
+        return nil if index < 0 || index >= @vertex_count
+
+        start = index * @layout.stride
+        vertex = {}
+
+        @layout.attributes.each do |name, attr|
+          offset = start + attr.offset
+          values = @data[offset, attr.size]
+
+          vertex[name] = case attr.size
+                         when 1 then values[0]
+                         when 2 then Larb::Vec2.new(*values)
+                         when 3 then Larb::Vec3.new(*values)
+                         when 4
+                           if name == :color
+                             Larb::Color.new(*values)
+                           else
+                             Larb::Vec4.new(*values)
+                           end
+                         end
+        end
+
+        vertex
+      end
+
+      def self.from_array(layout, data)
+        buffer = new(layout)
+        data.each { |vertex| buffer.add_vertex(**vertex) }
+        buffer
+      end
+    end
+
+    class IndexBuffer
+      attr_reader :indices
+
+      def initialize(indices = [])
+        @indices = indices.map(&:to_i)
+      end
+
+      def add(*idx)
+        @indices.concat(idx.flatten.map(&:to_i))
+        self
+      end
+
+      def triangle_count
+        @indices.size / 3
+      end
+
+      def get_triangle(index)
+        start = index * 3
+        @indices[start, 3]
+      end
+
+      def each_triangle
+        return enum_for(:each_triangle) unless block_given?
+
+        (0...triangle_count).each { |i| yield get_triangle(i) }
+      end
+    end
+  end
+end

data/lib/rbgl/engine/context.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Context
+      attr_reader :framebuffer, :rasterizer
+
+      def initialize(width:, height:)
+        @framebuffer = Framebuffer.new(width, height)
+        @rasterizer = Rasterizer.new(@framebuffer)
+        @pipeline = nil
+        @uniforms = Uniforms.new
+        @vertex_buffer = nil
+        @index_buffer = nil
+      end
+
+      def bind_pipeline(pipeline)
+        @pipeline = pipeline
+      end
+
+      def bind_vertex_buffer(buffer)
+        @vertex_buffer = buffer
+      end
+
+      def bind_index_buffer(buffer)
+        @index_buffer = buffer
+      end
+
+      def set_uniform(name, value)
+        @uniforms[name] = value
+      end
+
+      def set_uniforms(hash)
+        hash.each { |k, v| @uniforms[k] = v }
+      end
+
+      def clear(color: Larb::Color.black, depth: Float::INFINITY)
+        @framebuffer.clear(color: color, depth: depth)
+      end
+
+      def draw_arrays(mode, first, count)
+        raise "No pipeline bound" unless @pipeline
+        raise "No vertex buffer bound" unless @vertex_buffer
+
+        vertices = (first...first + count).map { |i| process_vertex(i) }
+
+        case mode
+        when :triangles
+          (0...vertices.size).step(3) do |i|
+            draw_triangle(vertices[i], vertices[i + 1], vertices[i + 2])
+          end
+        when :lines
+          (0...vertices.size).step(2) do |i|
+            draw_line(vertices[i], vertices[i + 1])
+          end
+        when :points
+          vertices.each { |v| draw_point(v) }
+        when :triangle_strip
+          (0...vertices.size - 2).each do |i|
+            if i.even?
+              draw_triangle(vertices[i], vertices[i + 1], vertices[i + 2])
+            else
+              draw_triangle(vertices[i], vertices[i + 2], vertices[i + 1])
+            end
+          end
+        when :triangle_fan
+          (1...vertices.size - 1).each do |i|
+            draw_triangle(vertices[0], vertices[i], vertices[i + 1])
+          end
+        end
+      end
+
+      def draw_elements(mode, count, offset = 0)
+        raise "No pipeline bound" unless @pipeline
+        raise "No vertex buffer bound" unless @vertex_buffer
+        raise "No index buffer bound" unless @index_buffer
+
+        indices = @index_buffer.indices[offset, count]
+        vertices = indices.map { |i| process_vertex(i) }
+
+        case mode
+        when :triangles
+          (0...vertices.size).step(3) do |i|
+            draw_triangle(vertices[i], vertices[i + 1], vertices[i + 2])
+          end
+        when :lines
+          (0...vertices.size).step(2) do |i|
+            draw_line(vertices[i], vertices[i + 1])
+          end
+        end
+      end
+
+      def width
+        @framebuffer.width
+      end
+
+      def height
+        @framebuffer.height
+      end
+
+      def aspect_ratio
+        width.to_f / height
+      end
+
+      private
+
+      def process_vertex(index)
+        input = @vertex_buffer.get_vertex(index)
+        input_io = ShaderIO.new
+        input.each { |k, v| input_io[k] = v }
+
+        @pipeline.vertex_shader.process(input_io, @uniforms)
+      end
+
+      def draw_triangle(v0, v1, v2)
+        return unless v0 && v1 && v2
+        return if clip_triangle?(v0, v1, v2)
+
+        @rasterizer.rasterize_triangle(
+          v0, v1, v2,
+          @pipeline.fragment_shader,
+          @uniforms,
+          cull_mode: @pipeline.cull_mode
+        )
+      end
+
+      def draw_line(v0, v1)
+        return unless v0 && v1
+
+        @rasterizer.rasterize_line(v0, v1, @pipeline.fragment_shader, @uniforms)
+      end
+
+      def draw_point(v)
+        return unless v
+
+        @rasterizer.rasterize_point(v, @pipeline.fragment_shader, @uniforms)
+      end
+
+      def clip_triangle?(v0, v1, v2)
+        positions = [v0[:position], v1[:position], v2[:position]].map do |p|
+          if p.is_a?(Larb::Vec4)
+            p.perspective_divide
+          else
+            p
+          end
+        end
+
+        positions.all? { |p| p.x < -1 } ||
+          positions.all? { |p| p.x > 1 } ||
+          positions.all? { |p| p.y < -1 } ||
+          positions.all? { |p| p.y > 1 } ||
+          positions.all? { |p| p.z < -1 } ||
+          positions.all? { |p| p.z > 1 }
+      end
+    end
+  end
+end

data/lib/rbgl/engine/framebuffer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Framebuffer
+      attr_reader :width, :height, :color_buffer, :depth_buffer
+
+      def initialize(width, height)
+        @width = width
+        @height = height
+        @color_buffer = Array.new(width * height) { Larb::Color.black }
+        @depth_buffer = Array.new(width * height) { Float::INFINITY }
+      end
+
+      def get_pixel(x, y)
+        return nil if x < 0 || x >= @width || y < 0 || y >= @height
+
+        @color_buffer[y * @width + x]
+      end
+
+      def set_pixel(x, y, color)
+        return if x < 0 || x >= @width || y < 0 || y >= @height
+
+        @color_buffer[y * @width + x] = color
+      end
+
+      def get_depth(x, y)
+        return Float::INFINITY if x < 0 || x >= @width || y < 0 || y >= @height
+
+        @depth_buffer[y * @width + x]
+      end
+
+      def set_depth(x, y, depth)
+        return if x < 0 || x >= @width || y < 0 || y >= @height
+
+        @depth_buffer[y * @width + x] = depth
+      end
+
+      def write_pixel(x, y, color, depth, depth_test: true)
+        return false if x < 0 || x >= @width || y < 0 || y >= @height
+
+        idx = y * @width + x
+        if !depth_test || depth < @depth_buffer[idx]
+          @color_buffer[idx] = color
+          @depth_buffer[idx] = depth
+          true
+        else
+          false
+        end
+      end
+
+      def clear(color: Larb::Color.black, depth: Float::INFINITY)
+        @color_buffer.fill(color)
+        @depth_buffer.fill(depth)
+      end
+
+      def clear_color(color)
+        @color_buffer.fill(color)
+      end
+
+      def clear_depth(depth = Float::INFINITY)
+        @depth_buffer.fill(depth)
+      end
+
+      def to_ppm
+        ppm = "P3\n#{@width} #{@height}\n255\n"
+        @height.times do |y|
+          row = @width.times.map do |x|
+            c = @color_buffer[y * @width + x]
+            bytes = c.to_bytes
+            "#{bytes[0]} #{bytes[1]} #{bytes[2]}"
+          end
+          ppm += row.join(" ") + "\n"
+        end
+        ppm
+      end
+
+      def to_ppm_binary
+        header = "P6\n#{@width} #{@height}\n255\n"
+        pixels = @color_buffer.flat_map { |c| c.to_bytes[0..2] }.pack("C*")
+        header + pixels
+      end
+
+      def to_rgba_bytes
+        size = @color_buffer.size
+        bytes = Array.new(size * 4)
+        i = 0
+        size.times do |idx|
+          c = @color_buffer[idx]
+          bytes[i] = (c.r * 255).round.clamp(0, 255)
+          bytes[i + 1] = (c.g * 255).round.clamp(0, 255)
+          bytes[i + 2] = (c.b * 255).round.clamp(0, 255)
+          bytes[i + 3] = (c.a * 255).round.clamp(0, 255)
+          i += 4
+        end
+        bytes.pack("C*")
+      end
+
+      def to_bgra_bytes
+        size = @color_buffer.size
+        bytes = Array.new(size * 4)
+        i = 0
+        size.times do |idx|
+          c = @color_buffer[idx]
+          bytes[i] = (c.b * 255).round.clamp(0, 255)
+          bytes[i + 1] = (c.g * 255).round.clamp(0, 255)
+          bytes[i + 2] = (c.r * 255).round.clamp(0, 255)
+          bytes[i + 3] = (c.a * 255).round.clamp(0, 255)
+          i += 4
+        end
+        bytes.pack("C*")
+      end
+    end
+  end
+end

data/lib/rbgl/engine/pipeline.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Pipeline
+      attr_accessor :vertex_shader, :fragment_shader
+      attr_accessor :depth_test, :depth_write
+      attr_accessor :cull_mode
+      attr_accessor :blend_mode
+
+      def initialize
+        @vertex_shader = nil
+        @fragment_shader = nil
+        @depth_test = true
+        @depth_write = true
+        @cull_mode = :back
+        @blend_mode = :none
+      end
+
+      def self.create(&block)
+        pipeline = new
+        pipeline.instance_eval(&block) if block_given?
+        pipeline
+      end
+
+      def vertex(&block)
+        @vertex_shader = VertexShader.new(&block)
+      end
+
+      def fragment(&block)
+        @fragment_shader = FragmentShader.new(&block)
+      end
+    end
+  end
+end