bg2e-js 2.3.11 → 2.3.13

package/src/scene/LightComponent.ts

@@ -1,155 +1,155 @@
-import Component from "./Component";
-import Light, { LightType } from "../base/Light";
-import FindNodeVisitor from "./FindNodeVisitor";
-import Node from "./Node";
-
-
-export default class LightComponent extends Component {
-    static GetLights(sceneRoot: Node): LightComponent[] {
-        if (sceneRoot.sceneChanged || !(sceneRoot as any).__lights) {
-            (sceneRoot as any).__lights = [];
-            let findLights = new FindNodeVisitor();
-            findLights.hasComponents(["Light"]);
-            sceneRoot.accept(findLights);
-            (sceneRoot as any).__lights = findLights.result.map(n => n.lightComponent);
-        }
-        return (sceneRoot as any).__lights;
-    }
-
-    static GetFirstShadowCastingLight(sceneRoot: Node): LightComponent | undefined {
-        if (sceneRoot.sceneChanged || !(sceneRoot as any).__mainDirectionalLight) {
-            (sceneRoot as any).__mainDirectionalLight = LightComponent.GetLights(sceneRoot)
-                .find(l => l.light.type === LightType.DIRECTIONAL || l.light.type === LightType.SPOT);
-        }
-        return (sceneRoot as any).__mainDirectionalLight;
-    }
-
-    static GetMainDirectionalLight(sceneRoot: Node): LightComponent | undefined {
-        if (sceneRoot.sceneChanged || !(sceneRoot as any).__mainDirectionalLight) {
-            (sceneRoot as any).__mainDirectionalLight = LightComponent.GetLights(sceneRoot)
-                .find(l => l.light.type === LightType.DIRECTIONAL);
-        }
-        return (sceneRoot as any).__mainDirectionalLight || LightComponent.GetFirstShadowCastingLight(sceneRoot);
-    }
-
-    _light: Light;
-
-    constructor(light: Light | null = null) {
-        super("Light");
-
-        this._light = light || new Light();
-    }
-
-    get light(): Light { return this._light; }
-    set light(l: Light) { this._light = l; }
-
-    set depthTexture(t: any) {
-        this._light.depthTexture = t;
-    }
-
-    get depthTexture(): any {
-        return this._light.depthTexture;
-    }
-
-    set viewMatrix(vm: any) {
-        this._light.viewMatrix = vm;
-    }
-
-    get viewMatrix(): any {
-        return this._light.viewMatrix;
-    }
-
-    clone(): LightComponent {
-        const result = new LightComponent();
-        result.assign(this);
-        return result;
-    }
-
-    assign(other: LightComponent): void {
-        this._light = other._light.clone();
-    }
-
-    setProperties({
-        enabled,
-        type,
-        lightType,  // alias of type
-        direction,
-        position,
-        color,
-        spotCutoff,
-        spotExponent,
-        shadowStrength,
-        castShadows,
-        shadowBias,
-        intensity,
-        projection 
-    }: {
-        enabled?: boolean;
-        type?: LightType;
-        lightType?: LightType;
-        direction?: any;
-        position?: any;
-        color?: any;
-        spotCutoff?: number;
-        spotExponent?: number;
-        shadowStrength?: number;
-        castShadows?: boolean;
-        shadowBias?: number;
-        intensity?: number;
-        projection?: any;
-    }): void {
-        if (enabled !== undefined) {
-            this.light.enabled = enabled;
-        }
-        if (type !== undefined) {
-            this.light.type = type;
-        }
-        if (lightType !== undefined) {
-            this.light.type = lightType;
-        }
-        if (direction !== undefined) {
-            this.light.direction = direction;
-        }
-        if (position !== undefined) {
-            this.light.position = position;
-        }
-        if (color !== undefined) {
-            this.light.color = color;
-        }
-        if (spotCutoff !== undefined) {
-            this.light.spotCutoff = spotCutoff;
-        }
-        if (spotExponent !== undefined) {
-            this.light.spotExponent = spotExponent;
-        }
-        if (shadowStrength !== undefined) {
-            this.light.shadowStrength = shadowStrength;
-        }
-        if (castShadows !== undefined) {
-            this.light.castShadows = castShadows;
-        }
-        if (shadowBias !== undefined) {
-            this.light.shadowBias = shadowBias;
-        }
-        if (intensity !== undefined) {
-            this.light.intensity = intensity;
-        }
-        if (projection !== undefined) {
-            this.light.projection = projection;
-        }
-    }
-
-    async deserialize(sceneData: any, loader: any): Promise<void> {
-        await this._light.deserialize(sceneData);
-    }
-
-    async serialize(sceneData: any, writer: any): Promise<void> {
-        await super.serialize(sceneData,writer);
-        await this._light.serialize(sceneData);
-        throw new Error("LightComponent.serialize() not implemented");
-    }
-
-    draw(renderQueue: any, modelMatrix: any): void {
-        renderQueue.addLight(this.light, modelMatrix);
-    }
+import Component from "./Component";
+import Light, { LightType } from "../base/Light";
+import FindNodeVisitor from "./FindNodeVisitor";
+import Node from "./Node";
+
+
+export default class LightComponent extends Component {
+    static GetLights(sceneRoot: Node): LightComponent[] {
+        if (sceneRoot.sceneChanged || !(sceneRoot as any).__lights) {
+            (sceneRoot as any).__lights = [];
+            let findLights = new FindNodeVisitor();
+            findLights.hasComponents(["Light"]);
+            sceneRoot.accept(findLights);
+            (sceneRoot as any).__lights = findLights.result.map(n => n.lightComponent);
+        }
+        return (sceneRoot as any).__lights;
+    }
+
+    static GetFirstShadowCastingLight(sceneRoot: Node): LightComponent | undefined {
+        if (sceneRoot.sceneChanged || !(sceneRoot as any).__mainDirectionalLight) {
+            (sceneRoot as any).__mainDirectionalLight = LightComponent.GetLights(sceneRoot)
+                .find(l => l.light.type === LightType.DIRECTIONAL || l.light.type === LightType.SPOT);
+        }
+        return (sceneRoot as any).__mainDirectionalLight;
+    }
+
+    static GetMainDirectionalLight(sceneRoot: Node): LightComponent | undefined {
+        if (sceneRoot.sceneChanged || !(sceneRoot as any).__mainDirectionalLight) {
+            (sceneRoot as any).__mainDirectionalLight = LightComponent.GetLights(sceneRoot)
+                .find(l => l.light.type === LightType.DIRECTIONAL);
+        }
+        return (sceneRoot as any).__mainDirectionalLight || LightComponent.GetFirstShadowCastingLight(sceneRoot);
+    }
+
+    _light: Light;
+
+    constructor(light: Light | null = null) {
+        super("Light");
+
+        this._light = light || new Light();
+    }
+
+    get light(): Light { return this._light; }
+    set light(l: Light) { this._light = l; }
+
+    set depthTexture(t: any) {
+        this._light.depthTexture = t;
+    }
+
+    get depthTexture(): any {
+        return this._light.depthTexture;
+    }
+
+    set viewMatrix(vm: any) {
+        this._light.viewMatrix = vm;
+    }
+
+    get viewMatrix(): any {
+        return this._light.viewMatrix;
+    }
+
+    clone(): LightComponent {
+        const result = new LightComponent();
+        result.assign(this);
+        return result;
+    }
+
+    assign(other: LightComponent): void {
+        this._light = other._light.clone();
+    }
+
+    setProperties({
+        enabled,
+        type,
+        lightType,  // alias of type
+        direction,
+        position,
+        color,
+        spotCutoff,
+        spotExponent,
+        shadowStrength,
+        castShadows,
+        shadowBias,
+        intensity,
+        projection 
+    }: {
+        enabled?: boolean;
+        type?: LightType;
+        lightType?: LightType;
+        direction?: any;
+        position?: any;
+        color?: any;
+        spotCutoff?: number;
+        spotExponent?: number;
+        shadowStrength?: number;
+        castShadows?: boolean;
+        shadowBias?: number;
+        intensity?: number;
+        projection?: any;
+    }): void {
+        if (enabled !== undefined) {
+            this.light.enabled = enabled;
+        }
+        if (type !== undefined) {
+            this.light.type = type;
+        }
+        if (lightType !== undefined) {
+            this.light.type = lightType;
+        }
+        if (direction !== undefined) {
+            this.light.direction = direction;
+        }
+        if (position !== undefined) {
+            this.light.position = position;
+        }
+        if (color !== undefined) {
+            this.light.color = color;
+        }
+        if (spotCutoff !== undefined) {
+            this.light.spotCutoff = spotCutoff;
+        }
+        if (spotExponent !== undefined) {
+            this.light.spotExponent = spotExponent;
+        }
+        if (shadowStrength !== undefined) {
+            this.light.shadowStrength = shadowStrength;
+        }
+        if (castShadows !== undefined) {
+            this.light.castShadows = castShadows;
+        }
+        if (shadowBias !== undefined) {
+            this.light.shadowBias = shadowBias;
+        }
+        if (intensity !== undefined) {
+            this.light.intensity = intensity;
+        }
+        if (projection !== undefined) {
+            this.light.projection = projection;
+        }
+    }
+
+    async deserialize(sceneData: any, loader: any): Promise<void> {
+        await this._light.deserialize(sceneData);
+    }
+
+    async serialize(sceneData: any, writer: any): Promise<void> {
+        await super.serialize(sceneData,writer);
+        await this._light.serialize(sceneData);
+        throw new Error("LightComponent.serialize() not implemented");
+    }
+
+    draw(renderQueue: any, modelMatrix: any): void {
+        renderQueue.addLight(this.light, modelMatrix);
+    }
 }

package/src/scene/MatrixState.ts

@@ -1,46 +1,46 @@
-
-import Mat4 from "../math/Mat4";
-
-const pushMatrix = function(mat: Mat4, stack: Mat4[], id: string): void {
-    stack.push(new Mat4(mat));
-}
-
-const popMatrix = function(mat: Mat4, stack: Mat4[], id: string): void {
-    if (stack.length > 0) {
-        mat.assign(stack[stack.length - 1]);
-        stack.splice(stack.length - 1, 1);
-    }
-    else {
-        throw new Error(`Matrix stack underflow detected in ${id} matrix`);
-    }
-}
-
-export default class MatrixState {
-    private _projection: Mat4;
-    private _view: Mat4;
-    private _model: Mat4;
-    private _projMatrixStack: Mat4[];
-    private _viewMatrixStack: Mat4[];
-    private _modelMatrixStack: Mat4[];
-
-    constructor() {
-        this._projection = Mat4.MakeIdentity();
-        this._view = Mat4.MakeIdentity();
-        this._model = Mat4.MakeIdentity();
-
-        this._projMatrixStack = [];
-        this._viewMatrixStack = [];
-        this._modelMatrixStack = [];
-    }
-
-    get projection(): Mat4 { return this._projection; }
-    get view(): Mat4 { return this._view; }
-    get model(): Mat4 { return this._model; }
-
-    pushProjection(): void { pushMatrix(this._projection, this._projMatrixStack, 'projection'); }
-    popProjection(): void { popMatrix(this._projection, this._projMatrixStack, 'projection'); }
-    pushView(): void { pushMatrix(this._view, this._viewMatrixStack, 'view'); }
-    popView(): void { popMatrix(this._view, this._viewMatrixStack, 'view'); }
-    pushModel(): void { pushMatrix(this._model, this._modelMatrixStack, 'model'); }
-    popModel(): void { popMatrix(this._model, this._modelMatrixStack, 'model'); }
-}
+
+import Mat4 from "../math/Mat4";
+
+const pushMatrix = function(mat: Mat4, stack: Mat4[], id: string): void {
+    stack.push(new Mat4(mat));
+}
+
+const popMatrix = function(mat: Mat4, stack: Mat4[], id: string): void {
+    if (stack.length > 0) {
+        mat.assign(stack[stack.length - 1]);
+        stack.splice(stack.length - 1, 1);
+    }
+    else {
+        throw new Error(`Matrix stack underflow detected in ${id} matrix`);
+    }
+}
+
+export default class MatrixState {
+    private _projection: Mat4;
+    private _view: Mat4;
+    private _model: Mat4;
+    private _projMatrixStack: Mat4[];
+    private _viewMatrixStack: Mat4[];
+    private _modelMatrixStack: Mat4[];
+
+    constructor() {
+        this._projection = Mat4.MakeIdentity();
+        this._view = Mat4.MakeIdentity();
+        this._model = Mat4.MakeIdentity();
+
+        this._projMatrixStack = [];
+        this._viewMatrixStack = [];
+        this._modelMatrixStack = [];
+    }
+
+    get projection(): Mat4 { return this._projection; }
+    get view(): Mat4 { return this._view; }
+    get model(): Mat4 { return this._model; }
+
+    pushProjection(): void { pushMatrix(this._projection, this._projMatrixStack, 'projection'); }
+    popProjection(): void { popMatrix(this._projection, this._projMatrixStack, 'projection'); }
+    pushView(): void { pushMatrix(this._view, this._viewMatrixStack, 'view'); }
+    popView(): void { popMatrix(this._view, this._viewMatrixStack, 'view'); }
+    pushModel(): void { pushMatrix(this._model, this._modelMatrixStack, 'model'); }
+    popModel(): void { popMatrix(this._model, this._modelMatrixStack, 'model'); }
+}