@woosh/meep-engine 2.33.36 → 2.33.37

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -122,6 +122,7 @@ export class VGThreeRenderer {
         // clear contexts
         const contexts = this.__contexts_array;
         const context_count = contexts.length;
+
         for (let i = 0; i < context_count; i++) {
             const ctx = contexts[i];
 
@@ -142,8 +143,11 @@ export class VGThreeRenderer {
             }
         };
 
-        for (let i = 0; i < this.__inputs.length; i++) {
-            const input_object = this.__inputs[i];
+        const inputs = this.__inputs;
+        const input_count = inputs.length;
+
+        for (let i = 0; i < input_count; i++) {
+            const input_object = inputs[i];
 
             input_object.traverse(processObject);
         }

package/engine/graphics/particles/node-based/rendering/billboard/ParticleBillboardShader.js

@@ -42,7 +42,7 @@ export const ParticleBillboardShader = {
                 
                 #ifdef DEPTH_SOFT_ENABLED
 			    
-				vFadeDistance = 1.0 / radius;
+				    vFadeDistance = 1.0 / radius;
 				
 				#endif
                 				

package/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js

@@ -17,9 +17,9 @@ const CHUNK_LAMBERT_LIGHTING = `
 vec3 diffuse = vec3( 1.0 );
 
 GeometricContext geometry;
-geometry.position = mvPosition.xyz;
+geometry.position = -vViewPosition;
 geometry.normal = normalize( transformedNormal );
-geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
+geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -vViewPosition.xyz );
 
 GeometricContext backGeometry;
 backGeometry.position = geometry.position;
@@ -156,28 +156,11 @@ function make_vertex_shader() {
                 varying vec2 vRotationMultiplier;
                 varying float vBlending;
                 
-                
                 #if defined(LIGHTS_ENABLED)
-                    #include <common>
-                    #include <bsdfs>
-                    #include <lights_pars_begin>
-                    
-                    struct LambertMaterial {
-                        vec3 diffuseColor;
-                    };
-                    
-                    void RE_Direct_Lambert( const in IncidentLight directLight, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
-                        vec3 irradiance = directLight.color;
-                        reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
-                    }
-                    
-                    void RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
-                        reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
-                    }
-                    
-                    #define RE_Direct				RE_Direct_Lambert
-                    #define RE_IndirectDiffuse		RE_IndirectDiffuse_Lambert
+                    varying vec3 vViewPosition;
                 #endif
+                    
+                
                 
                 void main() {
                    
@@ -194,10 +177,11 @@ function make_vertex_shader() {
                     
                     #if defined(LIGHTS_ENABLED)
                         vec4 mvPosition = modelViewMatrix * position4;
-                        vec3 vViewPosition = -mvPosition.xyz;
+                        vViewPosition = -mvPosition.xyz;
                         
                         vec3 transformedNormal = vec3(0.0,0.0,1.0);
-                    #else
+                        
+                        #include <worldpos_vertex>
                     #endif
                     
                     gl_Position = modelViewProjectionMatrix * position4;
@@ -222,7 +206,6 @@ function make_vertex_shader() {
                             
                         }
                     #endif
-                    //
                     
                     vRotationMultiplier = vec2( cos(rotationGlobal),sin(rotationGlobal) );
                     
@@ -238,30 +221,6 @@ function make_vertex_shader() {
                     
                     gl_PointSize = projected_radius;
                 
-                    #if defined(LIGHTS_ENABLED)
-                        vec3 vLightFront;
-                        vec3 vIndirectFront;
-                        
-                        #include <worldpos_vertex>
-                        ${CHUNK_LAMBERT_LIGHTING}
-                        
-                        LambertMaterial material = LambertMaterial(vColor.rgb);
-                        
-                        ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-                        vec3 totalEmissiveRadiance = vec3(0.0);
-                        
-                        reflectedLight.indirectDiffuse += vIndirectFront;
-                        reflectedLight.indirectDiffuse *= BRDF_Lambert( vColor.rgb );
-                        
-                        reflectedLight.directDiffuse = vLightFront;
-                        reflectedLight.directDiffuse *= BRDF_Lambert( vColor.rgb ); // shadowmask goes here
-                        
-                        //@injection_point FORWARD_PLUS:accumulation
-                        
-                        vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
-                        
-                        vColor.rgb = outgoingLight;
-                    #endif
                     
                 }`;
 }
@@ -276,6 +235,10 @@ function make_fragment_shader() {
                 uniform float cameraFar;
                 uniform mat4 modelViewMatrix;
                 uniform mat4 projectionMatrix;
+                      
+                uniform mat4 uProjectionInverse;
+                uniform mat4 uViewInverse;
+                
                 uniform vec2 resolution;
                 
                 varying float vFadeDistance;
@@ -285,7 +248,6 @@ function make_fragment_shader() {
                 varying vec2 vRotationMultiplier;
                 varying float vBlending;
                 
-                
                 out highp vec4 pc_fragColor;
                 
                 float depthToLinear( float z ) {
@@ -334,6 +296,58 @@ function make_fragment_shader() {
                     return zFade;
                 }
                 
+                
+                #if defined(LIGHTS_ENABLED)
+                
+                    vec3 computeWorldPositionFromFragmentPosition(vec3 coord){
+                         vec4 ndc = vec4(
+                        (coord.x - 0.5) * 2.0,
+                        (coord.y - 0.5) * 2.0,
+                        (coord.z - 0.5) * 2.0,
+                        1.0);
+                    
+                        vec4 clip = uProjectionInverse * ndc;
+                        return (uViewInverse* (clip / clip.w) ).xyz;
+                    }
+                
+                    vec3 construct_spherical_normal_from_point_coord(vec2 coord){
+                        float x = coord.x * 2.0 - 1.0;
+                        float y = coord.y * 2.0 - 1.0; // note we flip Y
+                    
+                        float z = sqrt(1.0 - clamp(x*x + y*y, 0.0, 1.0));
+                    
+                        
+                        vec3 position = vec3(x, -y, z);
+                    
+                        vec3 normal = normalize(position);
+                        
+                        return normal;
+                    }
+                
+                    #include <common>
+                    #include <bsdfs>
+                    #include <lights_pars_begin>
+                    
+                    struct LambertMaterial {
+                        vec3 diffuseColor;
+                    };
+                    
+                    void RE_Direct_Lambert( const in IncidentLight directLight, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
+                        float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
+                        vec3 irradiance =  dotNL * directLight.color;
+                        reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+                    }
+                    
+                    void RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
+                        reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+                    }
+                    
+                    #define RE_Direct				RE_Direct_Lambert
+                    #define RE_IndirectDiffuse		RE_IndirectDiffuse_Lambert
+                    
+                    varying vec3 vViewPosition;
+                #endif
+                
                 void main() {
                     float fragmentDepth = gl_FragCoord.z;
                     
@@ -365,6 +379,37 @@ function make_fragment_shader() {
                     
                     vec4 texel = spriteColor * vColor;
                     
+                    #if defined(LIGHTS_ENABLED)
+                        // compute world position
+                        vec3 v_world_position = computeWorldPositionFromFragmentPosition(gl_FragCoord.xyz);
+               
+                
+                        vec3 vLightFront;
+                        vec3 vIndirectFront;
+                        
+                        vec3 transformedNormal = construct_spherical_normal_from_point_coord(gl_PointCoord.xy);
+                        
+                        ${CHUNK_LAMBERT_LIGHTING}
+                        
+                        LambertMaterial material = LambertMaterial(texel.rgb);
+                        
+                        ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
+                        vec3 totalEmissiveRadiance = vec3(0.0);
+                        
+                        reflectedLight.indirectDiffuse += vIndirectFront;
+                        reflectedLight.indirectDiffuse *= BRDF_Lambert( texel.rgb );
+                        
+                        reflectedLight.directDiffuse = vLightFront;
+                        reflectedLight.directDiffuse *= BRDF_Lambert( texel.rgb ); // shadowmask goes here
+                        
+                        //@injection_point FORWARD_PLUS:accumulation
+                        
+                        vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
+                        
+                        texel.rgb = outgoingLight;
+                    #endif
+                                    
+                    
                     // premultiply alpha
                     texel.xyz *= texel.a;
                     
@@ -379,9 +424,8 @@ function make_fragment_shader() {
                         texel *= zFade;
                     
                     #endif
-                                    
-                    pc_fragColor = texel;
                     
+                    pc_fragColor = texel;
                 }`;
 }
 
@@ -426,7 +470,9 @@ export function make_particle_billboard_shader({ lights = false } = {}) {
         resolution: {
             type: 'v2',
             value: new ThreeVector2()
-        }
+        },
+        uViewInverse: { type: 'm4', value: new Matrix4() },
+        uProjectionInverse: { type: 'm4', value: new Matrix4() },
     };
 
     if (lights) {
@@ -439,8 +485,7 @@ export function make_particle_billboard_shader({ lights = false } = {}) {
             DEPTH_READ_ENABLED: true,
             DEPTH_SOFT_ENABLED: true,
             ALIGN_DIRECTION_ENABLED: false,
-            LIGHTS_ENABLED: lights,
-            LIGHTING_VERTEX_ONLY: true
+            LIGHTS_ENABLED: lights
         },
         uniforms: uniforms,
         vertexShader: make_vertex_shader(),

package/engine/graphics/particles/particular/engine/shader/ShaderManager.js

@@ -189,7 +189,9 @@ export class ShaderManager {
             },
             cameraFar: {
                 value: 0
-            }
+            },
+            uViewInverse: { type: 'm4', value: new Matrix4() },
+            uProjectionInverse: { type: 'm4', value: new Matrix4() },
         };
 
         // debugAtlas(this.spriteAtlas.atlas, { scale: new Vector2(1, 1) });
@@ -396,6 +398,9 @@ export class ShaderManager {
         uniforms.modelViewMatrix.value = modelViewMatrix;
         uniforms.cameraNear.value = cameraNear;
         uniforms.cameraFar.value = cameraFar;
+
+        uniforms.uProjectionInverse.value.copy(camera.projectionMatrixInverse);
+        uniforms.uViewInverse.value.copy(camera.matrixWorld);
     }
 
     /**

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.js

@@ -123,6 +123,7 @@ export class ParticleVolume {
             "softDepth": true,
             "depthSort": false,
             "velocityAlign": false,
+            "receiveLight": true,
             "blendingMode": 0,
             "layers": [
                 {

package/engine/graphics/render/forward_plus/cluster/compute_light_data_hash_0.js

@@ -13,5 +13,5 @@ export function compute_light_data_hash_0(nodes, count) {
         hash = hash * 31 + datum;
     }
 
-    return hash & 0x7fffffff;
+    return hash >>> 0;
 }

package/engine/graphics/render/forward_plus/materials/fp_build_fragment_shader.js

@@ -15,10 +15,8 @@ const accumulation_pars = `
 const preamble = `
     ${FP_SHADER_CHUNK_PREAMBLE}
     
-    varying vec3 v_world_position;
     
-    out highp vec4 pc_fragColor;
-    #define gl_FragColor pc_fragColor
+    
     `;
 
 /**
@@ -27,7 +25,22 @@ const preamble = `
  * @returns {string}
  */
 export function fp_build_fragment_shader(base) {
-    let result = preamble + base;
+    let result = preamble;
+
+    if (base.indexOf('v_world_position') === -1) {
+        result = result + `
+        varying vec3 v_world_position;
+        `;
+    }
+
+    if (base.indexOf('#define gl_FragColor') === -1 && base.indexOf('pc_fragColor') === -1) {
+        result = result + `
+            out highp vec4 pc_fragColor;
+            #define gl_FragColor pc_fragColor
+            `;
+    }
+
+    result = result + base
 
     result = insert_after(result, '#include <lights_pars_begin>', FP_SHADER_CHUNK_DECODE_PARS);
 

package/engine/graphics/render/forward_plus/plugin/ForwardPlusRenderingPlugin.js

@@ -40,7 +40,7 @@ export class ForwardPlusRenderingPlugin extends EnginePlugin {
     async startup() {
         const lm = this.__light_manager;
 
-        lm.setTileMapResolution(16, 8, 10);
+        lm.setTileMapResolution(16, 8, 8);
 
         const graphics = this.engine.graphics;
 

package/engine/graphics/render/visibility/VisibilityComputer.js

@@ -9,6 +9,12 @@ const frustum = new Frustum();
  */
 const objectFilters = [];
 
+/**
+ *
+ * @type {function[]}
+ */
+const objectFilterExecutors = [];
+
 export const SOURCE_RENDER_LAYER_PROPERTY = '@meep-render-layer';
 
 export class VisibilityComputer {
@@ -135,12 +141,6 @@ export class VisibilityComputer {
         // clear visible set
         // this.__output.initializeUpdate();
 
-        /**
-         *
-         * @type {function[]}
-         */
-        const objectFilterExecutors = [];
-
         const filters = this.filters;
         const filterCount = filters.length;
 
@@ -151,7 +151,7 @@ export class VisibilityComputer {
 
             if (f.enabled && f.layerPredicate(layer)) {
                 objectFilters[objectFilterCount] = f;
-                objectFilterExecutors.push(f.objectPredicateExecute);
+                objectFilterExecutors[objectFilterCount] = f.objectPredicateExecute;
 
                 objectFilterCount++;
             }
@@ -165,6 +165,7 @@ export class VisibilityComputer {
             f.objectPredicateInitialize(this.__view.camera);
         }
 
+        objectFilterExecutors.length = objectFilterCount;
 
         layer.buildVisibleSet(this.__frustums, objectFilterExecutors, this.__includeObject, this);
 

package/engine/graphics/shaders/TerrainShader.js

@@ -366,27 +366,27 @@ function fragment() {
         gl_FragColor  = vec4( outgoingLight, diffuseColor.a );
       
         #if defined( TONE_MAPPING )
-            gl_FragColor.rgb = toneMapping( pc_fragColor.rgb );
+            gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
         #endif
         
         //encode fragment
-        pc_fragColor = linearToOutputTexel( pc_fragColor );
+        gl_FragColor = linearToOutputTexel( gl_FragColor );
         #ifdef USE_FOG
             #ifdef FOG_EXP2
                 float fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );
             #else
                 float fogFactor = smoothstep( fogNear, fogFar, fogDepth );
             #endif
-            gl_FragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
+            gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
         #endif
         
         #ifdef PREMULTIPLIED_ALPHA
             // Get get normal blending with premultipled, use with CustomBlending, OneFactor, OneMinusSrcAlphaFactor, AddEquation.
-            gl_FragColor.rgb *= pc_fragColor.a;
+            gl_FragColor.rgb *= gl_FragColor.a;
         #endif
         
         #ifdef DITHERING
-            pc_fragColor.rgb = dithering( pc_fragColor.rgb );
+            gl_FragColor.rgb = dithering( gl_FragColor.rgb );
         #endif
     }
     `;

package/engine/graphics/shadows/testShadowMapRendering.js

@@ -0,0 +1,192 @@
+import { EngineHarness } from "../../EngineHarness.js";
+import { loadSerializedScene } from "../../scene/SerializedScene.js";
+import { EngineConfiguration } from "../../EngineConfiguration.js";
+import { MeshSystem } from "../ecs/mesh/MeshSystem.js";
+import GUIElementSystem from "../../ecs/gui/GUIElementSystem.js";
+import HeadsUpDisplaySystem from "../../ecs/gui/hud/HeadsUpDisplaySystem.js";
+import TagSystem from "../../ecs/systems/TagSystem.js";
+import { AttachmentSocketsSystem } from "../../ecs/sockets/AttachmentSocketsSystem.js";
+import { AttachmentSystem } from "../../ecs/attachment/AttachmentSystem.js";
+import { SoundEmitterSystem } from "../../sound/ecs/emitter/SoundEmitterSystem.js";
+import SoundControllerSystem from "../../sound/ecs/SoundControllerSystem.js";
+import SoundListenerSystem from "../../sound/ecs/SoundListenerSystem.js";
+import AnimationSystem from "../../ecs/systems/AnimationSystem.js";
+import TopDownCameraControllerSystem from "../ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { CameraSystem } from "../ecs/camera/CameraSystem.js";
+import ClingToTerrainSystem from "../../ecs/terrain/ecs/ClingToTerrainSystem.js";
+import TerrainSystem from "../../ecs/terrain/ecs/TerrainSystem.js";
+import Trail2DSystem from "../ecs/trail2d/Trail2DSystem.js";
+import { Foliage2System } from "../../ecs/foliage/ecs/Foliage2System.js";
+import ViewportPositionSystem from "../../ecs/gui/position/ViewportPositionSystem.js";
+import SynchronizePositionSystem from "../../ecs/systems/SynchronizePositionSystem.js";
+import InputControllerSystem from "../../input/ecs/systems/InputControllerSystem.js";
+import { InputSystem } from "../../input/ecs/systems/InputSystem.js";
+import MeshHighlightSystem from "../ecs/highlight/system/MeshHighlightSystem.js";
+import LightSystem from "../ecs/light/LightSystem.js";
+import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { SerializationMetadataSystem } from "../../ecs/systems/SerializationMetadataSystem.js";
+import { PathDisplaySystem } from "../ecs/path/PathDisplaySystem.js";
+import { ParticleEmitterSystem } from "../particles/ecs/ParticleEmitterSystem.js";
+import { ShadedGeometrySystem } from "../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { ArrayBufferLoader } from "../../asset/loaders/ArrayBufferLoader.js";
+import { initializeGameBinarySerializationRegistry } from "../../../../model/game/GameBinarySerializationRegistry.js";
+import WaterSystem from "../ecs/water/WaterSystem.js";
+import Army from "../../../../model/game/ecs/component/army/Army.js";
+import Mesh from "../ecs/mesh/Mesh.js";
+import EntityBuilder from "../../ecs/EntityBuilder.js";
+import { buildCanvasViewFromTexture } from "../render/visibility/hiz/buildCanvasViewFromTexture.js";
+import ViewportPosition from "../../ecs/gui/position/ViewportPosition.js";
+import Vector2 from "../../../core/geom/Vector2.js";
+import GUIElement from "../../ecs/gui/GUIElement.js";
+import { enableEditor } from "../../../editor/enableEditor.js";
+import { SerializationMetadata } from "../../ecs/components/SerializationMetadata.js";
+
+const eh = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {EngineConfiguration}
+ */
+function makeConfig(engine) {
+
+    const config = new EngineConfiguration();
+
+    /**
+     *
+     * @type {SoundEngine}
+     */
+    const sound = engine.sound;
+    const graphics = engine.graphics;
+    const assetManager = engine.assetManager;
+    const devices = engine.devices;
+
+    // graphics.renderer.shadowMap.type = BasicShadowMap;
+
+    const guiSystem = new GUIElementSystem(engine.gui.view, engine);
+    const headsUpDisplaySystem = new HeadsUpDisplaySystem(graphics);
+
+    config.addLoader('arraybuffer', new ArrayBufferLoader());
+
+    initializeGameBinarySerializationRegistry(engine.binarySerializationRegistry);
+
+    config.addManySystems(
+        new TagSystem(),
+        new AttachmentSocketsSystem(),
+        new AttachmentSystem(),
+        new SoundEmitterSystem(assetManager, sound.destination, sound.context),
+        new SoundControllerSystem(),
+        new SoundListenerSystem(sound.context),
+        guiSystem,
+        new AnimationSystem(graphics.viewport.size),
+        new TopDownCameraControllerSystem(graphics),
+        new CameraSystem(graphics.scene, graphics),
+        new MeshSystem(engine),
+        new ClingToTerrainSystem(),
+        new TerrainSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
+        new Foliage2System(assetManager, graphics),
+        new ViewportPositionSystem(graphics.viewport.size),
+        new SynchronizePositionSystem(),
+        new InputControllerSystem(devices),
+        new InputSystem(devices),
+        new MeshHighlightSystem(engine),
+        new LightSystem(engine, {
+            shadowResolution: 2048
+        }),
+        headsUpDisplaySystem,
+        new BehaviorSystem(engine),
+        new SerializationMetadataSystem(),
+        new PathDisplaySystem(engine),
+        new ParticleEmitterSystem(engine),
+        new ShadedGeometrySystem(engine),
+        new WaterSystem(graphics)
+    );
+
+
+    // Knowledge
+
+    return config;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function get_three_light(engine) {
+
+    return engine.graphics.scene.children.find(l => l.isDirectionalLight);
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function init_shadowmap_preview(engine) {
+    const ecd = engine.entityManager.dataset;
+
+    const graphics = engine.graphics;
+    const preview = buildCanvasViewFromTexture({
+        width: 512,
+        height: 512,
+        renderer: graphics.renderer,
+        texture: null
+    });
+
+    graphics.on.postOpaquePass.add(() => {
+
+        const light = get_three_light(engine);
+
+        if (light !== undefined) {
+            preview.texture = light.shadow.map.texture;
+
+            preview.render();
+        }
+    });
+
+
+    new EntityBuilder()
+        .add(ViewportPosition.fromJSON({
+            offset: new Vector2(10, 10)
+        }))
+        .add(GUIElement.fromView(preview.view))
+        .add(SerializationMetadata.Transient)
+        .build(ecd);
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {Promise<void>}
+ */
+async function main(engine) {
+
+    const ecd = engine.entityManager.dataset;
+    await loadSerializedScene('data/levels/character_creation/level.bin', ecd, engine);
+
+
+    const character = ecd.getAnyComponent(Army);
+
+    const entity = EntityBuilder.readFromDataset(character.entity, ecd);
+
+    entity.getComponent(Mesh).url = "data/models/Conqueror Mech/Conqueror Mech.gltf";
+
+    init_shadowmap_preview(engine);
+
+    window.light = get_three_light(engine);
+}
+
+async function init(engineHarness) {
+
+    const engine = await engineHarness.initialize();
+
+    const config = makeConfig(engine);
+
+    await config.apply(engine);
+
+    enableEditor(engine);
+
+    main(engine);
+}
+
+init(eh);

package/package.json

@@ -5,8 +5,9 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.36",
+  "version": "2.33.37",
   "dependencies": {
+    "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",
     "simplex-noise": "2.4.0",

package/view/elements/ColorPickerView.js

@@ -1,8 +1,9 @@
-import { hsv2rgb, rgb2hsv } from "../../core/color/ColorUtils.js";
 import GuiControl from "../controller/controls/GuiControl.js";
 import { GaugeView } from "../../editor/view/ecs/components/color/GaugeView.js";
 import Vector1 from "../../core/geom/Vector1.js";
 import { drawCheckers } from "../../editor/view/ecs/components/particles/ColorParameterLUTController.js";
+import { hsv2rgb } from "../../core/color/hsv2rgb.js";
+import { rgb2hsv } from "../../core/color/rgb2hsv.js";
 
 
 export class ColorPickerView extends GuiControl {