belts_engine 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 96110da4df4e213c5a54284cfee9210bc0426105e6c7b20f0891742189d49bae
+  data.tar.gz: 6aab3aa5dd2c03b7fceae17c6232b24c3f266b15cfe1d56874c107c7804f5b2a
+SHA512:
+  metadata.gz: bbd1af8726a3962be1228108a636f2c90857f60f0eed61605b09fd2379b26be80f315c8bf21cf727f33d240c5068f7d9264d428c24674133449e878c92ac52d9
+  data.tar.gz: ad4c75ec48c4c360137e1ca462f47bf5952bf98b74e39c5367dd9e61cef2e5928e147a64ec1d7a4d08f5a414cc9a5908b50c568a7bda71d2866015a8ca411821

data/lib/belts_engine/application.rb

@@ -0,0 +1,21 @@
+module BeltsEngine
+  class Application
+    include BeltsSupport::Configuration
+
+    config.plugins = []
+
+    def initialize
+      @game = ::Game.new
+
+      config.plugins.each do |plugin_class|
+        @game.use plugin_class
+      end
+
+      @game.start
+
+      while true
+        @game.update
+      end
+    end
+  end
+end

data/lib/belts_engine/components/mat4.rb

@@ -0,0 +1,88 @@
+Mat4 = Struct.new(:m) do
+  class << self
+    def identity = Matrix.identity(4)
+
+    def translation(x, y, z)
+      Matrix[
+        [1, 0, 0, x],
+        [0, 1, 0, y],
+        [0, 0, 1, z],
+        [0, 0, 0, 1]
+      ]
+    end
+
+    def rotation(x, y, z)
+      x = x * Math::PI / 180
+      y = y * Math::PI / 180
+      z = z * Math::PI / 180
+
+      rotation_x = Matrix[
+        [1, 0, 0, 0],
+        [0, Math.cos(x), -Math.sin(x), 0],
+        [0, Math.sin(x), Math.cos(x), 0],
+        [0, 0, 0, 1]
+      ]
+
+      rotation_y = Matrix[
+        [Math.cos(y), 0, Math.sin(y), 0],
+        [0, 1, 0, 0],
+        [-Math.sin(y), 0, Math.cos(y), 0],
+        [0, 0, 0, 1]
+      ]
+
+      rotation_z = Matrix[
+        [Math.cos(z), -Math.sin(z), 0, 0],
+        [Math.sin(z), Math.cos(z), 0, 0],
+        [0, 0, 1, 0],
+        [0, 0, 0, 1]
+      ]
+
+      rotation_x * rotation_y * rotation_z
+    end
+
+    def scale(x, y, z)
+      Matrix[
+        [x, 0, 0, 0],
+        [0, y, 0, 0],
+        [0, 0, z, 0],
+        [0, 0, 0, 1]
+      ]
+    end
+
+    def perspective(fov, aspect, near, far)
+      fov_rad = fov * Math::PI / 180
+
+      y_scale = 1 / Math.tan(fov_rad)
+      x_scale = y_scale / aspect
+      frustumLength = far - near
+
+      Matrix[
+        [x_scale, 0, 0, 0],
+        [0, y_scale, 0, 0],
+        [0, 0, -(far + near) / frustumLength, -1],
+        [0, 0, 2 * -(far * near) / frustumLength, 0]
+      ].transpose
+    end
+
+    def orthographic(left, right, bottom, top, near, far)
+      scale = scale(2.0 / (right - left), 2.0 / (top - bottom), 2.0 / (far - near))
+      centerer = translation(- (right + left) / (right - left), - (top + bottom) / (top - bottom), (far - near) / 2.0)
+      inverter = scale(1, 1, -1)
+
+      scale * centerer# * inverter
+    end
+
+    def look_at(eye, target, up)
+      z_axis = (eye - target).normalize
+      x_axis = up.cross(z_axis).normalize
+      y_axis = z_axis.cross(x_axis)
+
+      Matrix[
+        [x_axis[0], x_axis[1], x_axis[2], -x_axis.dot(eye)],
+        [y_axis[0], y_axis[1], y_axis[2], -y_axis.dot(eye)],
+        [z_axis[0], z_axis[1], z_axis[2], -z_axis.dot(eye)],
+        [0, 0, 0, 1]
+      ]
+    end
+  end
+end

data/lib/belts_engine/components/transform.rb

@@ -0,0 +1,28 @@
+Transform = Struct.new(:position, :rotation, :scale) do
+  def initialize(position: Vec3.zero, rotation: Vec3.zero, scale: Vec3.one) = super(position, rotation, scale)
+
+  def to_matrix
+    Mat4.translation(*position) *
+      Mat4.rotation(*rotation) *
+      Mat4.scale(*scale)
+  end
+
+  def forward
+    matrix = to_matrix
+    Vec3[matrix[0, 2], matrix[1, 2], matrix[2, 2]]
+  end
+
+  def right
+    matrix = to_matrix
+    Vec3[matrix[0, 0], matrix[1, 0], matrix[2, 0]]
+  end
+
+  def up
+    matrix = to_matrix
+    Vec3[matrix[0, 1], matrix[1, 1], matrix[2, 1]]
+  end
+
+  def back = -forward
+  def left = -right
+  def down = -up
+end

data/lib/belts_engine/components/vec3.rb

@@ -0,0 +1,29 @@
+class Vec3 < Vector
+  class << self
+    def [](x = 0, y = 0, z = 0) = super(x, y, z)
+
+    def zero = Vec3[0, 0, 0]
+    def one = Vec3[1, 1, 1]
+    def up = Vec3[0, 1, 0]
+    def down = Vec3[0, -1, 0]
+    def left = Vec3[-1, 0, 0]
+    def right = Vec3[1, 0, 0]
+    def forward = Vec3[0, 0, 1]
+    def back = Vec3[0, 0, -1]
+  end
+
+  def x = self[0]
+  def x=(value)
+    self[0] = value
+  end
+
+  def y = self[1]
+  def y=(value)
+    self[1] = value
+  end
+
+  def z = self[2]
+  def z=(value)
+    self[2] = value
+  end
+end

data/lib/belts_engine/ecs/collection.rb

@@ -0,0 +1,28 @@
+module BeltsEngine::Ecs
+  class Collection < Hash
+    attr_reader :key
+
+    def initialize(with: [], without: [])
+      @with = with.sort
+      @without = without.sort
+      @key = {with: with, without: without}
+    end
+
+    def add_entity(entity)
+      return if (@with - entity.keys).any?
+      return if (@without & entity.keys).any?
+
+      self[entity[:id]] = entity.slice(:id, *@with)
+    end
+
+    def remove_entity(entity_id)
+      self.delete(entity_id)
+    end
+
+    def each_with_components
+      each do |k, v|
+        yield **v
+      end
+    end
+  end
+end

data/lib/belts_engine/ecs/collection_manager.rb

@@ -0,0 +1,13 @@
+module BeltsEngine::Ecs
+  class CollectionManager < Hash
+    def register(**filters)
+      collection = Collection.new(**filters)
+      self[collection.key] ||= collection
+    end
+
+    def get(key)
+      raise "Collection not registered: #{key}" unless self.key?(key)
+      self[key]
+    end
+  end
+end

data/lib/belts_engine/ecs/entity.rb

@@ -0,0 +1,11 @@
+module BeltsEngine::Ecs
+  class Entity < Hash
+    def initialize(id)
+      self[:id] = id
+    end
+
+    def add_components()
+      self[name] = value
+    end
+  end
+end

data/lib/belts_engine/ecs/entity_manager.rb

@@ -0,0 +1,57 @@
+module BeltsEngine::Ecs
+  class EntityManager < Hash
+    def initialize(game)
+      @game = game
+      @next_id = 0
+    end
+
+    def instantiate(prefab_class, position = Vec3.zero, rotation = Vec3.zero, scale = Vec3.one)
+      id = @next_id
+      entity = self[id] = Entity.new(id)
+      @next_id += 1
+
+      components = Marshal.load(Marshal.dump(prefab_class.to_s.constantize.components)) # deep copy
+      components[:transform].position = position if position
+      components[:transform].rotation = rotation if rotation
+      add_components(id, components)
+
+      id
+    end
+
+    def add_components(id, components)
+      entity = self[id]
+      entity.merge!(**components)
+
+      @game.collections.values.each do |collection|
+        collection.add_entity(entity)
+      end
+    end
+
+    def remove_components(id, keys)
+      entity = self[id]
+
+      keys.each do |key|
+        entity.delete(key)
+      end
+
+      @game.collections.values.each do |collection|
+        collection.remove_entity(id)
+        collection.add_entity(entity)
+      end
+    end
+
+    def destroy(id)
+      @game.collections.values.each do |collection|
+        collection.remove_entity(id)
+      end
+
+      self.delete(id)
+    end
+
+    def destroy_all
+      keys.each do |id|
+        destroy(id)
+      end
+    end
+  end
+end

data/lib/belts_engine/ecs/system_manager.rb

@@ -0,0 +1,34 @@
+module BeltsEngine::Ecs
+  class SystemManager
+    def initialize(game)
+      @game = game
+      @systems = []
+
+      register_app_systems
+    end
+
+    def update
+      @systems.each(&:update)
+    end
+
+    def register_system(klass)
+      @systems << klass.new(@game) # TODO: Avoid duplicates
+
+      klass.collection_keys.each do |key|
+        @game.collections.register(**key)
+      end
+    end
+
+    private
+
+    def register_app_systems
+      klasses = Dir["app/systems/*.rb"].map do |file|
+        File.basename(file, ".rb").camelize.constantize
+      end
+
+      klasses.each do |klass|
+        register_system(klass)
+      end
+    end
+  end
+end

data/lib/belts_engine/game.rb

@@ -0,0 +1,32 @@
+module BeltsEngine
+  class Game
+    include BeltsSupport::Configuration
+    include BeltsEngine::ToolsManager
+
+    def initialize
+      register_tool(:time, Tools::Time.new)
+      register_tool(:input, Tools::Input.new)
+      register_tool(:window, Tools::Window.new)
+      register_tool(:collections, Ecs::CollectionManager.new)
+      register_tool(:entities, Ecs::EntityManager.new(self))
+      register_tool(:scenes, Tools::SceneManager.new(self))
+      register_tool(:systems, Ecs::SystemManager.new(self))
+    end
+
+    def use(extension)
+      extension.install(self)
+    end
+
+    def start
+      main_scene_class = config.main_scene.to_s.constantize
+      raise 'Main scene not specified' unless main_scene_class
+
+      scenes.load_scene(main_scene_class)
+    end
+
+    def update
+      time.update
+      systems.update
+    end
+  end
+end

data/lib/belts_engine/prefab/component_mixin.rb

@@ -0,0 +1,28 @@
+module BeltsEngine
+  class Prefab
+    module ComponentMixin
+      class << self
+        def included(base)
+          base.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def components
+          @components ||= {}
+        end
+
+        def component(name, val)
+          set_component(name, val)
+        end
+
+        private
+
+        def set_component(name, data)
+          @components ||= {}
+          @components[name] = data
+        end
+      end
+    end
+  end
+end

data/lib/belts_engine/prefab.rb

@@ -0,0 +1,10 @@
+module BeltsEngine
+  class Prefab
+    include Prefab::ComponentMixin
+
+    def self.inherited(subclass)
+      super
+      subclass.component(:transform, Transform.new)
+    end
+  end
+end

data/lib/belts_engine/scene.rb

@@ -0,0 +1,27 @@
+module BeltsEngine
+  class Scene
+    attr_reader :game
+
+    self.instance_eval do
+      extend Module.new {
+        def prefab(class_name, **options)
+          @@prefabs ||= []
+          @@prefabs << options.merge(class_name: class_name)
+        end
+      }
+    end
+
+    def initialize(game)
+      @game = game
+      init_entities
+    end
+
+    private
+
+    def init_entities
+      @@prefabs.each do |prefab|
+        @game.entities.instantiate(prefab[:class_name], prefab[:position], prefab[:rotation], prefab[:scale])
+      end
+    end
+  end
+end

data/lib/belts_engine/system/collection_mixin.rb

@@ -0,0 +1,33 @@
+module BeltsEngine
+  class System
+    module CollectionMixin
+      class << self
+        def included(base)
+          base.extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def collection_keys
+          @collection_keys ||= []
+        end
+
+        def collection(name, **filters)
+          key = Ecs::Collection.new(**filters).key
+          register_collection_key(key)
+
+          define_method(name) do
+            @collections.get(key)
+          end
+        end
+
+        private
+
+        def register_collection_key(key)
+          @collection_keys ||= []
+          @collection_keys << key
+        end
+      end
+    end
+  end
+end

data/lib/belts_engine/system.rb

@@ -0,0 +1,23 @@
+module BeltsEngine
+  class System
+    include System::CollectionMixin
+
+    def initialize(game)
+      @game = game
+      register_tool_shortcuts
+
+      start
+    end
+
+    def start
+    end
+
+    private
+
+    def register_tool_shortcuts
+      @game.tools.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+  end
+end

data/lib/belts_engine/tools/input/keyboard.rb

@@ -0,0 +1,25 @@
+module BeltsEngine
+  module Tools
+    class Input
+      module Keyboard
+        KEYS = [:w, :a, :s, :d].freeze
+
+        def key?(key) = @keyboard_state[key]
+        def key_down?(key) = @keyboard_state[key] && !@keyboard_previous_state[key]
+        def key_up?(key) = !@keyboard_state[key] && @keyboard_previous_state[key]
+
+        def update_keys(changes)
+          @keyboard_previous_state = @keyboard_state.dup
+          @keyboard_state.merge!(changes)
+        end
+
+        private
+
+        def reset_keyboard_state
+          @keyboard_state = KEYS.map { |key| [key, false] }.to_h
+          @keyboard_previous_state = @keyboard_state.dup
+        end
+      end
+    end
+  end
+end

data/lib/belts_engine/tools/input/mouse.rb

@@ -0,0 +1,32 @@
+module BeltsEngine
+  module Tools
+    class Input
+      module Mouse
+        BUTTONS = [:mouse_1, :mouse_2, :mouse_3].freeze
+
+        def button?(button) = @mouse_state[button]
+        def button_down?(button) = @mouse_state[button] && !@mouse_previous_state[button]
+        def button_up?(button) = !@mouse_state[button] && @mouse_previous_state[button]
+        def mouse(axis) = @mouse_state[axis]
+
+        def update_buttons(changes)
+          @mouse_previous_state = @mouse_state.dup
+          @mouse_state.merge!(changes)
+        end
+
+        def update_position(x, y)
+          @mouse_state[:x] = x
+          @mouse_state[:y] = y
+        end
+
+        private
+
+        def reset_mouse_state
+          @mouse_state = BUTTONS.map { |button| [button, false] }.to_h
+          @mouse_state[:x] = @mouse_state[:y] = 0
+          @mouse_previous_state = @mouse_state.dup
+        end
+      end
+    end
+  end
+end

data/lib/belts_engine/tools/input.rb

@@ -0,0 +1,18 @@
+module BeltsEngine
+  module Tools
+    class Input
+      include Keyboard
+      include Mouse
+
+      def initialize
+        reset_keyboard_state
+        # reset_mouse_state
+        #@current_keys[:mouse_x] = @current_keys[:mouse_y] = 0
+      end
+
+      def update(changes)
+        update_keys(changes)
+      end
+    end
+  end
+end

data/lib/belts_engine/tools/scene_manager.rb

@@ -0,0 +1,19 @@
+module BeltsEngine::Tools
+  class SceneManager
+    attr_reader :current_scene
+
+    def initialize(game)
+      @game = game
+      @current_scene = nil
+    end
+
+    def unload_scene
+      @game.entities.destroy_all
+    end
+
+    def load_scene(scene_class)
+      unload_scene
+      @current_scene = scene_class.new(@game)
+    end
+  end
+end

data/lib/belts_engine/tools/time.rb

@@ -0,0 +1,26 @@
+module BeltsEngine
+  module Tools
+    class Time
+      attr_reader :delta_time, :uptime
+
+      def initialize
+        @start_time = system_time
+        @last_time = @start_time
+        @uptime = 0
+        @delta_time = 0
+      end
+
+      def update
+        @delta_time = system_time - @last_time
+        @last_time = system_time
+        @uptime += @delta_time
+      end
+
+      private
+
+      def system_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/belts_engine/tools/window.rb

@@ -0,0 +1,22 @@
+module BeltsEngine
+  module Tools
+    class Window
+      attr_reader :ratio, :width, :height, :title
+
+      DEFAULT_WIDTH = 640
+      DEFAULT_HEIGHT = 480
+      DEFAULT_TITLE = 'Belts Demo'.freeze
+
+      def initialize
+        @title = DEFAULT_TITLE
+        resize(DEFAULT_WIDTH, DEFAULT_HEIGHT)
+      end
+
+      def resize(width, height)
+        @width = width
+        @height = height
+        @ratio = @width.to_f / @height.to_f
+      end
+    end
+  end
+end

data/lib/belts_engine/tools_manager.rb

@@ -0,0 +1,25 @@
+module BeltsEngine
+  module ToolsManager
+    def tools
+      @_tools ||= {}
+    end
+
+    def register_tool(name, obj)
+      raise "Tool #{name} already in use" if tools.key?(name)
+
+      tools[name] = obj
+    end
+
+    def respond_to?(name, include_private = false)
+      super || tools.key?(name.to_sym)
+    end
+
+    private
+
+    def method_missing(name, *args, &blk)
+      raise "Tool #{name} not registered" unless tools.key?(name)
+
+      tools[name]
+    end
+  end
+end

data/lib/belts_engine.rb

@@ -0,0 +1,12 @@
+require 'belts_support'
+
+# TODO: Load with zeitwerk
+require_relative './belts_engine/components/vec3'
+require_relative './belts_engine/components/mat4'
+require_relative './belts_engine/components/transform'
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module BeltsEngine
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: belts_engine
+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_support
+  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
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/belts_engine.rb
+- lib/belts_engine/application.rb
+- lib/belts_engine/components/mat4.rb
+- lib/belts_engine/components/transform.rb
+- lib/belts_engine/components/vec3.rb
+- lib/belts_engine/ecs/collection.rb
+- lib/belts_engine/ecs/collection_manager.rb
+- lib/belts_engine/ecs/entity.rb
+- lib/belts_engine/ecs/entity_manager.rb
+- lib/belts_engine/ecs/system_manager.rb
+- lib/belts_engine/game.rb
+- lib/belts_engine/prefab.rb
+- lib/belts_engine/prefab/component_mixin.rb
+- lib/belts_engine/scene.rb
+- lib/belts_engine/system.rb
+- lib/belts_engine/system/collection_mixin.rb
+- lib/belts_engine/tools/input.rb
+- lib/belts_engine/tools/input/keyboard.rb
+- lib/belts_engine/tools/input/mouse.rb
+- lib/belts_engine/tools/scene_manager.rb
+- lib/belts_engine/tools/time.rb
+- lib/belts_engine/tools/window.rb
+- lib/belts_engine/tools_manager.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: The core functionality of the Belts game engine
+test_files: []