finish export embed

Author: ianthehenry

src/cli/helpers.janet

@@ -59,14 +59,23 @@
 (defn- calry [f & args]
   (if f (f ;args)))
 
-(defn render-image [shader-source &named resolution origin orbit zoom t slices
+(defn render-image [shader-source &named
+  dimensions
+  animated?
+  free-camera?
+  resolution
+  origin
+  orbit
+  zoom
+  t
+  slices
   on-render-start
   on-slice-start
   on-slice-end
   on-render-end]
   (default slices [1 1])
   (default zoom 1)
-  (default origin [0 0 0])
+  (default origin (if (= dimensions 2) [0 0] [0 0 0]))
   (default orbit [0 0])
   (default t 0)
   (def frame-buffer (ray/make-fbo resolution :point))
@@ -75,14 +84,18 @@
   (defn set-uniform [name type value]
     (jaylib/set-shader-value shader (jaylib/get-shader-location shader name) value type))
 
-  (set-uniform "free_camera_origin" :vec3 origin)
-  (set-uniform "free_camera_orbit" :vec2 orbit)
-  (set-uniform "free_camera_zoom" :float zoom)
-  (set-uniform "origin_2d" :vec2 [0 0])
-  (set-uniform "camera_type" :int 0)
-  (set-uniform "t" :float t)
+  (when free-camera?
+    (set-uniform "free_camera_zoom" :float zoom)
+    (case dimensions
+      2 (do
+        (set-uniform "free_camera_origin" :vec2 origin))
+      3 (do
+        (set-uniform "free_camera_origin" :vec3 origin)
+        (set-uniform "free_camera_orbit" :vec2 orbit))
+      0 (do)
+      (error "invalid dimension")))
+  (when animated? (set-uniform "t" :float t))
   (set-uniform "viewport" :vec4 [0 0 ;resolution])
-  (set-uniform "crosshairs_3d" :vec4 [0 0 0 0])
 
   (def slice-size (map |(math/floor (/ $0 $1)) resolution slices))
   (def residution (map - resolution (map |(* $0 $1) slice-size slices)))

src/cli/init.janet

@@ -25,11 +25,14 @@
    --slices (optional vec2 [1 1]) "draw the image in multiple passes, e.g. 4x2 = 8 total draw calls"]
   (def source (read-input input))
   (def env (bauble/evaluator/evaluate source))
-  (def [shader-source dimension animated? has-custom-camera?]
-    (bauble/compile-to-glsl default-render-type false env "330"))
+  (def [shader-source dimensions animated? has-custom-camera?]
+    (bauble/compile-to-glsl default-render-type false false env "330"))
   (init-jaylib)
   (defn vec2 [[x y]] (string/format "%dx%d" x y))
   (def image (render-image shader-source
+    :dimensions dimensions
+    :free-camera? (not has-custom-camera?)
+    :animated? animated?
     :resolution resolution
     :orbit [0.125 -0.125]
     :t t
@@ -49,7 +52,7 @@
   (def source (read-input input))
   (def env (bauble/evaluator/evaluate source))
   (def [shader-source dimension animated? has-custom-camera?]
-    (bauble/compile-to-glsl default-render-type false env "330"))
+    (bauble/compile-to-glsl default-render-type false false env "330"))
   (if outfile
     (spit outfile shader-source)
     (print shader-source)))

src/lib/init.janet

@@ -5,10 +5,11 @@
 (import ./completer :export true)
 (import ./environment/uniforms-private)
 
-(defn compile-to-glsl [render-type crosshairs env glsl-version]
+(defn compile-to-glsl [render-type crosshairs dynamic-camera? env glsl-version]
   (renderer/render env glsl-version
     :render-type render-type
-    :crosshairs crosshairs))
+    :crosshairs crosshairs
+    :dynamic-camera? dynamic-camera?))
 
 (defn- type-to-string [type]
   (jlsl/type/match type

src/lib/renderer/init.janet

@@ -14,6 +14,8 @@
   (truthy? (some |(= dynvars/t (jlsl/param/var $))
     (jlsl/function/implicit-params (in program :main)))))
 
+(def @not not)
+
 (use ../environment)
 
 (defn render [env glsl-version &keys options]
@@ -35,7 +37,7 @@
     (assertf (camera? camera) "%q is not a camera")
     camera))
 
-  (assertf (or (nil? subject) (shape? subject)) "%q is not a shape" subject)
+  (assertf (@or (nil? subject) (shape? subject)) "%q is not a shape" subject)
 
   (def dimension (if subject
     (case (shape/type subject)
@@ -44,7 +46,10 @@
       (error "BUG"))
     0))
 
-  (def aa-grid-size (jlsl/coerce-expr (int/u64 (or (get-var stdenv 'aa-grid-size) 1))))
+  (if (@and camera (= dimension 2))
+    (error "custom cameras not supported in 2D yet"))
+
+  (def aa-grid-size (jlsl/coerce-expr (int/u64 (@or (get-var stdenv 'aa-grid-size) 1))))
 
   (jlsl/jlsl/implement :float nearest-distance [] (return ,(@or (@and subject (shape/distance subject)) 0)))
   (def sample
@@ -55,16 +60,18 @@
         (error "BUG"))
       (jlsl/fn :vec4 sample [] (return background-color))))
   (def frag-color (jlsl/variable/new "frag-color" jlsl/type/vec4))
+  (def free-camera? (@or (options :dynamic-camera?) (@not camera)))
   (def program (jlsl/program/new*
     :pragmas ['(precision highp float)]
     :uniforms
       (filter truthy? [
         ;custom-uniforms
-        camera-type
-        free-camera-target
-        free-camera-orbit
-        free-camera-zoom
-        origin-2d
+        (if (options :dynamic-camera?) camera-type)
+        ;(if free-camera?
+          (if (= dimension 2)
+            [free-camera-zoom free-camera-target-2d]
+            [free-camera-zoom free-camera-target-3d free-camera-orbit])
+          [])
         t
         viewport
         (if (in options :crosshairs) crosshairs-3d)])

src/lib/renderer/samplers.janet

@@ -5,13 +5,12 @@
 (use judge)
 
 (jlsl/jlsl/defdyn camera-type :int "")
-(jlsl/jlsl/defdyn free-camera-target :vec3 "")
+(def free-camera-target-3d (jlsl/variable/new "free_camera_target" jlsl/type/vec3))
+(def free-camera-target-2d (jlsl/variable/new "free_camera_target" jlsl/type/vec2))
 (jlsl/jlsl/defdyn free-camera-orbit :vec2 "")
 (jlsl/jlsl/defdyn free-camera-zoom :float "")
 (jlsl/jlsl/defdyn crosshairs-3d :vec4 "")
 
-(jlsl/jlsl/defdyn origin-2d :vec2 "")
-
 # TODO: these should probably be somewhere else
 (def- MAX_STEPS 256:u)
 (def- MINIMUM_HIT_DISTANCE 0.1)
@@ -42,7 +41,7 @@
 (defn make-sample-2d [options nearest-distance <background-color> <default-color> <color-field>]
   (def {:render-type render-type :crosshairs crosshairs} options)
   (jlsl/fn :vec4 sample []
-    (with [Q (frag-coord * ortho-base-zoom-distance * free-camera-zoom + origin-2d)
+    (with [Q (frag-coord * ortho-base-zoom-distance * free-camera-zoom + free-camera-target-2d)
            q Q
            dist (nearest-distance)
            gradient (calculate-gradient (nearest-distance))]
@@ -97,45 +96,58 @@
 
 # TODO: okay, so, theoretically we have nearest-distance in the current environment already
 (defn make-sample-3d [options nearest-distance <camera> <background-color> <default-color> <color-field>]
-  (def {:render-type render-type :crosshairs crosshairs} options)
+  (def {:render-type render-type :crosshairs crosshairs :dynamic-camera? dynamic-camera?} options)
   (def march (make-march nearest-distance))
   (def ortho-distance 1024)
 
   (jlsl/fn :vec4 sample []
     (var ray* (Ray [0 0 0] [0 0 1]))
-    (var ortho-quad [ortho-distance (* frag-coord ortho-base-zoom-distance free-camera-zoom)])
-    (var ortho-scale (* ortho-base-zoom-distance free-camera-zoom))
+    (var ortho-quad [0 0 0])
+    (var ortho-scale 0)
     (var fov 0)
-    (case camera-type
-      0:s ,(if <camera>
-        (jlsl/statement
-          (var camera <camera>)
-          (set ray* (camera/ray camera))
-          ,(if (has-fov? <camera>)
-            (jlsl/statement (set fov camera.fov))
-            (jlsl/statement (set ortho-scale camera.scale)))
-          (break))
+    ,(if dynamic-camera?
+      (jlsl/statement
+        (set ortho-quad [ortho-distance (* frag-coord ortho-base-zoom-distance free-camera-zoom)])
+        (set ortho-scale (* ortho-base-zoom-distance free-camera-zoom))
+        (case camera-type
+          0:s ,(if <camera>
+            (jlsl/statement
+              (var camera <camera>)
+              (set ray* (camera/ray camera))
+              ,(if (has-fov? <camera>)
+                (jlsl/statement (set fov camera.fov))
+                (jlsl/statement (set ortho-scale camera.scale)))
+              (break))
+            (jlsl/statement
+              # just fall through
+              ))
+          1:s (do
+            (var camera-rotation-matrix
+              (* (rotation-y (* tau free-camera-orbit.x))
+                 (rotation-x (* tau free-camera-orbit.y))))
+            (set ray* (Ray
+              (camera-rotation-matrix * [0 0 (base-zoom-distance * free-camera-zoom)] + free-camera-target-3d)
+              (camera-rotation-matrix * (perspective-vector free-camera-fov * [1 1 -1]))))
+            (set fov free-camera-fov)
+            (break))
+          2:s (do # XZ
+            (set ray* (Ray (ortho-quad.yxz + free-camera-target-3d) [0 -1 0]))
+            (break))
+          3:s (do # XY
+            (set ray* (Ray (ortho-quad.yzx + free-camera-target-3d) [0 0 -1]))
+            (break))
+          4:s (do # ZY
+            (set ray* (Ray (ortho-quad.xzy + free-camera-target-3d) [-1 0 0]))
+            (break))))
+      (if <camera>
+        (jlsl/statement (set ray* (camera/ray <camera>)))
         (jlsl/statement
-          # just fall through
-          ))
-      1:s (do
-        (var camera-rotation-matrix
-          (* (rotation-y (* tau free-camera-orbit.x))
-             (rotation-x (* tau free-camera-orbit.y))))
-        (set ray* (Ray
-          (camera-rotation-matrix * [0 0 (base-zoom-distance * free-camera-zoom)] + free-camera-target)
-          (camera-rotation-matrix * (perspective-vector free-camera-fov * [1 1 -1]))))
-        (set fov free-camera-fov)
-        (break))
-      2:s (do # XZ
-        (set ray* (Ray (ortho-quad.yxz + free-camera-target) [0 -1 0]))
-        (break))
-      3:s (do # XY
-        (set ray* (Ray (ortho-quad.yzx + free-camera-target) [0 0 -1]))
-        (break))
-      4:s (do # ZY
-        (set ray* (Ray (ortho-quad.xzy + free-camera-target) [-1 0 0]))
-        (break)))
+          (var camera-rotation-matrix
+            (* (rotation-y (* tau free-camera-orbit.x))
+               (rotation-x (* tau free-camera-orbit.y))))
+          (set ray* (Ray
+            (camera-rotation-matrix * [0 0 (base-zoom-distance * free-camera-zoom)] + free-camera-target-3d)
+            (camera-rotation-matrix * (perspective-vector free-camera-fov * [1 1 -1])))))))
 
     (var steps 0:u)
 

studio/bauble.tsx

@@ -122,7 +122,7 @@ const ExportEmbedDialog = (props: {
 
   const regenOutput = async () => {
     const script = props.getScript();
-    const request = {tag: 'compile', script, renderType: RenderType.Normal, crosshairs: false};
+    const request = {tag: 'compile', script, renderType: RenderType.Normal, crosshairs: false, dynamicCamera: false};
     // TODO: do something with result.outputs?
     const result: any = await props.wasmBox.send(request);
     if (result.isError) {
@@ -133,7 +133,7 @@ const ExportEmbedDialog = (props: {
         options.dimensions = result.dimension;
       }
       if (result.isAnimated) {
-        options.animate = true;
+        options.animation = true;
       }
       if (!result.hasCustomCamera) {
         options.freeCamera = true;
@@ -472,7 +472,7 @@ const Bauble = (props: BaubleProps) => {
     return {width: dpr * size.width, height: dpr * size.height};
   });
   const renderType = Signal.create(RenderType.Normal);
-  const dimension = Signal.create(0);
+  const dimensions = Signal.create(0);
   const prefersFreeCamera = Signal.create(false);
   const quadView = Signal.create(false);
   const quadSplitPoint = Signal.create(vec2.fromValues(0.5, 0.5));
@@ -524,7 +524,7 @@ const Bauble = (props: BaubleProps) => {
   const recompile = (script: string, renderType: RenderType) => {
     compileQueue.schedule(async () => {
       Signal.set(evaluationState, EvaluationState.Unknown);
-      const request = {tag: 'compile', script, renderType, crosshairs: true};
+      const request = {tag: 'compile', script, renderType, crosshairs: true, dynamicCamera: true};
       const result: any = await wasmBox.send(request);
 
       if (result.isError) {
@@ -534,7 +534,7 @@ const Bauble = (props: BaubleProps) => {
         try {
           //console.log(result.shaderSource);
           const shaderRecompilationTimeMs = await renderer.recompileShader(result.shaderSource) as number | undefined;
-          Signal.set(dimension, result.dimension);
+          Signal.set(dimensions, result.dimensions);
           Signal.set(isAnimated, result.isAnimated);
           Signal.set(hasCustomCamera, result.hasCustomCamera);
           Signal.set(evaluationState, EvaluationState.Success);
@@ -592,6 +592,7 @@ const Bauble = (props: BaubleProps) => {
       return Signal.get(quadView) ? focusVec_ : null;
     });
     renderer = new AsyncRenderer(renderBox, canvas, {
+      dimensions: Signal.getter(dimensions),
       time: Signal.getter(timer.t),
       isVisible: Signal.getter(isVisible),
       rotation: Signal.getter(rotation),
@@ -668,7 +669,7 @@ const Bauble = (props: BaubleProps) => {
   };
 
   const getMainViewInteraction = () => {
-    if (Signal.get(dimension) === 2) {
+    if (Signal.get(dimensions) === 2) {
       return Interaction.Pan2D;
     }
     if (usingFreeCamera()) {