@dcl/ecs 7.0.0-3532389879.commit-c89c80c → 7.0.0-3568547351.commit-5420eac

package/dist/schemas/index.js

@@ -0,0 +1,37 @@
+import { IArray } from './Array';
+import { Bool } from './basic/Boolean';
+import { IEnum } from './basic/Enum';
+import { Float32, Float64 } from './basic/Float';
+import { Int16, Int32, Int8, Int64 as iInt64 } from './basic/Integer';
+import { EcsString } from './basic/String';
+import { Color3Schema } from './custom/Color3';
+import { Color4Schema } from './custom/Color4';
+import { EntitySchema } from './custom/Entity';
+import { QuaternionSchema } from './custom/Quaternion';
+import { Vector3Schema } from './custom/Vector3';
+import { IMap } from './Map';
+import { IOptional } from './Optional';
+/**
+ * @public
+ */
+export var Schemas;
+(function (Schemas) {
+    Schemas.Boolean = Bool;
+    Schemas.String = EcsString;
+    Schemas.Float = Float32;
+    Schemas.Double = Float64;
+    Schemas.Byte = Int8;
+    Schemas.Short = Int16;
+    Schemas.Int = Int32;
+    Schemas.Int64 = iInt64;
+    Schemas.Number = Float32;
+    Schemas.Vector3 = Vector3Schema;
+    Schemas.Quaternion = QuaternionSchema;
+    Schemas.Color3 = Color3Schema;
+    Schemas.Color4 = Color4Schema;
+    Schemas.Entity = EntitySchema;
+    Schemas.Enum = IEnum;
+    Schemas.Array = IArray;
+    Schemas.Map = IMap;
+    Schemas.Optional = IOptional;
+})(Schemas || (Schemas = {}));

package/dist/schemas/typing.d.ts

@@ -0,0 +1,15 @@
+/** Include property keys from T where the property is assignable to U */
+export declare type IncludeUndefined<T> = {
+    [P in keyof T]: undefined extends T[P] ? P : never;
+}[keyof T];
+/** Excludes property keys from T where the property is assignable to U */
+export declare type ExcludeUndefined<T> = {
+    [P in keyof T]: undefined extends T[P] ? never : P;
+}[keyof T];
+export declare type OnlyOptionalUndefinedTypes<T> = {
+    [K in IncludeUndefined<T>]?: T[K];
+};
+export declare type OnlyNonUndefinedTypes<T> = {
+    [K in ExcludeUndefined<T>]: T[K];
+};
+export declare type ToOptional<T> = OnlyOptionalUndefinedTypes<T> & OnlyNonUndefinedTypes<T>;

package/dist/schemas/typing.js

@@ -0,0 +1 @@
+export {};

package/dist/serialization/ByteBuffer/index.d.ts

@@ -0,0 +1,140 @@
+/**
+ * @param writing - writing option, see object specs.
+ * @param reading - reading option, see object specs.
+ * @param initialCapacity - Initial capacity of buffer to allocate, ignored if you use writing or reading options
+ */
+export interface CreateByteBufferOptions {
+    /**
+     * @param buffer - a buffer already allocated to read from there.
+     * @param currentOffset - set the cursor where begins to read. Default 0
+     * @param length - delimite where the valid data ends. Default: buffer.length
+     */
+    reading?: {
+        buffer: Uint8Array;
+        length?: number;
+        currentOffset: number;
+    };
+    /**
+     * @param buffer - a buffer already allocated to write there.
+     * @param currentOffset - set the cursor to not start writing from the begin of it. Default 0
+     */
+    writing?: {
+        buffer: Uint8Array;
+        currentOffset?: number;
+    };
+    initialCapacity?: number;
+}
+/**
+ * ByteBuffer is a wrapper of DataView which also adds a read and write offset.
+ *  Also in a write operation it resizes the buffer is being used if it needs.
+ *
+ * - Use read and write function to generate or consume data.
+ * - Use set and get only if you are sure that you're doing.
+ */
+export declare function createByteBuffer(options?: CreateByteBufferOptions): ByteBuffer;
+/**
+ * @public
+ */
+export declare type ByteBuffer = {
+    /**
+     * @returns The entire current Uint8Array.
+     *
+     * WARNING: if the buffer grows, the view had changed itself,
+     *  and the reference will be a invalid one.
+     */
+    buffer(): Uint8Array;
+    /**
+     * @returns The capacity of the current buffer
+     */
+    bufferLength(): number;
+    /**
+     * Resets byteBuffer to avoid creating a new one
+     */
+    resetBuffer(): void;
+    /**
+     * @returns The current read offset
+     */
+    currentReadOffset(): number;
+    /**
+     * @returns The current write offset
+     */
+    currentWriteOffset(): number;
+    /**
+     * Reading purpose
+     * Returns the previuos offsset size before incrementing
+     */
+    incrementReadOffset(amount: number): number;
+    /**
+     * @returns How many bytes are available to read.
+     */
+    remainingBytes(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readInt64(): bigint;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readUint64(): bigint;
+    readBuffer(): Uint8Array;
+    /**
+     * Writing purpose
+     */
+    /**
+     * Increment offset
+     * @param amount - how many bytes
+     * @returns The offset when this reserving starts.
+     */
+    incrementWriteOffset(amount: number): number;
+    /**
+     * @returns The total number of bytes writen in the buffer.
+     */
+    size(): number;
+    /**
+     * Take care using this function, if you modify the data after, the
+     * returned subarray will change too. If you'll modify the content of the
+     * bytebuffer, maybe you want to use toCopiedBinary()
+     *
+     * @returns The subarray from 0 to offset as reference.
+     */
+    toBinary(): Uint8Array;
+    /**
+     * Safe copied buffer of the current data of ByteBuffer
+     *
+     * @returns The subarray from 0 to offset.
+     */
+    toCopiedBinary(): Uint8Array;
+    writeBuffer(value: Uint8Array, writeLength?: boolean): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeInt64(value: bigint): void;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint32(value: number): void;
+    writeUint64(value: bigint): void;
+    getFloat32(offset: number): number;
+    getFloat64(offset: number): number;
+    getInt8(offset: number): number;
+    getInt16(offset: number): number;
+    getInt32(offset: number): number;
+    getInt64(offset: number): bigint;
+    getUint8(offset: number): number;
+    getUint16(offset: number): number;
+    getUint32(offset: number): number;
+    getUint64(offset: number): bigint;
+    setFloat32(offset: number, value: number): void;
+    setFloat64(offset: number, value: number): void;
+    setInt8(offset: number, value: number): void;
+    setInt16(offset: number, value: number): void;
+    setInt32(offset: number, value: number): void;
+    setInt64(offset: number, value: bigint): void;
+    setUint8(offset: number, value: number): void;
+    setUint16(offset: number, value: number): void;
+    setUint32(offset: number, value: number): void;
+    setUint64(offset: number, value: bigint): void;
+};

package/dist/serialization/ByteBuffer/index.js

@@ -0,0 +1,244 @@
+/**
+ * Take the max between currentSize and intendedSize and then plus 1024. Then,
+ *  find the next nearer multiple of 1024.
+ * @param currentSize - number
+ * @param intendedSize - number
+ * @returns the calculated number
+ */
+function getNextSize(currentSize, intendedSize) {
+    const minNewSize = Math.max(currentSize, intendedSize) + 1024;
+    return Math.ceil(minNewSize / 1024) * 1024;
+}
+const defaultInitialCapacity = 10240;
+/**
+ * ByteBuffer is a wrapper of DataView which also adds a read and write offset.
+ *  Also in a write operation it resizes the buffer is being used if it needs.
+ *
+ * - Use read and write function to generate or consume data.
+ * - Use set and get only if you are sure that you're doing.
+ */
+export function createByteBuffer(options = {}) {
+    const initialROffset = options.reading?.currentOffset || 0;
+    let initialBuffer = null;
+    let initialWOffset = 0;
+    if (options.writing) {
+        initialBuffer = options.writing.buffer;
+        if (options.writing.currentOffset) {
+            initialWOffset = options.writing.currentOffset;
+        }
+    }
+    else if (options.reading) {
+        initialBuffer = options.reading.buffer;
+        initialWOffset = options.reading.length || options.reading.buffer.length;
+    }
+    else {
+        initialBuffer = new Uint8Array(options.initialCapacity || defaultInitialCapacity);
+    }
+    let buffer = initialBuffer;
+    let view = new DataView(buffer.buffer, buffer.byteOffset);
+    let woffset = initialWOffset;
+    let roffset = initialROffset;
+    /**
+     * Increement the write offset and resize the buffer if it needs.
+     */
+    const woAdd = (amount) => {
+        if (woffset + amount > buffer.byteLength) {
+            const newsize = getNextSize(buffer.byteLength, woffset + amount);
+            const newBuffer = new Uint8Array(newsize);
+            newBuffer.set(buffer);
+            buffer = newBuffer;
+            view = new DataView(buffer.buffer);
+        }
+        woffset += amount;
+        return woffset - amount;
+    };
+    /**
+     * Increment the read offset and throw an error if it's trying to read
+     *  outside the bounds.
+     */
+    const roAdd = (amount) => {
+        if (roffset + amount > woffset) {
+            throw new Error('Outside of the bounds of writen data.');
+        }
+        roffset += amount;
+        return roffset - amount;
+    };
+    return {
+        buffer() {
+            return buffer;
+        },
+        bufferLength() {
+            return buffer.length;
+        },
+        resetBuffer() {
+            roffset = 0;
+            woffset = 0;
+        },
+        currentReadOffset() {
+            return roffset;
+        },
+        currentWriteOffset() {
+            return woffset;
+        },
+        incrementReadOffset(amount) {
+            return roAdd(amount);
+        },
+        remainingBytes() {
+            return woffset - roffset;
+        },
+        readFloat32() {
+            return view.getFloat32(roAdd(4));
+        },
+        readFloat64() {
+            return view.getFloat64(roAdd(8));
+        },
+        readInt8() {
+            return view.getInt8(roAdd(1));
+        },
+        readInt16() {
+            return view.getInt16(roAdd(2));
+        },
+        readInt32() {
+            return view.getInt32(roAdd(4));
+        },
+        readInt64() {
+            return view.getBigInt64(roAdd(8));
+        },
+        readUint8() {
+            return view.getUint8(roAdd(1));
+        },
+        readUint16() {
+            return view.getUint16(roAdd(2));
+        },
+        readUint32() {
+            return view.getUint32(roAdd(4));
+        },
+        readUint64() {
+            return view.getBigUint64(roAdd(8));
+        },
+        readBuffer() {
+            const length = view.getUint32(roAdd(4));
+            return buffer.subarray(roAdd(length), roAdd(0));
+        },
+        incrementWriteOffset(amount) {
+            return woAdd(amount);
+        },
+        size() {
+            return woffset;
+        },
+        toBinary() {
+            return buffer.subarray(0, woffset);
+        },
+        toCopiedBinary() {
+            return new Uint8Array(this.toBinary());
+        },
+        writeBuffer(value, writeLength = true) {
+            if (writeLength) {
+                this.writeUint32(value.byteLength);
+            }
+            const o = woAdd(value.byteLength);
+            buffer.set(value, o);
+        },
+        writeFloat32(value) {
+            const o = woAdd(4);
+            view.setFloat32(o, value);
+        },
+        writeFloat64(value) {
+            const o = woAdd(8);
+            view.setFloat64(o, value);
+        },
+        writeInt8(value) {
+            const o = woAdd(1);
+            view.setInt8(o, value);
+        },
+        writeInt16(value) {
+            const o = woAdd(2);
+            view.setInt16(o, value);
+        },
+        writeInt32(value) {
+            const o = woAdd(4);
+            view.setInt32(o, value);
+        },
+        writeInt64(value) {
+            const o = woAdd(8);
+            view.setBigInt64(o, value);
+        },
+        writeUint8(value) {
+            const o = woAdd(1);
+            view.setUint8(o, value);
+        },
+        writeUint16(value) {
+            const o = woAdd(2);
+            view.setUint16(o, value);
+        },
+        writeUint32(value) {
+            const o = woAdd(4);
+            view.setUint32(o, value);
+        },
+        writeUint64(value) {
+            const o = woAdd(8);
+            view.setBigUint64(o, value);
+        },
+        // Dataview Proxy
+        getFloat32(offset) {
+            return view.getFloat32(offset);
+        },
+        getFloat64(offset) {
+            return view.getFloat64(offset);
+        },
+        getInt8(offset) {
+            return view.getInt8(offset);
+        },
+        getInt16(offset) {
+            return view.getInt16(offset);
+        },
+        getInt32(offset) {
+            return view.getInt32(offset);
+        },
+        getInt64(offset) {
+            return view.getBigInt64(offset);
+        },
+        getUint8(offset) {
+            return view.getUint8(offset);
+        },
+        getUint16(offset) {
+            return view.getUint16(offset);
+        },
+        getUint32(offset) {
+            return view.getUint32(offset);
+        },
+        getUint64(offset) {
+            return view.getBigUint64(offset);
+        },
+        setFloat32(offset, value) {
+            view.setFloat32(offset, value);
+        },
+        setFloat64(offset, value) {
+            view.setFloat64(offset, value);
+        },
+        setInt8(offset, value) {
+            view.setInt8(offset, value);
+        },
+        setInt16(offset, value) {
+            view.setInt16(offset, value);
+        },
+        setInt32(offset, value) {
+            view.setInt32(offset, value);
+        },
+        setInt64(offset, value) {
+            view.setBigInt64(offset, value);
+        },
+        setUint8(offset, value) {
+            view.setUint8(offset, value);
+        },
+        setUint16(offset, value) {
+            view.setUint16(offset, value);
+        },
+        setUint32(offset, value) {
+            view.setUint32(offset, value);
+        },
+        setUint64(offset, value) {
+            view.setBigUint64(offset, value);
+        }
+    };
+}

package/dist/serialization/crdt/componentOperation.d.ts

@@ -0,0 +1,31 @@
+import { ComponentDefinition } from '../../engine/component';
+import { Entity } from '../../engine/entity';
+import { ByteBuffer } from '../ByteBuffer';
+import WireMessage from '../wireMessage';
+export declare namespace ComponentOperation {
+    /**
+     * @param entity - Uint32 number of the entity
+     * @param componentId - Uint32 number of id
+     * @param timestamp - Uint64 Lamport timestamp
+     * @param data - Uint8[] data of component
+     */
+    type IPutComponent = {
+        entity: Entity;
+        componentId: number;
+        timestamp: number;
+        data: Uint8Array;
+    };
+    type IDeleteComponent = {
+        entity: Entity;
+        componentId: number;
+        timestamp: number;
+        data?: undefined;
+    };
+    const MESSAGE_HEADER_LENGTH = 20;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(type: WireMessage.Enum, entity: Entity, timestamp: number, componentDefinition: ComponentDefinition<any, any>, buf: ByteBuffer): void;
+    function read(buf: ByteBuffer): (WireMessage.Header & (IPutComponent | IDeleteComponent)) | null;
+}

package/dist/serialization/crdt/componentOperation.js

@@ -0,0 +1,47 @@
+import WireMessage from '../wireMessage';
+export var ComponentOperation;
+(function (ComponentOperation) {
+    ComponentOperation.MESSAGE_HEADER_LENGTH = 20;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(type, entity, timestamp, componentDefinition, buf) {
+        // reserve the beginning
+        const startMessageOffset = buf.incrementWriteOffset(WireMessage.HEADER_LENGTH + ComponentOperation.MESSAGE_HEADER_LENGTH);
+        // write body
+        if (type === WireMessage.Enum.PUT_COMPONENT) {
+            componentDefinition.writeToByteBuffer(entity, buf);
+        }
+        const messageLength = buf.size() - startMessageOffset;
+        // Write WireMessage header
+        buf.setUint32(startMessageOffset, messageLength);
+        buf.setUint32(startMessageOffset + 4, type);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentDefinition._id);
+        buf.setUint64(startMessageOffset + 16, BigInt(timestamp));
+        buf.setUint32(startMessageOffset + 24, messageLength - ComponentOperation.MESSAGE_HEADER_LENGTH - WireMessage.HEADER_LENGTH);
+    }
+    ComponentOperation.write = write;
+    function read(buf) {
+        const header = WireMessage.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        const common = {
+            ...header,
+            entity: buf.readUint32(),
+            componentId: buf.readInt32(),
+            timestamp: Number(buf.readUint64())
+        };
+        if (header.type === WireMessage.Enum.DELETE_COMPONENT) {
+            return common;
+        }
+        return {
+            ...common,
+            data: buf.readBuffer()
+        };
+    }
+    ComponentOperation.read = read;
+})(ComponentOperation || (ComponentOperation = {}));

package/dist/serialization/wireMessage.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The wire message is the top-level message that can be packed
+ *  inside it can contain a data with another structure or protocol
+ *
+ * Each wire message has three primitive property that it'll never change
+ *   ---> length        uint32 (message size up to 4,294,967,295)
+ *   ---> version       uint32 (for now just a number which is zero)
+ *   ---> message type  uint32
+ * The length indicates how many bytes are above self, the version in
+ * combination with message type defines the set of handlers that will be
+ * available to process the message
+ *
+ */
+import { ByteBuffer } from './ByteBuffer';
+export declare namespace WireMessage {
+    type Uint32 = number;
+    enum Enum {
+        RESERVED = 0,
+        PUT_COMPONENT = 1,
+        DELETE_COMPONENT = 2,
+        MAX_MESSAGE_TYPE = 3
+    }
+    /**
+     * @param length - Uint32 the length of all message (including the header)
+     * @param type - define the function which handles the data
+     */
+    type Header = {
+        length: Uint32;
+        type: Uint32;
+    };
+    const HEADER_LENGTH = 8;
+    /**
+     * Validate if the message incoming is completed
+     * @param buf - ByteBuffer
+     */
+    function validate(buf: ByteBuffer): boolean;
+    function readHeader(buf: ByteBuffer): Header | null;
+}
+export default WireMessage;

package/dist/serialization/wireMessage.js

@@ -0,0 +1,52 @@
+/**
+ * The wire message is the top-level message that can be packed
+ *  inside it can contain a data with another structure or protocol
+ *
+ * Each wire message has three primitive property that it'll never change
+ *   ---> length        uint32 (message size up to 4,294,967,295)
+ *   ---> version       uint32 (for now just a number which is zero)
+ *   ---> message type  uint32
+ * The length indicates how many bytes are above self, the version in
+ * combination with message type defines the set of handlers that will be
+ * available to process the message
+ *
+ */
+export var WireMessage;
+(function (WireMessage) {
+    let Enum;
+    (function (Enum) {
+        Enum[Enum["RESERVED"] = 0] = "RESERVED";
+        // Component Operation
+        Enum[Enum["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
+        Enum[Enum["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
+        Enum[Enum["MAX_MESSAGE_TYPE"] = 3] = "MAX_MESSAGE_TYPE";
+    })(Enum = WireMessage.Enum || (WireMessage.Enum = {}));
+    WireMessage.HEADER_LENGTH = 8;
+    /**
+     * Validate if the message incoming is completed
+     * @param buf - ByteBuffer
+     */
+    function validate(buf) {
+        const rem = buf.remainingBytes();
+        if (rem < WireMessage.HEADER_LENGTH) {
+            return false;
+        }
+        const messageLength = buf.getUint32(buf.currentReadOffset());
+        if (rem < messageLength) {
+            return false;
+        }
+        return true;
+    }
+    WireMessage.validate = validate;
+    function readHeader(buf) {
+        if (!validate(buf)) {
+            return null;
+        }
+        return {
+            length: buf.readUint32(),
+            type: buf.readUint32()
+        };
+    }
+    WireMessage.readHeader = readHeader;
+})(WireMessage || (WireMessage = {}));
+export default WireMessage;

package/dist/systems/async-task.d.ts

@@ -0,0 +1,5 @@
+import { IEngine } from '../engine';
+export declare type Task<T = unknown> = () => Promise<T>;
+export declare function createTaskSystem(engine: IEngine): {
+    executeTask(task: Task): void;
+};

package/dist/systems/async-task.js

@@ -0,0 +1,28 @@
+function getAndClean(value) {
+    const messagesToProcess = Array.from(value);
+    value.length = 0;
+    return messagesToProcess;
+}
+export function createTaskSystem(engine) {
+    const tasks = [];
+    async function runTask(task) {
+        try {
+            const resp = await task();
+            return resp;
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    function executeTasks() {
+        for (const task of getAndClean(tasks)) {
+            runTask(task).catch(console.error);
+        }
+    }
+    engine.addSystem(executeTasks);
+    return {
+        executeTask(task) {
+            tasks.push(task);
+        }
+    };
+}

package/dist/systems/crdt/index.d.ts

@@ -0,0 +1,8 @@
+import type { IEngine } from '../../engine';
+import { Entity } from '../../engine/entity';
+import { Transport } from './types';
+export declare function crdtSceneSystem(engine: Pick<IEngine, 'getComponent'>): {
+    createMessages: (dirtyMap: Map<Entity, Set<number>>) => void;
+    receiveMessages: () => void;
+    addTransport: (transport: Transport) => void;
+};