bg2e-js 2.0.0 → 2.0.2

package/base/Environment.js

@@ -1,78 +0,0 @@
-
-
-export default class Environment {
-    constructor() {
-        this._renderer = null;
-
-        this._equirectangularTexture = null;
-        this._irradianceIntensity = 1;
-        this._showSkybox = true;
-        this._cubemapSize = 512;
-        this._irradianceMapSize = 32;
-        this._specularMapSize = 32;
-        this._specularMapL2Size = 32;
-
-        this._dirty = true;
-    }
-
-    get equirectangularTexture() { return this._equirectangularTexture; }
-    set equirectangularTexture(t) { this._equirectangularTexture = t; this._dirty = true; }
-    get irradianceIntensity() { return this._irradianceIntensity; }
-    set irradianceIntensity(value) { this._irradianceIntensity = value; this._dirty = true}
-    get showSkybox() { return this._showSkybox; }
-    set showSkybox(value) { this._showSkybox = value; this._dirty = true}
-    get cubemapSize() { return this._cubemapSize; }
-    set cubemapSize(value) { this._cubemapSize = value; this._dirty = true}
-    get irradianceMapSize() { return this._irradianceMapSize; }
-    set irradianceMapSize(value) { this._irradianceMapSize = value; this._dirty = true}
-    get specularMapSize() { return this._specularMapSize; }
-    set specularMapSize(value) { this._specularMapSize = value; this._dirty = true}
-    get specularMapL2Size() { return this._specularMapL2Size; }
-    set specularMapL2Size(value) { this._specularMapL2Size = value; this._dirty = true}
-
-    get renderer() {
-        return this._renderer;
-    }
-
-    destroy() {
-        if (this.renderer) {
-            this.renderer.destroy();
-        }
-    }
-    
-    clone() {
-        const result = new SkyCube();
-        result.assign(this);
-        return result;
-    }
-
-    assign(other) {
-        this.equirectangularTexture = other.equirectangularTexture;
-        this.irradianceIntensity = other.irradianceIntensity;
-        this.showSkybox = other.showSkybox;
-        this.cubemapSize = other.cubemapSize;
-        this.irradianceMapSize = other.irradianceMapSize;
-        this.specularMapSize = other.specularMapSize;
-        this.specularMapL2Size = other.specularMapL2Size;
-    }
-
-    async deserialize(sceneData) {
-        this.equirectangularTexture = sceneData.equirectangularTexture || this.equirectangularTexture;
-        this.irradianceIntensity = sceneData.irradianceIntensity || this.irradianceIntensity;
-        this.showSkybox = sceneData.showSkybox || this.showSkybox;
-        this.cubemapSize = sceneData.cubemapSize || this.cubemapSize;
-        this.irradianceMapSize = sceneData.irradianceMapSize || this.irradianceMapSize;
-        this.specularMapSize = sceneData.specularMapSize || this.specularMapSize;
-        this.specularMapL2Size = sceneData.specularMapL2Size || this.specularMapL2Size;
-    }
-
-    async serialize(sceneData) {
-        sceneData.equirectangularTexture = this.equirectangularTexture;
-        sceneData.irradianceIntensity = this.irradianceIntensity;
-        sceneData.showSkybox = this.showSkybox;
-        sceneData.cubemapSize = this.cubemapSize;
-        sceneData.irradianceMapSize = this.irradianceMapSize;
-        sceneData.specularMapSize = this.specularMapSize;
-        sceneData.specularMapL2Size = this.specularMapL2Size;
-    } 
-}

package/base/Light.js

@@ -1,176 +0,0 @@
-
-import Vec from '../math/Vec';
-import Mat4 from '../math/Mat4';
-import Color from './Color';
-
-export const LightType = Object.freeze({
-    DIRECTIONAL: 4,
-    SPOT: 1,
-    POINT: 5,
-    DISABLED: 10
-});
-
-export default class Light {
-    constructor() {
-        this._enabled = true;
-        
-        this._type = LightType.DIRECTIONAL;
-        
-        this._direction = new Vec(0,0,-1);
-        this._position = new Vec(0,0,0);
-        
-        this._color = new Color({ rgb: 0.9 });
-        this._intensity = 20;
-        this._spotCutoff = 20;
-        this._spotExponent = 30;
-        this._shadowStrength = 0.7;
-        this._castShadows = true;
-        this._shadowBias = 0.00002;
-        
-        this._projection = Mat4.MakeOrtho(-10,10,-10,10,0.1,500.0);
-
-        // Internal engine use. This attribute will not be serialized
-        this._depthTexture = null;
-    }
-    
-    clone() {
-        const newLight = new Light();
-        newLight.assign(this);
-        return newLight;
-    }
-    
-    assign(other) {
-        this.enabled = other.enabled;
-        this.type = other.type;
-        this.direction.assign(other.direction);
-        this.position.assign(other.position);
-        this.color.assign(other.color);
-        this.spotCutoff = other.spotCutoff;
-        this.spotExponent = other.spotExponent;
-        this.shadowStrength = other.shadowStrength;
-        this.castShadows = other.castShadows;
-        this.shadowBias = other.shadowBias;
-        this.intensity = other.intensity;
-        this.projection.assign(other.projection);
-    }
-    
-    get enabled() { return this._enabled; }
-    set enabled(v) { this._enabled = v; }
-    
-    get type() { return this._type; }
-    set type(t) { this._type = t; }
-    
-    get direction() { return this._direction; }
-    set direction(d) { this._direction = d; }
-
-    get position() { return this._position; }
-    set position(p) { this._position = p; }
-    
-    get color() { return this._color; }
-    set color(c) {
-        if (c.length === 3) {
-            this._color = new Vec([c[0], c[1], c[2], 1]);
-        }
-        else if (c.length === 4) {
-            this._color = new Vec(c);
-        }
-        else {
-            throw new Error(`Invalid light color assignment. Parameter must be a three or four component array.`);
-        }
-    }
-    get intensity() { return this._intensity; }
-    set intensity(i) { this._intensity = i; }
-    
-    get spotCutoff() { return this._spotCutoff; }
-    set spotCutoff(c) { this._spotCutoff = c; }
-    get spotExponent() { return this._spotExponent; }
-    set spotExponent(e) { this._spotExponent = e; }
-    
-    get shadowStrength() { return this._shadowStrength; }
-    set shadowStrength(s) { this._shadowStrength = s; }
-    get castShadows() { return this._castShadows; }
-    set castShadows(s) { this._castShadows = s; }
-    get shadowBias() { return this._shadowBias; }
-    set shadowBias(s) { this._shadowBias = s; }
-    
-    get projection() { return this._projection; }
-    set projection(p) { this._projection = p; }
-
-    get depthTexture() {
-        return this._depthTexture;
-    }
-
-    set depthTexture(t) {
-        this._depthTexture = t;
-    }
-
-    get viewMatrix() {
-        return this._viewMatrix;
-    }
-
-    set viewMatrix(m) {
-        this._viewMatrix = m;
-    }
-
-    async deserialize(sceneData) {
-        switch (sceneData.lightType) {
-        case 'kTypeDirectional':
-        case LightType.DIRECTIONAL:
-            this._type = LightType.DIRECTIONAL;
-            // Use the predefined shadow bias for directional lights
-            //this._shadowBias = sceneData.shadowBias;
-            break;
-        case 'kTypeSpot':
-        case LightType.SPOT:
-            this._type = LightType.SPOT;
-            this._shadowBias = sceneData.shadowBias;
-            break;
-        case 'kTypePoint':
-        case LightType.POINT:
-            this._type = LightType.POINT;
-            break;
-        default:
-            this._type = LightType.DIRECTIONAL;
-        }
-
-        const defaultIntensity = () => this._type === LightType.DIRECTIONAL ? 1 : 20;
-
-        this._position = sceneData.position || new Vec(0,0,0);
-        this._direction = sceneData.direction || new Vec(0, 0, -1);
-
-        if (sceneData.diffuse) {
-            this._color = new Color(sceneData.diffuse);
-            this._intensity = (sceneData.intensity || 1) * defaultIntensity();
-        }
-        else if (sceneData.color) {
-            this._color = new Color(sceneData.color);
-            this._intensity = sceneData.intensity || defaultIntensity();
-        }
-        
-        this._spotCutoff = sceneData.spotCutoff || 20;
-        this._spotExponent = sceneData.spotExponent || 30;
-        this._shadowStrength = sceneData.shadowStrength || 1;
-        if (sceneData.projection) {
-            this._projection = new Mat4(sceneData.projection);
-        }
-        this._castShadows = sceneData.castShadows !== undefined ? sceneData.castShadows : true;
-    }
-
-    async serialize(sceneData) {
-        const lightTypes = [];
-        lightTypes[LightType.DIRECTIONAL] = "kTypeDirectional";
-        lightTypes[LightType.SPOT] = "kTypeSpot";
-        lightTypes[LightType.POINT] = "kTypePoint";
-        sceneData.lightType = lightTypes[this._type];
-        sceneData.position = this._position;
-        sceneData.direction = this._direction;
-        sceneData.color = this._color;
-        sceneData.intensity = this._intensity;
-        sceneData.spotCutoff = this._spotCutoff || 20;
-        sceneData.spotExponent = this._spotExponent || 30;
-        sceneData.shadowStrength = this._shadowStrength;
-        sceneData.projection = this._projection;
-        sceneData.castShadows = this._castShadows;
-        sceneData.shadowBias = this._shadowBias || 0.0029;
-    }
-}