bevy 1.0.0

data/lib/bevy/visibility.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Bevy
+  class Aabb
+    attr_accessor :center, :half_extents
+
+    def initialize(center:, half_extents:)
+      @center = center
+      @half_extents = half_extents
+    end
+
+    def self.from_min_max(min, max)
+      center = Vec3.new(
+        (min.x + max.x) / 2.0,
+        (min.y + max.y) / 2.0,
+        (min.z + max.z) / 2.0
+      )
+      half_extents = Vec3.new(
+        (max.x - min.x) / 2.0,
+        (max.y - min.y) / 2.0,
+        (max.z - min.z) / 2.0
+      )
+      new(center: center, half_extents: half_extents)
+    end
+
+    def min
+      Vec3.new(
+        @center.x - @half_extents.x,
+        @center.y - @half_extents.y,
+        @center.z - @half_extents.z
+      )
+    end
+
+    def max
+      Vec3.new(
+        @center.x + @half_extents.x,
+        @center.y + @half_extents.y,
+        @center.z + @half_extents.z
+      )
+    end
+
+    def contains_point?(point)
+      m = min
+      mx = max
+      point.x >= m.x && point.x <= mx.x &&
+        point.y >= m.y && point.y <= mx.y &&
+        point.z >= m.z && point.z <= mx.z
+    end
+
+    def intersects?(other)
+      min1 = min
+      max1 = max
+      min2 = other.min
+      max2 = other.max
+
+      min1.x <= max2.x && max1.x >= min2.x &&
+        min1.y <= max2.y && max1.y >= min2.y &&
+        min1.z <= max2.z && max1.z >= min2.z
+    end
+
+    def merge(other)
+      new_min = Vec3.new(
+        [min.x, other.min.x].min,
+        [min.y, other.min.y].min,
+        [min.z, other.min.z].min
+      )
+      new_max = Vec3.new(
+        [max.x, other.max.x].max,
+        [max.y, other.max.y].max,
+        [max.z, other.max.z].max
+      )
+      Aabb.from_min_max(new_min, new_max)
+    end
+
+    def type_name
+      'Aabb'
+    end
+  end
+
+  class Frustum
+    attr_reader :planes
+
+    def initialize(planes)
+      @planes = planes
+    end
+
+    def self.from_view_projection(view_projection)
+      new([])
+    end
+
+    def contains_point?(point)
+      @planes.all? { |plane| plane.signed_distance(point) >= 0 }
+    end
+
+    def intersects_aabb?(aabb)
+      @planes.all? do |plane|
+        p_vertex = Vec3.new(
+          plane.normal.x >= 0 ? aabb.max.x : aabb.min.x,
+          plane.normal.y >= 0 ? aabb.max.y : aabb.min.y,
+          plane.normal.z >= 0 ? aabb.max.z : aabb.min.z
+        )
+        plane.signed_distance(p_vertex) >= 0
+      end
+    end
+
+    def type_name
+      'Frustum'
+    end
+  end
+
+  class FrustumPlane
+    attr_reader :normal, :distance
+
+    def initialize(normal:, distance:)
+      @normal = normal
+      @distance = distance.to_f
+    end
+
+    def signed_distance(point)
+      @normal.x * point.x + @normal.y * point.y + @normal.z * point.z + @distance
+    end
+
+    def type_name
+      'FrustumPlane'
+    end
+  end
+
+  class VisibleEntities
+    attr_reader :entities
+
+    def initialize
+      @entities = []
+    end
+
+    def add(entity)
+      @entities << entity
+      self
+    end
+
+    def clear
+      @entities = []
+    end
+
+    def count
+      @entities.size
+    end
+
+    def include?(entity)
+      @entities.include?(entity)
+    end
+
+    def type_name
+      'VisibleEntities'
+    end
+  end
+
+  class RenderLayers
+    attr_reader :layers
+
+    DEFAULT_LAYER = 0
+
+    def initialize(layers = [DEFAULT_LAYER])
+      @layers = layers.to_a
+    end
+
+    def self.layer(layer)
+      new([layer])
+    end
+
+    def self.all
+      new((0..31).to_a)
+    end
+
+    def self.none
+      new([])
+    end
+
+    def with(layer)
+      self.class.new(@layers + [layer])
+    end
+
+    def without(layer)
+      self.class.new(@layers - [layer])
+    end
+
+    def intersects?(other)
+      (@layers & other.layers).any?
+    end
+
+    def type_name
+      'RenderLayers'
+    end
+  end
+
+  class OcclusionCulling
+    attr_accessor :enabled
+
+    def initialize(enabled: true)
+      @enabled = enabled
+      @occluders = []
+    end
+
+    def add_occluder(aabb)
+      @occluders << aabb
+    end
+
+    def clear_occluders
+      @occluders = []
+    end
+
+    def is_occluded?(aabb, from_point)
+      return false unless @enabled
+
+      @occluders.any? do |occluder|
+        occluder != aabb && occludes?(occluder, aabb, from_point)
+      end
+    end
+
+    def type_name
+      'OcclusionCulling'
+    end
+
+    private
+
+    def occludes?(occluder, target, _from_point)
+      occluder.contains_point?(target.center)
+    end
+  end
+
+  class Lod
+    attr_reader :distances, :current_level
+
+    def initialize(distances:)
+      @distances = distances.sort
+      @current_level = 0
+    end
+
+    def update(distance)
+      @current_level = @distances.index { |d| distance <= d } || @distances.size
+    end
+
+    def level_count
+      @distances.size + 1
+    end
+
+    def type_name
+      'Lod'
+    end
+  end
+end

data/lib/bevy/window.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module Bevy
+  module WindowMode
+    WINDOWED = :windowed
+    BORDERLESS_FULLSCREEN = :borderless_fullscreen
+    SIZED_FULLSCREEN = :sized_fullscreen
+    FULLSCREEN = :fullscreen
+  end
+
+  module CursorGrabMode
+    NONE = :none
+    CONFINED = :confined
+    LOCKED = :locked
+  end
+
+  module PresentMode
+    AUTO_VSYNC = :auto_vsync
+    AUTO_NO_VSYNC = :auto_no_vsync
+    FIFO = :fifo
+    FIFO_RELAXED = :fifo_relaxed
+    IMMEDIATE = :immediate
+    MAILBOX = :mailbox
+  end
+
+  class Window
+    attr_accessor :title, :width, :height, :position_x, :position_y
+    attr_accessor :mode, :present_mode, :resizable, :decorations
+    attr_accessor :cursor_visible, :cursor_grab_mode
+    attr_accessor :focused, :visible, :always_on_top
+    attr_accessor :resolution_scale_factor
+
+    def initialize(
+      title: 'Bevy App',
+      width: 1280.0,
+      height: 720.0,
+      mode: WindowMode::WINDOWED,
+      resizable: true,
+      decorations: true
+    )
+      @title = title
+      @width = width.to_f
+      @height = height.to_f
+      @position_x = nil
+      @position_y = nil
+      @mode = mode
+      @present_mode = PresentMode::AUTO_VSYNC
+      @resizable = resizable
+      @decorations = decorations
+      @cursor_visible = true
+      @cursor_grab_mode = CursorGrabMode::NONE
+      @focused = true
+      @visible = true
+      @always_on_top = false
+      @resolution_scale_factor = 1.0
+    end
+
+    def set_title(title)
+      @title = title
+      self
+    end
+
+    def resize(width, height)
+      @width = width.to_f
+      @height = height.to_f
+      self
+    end
+
+    def set_position(x, y)
+      @position_x = x.to_f
+      @position_y = y.to_f
+      self
+    end
+
+    def center
+      @position_x = nil
+      @position_y = nil
+      self
+    end
+
+    def set_mode(mode)
+      @mode = mode
+      self
+    end
+
+    def fullscreen
+      @mode = WindowMode::FULLSCREEN
+      self
+    end
+
+    def borderless_fullscreen
+      @mode = WindowMode::BORDERLESS_FULLSCREEN
+      self
+    end
+
+    def windowed
+      @mode = WindowMode::WINDOWED
+      self
+    end
+
+    def toggle_fullscreen
+      @mode = if @mode == WindowMode::WINDOWED
+                WindowMode::BORDERLESS_FULLSCREEN
+              else
+                WindowMode::WINDOWED
+              end
+      self
+    end
+
+    def hide_cursor
+      @cursor_visible = false
+      self
+    end
+
+    def show_cursor
+      @cursor_visible = true
+      self
+    end
+
+    def lock_cursor
+      @cursor_grab_mode = CursorGrabMode::LOCKED
+      self
+    end
+
+    def confine_cursor
+      @cursor_grab_mode = CursorGrabMode::CONFINED
+      self
+    end
+
+    def release_cursor
+      @cursor_grab_mode = CursorGrabMode::NONE
+      self
+    end
+
+    def aspect_ratio
+      return 0.0 if @height.zero?
+
+      @width / @height
+    end
+
+    def resolution
+      Vec2.new(@width, @height)
+    end
+
+    def fullscreen?
+      @mode != WindowMode::WINDOWED
+    end
+
+    def type_name
+      'Window'
+    end
+
+    def to_h
+      {
+        title: @title,
+        width: @width,
+        height: @height,
+        mode: @mode,
+        resizable: @resizable,
+        decorations: @decorations,
+        cursor_visible: @cursor_visible,
+        cursor_grab_mode: @cursor_grab_mode
+      }
+    end
+  end
+
+  class PrimaryWindow
+    attr_reader :window
+
+    def initialize(window = nil)
+      @window = window || Window.new
+    end
+
+    delegate_missing_to :@window if defined?(delegate_missing_to)
+
+    def method_missing(method, *args, &block)
+      if @window.respond_to?(method)
+        @window.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @window.respond_to?(method) || super
+    end
+
+    def type_name
+      'PrimaryWindow'
+    end
+  end
+
+  class WindowResized
+    attr_reader :window_id, :width, :height
+
+    def initialize(window_id:, width:, height:)
+      @window_id = window_id
+      @width = width.to_f
+      @height = height.to_f
+    end
+
+    def type_name
+      'WindowResized'
+    end
+  end
+
+  class WindowMoved
+    attr_reader :window_id, :position_x, :position_y
+
+    def initialize(window_id:, position_x:, position_y:)
+      @window_id = window_id
+      @position_x = position_x.to_f
+      @position_y = position_y.to_f
+    end
+
+    def type_name
+      'WindowMoved'
+    end
+  end
+
+  class WindowFocused
+    attr_reader :window_id, :focused
+
+    def initialize(window_id:, focused:)
+      @window_id = window_id
+      @focused = focused
+    end
+
+    def focused?
+      @focused
+    end
+
+    def type_name
+      'WindowFocused'
+    end
+  end
+
+  class WindowCloseRequested
+    attr_reader :window_id
+
+    def initialize(window_id:)
+      @window_id = window_id
+    end
+
+    def type_name
+      'WindowCloseRequested'
+    end
+  end
+
+  class WindowCreated
+    attr_reader :window_id
+
+    def initialize(window_id:)
+      @window_id = window_id
+    end
+
+    def type_name
+      'WindowCreated'
+    end
+  end
+
+  class Monitor
+    attr_reader :name, :physical_width, :physical_height, :refresh_rate, :scale_factor
+
+    def initialize(name:, physical_width:, physical_height:, refresh_rate: 60.0, scale_factor: 1.0)
+      @name = name
+      @physical_width = physical_width
+      @physical_height = physical_height
+      @refresh_rate = refresh_rate.to_f
+      @scale_factor = scale_factor.to_f
+    end
+
+    def resolution
+      Vec2.new(@physical_width.to_f, @physical_height.to_f)
+    end
+
+    def type_name
+      'Monitor'
+    end
+  end
+
+  class WindowPlugin
+    attr_accessor :primary_window, :exit_condition, :close_when_requested
+
+    def initialize(primary_window: nil, close_when_requested: true)
+      @primary_window = primary_window
+      @close_when_requested = close_when_requested
+      @exit_condition = :on_primary_closed
+    end
+
+    def build(app)
+      if @primary_window
+        app.insert_resource(PrimaryWindow.new(@primary_window))
+      end
+      app
+    end
+
+    def type_name
+      'WindowPlugin'
+    end
+  end
+end