belts_opengl 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea257ecc7aeb9a3ea5635678fb1a49d4988b9461875aeb4224e2c4ed464aea91
+  data.tar.gz: 8d79cbab0c5508b3c3958f91f7c12c2c4258e7f6c2401d8f27e5ffdbead5314e
+SHA512:
+  metadata.gz: 786cb5ffe3b6fb4bad57d01a5cb47d605d53ee45175e95b2cefae9453ee2c90981a7a0c670e43eba51a4800dd43048286d76282b7d3d5cd88c99827875fbe5c5
+  data.tar.gz: b347364f0df7ed3207f5c98c831d4940e8d9bc0280db163b2c6971bf47a905d75e5f43346c99b5c0d22cbf20cacdb3e5a519d3f98f287fa47973abbfb9d5ba2c

data/lib/belts_opengl/asset_manager.rb

@@ -0,0 +1,53 @@
+module BeltsOpengl
+  class AssetManager
+    def initialize
+      @shaders = {}
+      @meshes = {}
+
+      build_default_shader
+      build_default_meshes
+    end
+
+    def get_shader(key)
+      @shaders[key]
+    end
+
+    def get_mesh(key)
+      @meshes[key]
+    end
+
+    def build_default_shader
+      vert_shader = GL.CreateShader(GL::VERTEX_SHADER)
+      vpath = File.join(BeltsOpengl::root, 'lib/belts_opengl/assets/shaders/base.vert')
+      vcontent = [File.read(vpath)].pack('p')
+      vsize = [File.size(vpath)].pack('I')
+      GL.ShaderSource(vert_shader, 1, vcontent, vsize)
+      GL.CompileShader(vert_shader)
+
+      frag_shader = GL.CreateShader(GL::FRAGMENT_SHADER)
+      fpath = File.join(BeltsOpengl::root, 'lib/belts_opengl/assets/shaders/base.frag')
+      fcontent = [File.read(fpath)].pack('p')
+      fsize = [File.size(fpath)].pack('I')
+      GL.ShaderSource(frag_shader, 1, fcontent, fsize)
+      GL.CompileShader(frag_shader)
+
+      @shaders[:default] = GL.CreateProgram()
+      GL.AttachShader(@shaders[:default], vert_shader)
+      GL.AttachShader(@shaders[:default], frag_shader)
+      GL.LinkProgram(@shaders[:default])
+
+      GL.DeleteShader(vert_shader)
+      GL.DeleteShader(frag_shader)
+    end
+
+    def build_default_meshes
+      default_meshes = {
+        square: Assets::Meshes::Square.new,
+        triangle: Assets::Meshes::Triangle.new,
+        cube: Assets::Meshes::Cube.new
+      }
+
+      @meshes.merge!(default_meshes)
+    end
+  end
+end

data/lib/belts_opengl/assets/mesh.rb

@@ -0,0 +1,69 @@
+module BeltsOpengl::Assets
+  module BufferHelpers
+    private
+
+    def create_buffer
+      temp = ' ' * 4
+      GL.GenBuffers(1, temp)
+      temp.unpack('L')[0]
+    end
+
+    def create_vertex_array_buffer
+      temp = ' ' * 4
+      GL.GenVertexArrays(1, temp)
+      temp.unpack('L')[0]
+    end
+  end
+
+  class Mesh
+    include BufferHelpers
+
+    U = 1.0 # Unit size
+    HU = U/2 # Half unit size
+
+    def initialize(vertices, indexes)
+      @vertices = vertices
+      @indexes = indexes
+
+      @vao = create_vertex_array_buffer
+      @vbo = create_buffer
+      @ebo = create_buffer
+
+      upload_vertice_data
+    end
+
+    def draw
+      GL.BindVertexArray(@vao)
+      GL.DrawElements(GL::TRIANGLES, @indexes.size, GL::UNSIGNED_INT, 0)
+    end
+
+    def destroy
+      GL.DeleteVertexArrays(1, [@vao].pack('L'))
+      GL.DeleteBuffers(1, [@vbo].pack('L'))
+      GL.DeleteBuffers(1, [@ebo].pack('L'))
+    end
+
+    private
+
+    def upload_vertice_data
+      values_per_vertex = 3
+
+      GL.BindVertexArray(@vao)
+      GL.BindBuffer(GL::ARRAY_BUFFER, @vbo)
+
+      GL.BufferData(GL::ARRAY_BUFFER, @vertices.size * Fiddle::SIZEOF_FLOAT, @vertices.pack('F*'), GL::STATIC_DRAW)
+
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      GL.BufferData(GL::ELEMENT_ARRAY_BUFFER, @indexes.size * Fiddle::SIZEOF_INT, @indexes.pack('L*'), GL::STATIC_DRAW)
+
+      GL.VertexAttribPointer(0, 3, GL::FLOAT, GL::FALSE, 6 * Fiddle::SIZEOF_FLOAT, 0)
+      GL.VertexAttribPointer(1, 3, GL::FLOAT, GL::FALSE, 6 * Fiddle::SIZEOF_FLOAT, 3 * Fiddle::SIZEOF_FLOAT)
+      GL.EnableVertexAttribArray(0)
+      GL.EnableVertexAttribArray(1)
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, 0)
+      GL.BindVertexArray(0)
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, 0)
+    end
+  end
+end

data/lib/belts_opengl/assets/meshes/cube.rb

@@ -0,0 +1,68 @@
+module BeltsOpengl::Assets
+  class Meshes::Cube < Mesh
+    def initialize
+      common_vertices = [
+        # Back face
+        [-HU, HU, -HU],
+        [-HU, -HU, -HU],
+        [HU, -HU, -HU],
+        [HU, HU, -HU],
+
+        # Front face
+        [HU, HU, HU],
+        [HU, -HU, HU],
+        [-HU, -HU, HU],
+        [-HU, HU, HU]
+      ]
+
+      vertices = [
+        # Back face
+        *common_vertices[0], *Vec3.back,
+        *common_vertices[1], *Vec3.back,
+        *common_vertices[2], *Vec3.back,
+        *common_vertices[3], *Vec3.back,
+
+        # Right face
+        *common_vertices[3], *Vec3.right,
+        *common_vertices[2], *Vec3.right,
+        *common_vertices[5], *Vec3.right,
+        *common_vertices[4], *Vec3.right,
+
+        # Front face
+        *common_vertices[4], *Vec3.forward,
+        *common_vertices[5], *Vec3.forward,
+        *common_vertices[6], *Vec3.forward,
+        *common_vertices[7], *Vec3.forward,
+
+        # Left face
+        *common_vertices[7], *Vec3.left,
+        *common_vertices[6], *Vec3.left,
+        *common_vertices[1], *Vec3.left,
+        *common_vertices[0], *Vec3.left,
+
+        # Top face
+        *common_vertices[7], *Vec3.up,
+        *common_vertices[0], *Vec3.up,
+        *common_vertices[3], *Vec3.up,
+        *common_vertices[4], *Vec3.up,
+
+        # Bottom face
+        *common_vertices[1], *Vec3.down,
+        *common_vertices[6], *Vec3.down,
+        *common_vertices[5], *Vec3.down,
+        *common_vertices[2], *Vec3.down
+      ]
+
+      indexes = (0..5).map do |i|
+        stride = i * 4
+
+        [
+          stride, stride + 1, stride + 2,
+          stride + 2, stride + 3, stride
+        ]
+      end.flatten
+
+      super(vertices, indexes)
+    end
+  end
+end

data/lib/belts_opengl/assets/meshes/square.rb

@@ -0,0 +1,18 @@
+module BeltsOpengl::Assets
+  class Meshes::Square < Mesh
+    def initialize
+      vertices = [
+        -HU, HU, 0, *Vec3.back,
+        -HU, -HU, 0, *Vec3.back,
+        HU, -HU, 0, *Vec3.back,
+        HU, HU, 0, *Vec3.back
+      ]
+
+      indexes = [
+        0, 1, 2, 2, 3, 0
+      ]
+
+      super(vertices, indexes)
+    end
+  end
+end

data/lib/belts_opengl/assets/meshes/triangle.rb

@@ -0,0 +1,17 @@
+module BeltsOpengl::Assets
+  class Meshes::Triangle < Mesh
+    def initialize
+      vertices = [
+        0, HU, 0,
+        -HU, -HU, 0,
+        HU, -HU, 0
+      ]
+
+      indexes = [
+        0, 1, 2
+      ]
+
+      super(vertices, indexes)
+    end
+  end
+end

data/lib/belts_opengl/assets/shaders/base.frag

@@ -0,0 +1,17 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec3 normal;
+in vec4 curPosition;
+
+void main() {
+  float ambient = 0.2;
+  vec3 lightPosition = vec3(0, 0, -1);
+  vec3 lightDirection = normalize(lightPosition - vec3(curPosition));
+
+  float diffuse = max(dot(normal, lightDirection), 0.0);
+  vec4 objColor = vec4(1.0, 0.5, 1, 1);
+  vec4 lightColor = vec4(1, 1, 1, 1);
+
+  FragColor = objColor * lightColor * (diffuse + ambient);
+}

data/lib/belts_opengl/assets/shaders/base.vert

@@ -0,0 +1,17 @@
+#version 330 core
+layout (location = 0) in vec3 aPosition;
+layout (location = 1) in vec3 aNormal;
+
+uniform mat4 camera_matrix;
+uniform mat4 model_matrix;
+uniform mat4 normal_matrix;
+
+out vec3 normal;
+out vec4 curPosition;
+
+void main() {
+  normal = mat3(normal_matrix) * aNormal;
+  curPosition = model_matrix * vec4(aPosition, 1.0);
+
+  gl_Position = camera_matrix * curPosition;
+}

data/lib/belts_opengl/components/camera_data.rb

@@ -0,0 +1,4 @@
+CameraData = Struct.new(:projection_type) do
+  def perspective? = projection_type == :perspective
+  def orthographic? = projection_type == :orthographic
+end

data/lib/belts_opengl/components/light_data.rb

@@ -0,0 +1,5 @@
+LightData = Struct.new(:light_type) do
+  def directional? = light_type == :directional
+  def point? = light_type == :point
+  def ambient? = light_type == :ambient
+end

data/lib/belts_opengl/components/render_data.rb

@@ -0,0 +1 @@
+RenderData = Struct.new(:type, :color)

data/lib/belts_opengl/input_manager.rb

@@ -0,0 +1,65 @@
+module BeltsOpengl
+  class InputManager
+    KEY_MAP = {
+      GLFW::KEY_W => :w,
+      GLFW::KEY_A => :a,
+      GLFW::KEY_S => :s,
+      GLFW::KEY_D => :d,
+    }
+
+    BUTTON_MAP = {
+      GLFW::MOUSE_BUTTON_1 => :mouse_1,
+      GLFW::MOUSE_BUTTON_2 => :mouse_2,
+      GLFW::MOUSE_BUTTON_3 => :mouse_3
+    }
+
+    def initialize(game, window)
+      @game = game
+      @window = window
+      @input_changes = {}
+
+      GLFW.SetKeyCallback(@window, key_callback)
+      GLFW.SetCursorPosCallback(@window, cursor_callback)
+      GLFW.SetMouseButtonCallback(@window, mouse_button_callback)
+    end
+
+    def update
+      @game.input.update(@input_changes)
+      @input_changes = {}
+    end
+
+    private
+
+    # NOTE: registering the callback with memoization because the gem has an
+    # issue keeping reference to a local variable or method call, resulting
+    # in a segfault
+    def key_callback
+      @_key_callback ||= GLFW::create_callback(:GLFWkeyfun) do |window, key, scancode, action, mods|
+        key = KEY_MAP[key]
+
+        next if key.nil?
+        next if action == GLFW::REPEAT
+
+        @input_changes[key] = action == GLFW::PRESS
+      end
+    end
+
+    def cursor_callback
+      @_cursor_callback ||= GLFW::create_callback(:GLFWcursorposfun) do |window, x, y|
+        @input_changes[:mouse_x] = x
+        @input_changes[:mouse_y] = y
+      end
+    end
+
+    def mouse_button_callback
+      @_mouse_button_callback ||= GLFW::create_callback(:GLFWmousebuttonfun) do |window, button, action, mods|
+        button = BUTTON_MAP[button]
+
+        next if button.nil?
+        next if action == GLFW::REPEAT
+
+        @input_changes[button] = action == GLFW::PRESS
+      end
+    end
+  end
+end

data/lib/belts_opengl/prefab/renderer_mixin.rb

@@ -0,0 +1,17 @@
+module BeltsOpengl
+  module Prefab
+    module RendererMixin
+      class << self
+        def included(base)
+          base.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def renderer(type, **options)
+          set_component(:render_data, RenderData.new(type, options[:color]))
+        end
+      end
+    end
+  end
+end

data/lib/belts_opengl/systems/render_system.rb

@@ -0,0 +1,60 @@
+module BeltsOpengl
+  class RenderSystem < BeltsEngine::System
+    collection :cameras,
+      with: [:transform, :camera_data]
+
+    collection :objects,
+      with: [:transform, :render_data]
+
+    def start
+      GL.Enable(GL::DEPTH_TEST)
+      GL.Enable(GL::CULL_FACE)
+    end
+
+    def update
+      GL.ClearColor(0.07, 0.13, 0.17, 1.0)
+      GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
+      GL.UseProgram(default_shader)
+
+      render_entities
+    end
+
+    private
+
+    def render_entities
+      camera_matrix = nil
+
+      cameras.each_with_components do |transform:, camera_data:, **|
+        # view_matrix = Mat4.look_at(transform.position, transform.position + transform.forward, transform.up)
+        view_matrix = Mat4.rotation(*-transform.rotation) * Mat4.scale(1, 1, -1) * Mat4.translation(*-transform.position)
+        proj_matrix = Mat4.perspective(45, @game.window.ratio, 0.1, 100)
+
+        ortho_size = 5
+        orth_matrix = Mat4.orthographic(-ortho_size * @game.window.ratio, ortho_size * @game.window.ratio, -ortho_size, ortho_size, 0, 10)
+
+        camera_matrix = (proj_matrix * view_matrix)
+      end
+
+      objects.each_with_components do |transform:, render_data:, **|
+        model_matrix = transform.to_matrix
+        normal_matrix = model_matrix.inverse.transpose
+
+        cameraLoc = GL.GetUniformLocation(default_shader, "camera_matrix")
+        GL.UniformMatrix4fv(cameraLoc, 1, GL::FALSE, camera_matrix.transpose.to_a.flatten.pack("F*"))
+
+        modelLoc = GL.GetUniformLocation(default_shader, "model_matrix")
+        GL.UniformMatrix4fv(modelLoc, 1, GL::FALSE, model_matrix.transpose.to_a.flatten.pack("F*"))
+
+        normalLoc = GL.GetUniformLocation(default_shader, "normal_matrix")
+        GL.UniformMatrix4fv(normalLoc, 1, GL::FALSE, normal_matrix.transpose.to_a.flatten.pack("F*"))
+
+        mesh = @game.asset_manager.get_mesh(render_data.type)
+        mesh.draw
+      end
+    end
+
+    def default_shader
+      @game.asset_manager.get_shader(:default)
+    end
+  end
+end

data/lib/belts_opengl/systems/window_system.rb

@@ -0,0 +1,34 @@
+module BeltsOpengl
+  class WindowSystem < BeltsEngine::System
+    def start
+      GLFW.WindowHint(GLFW::ALPHA_BITS, 0)
+      @window = GLFW.CreateWindow(640, 480, "Belts Demo", nil, nil)
+      GLFW.MakeContextCurrent(@window)
+
+      @input_manager = BeltsOpengl::InputManager.new(@game, @window)
+    end
+
+    def update
+      update_window_size
+
+      GLFW.SwapBuffers(@window)
+      GLFW.PollEvents()
+
+      @input_manager.update
+    end
+
+    private
+
+    def update_window_size
+      width_ptr = ' ' * 8
+      height_ptr = ' ' * 8
+      GLFW.GetFramebufferSize(@window, width_ptr, height_ptr)
+
+      width = width_ptr.unpack('L')[0]
+      height = height_ptr.unpack('L')[0]
+      GL.Viewport(0, 0, width, height)
+
+      @game.window.resize(width, height)
+    end
+  end
+end

data/lib/belts_opengl.rb

@@ -0,0 +1,34 @@
+require 'belts_engine'
+require 'opengl'
+require 'glfw'
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module BeltsOpengl
+  extend BeltsSupport::Extension
+
+  def self.install(game)
+    require 'belts_opengl/components/camera_data'
+    require 'belts_opengl/components/light_data'
+    require 'belts_opengl/components/render_data'
+
+    require 'belts_opengl/systems/window_system'
+    require 'belts_opengl/systems/render_system'
+
+    GLFW.load_lib
+    GLFW.Init
+    GL.load_lib
+
+    game.systems.register_system(BeltsOpengl::WindowSystem)
+    game.systems.register_system(BeltsOpengl::RenderSystem)
+
+    game.register_tool(:asset_manager, BeltsOpengl::AssetManager.new)
+
+    BeltsEngine::Prefab.include BeltsOpengl::Prefab::RendererMixin
+  end
+
+  def self.root
+    File.dirname __dir__
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: belts_opengl
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Guilherme Graca
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: belts_engine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: opengl-bindings2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/belts_opengl.rb
+- lib/belts_opengl/asset_manager.rb
+- lib/belts_opengl/assets/mesh.rb
+- lib/belts_opengl/assets/meshes/cube.rb
+- lib/belts_opengl/assets/meshes/square.rb
+- lib/belts_opengl/assets/meshes/triangle.rb
+- lib/belts_opengl/assets/shaders/base.frag
+- lib/belts_opengl/assets/shaders/base.vert
+- lib/belts_opengl/components/camera_data.rb
+- lib/belts_opengl/components/light_data.rb
+- lib/belts_opengl/components/render_data.rb
+- lib/belts_opengl/input_manager.rb
+- lib/belts_opengl/prefab/renderer_mixin.rb
+- lib/belts_opengl/systems/render_system.rb
+- lib/belts_opengl/systems/window_system.rb
+homepage: https://github.com/ggraca/belts
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: OpenGL graphics plugin for the Belts game engine
+test_files: []