Change priority of internal logging from kInfo to kTrace. Make julia the default shader for shadertui.

Author: austinvhuang

examples/shadertui/shader.wgsl

@@ -2,60 +2,39 @@
 @group(0) @binding(1) var<uniform> params: Params;
 
 struct Params {
-    time: f32,
-    screenwidth: u32,
-    screenheight: u32,
+  time: f32,
+  screenwidth: u32,
+  screenheight: u32,
 };
 
-struct Particle {
-    position: vec2<f32>,
-    velocity: vec2<f32>,
-    life: f32,
-}
-
-const NUM_PARTICLES: u32 = 1000u;
-const PARTICLE_LIFE: f32 = 9.0;
-const EMISSION_RATE: f32 = 300.0;
+const MAX_ITERATIONS: u32 = 100;
 
-fn rand(n: f32) -> f32 {
-    return fract(sin(n) * 43758.5453123);
-}
-
-fn initialize_particle(id: f32, time: f32) -> Particle {
-    let random1 = rand(id * 0.01 + time * 0.1);
-    let random2 = rand(id * 0.02 + time * 0.1);
-    let angle = random1 * 2.0 * 3.14159;
-    let speed = 0.05 + random2 * 0.05;
-    
-    return Particle(
-        vec2<f32>(0.5, 0.5),
-        vec2<f32>(cos(angle) * speed, sin(angle) * speed),
-        PARTICLE_LIFE
-    );
+fn complex_mul(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
+    return vec2<f32>(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
 }
 
 @compute @workgroup_size(16, 16, 1)
 fn main(@builtin(global_invocation_id) globalID : vec3<u32>) {
     let resolution = vec2<f32>(f32(params.screenwidth), f32(params.screenheight));
-    let uv = vec2<f32>(f32(globalID.x) / resolution.x, f32(globalID.y) / resolution.y);
-    let idx = globalID.y * params.screenwidth + globalID.x;
+    let uv = (vec2<f32>(globalID.xy) - 0.5 * resolution) / min(resolution.x, resolution.y);
+    
+    // Animate the Julia set parameters
+    let t = params.time * 0.3;
+    let c = 0.7885 * vec2<f32>(cos(t), sin(t));
 
-    var color: f32 = 0.0;
+    var z = uv * 3.0;
+    var i: u32 = 0u;
 
-    for (var i: f32 = 0.0; i < f32(NUM_PARTICLES); i += 1.0) {
-        let spawn_time = i / EMISSION_RATE;
-        let particle_age = fract((params.time - spawn_time) / PARTICLE_LIFE) * PARTICLE_LIFE;
-        
-        if (particle_age < PARTICLE_LIFE) {
-            var particle = initialize_particle(i, spawn_time);
-            particle.position += particle.velocity * particle_age;
-            
-            let distance = length(uv - particle.position);
-            if (distance < 0.005) {
-                color += 0.5 * (1.0 - particle_age / PARTICLE_LIFE);
-            }
+    for (; i < MAX_ITERATIONS; i = i + 1u) {
+        z = complex_mul(z, z) + c;
+        if (dot(z, z) > 4.0) {
+            break;
         }
     }
 
-    out[idx] = min(color, 1.0);
+    let smooth_i = f32(i) + 1.0 - log2(log2(dot(z, z)));
+    let color = 0.5 + 0.5 * cos(3.0 + smooth_i * 0.15 + vec3<f32>(0.0, 0.6, 1.0));
+    
+    let idx = globalID.y * params.screenwidth + globalID.x;
+    out[idx] = (color.r + color.g + color.b) / 3.0;
 }

gpu.hpp

@@ -530,7 +530,6 @@ struct Context {
   // Default constructor
   Context() = default;
 
-  // Move constructor: steals GPU handles so the source destructor won't free them.
   Context(Context&& other) noexcept
       : instance(other.instance),
         adapter(other.adapter),
@@ -542,6 +541,7 @@ struct Context {
         adapterStatus(other.adapterStatus),
         deviceStatus(other.deviceStatus)
   {
+    LOG(kDefLog, kTrace, "Moving Context ownership");
     // Move over the resources in the pools:
     pool.data       = std::move(other.pool.data);
     kernelPool.data = std::move(other.kernelPool.data);
@@ -555,7 +555,6 @@ struct Context {
     // other.deviceStatus = 0;
   }
 
-  // Optional move‐assignment operator, similarly stealing resources:
   Context& operator=(Context&& other) noexcept {
     if (this != &other) {
       // Free any existing resources. In most cases, this should be a no-op
@@ -573,26 +572,26 @@ struct Context {
     if (queue) {
       wgpuQueueRelease(queue);
     } else {
-      LOG(kDefLog, kWarn, "Queue is null");
+      LOG(kDefLog, kTrace, "Queue is null");
     }
     if (device) {
       wgpuDeviceRelease(device);
       processEvents(instance);
     } else {
-      LOG(kDefLog, kWarn, "Device is null");
+      LOG(kDefLog, kTrace, "Device is null");
     }
     if (adapter) {
       wgpuAdapterRelease(adapter);
       processEvents(instance);
     } else {
-      LOG(kDefLog, kWarn, "Adapter is null");
+      LOG(kDefLog, kTrace, "Adapter is null");
     }
     if (instance) {
       wgpuInstanceRelease(instance);
     } else {
-      LOG(kDefLog, kWarn, "Instance is null");
+      LOG(kDefLog, kTrace, "Instance is null");
     }
-    LOG(kDefLog, kInfo, "Context destroyed");
+    LOG(kDefLog, kTrace, "Context destroyed");
   }
 };
 
@@ -827,7 +826,7 @@ inline Context createContext(
 #endif
   check(ctx.instance, "Initialize WebGPU", __FILE__, __LINE__);
 
-  LOG(kDefLog, kInfo, "Requesting adapter");
+  LOG(kDefLog, kTrace, "Requesting adapter");
   {
     struct AdapterData {
       WGPUAdapter adapter = nullptr;
@@ -869,7 +868,7 @@ inline Context createContext(
     ctx.adapterStatus = adapterData.status;
   }
 
-  LOG(kDefLog, kInfo, "Requesting device");
+  LOG(kDefLog, kTrace, "Requesting device");
   {
     struct DeviceData {
       WGPUDevice device = nullptr;
@@ -900,11 +899,11 @@ inline Context createContext(
     };
     wgpuAdapterRequestDevice(ctx.adapter, &devDescriptor, deviceCallbackInfo);
 
-    LOG(kDefLog, kInfo, "Waiting for device request to end");
+    LOG(kDefLog, kTrace, "Waiting for device request to end");
     while (!devData.requestEnded) {
       processEvents(ctx.instance);
     }
-    LOG(kDefLog, kInfo, "Device request ended");
+    LOG(kDefLog, kTrace, "Device request ended");
 
     ctx.device = devData.device;
     ctx.deviceStatus = devData.status;