bevy 1.0.0

data/lib/bevy/shader.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+module Bevy
+  class ShaderSource
+    attr_reader :vertex, :fragment, :compute
+
+    def initialize(vertex: nil, fragment: nil, compute: nil)
+      @vertex = vertex
+      @fragment = fragment
+      @compute = compute
+    end
+
+    def has_vertex?
+      !@vertex.nil?
+    end
+
+    def has_fragment?
+      !@fragment.nil?
+    end
+
+    def has_compute?
+      !@compute.nil?
+    end
+
+    def type_name
+      'ShaderSource'
+    end
+  end
+
+  class Shader
+    attr_reader :name, :source, :path
+
+    def initialize(name:, source: nil, path: nil)
+      @name = name
+      @source = source
+      @path = path
+    end
+
+    def self.from_wgsl(name, wgsl_source)
+      new(name: name, source: ShaderSource.new(fragment: wgsl_source, vertex: wgsl_source))
+    end
+
+    def self.from_file(name, path)
+      new(name: name, path: path)
+    end
+
+    def loaded?
+      @source || @path
+    end
+
+    def type_name
+      'Shader'
+    end
+  end
+
+  class ShaderDefVal
+    attr_reader :key, :value
+
+    def initialize(key, value)
+      @key = key.to_s
+      @value = value
+    end
+
+    def self.bool(key, value)
+      new(key, value ? 1 : 0)
+    end
+
+    def self.int(key, value)
+      new(key, value.to_i)
+    end
+
+    def self.uint(key, value)
+      new(key, value.to_i.abs)
+    end
+
+    def type_name
+      'ShaderDefVal'
+    end
+  end
+
+  class ShaderDefs
+    def initialize
+      @defs = {}
+    end
+
+    def set(key, value)
+      @defs[key.to_s] = value
+      self
+    end
+
+    def get(key)
+      @defs[key.to_s]
+    end
+
+    def remove(key)
+      @defs.delete(key.to_s)
+      self
+    end
+
+    def to_h
+      @defs.dup
+    end
+
+    def type_name
+      'ShaderDefs'
+    end
+  end
+
+  class PostProcessSettings
+    attr_accessor :enabled, :intensity
+
+    def initialize(enabled: true, intensity: 1.0)
+      @enabled = enabled
+      @intensity = intensity.to_f
+    end
+
+    def type_name
+      'PostProcessSettings'
+    end
+  end
+
+  class Bloom
+    attr_accessor :intensity, :threshold, :soft_threshold, :composite_mode
+
+    def initialize(intensity: 0.5, threshold: 1.0, soft_threshold: 0.5, composite_mode: :additive)
+      @intensity = intensity.to_f
+      @threshold = threshold.to_f
+      @soft_threshold = soft_threshold.to_f
+      @composite_mode = composite_mode
+    end
+
+    def type_name
+      'Bloom'
+    end
+
+    def to_h
+      {
+        intensity: @intensity,
+        threshold: @threshold,
+        soft_threshold: @soft_threshold,
+        composite_mode: @composite_mode
+      }
+    end
+  end
+
+  class ChromaticAberration
+    attr_accessor :intensity, :max_samples
+
+    def initialize(intensity: 0.02, max_samples: 8)
+      @intensity = intensity.to_f
+      @max_samples = max_samples
+    end
+
+    def type_name
+      'ChromaticAberration'
+    end
+
+    def to_h
+      {
+        intensity: @intensity,
+        max_samples: @max_samples
+      }
+    end
+  end
+
+  class Vignette
+    attr_accessor :intensity, :radius, :smoothness, :color
+
+    def initialize(intensity: 0.5, radius: 0.5, smoothness: 0.5, color: nil)
+      @intensity = intensity.to_f
+      @radius = radius.to_f
+      @smoothness = smoothness.to_f
+      @color = color || Color.black
+    end
+
+    def type_name
+      'Vignette'
+    end
+
+    def to_h
+      {
+        intensity: @intensity,
+        radius: @radius,
+        smoothness: @smoothness,
+        color: @color.to_a
+      }
+    end
+  end
+
+  class FilmGrain
+    attr_accessor :intensity, :response
+
+    def initialize(intensity: 0.1, response: 0.5)
+      @intensity = intensity.to_f
+      @response = response.to_f
+    end
+
+    def type_name
+      'FilmGrain'
+    end
+
+    def to_h
+      {
+        intensity: @intensity,
+        response: @response
+      }
+    end
+  end
+
+  class Tonemapping
+    attr_accessor :mode
+
+    MODES = %i[none reinhard reinhard_luminance aces_fitted aces_approximate tony_mc_mapface blender_filmic].freeze
+
+    def initialize(mode: :tony_mc_mapface)
+      @mode = mode
+    end
+
+    def type_name
+      'Tonemapping'
+    end
+  end
+
+  class ColorGrading
+    attr_accessor :exposure, :gamma, :saturation, :contrast
+
+    def initialize(exposure: 0.0, gamma: 1.0, saturation: 1.0, contrast: 1.0)
+      @exposure = exposure.to_f
+      @gamma = gamma.to_f
+      @saturation = saturation.to_f
+      @contrast = contrast.to_f
+    end
+
+    def type_name
+      'ColorGrading'
+    end
+
+    def to_h
+      {
+        exposure: @exposure,
+        gamma: @gamma,
+        saturation: @saturation,
+        contrast: @contrast
+      }
+    end
+  end
+
+  class DepthOfField
+    attr_accessor :focal_distance, :focal_length, :aperture_f_stops, :max_blur
+
+    def initialize(focal_distance: 10.0, focal_length: 50.0, aperture_f_stops: 2.8, max_blur: 0.01)
+      @focal_distance = focal_distance.to_f
+      @focal_length = focal_length.to_f
+      @aperture_f_stops = aperture_f_stops.to_f
+      @max_blur = max_blur.to_f
+    end
+
+    def type_name
+      'DepthOfField'
+    end
+
+    def to_h
+      {
+        focal_distance: @focal_distance,
+        focal_length: @focal_length,
+        aperture_f_stops: @aperture_f_stops,
+        max_blur: @max_blur
+      }
+    end
+  end
+
+  class MotionBlur
+    attr_accessor :shutter_angle, :samples
+
+    def initialize(shutter_angle: 0.5, samples: 4)
+      @shutter_angle = shutter_angle.to_f
+      @samples = samples
+    end
+
+    def type_name
+      'MotionBlur'
+    end
+
+    def to_h
+      {
+        shutter_angle: @shutter_angle,
+        samples: @samples
+      }
+    end
+  end
+
+  class Fxaa
+    attr_accessor :enabled, :edge_threshold, :edge_threshold_min
+
+    def initialize(enabled: true, edge_threshold: :high, edge_threshold_min: :high)
+      @enabled = enabled
+      @edge_threshold = edge_threshold
+      @edge_threshold_min = edge_threshold_min
+    end
+
+    def type_name
+      'Fxaa'
+    end
+  end
+
+  class Smaa
+    attr_accessor :preset
+
+    PRESETS = %i[low medium high ultra].freeze
+
+    def initialize(preset: :high)
+      @preset = preset
+    end
+
+    def type_name
+      'Smaa'
+    end
+  end
+end

data/lib/bevy/shape.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Bevy
+  module Shape
+    class Rectangle
+      attr_reader :width, :height, :color
+
+      def initialize(width:, height:, color: Color.white)
+        @width = width.to_f
+        @height = height.to_f
+        @color = color
+      end
+
+      def to_sprite
+        Sprite.new(
+          color: @color,
+          custom_size: Vec2.new(@width, @height)
+        )
+      end
+
+      def type_name
+        'Shape::Rectangle'
+      end
+    end
+
+    class Circle
+      attr_reader :radius, :color, :segments
+
+      def initialize(radius:, color: Color.white, segments: 32)
+        @radius = radius.to_f
+        @color = color
+        @segments = segments
+      end
+
+      def diameter
+        @radius * 2.0
+      end
+
+      def to_sprite
+        Sprite.new(
+          color: @color,
+          custom_size: Vec2.new(diameter, diameter)
+        )
+      end
+
+      def type_name
+        'Shape::Circle'
+      end
+    end
+
+    class Line
+      attr_reader :start_point, :end_point, :thickness, :color
+
+      def initialize(start_point:, end_point:, thickness: 2.0, color: Color.white)
+        @start_point = start_point
+        @end_point = end_point
+        @thickness = thickness.to_f
+        @color = color
+      end
+
+      def length
+        dx = @end_point.x - @start_point.x
+        dy = @end_point.y - @start_point.y
+        Math.sqrt(dx * dx + dy * dy)
+      end
+
+      def angle
+        dx = @end_point.x - @start_point.x
+        dy = @end_point.y - @start_point.y
+        Math.atan2(dy, dx)
+      end
+
+      def center
+        Vec2.new(
+          (@start_point.x + @end_point.x) / 2.0,
+          (@start_point.y + @end_point.y) / 2.0
+        )
+      end
+
+      def to_sprite
+        Sprite.new(
+          color: @color,
+          custom_size: Vec2.new(length, @thickness)
+        )
+      end
+
+      def to_transform(z: 0.0)
+        center_point = center
+        Transform.new(
+          translation: Vec3.new(center_point.x, center_point.y, z),
+          rotation: Quat.from_rotation_z(angle),
+          scale: Vec3.one
+        )
+      end
+
+      def type_name
+        'Shape::Line'
+      end
+    end
+
+    class Polygon
+      attr_reader :points, :color
+
+      def initialize(points:, color: Color.white)
+        @points = points
+        @color = color
+      end
+
+      def centroid
+        return Vec2.zero if @points.empty?
+
+        sum_x = @points.sum(&:x)
+        sum_y = @points.sum(&:y)
+        Vec2.new(sum_x / @points.length, sum_y / @points.length)
+      end
+
+      def bounding_box
+        return { min: Vec2.zero, max: Vec2.zero } if @points.empty?
+
+        min_x = @points.map(&:x).min
+        max_x = @points.map(&:x).max
+        min_y = @points.map(&:y).min
+        max_y = @points.map(&:y).max
+
+        { min: Vec2.new(min_x, min_y), max: Vec2.new(max_x, max_y) }
+      end
+
+      def to_sprite
+        bbox = bounding_box
+        width = bbox[:max].x - bbox[:min].x
+        height = bbox[:max].y - bbox[:min].y
+
+        Sprite.new(
+          color: @color,
+          custom_size: Vec2.new(width, height)
+        )
+      end
+
+      def type_name
+        'Shape::Polygon'
+      end
+    end
+
+    class RegularPolygon
+      attr_reader :radius, :sides, :color
+
+      def initialize(radius:, sides:, color: Color.white)
+        @radius = radius.to_f
+        @sides = [sides.to_i, 3].max
+        @color = color
+      end
+
+      def points
+        (0...@sides).map do |i|
+          angle = (2.0 * Math::PI * i / @sides) - (Math::PI / 2.0)
+          Vec2.new(
+            @radius * Math.cos(angle),
+            @radius * Math.sin(angle)
+          )
+        end
+      end
+
+      def to_sprite
+        Sprite.new(
+          color: @color,
+          custom_size: Vec2.new(@radius * 2, @radius * 2)
+        )
+      end
+
+      def type_name
+        'Shape::RegularPolygon'
+      end
+    end
+
+    class Triangle < RegularPolygon
+      def initialize(radius:, color: Color.white)
+        super(radius: radius, sides: 3, color: color)
+      end
+
+      def type_name
+        'Shape::Triangle'
+      end
+    end
+
+    class Hexagon < RegularPolygon
+      def initialize(radius:, color: Color.white)
+        super(radius: radius, sides: 6, color: color)
+      end
+
+      def type_name
+        'Shape::Hexagon'
+      end
+    end
+  end
+end