@openglobus/og 0.17.2 → 0.18.0

package/src/{og/light/LightSource.js → light/LightSource.ts}

@@ -1,12 +1,20 @@
-"use strict";
-
-import { Vec3 } from "../math/Vec3.js";
+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 {Object} [params] - Light parameters:
+ * @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.
@@ -14,26 +22,85 @@ import { Vec3 } from "../math/Vec3.js";
  * @param {number} [params.shininess]  - Specular shininess.
  */
 class LightSource {
-    static get _staticCounter() {
-        if (!this._counter && this._counter !== 0) {
-            this._counter = 0;
-        }
-        return this._counter;
-    }
 
-    static set _staticCounter(n) {
-        this._counter = n;
-    }
+    static __counter__: number = 0;
+
+    /**
+     * 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}
+     */
+    public _position: Vec3;
+
+    /**
+     * True if the light is directional.
+     * @public
+     * @type {boolean}
+     */
+    public 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;
 
-    constructor(name, params) {
-        params = params || {};
+    /**
+     * 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) {
 
         /**
          * Light name.
          * @protected
          * @type {string}
          */
-        this._name = name || "light_" + LightSource._staticCounter++;
+        this._name = name || "light_" + LightSource.__counter__++;
 
         /**
          * Render node where light is shines.
@@ -44,7 +111,7 @@ class LightSource {
 
         /**
          * Light position.
-         * @protected
+         * @public
          * @type {Vec3}
          */
         this._position = params.position || new Vec3();
@@ -54,7 +121,7 @@ class LightSource {
          * @public
          * @type {boolean}
          */
-        this.directional = params.derectional != undefined ? params.derectional : true;
+        this.directional = params.directional != undefined ? params.directional : true;
 
         /**
          * Ambient color.
@@ -103,7 +170,7 @@ class LightSource {
      * @public
      * @returns {LightSource}
      */
-    clone() {
+    public clone() {
         // TODO
     }
 
@@ -112,11 +179,11 @@ class LightSource {
      * @public
      * @param {boolean} active - Light activity.
      */
-    setActive(active) {
+    public setActive(active: boolean) {
         if (active && !this._active) {
-            var rn = this._renderNode;
+            const rn = this._renderNode;
             if (rn) {
-                var index = rn._lightsNames.indexOf(this._name);
+                let index = rn._lightsNames.indexOf(this._name);
                 this._shininess = rn._lightsParamsf[index] = this._tempShininess;
                 if (index != -1) {
                     index *= 9;
@@ -149,7 +216,7 @@ class LightSource {
      * @public
      * @returns {boolean}
      */
-    isActive() {
+    public isActive(): boolean {
         return this._active;
     }
 
@@ -157,26 +224,21 @@ class LightSource {
      * Set light source position, or if it is a directional type sets light direction vector.
      * @public
      * @param {Vec3} position - Light position or direction vector.
-     * @returns {LightSource}
      */
-    setPosition3v(position) {
+    public setPosition3v(position: Vec3) {
         this._position.x = position.x;
         this._position.y = position.y;
         this._position.z = position.z;
-        return this;
     }
 
     /**
      * Set light source position, or if it is a directional type sets light direction vector.
      * @public
-     * @param {Vec3} position - Light position or direction vector.
-     * @returns {LightSource}
      */
-    setPosition(x, y, z) {
+    public setPosition(x: number, y: number, z: number) {
         this._position.x = x;
         this._position.y = y;
         this._position.z = z;
-        return this;
     }
 
     /**
@@ -184,7 +246,7 @@ class LightSource {
      * @public
      * @returns {Vec3} - Light source position/direction.
      */
-    getPosition() {
+    public getPosition(): Vec3 {
         return this._position.clone();
     }
 
@@ -192,171 +254,148 @@ class LightSource {
      * Set ambient color.
      * @public
      * @param {Vec3} rgb - Ambient color.
-     * @returns {LightSource}
      */
-    setAmbient3v(rgb) {
-        return this.setAmbient(rgb.x, rgb.y, rgb.z);
+    public setAmbient3v(rgb: Vec3) {
+        this.setAmbient(rgb.x, rgb.y, rgb.z);
     }
 
     /**
      * Set diffuse color.
      * @public
      * @param {Vec3} rgb - Diffuse color.
-     * @returns {LightSource}
      */
-    setDiffuse3v(rgb) {
-        return this.setDiffuse(rgb.x, rgb.y, rgb.z);
+    public setDiffuse3v(rgb: Vec3) {
+        this.setDiffuse(rgb.x, rgb.y, rgb.z);
     }
 
     /**
      * Set specular color.
      * @public
      * @param {Vec3} rgb - Specular color.
-     * @returns {LightSource}
      */
-    setSpecular3v(rgb) {
-        return this.setSpecular(rgb.x, rgb.y, rgb.z);
+    public setSpecular3v(rgb: Vec3) {
+        this.setSpecular(rgb.x, rgb.y, rgb.z);
     }
 
     /**
      * Set ambient color.
      * @public
-     * @param {Vec3} rgb - Ambient color.
-     * @returns {LightSource}
      */
-    setAmbient(r, g, b) {
+    public setAmbient(r: number, g: number, b: number) {
         this._ambient.set(r, g, b);
-        var rn = this._renderNode;
+        const rn = this._renderNode;
         if (rn) {
-            var index = 9 * rn._lightsNames.indexOf(this._name);
+            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;
             }
         }
-        return this;
     }
 
     /**
      * Set diffuse color.
      * @public
-     * @returns {LightSource}
      */
-    setDiffuse(r, g, b) {
+    public setDiffuse(r: number, g: number, b: number) {
         this._diffuse.set(r, g, b);
-        var rn = this._renderNode;
+        const rn = this._renderNode;
         if (rn) {
-            var index = 9 * rn._lightsNames.indexOf(this._name);
+            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;
             }
         }
-        return this;
     }
 
     /**
      * Set specular color.
      * @public
-     * @returns {LightSource}
      */
-    setSpecular(r, g, b) {
+    public setSpecular(r: number, g: number, b: number) {
         this._specular.set(r, g, b);
-        var rn = this._renderNode;
+        const rn = this._renderNode;
         if (rn) {
-            var index = 9 * rn._lightsNames.indexOf(this._name);
+            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;
             }
         }
-        return this;
     }
 
     /**
      * Set material shininess.
      * @public
-     * @returns {LightSource}
      */
-    setShininess(shininess) {
+    public setShininess(shininess: number) {
         this._shininess = shininess;
-        var rn = this._renderNode;
+        const rn = this._renderNode;
         if (rn) {
-            var index = rn._lightsNames.indexOf(this._name);
+            let index = rn._lightsNames.indexOf(this._name);
             if (index != -1) {
                 rn._lightsParamsf[index] = shininess;
             }
         }
-        return this;
     }
 
     /**
      * Sets light to black.
      * @public
-     * @returns {LightSource}
      */
-    setBlack() {
+    public setBlack() {
         this._ambient.clear();
         this._diffuse.clear();
         this._specular.clear();
         this._shininess = 0;
-        var rn = this._renderNode;
+        const rn = this._renderNode;
         if (rn) {
-            var 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;
+            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;
             }
         }
-        return this;
     }
 
     /**
      * Adds current light to the render node scene.
      * @public
      * @param {RenderNode} renderNode - Render node scene.
-     * @returns {LightSource}
      */
-    addTo(renderNode) {
+    public addTo(renderNode: 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.toVec());
-        renderNode._lightsParamsv.push.apply(renderNode._lightsParamsv, this._diffuse.toVec());
-        renderNode._lightsParamsv.push.apply(renderNode._lightsParamsv, this._specular.toVec());
+        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();
-        return this;
     }
 
     /**
      * Removes from render node scene.
      * @public
      */
-    remove() {
-        var rn = this.renderNode;
+    public remove() {
+        const rn = this._renderNode;
         if (rn) {
-            var 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);
-            }
+            // 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;
     }
 }
 
-export { LightSource };
+export {LightSource};

package/src/{og/math/Line2.js → math/Line2.ts}

@@ -1,28 +1,31 @@
-'use strict';
-
-import { Vec2 } from './Vec2.js';
+import {Vec2} from './Vec2';
 
 export class Line2 {
+
+    public a: number;
+    public b: number;
+    public c: number;
+
     constructor(a = 0, b = 0, c = 0) {
         this.a = a;
         this.b = b;
         this.c = c;
     }
 
-    static get(p0, p1) {
+    static get(p0: Vec2, p1: Vec2): Line2 {
         return new Line2(p1.y - p0.y, p0.x - p1.x, p1.x * p0.y - p0.x * p1.y);
     }
 
-    static getParallel(l, p) {
+    static getParallel(l: Line2, p: Vec2): Line2 {
         return new Line2(l.a, l.b, -l.a * p.x - l.b * p.y);
     }
 
-    static getIntersection(L0, L1) {
-        var x = (L1.b * L0.c - L0.b * L1.c) / (L0.b * L1.a - L1.b * L0.a);
+    static getIntersection(L0: Line2, L1: Line2): Vec2 {
+        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) {
+    public intersects(l: Line2): Vec2 {
         return Line2.getIntersection(this, l);
     }
 }

package/src/{og/math/Line3.js → math/Line3.ts}

@@ -1,70 +1,93 @@
-'use strict';
-
-import { EPS10 } from '../math.js';
-import { Vec3 } from './Vec3.js';
-
+import {EPS10} from '../math';
+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 class Line3 {
-    constructor(p0, p1) {
+
+    /**
+     * First point of the line
+     * @public
+     * @type: Vec3
+     */
+    public p0: Vec3;
+
+    /**
+     * Second point of the line
+     * @public
+     * @type: Vec3
+     */
+    public p1: Vec3;
+
+    constructor(p0?: Vec3, p1?: Vec3) {
         this.p0 = p0 || new Vec3();
         this.p1 = p1 || new Vec3();
     }
 
-    getMagnitude() {
+    public getMagnitude(): number {
         return this.p0.distance(this.p1);
     }
 
-    getSphereIntersection(sphere) {
-        var p0 = this.p0,
+    public getSphereIntersection(sphere: Sphere): [Vec3] | [Vec3, Vec3] | [] {
+        let p0 = this.p0,
             p1 = this.p1;
 
-        var cx = sphere.x,
-            cy = sphere.y,
-            cz = sphere.z;
+        let cx = sphere.center.x,
+            cy = sphere.center.y,
+            cz = sphere.center.z;
 
-        var px = p0.x,
+        let px = p0.x,
             py = p0.y,
             pz = p0.z;
 
-        var vx = p1.x - px,
+        let vx = p1.x - px,
             vy = p1.y - py,
             vz = p1.z - pz;
 
-        var A = vx * vx + vy * vy + vz * vz,
+        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;
-        var D = B * B - 4 * A * C;
+        let D = B * B - 4 * A * C;
 
         if (D < 0) {
-            return null;
+            // no solutions
+            return [];
         }
 
-        var t1 = (-B - Math.Sqrt(D)) / (2.0 * A);
+        let t1 = (-B - Math.sqrt(D)) / (2.0 * A);
 
-        var solution1 = new Vec3(
+        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);
+            p0.z * (1 - t1) + t1 * p1.z
+        );
 
         if (D == 0) {
-            return solution1;
+            return [solution1];
         }
 
-        var t2 = (-B + Math.Sqrt(D)) / (2.0 * A);
-        var solution2 = new Vec3(
+        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)) {
+        if (Math.abs(t1 - 0.5) < Math.abs(t2 - 0.5)) {
             return [solution1, solution2];
         }
 
         return [solution2, solution1];
     }
 
-    intersects(line, res, res2) {
+    public intersects(line: Line3, res: Vec3, res2?: Vec3): boolean {
 
         let p13 = this.p0.sub(line.p0),
             p43 = line.p1.sub(line.p0);
@@ -111,7 +134,7 @@ export class Line3 {
         return true;
     }
 
-    getNearestDistancePoint(point, res) {
+    public getNearestDistancePoint(point: Vec3, res: Vec3): boolean {
 
         let p0 = this.p0,
             p1 = this.p1;
@@ -136,5 +159,4 @@ export class Line3 {
 
         return true;
     }
-
 }