@openglobus/og 0.17.2 → 0.18.1

package/lib/js/light/LightSource.d.ts

@@ -0,0 +1,174 @@
+import { Vec3 } from "../math/Vec3";
+import { RenderNode } from "../scene/RenderNode";
+export interface ILightSourceParams {
+    position?: Vec3;
+    directional?: boolean;
+    ambient?: Vec3;
+    diffuse?: Vec3;
+    specular?: Vec3;
+    shininess?: number;
+}
+/**
+ * Represents basic light source.
+ * @class
+ * @param {string} [name] - Light source name.
+ * @param {ILightSourceParams} [params] - Light parameters:
+ * @param {Vec3} [params.position] - Light source position if it is a point light, otherwise it is a light direction vector.
+ * @param {Vec3} [params.ambient]  - Ambient RGB color.
+ * @param {Vec3} [params.diffuse]  - Diffuse RGB color.
+ * @param {Vec3} [params.specular]  - Specular RGB color.
+ * @param {number} [params.shininess]  - Specular shininess.
+ */
+declare class LightSource {
+    static __counter__: number;
+    /**
+     * Light name.
+     * @protected
+     * @type {string}
+     */
+    protected _name: string;
+    /**
+     * Render node where light is shines.
+     * @protected
+     * @type {RenderNode}
+     */
+    protected _renderNode: RenderNode | null;
+    /**
+     * Light position.
+     * @public
+     * @type {Vec3}
+     */
+    _position: Vec3;
+    /**
+     * True if the light is directional.
+     * @public
+     * @type {boolean}
+     */
+    directional: boolean;
+    /**
+     * Ambient color.
+     * @protected
+     * @type {Vec3}
+     */
+    protected _ambient: Vec3;
+    /**
+     * Diffuse color.
+     * @protected
+     * @type {Vec3}
+     */
+    protected _diffuse: Vec3;
+    /**
+     * Specular color.
+     * @protected
+     * @type {Vec3}
+     */
+    protected _specular: Vec3;
+    /**
+     * Shininess.
+     * @protected
+     * @type {number}
+     */
+    protected _shininess: number;
+    /**
+     * Light activity.
+     * @protected
+     * @type {boolean}
+     */
+    protected _active: boolean;
+    protected _tempAmbient: Vec3;
+    protected _tempDiffuse: Vec3;
+    protected _tempSpecular: Vec3;
+    protected _tempShininess: number;
+    constructor(name: string, params: ILightSourceParams);
+    /**
+     * Creates clone of the current light object.
+     * @todo: TODO
+     * @public
+     * @returns {LightSource}
+     */
+    clone(): void;
+    /**
+     * Set light activity. If activity is false the light doesn't shine.
+     * @public
+     * @param {boolean} active - Light activity.
+     */
+    setActive(active: boolean): void;
+    /**
+     * Gets light activity.
+     * @public
+     * @returns {boolean}
+     */
+    isActive(): boolean;
+    /**
+     * Set light source position, or if it is a directional type sets light direction vector.
+     * @public
+     * @param {Vec3} position - Light position or direction vector.
+     */
+    setPosition3v(position: Vec3): void;
+    /**
+     * Set light source position, or if it is a directional type sets light direction vector.
+     * @public
+     */
+    setPosition(x: number, y: number, z: number): void;
+    /**
+     * Returns light source position, or if it is a directional type sets light direction vector.
+     * @public
+     * @returns {Vec3} - Light source position/direction.
+     */
+    getPosition(): Vec3;
+    /**
+     * Set ambient color.
+     * @public
+     * @param {Vec3} rgb - Ambient color.
+     */
+    setAmbient3v(rgb: Vec3): void;
+    /**
+     * Set diffuse color.
+     * @public
+     * @param {Vec3} rgb - Diffuse color.
+     */
+    setDiffuse3v(rgb: Vec3): void;
+    /**
+     * Set specular color.
+     * @public
+     * @param {Vec3} rgb - Specular color.
+     */
+    setSpecular3v(rgb: Vec3): void;
+    /**
+     * Set ambient color.
+     * @public
+     */
+    setAmbient(r: number, g: number, b: number): void;
+    /**
+     * Set diffuse color.
+     * @public
+     */
+    setDiffuse(r: number, g: number, b: number): void;
+    /**
+     * Set specular color.
+     * @public
+     */
+    setSpecular(r: number, g: number, b: number): void;
+    /**
+     * Set material shininess.
+     * @public
+     */
+    setShininess(shininess: number): void;
+    /**
+     * Sets light to black.
+     * @public
+     */
+    setBlack(): void;
+    /**
+     * Adds current light to the render node scene.
+     * @public
+     * @param {RenderNode} renderNode - Render node scene.
+     */
+    addTo(renderNode: RenderNode): void;
+    /**
+     * Removes from render node scene.
+     * @public
+     */
+    remove(): void;
+}
+export { LightSource };

package/lib/js/light/LightSource.js

@@ -0,0 +1,292 @@
+import { Vec3 } from "../math/Vec3";
+/**
+ * Represents basic light source.
+ * @class
+ * @param {string} [name] - Light source name.
+ * @param {ILightSourceParams} [params] - Light parameters:
+ * @param {Vec3} [params.position] - Light source position if it is a point light, otherwise it is a light direction vector.
+ * @param {Vec3} [params.ambient]  - Ambient RGB color.
+ * @param {Vec3} [params.diffuse]  - Diffuse RGB color.
+ * @param {Vec3} [params.specular]  - Specular RGB color.
+ * @param {number} [params.shininess]  - Specular shininess.
+ */
+class LightSource {
+    constructor(name, params) {
+        /**
+         * Light name.
+         * @protected
+         * @type {string}
+         */
+        this._name = name || "light_" + LightSource.__counter__++;
+        /**
+         * Render node where light is shines.
+         * @protected
+         * @type {RenderNode}
+         */
+        this._renderNode = null;
+        /**
+         * Light position.
+         * @public
+         * @type {Vec3}
+         */
+        this._position = params.position || new Vec3();
+        /**
+         * True if the light is directional.
+         * @public
+         * @type {boolean}
+         */
+        this.directional = params.directional != undefined ? params.directional : true;
+        /**
+         * Ambient color.
+         * @protected
+         * @type {Vec3}
+         */
+        this._ambient = params.ambient || new Vec3();
+        /**
+         * Diffuse color.
+         * @protected
+         * @type {Vec3}
+         */
+        this._diffuse = params.diffuse || new Vec3(0.8, 0.8, 0.8);
+        /**
+         * Specular color.
+         * @protected
+         * @type {Vec3}
+         */
+        this._specular = params.specular || new Vec3(0.18, 0.18, 0.18);
+        /**
+         * Shininess.
+         * @protected
+         * @type {number}
+         */
+        this._shininess = params.shininess != undefined ? params.shininess : 3.3;
+        /**
+         * Light activity.
+         * @protected
+         * @type {boolean}
+         */
+        this._active = true;
+        this._tempAmbient = this._ambient.clone();
+        this._tempDiffuse = this._diffuse.clone();
+        this._tempSpecular = this._specular.clone();
+        this._tempShininess = this._shininess;
+    }
+    /**
+     * Creates clone of the current light object.
+     * @todo: TODO
+     * @public
+     * @returns {LightSource}
+     */
+    clone() {
+        // TODO
+    }
+    /**
+     * Set light activity. If activity is false the light doesn't shine.
+     * @public
+     * @param {boolean} active - Light activity.
+     */
+    setActive(active) {
+        if (active && !this._active) {
+            const rn = this._renderNode;
+            if (rn) {
+                let index = rn._lightsNames.indexOf(this._name);
+                this._shininess = rn._lightsParamsf[index] = this._tempShininess;
+                if (index != -1) {
+                    index *= 9;
+                    this._ambient.x = rn._lightsParamsv[index] = this._tempAmbient.x;
+                    this._ambient.y = rn._lightsParamsv[index + 1] = this._tempAmbient.y;
+                    this._ambient.z = rn._lightsParamsv[index + 2] = this._tempAmbient.z;
+                    this._diffuse.x = rn._lightsParamsv[index + 3] = this._tempDiffuse.x;
+                    this._diffuse.y = rn._lightsParamsv[index + 4] = this._tempDiffuse.y;
+                    this._diffuse.z = rn._lightsParamsv[index + 5] = this._tempDiffuse.z;
+                    this._specular.x = rn._lightsParamsv[index + 6] = this._tempSpecular.x;
+                    this._specular.y = rn._lightsParamsv[index + 7] = this._tempSpecular.y;
+                    this._specular.z = rn._lightsParamsv[index + 8] = this._tempSpecular.z;
+                }
+            }
+            this._active = true;
+        }
+        else if (!active && this._active) {
+            this._tempAmbient = this._ambient.clone();
+            this._tempDiffuse = this._diffuse.clone();
+            this._tempSpecular = this._specular.clone();
+            this._tempShininess = this._shininess;
+            this.setBlack();
+            this._active = false;
+        }
+    }
+    /**
+     * Gets light activity.
+     * @public
+     * @returns {boolean}
+     */
+    isActive() {
+        return this._active;
+    }
+    /**
+     * Set light source position, or if it is a directional type sets light direction vector.
+     * @public
+     * @param {Vec3} position - Light position or direction vector.
+     */
+    setPosition3v(position) {
+        this._position.x = position.x;
+        this._position.y = position.y;
+        this._position.z = position.z;
+    }
+    /**
+     * Set light source position, or if it is a directional type sets light direction vector.
+     * @public
+     */
+    setPosition(x, y, z) {
+        this._position.x = x;
+        this._position.y = y;
+        this._position.z = z;
+    }
+    /**
+     * Returns light source position, or if it is a directional type sets light direction vector.
+     * @public
+     * @returns {Vec3} - Light source position/direction.
+     */
+    getPosition() {
+        return this._position.clone();
+    }
+    /**
+     * Set ambient color.
+     * @public
+     * @param {Vec3} rgb - Ambient color.
+     */
+    setAmbient3v(rgb) {
+        this.setAmbient(rgb.x, rgb.y, rgb.z);
+    }
+    /**
+     * Set diffuse color.
+     * @public
+     * @param {Vec3} rgb - Diffuse color.
+     */
+    setDiffuse3v(rgb) {
+        this.setDiffuse(rgb.x, rgb.y, rgb.z);
+    }
+    /**
+     * Set specular color.
+     * @public
+     * @param {Vec3} rgb - Specular color.
+     */
+    setSpecular3v(rgb) {
+        this.setSpecular(rgb.x, rgb.y, rgb.z);
+    }
+    /**
+     * Set ambient color.
+     * @public
+     */
+    setAmbient(r, g, b) {
+        this._ambient.set(r, g, b);
+        const rn = this._renderNode;
+        if (rn) {
+            let index = 9 * rn._lightsNames.indexOf(this._name);
+            if (index != -1) {
+                rn._lightsParamsv[index] = r;
+                rn._lightsParamsv[index + 1] = g;
+                rn._lightsParamsv[index + 2] = b;
+            }
+        }
+    }
+    /**
+     * Set diffuse color.
+     * @public
+     */
+    setDiffuse(r, g, b) {
+        this._diffuse.set(r, g, b);
+        const rn = this._renderNode;
+        if (rn) {
+            let index = 9 * rn._lightsNames.indexOf(this._name);
+            if (index != -1) {
+                rn._lightsParamsv[index + 3] = r;
+                rn._lightsParamsv[index + 4] = g;
+                rn._lightsParamsv[index + 5] = b;
+            }
+        }
+    }
+    /**
+     * Set specular color.
+     * @public
+     */
+    setSpecular(r, g, b) {
+        this._specular.set(r, g, b);
+        const rn = this._renderNode;
+        if (rn) {
+            let index = 9 * rn._lightsNames.indexOf(this._name);
+            if (index != -1) {
+                rn._lightsParamsv[index + 6] = r;
+                rn._lightsParamsv[index + 7] = g;
+                rn._lightsParamsv[index + 8] = b;
+            }
+        }
+    }
+    /**
+     * Set material shininess.
+     * @public
+     */
+    setShininess(shininess) {
+        this._shininess = shininess;
+        const rn = this._renderNode;
+        if (rn) {
+            let index = rn._lightsNames.indexOf(this._name);
+            if (index != -1) {
+                rn._lightsParamsf[index] = shininess;
+            }
+        }
+    }
+    /**
+     * Sets light to black.
+     * @public
+     */
+    setBlack() {
+        this._ambient.clear();
+        this._diffuse.clear();
+        this._specular.clear();
+        this._shininess = 0;
+        const rn = this._renderNode;
+        if (rn) {
+            let index = 9 * rn._lightsNames.indexOf(this._name);
+            if (index !== -1) {
+                rn._lightsParamsv[index] = rn._lightsParamsv[index + 1] = rn._lightsParamsv[index + 2] =
+                    rn._lightsParamsv[index + 3] = rn._lightsParamsv[index + 4] = rn._lightsParamsv[index + 5] =
+                        rn._lightsParamsv[index + 6] = rn._lightsParamsv[index + 7] = rn._lightsParamsv[index + 8] = 0;
+            }
+        }
+    }
+    /**
+     * Adds current light to the render node scene.
+     * @public
+     * @param {RenderNode} renderNode - Render node scene.
+     */
+    addTo(renderNode) {
+        this._renderNode = renderNode;
+        renderNode._lights.push(this);
+        renderNode._lightsNames.push(this._name);
+        renderNode._lightsParamsf.push(this._shininess);
+        renderNode._lightsParamsv.push.apply(renderNode._lightsParamsv, this._ambient.toArray());
+        renderNode._lightsParamsv.push.apply(renderNode._lightsParamsv, this._diffuse.toArray());
+        renderNode._lightsParamsv.push.apply(renderNode._lightsParamsv, this._specular.toArray());
+        renderNode.transformLights();
+    }
+    /**
+     * Removes from render node scene.
+     * @public
+     */
+    remove() {
+        const rn = this._renderNode;
+        if (rn) {
+            // let li = rn.getLightById(this._name);
+            // if (li != -1) {
+            //     rn._lights.splice(li, 1);
+            //     rn._lightsNames.splice(li, 1);
+            //     rn._lightsParamsf.splice(li, 1);
+            //     rn._lightsParamsv.splice(li, 9);
+            // }
+        }
+        this._renderNode = null;
+    }
+}
+LightSource.__counter__ = 0;
+export { LightSource };

package/lib/js/math/Line2.d.ts

@@ -0,0 +1,11 @@
+import { Vec2 } from './Vec2';
+export declare class Line2 {
+    a: number;
+    b: number;
+    c: number;
+    constructor(a?: number, b?: number, c?: number);
+    static get(p0: Vec2, p1: Vec2): Line2;
+    static getParallel(l: Line2, p: Vec2): Line2;
+    static getIntersection(L0: Line2, L1: Line2): Vec2;
+    intersects(l: Line2): Vec2;
+}

package/lib/js/math/Line2.js

@@ -0,0 +1,21 @@
+import { Vec2 } from './Vec2';
+export class Line2 {
+    constructor(a = 0, b = 0, c = 0) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+    }
+    static get(p0, p1) {
+        return new Line2(p1.y - p0.y, p0.x - p1.x, p1.x * p0.y - p0.x * p1.y);
+    }
+    static getParallel(l, p) {
+        return new Line2(l.a, l.b, -l.a * p.x - l.b * p.y);
+    }
+    static getIntersection(L0, L1) {
+        let x = (L1.b * L0.c - L0.b * L1.c) / (L0.b * L1.a - L1.b * L0.a);
+        return new Vec2(x, -(L0.c + L0.a * x) / L0.b);
+    }
+    intersects(l) {
+        return Line2.getIntersection(this, l);
+    }
+}

package/lib/js/math/Line3.d.ts

@@ -0,0 +1,28 @@
+import { Sphere } from "../bv/Sphere";
+import { Vec3 } from './Vec3';
+/**
+ * @todo: write tests
+ * @class Line3
+ * Represents a line segment in 3d space.
+ * @param {Vec3} [p0] - First point of the line
+ * @param {Vec3} [p1] - Second point of the line
+ */
+export declare class Line3 {
+    /**
+     * First point of the line
+     * @public
+     * @type: Vec3
+     */
+    p0: Vec3;
+    /**
+     * Second point of the line
+     * @public
+     * @type: Vec3
+     */
+    p1: Vec3;
+    constructor(p0?: Vec3, p1?: Vec3);
+    getMagnitude(): number;
+    getSphereIntersection(sphere: Sphere): [Vec3] | [Vec3, Vec3] | [];
+    intersects(line: Line3, res: Vec3, res2?: Vec3): boolean;
+    getNearestDistancePoint(point: Vec3, res: Vec3): boolean;
+}

package/lib/js/math/Line3.js

@@ -0,0 +1,85 @@
+import { EPS10 } from '../math';
+import { Vec3 } from './Vec3';
+/**
+ * @todo: write tests
+ * @class Line3
+ * Represents a line segment in 3d space.
+ * @param {Vec3} [p0] - First point of the line
+ * @param {Vec3} [p1] - Second point of the line
+ */
+export class Line3 {
+    constructor(p0, p1) {
+        this.p0 = p0 || new Vec3();
+        this.p1 = p1 || new Vec3();
+    }
+    getMagnitude() {
+        return this.p0.distance(this.p1);
+    }
+    getSphereIntersection(sphere) {
+        let p0 = this.p0, p1 = this.p1;
+        let cx = sphere.center.x, cy = sphere.center.y, cz = sphere.center.z;
+        let px = p0.x, py = p0.y, pz = p0.z;
+        let vx = p1.x - px, vy = p1.y - py, vz = p1.z - pz;
+        let A = vx * vx + vy * vy + vz * vz, B = 2.0 * (px * vx + py * vy + pz * vz - vx * cx - vy * cy - vz * cz), C = px * px - 2 * px * cx + cx * cx + py * py - 2 * py * cy + cy * cy +
+            pz * pz - 2 * pz * cz + cz * cz - sphere.radius * sphere.radius;
+        let D = B * B - 4 * A * C;
+        if (D < 0) {
+            // no solutions
+            return [];
+        }
+        let t1 = (-B - Math.sqrt(D)) / (2.0 * A);
+        let solution1 = new Vec3(p0.x * (1 - t1) + t1 * p1.x, p0.y * (1 - t1) + t1 * p1.y, p0.z * (1 - t1) + t1 * p1.z);
+        if (D == 0) {
+            return [solution1];
+        }
+        let t2 = (-B + Math.sqrt(D)) / (2.0 * A);
+        let solution2 = new Vec3(p0.x * (1 - t2) + t2 * p1.x, p0.y * (1 - t2) + t2 * p1.y, p0.z * (1 - t2) + t2 * p1.z);
+        // prefer a solution that's on the line segment itself
+        if (Math.abs(t1 - 0.5) < Math.abs(t2 - 0.5)) {
+            return [solution1, solution2];
+        }
+        return [solution2, solution1];
+    }
+    intersects(line, res, res2) {
+        let p13 = this.p0.sub(line.p0), p43 = line.p1.sub(line.p0);
+        if (Math.abs(p43.x) < EPS10 && Math.abs(p43.y) < EPS10 && Math.abs(p43.z) < EPS10) {
+            return false;
+        }
+        let p21 = this.p1.sub(this.p0);
+        if (Math.abs(p21.x) < EPS10 && Math.abs(p21.y) < EPS10 && Math.abs(p21.z) < EPS10) {
+            return false;
+        }
+        let d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z, d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z, d1321 = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z, d4343 = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z, d2121 = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z;
+        let denom = d2121 * d4343 - d4321 * d4321;
+        if (Math.abs(denom) < EPS10) {
+            return false;
+        }
+        let numer = d1343 * d4321 - d1321 * d4343;
+        let mua = numer / denom;
+        res.x = this.p0.x + mua * p21.x;
+        res.y = this.p0.y + mua * p21.y;
+        res.z = this.p0.z + mua * p21.z;
+        if (res2) {
+            let mub = (d1343 + d4321 * mua) / d4343;
+            res2.x = line.p0.x + mub * p43.x;
+            res2.y = line.p0.y + mub * p43.y;
+            res2.z = line.p0.z + mub * p43.z;
+        }
+        return true;
+    }
+    getNearestDistancePoint(point, res) {
+        let p0 = this.p0, p1 = this.p1;
+        let mag = this.getMagnitude();
+        let u = (((point.x - p0.x) * (p1.x - p0.x)) +
+            ((point.y - p0.y) * (p1.y - p0.y)) +
+            ((point.z - p0.z) * (p1.z - p0.z))) /
+            (mag * mag);
+        res.x = p0.x + u * (p1.x - p0.x);
+        res.y = p0.y + u * (p1.y - p0.y);
+        res.z = p0.z + u * (p1.z - p0.z);
+        if (u < 0.0 || u > 1.0) {
+            return false;
+        }
+        return true;
+    }
+}

package/lib/js/math/Mat3.d.ts

@@ -0,0 +1,77 @@
+import { Mat4 } from "./Mat4";
+import { Vec3 } from "./Vec3";
+export type NumberArray9 = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/**
+ * Class represents a 3x3 matrix.
+ * @class
+ */
+export declare class Mat3 {
+    /**
+     * A 3x3 matrix, indexing as a column-major order array.
+     * @public
+     * @type {Array.<number>}
+     */
+    _m: NumberArray9;
+    constructor();
+    /**
+     * Sets column-major order array matrix.
+     * @public
+     * @param {Array.<number>} m - Matrix array.
+     * @returns {Mat3}
+     */
+    set(m: NumberArray9): Mat3;
+    /**
+     * Duplicates a Mat3 instance.
+     * @public
+     * @returns {Mat3}
+     */
+    clone(): Mat3;
+    /**
+     * Copy matrix.
+     * @public
+     * @param {Mat3} a - Matrix to copy.
+     * @returns {Mat3}
+     */
+    copy(a: Mat3): Mat3;
+    /**
+     * Creates transposed matrix from the current.
+     * @public
+     * @returns {Mat3}
+     */
+    transposeTo(): Mat3;
+    /**
+     * Sets matrix to identity.
+     * @public
+     * @returns {Mat3}
+     */
+    setIdentity(): Mat3;
+    /**
+     * Multiply to 3d vector.
+     * @public
+     * @params {Vec3} p - 3d vector.
+     * @returns {Vec3}
+     */
+    mulVec(p: Vec3): Vec3;
+    /**
+     * Converts to 4x4 matrix.
+     * @public
+     * @returns {Mat4}
+     */
+    toMatrix4(): Mat4;
+}
+/**
+ * Mat3 factory.
+ * @static
+ * @return {Mat3}
+ */
+export declare function mat3(): Mat3;