ngsolve-webgpu 0.0.1__py3-none-any.whl

ngsolve_webgpu/shaders/clipping/render.wgsl

@@ -0,0 +1,37 @@
+
+@group(0) @binding(24) var<storage> subtrigs: array<SubTrig>;
+
+struct VertexOutputClip {
+  @builtin(position) fragPosition: vec4<f32>,
+  @location(0) p: vec3<f32>,
+  @location(1) n: vec3<f32>,
+  @location(2) lam: vec3<f32>,
+  @location(3) @interpolate(flat) elnr: u32
+};
+
+@vertex
+fn vertex_main(@builtin(vertex_index) vertId: u32,
+               @builtin(instance_index) trigId: u32)
+  -> VertexOutputClip
+{
+  let trig = subtrigs[trigId];
+  let points = get_tet_points(trig.id);
+  var lam = vec4<f32>(trig.lam[vertId], 1.);
+  lam[3] = 1.0 - lam[0] - lam[1] - lam[2];
+  var p = vec3<f32>(0.0, 0.0, 0.0);
+  for(var i = 0u; i < 4u; i = i + 1u) {
+    p = p + lam[i] * points[i];
+  }
+  
+  return VertexOutputClip(cameraMapPoint(p), p, -u_clipping.plane.xyz, lam.xyz,
+                      trig.id);
+}
+
+@fragment
+fn fragment_main(input: VertexOutputClip) -> @location(0) vec4<f32>
+{
+  let value = evalTet(&function_values_3d, input.elnr, 0, input.lam);
+  return lightCalcColor(input.n, getColor(value));
+}
+
+

ngsolve_webgpu/shaders/compute.wgsl

@@ -0,0 +1,59 @@
+@compute  @workgroup_size(16, 16, 1)
+fn create_mesh(@builtin(num_workgroups) n_groups: vec3<u32>, @builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let n: u32 = n_groups.x * 16;
+    let h: f32 = 1.0 / (f32(n) + 1.);
+
+    if lid.x == 0 && lid.y == 0 && wid.x == 0 {
+        create_mesh_trig_function_values[0] = 1.0;
+        create_mesh_trig_function_values[1] = 1.0;
+    }
+
+    let ix: u32 = wid.x * 16u + lid.x;
+    let x: f32 = h * f32(ix);
+    for (var iy: u32 = wid.y * 16u + lid.y; iy < n + 1; iy += 16u) {
+        let y: f32 = h * f32(iy);
+        for (var k: u32 = 0u; k < 2u; k++) {
+            if iy < n {
+                let i = 2 * (ix + iy * n) + k;
+                let i1 = ix + iy * (n + 1);
+                var px: array<f32, 3>;
+                var py: array<f32, 3>;
+                if k == 0 {
+                    px = array<f32, 3>(x, x + h, x);
+                    py = array<f32, 3>(y, y, y + h);
+                } else {
+                    px = array<f32, 3>(x + h, x + h, x);
+                    py = array<f32, 3>(y, y + h, y + h);
+                }
+                create_mesh_trigs_p1[i].index = 1;
+                for (var pi: u32 = 0u; pi < 3u; pi++) {
+                    create_mesh_trigs_p1[i].p[3 * pi + 0] = px[pi];
+                    create_mesh_trigs_p1[i].p[3 * pi + 1] = py[pi];
+                    create_mesh_trigs_p1[i].p[3 * pi + 2] = 0.0;
+                    create_mesh_trig_function_values[2 + 3 * i + pi] = px[pi];
+                }
+
+                if k == 0 {
+                    create_mesh_index_buffer[3 * i] = i1;
+                    create_mesh_index_buffer[3 * i + 1] = i1 + 1;
+                    create_mesh_index_buffer[3 * i + 2] = i1 + n + 1;
+                } else {
+                    create_mesh_index_buffer[3 * i] = i1 + 1;
+                    create_mesh_index_buffer[3 * i + 1] = i1 + n + 1 + 1;
+                    create_mesh_index_buffer[3 * i + 2] = i1 + n + 1;
+                }
+            }
+        }
+
+        let iv = 3 * (ix + iy * (n + 1));
+        create_mesh_vertex_buffer[iv] = x;
+        create_mesh_vertex_buffer[iv + 1] = y;
+        create_mesh_vertex_buffer[iv + 2] = 0.0;
+
+        if ix + 1 == n {
+            create_mesh_vertex_buffer[iv + 3] = x + h;
+            create_mesh_vertex_buffer[iv + 4] = y;
+            create_mesh_vertex_buffer[iv + 5] = 0.;
+        }
+    }
+}

ngsolve_webgpu/shaders/elements3d.wgsl

@@ -0,0 +1,83 @@
+
+@group(0) @binding(12) var<storage> vertices : array<f32>;
+@group(0) @binding(20) var<uniform> u_mesh : MeshUniforms;
+@group(0) @binding(25) var<storage> u_tets : array<Tet>;
+                        
+const TET_FACES = array(
+    vec3u(0u, 2u, 1u),
+    vec3u(0u, 1u, 3u),
+    vec3u(1u, 2u, 3u),
+    vec3u(2u, 0u, 3u)
+);
+
+struct MeshUniforms {
+  subdivision: u32,
+  shrink: f32,
+
+  padding0: f32,
+  padding1: f32,
+};
+
+struct Tet { p: array<u32, 4>, index: u32, padding: u32};
+
+struct MeshFragmentInput {
+  @builtin(position) fragPosition: vec4<f32>,
+  @location(0) p: vec3<f32>,
+  @location(1) n: vec3<f32>,
+  @location(2) @interpolate(flat) id: u32,
+  @location(3) @interpolate(flat) index: u32,
+};
+
+fn calcMeshFace(p: array<vec3<f32>, 3>,
+                vertId: u32, nr: u32, index: u32,
+                lams: array<vec3<f32>,3>) -> MeshFragmentInput
+{
+    let n = cross(p[1] - p[0], p[2] - p[0]);
+    let point = p[vertId % 3];
+    let position = cameraMapPoint(point);
+    return MeshFragmentInput(position, point, n, nr, index);
+}
+
+
+@vertex
+fn vertex_main(@builtin(vertex_index) vertId: u32,
+               @builtin(instance_index) elId: u32)
+  -> MeshFragmentInput
+{
+    const N: u32 = 4u;
+    let faceId: u32 = vertId / 3u;
+    let el = u_tets[elId];
+    var p: array<vec3<f32>, 4>;
+
+    var lam = vec4<f32>(0.0, 0.0, 0.0, 0.0);
+    var center = vec3<f32>(0.0, 0.0, 0.0);
+    for (var i = 0u; i < N; i++) {
+        let n = 3u * el.p[i];
+        p[i] = vec3<f32>(vertices[n], vertices[n + 1u], vertices[n + 2u]);
+        center += p[i] / f32(N);
+    }
+
+
+    for (var i = 0u; i < 4u; i++) {
+        p[i] = mix(center, p[i], u_mesh.shrink);
+    }
+    var lams = array<vec3<f32>, 4>(
+        vec3<f32>(1.0, 0.0, 0.0),
+        vec3<f32>(0.0, 1.0, 0.0),
+        vec3<f32>(0.0, 0.0, 1.0),
+        vec3<f32>(0.0, 0.0, 0.0),
+    );
+    let pi = TET_FACES[faceId];
+    let points = array<vec3<f32>, 3>(p[pi[0]], p[pi[1]], p[pi[2]]);
+
+    return calcMeshFace(points, vertId, elId, el.index,
+                        array<vec3<f32>, 3> (lams[pi[0]], lams[pi[1]], lams[pi[2]]));
+}
+
+@fragment
+fn fragment_main(input: MeshFragmentInput) -> @location(0) vec4<f32>
+{
+  checkClipping(input.p);
+  let color = vec4<f32>(1., 0., 0., 1.);
+  return lightCalcColor(input.n, color);
+}

ngsolve_webgpu/shaders/eval/common.wgsl

@@ -0,0 +1,14 @@
+
+@group(0) @binding(13) var<storage> u_function_values_3d : array<f32>;
+@group(0) @binding(10) var<storage> u_function_values_2d : array<f32>;
+@group(0) @binding(14) var<storage> u_curvature_values_2d : array<f32>;
+@group(0) @binding(15) var<uniform> u_curvature_subdivision : u32;
+@group(0) @binding(16) var<storage> u_deformation_values_2d : array<f32>;
+@group(0) @binding(17) var<uniform> u_deformation_scale : f32;
+@group(0) @binding(55) var<storage> u_function_component: i32;
+
+
+
+// storing number of components and order of basis functions in first two entries
+const VALUES_OFFSET: u32 = 2; 
+

ngsolve_webgpu/shaders/eval/seg.wgsl

@@ -0,0 +1,30 @@
+#import eval/common
+
+fn evalSeg(data: ptr<storage, array<f32>, read>, id: u32, icomp: u32, lam: f32) -> f32 {
+    let order: u32 = u32((*data)[1]);
+    let ncomp: u32 = u32((*data)[0]);
+    let ndof: u32 = order + 1;
+
+    let offset: u32 = ndof * id + VALUES_OFFSET;
+    let stride: u32 = ncomp;
+
+    var v: array<f32, 7>;
+    for (var i: u32 = 0u; i < ndof; i++) {
+        v[i] = (*data)[offset + i * stride];
+    }
+
+    for (var i: u32 = 0u; i < ndof; i++) {
+        v[i] = (*data)[offset + i * stride];
+    }
+
+    let b = vec2f(lam, 1.0 - lam);
+
+    for (var n = order; n > 0; n--) {
+        for (var i = 0u; i < n; i++) {
+            v[i] = dot(b, vec2f(v[i], v[i + 1]));
+        }
+    }
+
+    return v[0];
+}
+

ngsolve_webgpu/shaders/eval/tet.wgsl

@@ -0,0 +1,61 @@
+
+fn factorial(n: u32) -> u32 {
+    var result: u32 = 1u;
+    var i: u32 = 2u;
+    while (i <= n) {
+        result = result * i;
+        i = i + 1u;
+    }
+    return result;
+}
+
+fn mypow(val: f32, exp: u32) -> f32 {
+    var result: f32 = 1.0;
+    for (var i: u32 = 0u; i < exp; i = i + 1u) {
+        result = result * val;
+    }
+    return result;
+}
+
+fn evalTet(data: ptr<storage, array<f32>, read>,
+           id: u32, icomp: u32, lam: vec3<f32>) -> f32 {
+  let ncomp: u32 = u32((*data)[0]);
+  let order: u32 = u32((*data)[1]);
+  var ndof: u32 = ((order + 1u) * (order + 2u) * (order + 3u)) / 6u;
+
+  let offset: u32 = ndof * id + VALUES_OFFSET;
+  let stride: u32 = ncomp;
+
+  var value: f32 = 0.0;
+  var i = 0u;
+  for(var d: u32 = 0u; d < order+1u; d++) {
+    for(var c: u32 = 0u; c < order+1u-d; c++) {
+      for(var b: u32 = 0u; b < order+1u-c-d;b++) {
+        let a = order - b - c - d;
+        let fac = f32(factorial(order))/f32((factorial(a) * factorial(b) * factorial(c) * factorial(d)));
+        value = value + fac * (*data)[offset + i * stride] * mypow(lam.x, a) * mypow(lam.y, b) * mypow(lam.z, c) * mypow(1.0 - lam.x - lam.y - lam.z, d);
+        i++;
+      }
+    }
+  }
+  return value;
+    // let dy = order + 1u;
+    // let dz = (order + 1u) * (order + 2u) / 2u;
+    // let b = vec4f(lam.x, lam.y, lam.z, 1.0 - lam.x - lam.y - lam.z);
+
+    // for (var n = order; n > 0u; n--) {
+    //     var iz0 = 0u;
+    //     for (var iz = 0u; iz < n; iz++) {
+    //         var iy0 = iz0;
+    //         for (var iy = 0u; iy < n - iz; iy++) {
+    //             for (var ix = 0u; ix < n - iz - iy; ix++) {
+    //                 v[iy0 + ix] = dot(b, vec4f(v[iy0 + ix], v[iy0 + ix + 1u], v[iy0 + ix + dy - iy], v[iy0 + ix + dz - iz]));
+    //             }
+    //             iy0 += dy - iy - iz;
+    //         }
+    //         iz0 += dz - (n - 1u - iz);
+    //     }
+    // }
+
+    // return v[0];
+}

ngsolve_webgpu/shaders/eval/trig.wgsl

@@ -0,0 +1,121 @@
+#import eval/common
+
+fn evalTrig(data: ptr<storage, array<f32>, read>, id: u32, icomp: i32, lam: vec2<f32>) -> f32 {
+    var order: i32 = i32((*data)[1]);
+    let ncomp: u32 = u32((*data)[0]);
+    var ndof: u32 = u32((order + 1) * (order + 2) / 2);
+
+    var v: array<f32, 28>;
+    let offset: u32 = ndof * id * ncomp + VALUES_OFFSET;
+    let stride: u32 = ncomp;
+
+    if icomp == -1 {
+        // norm of vector
+        for (var i: u32 = 0u; i < ndof; i++) {
+            v[i] = 0.0;
+            for (var j: u32 = 0u; j < ncomp; j++) {
+                v[i] += (*data)[offset + i * stride + j] * (*data)[offset + i * stride + j];
+            }
+            v[i] = sqrt(v[i]);
+        }
+    } else {
+        for (var i: u32 = 0u; i < ndof; i++) {
+            v[i] = (*data)[offset + u32(icomp) + i * stride];
+        }
+    }
+
+    let dy = order + 1;
+    let b = vec3f(lam.x, lam.y, 1.0 - lam.x - lam.y);
+
+    for (var n = order; n > 0; n--) {
+        var i0 = 0;
+        for (var iy = 0; iy < n; iy++) {
+            for (var ix = 0; ix < n - iy; ix++) {
+                v[i0 + ix] = dot(b, vec3f(v[i0 + ix], v[i0 + ix + 1], v[i0 + ix + dy - iy]));
+            }
+            i0 += dy - iy;
+        }
+    }
+
+    return v[0];
+}
+
+fn _evalTrigVec3Data(order: i32, data: array<vec3f, 28>, lam: vec2f, dy: i32) -> vec3f {
+    let b = vec3f(lam.x, lam.y, 1.0 - lam.x - lam.y);
+    var v: array<vec3f, 28> = data;
+
+    for (var n = order; n > 0; n--) {
+        var i0 = 0;
+        for (var iy = 0; iy < n; iy++) {
+            for (var ix = 0; ix < n - iy; ix++) {
+                v[i0 + ix] = mat3x3<f32>(v[i0 + ix], v[i0 + ix + 1], v[i0 + ix + dy - iy]) * b;
+            }
+            i0 += dy - iy;
+        }
+    }
+
+    return v[0];
+}
+
+fn evalTrigVec3(data: ptr<storage, array<f32>, read>, id: u32, icomp: i32, lam: vec2<f32>) -> vec3f {
+    var order: i32 = i32((*data)[1]);
+    let ncomp: u32 = u32((*data)[0]);
+    var ndof: u32 = u32((order + 1) * (order + 2) / 2);
+
+    var v: array<vec3f, 28>;
+    let offset: u32 = ndof * id * ncomp + VALUES_OFFSET;
+    let stride: u32 = ncomp;
+
+    for (var i: u32 = 0u; i < ndof; i++) {
+        v[i].x = (*data)[offset + u32(icomp) + i * stride + 0];
+        v[i].y = (*data)[offset + u32(icomp) + i * stride + 1];
+        v[i].z = (*data)[offset + u32(icomp) + i * stride + 2];
+    }
+
+    return _evalTrigVec3Data(order, v, lam, order+1);
+}
+
+fn evalTrigVec3Grad(data: ptr<storage, array<f32>, read>, id: u32, lam: vec2<f32>) -> mat3x3<f32> {
+    var order: i32 = i32((*data)[1]);
+    let ncomp: u32 = u32((*data)[0]);
+    var ndof: u32 = u32((order + 1) * (order + 2) / 2);
+    let dy = order + 1;
+
+    var v: array<vec3f, 28>;
+    let offset: u32 = ndof * id * ncomp + VALUES_OFFSET;
+    let stride: u32 = ncomp;
+
+    for (var i: u32 = 0u; i < ndof; i++) {
+        v[i].x = (*data)[offset + i * stride + 0];
+        v[i].y = (*data)[offset + i * stride + 1];
+        v[i].z = (*data)[offset + i * stride + 2];
+    }
+
+    var result: mat3x3<f32>;
+
+    result[0] = _evalTrigVec3Data(order, v, lam, dy);
+    var vd: array<vec3f, 28>;
+
+    var i0 = 0;
+    for (var iy = 0; iy < order; iy++) {
+        for (var ix = 0; ix < order - iy; ix++) {
+            vd[i0 + ix] = v[i0 + ix + 1] - v[i0 + ix];
+        }
+        i0 += dy - iy;
+    }
+
+    result[1] = _evalTrigVec3Data(order-1, vd, lam, dy);
+
+    i0 = 0;
+    for (var iy = 0; iy < order; iy++) {
+        for (var ix = 0; ix < order - iy; ix++) {
+            vd[i0 + ix] = v[i0 + ix + dy - iy] - v[i0 + ix + 1];
+        }
+        i0 += dy - iy;
+    }
+
+    result[2] = _evalTrigVec3Data(order-1, vd, lam, dy);
+
+    return result;
+}
+

ngsolve_webgpu/shaders/geo_edge.wgsl

@@ -0,0 +1,55 @@
+
+@group(0) @binding(90) var<storage> u_vertices: array<f32>;
+@group(0) @binding(91) var<storage> u_color: array<f32>;
+@group(0) @binding(92) var<uniform> u_thickness: f32;
+@group(0) @binding(93) var<storage> u_indices: array<u32>;
+
+struct GeoEdgeInput
+{
+  @builtin(position) position: vec4<f32>,
+  @location(1) @interpolate(flat) index: u32,
+};
+
+
+@vertex
+fn vertex_main(@builtin(vertex_index) vertId: u32,
+               @builtin(instance_index) instanceId: u32) -> GeoEdgeInput
+{
+  let p1 = vec3f(u_vertices[instanceId * 6],
+                 u_vertices[instanceId * 6 + 1],
+                 u_vertices[instanceId * 6 + 2]);
+  let p2 = vec3f(u_vertices[instanceId * 6 + 3],
+                 u_vertices[instanceId * 6 + 4],
+                 u_vertices[instanceId * 6 + 5]);
+  let tp1 = cameraMapPoint(p1);
+  let tp2 = cameraMapPoint(p2);
+  let v = normalize(tp2.xy*tp1.w - tp1.xy*tp2.w);
+  let v2 = vec2<f32>(-v.y, v.x);
+  var pos: vec4<f32>;
+  if(vertId == 0) {
+    pos = vec4<f32>(tp1.xy + (-0.5*v.xy + v2) * u_thickness/2.*tp1.w, tp1.zw); }
+  else if(vertId == 1) {
+    pos = vec4<f32>(tp1.xy + (-0.5*v.xy + - v2) * u_thickness/2.*tp1.w, tp1.zw); }
+  else if(vertId == 2) {
+    pos = vec4<f32>(tp2.xy + (0.5*v.xy + v2) * u_thickness/2.*tp2.w, tp2.zw); }
+  else {
+    pos = vec4<f32>(tp2.xy + (0.5*v.xy - v2) * u_thickness/2.*tp2.w, tp2.zw); }
+  
+  return GeoEdgeInput(pos, u_indices[instanceId]);
+}
+
+@fragment
+fn fragment_main(input: GeoEdgeInput) -> @location(0) vec4<f32> {
+  if (u_color[input.index*4+3] == 0.0) {
+    discard;
+  }
+  return vec4<f32>(u_color[input.index * 4],
+                   u_color[input.index * 4 + 1],
+                   u_color[input.index * 4 + 2],
+                   u_color[input.index * 4 + 3]);
+}
+
+@fragment
+fn fragmentQueryIndex(input: GeoEdgeInput) -> @location(0) vec2<u32> {
+  return vec2<u32>(input.index, 1u);
+}

ngsolve_webgpu/shaders/geo_face.wgsl

@@ -0,0 +1,47 @@
+
+@group(0) @binding(90) var<storage> u_vertices : array<f32>;
+@group(0) @binding(91) var<storage> u_normals : array<f32>;
+@group(0) @binding(92) var<storage> u_indices : array<u32>;
+@group(0) @binding(93) var<storage> u_colors: array<f32>;
+
+struct GeoFragmentInput {
+  @builtin(position) position: vec4<f32>,
+    @location(0) p: vec3<f32>,
+    @location(1) n: vec3<f32>,
+    @location(2) @interpolate(flat) id: u32,
+    @location(3) @interpolate(flat) index: u32,
+};
+
+@vertex
+fn vertex_main(@builtin(vertex_index) vertId: u32,
+               @builtin(instance_index) trigId: u32) -> GeoFragmentInput {
+  let point = vec3<f32>(u_vertices[trigId * 9 + vertId * 3],
+                        u_vertices[trigId * 9 + vertId * 3 + 1],
+                        u_vertices[trigId * 9 + vertId * 3 + 2]);
+  let normal = vec3<f32>(u_normals[trigId * 9 + vertId * 3],
+                         u_normals[trigId * 9 + vertId * 3 + 1],
+                         u_normals[trigId * 9 + vertId * 3 + 2]);
+  let position = cameraMapPoint(point);
+  return GeoFragmentInput(position,
+                          point,
+                          normal,
+                          trigId, u_indices[trigId]);
+}
+
+@fragment
+fn fragment_main(input: GeoFragmentInput) -> @location(0) vec4<f32> {
+  let color = vec4<f32>(u_colors[input.index * 4],
+                        u_colors[input.index * 4 + 1],
+                        u_colors[input.index * 4 + 2],
+                        u_colors[input.index * 4 + 3]);
+  if (color.a == 0.) {
+    discard;
+  }
+  return lightCalcColor(input.n, color);
+}
+
+@fragment
+fn fragmentQueryIndex(input: GeoFragmentInput) -> @location(0) vec2<u32>
+{
+  return vec2<u32>(input.index, 2u);
+}

ngsolve_webgpu/shaders/geo_vertex.wgsl

@@ -0,0 +1,71 @@
+
+@group(0) @binding(90) var<storage> u_vertices: array<f32>;
+@group(0) @binding(91) var<storage> u_vertex_color: array<f32>;
+@group(0) @binding(92) var<uniform> u_vertex_thickness: f32;
+
+struct GeoVertexInput
+{
+  @builtin(position) position: vec4<f32>,
+  @location(1) pos: vec4<f32>,
+  @location(2) pos2: vec4<f32>,
+  @location(3) p: vec3<f32>,
+  @location(4) @interpolate(flat) index: u32,
+};
+
+
+@vertex
+fn vertex_main(@builtin(vertex_index) vertId: u32,
+               @builtin(instance_index) vertIndex: u32) -> GeoVertexInput
+{
+  let point = vec3<f32>(u_vertices[vertIndex * 3u],
+                        u_vertices[vertIndex * 3u + 1u],
+                        u_vertices[vertIndex * 3u + 2u]);
+  let pos = cameraMapPoint(point);
+  var position = pos;
+  // draw a rectangle, we discard points outside the circle in the fragment shader
+  if(vertId == 0)
+    {
+      position.x -= u_vertex_thickness/2.;
+      position.y += u_vertex_thickness/2.;
+    }
+  else if(vertId == 1)
+    {
+      position.x -= u_vertex_thickness/2.;
+      position.y -= u_vertex_thickness/2.;
+    }
+  else if(vertId == 2)
+    {
+      position.x += u_vertex_thickness/2.;
+      position.y += u_vertex_thickness/2.;
+    }
+  else if(vertId == 3)
+    {
+      position.x += u_vertex_thickness/2.;
+      position.y -= u_vertex_thickness/2.;
+    }
+
+  return GeoVertexInput(position, position, pos, point, vertIndex);
+}
+
+@fragment
+fn fragment_main(input: GeoVertexInput) -> @location(0) vec4<f32> {
+  if(length(input.pos.xy - input.pos2.xy) > u_vertex_thickness/2.) {
+    discard;
+  }
+  if (u_vertex_color[input.index*4+3] == 0.) {
+    discard;
+  }
+
+  return vec4<f32>(u_vertex_color[input.index * 4],
+                   u_vertex_color[input.index * 4 + 1],
+                   u_vertex_color[input.index * 4 + 2],
+                   u_vertex_color[input.index * 4 + 3]);
+}
+
+@fragment
+fn fragmentQueryIndex(input: GeoVertexInput) -> @location(0) vec2<u32> {
+  if(length(input.pos.xy - input.pos2.xy) > u_vertex_thickness/2.) {
+    discard;
+  }
+  return vec2<u32>(input.index, 0u);
+}

ngsolve_webgpu/shaders/isosurface/compute.wgsl

@@ -0,0 +1,63 @@
+
+@group(0) @binding(21) var<storage, read_write> count_trigs: atomic<u32>;
+@group(0) @binding(22) var<uniform> u_ntets: u32;
+@group(0) @binding(23) var<uniform> only_count: u32;
+@group(0) @binding(24) var<storage, read_write> subtrigs: array<SubTrig>;
+@group(0) @binding(26) var<storage> levelset_values: array<f32>;
+@group(0) @binding(27) var<uniform> u_subdivision: u32;
+
+fn my_pow(x: u32, y: u32) -> u32 {
+  var res = 1u;
+  for(var i = 0u; i < y; i++) {
+    res *= x;
+  }
+  return res;
+}
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  for (var i = id.x; i<u_ntets*my_pow(4u,u_subdivision); i+=256u*1024u) {
+    var b0 = vec4<f32> (1.0, 0.0, 0.0, 0.0);
+    var b1 = vec4<f32> (0.0, 1.0, 0.0, 0.0);
+    var b2 = vec4<f32> (0.0, 0.0, 1.0, 0.0);
+    var b3 = vec4<f32> (0.0, 0.0, 0.0, 1.0);
+    var elnr = i / my_pow(4u,u_subdivision);
+    var scale: f32 = 1.;
+    var ind = i;
+    for(var level = 0u; level < u_subdivision; level++)
+      {
+        var b = ind % 4u;
+        ind /= 4u;
+        if(b == 0u) {
+          b0 = (b0 + b1) * 0.5;
+        } else if(b == 1u) {
+          b1 = (b0 + b1) * 0.5;
+        } else if(b == 2u) {
+          b2 = (b2 + b3) * 0.5;
+        } else if(b == 3u) {
+          b3 = (b2 + b3) * 0.5;
+        }
+      }
+    let p = get_tet_points(elnr);
+    let lam = array(b0.xyz,
+                    b1.xyz,
+                    b2.xyz,
+                    b3.xyz);
+    let f = array(evalTet(&levelset_values, elnr, 0, b0.xyz),
+                  evalTet(&levelset_values, elnr, 0, b1.xyz),
+                  evalTet(&levelset_values, elnr, 0, b2.xyz),
+                  evalTet(&levelset_values, elnr, 0, b3.xyz));
+    let cuts = clipTet(lam, f, elnr);
+    if(cuts.n == 0) {
+      continue;
+    }
+    let index = atomicAdd(&count_trigs, cuts.n);
+    if(only_count == u32(1)) {
+      continue;
+    }
+    for(var k = 0u; k < cuts.n; k++) {
+      subtrigs[index+k] = cuts.trigs[k];
+    }
+  }
+}
+

ngsolve_webgpu/shaders/isosurface/negative_clipping.wgsl

@@ -0,0 +1,13 @@
+
+@group(0) @binding(80) var<storage> levelset: array<f32>;
+
+@fragment
+fn fragment_neg_clip(input: VertexOutputClip) -> @location(0) vec4<f32>
+{
+  let lvlset = evalTet(&levelset, input.elnr, 0, input.lam);
+  if(lvlset > 0.) {
+    discard;
+  }
+  let value = evalTet(&function_values_3d, input.elnr, 0, input.lam);
+  return lightCalcColor(input.n, getColor(value));
+}

ngsolve_webgpu/shaders/isosurface/negative_surface.wgsl

@@ -0,0 +1,15 @@
+
+@group(0) @binding(80) var<storage> levelset_values : array<f32>;
+
+@fragment
+fn fragmentCheckLevelset(input: VertexOutput2d) -> @location(0) vec4<f32> {
+    checkClipping(input.p);
+    let p = &u_function_values_2d;
+    let value = evalTrig(p, input.id, 0, input.lam);
+    let pl = &levelset_values;
+    let levelset = evalTrig(pl, input.id, 0, input.lam);
+    if (levelset > 0.0) {
+      discard;
+    }
+    return lightCalcColor(-input.n, getColor(value));
+}