pbrt 0.1.0

data/lib/pbrt/builder/accelerator.rb

@@ -0,0 +1,36 @@
+module PBRT
+  class Builder
+    class Accelerator
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def bvh(params = {})
+        write Statement.variadic("Accelerator", "bvh", ParameterList.from(
+          params,
+
+          maxnodeprims: :integer,
+          splitmethod: :string,
+        ))
+      end
+
+      def kdtree(params = {})
+        write Statement.variadic("Accelerator", "kdtree", ParameterList.from(
+          params,
+
+          intersectcost: :integer,
+          traversalcost: :integer,
+          emptybonus: :float,
+          maxprims: :integer,
+          maxdepth: :integer,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/area_light_source.rb

@@ -0,0 +1,25 @@
+module PBRT
+  class Builder
+    class AreaLightSource
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def diffuse(params = {})
+        write Statement.variadic("AreaLightSource", "diffuse", ParameterList.from(
+          params,
+
+          L: :spectrum,
+          twosided: :bool,
+          samples: :integer,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/camera.rb

@@ -0,0 +1,67 @@
+module PBRT
+  class Builder
+    class Camera
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def environment(params = {})
+        write Statement.variadic("Camera", "environment", ParameterList.from(
+          params,
+
+          shutteropen: :float,
+          shutterclose: :float,
+          frameaspectratio: :float,
+          screenwindow: :float,
+        ))
+      end
+
+      def orthographic(params = {})
+        write Statement.variadic("Camera", "orthographic", ParameterList.from(
+          params,
+
+          shutteropen: :float,
+          shutterclose: :float,
+          frameaspectratio: :float,
+          screenwindow: :float,
+          lensradius: :float,
+          focaldistance: :float,
+        ))
+      end
+
+      def perspective(params = {})
+        write Statement.variadic("Camera", "perspective", ParameterList.from(
+          params,
+
+          shutteropen: :float,
+          shutterclose: :float,
+          frameaspectratio: :float,
+          screenwindow: :float,
+          lensradius: :float,
+          focaldistance: :float,
+          fov: :float,
+          halffov: :float,
+        ))
+      end
+
+      def realistic(params = {})
+        write Statement.variadic("Camera", "realistic", ParameterList.from(
+          params,
+
+          shutteropen: :float,
+          shutterclose: :float,
+          lensfile: :string,
+          aperturediameter: :float,
+          focusdistance: :float,
+          simpleweighting: :bool,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/film.rb

@@ -0,0 +1,29 @@
+module PBRT
+  class Builder
+    class Film
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def image(params = {})
+        write Statement.variadic("Film", "image", ParameterList.from(
+          params,
+
+          xresolution: :integer,
+          yresolution: :integer,
+          cropwindow: :float,
+          scale: :float,
+          maxsampleluminance: :float,
+          diagonal: :float,
+          filename: :string,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/integrator.rb

@@ -0,0 +1,82 @@
+module PBRT
+  class Builder
+    class Integrator
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def bdpt(params = {})
+        write Statement.variadic("Integrator", "bdpt", ParameterList.from(
+          params,
+
+          maxdepth: :integer,
+          pixelbounds: :integer,
+          lightsamplestrategy: :string,
+          visualizestrategies: :bool,
+          visualizeweights: :bool,
+        ))
+      end
+
+      def directlighting(params = {})
+        write Statement.variadic("Integrator", "directlighting", ParameterList.from(
+          params,
+
+          strategy: :string,
+          maxdepth: :integer,
+          pixelbounds: :integer,
+        ))
+      end
+
+      def mlt(params = {})
+        write Statement.variadic("Integrator", "mlt", ParameterList.from(
+          params,
+
+          maxdepth: :integer,
+          bootstrapsamples: :integer,
+          chains: :integer,
+          mutationsperpixel: :integer,
+          largestepprobability: :float,
+          sigma: :float,
+        ))
+      end
+
+      def path(params = {})
+        write Statement.variadic("Integrator", "path", ParameterList.from(
+          params,
+
+          maxdepth: :integer,
+          pixelbounds: :integer,
+          rrthreshold: :float,
+          lightsamplestrategy: :string,
+        ))
+      end
+
+      def sppm(params = {})
+        write Statement.variadic("Integrator", "sppm", ParameterList.from(
+          params,
+
+          maxdepth: :integer,
+          iterations: :integer,
+          photonsperiteration: :integer,
+          imagewritefrequency: :integer,
+          radius: :float,
+        ))
+      end
+
+      def whitted(params = {})
+        write Statement.variadic("Integrator", "whitted", ParameterList.from(
+          params,
+
+          maxdepth: :integer,
+          pixelbounds: :integer,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/light_source.rb

@@ -0,0 +1,81 @@
+module PBRT
+  class Builder
+    class LightSource
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def distant(params = {})
+        write Statement.variadic("LightSource", "distant", ParameterList.from(
+          params,
+
+          scale: :spectrum,
+          L: :spectrum,
+          from: :point3,
+          to: :point3,
+        ))
+      end
+
+      def goniometric(params = {})
+        write Statement.variadic("LightSource", "goniometric", ParameterList.from(
+          params,
+
+          scale: :spectrum,
+          I: :spectrum,
+          mapname: :string,
+        ))
+      end
+
+      def infinite(params = {})
+        write Statement.variadic("LightSource", "infinite", ParameterList.from(
+          params,
+
+          scale: :spectrum,
+          L: :spectrum,
+          samples: :integer,
+          mapname: :string,
+        ))
+      end
+
+      def point(params = {})
+        write Statement.variadic("LightSource", "point", ParameterList.from(
+          params,
+
+          scale: :spectrum,
+          I: :spectrum,
+          from: :point3,
+        ))
+      end
+
+      def projection(params = {})
+        write Statement.variadic("LightSource", "projection", ParameterList.from(
+          params,
+
+          scale: :spectrum,
+          I: :spectrum,
+          fov: :float,
+          mapname: :string,
+        ))
+      end
+
+      def spot(params = {})
+        write Statement.variadic("LightSource", "spot", ParameterList.from(
+          params,
+
+          scale: :spectrum,
+          I: :spectrum,
+          from: :point3,
+          to: :point3,
+          coneangle: :float,
+          conedeltaangle: :float,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/material.rb

@@ -0,0 +1,266 @@
+module PBRT
+  class Builder
+    class Material
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def disney(params = {})
+        write Statement.variadic("Material", "disney", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          color: :spectrum_texture,
+          anisotropic: :float_texture,
+          clearcoat: :float_texture,
+          clearcoatgloss: :float_texture,
+          eta: :float_texture,
+          metallic: :float_texture,
+          roughness: :float_texture,
+          scatterdistance: :spectrum_texture,
+          sheen: :float_texture,
+          sheentint: :float_texture,
+          spectrans: :float_texture,
+          speculartint: :float_texture,
+          thin: :bool,
+          difftrans: :spectrum_texture,
+          flatness: :spectrum_texture,
+        ))
+      end
+
+      def fourier(params = {})
+        write Statement.variadic("Material", "fourier", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          bsdffile: :string,
+        ))
+      end
+
+      def glass(params = {})
+        write Statement.variadic("Material", "glass", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          Kr: :spectrum_texture,
+          Kt: :spectrum_texture,
+          eta: :float_texture,
+          uroughness: :float_texture,
+          vroughness: :float_texture,
+          remaproughness: :bool,
+        ))
+      end
+
+      def hair(params = {})
+        write Statement.variadic("Material", "hair", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          sigma_a: :spectrum_texture,
+          color: :spectrum_texture,
+          eumelanin: :float_texture,
+          pheomelanin: :float_texture,
+          eta: :float_texture,
+          beta_m: :float_texture,
+          beta_n: :float_texture,
+          alpha: :float_texture,
+        ))
+      end
+
+      def kdsubsurface(params = {})
+        write Statement.variadic("Material", "kdsubsurface", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          Kd: :spectrum_texture,
+          mfp: :float_texture,
+          eta: :float_texture,
+          Kr: :spectrum_texture,
+          Kt: :spectrum_texture,
+          uroughness: :float_texture,
+          vroughness: :float_texture,
+          remaproughness: :bool,
+        ))
+      end
+
+      def matte(params = {})
+        write Statement.variadic("Material", "matte", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          Kd: :spectrum_texture,
+          sigma: :float_texture,
+        ))
+      end
+
+      def metal(params = {})
+        write Statement.variadic("Material", "metal", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          eta: :spectrum_texture,
+          k: :spectrum_texture,
+          roughness: :float_texture,
+          uroughness: :float_texture,
+          vroughness: :float_texture,
+          remaproughness: :bool,
+        ))
+      end
+
+      def mirror(params = {})
+        write Statement.variadic("Material", "mirror", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          Kr: :spectrum_texture,
+        ))
+      end
+
+      def mix(params = {})
+        write Statement.variadic("Material", "mix", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          amount: :spectrum_texture,
+          namedmaterial1: :string,
+          namedmaterial2: :string,
+        ))
+      end
+
+      def none(params = {})
+        write Statement.variadic("Material", "none", ParameterList.from(
+          params,
+          bumpmap: :float_texture,
+        ))
+      end
+
+      def plastic(params = {})
+        write Statement.variadic("Material", "plastic", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          Kd: :spectrum_texture,
+          Ks: :spectrum_texture,
+          roughness: :float_texture,
+          remaproughness: :bool,
+        ))
+      end
+
+      def substrate(params = {})
+        write Statement.variadic("Material", "substrate", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          Kd: :spectrum_texture,
+          Ks: :spectrum_texture,
+          uroughness: :float_texture,
+          vroughness: :float_texture,
+          remaproughness: :bool,
+        ))
+      end
+
+      def subsurface(params = {})
+        write Statement.variadic("Material", "subsurface", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          name: :string,
+          sigma_a: :spectrum_texture,
+          sigma_prime_s: :spectrum_texture,
+          scale: :float,
+          eta: :float_texture,
+          Kr: :spectrum_texture,
+          Kt: :spectrum_texture,
+          uroughness: :float_texture,
+          vroughness: :float_texture,
+          remaproughness: :bool,
+        ))
+      end
+
+      def translucent(params = {})
+        write Statement.variadic("Material", "translucent", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          Kd: :spectrum_texture,
+          Ks: :spectrum_texture,
+          reflect: :spectrum_texture,
+          transmit: :spectrum_texture,
+          roughness: :float_texture,
+          remaproughness: :bool,
+        ))
+      end
+
+      def uber(params = {})
+        write Statement.variadic("Material", "uber", ParameterList.from(
+          params,
+
+          bumpmap: :float_texture,
+          Kd: :spectrum_texture,
+          Ks: :spectrum_texture,
+          Kr: :spectrum_texture,
+          Kt: :spectrum_texture,
+          roughness: :float_texture,
+          uroughness: :float_texture,
+          vroughness: :float_texture,
+          eta: :float_texture,
+          opacity: :spectrum_texture,
+          remaproughness: :bool,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+
+      ALL_PARAMS = {
+          Kd: :spectrum_texture,
+          Kr: :spectrum_texture,
+          Ks: :spectrum_texture,
+          Kt: :spectrum_texture,
+          alpha: :float_texture,
+          amount: :spectrum_texture,
+          anisotropic: :float_texture,
+          beta_m: :float_texture,
+          beta_n: :float_texture,
+          bsdffile: :string,
+          bumpmap: :float_texture,
+          clearcoat: :float_texture,
+          clearcoatgloss: :float_texture,
+          color: :spectrum_texture,
+          difftrans: :spectrum_texture,
+          eumelanin: :float_texture,
+          flatness: :spectrum_texture,
+          k: :spectrum_texture,
+          metallic: :float_texture,
+          mfp: :float_texture,
+          name: :string,
+          namedmaterial1: :string,
+          namedmaterial2: :string,
+          opacity: :spectrum_texture,
+          pheomelanin: :float_texture,
+          reflect: :spectrum_texture,
+          remaproughness: :bool,
+          roughness: :float_texture,
+          scale: :float,
+          scatterdistance: :spectrum_texture,
+          sheen: :float_texture,
+          sheentint: :float_texture,
+          sigma: :float_texture,
+          sigma_a: :spectrum_texture,
+          sigma_prime_s: :spectrum_texture,
+          spectrans: :float_texture,
+          speculartint: :float_texture,
+          thin: :bool,
+          transmit: :spectrum_texture,
+          uroughness: :float_texture,
+          vroughness: :float_texture,
+
+          # eta appears as both a float_texture and spectrum_texture
+          eta: :texture,
+      }.freeze
+    end
+  end
+end