@luminocity/lemonate-engine 26.3.13 → 26.3.15

package/dist/subsystems/particlesystem/ParticleTexturePreview.d.ts

@@ -0,0 +1,50 @@
+import { WebGLRenderer, Texture, Vector2, Vector4 } from "three";
+import { Engine } from "../../Engine";
+export declare class ParticleTexturePreview {
+    private renderer;
+    private engine;
+    id: string;
+    size: number;
+    private renderTarget;
+    private rtCamera;
+    private rtScene;
+    private shader;
+    private jpegData?;
+    constructor(renderer: WebGLRenderer, engine: Engine, id: string, size?: number);
+    get lifeRatio(): number;
+    set lifeRatio(v: number);
+    get time(): number;
+    set time(v: number);
+    set baseColor(v: Vector4);
+    set baseFinalColor(v: Vector4);
+    set enableFinalColor(v: boolean);
+    set enableTexture(v: boolean);
+    set particleTexture(v: Texture | null);
+    set maskType(v: number);
+    set flipY(v: boolean);
+    set textureBlendingFlag(v: boolean);
+    set preMultiplyAlphaFlag(v: boolean);
+    set blendValue(v: number);
+    set hueShift(v: number);
+    set randomColorFactor(v: number);
+    set angularVelocity(v: number);
+    set rotationDirection(v: number);
+    set rollSpriteWithLife(v: boolean);
+    set enableSpriteFade(v: boolean);
+    set spriteSpeed(v: number);
+    set spriteRows(v: number);
+    set spriteCols(v: number);
+    set atlasWidth(v: number);
+    set atlasHeight(v: number);
+    set fadeMode(v: number);
+    set fadeFunction(v: number);
+    set fadeApproach(v: number);
+    set fadeRange(v: Vector2);
+    set fadeInitialOpacity(v: number);
+    set fadeFinalOpacity(v: number);
+    private handleSetLifeRatio;
+    render(): void;
+    getTexture(): Promise<string | undefined>;
+    emitUpdateEvent(): void;
+    destroy(): void;
+}

package/dist/subsystems/particlesystem/shaders/common.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared GLSL fragments for particle rendering.
+ *
+ * Both the visualisation shader (GL_POINTS) and the particle preview shader
+ * (fullscreen quad) compose their fragment shaders from these building blocks.
+ *
+ * Callers of `mainBody` must define these macros before embedding it:
+ *
+ *   POINTCOORD         — vec2 [0,1]^2 (gl_PointCoord or vUv)
+ *   LIFE_RATIO         — float [0,1] normalised particle age
+ *   ROTATION_ANGLE     — float per-particle rotation (vRotation or 0.0)
+ *   ATLAS_INDEX_OFFSET — float atlas cell offset (vAtlasUV.x or 0.0)
+ *   FADE_ALPHA         — float fade factor (vColor.a or 1.0)
+ *   RANDOM_COLOR       — vec3 per-particle random colour (vColor.xyz or vec3(0.5))
+ *   OUTPUT_COLOR(c)    — statement that writes the final vec4 output
+ */
+declare const uniforms = "\n    uniform float time;\n    uniform float randomColorFactor;\n    uniform vec4 baseColor;\n    uniform vec4 baseFinalColor;\n    uniform bool enableFinalColor;\n    uniform bool enableTexture;\n    uniform sampler2D particleTexture;\n    uniform int maskType; // 0 = none, 1 = circular\n    uniform bool textureFlipY;\n    uniform bool textureBlendingFlag;\n    uniform bool preMultiplyAlphaFlag;\n    uniform float blendValue;\n    uniform float hueShift;\n    uniform float angularVelocity;\n    uniform float rotationDirection;\n    uniform bool rollSpriteWithLife;\n    uniform bool enableSpriteFade;\n    uniform float spriteSpeed;\n    uniform float spriteRows;\n    uniform float spriteCols;\n    uniform float atlasWidth;\n    uniform float atlasHeight;\n\n    // Fade-over-life (mirrored from the visualisation vertex shader)\n    uniform int fadeMode;       // 0 = constant, 1 = over life, 2 = by velocity\n    uniform int fadeFunction;   // easing: 0 = linear, 1 = exp, 2 = inv-exp, 3 = ease-in-out\n    uniform float fadeApproach; // easing curve strength\n    uniform vec2 fadeRange;     // (initialOpacity, finalOpacity)\n";
+declare const helpers = "\n    float rand(vec2 co) {\n        return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);\n    }\n\n    float pseudoRandom(vec2 co) {\n        float a = 12.9898;\n        float b = 78.233;\n        float c = 43758.5453;\n        float dt = dot(co.xy, vec2(a, b));\n        float sn = mod(dt, 3.14);\n        return fract(sin(sn) * c);\n    }\n\n    mat2 getRotationMatrix(float angle) {\n        float c = cos(angle);\n        float s = sin(angle);\n        return mat2(c, s, -s, c);\n    }\n\n    vec2 getAtlasTexCoord(float index) {\n        float imageWidth = atlasWidth / spriteCols;\n        float imageHeight = atlasHeight / spriteRows;\n\n        float atlasRow = floor(index / spriteCols);\n        float atlasColumn = mod(index, spriteCols);\n\n        float u = (atlasColumn * imageWidth) / atlasWidth;\n        float v = (atlasRow * imageHeight) / atlasHeight;\n\n        return vec2(u, v);\n    }\n\n    float applyEasing(float t, int mode, float k) {\n        if (mode == 1) return pow(t, k);\n        if (mode == 2) return 1.0 - pow(1.0 - t, k);\n        if (mode == 3) return (t < 0.5) ? 0.5 * pow(2.0 * t, k)\n                         : 1.0 - 0.5 * pow(2.0 * (1.0 - t), k);\n        // mode 0 default (linear)\n        return t;\n    }\n\n    /** Compute the fade factor for a given life ratio and fade parameters. */\n    float computeFadeFactor(float lifeR, int fMode, int fFunc, float fApproach, vec2 fRange) {\n        float eased = applyEasing(lifeR, fFunc, fApproach);\n        float fadeConst = fRange.x;\n        float fadeLife  = mix(fRange.x, fRange.y, eased);\n        // For the preview we don't have velocity, so mode 2 falls back to constant\n        float factor = fadeConst;\n        factor = mix(factor, fadeLife, float(fMode == 1));\n        return factor;\n    }\n\n    vec3 shiftHue(vec3 color, float hueShift) {\n        vec3 P = vec3(0.55735) * dot(vec3(0.55735), color);\n        vec3 U = color - P;\n        vec3 V = cross(vec3(0.55735), U);\n        color = U * cos(hueShift * 6.2832) + V * sin(hueShift * 6.2832) + P;\n        return color;\n    }\n";
+declare const mainBody = "\n    // -------------------------------------------------------------------------\n    // Step 1 \u2014 Sample base color (texture or flat color)\n    // -------------------------------------------------------------------------\n    vec2 UV = textureFlipY ? vec2(POINTCOORD.x, 1.0 - POINTCOORD.y) : POINTCOORD;\n    mat2 rotationMatrix = getRotationMatrix(rotationDirection * ROTATION_ANGLE * angularVelocity);\n\n    vec4 sampledColor;\n    if (enableTexture) {\n        if (spriteSpeed == 0.0 && !rollSpriteWithLife) {\n            vec2 rotatedUV = rotationMatrix * (UV - 0.5) + 0.5;\n            sampledColor = texture(particleTexture, rotatedUV);\n        } else {\n            float spriteIndexFactor = rollSpriteWithLife\n                ? (spriteCols * spriteRows * LIFE_RATIO)\n                : (spriteSpeed * time);\n            float atlasIndex = mod(floor(spriteIndexFactor) + ATLAS_INDEX_OFFSET, spriteRows * spriteCols);\n\n            vec2 cellSize  = vec2(1.0 / spriteCols, 1.0 / spriteRows);\n            vec2 localUV   = (UV - 0.5) * 0.9 + 0.5;\n            vec2 rotatedUV = rotationMatrix * (localUV - 0.5) + 0.5;\n            vec2 atlasUV   = getAtlasTexCoord(atlasIndex) + rotatedUV * cellSize;\n\n            if (enableSpriteFade) {\n                float nextIndex  = mod(atlasIndex + 1.0, spriteRows * spriteCols);\n                vec2  nextAtlasUV = getAtlasTexCoord(nextIndex) + rotatedUV * cellSize;\n                sampledColor = mix(\n                    texture(particleTexture, atlasUV),\n                    texture(particleTexture, nextAtlasUV),\n                    fract(spriteIndexFactor)\n                );\n            } else {\n                sampledColor = texture(particleTexture, atlasUV);\n            }\n        }\n    } else {\n        sampledColor = baseColor;\n    }\n\n    // -------------------------------------------------------------------------\n    // Step 2 \u2014 Mix base color with finalColor over lifetime\n    // -------------------------------------------------------------------------\n    vec4 particleColor = sampledColor;\n\n    if (enableFinalColor) {\n        vec3 startTint = enableTexture\n            ? (textureBlendingFlag ? sampledColor.rgb * baseColor.rgb : sampledColor.rgb)\n            : baseColor.rgb;\n        vec3 endTint = enableTexture\n            ? (textureBlendingFlag ? sampledColor.rgb * baseFinalColor.rgb : sampledColor.rgb)\n            : baseFinalColor.rgb;\n        particleColor.rgb = mix(startTint, endTint, LIFE_RATIO);\n    } else if (textureBlendingFlag && enableTexture) {\n        // Only multiply when there's actually a texture to blend with\n        particleColor.rgb *= baseColor.rgb;\n        particleColor.a   *= baseColor.a;\n    }\n\n    // -------------------------------------------------------------------------\n    // Step 3 \u2014 Compute other color variations\n    // -------------------------------------------------------------------------\n    if (hueShift != 0.0) {\n        particleColor.rgb = shiftHue(particleColor.rgb, -hueShift);\n    }\n\n    if (randomColorFactor > 0.0) {\n        particleColor.rgb = mix(particleColor.rgb, RANDOM_COLOR, randomColorFactor);\n    }\n\n    // -------------------------------------------------------------------------\n    // Step 4 \u2014 Alpha computation: shape mask, fading\n    // -------------------------------------------------------------------------\n    float mask = 1.0;\n    if (maskType == 1) {\n        float distanceFromCenter = length(POINTCOORD - vec2(0.5));\n        mask = smoothstep(0.5, 0.45, distanceFromCenter);\n    }\n\n    particleColor.a *= mask * FADE_ALPHA;\n    if (particleColor.a < 0.001) discard;\n\n    if (!preMultiplyAlphaFlag) {\n        particleColor.a *= blendValue;\n    }\n\n    OUTPUT_COLOR(particleColor)\n";
+export { uniforms, helpers, mainBody };

package/dist/subsystems/particlesystem/shaders/particlepreview/shader.d.ts

@@ -0,0 +1,94 @@
+import { Vector2, Vector4 } from "three";
+/**
+ * Shader for rendering a single-particle preview to an off-screen target.
+ * Uses a fullscreen quad (PlaneGeometry 2x2) with vUv in place of gl_PointCoord.
+ */
+declare const ParticlePreviewShader: {
+    shaderID: string;
+    uniforms: {
+        lifeRatio: {
+            value: number;
+        };
+        time: {
+            value: number;
+        };
+        baseColor: {
+            value: Vector4;
+        };
+        baseFinalColor: {
+            value: Vector4;
+        };
+        enableFinalColor: {
+            value: boolean;
+        };
+        enableTexture: {
+            value: boolean;
+        };
+        particleTexture: {
+            value: null;
+        };
+        maskType: {
+            value: number;
+        };
+        textureFlipY: {
+            value: boolean;
+        };
+        textureBlendingFlag: {
+            value: boolean;
+        };
+        preMultiplyAlphaFlag: {
+            value: boolean;
+        };
+        blendValue: {
+            value: number;
+        };
+        hueShift: {
+            value: number;
+        };
+        randomColorFactor: {
+            value: number;
+        };
+        angularVelocity: {
+            value: number;
+        };
+        rotationDirection: {
+            value: number;
+        };
+        rollSpriteWithLife: {
+            value: boolean;
+        };
+        enableSpriteFade: {
+            value: boolean;
+        };
+        spriteSpeed: {
+            value: number;
+        };
+        spriteRows: {
+            value: number;
+        };
+        spriteCols: {
+            value: number;
+        };
+        atlasWidth: {
+            value: number;
+        };
+        atlasHeight: {
+            value: number;
+        };
+        fadeMode: {
+            value: number;
+        };
+        fadeFunction: {
+            value: number;
+        };
+        fadeApproach: {
+            value: number;
+        };
+        fadeRange: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export { ParticlePreviewShader };

package/dist/subsystems/particlesystem/shaders/visualisation/shader.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Fragment shader for GL_POINTS particle visualisation.
+ * Uses per-particle varyings from the vertex shader and gl_PointCoord.
+ */
+declare const VisualisationShader: {
+    shaderID: string;
+    fragmentShader: string;
+};
+export { VisualisationShader };

package/dist/subsystems/scripting/ScriptEngine.d.ts

@@ -28,6 +28,30 @@ type PromiseEntry = {
     reject: ((reason: string) => void) | undefined;
     resolve: (() => void) | undefined;
 };
+type RendererDataSet = {
+    width: number;
+    height: number;
+};
+type TimingDataSet = {
+    time: number;
+    deltaTime: number;
+    gameTime: number;
+    deltaGameTime: number;
+    deltaGameTimeSmooth: number;
+};
+export type UpdateDataSet = {
+    timing: TimingDataSet;
+    renderer: RendererDataSet;
+};
+export type ScriptRuntimeData = {
+    engine: Engine;
+    scriptEngine: ScriptEngine;
+    time: number;
+    deltaTime: number;
+    gameTime: number;
+    deltaGameTime: number;
+    deltaGameTimeSmooth: number;
+};
 export declare class ScriptEngine {
     engine: Engine;
     itemRepo: ItemRepo;
@@ -36,7 +60,7 @@ export declare class ScriptEngine {
     scriptRunners: Map<string, ScriptRunner>;
     scripts: Map<any, any>;
     eventListeners: Map<any, any>;
-    scriptRuntimeData: any;
+    scriptRuntimeData: ScriptRuntimeData;
     scriptRuntime: ScriptRuntime;
     breakpointsMap: any;
     importedLibsPromises: any;
@@ -60,12 +84,18 @@ export declare class ScriptEngine {
     _createBuffer(size: number): LuaBuffer;
     _freeBuffer(buffer: LuaBuffer): void;
     getScriptRuntime(): ScriptRuntime;
-    getScriptRuntimeData(): any;
+    getScriptRuntimeData(): ScriptRuntimeData;
     resetScriptEngineState(): void;
     tick(deltaTimeMs: number): Promise<any>;
+    updateActiveScripts(activeScripts: {
+        [k: string]: boolean;
+    }): Promise<any>;
+    callUpdateHooks(data: UpdateDataSet): Promise<any>;
+    callRenderHooks(): Promise<any>;
+    callRenderGuiHooks(): Promise<any>;
     packMessage(data: any): Uint8Array<ArrayBufferLike>;
     unpackMessage(data: any): unknown;
-    reset(): void;
+    reset(): Promise<void>;
     waitForLua(): Promise<void>;
     destroy(): void;
     debuggerEnable(): void;
@@ -90,12 +120,12 @@ export declare class ScriptEngine {
     createScript(scriptItem: ScriptItem): Promise<void>;
     updateScript(scriptItem: ScriptItem): Promise<void>;
     deleteScript(scriptItem: ScriptItem): void;
-    createInstance(scriptRunner: ScriptRunner): Promise<any>;
+    createInstance(scriptRunner: ScriptRunner): Promise<string>;
     deleteInstance(scriptId: string): Promise<void>;
     _parseAndLoadImportedLibs(code: string, scriptItemId: string, scriptItemName: string, level?: number): Promise<void>;
     _importLib(scriptItemId: any, path: any, scriptItemName: any): Promise<any>;
     _disposeBehaviour(scriptId: string): Promise<void>;
-    _injectValues(scriptId: any, scriptItemName: any, scriptRunner: any): Promise<void>;
+    _injectValues(scriptId: string, scriptItemName: string, scriptRunner: ScriptRunner): Promise<void>;
     _prepareCode(code: string, scriptItemId: string, injectedFields?: any[] | undefined): {
         preparedCode: string;
         breakpointsOffset: number;

package/dist/subsystems/scripting/ScriptRunner.d.ts

@@ -24,7 +24,7 @@ export declare class ScriptRunner {
     setNode(node: any): void;
     setInjectedFields(fields: any): void;
     getInjectedFields(): any;
-    loadCode(script: ScriptItem): Promise<void>;
+    loadCode(script: ScriptItem): Promise<string>;
     _unloadCode(): Promise<void>;
     existsFunction(name: string, forceFunctionCall?: boolean): any;
     callUpdateHook(deltaTimes: any): Promise<any>;

package/dist/subsystems/scripting/runtime/sceneobjects/RtSgScriptedMesh.d.ts

@@ -2,7 +2,7 @@ import { RtItem } from '../RtItem';
 import { ScriptRuntime } from "@/subsystems/scripting/ScriptRuntime";
 export declare class RtSgScriptedMesh extends RtItem {
     constructor(runtime: ScriptRuntime);
-    setAttributeData(params: any): void;
+    setAttributeData(params: any, buffers?: any): void;
     computeBoundingBox(params: any): void;
     computeBoundingSphere(params: any): void;
     computeTangents(params: any): void;

package/headlessrenderer/ItemRenderer.ts

@@ -36,7 +36,7 @@ export class ItemRenderer {
     debugMode: boolean;
     browserType: string;
     log: Function;
-    previewTypes: string[] = [];
+    previewTypes: string[] | undefined;
 
     RendererType: any;
 
@@ -78,7 +78,7 @@ export class ItemRenderer {
         return this.apiClient.initCaches();
     }
 
-    setPreviewTypes(types: string[]) {
+    setPreviewTypes(types: string[] | undefined) {
         this.previewTypes = types;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luminocity/lemonate-engine",
-  "version": "26.3.13",
+  "version": "26.3.15",
   "productName": "Lemonate Engine",
   "repository": "https://codeberg.org/Luminocity/lemonate-engine",
   "homepage": "https://lemonate.io",
@@ -43,7 +43,7 @@
   "dependencies": {
     "@gltf-transform/core": "^4.0.1",
     "@gltf-transform/extensions": "^4.0.1",
-    "@luminocity/lemonate-gateway": "8.2.23",
+    "@luminocity/lemonate-gateway": "8.2.25",
     "@msgpack/msgpack": "3.1.1",
     "@recast-navigation/three": "^0.42.0",
     "@sparkjsdev/spark": "^0.1.10",
@@ -60,6 +60,8 @@
     "moment": "2.30.1",
     "opentype.js": "1.3.4",
     "recast-navigation": "^0.42.0",
+    "sharp": "^0.34.5",
+    "sharp-phash": "^2.2.0",
     "stats-gl": "3.6.0",
     "three": "0.182.0",
     "wavesurfer.js": "7.9.9",