ngsolve-webgpu 0.0.1__py3-none-any.whl

ngsolve_webgpu/shaders/isosurface/render.wgsl

@@ -0,0 +1,50 @@
+
+struct MeshFragmentInput {
+  @builtin(position) fragPosition: vec4<f32>,
+  @location(0) color_val: f32,
+  @location(1) p: vec3<f32>,
+  @location(2) n: vec3<f32>,
+  @location(3) @interpolate(flat) id: u32,
+  @location(4) @interpolate(flat) index: u32,
+};
+
+@vertex
+fn vertex_isosurface(@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];
+  }
+
+  var p0 = (1.-trig.lam[0][0]-trig.lam[0][1]-trig.lam[0][2]) * points[3];
+  for(var i=0u; i<3u; i=i+1u) {
+    p0 = p0 + trig.lam[0][i] * points[i];
+  }
+  var p1 = (1.-trig.lam[1][0]-trig.lam[1][1]-trig.lam[1][2]) * points[3];
+  for(var i=0u; i<3u; i=i+1u) {
+    p1 = p1 + trig.lam[1][i] * points[i];
+  }
+  var p2 = (1.-trig.lam[2][0]-trig.lam[2][1]-trig.lam[2][2]) * points[3];
+  for(var i=0u; i<3u; i=i+1u) {
+    p2 = p2 + trig.lam[2][i] * points[i];
+  }
+  let n = normalize(cross(p1 - p0, p2 - p0));
+
+  return VertexOutputClip(cameraMapPoint(p), p, -n, lam.xyz,
+                      trig.id);
+}
+
+
+@fragment
+fn fragment_isosurface(input: VertexOutputClip) -> @location(0) vec4<f32>
+{
+  checkClipping(input.p);
+  let value = evalTet(&function_values_3d, input.elnr, 0, input.lam);
+  return lightCalcColor(input.n, getColor(value));
+}

ngsolve_webgpu/shaders/line_integral_convolution.wgsl

@@ -0,0 +1,100 @@
+fn random(seed: u32) -> u32 {
+   // Xorshift32, see https://en.wikipedia.org/wiki/Xorshift
+    var value: u32 = seed;
+    value ^= value << 13;
+    value ^= value >> 17;
+    value ^= value << 5;
+    return value;
+}
+
+fn randomFloat(seed: u32) -> f32 {
+    return f32(random(seed)) / f32(0xFFFFFFFFu);
+}
+
+fn getSeed(j: u32, k: u32) -> u32 {
+    // create hash value as seed for random number generator
+    // https://www.burtleburtle.net/bob/hash/integer.html
+    let n = (k << 16) + j;
+    var seed = (n ^ 61) ^ (n >> 16);
+    seed *= seed * 9;
+    seed = seed ^ (seed >> 4);
+    seed = seed * 0x27d4eb2d;
+    seed = seed ^ (seed >> 15);
+    return seed;
+}
+
+fn noise(x: u32, y: u32) -> f32 {
+    let seed = getSeed(x, y);
+    return randomFloat(seed);
+}
+
+fn dropletNoise(x: u32, y: u32) -> f32 {
+  // large droplets for oriented line integral convolution
+    let n = u_line_integral_convolution.thickness;
+    let rand: f32 = noise(x / n, y / n);
+
+    if rand < 0.85 {
+        return 0.0;
+    }
+
+    let dx = f32(x % n) - f32(n) / 2.;
+    let dy = f32(y % n) - f32(n) / 2.;
+    let d = 4 * (dx * dx + dy * dy) / f32(n * n);
+
+    return clamp(1.0 - d, 0.0, 1.0);
+}
+
+
+fn lineIntegralConvolution(x: u32, y: u32) -> f32 {
+    let w = u_line_integral_convolution.width;
+    let h = u_line_integral_convolution.height;
+    let kernel_length = u_line_integral_convolution.kernel_length;
+    let oriented = u_line_integral_convolution.oriented;
+    var sum: f32 = 0;
+    var weight: f32 = 0;
+
+    for (var dir: i32 = -1; dir <= 1; dir += 2) {
+        var p = vec2f(f32(x) + .5, f32(y) + .5);
+
+        for (var k: u32 = 0; k < kernel_length; k++) {
+            var v = textureLoad(u_line_integral_convolution_input, vec2i(p), 0).xy;
+            v = normalize(v);
+
+            p += f32(dir) * v;
+
+            if p.x < 0.0 || p.x >= f32(w) || p.y < 0.0 || p.y >= f32(h) {
+              break;
+            }
+
+            let ix = u32(p.x);
+            let iy = u32(p.y);
+
+            var kernel_weight: f32 = f32(k) / f32(kernel_length);
+            if oriented == 0 {
+                kernel_weight = 1.0 - f32(k) / f32(kernel_length);
+                sum += kernel_weight * noise(ix, iy);
+                weight += kernel_weight;
+            } else {
+                var t = 0.5 * (1.0 + f32(dir) * f32(k) / f32(kernel_length));
+                kernel_weight = 0.1 + 0.9 * t * t * t * t;
+                sum += kernel_weight * dropletNoise(ix, iy);
+                weight += kernel_weight;
+            }
+        }
+    }
+
+    return sum / weight;
+}
+
+@compute  @workgroup_size(16, 16, 1)
+fn computeLineIntegralConvolution(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let w = u_line_integral_convolution.width;
+    let h = u_line_integral_convolution.height;
+
+    if gid.x >= w || gid.y >= h {
+        return;
+    }
+
+    let value = lineIntegralConvolution(gid.x, gid.y);
+    textureStore(u_line_integral_convolution_output, gid.xy, vec4f(value, .0, .0, .0));
+}

ngsolve_webgpu/shaders/mesh.wgsl

@@ -0,0 +1,296 @@
+struct MeshFragmentInput {
+  @builtin(position) fragPosition: vec4<f32>,
+  @location(0) color: vec4<f32>,
+  @location(1) p: vec3<f32>,
+  @location(2) n: vec3<f32>,
+  @location(3) @interpolate(flat) id: u32,
+  @location(4) @interpolate(flat) index: u32,
+};
+
+// A triangle as part of a 3d element (thus, 3 barycentric coordinates)
+struct SubTrig {
+  lam: array<vec3f, 3>,
+  id: u32,
+}
+
+struct ClipTetResult {
+  n: u32,
+  trigs: array<SubTrig, 2>,
+}
+
+// clip tet such that the clip triangle(s) have value 0 everywhere
+fn clipTet(lam: array<vec3f, 4>, values: array<f32, 4>) -> ClipTetResult {
+    let ei = 0u;
+    var trigs = ClipTetResult(0, array<SubTrig, 2>(SubTrig(array<vec3f, 3>(vec3f(0.0), vec3f(0.0), vec3f(0.0)), 0), SubTrig(array<vec3f, 3>(vec3f(0.0), vec3f(0.0), vec3f(0.0)), 0)));
+    var p_pos = array<u32, 4>(0u, 0u, 0u, 0u);
+    var p_neg = array<u32, 4>(0u, 0u, 0u, 0u);
+
+    var n_pos: u32 = 0u;
+    var n_neg: u32 = 0u;
+
+    for (var i = 0u; i < 4u; i++) {
+        if values[i] > 0.0 {
+            p_pos[n_pos] = i;
+            n_pos++;
+        } else {
+            p_neg[n_neg] = i;
+            n_neg++;
+        }
+    }
+
+    if n_pos == 4u || n_neg == 4u {
+        return trigs;
+    }
+
+    if n_pos == 3u {
+        trigs.n = 1u;
+        n_pos = 1u;
+        n_neg = 3u;
+        p_pos[3] = p_neg[0];
+        p_neg[0] = p_pos[0];
+        p_neg[1] = p_pos[1];
+        p_neg[2] = p_pos[2];
+        p_pos[0] = p_pos[3];
+    }
+
+    if n_pos == 1u {
+        trigs.n = 1u;
+        trigs.trigs[0].id = ei;
+        for (var i = 0u; i < 3u; i++) {
+            let t = values[p_pos[0] ] / (values[p_pos[0] ] - values[p_neg[i] ]);
+            let lam_trig = mix(lam[p_pos[0] ], lam[p_neg[i] ], t);
+            trigs.trigs[0].lam[i] = lam_trig;
+        }
+        return trigs;
+    }
+
+  // two points before, two points behind clipping plane
+  // -> two triangles
+    trigs.n = 2u;
+    var pairs = array<vec2u,4>(
+        vec2u(p_pos[1], p_neg[0]),
+        vec2u(p_pos[0], p_neg[0]),
+        vec2u(p_pos[0], p_neg[1]),
+        vec2u(p_pos[1], p_neg[1])
+    );
+    var points: array<vec3f, 4> = array<vec3f, 4>(vec3f(0.0), vec3f(0.0), vec3f(0.0), vec3f(0.0));
+    for (var i = 0; i < 4; i++) {
+        let p0 = pairs[i].x;
+        let p1 = pairs[i].y;
+        let t = values[p0 ] / (values[p0] - values[p1]);
+        let lam_trig = mix(lam[p0], lam[p1], t);
+        points[i] = lam_trig;
+    }
+    trigs.trigs[0].id = ei;
+    trigs.trigs[0].lam = array(points[0], points[1], points[2]);
+    trigs.trigs[1].id = ei;
+    trigs.trigs[1].lam = array(points[0], points[2], points[3]);
+    return trigs;
+}
+
+fn calcMeshFace(color: vec4<f32>, p: array<vec3<f32>, 3>, vertId: u32, nr: u32, index: u32) -> MeshFragmentInput {
+    let n = cross(p[1] - p[0], p[2] - p[0]);
+    let point = p[vertId % 3];
+    let position = cameraMapPoint(point);
+    return MeshFragmentInput(position, color, point, n, nr, index);
+}
+
+@fragment
+fn fragmentMesh(input: MeshFragmentInput) -> @location(0) vec4<f32> {
+    return lightCalcColor(input.n, input.color);
+    // checkClipping(input.p);
+    // let n4 = cameraMapNormal(input.n);
+    // let n = normalize(n4.xyz);
+    // let brightness = clamp(dot(n, normalize(vec3<f32>(-1., -3., -3.))), .0, 1.) * 0.7 + 0.3;
+    // let color = input.color.xyz * brightness;
+    // return vec4<f32>(color, input.color.w);
+}
+
+@vertex
+fn vertexClipTet(@builtin(vertex_index) vertId: u32, @builtin(instance_index) elId: u32) -> MeshFragmentInput {
+    const N: u32 = 4;
+    let faceId: u32 = vertId / 3;
+    let el = u_tets[elId];
+    var p: array<vec3f, 4>;
+
+    for (var i = 0u; i < N; i++) {
+        let n = 3 * el.p[i];
+        p[i] = vec3<f32>(vertices[n], vertices[n + 1], vertices[n + 2]);
+    }
+
+    let lam = array(vec3f(1.0, 0.0, 0.0), vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), vec3f(0.0, 0.0, 0.0));
+
+    let s = u_mesh.shrink;
+    let values = array(p[0].z-s, p[1].z-s, p[2].z-s, p[3].z-s);
+
+    let trigs = clipTet(lam, values);
+
+    var points = array<vec3<f32>, 3>(vec3f(0.0), vec3f(0.0), vec3f(0.0));
+    if(trigs.n > faceId) {
+      let trig = trigs.trigs[faceId];
+      for (var k = 0u; k < 3u; k++) {
+       let lam = vec4f(trig.lam[k], 1.0 - trig.lam[k].x - trig.lam[k].y - trig.lam[k].z);
+        for (var i = 0u; i < 3u; i++) {
+          points[k][i] = lam.x * p[0][i] + lam.y * p[1][i] + lam.z * p[2][i] + lam.w * p[3][i];
+        }
+      }
+    }
+
+    return calcMeshFace(vec4<f32>(1., 0., 0., 1.), points, vertId, el.nr, el.index);
+}
+
+@vertex
+fn vertexMeshTet(@builtin(vertex_index) vertId: u32, @builtin(instance_index) elId: u32) -> MeshFragmentInput {
+    const N: u32 = 4;
+    let faceId: u32 = vertId / 3;
+    let el = u_tets[elId];
+    var p: array<vec3<f32>, 4>;
+
+    var center = vec3<f32>(0.0, 0.0, 0.0);
+    for (var i = 0u; i < N; i++) {
+        let n = 3 * el.p[i];
+        p[i] = vec3<f32>(vertices[n], vertices[n + 1], vertices[n + 2]);
+        center += p[i] / f32(N);
+    }
+
+    for (var i = 0u; i < 4u; i++) {
+        p[i] = mix(center, p[i], u_mesh.shrink);
+    }
+
+    let pi = TET_FACES[faceId];
+    let points = array<vec3<f32>, 3>(p[pi[0] ], p[pi[1] ], p[pi[2] ]);
+
+    return calcMeshFace(vec4<f32>(1., 0., 0., 1.), points, vertId, el.nr, el.index);
+}
+
+
+@vertex
+fn vertexMeshPyramid(@builtin(vertex_index) vertId: u32, @builtin(instance_index) elId: u32) -> MeshFragmentInput {
+    const N: u32 = 5;
+    let faceId = vertId / 3;
+    let el = u_pyramids[elId];
+    var p: array<vec3<f32>, 5>;
+
+    var center = vec3<f32>(0.0, 0.0, 0.0);
+    for (var i = 0u; i < N; i++) {
+        p[i] = vec3<f32>(vertices[3 * el.p[i] ], vertices[3 * el.p[i] + 1], vertices[3 * el.p[i] + 2]);
+        center += p[i] / f32(N);
+    }
+
+    for (var i = 0u; i < N; i++) {
+        p[i] = mix(center, p[i], u_mesh.shrink);
+    }
+
+    let pi = PYRAMID_FACES[faceId];
+    var points = array<vec3<f32>, 3>(p[pi[0] ], p[pi[1] ], p[pi[2] ]);
+
+    return calcMeshFace(vec4<f32>(1., 0., 1., 1.), points, vertId, el.nr, el.index);
+}
+
+
+@vertex
+fn vertexMeshPrism(@builtin(vertex_index) vertId: u32, @builtin(instance_index) elId: u32) -> MeshFragmentInput {
+    const N: u32 = 6;
+    let faceId = vertId / 3;
+    let el = u_prisms[elId];
+    var p: array<vec3<f32>, 6>;
+
+    var center = vec3<f32>(0.0, 0.0, 0.0);
+    for (var i = 0u; i < N; i++) {
+        p[i] = vec3<f32>(vertices[3 * el.p[i] ], vertices[3 * el.p[i] + 1], vertices[3 * el.p[i] + 2]);
+        center += p[i] / f32(N);
+    }
+
+    for (var i = 0u; i < N; i++) {
+        p[i] = mix(center, p[i], u_mesh.shrink);
+    }
+
+    let pi = PRISM_FACES[faceId];
+    var points = array<vec3<f32>, 3>(p[pi[0] ], p[pi[1] ], p[pi[2] ]);
+
+    return calcMeshFace(vec4<f32>(0., 1., 1., 1.), points, vertId, el.nr, el.index);
+}
+
+
+@vertex
+fn vertexMeshHex(@builtin(vertex_index) vertId: u32, @builtin(instance_index) elId: u32) -> MeshFragmentInput {
+    const N: u32 = 8;
+    let faceId = vertId / 3;
+    let el = u_hexes[elId];
+    var p: array<vec3<f32>, 8>;
+
+    var center = vec3<f32>(0.0, 0.0, 0.0);
+    for (var i = 0u; i < N; i++) {
+        p[i] = vec3<f32>(vertices[3 * el.p[i] ], vertices[3 * el.p[i] + 1], vertices[3 * el.p[i] + 2]);
+        center += p[i] / f32(N);
+    }
+
+    for (var i = 0u; i < N; i++) {
+        p[i] = mix(center, p[i], u_mesh.shrink);
+    }
+
+    let pi = HEX_FACES[faceId];
+    var points = array<vec3<f32>, 3>(p[pi[0] ], p[pi[1] ], p[pi[2] ]);
+
+    return calcMeshFace(vec4<f32>(1., 1., 0., 1.), points, vertId, el.nr, el.index);
+}
+
+@group(0) @binding(54) var<storage> u_mesh_color: vec4<f32>;
+
+@fragment
+fn fragment2dElement(input: VertexOutput2d) -> @location(0) vec4<f32> {
+  checkClipping(input.p);
+  return lightCalcColor(-input.n, u_mesh_color);
+}
+
+@fragment
+fn fragmentWireframe2d(input: VertexOutput2d) -> @location(0) vec4<f32> {
+  checkClipping(input.p);
+  if (input.lam[0] > 0.001 && input.lam[1] > 0.001 && input.lam[0] + input.lam[1] < 0.999) {
+    discard;
+  }
+  return lightCalcColor(-input.n, u_mesh_color);
+}
+
+
+const TET_FACES = array(
+    vec3i(0, 2, 1),
+    vec3i(0, 1, 3),
+    vec3i(1, 2, 3),
+    vec3i(2, 0, 3)
+);
+
+const PYRAMID_FACES = array(
+    vec3i(0, 2, 1),
+    vec3i(0, 3, 2),
+    vec3i(0, 1, 4),
+    vec3i(1, 2, 4),
+    vec3i(2, 3, 4),
+    vec3i(3, 0, 4)
+);
+
+const PRISM_FACES = array(
+    vec3i(0, 2, 1),
+    vec3i(3, 4, 5),
+    vec3i(0, 1, 4),
+    vec3i(0, 4, 3),
+    vec3i(1, 2, 5),
+    vec3i(1, 5, 4),
+    vec3i(2, 0, 3),
+    vec3i(2, 3, 5)
+);
+
+const HEX_FACES = array(
+    vec3i(0, 3, 1),
+    vec3i(3, 2, 1),
+    vec3i(4, 5, 6),
+    vec3i(4, 6, 7),
+    vec3i(0, 1, 5),
+    vec3i(0, 5, 4),
+    vec3i(1, 2, 6),
+    vec3i(1, 6, 5),
+    vec3i(2, 3, 7),
+    vec3i(2, 7, 6),
+    vec3i(3, 0, 4),
+    vec3i(3, 4, 7)
+);

ngsolve_webgpu/shaders/numbers.wgsl

@@ -0,0 +1,40 @@
+#import font
+#import clipping
+#import camera
+
+@group(0) @binding(12) var<storage> vertices : array<f32>;
+
+@vertex
+fn vertexPointNumber(@builtin(vertex_index) vertexId: u32, @builtin(instance_index) pointId: u32) -> FontFragmentInput {
+    var p = vec3<f32>(vertices[3 * pointId], vertices[3 * pointId + 1], vertices[3 * pointId + 2]);
+
+    if calcClipping(p) == false {
+        return FontFragmentInput(vec4<f32>(-1.0, -1.0, 0.0, 1.0), vec2<f32>(0.));
+    }
+
+    var position = cameraMapPoint(p);
+
+    let i_digit = vertexId / 6;
+    let vi = vertexId % 6;
+
+    var length = 1u;
+    var n = 10u;
+    while n <= pointId + 1 {
+        length++;
+        n *= 10u;
+    }
+
+    if i_digit >= length {
+        return FontFragmentInput(vec4<f32>(-1.0, -1.0, 0.0, 1.0), vec2<f32>(0.));
+    }
+
+    var digit = pointId + 1;
+    for (var i = 0u; i < i_digit; i++) {
+        digit = digit / 10;
+    }
+    digit = digit % 10;
+
+    position.x += f32(length - i_digit - 1) * u_font.width_normalized * position.w;
+    return fontCalc(digit+48, position, vi);
+}
+

ngsolve_webgpu/shaders/shader.wgsl

@@ -0,0 +1,111 @@
+#import eval/trig
+
+
+struct VertexOutput1d {
+  @builtin(position) fragPosition: vec4<f32>,
+  @location(0) p: vec3<f32>,
+  @location(1) lam: f32,
+  @location(2) @interpolate(flat) id: u32,
+};
+
+struct VertexOutput2d {
+  @builtin(position) fragPosition: vec4<f32>,
+  @location(0) p: vec3<f32>,
+  @location(1) lam: vec2<f32>,
+  @location(2) @interpolate(flat) id: u32,
+  @location(3) n: vec3<f32>,
+};
+
+struct VertexOutput3d {
+  @builtin(position) fragPosition: vec4<f32>,
+  @location(0) p: vec3<f32>,
+  @location(1) lam: vec3<f32>,
+  @location(2) @interpolate(flat) id: u32,
+  @location(3) n: vec3<f32>,
+};
+
+@vertex
+fn vertexEdgeP1(@builtin(vertex_index) vertexId: u32, @builtin(instance_index) edgeId: u32) -> VertexOutput1d {
+    let edge = edges_p1[edgeId];
+    var p: vec3<f32> = vec3<f32>(edge.p[3 * vertexId], edge.p[3 * vertexId + 1], edge.p[3 * vertexId + 2]);
+
+    var lam: f32 = 0.0;
+    if vertexId == 0 {
+        lam = 1.0;
+    }
+
+    var position = cameraMapPoint(p);
+    return VertexOutput1d(position, p, lam, edgeId);
+}
+
+fn calcTrig(p: array<vec3<f32>, 3>, vertexId: u32, trigId: u32) -> VertexOutput2d {
+    let subdivision = u_curvature_subdivision;
+    let h = 1.0 / f32(subdivision);
+
+    var lam = vec2f(0.0, 0.0);
+    if (vertexId % 3) < 2 {
+        lam[vertexId % 3] += h;
+    }
+
+    var position: vec3f;
+    var normal: vec3f;
+
+    if subdivision == 1 {
+        position = p[vertexId];
+        normal = cross(p[1] - p[0], p[2] - p[0]);
+    } else {
+        var subTrigId: u32 = vertexId / 3;
+        var ix = subTrigId % subdivision;
+        var iy = subTrigId / subdivision;
+        lam += h * vec2f(f32(ix), f32(iy));
+
+        if ix + iy >= subdivision {
+            lam[0] = 1.0 - lam[0];
+            lam[1] = 1.0 - lam[1];
+        }
+
+        let data = &u_curvature_values_2d;
+        var pos_and_gradients = evalTrigVec3Grad(data, trigId, lam);
+        if (u_deformation_values_2d[0] != -1.) {
+          pos_and_gradients += u_deformation_scale * evalTrigVec3Grad(&u_deformation_values_2d, trigId, lam);
+        }
+        position = pos_and_gradients[0];
+        normal = normalize(cross(pos_and_gradients[1], pos_and_gradients[2]));
+    }
+
+    let mapped_position = cameraMapPoint(position);
+
+    return VertexOutput2d(mapped_position, position, lam, trigId, normal);
+}
+
+
+@vertex
+fn vertexTrigP1Indexed(@builtin(vertex_index) vertexId: u32, @builtin(instance_index) trigId: u32) -> VertexOutput2d {
+    var vid = 3 * vec3u(
+        trigs[4 * trigId + 0],
+        trigs[4 * trigId + 1],
+        trigs[4 * trigId + 2]
+    );
+
+    var p = array<vec3<f32>, 3>(
+        vec3<f32>(vertices[vid[0] ], vertices[vid[0] + 1], vertices[vid[0] + 2]),
+        vec3<f32>(vertices[vid[1] ], vertices[vid[1] + 1], vertices[vid[1] + 2]),
+        vec3<f32>(vertices[vid[2] ], vertices[vid[2] + 1], vertices[vid[2] + 2])
+    );
+    return calcTrig(p, vertexId, trigId);
+}
+
+
+@fragment
+fn fragmentTrig(input: VertexOutput2d) -> @location(0) vec4<f32> {
+    checkClipping(input.p);
+    let p = &u_function_values_2d;
+    let value = evalTrig(p, input.id, u_function_component, input.lam);
+    return lightCalcColor(input.n, getColor(value));
+}
+
+@fragment
+fn fragmentEdge(@location(0) p: vec3<f32>) -> @location(0) vec4<f32> {
+    checkClipping(p);
+    return vec4<f32>(0, 0, 0, 1.0);
+}

ngsolve_webgpu/shaders/uniforms.wgsl

@@ -0,0 +1,93 @@
+// Uniforms are global variables that are constant for all invocations of a shader.
+// They are used to store configuration data (no mesh etc.)
+// Each uniform must have a unique binding group and number
+// They are used to pass data from the CPU to the GPU (variable names are only relevant within the shader code)
+
+// general uniforms
+@group(0) @binding(14) var gBufferLam : texture_2d<f32>;
+
+// legacy uniforms
+@group(0) @binding(8) var<storage> edges_p1 : array<EdgeP1>;
+@group(0) @binding(12) var<storage> vertices : array<f32>;
+@group(0) @binding(13) var<storage> trigs : array<u32>;
+
+// mesh uniforms
+@group(0) @binding(20) var<uniform> u_mesh : MeshUniforms;
+@group(0) @binding(21) var<storage> u_edges : array<Edge>;
+@group(0) @binding(22) var<storage> u_segs : array<Seg>;
+@group(0) @binding(23) var<storage> u_trigs : array<Trig>;
+@group(0) @binding(24) var<storage> u_quads : array<Quad>;
+@group(0) @binding(25) var<storage> u_tets : array<Tet>;
+@group(0) @binding(26) var<storage> u_pyramids : array<Pyramid>;
+@group(0) @binding(27) var<storage> u_prisms : array<Prism>;
+@group(0) @binding(28) var<storage> u_hexes : array<Hex>;
+
+// deformation uniforms
+@group(0) @binding(30) var<storage> u_segs_deformation : array<f32>;
+@group(0) @binding(31) var<storage> u_trigs_deformation : array<f32>;
+@group(0) @binding(32) var<storage> u_quads_deformation : array<f32>;
+@group(0) @binding(33) var<storage> u_tets_deformation : array<f32>;
+@group(0) @binding(34) var<storage> u_pyramids_deformation : array<f32>;
+@group(0) @binding(35) var<storage> u_prisms_deformation : array<f32>;
+@group(0) @binding(36) var<storage> u_hexes_deformation : array<f32>;
+
+// function uniforms
+@group(0) @binding(30) var<storage> u_segs_function : array<f32>;
+@group(0) @binding(31) var<storage> u_trigs_function : array<f32>;
+@group(0) @binding(32) var<storage> u_quads_function : array<f32>;
+@group(0) @binding(33) var<storage> u_tets_function : array<f32>;
+@group(0) @binding(34) var<storage> u_pyramids_function : array<f32>;
+@group(0) @binding(35) var<storage> u_prisms_function : array<f32>;
+@group(0) @binding(36) var<storage> u_hexes_function : array<f32>;
+
+// Line integral convolution
+@group(0) @binding(40) var<uniform> u_line_integral_convolution : LineIntegralConvolutionUniforms;
+@group(0) @binding(41) var u_line_integral_convolution_input: texture_2d<f32>;
+@group(0) @binding(42) var u_line_integral_convolution_output: texture_storage_2d<r32float, write>;
+
+// Create mesh
+@group(0) @binding(50) var<storage, read_write> create_mesh_trigs_p1 : array<TrigP1>;
+@group(0) @binding(51) var<storage, read_write> create_mesh_trig_function_values : array<f32>;
+@group(0) @binding(52) var<storage, read_write> create_mesh_vertex_buffer : array<f32>;
+@group(0) @binding(53) var<storage, read_write> create_mesh_index_buffer : array<u32>;
+
+struct MeshUniforms {
+  subdivision: u32,
+  shrink: f32,
+
+  padding0: f32,
+  padding1: f32,
+};
+
+struct LineIntegralConvolutionUniforms {
+  width: u32,         // canvas width
+  height: u32,        // canvas height
+  kernel_length: u32,
+  oriented: u32,      // 0: not oriented, 1: oriented
+  thickness: u32,     // thickness of the lines (only used for oriented)
+
+  padding0: u32,
+  padding1: u32,
+  padding2: u32,
+};
+// Mesh element structures
+
+struct Edge { p: array<u32, 2> }; // Inner edge, for wireframe
+struct Seg { p: array<u32, 2>, nr: u32, index: u32 };
+struct Trig { p: array<u32, 3>, nr: u32, index: u32 };
+struct Quad { p: array<u32, 4>, nr: u32, index: u32 };
+struct Tet { p: array<u32, 4>, nr: u32, index: u32 };
+struct Pyramid { p: array<u32, 5>, nr: u32, index: u32 };
+struct Prism { p: array<u32, 6>, nr: u32, index: u32 };
+struct Hex { p: array<u32, 8>, nr: u32, index: u32 };
+
+
+// legacy mesh structs
+struct EdgeP1 { p: array<f32, 6> };
+struct TrigP1 { p: array<f32, 9>, index: i32 }; // 3 vertices with 3 coordinates each, don't use vec3 due to 16 byte alignment
+struct TrigP2 { p: array<f32, 18>, index: i32 };
+
+struct ClippingTrig {
+  nr: u32,            // volume element number
+  lam: array<f32, 9>, // 3 vertices with 3 barycentric coordinates each
+};

ngsolve_webgpu-0.0.1.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: ngsolve_webgpu
+Version: 0.0.1
+Summary: WebGPU/Pyodide based rendering tools for Netgen/NGSolve
+Author-email: Matthias Hochsteger <mhochsteger@cerbsim.com>, Christopher Lackner <clackner@cerbsim.com>
+License-Expression: LGPL-2.1-or-later
+Keywords: WebGPU,compute shaders,graphics,Python,NGSolve,FEM,Netgen
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file