pbrt 0.1.0

data/lib/pbrt/builder/named_material.rb

@@ -0,0 +1,24 @@
+module PBRT
+  class Builder
+    class NamedMaterial
+      def initialize(builder, name)
+        @builder = builder
+        @name = name
+      end
+
+      def method_missing(method, *args)
+        Material.new(self).public_send(method, *args)
+      end
+
+      def write(statement)
+        @builder.write(modified(statement))
+      end
+
+      private
+
+      def modified(statement)
+        statement.to_s.sub("Material", %(MakeNamedMaterial "#@name" "string type"))
+      end
+    end
+  end
+end

data/lib/pbrt/builder/named_medium.rb

@@ -0,0 +1,46 @@
+module PBRT
+  class Builder
+    class NamedMedium
+      def initialize(builder, name)
+        @builder = builder
+        @directive = %(MakeNamedMedium "#{name}" "string type")
+      end
+
+      def homogeneous(params = {})
+        write Statement.variadic(@directive, "homogeneous", ParameterList.from(
+          params,
+
+          sigma_a: :spectrum,
+          sigma_s: :spectrum,
+          preset: :string,
+          g: :float,
+          scale: :float,
+        ))
+      end
+
+      def heterogeneous(params = {})
+        write Statement.variadic(@directive, "heterogeneous", ParameterList.from(
+          params,
+
+          sigma_a: :spectrum,
+          sigma_s: :spectrum,
+          preset: :string,
+          g: :float,
+          scale: :float,
+          p0: :point3,
+          p1: :point3,
+          nx: :integer,
+          ny: :integer,
+          nz: :integer,
+          density: :float,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/pixel_filter.rb

@@ -0,0 +1,64 @@
+module PBRT
+  class Builder
+    class PixelFilter
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def box(params = {})
+        write Statement.variadic("PixelFilter", "box", ParameterList.from(
+          params,
+
+          xwidth: :float,
+          ywidth: :float,
+        ))
+      end
+
+      def gaussian(params = {})
+        write Statement.variadic("PixelFilter", "gaussian", ParameterList.from(
+          params,
+
+          xwidth: :float,
+          ywidth: :float,
+          alpha: :float,
+        ))
+      end
+
+      def mitchell(params = {})
+        write Statement.variadic("PixelFilter", "mitchell", ParameterList.from(
+          params,
+
+          xwidth: :float,
+          ywidth: :float,
+          B: :float,
+          C: :float,
+        ))
+      end
+
+      def sinc(params = {})
+        write Statement.variadic("PixelFilter", "sinc", ParameterList.from(
+          params,
+
+          xwidth: :float,
+          ywidth: :float,
+          tau: :float,
+        ))
+      end
+
+      def triangle(params = {})
+        write Statement.variadic("PixelFilter", "triangle", ParameterList.from(
+          params,
+
+          xwidth: :float,
+          ywidth: :float,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/sampler.rb

@@ -0,0 +1,60 @@
+module PBRT
+  class Builder
+    class Sampler
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def o2sequence(params = {})
+        write Statement.variadic("Sampler", "02sequence", ParameterList.from(
+          params,
+          pixelsamples: :integer,
+        ))
+      end
+
+      def halton(params = {})
+        write Statement.variadic("Sampler", "halton", ParameterList.from(
+          params,
+          pixelsamples: :integer,
+        ))
+      end
+
+      def maxmindist(params = {})
+        write Statement.variadic("Sampler", "maxmindist", ParameterList.from(
+          params,
+          pixelsamples: :integer,
+        ))
+      end
+
+      def random(params = {})
+        write Statement.variadic("Sampler", "random", ParameterList.from(
+          params,
+          pixelsamples: :integer,
+        ))
+      end
+
+      def sobol(params = {})
+        write Statement.variadic("Sampler", "sobol", ParameterList.from(
+          params,
+          pixelsamples: :integer,
+        ))
+      end
+
+      def stratified(params = {})
+        write Statement.variadic("Sampler", "stratified", ParameterList.from(
+          params,
+
+          jitter: :bool,
+          xsamples: :integer,
+          ysamples: :integer,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/shape.rb

@@ -0,0 +1,171 @@
+module PBRT
+  class Builder
+    class Shape
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def cone(params = {})
+        write Statement.variadic("Shape", "cone", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          radius: :float,
+          height: :float,
+          phimax: :float,
+        ))
+      end
+
+      def curve(params = {})
+        write Statement.variadic("Shape", "curve", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          P: :point3,
+          basis: :string,
+          degree: :integer,
+          type: :string,
+          N: :normal3,
+          width: :float,
+          width0: :float,
+          width1: :float,
+          splitdepth: :integer,
+        ))
+      end
+
+      def cylinder(params = {})
+        write Statement.variadic("Shape", "cylinder", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          radius: :float,
+          zmin: :float,
+          zmax: :float,
+          phimax: :float,
+        ))
+      end
+
+      def disk(params = {})
+        write Statement.variadic("Shape", "disk", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          height: :float,
+          radius: :float,
+          innerradius: :float,
+          phimax: :float,
+        ))
+      end
+
+      def hyperboloid(params = {})
+        write Statement.variadic("Shape", "hyperboloid", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          p1: :point3,
+          p2: :point3,
+          phimax: :float,
+        ))
+      end
+
+      def paraboloid(params = {})
+        write Statement.variadic("Shape", "paraboloid", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          radius: :float,
+          zmin: :float,
+          zmax: :float,
+          phimax: :float,
+        ))
+      end
+
+      def sphere(params = {})
+        write Statement.variadic("Shape", "sphere", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          radius: :float,
+          zmin: :float,
+          zmax: :float,
+          phimax: :float,
+        ))
+      end
+
+      def trianglemesh(params = {})
+        write Statement.variadic("Shape", "trianglemesh", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          indices: :integer,
+          P: :point3,
+          N: :normal3,
+          S: :vector3,
+          uv: :float,
+          alpha: :float_texture,
+          shadowalpha: :float_texture,
+          st: :float,
+        ))
+      end
+
+      def heightfield(params = {})
+        write Statement.variadic("Shape", "heightfield", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          nu: :integer,
+          nv: :integer,
+          Pz: :float,
+        ))
+      end
+
+      def loopsubdiv(params = {})
+        write Statement.variadic("Shape", "loopsubdiv", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          levels: :integer,
+          indices: :integer,
+          P: :point3,
+        ))
+      end
+
+      def nurbs(params = {})
+        write Statement.variadic("Shape", "nurbs", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          nu: :integer,
+          nv: :integer,
+          uorder: :integer,
+          vorder: :integer,
+          uknots: :float,
+          vknots: :float,
+          u0: :float,
+          v0: :float,
+          u1: :float,
+          v1: :float,
+          P: :point3,
+          Pw: :float,
+        ))
+      end
+
+      def plymesh(params = {})
+        write Statement.variadic("Shape", "plymesh", ParameterList.from(
+          params,
+
+          allow_material_overrides: true,
+          filename: :string,
+          alpha: :float_texture,
+          shadowalpha: :float_texture,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end

data/lib/pbrt/builder/texture.rb

@@ -0,0 +1,167 @@
+module PBRT
+  class Builder
+    class Texture
+      def initialize(builder, name, type)
+        @builder = builder
+        @directive = %(Texture "#{name}" "#{type}")
+      end
+
+      def bilerp(params = {})
+        write Statement.variadic(@directive, "bilerp", ParameterList.from(
+          params,
+
+          mapping: :string,
+          uscale: :float,
+          vscale: :float,
+          udelta: :float,
+          vdelta: :float,
+          v1: :vector3,
+          v2: :vector3,
+          v00: :texture,
+          v01: :texture,
+          v10: :texture,
+          v11: :texture,
+        ))
+      end
+
+      def checkerboard(params = {})
+        write Statement.variadic(@directive, "checkerboard", ParameterList.from(
+          params,
+
+          mapping: :string,
+          uscale: :float,
+          vscale: :float,
+          udelta: :float,
+          vdelta: :float,
+          v1: :vector3,
+          v2: :vector3,
+          dimension: :integer,
+          tex1: :texture,
+          tex2: :texture,
+          aamode: :string,
+        ))
+      end
+
+      def constant(params = {})
+        write Statement.variadic(@directive, "constant", ParameterList.from(
+          params,
+
+          value: :texture,
+          foo: :texture,
+        ))
+      end
+
+      def dots(params = {})
+        write Statement.variadic(@directive, "dots", ParameterList.from(
+          params,
+
+          mapping: :string,
+          uscale: :float,
+          vscale: :float,
+          udelta: :float,
+          vdelta: :float,
+          v1: :vector3,
+          v2: :vector3,
+          inside: :texture,
+          outside: :texture,
+        ))
+      end
+
+      def fbm(params = {})
+        write Statement.variadic(@directive, "fbm", ParameterList.from(
+          params,
+
+          octaves: :integer,
+          roughness: :float,
+        ))
+      end
+
+      def imagemap(params = {})
+        write Statement.variadic(@directive, "imagemap", ParameterList.from(
+          params,
+
+          mapping: :string,
+          uscale: :float,
+          vscale: :float,
+          udelta: :float,
+          vdelta: :float,
+          v1: :vector3,
+          v2: :vector3,
+          filename: :string,
+          wrap: :string,
+          maxanisotropy: :float,
+          trilinear: :bool,
+          scale: :float,
+          gamma: :bool,
+        ))
+      end
+
+      def marble(params = {})
+        write Statement.variadic(@directive, "marble", ParameterList.from(
+          params,
+
+          octaves: :integer,
+          roughness: :float,
+          scale: :float,
+          variation: :float,
+        ))
+      end
+
+      def mix(params = {})
+        write Statement.variadic(@directive, "mix", ParameterList.from(
+          params,
+
+          tex1: :texture,
+          tex2: :texture,
+          amount: :float_texture,
+        ))
+      end
+
+      def scale(params = {})
+        write Statement.variadic(@directive, "scale", ParameterList.from(
+          params,
+
+          tex1: :texture,
+          tex2: :texture,
+        ))
+      end
+
+      def uv(params = {})
+        write Statement.variadic(@directive, "uv", ParameterList.from(
+          params,
+
+          mapping: :string,
+          uscale: :float,
+          vscale: :float,
+          udelta: :float,
+          vdelta: :float,
+          v1: :vector3,
+          v2: :vector3,
+        ))
+      end
+
+      def windy(params = {})
+        write Statement.variadic(@directive, "windy", ParameterList.from(
+          params,
+
+          mapping: :string,
+        ))
+      end
+
+      def wrinkled(params = {})
+        write Statement.variadic(@directive, "wrinkled", ParameterList.from(
+          params,
+
+          octaves: :integer,
+          roughness: :float,
+        ))
+      end
+
+      private
+
+      def write(statement)
+        @builder.write(statement)
+      end
+    end
+  end
+end