Kinda working

shaders/ray_marching.wgsl

@@ -1,14 +1,20 @@
+struct FractalParameters
+{
+    translation: vec3<f32>,
+    rotation: vec3<f32>,
+    scale: f32,
+    iterations: u32
+}
+
 struct RayMarchingPushConstants
 {
     inverse_proj: mat4x4<f32>,
     view_matrix: mat4x4<f32>,
     camera_pos: vec3<f32>,
-
-    scale: f32,
-    translation: vec3<f32>,
-    rotation: vec3<f32>,
+    fractal_parameters: FractalParameters
 }
 
+
 var<push_constant> constants: RayMarchingPushConstants; 
 
 struct Vertex
@@ -92,31 +98,39 @@ fn sdf(pos: vec3<f32>) -> f32
     var x = pos;
     var t = 1.;
 
-    for(var i = 0u; i < 3; i++)
+    for(var i = 0u; i < constants.fractal_parameters.iterations; i++)
     {
-        x *= 1.5;
-        t *= 1.5;
+        x *= constants.fractal_parameters.scale;
+        t *= constants.fractal_parameters.scale;
         x = abs(x);
-        x += vec3<f32>(0.01, 0.02, 0.08);
+        x += constants.fractal_parameters.translation;
         x *= rot();
     }
 
-    return sdf_box(x, vec3<f32>(1.)) / t;
+    return sdf_octahedron(x, 1.) / t;
 }
 
 fn rot() -> mat3x3<f32>
 {
-    let rx = 0.6;
-    let ry = 8.1;
+    let rx = constants.fractal_parameters.rotation.x;
+    let ry = constants.fractal_parameters.rotation.y;
+    let rz = constants.fractal_parameters.rotation.z;
     return mat3x3<f32>(
         cos(rx), sin(rx), 0.,
         -sin(rx), cos(rx), 0.,
         0., 0., 1.
-    )*
+    )
+    *
+    mat3x3<f32>(
+         cos(ry), 0., sin(ry),
+        0., 1., 0.,
+         -sin(ry), 0., cos(ry)
+    )
+*
     mat3x3<f32>(
         1., 0., 0.,
-        0., cos(ry), sin(ry),
-        0, -sin(ry), cos(ry)
+        0., cos(rz), sin(rz),
+        0, -sin(rz), cos(rz)
     );
 
 }
@@ -127,9 +141,15 @@ fn sdf_box(pos: vec3<f32>, b: vec3<f32>) -> f32
     return length(max(q, vec3<f32>(0.))) + min(max(q.x, max(q.y, q.z)), 0.);
 }
 
+fn sdf_octahedron(pos: vec3<f32>, s: f32) -> f32
+{
+    let p = abs(pos);
+    return (p.x + p.y + p.z - s) *0.57735;
+}
+
 fn sdf_gradient(p: vec3<f32>) -> vec3<f32>
 {
-    let eps = 0.000001;
+    let eps = 0.0001;
     let h = vec2<f32>(eps, 0);
 
     return normalize(