ngsolve-webgpu 0.0.4__tar.gz → 0.0.5__tar.gz

{ngsolve_webgpu-0.0.4/ngsolve_webgpu.egg-info → ngsolve_webgpu-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngsolve_webgpu
-Version: 0.0.4
+Version: 0.0.5
 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

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/docs/functions.ipynb

@@ -75,6 +75,19 @@
    "id": "8cea4e67-8bb6-4b10-8d13-696b0064cbef",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "from ngsolve_webgpu.cf import FieldLines\n",
+    "cf = CF((-y,x,0.1))\n",
+    "fieldlines = FieldLines(cf, mesh)\n",
+    "scene = Draw([fieldlines])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f7356d5f-1a45-48e1-815b-e11ff0461f17",
+   "metadata": {},
+   "outputs": [],
    "source": []
   }
  ],

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.4'
-__version_tuple__ = version_tuple = (0, 0, 4)
+__version__ = version = '0.0.5'
+__version_tuple__ = version_tuple = (0, 0, 5)

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/cf.py

@@ -6,6 +6,7 @@ import numpy as np
 from webgpu.clipping import Clipping
 from webgpu.colormap import Colormap
 from webgpu.renderer import Renderer, RenderOptions, check_timestamp
+from webgpu.shapes import ShapeRenderer, generate_cylinder
 from webgpu.utils import (
     BufferBinding,
     UniformBinding,
@@ -178,8 +179,16 @@ class FunctionData:
         return self.mesh_data.num_elements
 
     @property
-    def curvature_subdivision(self):
-        return self.mesh_data.curvature_subdivision
+    def subdivision(self):
+        return self.mesh_data.subdivision
+
+    @property
+    def curvature_data(self):
+        return self.mesh_data.curvature_data
+
+    @property
+    def deformation_data(self):
+        return self.mesh_data.deformation_data
 
     def _create_data(self):
         self.gpu_2d = None
@@ -280,6 +289,7 @@ class CFRenderer(MeshElements2d):
             self.colormap.set_min_max(self.data.minval, self.data.maxval, set_autoscale=False)
         self.colormap._update_and_create_render_pipeline(options)
         self.component_buffer = buffer_from_array(np.array([self.component], np.int32))
+        self.shader_defines["MAX_EVAL_ORDER"] = self.data.order
 
     def get_bounding_box(self):
         return self.data.get_bounding_box()
@@ -359,3 +369,54 @@ class VectorCFRenderer(VectorRenderer):
             [values[:, 0], values[:, 1], np.zeros_like(values[:, 0])], dtype=np.float32
         ).T.reshape(-1)
         super().update(options)
+
+
+class FieldLines(ShapeRenderer):
+    def __init__(
+        self,
+        cf,
+        start_region: ngs.Region | ngs.Mesh,
+        num_lines: int = 100,
+        length: float = 0.5,
+        max_points_per_line: float = 500,
+        thickness: float = 0.0015,
+        tolerance: float = 0.0005,
+        direction: int = 0,
+    ):
+        self.fieldline_options = {
+            "thickness": thickness,
+            "num_lines": num_lines,
+            "length": length,
+            "max_points_per_line": max_points_per_line,
+            "tolerance": tolerance,
+            "direction": direction,
+        }
+        self.cf = cf
+        if isinstance(start_region, ngs.Mesh):
+            self.mesh = start_region
+            self.start_region = start_region.Materials(".*")
+        else:
+            self.start_region = start_region
+            self.mesh = start_region.mesh
+
+        bbox = self.mesh.ngmesh.bounding_box
+        thickness = (bbox[1] - bbox[0]).Norm() * thickness
+
+        cyl = generate_cylinder(8, thickness, 1.0, top_face=False, bottom_face=False)
+
+        super().__init__(cyl, None, None)
+        self.scale_mode = ShapeRenderer.SCALE_Z
+
+    def get_bounding_box(self):
+        pmin, pmax = self.mesh.ngmesh.bounding_box
+        return ([pmin[0], pmin[1], pmin[2]], [pmax[0], pmax[1], pmax[2]])
+
+    def update(self, options):
+        from ngsolve.webgui import FieldLines
+
+        data = FieldLines(self.cf, self.start_region, **self.fieldline_options)
+        self.positions = data["pstart"]
+        self.directions = data["pend"]
+        self.directions = self.directions - self.positions
+        self.values = data["value"]
+        super().update(options)

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/geometry.py

@@ -71,7 +71,6 @@ class BaseGeometryRenderer(Renderer):
 
 class GeometryFaceRenderer(BaseGeometryRenderer):
     n_vertices: int = 3
-    depthBias: int = 1
     clipping: Clipping | None = None
 
     def __init__(self, geo):
@@ -93,7 +92,7 @@ class GeometryFaceRenderer(BaseGeometryRenderer):
     def update(self, options, vis_data):
         self.bounding_box = (vis_data["min"], vis_data["max"])
         verts = vis_data["vertices"]
-        self.n_instances = len(verts) // 6
+        self.n_instances = len(verts) // 9
         normals = vis_data["normals"]
         indices = vis_data["indices"]
         if self.colors is None:
@@ -122,11 +121,15 @@ class GeometryEdgeRenderer(BaseGeometryRenderer):
     topology: PrimitiveTopology = PrimitiveTopology.triangle_strip
     clipping: Clipping | None = None
 
+    # make sure that edges are rendered on top of faces
+    depthBias: int = -5
+    depthBiasSlopeScale: int = -5
+
     def __init__(self, geo):
         self.geo = geo
         super().__init__(label="GeometryEdges")
         self.active = True
-        self.thickness = 0.02
+        self.thickness = 0.015
         self._buffers = {}
 
     def set_colors(self, colors):
@@ -160,7 +163,6 @@ class GeometryEdgeRenderer(BaseGeometryRenderer):
 class GeometryVertexRenderer(BaseGeometryRenderer):
     n_vertices: int = 4
     topology: PrimitiveTopology = PrimitiveTopology.triangle_strip
-    depthBias: int = 0
     clipping: Clipping | None = None
 
     def __init__(self, geo):
@@ -214,7 +216,6 @@ class GeometryRenderer(MultipleRenderer):
 
     def update(self, options: RenderOptions):
         vis_data = self.geo._visualizationData()
-        self.bounding_box = (vis_data["min"] + 1e-7, vis_data["max"] - 1e-7)
 
         for ro in self.render_objects:
             ro.update(options, vis_data)
@@ -222,7 +223,9 @@ class GeometryRenderer(MultipleRenderer):
         self.canvas = options.canvas
 
     def get_bounding_box(self):
-        return self.bounding_box
+        pmin, pmax = self.geo.shape.bounding_box
+        return ([pmin[0], pmin[1], pmin[2]],
+                [pmax[0], pmax[1], pmax[2]])
 
     def render(self, encoder):
         for r in self.render_objects:

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/jupyter.py

@@ -107,6 +107,7 @@ def Draw(
     order: int = 2,
     vectors=None,
     deformation=None,
+    subdivision: int | None = None,
     **kwargs,
 ):
     """
@@ -171,7 +172,10 @@ def Draw(
             render_objects.append(vcf)
 
     if deformation:
-        mesh_data.deformation_data = FunctionData(mesh_data, deformation, order=order)
+        mesh_data.deformation_data = FunctionData(mesh_data, deformation, order=min(order, 3))
+
+    if subdivision is not None:
+        mesh_data.subdivision = subdivision
 
     scene = wj.Draw(render_objects, width, height)
     if dim == 3:

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/mesh.py

@@ -1,6 +1,8 @@
 from enum import Enum
+
 import netgen.meshing
 import numpy as np
+from webgpu.clipping import Clipping
 from webgpu.font import Font
 from webgpu.renderer import Renderer, RenderOptions, check_timestamp
 
@@ -9,13 +11,12 @@ from webgpu.uniforms import UniformBase, ct
 from webgpu.utils import (
     BufferBinding,
     UniformBinding,
-    read_shader_file,
     buffer_from_array,
-    uniform_from_array,
     get_device,
+    read_shader_file,
+    uniform_from_array,
 )
 from webgpu.webgpu_api import *
-from webgpu.clipping import Clipping
 
 
 class Binding:
@@ -27,7 +28,7 @@ class Binding:
     VERTICES = 12
     TRIGS_INDEX = 13
     CURVATURE_VALUES_2D = 14
-    CURVATURE_SUBDIVISION = 15
+    SUBDIVISION = 15
     DEFORMATION_VALUES = 16
     DEFORMATION_SCALE = 17
 
@@ -95,7 +96,7 @@ class MeshData:
     num_elements: dict[str | ElType, int]
     elements: dict[str | ElType, np.ndarray]
     gpu_elements: dict[str | ElType, Buffer]
-    curvature_subdivision: int
+    subdivision: int
 
     mesh: netgen.meshing.Mesh
     curvature_data = None
@@ -121,7 +122,7 @@ class MeshData:
         self.num_elements = {}
         self.elements = {}
         self.gpu_elements = {}
-        self.curvature_subdivision = None
+        self.subdivision = None
         self._deformation_scale = 1
 
     @property
@@ -227,27 +228,34 @@ class MeshData:
         if self.deformation_data is not None:
             curve_order = max(curve_order, self.deformation_data.order)
         if curve_order > 1:
-            from .cf import FunctionData
             import ngsolve as ngs
 
+            from .cf import FunctionData
+
             cf = ngs.CF((ngs.x, ngs.y, ngs.z))
             self.curvature_data = FunctionData(self, cf, curve_order)
         else:
-            if self.curvature_subdivision is None:
-                self.curvature_subdivision = 1
-        if self.curvature_subdivision is None:
+            if self.subdivision is None:
+                self.subdivision = 1
+        if self.subdivision is None:
             deformation_order = 1
             if self.deformation_data:
                 deformation_order = self.deformation_data.order
-            subdiv = max(curve_order, deformation_order)
-            if subdiv > 1:
-                subdiv *= 2
-            self.curvature_subdivision = subdiv
+            order = max(curve_order, deformation_order)
+            if order > 3:
+                subdiv = (order + 2) // 3 + 1
+            elif order > 1:
+                subdiv = 3
+            else:
+                subdiv = 1
+            self.subdivision = subdiv
 
         self._last_mesh_timestamp = mesh._timestamp
 
     def get_bounding_box(self):
-        return (self.pmin, self.pmax)
+        pmin, pmax = self.mesh.bounding_box
+        return ([pmin[0], pmin[1], pmin[2]],
+                [pmax[0], pmax[1], pmax[2]])
 
     def get_buffers(self):
         for eltype in self.elements:
@@ -255,10 +263,10 @@ class MeshData:
                 self.gpu_elements[eltype] = buffer_from_array(
                     self.elements[eltype], label="mesh_" + str(eltype)
                 )
-        if "curvature_subdivision" not in self.gpu_elements:
-            self.gpu_elements["curvature_subdivision"] = uniform_from_array(
-                np.array([self.curvature_subdivision], dtype=np.uint32),
-                label="curvature_subdivision",
+        if "subdivision" not in self.gpu_elements:
+            self.gpu_elements["subdivision"] = uniform_from_array(
+                np.array([self.subdivision], dtype=np.uint32),
+                label="subdivision",
             )
         if "deformation_scale" not in self.gpu_elements:
             self.gpu_elements["deformation_scale"] = uniform_from_array(
@@ -283,8 +291,8 @@ class MeshElements2d(Renderer):
     def update(self, options: RenderOptions):
         self.clipping.update(options)
         self.data.update(options)
-        self.curvature_subdivision = self.data.curvature_subdivision
-        self.n_vertices = 3 * self.curvature_subdivision**2
+        self.subdivision = self.data.subdivision
+        self.n_vertices = 3 * self.subdivision**2
 
         self._buffers = self.data.get_buffers()
         self.n_instances = self.data.num_elements[ElType.TRIG]
@@ -292,6 +300,14 @@ class MeshElements2d(Renderer):
             np.array(self.color, dtype=np.float32), label="color_uniform"
         )
 
+        order = 1
+        if self.data.curvature_data:
+            order = max(order, self.data.curvature_data.order)
+        if self.data.deformation_data:
+            order = max(order, self.data.deformation_data.order)
+
+        self.shader_defines = {"MAX_EVAL_ORDER": 1, "MAX_EVAL_ORDER_VEC3": order + 1}
+
     def get_bounding_box(self):
         return self.data.get_bounding_box()
 
@@ -303,7 +319,7 @@ class MeshElements2d(Renderer):
             BufferBinding(Binding.CURVATURE_VALUES_2D, self._buffers["curvature_2d"]),
             BufferBinding(Binding.DEFORMATION_VALUES, self._buffers["deformation_2d"]),
             UniformBinding(Binding.DEFORMATION_SCALE, self._buffers["deformation_scale"]),
-            UniformBinding(Binding.CURVATURE_SUBDIVISION, self._buffers["curvature_subdivision"]),
+            UniformBinding(Binding.SUBDIVISION, self._buffers["subdivision"]),
         ]
         if hasattr(self, "color_uniform"):
             bindings.append(BufferBinding(54, self.color_uniform))
@@ -315,6 +331,7 @@ class MeshElements2d(Renderer):
 
 class MeshWireframe2d(MeshElements2d):
     depthBias: int = 0
+    depthBiasSlopeScale: float = 0.
     topology: PrimitiveTopology = PrimitiveTopology.line_strip
     color = (0, 0, 0, 1)
     fragment_entry_point: str = "fragmentWireframe2d"
@@ -322,7 +339,7 @@ class MeshWireframe2d(MeshElements2d):
 
     def update(self, options: RenderOptions):
         super().update(options)
-        self.n_vertices = 3 * self.curvature_subdivision + 1
+        self.n_vertices = 3 * self.subdivision + 1
 
 
 class El3dUniform(UniformBase):

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/shaders/eval/common.wgsl

@@ -1,7 +1,7 @@
 @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(15) var<uniform> u_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;

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/shaders/eval/trig.wgsl

@@ -1,11 +1,14 @@
 #import ngsolve/eval/common
 
+const N_DOFS_TRIG: u32 = (@MAX_EVAL_ORDER@+1) * (@MAX_EVAL_ORDER@ + 2) / 2;
+const N_DOFS_TRIG_VEC3: u32 = (@MAX_EVAL_ORDER_VEC3@+1) * (@MAX_EVAL_ORDER_VEC3@ + 2) / 2;
+
 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>;
+    var v: array<f32, N_DOFS_TRIG>;
     let offset: u32 = ndof * id * ncomp + VALUES_OFFSET;
     let stride: u32 = ncomp;
 
@@ -40,9 +43,9 @@ fn evalTrig(data: ptr<storage, array<f32>, read>, id: u32, icomp: i32, lam: vec2
     return v[0];
 }
 
-fn _evalTrigVec3Data(order: i32, data: array<vec3f, 28>, lam: vec2f, dy: i32) -> vec3f {
+fn _evalTrigVec3Data(order: i32, data: array<vec3f, N_DOFS_TRIG_VEC3>, lam: vec2f, dy: i32) -> vec3f {
     let b = vec3f(lam.x, lam.y, 1.0 - lam.x - lam.y);
-    var v: array<vec3f, 28> = data;
+    var v: array<vec3f, N_DOFS_TRIG_VEC3> = data;
 
     for (var n = order; n > 0; n--) {
         var i0 = 0;
@@ -62,7 +65,7 @@ fn evalTrigVec3(data: ptr<storage, array<f32>, read>, id: u32, lam: vec2<f32>) -
     let ncomp: u32 = u32((*data)[0]);
     var ndof: u32 = u32((order + 1) * (order + 2) / 2);
 
-    var v: array<vec3f, 28>;
+    var v: array<vec3f, N_DOFS_TRIG_VEC3>;
     let offset: u32 = ndof * id * ncomp + VALUES_OFFSET;
     let stride: u32 = ncomp;
 
@@ -81,7 +84,7 @@ fn evalTrigVec3Grad(data: ptr<storage, array<f32>, read>, id: u32, lam: vec2<f32
     var ndof: u32 = u32((order + 1) * (order + 2) / 2);
     let dy = order + 1;
 
-    var v: array<vec3f, 28>;
+    var v: array<vec3f, N_DOFS_TRIG_VEC3>;
     let offset: u32 = ndof * id * ncomp + VALUES_OFFSET;
     let stride: u32 = ncomp;
 
@@ -94,12 +97,12 @@ fn evalTrigVec3Grad(data: ptr<storage, array<f32>, read>, id: u32, lam: vec2<f32
     var result: mat3x3<f32>;
 
     result[0] = _evalTrigVec3Data(order, v, lam, dy);
-    var vd: array<vec3f, 28>;
+    var vd: array<vec3f, N_DOFS_TRIG_VEC3>;
 
     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];
+            vd[i0 + ix] = v[i0 + ix] - v[i0 + ix + dy - iy];
         }
         i0 += dy - iy;
     }
@@ -109,7 +112,7 @@ fn evalTrigVec3Grad(data: ptr<storage, array<f32>, read>, id: u32, lam: vec2<f32
     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];
+            vd[i0 + ix] = v[i0 + ix + 1] - v[i0 + ix + dy - iy];
         }
         i0 += dy - iy;
     }

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/shaders/geo_edge.wgsl

@@ -23,19 +23,35 @@ fn vertex_main(@builtin(vertex_index) vertId: u32,
   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>;
+
+  // thick lines in screen space, 
+  // see https://www.iquilezles.org/www/articles/thicklines/thicklines.htm
+  var tp1 = cameraMapPoint(p1);
+  var tp2 = cameraMapPoint(p2);
+  var sp1 = tp1.xy/tp1.w;
+  var sp2 = tp2.xy/tp2.w;
+  sp1.x *= u_camera.aspect;
+  sp2.x *= u_camera.aspect;
+  let v = normalize(sp2 - sp1);
+  var normal = vec2<f32>(-v.y, v.x) * u_thickness * 0.5;
+  normal.x = normal.x / u_camera.aspect;
+  var pos : vec4<f32>;
   if(vertId == 0) {
-    pos = vec4<f32>(tp1.xy + (-0.5*v.xy + v2) * u_thickness/2.*tp1.w, tp1.zw); }
+    pos = tp1;
+    normal = -normal;
+  }
   else if(vertId == 1) {
-    pos = vec4<f32>(tp1.xy + (-0.5*v.xy + - v2) * u_thickness/2.*tp1.w, tp1.zw); }
+    pos = tp1;
+  }
   else if(vertId == 2) {
-    pos = vec4<f32>(tp2.xy + (0.5*v.xy + v2) * u_thickness/2.*tp2.w, tp2.zw); }
+    pos = tp2;
+    normal = -normal;
+  }
   else {
-    pos = vec4<f32>(tp2.xy + (0.5*v.xy - v2) * u_thickness/2.*tp2.w, tp2.zw); }
+    pos = tp2;
+  }
+
+  pos = vec4<f32>(pos.xy + normal*pos.w, pos.zw);
   
   return GeoEdgeInput(pos, u_indices[instanceId]);
 }

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5}/ngsolve_webgpu/shaders/shader.wgsl

@@ -38,7 +38,7 @@ fn vertexEdgeP1(@builtin(vertex_index) vertexId: u32, @builtin(instance_index) e
 }
 
 fn calcTrig(p: array<vec3<f32>, 3>, vertexId: u32, trigId: u32) -> VertexOutput2d {
-    let subdivision = u_curvature_subdivision;
+    let subdivision = u_subdivision;
     let h = 1.0 / f32(subdivision);
 
     var lam = vec2f(0.0, 0.0);
@@ -51,14 +51,16 @@ fn calcTrig(p: array<vec3<f32>, 3>, vertexId: u32, trigId: u32) -> VertexOutput2
 
     if subdivision == 1 {
         position = p[vertexId];
-        normal = cross(p[1] - p[0], p[2] - p[0]);
         if (u_deformation_values_2d[0] != -1.) {
           let pos_and_gradients = u_deformation_scale * evalTrigVec3Grad(&u_deformation_values_2d, trigId, lam);
-          position += pos_and_gradients[0];
-          var v1 = p[1] - p[0] + pos_and_gradients[1];
-          var v2 = p[2] - p[0] + pos_and_gradients[2];
+          position += u_deformation_scale * pos_and_gradients[0];
+          var v1 = p[0] - p[2] + u_deformation_scale * pos_and_gradients[1];
+          var v2 = p[1] - p[2] + u_deformation_scale * pos_and_gradients[2];
           normal = normalize(cross(v1, v2));
         }
+        else {
+          normal = cross(p[1] - p[0], p[2] - p[0]);
+        }
     } else {
         var subTrigId: u32 = vertexId / 3u;
         var ix = subTrigId % subdivision;
@@ -115,46 +117,43 @@ fn vertexWireframe2d(@builtin(vertex_index) vertexId: u32, @builtin(instance_ind
         vec3<f32>(vertices[vid[2] ], vertices[vid[2] + 1], vertices[vid[2] + 2])
     );
 
-    let subdivision = u_curvature_subdivision;
+    let subdivision = u_subdivision;
     let h = 1./ f32(subdivision);
     var lam = vec2f(0.0, 0.0);
     var position: vec3f;
+    var side = vertexId / subdivision;
+    if (side >= 2u) {
+      side = 2u;
+    }
+    var subId = vertexId - subdivision * side;
+    if(side == 0u)
+      {
+        lam[0] = h * f32(subId);
+        lam[1] = 0.;
+      }
+    else {
+      if(side == 1u)
+      {
+        lam[0] = 1.0 - h * f32(subId);
+        lam[1] = h * f32(subId);
+      }
+    else
+      {
+        lam[0] = 0.;
+        lam[1] = 1. - h * f32(subId);
+      }
+    }
     if(subdivision == 1)
       {
-        position = p[vertexId % 3];
-        if (u_deformation_values_2d[0] != -1.) {
-          position += u_deformation_scale * evalTrigVec3(&u_deformation_values_2d, trigId, lam);
-        }
+        position = p[(vertexId+2)%3u];
       }
     else
       {
-        var side = vertexId / subdivision;
-        if (side >= 2u) {
-          side = 2u;
-        }
-        var subId = vertexId - subdivision * side;
-        if(side == 0u)
-          {
-            lam[0] = h * f32(subId);
-            lam[1] = 0.;
-          }
-        else {
-          if(side == 1u)
-          {
-            lam[0] = 1.0 - h * f32(subId);
-            lam[1] = h * f32(subId);
-          }
-        else
-          {
-            lam[0] = 0.;
-            lam[1] = 1. - h * f32(subId);
-          }
-        }
         position = evalTrigVec3(&u_curvature_values_2d, trigId, lam);
-        if (u_deformation_values_2d[0] != -1.) {
-          position += u_deformation_scale * evalTrigVec3(&u_deformation_values_2d, trigId, lam);
-        }
       }
+    if (u_deformation_values_2d[0] != -1.) {
+      position += u_deformation_scale * evalTrigVec3(&u_deformation_values_2d, trigId, lam);
+    }
     return VertexOutput2d(cameraMapPoint(position), position, lam, trigId,
                           normalize(cross(p[1] - p[0], p[2] - p[0])));
 }

{ngsolve_webgpu-0.0.4 → ngsolve_webgpu-0.0.5/ngsolve_webgpu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngsolve_webgpu
-Version: 0.0.4
+Version: 0.0.5
 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