bg2e-js 2.0.1 → 2.0.2

package/render/webgl/VertexBuffer.js

@@ -1,128 +0,0 @@
-
-export const BufferTarget = {
-    ARRAY_BUFFER:               0,
-    ELEMENT_ARRAY_BUFFER:       1,
-
-    // WebGL 2:
-    COPY_READ_BUFFER:           2,
-    COPY_WRITE_BUFFER:          3,
-    TRANSFORM_FEEDBACK_BUFFER:  4,
-    UNIFORM_BUFFER:             5,
-    PIXEL_PACK_BUFFER:          6,
-    PIXEL_UNPACK_BUFFER:        7
-};
-
-export const BufferUsage = {
-    STATIC_DRAW:    0,
-    DYNAMIC_DRAW:   1,
-    STREAM_DRAW:    2,
-
-    // WebGL 2:
-    STATIC_READ:    3,
-    DYNAMIC_READ:   4,
-    STREAM_READ:    5,
-    STATIC_COPY:    6,
-    DYNAMIC_COPY:   7,
-    STREAM_COPY:    8
-};
-
-const g_bufferTargetConversion = [];
-const g_bufferUsageConversion = [];
-
-const g_createdBuffers = {};
-
-// DEBUG: assign an unique identifier to each buffer
-let g_bg2e_id__ = 0;
-
-export default class VertexBuffer {
-
-    static Delete(buffer) {
-        const gls = Symbol.for(buffer._gl);
-        const buffer_s = Symbol.for(buffer._buffer);
-        g_createdBuffers[gls] = g_createdBuffers[gls] || {};
-        if (g_createdBuffers[gls][buffer_s]) {
-            delete g_createdBuffers[gls][buffer_s];
-        }
-        buffer._gl.deleteBuffer(buffer._buffer);
-        buffer._buffer = null;
-    }
-
-    static CreateArrayBuffer(gl,data,usage = BufferUsage.STATIC_DRAW) {
-        const buffer = new VertexBuffer(gl);
-        buffer.bind(BufferTarget.ARRAY_BUFFER);
-        buffer.bufferData(BufferTarget.ARRAY_BUFFER, data, usage);
-        return buffer;
-    }
-
-    static CreateElementArrayBuffer(gl,data,usage = BufferUsage.STATIC_DRAW) {
-        const buffer = new VertexBuffer(gl);
-        buffer.bind(BufferTarget.ELEMENT_ARRAY_BUFFER);
-        buffer.bufferData(BufferTarget.ELEMENT_ARRAY_BUFFER, data, usage);
-        return buffer;
-    }
-    
-    static CurrentBuffer(gl, target) {
-        if (target === BufferTarget.ARRAY_BUFFER) {
-            target = gl.ARRAY_BUFFER_BINDING;
-        }
-        else if (target === BufferTarget.ELEMENT_ARRAY_BUFFER) {
-            target = gl.ELEMENT_ARRAY_BUFFER_BINDING;
-        }
-        const gls = gl._bg2_id;
-        g_createdBuffers[gls] = g_createdBuffers[gls] || {}
-        const gl_buffer = gl.getParameter(target);
-        const buffer = g_createdBuffers[gls][gl_buffer._bg2e_id_];
-        return buffer;
-    }
-
-    get id() {
-        return this._buffer?._bg2e_id_;
-    }
-
-    constructor(gl) {
-        this._gl = gl;
-        this._buffer = gl.createBuffer();
-        gl._bg2_id_ = gl._bg2_id_ ?? ++g_bg2e_id__;
-        this._buffer._bg2e_id_ = ++g_bg2e_id__;
-        const gls = gl._bg2_id;
-        g_createdBuffers[gls] = g_createdBuffers[gls] || {}
-        g_createdBuffers[gls][this._buffer._bg2e_id_] = this;
-
-        if (g_bufferTargetConversion.length === 0) {
-            g_bufferTargetConversion.push(gl.ARRAY_BUFFER);
-            g_bufferTargetConversion.push(gl.ELEMENT_ARRAY_BUFFER);
-            g_bufferTargetConversion.push(gl.COPY_READ_BUFFER);
-            g_bufferTargetConversion.push(gl.COPY_WRITE_BUFFER);
-            g_bufferTargetConversion.push(gl.TRANSFORM_FEEDBACK_BUFFER);
-            g_bufferTargetConversion.push(gl.UNIFORM_BUFFER);
-            g_bufferTargetConversion.push(gl.PIXEL_PACK_BUFFER);
-            g_bufferTargetConversion.push(gl.PIXEL_UNPACK_BUFFER);
-        }
-
-        if (g_bufferUsageConversion.length === 0) {
-            g_bufferUsageConversion.push(gl.STATIC_DRAW);
-            g_bufferUsageConversion.push(gl.DYNAMIC_DRAW);
-            g_bufferUsageConversion.push(gl.STREAM_DRAW);
-            g_bufferUsageConversion.push(gl.STATIC_READ);
-            g_bufferUsageConversion.push(gl.DYNAMIC_READ);
-            g_bufferUsageConversion.push(gl.STREAM_READ);
-            g_bufferUsageConversion.push(gl.STATIC_COPY);
-            g_bufferUsageConversion.push(gl.DYNAMIC_COPY);
-            g_bufferUsageConversion.push(gl.STREAM_COPY);
-        }
-    }
-
-    get buffer() {
-        return this._buffer;
-    }
-
-    bind(target) {
-        this._gl.bindBuffer(g_bufferTargetConversion[target], this._buffer);
-    }
-
-    bufferData(target, data, usage, srcOffset = null, length = null) {
-        this._gl.bufferData(
-            g_bufferTargetConversion[target], data, 
-            g_bufferUsageConversion[usage], srcOffset, length);
-    }
-}

package/scene/Camera.js

@@ -1,378 +0,0 @@
-import Mat4 from "../math/Mat4";
-import Vec from "../math/Vec";
-import Component from "./Component";
-import MatrixStrategy from "../math/MatrixStrategy";
-import { radiansToDegrees } from "../math/functions";
-import NodeVisitor from "./NodeVisitor";
-import Node from "./Node";
-
-export class ProjectionStrategy extends MatrixStrategy {
-    static Factory(jsonData) {
-        const create = () => {
-            switch (jsonData?.type) {
-            case "PerspectiveProjectionMethod":
-                return new PerspectiveProjectionStrategy();
-            case "OpticalProjectionMethod":
-                return new OpticalProjectionStrategy();
-            case "OrthographicProjectionStrategy":
-                return new OrthographicProjectionStrategy();
-            default:
-                return null;
-            }
-        }
-
-        const result = create();
-        if (result) {
-            result.deserialize(jsonData);
-        }
-        return result;
-    }
-
-    constructor(target) {
-        super(target);
-
-        this._near = 0.1;
-        this._far = 1000.0;
-        this._viewport = new Vec([0, 0, 512, 512]);
-    }
-
-    clone() {
-        throw Error("ProjectionStrategy.clone(): method not implemented by child class.");
-    }
-
-    assign(other) {
-        this.near = other.near;
-        this.far = other.far;
-        this.viewport = new Vec(other.viewport);
-    }
-
-    set near(v) { this._near = v; this.apply(); }
-    get near() { return this._near; }
-    set far(v) { this._far = v; this.apply(); }
-    get far() { return this._far; }
-    set viewport(v) { this._viewport = v; this.apply(); }
-    get viewport() { return this._viewport; }
-
-    get fov() { return 0; }
-
-    serialize(jsonData) {
-        jsonData.near = this.near;
-        jsonData.far = this.far;
-        jsonData.viewport = this.viewport;
-    }
-
-    deserialize(jsonData) {
-        this.near = jsonData.near || this.near;
-        this.far = jsonData.far || this.far;
-        this.viewport = Array.isArray(jsonData.viewport) ? new Vec(jsonData.viewport) : this.viewport;
-    }
-}
-
-export class PerspectiveProjectionStrategy extends ProjectionStrategy {
-    constructor(target) {
-        super(target);
-        this._fov = 60;
-    }
-
-    set fov(f) { this._fov = f; this.apply(); }
-    get fov() { return this._fov; }
-
-    clone() {
-        const other = new PerspectiveProjectionStrategy(this._target);
-        other.assign(this);
-        return other;
-    }
-
-    assign(other) {
-        super.assign(other);
-        this.fov = other.fov;
-    }
-
-    apply() {
-        if (this.target) {
-            this.target.perspective(this.fov, this.viewport.aspectRatio, this.near, this.far);
-        }
-    }
-
-    serialize(jsonData) {
-        jsonData.type = "PerspectiveProjectionMethod";
-        jsonData.fov = this.fov;
-        super.serialize(jsonData);
-    }
-
-    deserialize(jsonData) {
-        super.deserialize(jsonData);
-        this.fov = jsonData.fov || this.fov;
-    }
-}
-
-export class OpticalProjectionStrategy extends ProjectionStrategy {
-    constructor(target) {
-        super(target);
-        this._focalLength = 50;
-        this._frameSize = 35;
-    }
-
-    set focalLength(v) { this._focalLength; this.apply(); }
-    get focalLength() { return this._focalLength; }
-    set frameSize(v) { this._frameSize; this.apply(); }
-    get frameSize() { return this._frameSize; }
-
-    get fov() {
-        return 2 * Math.atan((this.frameSize / 2.0) / this.focalLength);
-    }
-
-    clone() {
-        const other = new OpticalProjectionStrategy(this._target);
-        other.assign(this);
-        return other;
-    }
-
-    assign(other) {
-        super.assign(other);
-        this.focalLength = other.focalLength;
-        this.frameSize = other.frameSize;
-    }
-
-    apply() {
-        if (this.target) {
-            const fov = radiansToDegrees(this.fov);
-            this.target.perspective(fov, this.viewport.aspectRatio, this.near, this.far);
-        }
-    }
-
-    serialize(jsonData) {
-        super.serialize(jsonData);
-        jsonData.type = "OpticalProjectionMethod";
-        jsonData.frameSize = this.frameSize;
-        jsonData.focalLength = this.focalLength;
-    }
-
-    deserialize(jsonData) {
-        super.deserialize(jsonData);
-        this.frameSize = jsonData.frameSize || this.frameSize;
-        this.focalLength = jsonData.focalLength || this.focalLength;
-    }
-}
-
-export class OrthographicProjectionStrategy extends ProjectionStrategy {
-    constructor(target) {
-        super(target);
-        this._viewWidth = 100;
-    }
-
-    set viewWidth(v) { this._viewWidth = v; this.apply(); }
-    get viewWidth() { return this._viewWidth; }
-
-    clone() {
-        const other = new OrthographicProjectionStrategy(this._target);
-        other.assign(this);
-        return other;
-    }
-
-    asign(other) {
-        super.assign(other);
-        this.viewWidth = other.viewWidth;
-    }
-
-    apply() {
-        if (this.target) {
-            const height = this.viewWidth / this.viewport.aspectRatio;
-            const x = this.viewWidth / 2;
-            const y = height / 2;
-            this.target.ortho(-x, x, -y, y, -this._far, this._far);
-        }
-    }
-
-    serialize(jsonData) {
-        jsonData.type = "OrthographicProjectionStrategy";
-        jsonData.viewWidth = this.viewWidth;
-        super.serialize(jsonData);
-    }
-
-    deserialize(jsonData) {
-        this.viewWidth = jsonData.viewWidth || this.viewWidth;
-        super.deserialize(jsonData);
-    }
-}
-
-class SetMainCameraVisitor extends NodeVisitor {
-    constructor(mainCamera) {
-        super();
-        if (!mainCamera) {
-            throw Error("Set main camera: invalid parameter. The camera paremeter is null.")
-        }
-        if (!(mainCamera instanceof Camera)) {
-            throw Error("Set main camera: invalid parameter. The object is not an instance of Camera class.")
-        }
-        this._mainCamera = mainCamera;
-    }
-
-    visit(node) {
-        const cam = node.camera;
-        if (cam && cam === this._mainCamera) {
-            cam._isMain = true;
-        }
-        else if (cam && cam !== this._mainCamera) {
-            cam._isMain = false;
-        }
-    }
-}
-
-class GetMainCameraVisitor extends NodeVisitor {
-    constructor() {
-        super();
-        this._mainCamera;
-        this._firstCameraFound;
-    }
-
-    get mainCamera() {
-        return this._mainCamera;
-    }
-
-    get firstCameraFound() {
-        return this._firstCameraFound;
-    }
-
-    clear() {
-        this._mainCamera = null;
-        this._firstCameraFound = null;
-    }
-
-    visit(node) {
-        // Note: The _isMain flag is set in Cmaer.SetMain() function
-        if (node.camera && node.camera.isMain) {
-            node.camera._isMain = false;
-            if (this._mainCamera) {
-                console.warn("More than one main cameras found in the scene");
-            }
-            this._mainCamera = node.camera;
-        }
-        else if (node.camera && !this._firstCameraFound) {
-            node.camera._isMain = false;
-            this._firstCameraFound = node.camera;
-        }
-    }
-}
-
-export default class Camera extends Component {
-    static SetMain(sceneRoot,camera) {
-        const isNode = sceneRoot instanceof Node;
-        if (!isNode || sceneRoot.parent !== null) {
-            throw Error("Camera.setMain(): invalid parameter. Object is not a scene root");
-        }
-        const visitor = new SetMainCameraVisitor(camera);
-        sceneRoot.accept(visitor);
-        sceneRoot.__mainCamera__ = camera;
-    }
-
-    static GetMain(sceneRoot) {
-        if (!sceneRoot.__mainCamera__) {
-            const visitor = new GetMainCameraVisitor();
-            sceneRoot.accept(visitor);
-            sceneRoot.__mainCamera__ = visitor.result || visitor.firstCameraFound;
-            if (sceneRoot.__mainCamera__) {
-                sceneRoot.__mainCamera__._isMain = true;
-            }
-        }
-        return sceneRoot.__mainCamera__;
-    }
-
-    setMain(sceneRoot) {
-        Camera.SetMain(sceneRoot,this);
-    }
-
-    constructor() {
-        super("Camera");
-
-        this._projectionStrategy = null;
-        this._isMain = false;
-
-        this._projectionMatrix = Mat4.MakePerspective(45.0, 1, 0.1, 100.0);
-        this._viewport = new Vec(0, 0, 512, 512);
-
-        this._focusDistance = 5;
-    }
-
-    clone() {
-        const other = new Camera();
-        other.assign(this);
-        return other;
-    }
-
-    assign(other) {
-        other._projectionStrategy = this._projectionStrategy?.clone() || null;
-        // This attribute cannot be assigned, because there can only be one main camera.
-        other._isMain = false;
-        other._projectionMatrix = new Mat4(this._projectionMatrix);
-        other._viewport = new Vec(this._viewport);
-        other._focusDistance = this._focusDistance;
-    }
-
-    get isMain() {
-        return this._isMain;
-    }
-
-    get projectionMatrix() {
-        return this._projectionMatrix;
-    }
-
-    set projectionMatrix(p) {
-        this._projectionStrategy = null;
-        this._projectionMatrix = p;
-    }
-
-    get viewport() {
-        return this._viewport;
-    }
-
-    set viewport(vp) {
-        this._viewport = vp;
-    }
-
-    get projectionStrategy() {
-        return this._projectionStrategy;
-    }
-
-    set projectionStrategy(ps) {
-        this._projectionStrategy = ps;
-        this._projectionStrategy.target = this._projectionMatrix;
-    }
-
-    get focusDistance() {
-        return this._focusDistance;
-    }
-
-    set focusDistance(fd) {
-        this._focusDistance = fd;
-    }
-
-    // This function regenerate the projection matrix with the new
-    // aspect ratio, if the projectionStrategy is set.
-    resize(width,height) {
-        this._viewport = new Vec([0, 0, width, height]);
-        if (this._projectionStrategy) {
-            this._projectionStrategy.viewport = this._viewport;
-            this._projectionStrategy.apply();
-        }
-    }
-
-    async deserialize(sceneData,loader) {
-        this.focusDistance = sceneData.focusDistance ?? this._focusDistance;
-        if (sceneData.projectionMethod) {
-            this.projectionStrategy = ProjectionStrategy.Factory(sceneData.projectionMethod || {});
-        }
-    }
-
-    async serialize(sceneData,writer) {
-        super.serialize(sceneData,writer);
-        sceneData.isMain = this._isMain;
-        sceneData.focusDistance = this._focusDistance;
-        if (this.projectionStrategy) {
-            const projMethod = {};
-            sceneData.projectionMethod = projMethod;
-            this.projectionStrategy.serialize(projMethod);
-        }
-    }
-}
-

package/scene/Chain.js

@@ -1,43 +0,0 @@
-
-import Mat4 from "../math/Mat4";
-import Component from "./Component";
-
-export default class Chain extends Component {
-    constructor() {
-        super('Chain');
-    }
-
-    willUpdate(frame,matrixState) {
-        if (this.node) {
-            const matrix = Mat4.MakeIdentity();
-            this.node.children.forEach((child, index) => {
-                const trx = child.component("Transform");
-                const inJoint = child.component("InputChainJoint");
-                const outJoint = child.component("OutputChainJoint");
-
-                if (index>0 && inJoint) {
-                    inJoint.joint.applyTransform(matrix);
-                }
-                else {
-                    matrix.identity();
-                }
-
-                if (trx) {
-                    trx.matrix.assign(matrix);
-                }
-
-                if (outJoint) {
-                    outJoint.joint.applyTransform(matrix);
-                }
-            });
-        }
-    }
-    
-    clone() { return new Chain(); }
-    assign(other) {}
-    async deserialize(sceneData,loader) {}
-
-    async serialize(sceneData,writer) {
-        await super.serialize(sceneData,writer);
-    }
-}

package/scene/ChainJoint.js

@@ -1,55 +0,0 @@
-import Component from "./Component";
-import Joint, { LinkTransformOrder, LinkJoint } from "../phsics/joint";
-
-export class ChainJoint extends Component {
-    constructor(typeId) {
-        super(typeId);
-
-        this._joint = new LinkJoint();
-    }
-
-    get joint() { return this._joint; }
-    set joint(j) { this._joint = j; }
-
-    assign(other) {
-        this.joint.assign(other.joint);
-    }
-
-    async deserialize(sceneData,loader) {
-        if (sceneData.joint) {
-            this.joint = Joint.Factory(sceneData.joint);
-        }
-    }
-
-    async serialize(sceneData,writer) {
-        await super.serialize(sceneData,writer);
-        sceneData.joint = {};
-        this.joint.serialize(sceneData.joint);
-    }
-}
-
-export class InputChainJoint extends ChainJoint {
-    constructor() {
-        super('InputChainJoint');
-        this.joint.transformOrder = LinkTransformOrder.ROTATE_TRANSLATE;
-    }
-
-    clone() {
-        const result = new InputChainJoint();
-        result.assign(this);
-        return result;
-    }
-}
-
-export class OutputChainJoint extends ChainJoint {
-    constructor() {
-        super('OutputChainJoint');
-        this.joint.transformOrder = LinkTransformOrder.TRANSLATE_ROTATE;
-    }
-
-    clone() {
-        const result = new OutputChainJoint();
-        result.assign(this);
-        return result;
-    }
-}