raysetta 0.1.0

data/sig/raysetta/object/sphere.rbs

@@ -0,0 +1,14 @@
+module Raysetta
+  module Object
+    class Sphere < Base
+      attr_accessor center: Vec3
+      attr_accessor radius: Float
+      attr_accessor material: Material::Base
+      attr_reader bounding_box: AABB
+
+      def initialize: (Vec3 center, Float radius, Material::Base material) -> void
+
+      def hit: (Ray r, Range[Float] ray_t, ?Vec3 center) -> Hit?
+    end
+  end
+end

data/sig/raysetta/object/tri.rbs

@@ -0,0 +1,15 @@
+module Raysetta
+  module Object
+    class Tri < Quad
+      # Compute the bounding box of all three vertices.
+      @bounding_box: AABB
+
+      def initialize: (Vec3 a, Vec3 b, Vec3 c, Material::Base material) -> void
+
+      private
+
+      def interior?: (Float a, Float b) -> Vec2?
+      def compute_bounding_box: () -> AABB
+    end
+  end
+end

data/sig/raysetta/output/base.rbs

@@ -0,0 +1,15 @@
+module Raysetta
+  module Output
+    class Base
+      type pixel = [Integer, Integer, Integer]
+      attr_reader pixels: Array[Array[pixel]]
+      attr_reader width: Integer
+      attr_reader height: Integer
+
+      def initialize: (Array[Array[pixel]] pixels, width: Integer, height: Integer) -> void
+
+      def call: () -> untyped
+      def save: (String file) -> void
+    end
+  end
+end

data/sig/raysetta/output/png.rbs

@@ -0,0 +1,8 @@
+module Raysetta
+  module Output
+    class PNG < Base
+      def call: () -> ChunkyPNG::Image
+      def save: (String file) -> void
+    end
+  end
+end

data/sig/raysetta/output/ppm.rbs

@@ -0,0 +1,7 @@
+module Raysetta
+  module Output
+    class PPM < Base
+      def call: () -> String
+    end
+  end
+end

data/sig/raysetta/perlin.rbs

@@ -0,0 +1,19 @@
+module Raysetta
+  class Perlin < EntityBase
+    attr_accessor randvec: Array[Vec3]
+    attr_accessor perm_x: Array[Integer]
+    attr_accessor perm_y: Array[Integer]
+    attr_accessor perm_z: Array[Integer]
+
+    POINT_COUNT: 256
+
+    def initialize: (?Array[Vec3] randvec, ?Array[Integer] perm_x, ?Array[Integer] perm_y, ?Array[Integer] perm_z) -> void
+
+    def noise: (Vec3 point) -> Float
+    def turb: (Vec3 point, Integer  depth) -> Float
+
+    def self.perlin_interp: (Array[Array[Array[Vec3]]] c, Vec3 vec) -> Float
+
+    CUBE: Array[[Integer, Integer, Integer]]
+  end
+end

data/sig/raysetta/ray.rbs

@@ -0,0 +1,18 @@
+module Raysetta
+  class Ray
+    attr_accessor origin: Vec3
+    attr_accessor direction: Vec3
+    attr_accessor time: Float
+
+    def initialize: (Vec3 origin, Vec3 direction, ?Float time) -> void
+
+    def at: (Float t) -> Vec3
+
+    def dup: () -> instance
+
+    def ==: (untyped r) -> bool
+    alias eql? ==
+
+    def hash: () -> Integer
+  end
+end

data/sig/raysetta/runner/base.rbs

@@ -0,0 +1,15 @@
+module Raysetta
+  module Runner
+    type output = Array[Array[Output::Base::pixel]]
+
+    class Base
+      attr_reader tracer: Tracer
+
+      def initialize: (Tracer tracer) -> void
+
+      def call: () -> void
+      def progress: () -> void
+      def finish: () -> void
+    end
+  end
+end

data/sig/raysetta/runner/concurrent.rbs

@@ -0,0 +1,10 @@
+module Raysetta
+  module Runner
+    class Concurrent < Base
+      attr_reader count: Integer
+      attr_reader output: output
+
+      def initialize: (Tracer tracer, ?count: Integer) -> void
+    end
+  end
+end

data/sig/raysetta/runner/processes.rbs

@@ -0,0 +1,9 @@
+module Raysetta
+  module Runner
+    class Processes < Concurrent
+      attr_reader output: output
+
+      def call: () -> void
+    end
+  end
+end

data/sig/raysetta/runner/ractors.rbs

@@ -0,0 +1,11 @@
+module Raysetta
+  module Runner
+    class Ractors < Concurrent
+      attr_reader output: output
+
+      def call: () -> void
+
+      def self.run: ([Integer, Tracer]) -> Array[Output::Base::pixel]
+    end
+  end
+end

data/sig/raysetta/runner/sync.rbs

@@ -0,0 +1,11 @@
+module Raysetta
+  module Runner
+    class Sync < Base
+      attr_reader output: output
+
+      def initialize: (Tracer tracer) -> void
+
+      def call: () -> void
+    end
+  end
+end

data/sig/raysetta/runner/threads.rbs

@@ -0,0 +1,9 @@
+module Raysetta
+  module Runner
+    class Threads < Concurrent
+      attr_reader output: output
+
+      def call: () -> void
+    end
+  end
+end

data/sig/raysetta/runner.rbs

@@ -0,0 +1,5 @@
+module Raysetta
+  module Runner
+    def self.parse_scene: (String input_path, ?output_path: String?, ?runner: Symbol, ?format: Symbol, ?concurrency: Integer, **untyped options) -> void
+  end
+end

data/sig/raysetta/scatter.rbs

@@ -0,0 +1,8 @@
+module Raysetta
+  class Scatter
+    attr_accessor ray: Ray
+    attr_accessor attenuation: Vec3
+
+    def initialize: (Ray ray, Vec3 attenuation) -> void
+  end
+end

data/sig/raysetta/scene.rbs

@@ -0,0 +1,69 @@
+module Raysetta
+  class Scene
+    type json = Hash[String, Hash[String, Hash[String, untyped]]]
+
+    attr_accessor world: Object::Base
+    attr_accessor camera: Camera
+    attr_accessor background: Background::Base
+
+    def initialize: (Object::Base world, Camera camera, Background::Base background) -> void
+
+    def self.parse: (json json) -> Scene
+
+    def export: () -> Hash[Symbol, untyped]
+
+    private
+
+    interface _Exportable
+      def id: () -> String
+      def export: () -> Hash[Symbol, untyped]
+    end
+
+    def export_by_id: (Array[_Exportable] entities) -> Hash[String, Hash[Symbol, untyped]]
+
+    class Parser
+      @noises: Hash[String, Perlin]
+      @images: Hash[String, Image]
+      @textures: Hash[String, Texture::Base]
+      @materials: Hash[String, Material::Base]
+
+      class Error < Raysetta::Error
+      end
+
+      attr_reader json: json
+
+      def initialize: (json json) -> void
+
+      def parse: () -> Scene
+
+      def parse_noise: (Hash[String, untyped] noise) -> Perlin
+      def parse_image: (Hash[String, untyped] img) -> Image
+      def parse_texture: (Hash[String, untyped] tex) -> Texture::Base
+      def parse_material: (Hash[String, untyped] mat) -> Material::Base
+      def parse_world: (Hash[String, Hash[String, untyped]] json) -> Object::Base
+
+      def parse_object: (Hash[String, untyped] obj) -> Object::Base
+      def parse_sphere: (Hash[String, untyped] obj) -> Object::Sphere
+      def parse_moving_sphere: (Hash[String, untyped] obj) -> Object::MovingSphere
+      def parse_quad: (Hash[String, untyped] obj) -> Object::Quad
+      def parse_tri: (Hash[String, untyped] obj) -> Object::Tri
+      def parse_box: (Hash[String, untyped] obj) -> Object::Box
+
+      def material: (String name) -> Material::Base
+      def texture: (String name) -> Texture::Base
+      def image: (String name) -> Image
+      def noise: (String name) -> Perlin
+
+      def parse_camera: (Hash[String, untyped] cam) -> Camera
+      def parse_background: (Hash[String, untyped] bg) -> Background::Base
+      def parse_solid_bg: (Hash[String, untyped] bg) -> Background::Solid
+      def parse_gradient_bg: (Hash[String, untyped] bg) -> Background::Gradient
+      def parse_sphere_map: (Hash[String, untyped] bg) -> Background::SphereMap
+      def parse_cube_map: (Hash[String, untyped] bg) -> Background::CubeMap
+
+      def vec2: (Array[Float]) -> Vec2
+      def vec3: (Array[Float]) -> Vec3
+      alias rgb vec3
+    end
+  end
+end

data/sig/raysetta/texture/base.rbs

@@ -0,0 +1,11 @@
+module Raysetta
+  module Texture
+    class Base < EntityBase
+      def sample: (Vec2 uv, Vec3 point) -> Vec3
+
+      def export: () -> Hash[Symbol, untyped]
+      def images: () -> Array[Image]
+      def noises: () -> Array[Perlin]
+    end
+  end
+end

data/sig/raysetta/texture/checker.rbs

@@ -0,0 +1,15 @@
+module Raysetta
+  module Texture
+    class Checker < Base
+      attr_accessor inv_scale: Float
+      attr_accessor even: Texture::Base
+      attr_accessor odd: Texture::Base
+
+      def initialize: (Float scale, Texture::Base even, Texture::Base odd) -> void
+      def self.solid: (Float scale, Vec3 even, Vec3 odd) -> instance
+
+      def scale=: (Float scale) -> Float
+      def scale: () -> Float
+    end
+  end
+end

data/sig/raysetta/texture/image.rbs

@@ -0,0 +1,11 @@
+module Raysetta
+  module Texture
+    class Image < Base
+      attr_accessor image: Raysetta::Image
+
+      def initialize: (Raysetta::Image image) -> void
+
+      def images: () -> [Raysetta::Image]
+    end
+  end
+end

data/sig/raysetta/texture/noise.rbs

@@ -0,0 +1,13 @@
+module Raysetta
+  module Texture
+    class Noise < Base
+      attr_accessor scale: Float
+      attr_accessor depth: Integer
+      attr_accessor marble_axis: Symbol
+
+      def initialize: (Float scale, Integer depth, Symbol marble_axis, ?Perlin noise) -> void
+
+      attr_reader noise: Perlin
+    end
+  end
+end

data/sig/raysetta/texture/solid_color.rbs

@@ -0,0 +1,10 @@
+module Raysetta
+  module Texture
+    class SolidColor < Base
+      attr_accessor albedo: Vec3
+
+      def initialize: (Vec3 albedo) -> void
+      def self.rgb: (Float r, Float g, Float b) -> instance
+    end
+  end
+end

data/sig/raysetta/tracer.rbs

@@ -0,0 +1,16 @@
+module Raysetta
+  class Tracer
+    @pixel_sample_scale: Float
+
+    attr_reader scene: Scene
+    attr_reader width: Integer
+    attr_reader height: Integer
+    attr_reader samples_per_pixel: Integer
+    attr_reader max_depth: Integer
+
+    def initialize: (Scene scene, ?width: Integer, ?height: Integer, ?samples_per_pixel: Integer, ?max_depth: Integer) -> void
+
+    def call: (Integer x, Integer y) -> [Integer, Integer, Integer]
+    def ray_color: (Ray r, ?Integer depth) -> Vec3
+  end
+end

data/sig/raysetta/util.rbs

@@ -0,0 +1,15 @@
+module Raysetta
+  module Util
+    EPSILON: Float
+
+    def self.degrees_to_radians: (Float degrees) -> Float
+
+    # Returns a random real in [min,max).
+    def self.random: (Float min, Float max) -> Float
+
+    def self.linear_to_gamma: (Float linear_component) -> Float
+    def self.gamma_to_linear: (Float gamma_component, ?Float gamma) -> Float
+
+    def self.sphere_uv: (Vec3 point) -> Vec2
+  end
+end

data/sig/raysetta/vec2.rbs

@@ -0,0 +1,48 @@
+module Raysetta
+  class Vec2
+    attr_accessor x: Float
+    attr_accessor y: Float
+
+    attr_accessor u (): Float
+    attr_accessor v (): Float
+
+    def initialize: (?Float x, ?Float y) -> void
+
+    def self.random: (?Float min, ?Float max) -> Vec2
+    def self.sample_square: () -> instance
+
+    def []: (Integer i) -> Float
+    def []=: (Integer i, Float v) -> void
+
+    def -@: () -> Vec2
+
+    def +: (Vec2 v) -> Vec2
+    def -: (Vec2 v) -> Vec2
+    def *: (Float t) -> Vec2
+    def /: (Float t) -> Vec2
+
+    def add: (Vec2 v) -> self
+    def sub: (Vec2 v) -> self
+    def mul: (Float t) -> self
+    def div: (Float t) -> self
+
+    def neg: () -> self
+
+    def length: () -> Float
+    def length_squared: () -> Float
+
+    def dot: (Vec2 v) -> Float
+    def unit: () -> Vec2
+    def normalize: () -> self
+
+    def dup: () -> Vec2
+
+    def abs!: () -> self
+    def abs: () -> Vec2
+
+    def zero?: () -> bool
+
+    def to_a: () -> [Float, Float]
+    alias to_ary to_a
+  end
+end

data/sig/raysetta/vec3.rbs

@@ -0,0 +1,67 @@
+module Raysetta
+  class Vec3
+    attr_accessor x: Float
+    attr_accessor y: Float
+    attr_accessor z: Float
+
+    attr_accessor r (): Float
+    attr_accessor g (): Float
+    attr_accessor b (): Float
+
+    def self.dimensions: () -> 3
+
+    def initialize: (?Float x, ?Float y, ?Float z) -> void
+
+    def self.random: (?Float min, ?Float max) -> Vec3
+    def self.random_in_unit_sphere: () -> instance
+    def self.random_unit: () -> instance
+    def self.random_on_hemisphere: (Vec3 normal) -> instance
+    def self.random_in_unit_disk: () -> instance
+
+    def []: (Integer i) -> Float
+    def []=: (Integer i, Float v) -> void
+
+    def -@: () -> Vec3
+
+    def +: (Vec3 v) -> Vec3
+    def -: (Vec3 v) -> Vec3
+    def *: (Float t) -> Vec3
+    def /: (Float t) -> Vec3
+
+    def add: (Vec3 v) -> self
+    def sub: (Vec3 v) -> self
+    def mul: (Float t) -> self
+    def div: (Float t) -> self
+
+    def neg: () -> self
+
+    def length: () -> Float
+    def length_squared: () -> Float
+
+    def dot: (Vec3 v) -> Float
+    def unit: () -> Vec3
+    def normalize: () -> self
+
+    def dup: () -> Vec3
+
+    def abs!: () -> self
+    def abs: () -> Vec3
+
+    def smoothstep!: () -> self
+    def smoothstep: () -> Vec3
+
+    def multiply: (Vec3 v) -> self
+    def times: (Vec3 v) -> Vec3
+
+    def cross: (Vec3 v) -> Vec3
+    def reflect: (Vec3 n) -> Vec3
+    def refract: (Vec3 n, Float etai_over_etat) -> instance
+
+    def to_pixel: () -> [Integer, Integer, Integer]
+
+    def zero?: () -> bool
+
+    def to_a: () -> [Float, Float, Float]
+    alias to_ary to_a
+  end
+end

data/sig/raysetta.rbs

@@ -0,0 +1,6 @@
+module Raysetta
+  VERSION: String
+
+  class Error < StandardError
+  end
+end

data/sig/stdlib/chunky_png.rbs

@@ -0,0 +1,24 @@
+module ChunkyPNG
+  class Canvas
+    def width: () -> Integer
+    def height: () -> Integer
+    def get_pixel: (Integer, Integer) -> Color
+    def set_pixel: (Integer, Integer, Integer) -> void
+    def to_data_url: () -> String
+    def save: (String, Symbol) -> void
+  end
+
+  class Image < Canvas
+    def initialize: (Integer width, Integer height) -> void
+
+    def self.from_file: (String) -> instance
+    def self.from_data_url: (String) -> instance
+  end
+
+  class Color
+    def self.r: (instance) -> Integer
+    def self.g: (instance) -> Integer
+    def self.b: (instance) -> Integer
+    def self.rgb: (Integer, Integer, Integer) -> Integer
+  end
+end

data/sig/stdlib/etc.rbs

@@ -0,0 +1,3 @@
+module Etc
+  def self.nprocessors: () -> Integer
+end

data/sig/stdlib/json.rbs

@@ -0,0 +1,3 @@
+module JSON
+  def self.parse: (String) -> Hash[String, untyped]
+end

data/sig/stdlib/optparse.rbs

@@ -0,0 +1,4 @@
+class OptionParser
+  def initialize: () { (untyped) -> void } -> void
+  def parse!: () -> void
+end

data/sig/stdlib/parallel.rbs

@@ -0,0 +1,5 @@
+module Parallel
+  def self.map: [I, O] (Array[I], in_threads: Integer, ?finish: Proc) { (I) -> O } -> Array[O]
+              | [I, O] (Array[I], in_processes: Integer, ?finish: Proc) { (I) -> O } -> Array[O]
+              | [I] (Array[I], in_ractors: Integer, ractor: [Class, Symbol], ?finish: Proc) -> Array[untyped]
+end

data/sig/stdlib/progress.rbs

@@ -0,0 +1,5 @@
+module Progress
+  def self.start: (String, Integer) -> void
+  def self.step: () -> void
+  def self.stop: () -> void
+end