@woosh/meep-engine 2.40.1 → 2.41.0

package/engine/graphics/impostors/octahedral/shader/glsl/common.glsl

@@ -0,0 +1,206 @@
+struct ImposterData
+{
+    vec2 uv;
+    vec2 grid;
+    vec4 frame0;
+    vec4 frame1;
+    vec4 frame2;
+    vec4 vertex;
+};
+
+struct Ray
+{
+    vec3 Origin;
+    vec3 Direction;
+};
+
+//for hemisphere
+vec3 OctaHemiEnc(vec2 coord)
+{
+    coord = vec2(coord.x + coord.y, coord.x - coord.y) * 0.5;
+    vec3 vec = vec3(coord.x, 1.0 - dot(vec2(1.0, 1.0), abs(coord.xy)), coord.y);
+    return vec;
+}
+//for sphere
+vec3 OctaSphereEnc(vec2 coord)
+{
+    vec3 vec = vec3(coord.x, 1.0 - dot(vec2(1.0), abs(coord)), coord.y);
+    if (vec.y < 0.0)
+    {
+        vec2 flip = vec.xz >= 0.0 ? vec2(1.0, 1.0) : vec2(-1.0, -1.0);
+        vec.xz = (1-abs(vec.zx)) * flip;
+    }
+    return vec;
+}
+
+vec3 GridToVector(vec2 coord)
+{
+    vec3 vec;
+    if (_ImposterFullSphere)
+    {
+        vec = OctaSphereEnc(coord);
+    }
+    else
+    {
+        vec = OctaHemiEnc(coord);
+    }
+    return vec;
+}
+
+//for hemisphere
+vec2 VecToHemiOct(vec3 vec)
+{
+    vec.xz /= dot(1.0, abs(vec));
+    return vec2(vec.x + vec.z, vec.x - vec.z);
+}
+
+vec2 VecToSphereOct(vec3 vec)
+{
+    vec.xz /= dot(1, abs(vec));
+    if (vec.y <= 0)
+    {
+        vec2 flip = vec.xz >= 0 ? vec2(1, 1) : vec2(-1, -1);
+        vec.xz = (1-abs(vec.zx)) * flip;
+    }
+    return vec.xz;
+}
+
+vec2 VectorToGrid(vec3 vec)
+{
+    vec2 coord;
+
+    if (_ImposterFullSphere)
+    {
+        coord = VecToSphereOct(vec);
+    }
+    else
+    {
+        vec.y = max(0.001, vec.y);
+        vec = normalize(vec);
+        coord = VecToHemiOct(vec);
+    }
+    return coord;
+}
+
+vec3 SpriteProjection(vec3 pivotToCameraRayLocal, float frames, vec2 size, vec2 coord){
+    vec3 gridVec = pivotToCameraRayLocal;
+
+    //octahedron vector, pivot to camera
+    vec3 y = normalize(gridVec);
+
+    vec3 x = normalize(cross(y, vec3(0.0, 1.0, 0.0)));
+    vec3 z = normalize(cross(x, y));
+
+    vec2 uv = ((coord*frames)-0.5) * 2.0;//-1 to 1
+
+    vec3 newX = x * uv.x;
+    vec3 newZ = z * uv.y;
+
+    vec2 halfSize = size*0.5;
+
+    newX *= halfSize.x;
+    newZ *= halfSize.y;
+
+    vec3 res = newX + newZ;
+
+    return res;
+}
+
+vec4 TriangleInterpolate(vec2 uv){
+    uv = frac(uv);
+
+    vec2 omuv = vec2(1.0, 1.0) - uv.xy;
+
+    vec4 res = vec4(0, 0, 0, 0);
+    //frame 0
+    res.x = min(omuv.x, omuv.y);
+    //frame 1
+    res.y = abs(dot(uv, vec2(1.0, -1.0)));
+    //frame 2
+    res.z = min(uv.x, uv.y);
+    //mask
+    res.w = saturate(ceil(uv.x-uv.y));
+
+    return res;
+}
+
+//frame and framecout, returns
+vec3 FrameXYToRay(vec2 frame, vec2 frameCountMinusOne)
+{
+    //divide frame x y by framecount minus one to get 0-1
+    vec2 f = frame.xy / frameCountMinusOne;
+
+    //bias and scale to -1 to 1
+    f = (f-0.5)*2.0;
+
+    //convert to vector, either full sphere or hemi sphere
+    vec3 vec = GridToVector(f);
+
+    vec = normalize(vec);
+
+    return vec;
+}
+
+vec3 ITBasis(vec3 vec, vec3 basedX, vec3 basedY, vec3 basedZ)
+{
+    return vec3(dot(basedX, vec), dot(basedY, vec), dot(basedZ, vec));
+}
+
+vec3 FrameTransform(vec3 projRay, vec3 frameRay, out vec3 worldX, out vec3 worldZ)
+{
+    //TODO something might be wrong here
+    worldX = normalize(vec3(-frameRay.z, 0, frameRay.x));
+    worldZ = normalize(cross(worldX, frameRay));
+
+    projRay *= -1.0;
+
+    vec3 local = normalize(ITBasis(projRay, worldX, frameRay, worldZ));
+    return local;
+}
+
+
+vec4 ImposterBlendWeights(sampler2D tex, vec2 uv, vec2 frame0, vec2 frame1, vec2 frame2, vec4 weights, vec2 ddxy)
+{
+    vec4 samp0 = tex2Dgrad(tex, frame0, ddxy.x, ddxy.y);
+    vec4 samp1 = tex2Dgrad(tex, frame1, ddxy.x, ddxy.y);
+    vec4 samp2 = tex2Dgrad(tex, frame2, ddxy.x, ddxy.y);
+
+    //vec4 samp0 = tex2Dlod( tex, float4(frame0,0,0) );
+    //vec4 samp1 = tex2Dlod( tex, float4(frame1,0,0) );
+    //vec4 samp2 = tex2Dlod( tex, float4(frame2,0,0) );
+
+    vec4 result = samp0*weights.x + samp1*weights.y + samp2*weights.z;
+
+    return result;
+}
+
+vec2 VirtualPlaneUV(vec3 planeNormal, vec3 planeX, vec3 planeZ, vec3 center, vec2 uvScale, Ray rayLocal){
+    float normalDotOrigin = dot(planeNormal, rayLocal.Origin);
+    float normalDotCenter = dot(planeNormal, center);
+    float normalDotRay = dot(planeNormal, rayLocal.Direction);
+
+    float planeDistance = normalDotOrigin-normalDotCenter;
+    planeDistance *= -1.0;
+
+    float intersect = planeDistance / normalDotRay;
+
+    vec3 intersection = ((rayLocal.Direction * intersect) + rayLocal.Origin) - center;
+
+    float dx = dot(planeX, intersection);
+    float dz = dot(planeZ, intersection);
+
+    vec2 uv = vec2(0, 0);
+
+    if (intersect > 0)
+    {
+        uv = vec2(dx, dz);
+    }
+    else
+    {
+        uv = vec2(0, 0);
+    }
+
+    uv /= uvScale;
+    uv += vec2(0.5, 0.5);
+    return uv;
+}

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -1,6 +1,6 @@
 import { HashMap } from "../../../core/collection/HashMap.js";
-import { computeGeometryHash } from "../../asset/loaders/geometry/geometry/computeGeometryHash.js";
-import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
+import { computeGeometryHash } from "../geometry/buffered/computeGeometryHash.js";
+import { computeGeometryEquality } from "../geometry/buffered/computeGeometryEquality.js";
 import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
 import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
 import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -3,8 +3,8 @@ import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
 import { Cache } from "../../../../core/cache/Cache.js";
-import { computeGeometryHash } from "../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
-import { computeGeometryEquality } from "../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
+import { computeGeometryHash } from "../../geometry/buffered/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../geometry/buffered/computeGeometryEquality.js";
 import { CachedAsyncMap } from "../../../../core/collection/map/CachedAsyncMap.js";
 import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteHashMap.js";
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";

package/engine/graphics/particles/node-based/codegen/CodeGenerator.js

@@ -14,6 +14,6 @@ export class CodeGenerator {
                  uniforms
              }) {
 
-
+        throw new Error('Not Implemented');
     }
 }

package/engine/graphics/particles/node-based/nodes/noise/CurlNoiseNode.js

@@ -24,7 +24,7 @@ export class CurlNoiseNode extends ShaderNode {
                 ],
                 ParticleDataTypes.Vector3
             )
-        ))
+        ));
     }
 
     generate_code(instance, output, context, port_variables) {

package/engine/graphics/render/visibility/hiz/buildCanvasViewFromTexture.js

@@ -11,6 +11,9 @@ import {
 } from "three";
 import CheckersTexture from "../../../texture/CheckersTexture.js";
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../../../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import { formatToChannelCount } from "../../../texture/formatToChannelCount.js";
+import { glsl_gen_swizzled_read } from "../../../shaders/glsl_gen_swizzled_read.js";
+import { assert } from "../../../../../core/assert.js";
 
 
 /**
@@ -44,8 +47,19 @@ function sampleTexel(texture, name, uv) {
 /**
  *
  * @param {THREE.Texture} texture
+ * @param {number} [alpha_override] will force specified alpha value in output, useful for cases where alpha would be 0 otherwise
+ * @param {(string|number)[]} swizzle allows us to re-arrange pixels as they are being written out
  */
-function makeShader(texture) {
+function makeShader({ texture, alpha_override, swizzle }) {
+    let _swizzle = swizzle.slice();
+
+    const texture_channel_count = formatToChannelCount(texture.format);
+
+    if (texture_channel_count < 4) {
+        // no override specified, and alpha would be 0, force it to one to make image visible
+        _swizzle[4] = 1;
+    }
+
     return new ShaderMaterial({
 
         vertexShader: /* glsl */`
@@ -68,11 +82,7 @@ function makeShader(texture) {
 		void main() {
 
 			vec4 texel = ${sampleTexel(texture, 'tDiffuse', 'vUv')};
-			gl_FragColor = texel;
-			
-			gl_FragColor.a = 1.0;
-			// gl_FragColor.r *= 255.0;
-
+			gl_FragColor = ${glsl_gen_swizzled_read('texel', swizzle)};
 		}`,
         uniforms: {
 
@@ -88,7 +98,8 @@ function makeShader(texture) {
  * @param {number} width
  * @param {THREE.Texture} texture
  * @param {THREE.WebGLRenderer} renderer
- * @param flipY
+ * @param {boolean} [flipY]
+ * @param {(string|number)[]} [swizzle]
  * @return {{view: View, render: function}}
  */
 export function buildCanvasViewFromTexture({
@@ -96,9 +107,18 @@ export function buildCanvasViewFromTexture({
                                                width = texture.image.width,
                                                height = texture.image.height,
                                                renderer,
-                                               flipY = true
+                                               flipY = true,
+                                               swizzle = ['r', 'g', 'b', 'a']
                                            }) {
+
+    assert.isArray(swizzle, 'swizzle');
+
     const canvasView = new CanvasView();
+    canvasView.css({
+        position: 'absolute',
+        left: 0,
+        top: 0
+    });
     canvasView.size.set(width, height);
 
     const ctx = canvasView.context2d;
@@ -137,7 +157,7 @@ export function buildCanvasViewFromTexture({
      */
     function getShader() {
         if (__texture_cached !== texture || copyShader === null) {
-            copyShader = makeShader(texture);
+            copyShader = makeShader({ texture: texture, swizzle });
 
             copyShader.side = DoubleSide;
             copyShader.uniforms.tDiffuse.value = texture;
@@ -154,6 +174,8 @@ export function buildCanvasViewFromTexture({
 
         getShader().uniforms.tDiffuse.value = texture;
 
+        const _rt = renderer.getRenderTarget();
+
         renderer.setRenderTarget(renderTarget);
 
         renderer.render(scene, camera);
@@ -163,7 +185,7 @@ export function buildCanvasViewFromTexture({
 
         ctx.putImageData(imageData, 0, 0)
 
-        renderer.setRenderTarget(null);
+        renderer.setRenderTarget(_rt);
     };
 
     return {

package/engine/graphics/shaders/ScreenSpaceQuadShader.js

@@ -1,3 +1,5 @@
+import { glsl_gen_swizzled_read } from "./glsl_gen_swizzled_read.js";
+
 function vertexShader() {
     return `
                 varying vec2 vUv;
@@ -11,25 +13,13 @@ function vertexShader() {
         `;
 }
 
+
 /**
  *
  * @param {string[]} [swizzle] what to read from the texture
  * @returns {string}
  */
 function fragmentShader(swizzle = ['r', 'g', 'b', 'a']) {
-    const swizzle_read = [];
-    const n = swizzle.length;
-    for (let i = 0; i < n; i++) {
-        const token = swizzle[i];
-
-        if (typeof token === "string") {
-            swizzle_read[i] = `texel.${token}`;
-        } else if (typeof token === "number") {
-            swizzle_read[i] = Number(token).toFixed(4);
-        } else {
-            throw new Error(`Unsupported swizzle token '${token}'`);
-        }
-    }
 
     return `
                 uniform sampler2D tTexture;
@@ -37,7 +27,7 @@ function fragmentShader(swizzle = ['r', 'g', 'b', 'a']) {
                             
                 void main(){
                     vec4 texel = texture2D( tTexture, vUv );
-                    gl_FragColor = vec4(${swizzle_read.join(',')});
+                    gl_FragColor = ${glsl_gen_swizzled_read('texel', swizzle)};
                 }
         `;
 }

package/engine/graphics/shaders/glsl_gen_swizzled_read.js

@@ -0,0 +1,39 @@
+/**
+ *
+ * @param {string} input name of the variable on which components are being accessed
+ * @param {(string|number)[]} swizzle
+ * @returns {string} swizzled vector
+ */
+export function glsl_gen_swizzled_read(input, swizzle) {
+    const swizzle_read = [];
+    const n = swizzle.length;
+    for (let i = 0; i < n; i++) {
+        const token = swizzle[i];
+
+        if (typeof token === "string") {
+            swizzle_read[i] = `${input}.${token}`;
+        } else if (typeof token === "number") {
+            swizzle_read[i] = Number(token).toFixed(4);
+        } else {
+            throw new Error(`Unsupported swizzle token '${token}'`);
+        }
+    }
+
+    const arg_string = swizzle_read.join(', ');
+
+    const ctors = [
+        undefined,
+        'float',
+        'vec2',
+        'vec3',
+        'vec4'
+    ];
+
+    const ctor = ctors[swizzle.length];
+
+    if (ctor === undefined) {
+        throw new Error(`No constructor for input length ${swizzle.length}`);
+    }
+
+    return `${ctor}(${arg_string})`;
+}

package/engine/ui/GUIEngine.js

@@ -103,7 +103,14 @@ function GUIEngine() {
         }
     });
 
-    this.view = new EmptyView({ classList: ['gui-engine-root'] });
+    this.view = new EmptyView({
+        classList: ['gui-engine-root'],
+        css: {
+            position: "absolute",
+            left: "0",
+            top: "0"
+        }
+    });
 
     /**
      *

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.40.1",
+  "version": "2.41.0",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/view/tooltip/gml/parser/readReferenceToken.js

@@ -1,9 +1,9 @@
 import ParserError from "../../../../core/parser/simple/ParserError.js";
-import { skipWhitespace } from "../../../../core/parser/simple/SimpleParser.js";
 import { readReferenceValueToken } from "./readReferenceValueToken.js";
 import { TooltipReferenceValue } from "./TooltipReferenceValue.js";
 import Token from "../../../../core/parser/simple/Token.js";
 import { TooltipTokenType } from "./TooltipTokenType.js";
+import { skipWhitespace } from "../../../../core/parser/simple/skipWhitespace.js";
 
 /**
  *

package/engine/asset/GameAssetManager.js

@@ -1,137 +0,0 @@
-/**
- * Created by Alex on 03/09/2014.
- */
-
-import { sRGBEncoding, TextureLoader as ThreeTextureLoader } from "three";
-
-import { Asset } from "./Asset.js";
-import { computeFileExtension } from "../../core/FilePath.js";
-import { DDSLoader } from "three/examples/jsm/loaders/DDSLoader.js";
-import { ArrayBufferLoader } from "./loaders/ArrayBufferLoader.js";
-import { JsonAssetLoader } from "./loaders/JsonAssetLoader.js";
-import { GameAssetType } from "./GameAssetType.js";
-import { TextAssetLoader } from "./loaders/TextAssetLoader.js";
-import { AnimationGraphDefinitionAssetLoader } from "../graphics/ecs/animation/animator/graph/definition/serialization/AnimationGraphDefinitionAssetLoader.js";
-import { JavascriptAssetLoader } from "./loaders/JavascriptAssetLoader.js";
-import { ImageRGBADataLoader } from "./loaders/image/ImageRGBADataLoader.js";
-import { GLTFAssetLoader } from "./loaders/GLTFAssetLoader.js";
-import { SVGAssetLoader } from "./loaders/SVGAssetLoader.js";
-import { AttachmentSocketsAssetLoader } from "../ecs/sockets/serialization/AttachmentSocketsAssetLoader.js";
-import { FontAssetLoader } from "../../core/font/FontAssetLoader.js";
-import { computeTextureByteSize } from "./loaders/texture/loadStandardImageTexture.js";
-import { TextureAssetLoader } from "./loaders/texture/TextureAssetLoader.js";
-
-
-const textureLoader = new ThreeTextureLoader();
-const ddsLoader = new DDSLoader();
-
-export function deferredTextureLoader(path, success, failure, progress) {
-
-    /**
-     *
-     * @param {Texture} texture
-     */
-    function handleLoad(texture) {
-        const byteSize = computeTextureByteSize(texture);
-
-        asset.byteSize = byteSize;
-
-        pending.forEach(p => {
-            p.image = texture.image;
-            p.mipmaps = texture.mipmaps;
-
-            p.format = texture.format;
-
-            p.needsUpdate = true;
-        });
-
-        isLoaded = true;
-    }
-
-    function loadCompressed() {
-        const texture = ddsLoader.load(path, handleLoad, progress, failure);
-
-        if (texture.mipmaps === undefined) {
-            texture.mipmaps = [];
-        }
-
-        return texture;
-    }
-
-    const pending = [];
-
-    let isLoaded = false;
-
-    //figure out what kind of a texture it is
-    const fileExtension = computeFileExtension(path);
-    if (fileExtension === null) {
-        throw new Error(`no file extension on path '${path}'`);
-    }
-
-    const lowerCaseExtension = fileExtension.toLowerCase();
-
-    let texture;
-
-    switch (lowerCaseExtension) {
-        case  "dds":
-            texture = loadCompressed();
-            break;
-        case "png":
-        case "jpg":
-            texture = textureLoader.load(path, handleLoad, progress, failure);
-            break;
-        default:
-            throw new Error(`Unsupported texture file format: '${lowerCaseExtension}'`);
-
-    }
-
-    texture.encoding = sRGBEncoding;
-
-    const asset = new Asset(function () {
-
-        const clone = texture.clone();
-
-        if (isLoaded) {
-            clone.needsUpdate = true;
-        } else {
-            pending.push(clone);
-        }
-
-        return clone;
-    }, 1);
-
-    success(asset);
-}
-
-
-/**
- *
- * @param {AssetManager} assetManager
- */
-function initAssetManager(assetManager) {
-
-    assetManager.registerLoader(GameAssetType.ModelGLTF, new GLTFAssetLoader());
-    assetManager.registerLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
-    assetManager.registerLoader(GameAssetType.ArrayBuffer, new ArrayBufferLoader());
-    assetManager.registerLoader(GameAssetType.Texture, new TextureAssetLoader());
-    assetManager.registerLoader(GameAssetType.DeferredTexture, deferredTextureLoader);
-
-    assetManager.registerLoader(GameAssetType.JSON, new JsonAssetLoader());
-    assetManager.registerLoader(GameAssetType.Text, new TextAssetLoader());
-
-    assetManager.registerLoader(GameAssetType.JavaScript, new JavascriptAssetLoader());
-
-    assetManager.registerLoader(GameAssetType.Font, new FontAssetLoader());
-
-
-    assetManager.registerLoader(GameAssetType.AnimationGraph, new AnimationGraphDefinitionAssetLoader());
-    assetManager.registerLoader(GameAssetType.AttachmentSockets, new AttachmentSocketsAssetLoader());
-
-    assetManager.registerLoader(GameAssetType.Image, new ImageRGBADataLoader());
-
-    assetManager.registerLoader(GameAssetType.ImageSvg, new SVGAssetLoader());
-}
-
-export {
-    initAssetManager
-};