@woosh/meep-engine 2.109.10 → 2.109.12

package/src/engine/graphics/sh3/gi/material/common.glsl

@@ -62,11 +62,22 @@ vec3[9] lpv_probe_getData(uint probe_index) {
     return result;
 }
 
+float sign_not_zero(float x) {
+    return x >= 0.0 ? 1.0 : -1.0;
+}
+
+vec2 sign_not_zero(vec2 x) {
+    return vec2(
+        sign_not_zero(x.x),
+        sign_not_zero(x.y)
+    );
+}
+
 vec3 sign_not_zero(vec3 x) {
     return vec3(
-        x.x >= 0.0 ? 1.0 : -1.0,
-        x.y >= 0.0 ? 1.0 : -1.0,
-        x.z >= 0.0 ? 1.0 : -1.0
+        sign_not_zero(x.x),
+        sign_not_zero(x.y),
+        sign_not_zero(x.z)
     );
 }
 
@@ -93,40 +104,17 @@ vec4 quadBlendWieghts(vec2 coords)
     return res;
 }
 
-//vec2 VecToSphereOct(vec3 direction)
-//{
-//    vec3 octant = sign_not_zero(direction);
-//
-//    //  |x| + |y| + |z| = 1
-//    float sum = dot(direction, octant);
-//    vec3 octahedron = direction / sum;
-//
-//    if (direction.z < 0.0)
-//    {
-//        vec3 absolute = abs(octahedron);
-//
-//        octahedron.xy = octant.xy * vec2(1.0f - absolute.y, 1.0f - absolute.x);
-//    }
-//
-//    return octahedron.xy;
-//}
-
-vec2 VecToSphereOct(vec3 direction)
+vec2 VecToSphereOct(vec3 v)
 {
-    vec3 octant = sign_not_zero(direction);
-
-    //  |x| + |y| + |z| = 1
-    float sum = dot(direction, octant);
-    vec3 octahedron = direction / sum;
+    float l1norm = abs(v.x) + abs(v.y) + abs(v.z);
 
-    if (direction.y < 0.0)
-    {
-        vec3 absolute = abs(octahedron);
+    vec2 result = v.xz / l1norm;
 
-        octahedron.xz = octant.xz * vec2(1.0f - absolute.z, 1.0f - absolute.x);
+    if (v.y < 0.0) {
+        result = (1.0 - abs(result.yx)) * sign_not_zero(result.xy);
     }
 
-    return octahedron.xz;
+    return result;
 }
 
 float SampleBlended(sampler2D tex, vec2 uv0, vec2 uv1, vec2 uv2, vec4 weights) {
@@ -138,7 +126,7 @@ float SampleBlended(sampler2D tex, vec2 uv0, vec2 uv1, vec2 uv2, vec4 weights) {
     return samp0 * weights.x + samp1 * weights.y + samp2 * weights.z;
 }
 
-vec2 lpv_probe_getDepth(uint probe_index, vec3 direction) {
+vec2 lpv_probe_getDepthTriangular(uint probe_index, vec3 direction) {
     // get offset
     uint depth_tile_resolution = lpv_u_probe_depth_resolution;
     uvec2 atlas_size = uvec2(4096u);
@@ -176,12 +164,70 @@ vec2 lpv_probe_getDepth(uint probe_index, vec3 direction) {
     float samp1 = texelFetch(lpv_t_probe_depth, ivec2(frame1), 0).r;
     float samp2 = texelFetch(lpv_t_probe_depth, ivec2(frame2), 0).r;
 
-    float mean = samp0 * weights.x + samp1 * weights.y + samp2 * weights.z;
-    float mean2 = samp0 * samp0 * weights.x + samp1 * samp1 * weights.y + samp2 * samp2 * weights.z;
+    float d0 = samp0 * weights.x;
+    float d1 = samp1 * weights.y;
+    float d2 = samp2 * weights.z;
+
+    float mean = d0 + d1 + d2;
+    float mean2 = samp0 * d0 + samp1 * d1 + samp2 * d2;
 
     return vec2(mean, mean2);
 }
 
+float lpv_bilinear_lerp(float v00, float v01, float v10, float v11, vec2 fraction) {
+
+    float x0 = mix(v00, v01, fraction.x);
+    float x1 = mix(v10, v11, fraction.x);
+
+    return mix(x0, x1, fraction.y);
+}
+
+vec2 lpv_sample_bilinear(sampler2D tex, ivec2 texel_position, vec2 fraction) {
+
+    float texel_00 = texelFetch(tex, texel_position, 0).r;
+    float texel_01 = texelFetch(tex, texel_position + ivec2(1, 0), 0).r;
+    float texel_10 = texelFetch(tex, texel_position + ivec2(0, 1), 0).r;
+    float texel_11 = texelFetch(tex, texel_position + ivec2(1, 1), 0).r;
+
+    return vec2(
+        lpv_bilinear_lerp(
+        texel_00, texel_01,
+        texel_10, texel_11,
+        fraction
+    ),
+        lpv_bilinear_lerp(
+            texel_00*texel_00, texel_01*texel_01,
+            texel_10*texel_10, texel_11*texel_11,
+            fraction
+        )
+    );
+}
+
+vec2 lpv_probe_getDepthBilinear(uint probe_index, vec3 direction) {
+    // get offset
+    uint depth_tile_resolution = lpv_u_probe_depth_resolution;
+    uvec2 atlas_size = uvec2(4096u);
+
+    uint tiles_per_row = atlas_size.x / depth_tile_resolution;
+
+    uint tile_x = probe_index % tiles_per_row;
+    uint tile_y = probe_index / tiles_per_row;
+
+    vec2 tile_offset = vec2(
+        tile_x * depth_tile_resolution,
+        tile_y * depth_tile_resolution
+    );
+
+    // convert direction to UV
+    vec2 octahedral_uv = clamp(VecToSphereOct(direction) * 0.5 + 0.5, 0.0, 1.0);
+    vec2 grid = octahedral_uv * vec2(depth_tile_resolution - 1u);
+
+    vec2 gridFrac = fract(grid);
+    vec2 gridFloor = floor(grid);
+
+    return lpv_sample_bilinear(lpv_t_probe_depth, ivec2(gridFloor+tile_offset),gridFrac);
+}
+
 vec3 lpv_probe_getPosition(uint probe_index) {
     return texelFetch(lpv_t_probe_positions, lpv_index_to_256_coordinate(probe_index), 0).rgb;
 }
@@ -219,15 +265,15 @@ in uint tet_guess,
 out uint tet_index,
 out vec4 weights
 ) {
-    uint came_from = 0u;
-
     tet_index = tet_guess;
 
     for (uint i = 0u; i < SEARCH_STEP_LIMIT; i++) {
 
         weights = lpv_mesh_getBarycentricCoordinates(tet_index, position);
 
+        // Check if we're in the current "best guess" tetrahedron
         if (weights.x >= 0.0 && weights.y >= 0.0 && weights.z >= 0.0 && weights.w >= 0.0) {
+            // success
             return;
         }
 
@@ -246,12 +292,6 @@ out vec4 weights
             next_tet = neighbors[3];
         }
 
-        if (next_tet == came_from) {
-            // numerical instability caused us to oscillate on the boundary
-            return;
-        }
-
-        came_from = tet_index;
         tet_index = next_tet;
     }
 
@@ -262,13 +302,13 @@ float lpv_probe_getVisibilityMask(vec3 position, uint probe_index) {
 
     vec3 probe_position = lpv_probe_getPosition(probe_index);
 
-    vec3 local_probe_offset = probe_position - position;
+    vec3 local_probe_offset = position - probe_position;
 
     float distToProbe = length(local_probe_offset);
 
-    vec3 direction = normalize(local_probe_offset);
+    vec3 direction = local_probe_offset / distToProbe;
 
-    vec2 temp = lpv_probe_getDepth(probe_index, direction);
+    vec2 temp = lpv_probe_getDepthBilinear(probe_index, direction);
 
     float mean = temp.x;
     float variance = abs(mean * mean - temp.y);
@@ -280,7 +320,7 @@ float lpv_probe_getVisibilityMask(vec3 position, uint probe_index) {
     float chebyshevWeight = variance / (variance + distance_delta * distance_delta);
 
     // Increase contrast in the weight
-//    chebyshevWeight = max(chebyshevWeight*chebyshevWeight*chebyshevWeight, 0.0);
+    chebyshevWeight = max(chebyshevWeight * chebyshevWeight * chebyshevWeight, 0.0);
 
     return (distToProbe <= mean) ? 1.0 : chebyshevWeight;
 }
@@ -299,35 +339,6 @@ vec4 lvp_mask_weights_by_visibility_by_depth(vec3 position, uint tet_index, vec4
     return visibility * weights;
 }
 
-float lpv_probe_visibility_weight(uint probe_index, vec3 position, vec3 normal) {
-    float weight = 1.0;
-
-    vec3 probe_position = lpv_probe_getPosition(probe_index);
-
-    vec3 direction_to_probe = normalize(probe_position - position);
-
-    // Smooth backface test
-
-
-    // The naive soft backface weight would ignore a probe when
-    // it is behind the surface. That's good for walls. But for small details inside of a
-    // room, the normals on the details might rule out all of the probes that have mutual
-    // visibility to the point. So, we instead use a "wrap shading" test below inspired by
-    // NPR work.
-    // weight *= max(0.0001, dot(direction_to_probe, normal));
-
-    // The small offset at the end reduces the "going to zero" impact
-    // where this is really close to exactly opposite
-    float backface_term = max(0.0001, (dot(direction_to_probe, normal) + 1.0) * 0.5);
-    weight *= backface_term * backface_term + 0.2;
-
-    weight *= lpv_probe_getVisibilityMask(position, probe_index);
-
-    // Avoid zero weight
-    weight = max(0.000001, weight);
-
-    return weight;
-}
 
 vec4 lvp_mask_weights_by_visibility_by_normal(vec3 position, vec3 normal, uint tet_index, vec4 weights) {
 
@@ -346,16 +357,92 @@ vec4 lvp_mask_weights_by_visibility_by_normal(vec3 position, vec3 normal, uint t
     return visibility * weights;
 }
 
-vec4 lvp_mask_weights_by_visibility(vec3 position, vec3 normal, uint tet_index) {
+
+/** Slightly bump the location of the shadow test point away from the shadow casting surface.
+    The shadow casting surface is the boundary for shadow, so the nearer an imprecise value is
+    to it the more the light leaks.
+*/
+#define LPV_NORMAL_BIAS 0.01f
+
+vec4 lvp_mask_weights_by_visibility(in vec3 position, in vec3 normal, in vec3 view_direction, in uint tet_index, in vec4 barycentric) {
 
     uvec4 vertices = lpv_mesh_getVertices(tet_index);
 
     vec4 visibility;
 
-    for (int i = 0; i < 4; i++) {
-        visibility[i] = lpv_probe_visibility_weight(vertices[i], position, normal);
+    // Bias the position at which visibility is computed; this
+    // avoids performing a shadow test *at* a surface, which is a
+    // dangerous location because that is exactly the line between
+    // shadowed and unshadowed. If the normal bias is too small,
+    // there will be light and dark leaks. If it is too large,
+    // then samples can pass through thin occluders to the other
+    // side (this can only happen if there are MULTIPLE occluders
+    // near each other, a wall surface won't pass through itself.)
+    vec3 lookup_position = position + (normal - view_direction * 3.0) * LPV_NORMAL_BIAS;
+
+    float weight_sum = 0.0;
+
+    for (uint i = 0u; i < 4u; i++) {
+
+        float weight = 1.0;
+
+        uint probe_index = vertices[i];
+
+        vec3 probe_position = lpv_probe_getPosition(probe_index);
+
+
+        // Smooth backface test
+        {
+
+            // Computed without the biasing applied to the "dir" variable.
+            // This test can cause reflection-map looking errors in the image
+            // (stuff looks shiny) if the transition is poor.
+            vec3 direction_to_probe = normalize(probe_position - position);
+
+            // The naive soft backface weight would ignore a probe when
+            // it is behind the surface. That's good for walls. But for small details inside of a
+            // room, the normals on the details might rule out all of the probes that have mutual
+            // visibility to the point. So, we instead use a "wrap shading" test below inspired by
+            // NPR work.
+            //             weight *= max(0.0001, dot(direction_to_probe, normal));
+
+            // The small offset at the end reduces the "going to zero" impact
+            // where this is really close to exactly opposite
+            float backface_term = max(0.0001, (dot(direction_to_probe, normal) + 1.0) * 0.5);
+            weight *= backface_term * backface_term + 0.2;
+
+        }
+
+        // Moment visibility test (depth)
+        {
+
+            weight *= lpv_probe_getVisibilityMask(lookup_position, probe_index);
+
+        }
+
+
+        // A tiny bit of light is really visible due to log perception, so
+        // crush tiny weights but keep the curve continuous. This must be done
+        // before the trilinear weights, because those should be preserved.
+        const float crushThreshold = 0.2;
+
+        if (weight < crushThreshold) {
+            weight *= weight * weight * (1.0 / (crushThreshold * crushThreshold));
+        }
+
+        // Avoid zero weight
+        weight = max(0.000001, weight);
+
+        weight *= barycentric[i];
+
+        weight_sum += weight;
+
+        visibility[i] = weight;
     }
 
+    // normalize
+    visibility /= weight_sum;
+
     return visibility;
 }
 
@@ -420,8 +507,8 @@ vec4 lpv_renormalize_weights(in vec4 source) {
 
     float sum = source.x + source.y + source.z + source.w;
 
-    if (sum <= 0.0) {
-        return vec4(1.0);
+    if (sum <= 0.0001) {
+        return vec4(0.0);
     }
 
     return source / sum;
@@ -430,12 +517,6 @@ vec4 lpv_renormalize_weights(in vec4 source) {
 
 
 
-/** Slightly bump the location of the shadow test point away from the shadow casting surface.
-    The shadow casting surface is the boundary for shadow, so the nearer an imprecise value is
-    to it the more the light leaks.
-*/
-#define LPV_NORMAL_BIAS 0.01f
-
 vec3 lpv_sample_irradiance(vec3 position, vec3 normal, vec3 view_direction) {
 
     // Bias the position at which visibility is computed; this
@@ -457,16 +538,11 @@ vec3 lpv_sample_irradiance(vec3 position, vec3 normal, vec3 view_direction) {
     uint nearest_tet = lpv_guess_initial_tet(lookup_position);
 
     uint tet;
-    vec4 weights;
-    lpv_walk_to_tetrahedron(lookup_position, nearest_tet, tet, weights);
+    vec4 barycentric_coordinates;
+    lpv_walk_to_tetrahedron(lookup_position, nearest_tet, tet, barycentric_coordinates);
 
     // apply visibility term
-    //    weights = lvp_mask_weights_by_visibility_by_depth(lookup_position, tet, weights);
-    //    weights = lvp_mask_weights_by_visibility_by_normal(lookup_position,normal, tet, weights);
-    weights *= lvp_mask_weights_by_visibility(lookup_position, normal, tet);
-
-    // re-normalize weights
-    weights = lpv_renormalize_weights(weights);
+    vec4 weights = lvp_mask_weights_by_visibility(lookup_position, normal, view_direction, tet, barycentric_coordinates);
 
     if (tet == INVALID_TET) {
         // do nothing

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Irradiance field representation
+ * @see "Irradiance Volumes" by G.Greger, 1998
+ */
 export class LightProbeVolume {
     get version(): number;
     clear(): void;

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAED,mCAEC;IAED,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAnL+B,wDAAwD;2BAC7D,mCAAmC"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAED,mCAEC;IAED,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAvL+B,wDAAwD;2BAC7D,mCAAmC"}

package/src/engine/graphics/sh3/lpv/LightProbeVolume.js

@@ -8,6 +8,10 @@ import { Transform } from "../../../ecs/transform/Transform.js";
 import { sh3_make_shaded_geometry } from "../visualise_spherical_harmonic_sphere.js";
 
 
+/**
+ * Irradiance field representation
+ * @see "Irradiance Volumes" by G.Greger, 1998
+ */
 export class LightProbeVolume {
     #version = 0;
 

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bake_octahedral_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QAuChB"}
+{"version":3,"file":"bake_octahedral_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js"],"names":[],"mappings":"AAkBA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QAmFhB"}

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js

@@ -3,9 +3,17 @@ import {
     decode_octahedron_to_unit
 } from "../../../../../../core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js";
 import { Ray3 } from "../../../../../../core/geom/3d/Ray3.js";
+import { v3_distance } from "../../../../../../core/geom/vec3/v3_distance.js";
+import { v3_dot } from "../../../../../../core/geom/vec3/v3_dot.js";
+import { clamp01 } from "../../../../../../core/math/clamp01.js";
+import { PI_HALF } from "../../../../../../core/math/PI_HALF.js";
 
 const scratch_ray = new Ray3();
 
+/**
+ *
+ * @type {number[]}
+ */
 const ray_hit = [];
 
 /**
@@ -29,6 +37,20 @@ export function bake_octahedral_depth_map(
     scratch_ray.tMax = max_depth;
     array_copy(position, position_offset, scratch_ray, 0, 3);
 
+
+    /**
+     * Resolution bias is to compensate for discontinuities between samples
+     * The lower the resolution - the higher the discontinuities
+     * This is heights of an arch on a unit sphere, where arch spans 1/resolution angle
+     * Half-PI is to get the height at midpoint of the arch
+     * x2 is to get error over the entire circle, as the previous term only gets us to semicircle
+     * xMath.SQRT2 is to allow for diagonals between pixels
+     * @type {number}
+     */
+    const RESOLUTION_BIAS = Math.sin(PI_HALF / resolution) * 2 * Math.SQRT2;
+
+    const NORMAL_BIAS = max_depth * 0.01;
+
     const ray_direction = scratch_ray.direction;
 
     for (let oct_x = 0; oct_x < resolution; oct_x++) {
@@ -47,6 +69,36 @@ export function bake_octahedral_depth_map(
             if (distance < 0) {
                 // no hit
                 distance = max_depth;
+            } else {
+                const surface_normal_x = ray_hit[3];
+                const surface_normal_y = ray_hit[4];
+                const surface_normal_z = ray_hit[5];
+
+                const surface_position_x = ray_hit[0];
+                const surface_position_y = ray_hit[1];
+                const surface_position_z = ray_hit[2];
+
+                // check for possible miss
+                const hit_angle_cos = -v3_dot(
+                    surface_normal_x, surface_normal_y, surface_normal_z,
+                    ray_direction[0], ray_direction[1], ray_direction[2]
+                );
+
+                const resolution_bias_offset = distance * RESOLUTION_BIAS;
+
+                const hit_normal_bias = -clamp01(1 - hit_angle_cos) * NORMAL_BIAS;
+
+                // sink the contact into the surface along the hit normal
+                const biased_hit_x = surface_position_x + surface_normal_x * hit_normal_bias;
+                const biased_hit_y = surface_position_y + surface_normal_y * hit_normal_bias;
+                const biased_hit_z = surface_position_z + surface_normal_z * hit_normal_bias;
+
+                distance = v3_distance(
+                    scratch_ray[0], scratch_ray[1], scratch_ray[2],
+                    biased_hit_x, biased_hit_y, biased_hit_z
+                );
+
+                distance += resolution_bias_offset;
             }
 
             const pixel_index = oct_y * resolution + oct_x;

package/src/engine/graphics/sh3/prototypeSH3Probe.js

@@ -327,6 +327,7 @@ async function main(engine) {
 
     await EngineHarness.buildBasics({
         engine,
+        showFps: false,
         enableWater: false,
         enableTerrain: false,
         enableLights: false,
@@ -380,8 +381,8 @@ async function main(engine) {
     // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
     // const path = 'data/models/sibenik/3-window-less/model.gltf';
     // const path = 'data/models/samples/gi_box_01/model.glb';
-    // const path = 'data/models/sponza-pbr/gltf/sponza.glb';
-    const path = 'data/models/pica_pica/pica_pica.gltf';
+    const path = 'data/models/sponza-pbr/gltf/sponza.glb';
+    // const path = 'data/models/pica_pica/pica_pica.gltf';
 
     const mesh_asset = await engine.assetManager.promise(path, 'model/gltf+json');
     const gltf = mesh_asset.gltf;
@@ -409,8 +410,7 @@ async function main(engine) {
         const sg = n.entity.getComponent(ShadedGeometry);
 
         if (sg !== null) {
-            sg.writeFlag(ShadedGeometryFlags.CastShadow, true);
-            sg.writeFlag(ShadedGeometryFlags.ReceiveShadow, true);
+            sg.writeFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow, true);
         }
     });
 

package/src/core/model/node-graph/DataType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/DataType.js"],"names":[],"mappings":"AAEA;IAyDI;;;;OAIG;IACH,yBAFa,QAAQ,CAQpB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAQpB;IAjFD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;;OAIG;IACH,QAHW,MAAM,QACN,MAAM,QAQhB;IAED,eAEC;IAED;;;aAEC;IAgCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}

package/src/core/model/node-graph/DataType.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataType.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/DataType.spec.js"],"names":[],"mappings":""}

package/src/core/model/node-graph/ParametricDataType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParametricDataType.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/ParametricDataType.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IAyCI;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,eACN,QAAQ,EAAE,sBAUpB;IArDD;;;OAGG;IACH,YAFU,QAAQ,EAAE,CAEJ;IAGhB;;;;;OAKG;IACH,QAJW,MAAM,QACN,MAAM,eACN,QAAQ,EAAE,QAMpB;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAQnB;IAED,eAEC;IAED,uBAEC;CAgBJ;yBA7DwB,eAAe"}