fix up sdf example - scaling index bug resolved

Author: austinvhuang

examples/raymarch/run.cpp

@@ -24,8 +24,7 @@ struct Params {
 };
 
 fn sdf(p: vec3<f32>, c: vec3<f32>, r: f32) -> f32 {
-  let l: vec3<f32> = p - c;
-  return sqrt(l.x * l.x + l.y * l.y + l.z * l.z) - r;
+  return length(p - c) - r;
 }
 
 @compute @workgroup_size(16, 16)
@@ -34,44 +33,40 @@ fn main(@builtin(global_invocation_id) GlobalInvocationID: vec3<u32>) {
         || GlobalInvocationID.y >= params.screenHeight) {
       return;
     }
+    let id: u32 = GlobalInvocationID.y * params.screenWidth + GlobalInvocationID.x;
 
     let x: f32 = f32(GlobalInvocationID.x);
     let y: f32 = f32(GlobalInvocationID.y);
 
     // ray position, starting at the camera
-    var p: vec3<f32> = vec3<f32>((x / f32(params.screenWidth)) * 2.0 - 1.0,
+    var p: vec3<f32> = vec3<f32>((x / f32(params.screenWidth)) * 4.0 - 2.0,
                                  (y / f32(params.screenHeight)) * 2.0 - 1.0,
                                  params.focalLength);
 
-    let len: f32 = length(p);
-    let dir: vec3<f32> = vec3<f32>(p.x / len, p.y / len, p.z / len);
+    let dir: vec3<f32> = p / length(p); // direction from focal point to pixel
 
     // object dynamics
-    // let offsetX: f32 = sin(f32(params.time) / 200) * 6.0;
-    // let offsetY: f32 = cos(f32(params.time) / 200) * 6.0;
-    let offsetX: f32 = 0.0;
-    let offsetY: f32 = 0.0;
-    let offsetZ: f32 = sin(f32(params.time) / 400) * 2.0;
-    // let offsetZ: f32 = 0.0;
+    var offsetX: f32 = sin(f32(params.time) / 750) * 0.5;
+    var offsetY: f32 = cos(f32(params.time) / 750) * 0.5;
+    var offsetZ: f32 = sin(f32(params.time) / 1000) * 1.0;
     let c: vec3<f32> = vec3<f32>(params.sphereCenterX + offsetX,
                                  params.sphereCenterY + offsetY,
                                  params.sphereCenterZ + offsetZ);
 
     let dist: f32 = 0.0;
-    out[GlobalInvocationID.y * params.screenWidth + GlobalInvocationID.x] = 0.0;
-
-    let maxIter: u32 = 10;
+    out[id] = 0.0;
 
+    let maxIter: u32 = 30;
     // march the ray in the direction of dir by length derived by the SDF
     for (var i: u32 = 0; i < maxIter; i++) {
       // largest step we can take w/o intersection is = SDF value at point
       let step : f32 = sdf(p, c, params.sphereRadius);
       if (abs(step) < .001) {
         return;
       }
-      out[GlobalInvocationID.y * params.screenWidth + GlobalInvocationID.x] =
-        max(0, min(10.0, out[GlobalInvocationID.y * params.screenWidth + GlobalInvocationID.x] + step));
-      if (out[GlobalInvocationID.y * params.screenWidth + GlobalInvocationID.x] == 10.0) {
+      out[id] = 
+        max(0, min(5.0, out[id] + step));
+      if (out[id] == 10.0) {
         return;
       }
       p = p + dir * step;
@@ -103,13 +98,13 @@ int main(int argc, char **argv) {
     float sphereCenterY;
     float sphereCenterZ;
     uint32_t time;
-  } params = {/* focal length */ 0.2,
+  } params = {/* focal length */ 1.0,
               NCOLS,
               NROWS,
-              /* radius */ 2.0,
+              /* radius */ 1.0,
               /* x */ 0.0,
               /* y */ 0.0,
-              /* z */ 5.0,
+              /* z */ 2.5,
               0};
 
   std::fill(begin(screen), end(screen), 0.0f);
@@ -122,36 +117,36 @@ int main(int argc, char **argv) {
     params.time = getCurrentTimeInMilliseconds() - zeroTime;
     Kernel render =
         CreateKernel(ctx, CreateShader(kSDF), {}, 0, devScreen, params);
-    // ToGPU(ctx, &params, render.buffers[render.numBuffers - 1],
-    // sizeof(params));
     DispatchKernel(ctx, render);
     Wait(ctx, render.future);
     ToCPU(ctx, devScreen, screen.data(), sizeof(screen));
 
-    static const char intensity[] = "@%#*+=-:. ";
+    static const char intensity[] = "@%#8X7x*+=-:^~'.` ";
+
     // clear the screen, move cursor to the top
     printf("\033[2J\033[H");
 
     fprintf(stdout, "%s",
             show<float, NROWS, NCOLS>(screen, "Raw values").c_str());
 
     // normalize values
-    // float min = *std::min_element(screen.begin(), screen.end());
-    // float max = *std::max_element(screen.begin(), screen.end());
-    float min = 0.0;
-    float max = 10.0;
+    float min = *std::min_element(screen.begin(), screen.end());
+    float max = min + params.sphereRadius; // maximize dynamic range
 
     for (size_t i = 0; i < screen.size(); ++i) {
       screen[i] = (screen[i] - min) / (max - min);
     }
     fprintf(stdout, "%s",
-            show<float, NROWS, NCOLS>(screen, "Normalized").c_str());
+            show<float, NROWS, NCOLS>(screen, "Scaled").c_str());
 
     // index into intensity array
-    std::array<char, NROWS *(NCOLS + 1)> raster;
+    std::array<char, screen.size()> raster;
     for (size_t i = 0; i < screen.size(); ++i) {
-      raster[i] =
-          intensity[static_cast<size_t>(screen[i] * (sizeof(intensity) - 1))];
+      size_t index =
+          std::min(sizeof(intensity) - 2,
+                   std::max(0ul, static_cast<size_t>(screen[i] *
+                                                     (sizeof(intensity) - 2))));
+      raster[i] = intensity[index];
     }
 
     for (size_t row = 0; row < NROWS; ++row) {