simulationjsv2 0.6.0 → 0.7.1

package/dist/simulation.js

@@ -1,9 +1,10 @@
 import { vec3 } from 'wgpu-matrix';
-import { Instance, SimulationElement3d } from './graphics.js';
+import { EmptyElement, SimulationElement3d } from './graphics.js';
 import { BUF_LEN, worldProjMatOffset } from './constants.js';
-import { Color, matrix4, toSceneObjInfoMany, transitionValues, vector2, vector3 } from './utils.js';
+import { Color, matrix4, transitionValues, vector2, vector3 } from './utils.js';
 import { BlankGeometry } from './geometry.js';
-import { addObject, buildDepthTexture, buildMultisampleTexture, updateProjectionMatrix, createPipeline, getTotalVertices, logger, removeObject, removeObjectId, updateOrthoProjectionMatrix, updateWorldProjectionMatrix, wrapVoidPromise } from './internalUtils.js';
+import { SimSceneObjInfo, buildDepthTexture, buildMultisampleTexture, updateProjectionMatrix, createPipeline, getTotalVertices, logger, removeObjectId, updateOrthoProjectionMatrix, updateWorldProjectionMatrix } from './internalUtils.js';
+import { Settings } from './settings.js';
 const shader = `
 struct Uniforms {
   worldProjectionMatrix: mat4x4<f32>,
@@ -31,6 +32,7 @@ fn vertex_main(
 ) -> VertexOutput {
   var output: VertexOutput;
 
+
   if (drawingInstance == 1) {
     output.Position = uniforms.worldProjectionMatrix * uniforms.modelProjectionMatrix * instanceMatrices[instanceIdx] * vec4(position, 1.0);
   } else {
@@ -115,7 +117,95 @@ let aspectRatio = 0;
 const projMat = matrix4();
 const worldProjMat = matrix4();
 const orthoMatrix = matrix4();
-export class Simulation {
+export class Camera {
+    pos;
+    rotation;
+    aspectRatio = 1;
+    updated;
+    screenSize = vector2();
+    constructor(pos, rotation = vector3()) {
+        this.pos = pos;
+        this.updated = false;
+        this.rotation = rotation;
+    }
+    setScreenSize(size) {
+        this.screenSize = size;
+        this.aspectRatio = size[0] / size[1];
+        this.updated = true;
+    }
+    getScreenSize() {
+        return this.screenSize;
+    }
+    hasUpdated() {
+        return this.updated;
+    }
+    updateConsumed() {
+        this.updated = false;
+    }
+    move(amount, t = 0, f) {
+        const initial = vector3();
+        vec3.clone(this.pos, initial);
+        return transitionValues((p) => {
+            const x = amount[0] * p;
+            const y = amount[1] * p;
+            const z = amount[2] * p;
+            const diff = vector3(x, y, z);
+            vec3.add(this.pos, diff, this.pos);
+        }, () => {
+            vec3.add(initial, amount, this.pos);
+        }, t, f);
+    }
+    moveTo(pos, t = 0, f) {
+        const diff = vector3();
+        vec3.sub(pos, this.pos, diff);
+        return transitionValues((p) => {
+            const x = diff[0] * p;
+            const y = diff[1] * p;
+            const z = diff[2] * p;
+            const amount = vector3(x, y, z);
+            vec3.add(this.pos, amount, this.pos);
+        }, () => {
+            vec3.clone(pos, this.pos);
+        }, t, f);
+    }
+    rotateTo(value, t = 0, f) {
+        const diff = vec3.clone(value);
+        vec3.sub(diff, diff, this.rotation);
+        return transitionValues((p) => {
+            const x = diff[0] * p;
+            const y = diff[1] * p;
+            const z = diff[2] * p;
+            vec3.add(this.rotation, this.rotation, vector3(x, y, z));
+            this.updated = true;
+        }, () => {
+            this.rotation = value;
+        }, t, f);
+    }
+    rotate(amount, t = 0, f) {
+        const initial = vector3();
+        vec3.clone(this.rotation, initial);
+        return transitionValues((p) => {
+            const x = amount[0] * p;
+            const y = amount[1] * p;
+            const z = amount[2] * p;
+            vec3.add(this.rotation, vector3(x, y, z), this.rotation);
+            this.updated = true;
+        }, () => {
+            vec3.add(initial, amount, this.rotation);
+        }, t, f);
+    }
+    getRotation() {
+        return this.rotation;
+    }
+    getPos() {
+        return this.pos;
+    }
+    getAspectRatio() {
+        return this.aspectRatio;
+    }
+}
+export let camera = new Camera(vector3());
+export class Simulation extends Settings {
     canvasRef = null;
     bgColor = new Color(255, 255, 255);
     scene = [];
@@ -123,12 +213,12 @@ export class Simulation {
     running = true;
     initialized = false;
     frameRateView;
-    camera;
     device = null;
     pipelines = null;
     renderInfo = null;
     resizeEvents;
-    constructor(idOrCanvasRef, camera = null, showFrameRate = false) {
+    constructor(idOrCanvasRef, sceneCamera = null, showFrameRate = false) {
+        super();
         if (typeof idOrCanvasRef === 'string') {
             const ref = document.getElementById(idOrCanvasRef);
             if (ref !== null)
@@ -143,10 +233,9 @@ export class Simulation {
             throw logger.error(`Canvas ref/id provided is invalid`);
         }
         const parent = this.canvasRef.parentElement;
-        if (!camera)
-            this.camera = new Camera(vector3());
-        else
-            this.camera = camera;
+        if (sceneCamera) {
+            camera = sceneCamera;
+        }
         if (parent === null)
             throw logger.error('Canvas parent is null');
         this.resizeEvents = [];
@@ -173,10 +262,24 @@ export class Simulation {
         return (this.canvasRef?.height || 0) / devicePixelRatio;
     }
     add(el, id) {
-        addObject(this.scene, el, this.device, id);
+        if (el instanceof SimulationElement3d) {
+            if (this.device !== null) {
+                el.propagateDevice(this.device);
+            }
+            const obj = new SimSceneObjInfo(el, id);
+            this.scene.unshift(obj);
+        }
+        else {
+            throw logger.error('Cannot add invalid SimulationElement');
+        }
     }
     remove(el) {
-        removeObject(this.scene, el);
+        for (let i = 0; i < this.scene.length; i++) {
+            if (this.scene[i].getObj() === el) {
+                this.scene.splice(i, 1);
+                break;
+            }
+        }
     }
     removeId(id) {
         removeObjectId(this.scene, id);
@@ -228,16 +331,14 @@ export class Simulation {
                 format: 'bgra8unorm'
             });
             const screenSize = vector2(this.canvasRef.width, this.canvasRef.height);
-            this.camera.setScreenSize(screenSize);
+            camera.setScreenSize(screenSize);
             this.render(ctx);
         })();
     }
     propagateDevice(device) {
         for (let i = 0; i < this.scene.length; i++) {
             const el = this.scene[i].getObj();
-            if (el instanceof SceneCollection) {
-                el.setDevice(device);
-            }
+            el.propagateDevice(device);
         }
     }
     stop() {
@@ -294,8 +395,8 @@ export class Simulation {
             updateProjectionMatrix(projMat, newAspectRatio);
             aspectRatio = newAspectRatio;
         }
-        updateWorldProjectionMatrix(worldProjMat, projMat, this.camera);
-        updateOrthoProjectionMatrix(orthoMatrix, this.camera.getScreenSize());
+        updateWorldProjectionMatrix(worldProjMat, projMat);
+        updateOrthoProjectionMatrix(orthoMatrix, camera.getScreenSize());
         let multisampleTexture = buildMultisampleTexture(device, ctx, canvas.width, canvas.height);
         let depthTexture = buildDepthTexture(device, canvas.width, canvas.height);
         const renderPassDescriptor = {
@@ -328,14 +429,14 @@ export class Simulation {
             prevFps = fps;
             canvas.width = canvas.clientWidth * devicePixelRatio;
             canvas.height = canvas.clientHeight * devicePixelRatio;
-            const screenSize = this.camera.getScreenSize();
+            const screenSize = camera.getScreenSize();
             if (screenSize[0] !== canvas.width || screenSize[1] !== canvas.height) {
-                this.camera.setScreenSize(vector2(canvas.width, canvas.height));
+                camera.setScreenSize(vector2(canvas.width, canvas.height));
                 screenSize[0] = canvas.width;
                 screenSize[1] = canvas.height;
-                aspectRatio = this.camera.getAspectRatio();
+                aspectRatio = camera.getAspectRatio();
                 updateProjectionMatrix(projMat, aspectRatio);
-                updateWorldProjectionMatrix(worldProjMat, projMat, this.camera);
+                updateWorldProjectionMatrix(worldProjMat, projMat);
                 multisampleTexture = buildMultisampleTexture(device, ctx, screenSize[0], screenSize[1]);
                 depthTexture = buildDepthTexture(device, screenSize[0], screenSize[1]);
                 renderPassDescriptor.depthStencilAttachment.view = depthTexture.createView();
@@ -346,9 +447,9 @@ export class Simulation {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             renderPassDescriptor.colorAttachments[0].resolveTarget = ctx.getCurrentTexture().createView();
-            if (this.camera.hasUpdated()) {
-                updateOrthoProjectionMatrix(orthoMatrix, this.camera.getScreenSize());
-                updateWorldProjectionMatrix(worldProjMat, projMat, this.camera);
+            if (camera.hasUpdated()) {
+                updateOrthoProjectionMatrix(orthoMatrix, camera.getScreenSize());
+                updateWorldProjectionMatrix(worldProjMat, projMat);
             }
             const commandEncoder = device.createCommandEncoder();
             const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
@@ -362,7 +463,7 @@ export class Simulation {
                 });
             }
             this.renderScene(device, passEncoder, this.renderInfo.vertexBuffer, this.scene, 0, diff);
-            this.camera.updateConsumed();
+            camera.updateConsumed();
             passEncoder.end();
             device.queue.submit([commandEncoder.finish()]);
         };
@@ -384,7 +485,7 @@ export class Simulation {
                 scene[i].traverseLife(diff);
             }
             const obj = scene[i].getObj();
-            if (obj instanceof SceneCollection) {
+            if (obj.hasChildren()) {
                 let shaderInfo = undefined;
                 if (obj instanceof ShaderGroup) {
                     const pipeline = obj.getPipeline();
@@ -394,30 +495,27 @@ export class Simulation {
                             paramGenerator: obj.getVertexParamGenerator(),
                             bufferInfo: obj.hasBindGroup()
                                 ? {
-                                    buffers: obj.getBindGroupBuffers(),
+                                    buffers: obj.getBindGroupBuffers(device),
                                     layout: obj.getBindGroupLayout()
                                 }
                                 : null
                         };
                     }
                 }
-                currentOffset += this.renderScene(device, passEncoder, vertexBuffer, obj.getScene(), currentOffset, diff, shaderInfo || undefined);
-                continue;
+                currentOffset += this.renderScene(device, passEncoder, vertexBuffer, obj.getChildrenInfos(), currentOffset, diff, shaderInfo);
             }
+            if (obj.isEmpty)
+                continue;
             const buffer = new Float32Array(obj.getBuffer(shaderInfo?.paramGenerator));
             const bufLen = shaderInfo?.paramGenerator?.bufferSize || BUF_LEN;
             const vertexCount = buffer.length / bufLen;
-            device.queue.writeBuffer(vertexBuffer, currentOffset, buffer);
+            device.queue.writeBuffer(vertexBuffer, currentOffset, buffer.buffer, buffer.byteOffset, buffer.byteLength);
             vertexBuffer.unmap();
             passEncoder.setVertexBuffer(0, vertexBuffer, currentOffset, buffer.byteLength);
-            const modelMatrix = obj.getModelMatrix(this.camera);
+            const modelMatrix = obj.getModelMatrix();
             const uniformBuffer = obj.getUniformBuffer(device, modelMatrix);
-            if (obj.is3d) {
-                device.queue.writeBuffer(uniformBuffer, worldProjMatOffset, worldProjMat.buffer, worldProjMat.byteOffset, worldProjMat.byteLength);
-            }
-            else {
-                device.queue.writeBuffer(uniformBuffer, worldProjMatOffset, orthoMatrix.buffer, orthoMatrix.byteOffset, orthoMatrix.byteLength);
-            }
+            const projBuf = obj.is3d ? worldProjMat : orthoMatrix;
+            device.queue.writeBuffer(uniformBuffer, worldProjMatOffset, projBuf.buffer, projBuf.byteOffset, projBuf.byteLength);
             if (shaderInfo) {
                 passEncoder.setPipeline(shaderInfo.pipeline);
             }
@@ -436,7 +534,7 @@ export class Simulation {
             let instances = 1;
             if (this.renderInfo) {
                 let instanceBuffer;
-                if (obj instanceof Instance) {
+                if (obj.isInstance) {
                     instances = obj.getNumInstances();
                     instanceBuffer = obj.getMatrixBuffer(device);
                 }
@@ -480,7 +578,7 @@ export class Simulation {
             currentOffset += buffer.byteLength;
         }
         for (let i = toRemove.length - 1; i >= 0; i--) {
-            removeObject(scene, scene[i].getObj());
+            this.remove(scene[i].getObj());
         }
         return currentOffset - startOffset;
     }
@@ -496,179 +594,6 @@ export class Simulation {
         }
     }
 }
-export class SceneCollection extends SimulationElement3d {
-    geometry;
-    name;
-    scene;
-    device = null;
-    constructor(name) {
-        super(vector3());
-        this.wireframe = false;
-        this.name = name || null;
-        this.scene = [];
-        this.geometry = new BlankGeometry();
-    }
-    setWireframe(wireframe) {
-        this.wireframe = wireframe;
-        for (let i = 0; i < this.scene.length; i++) {
-            this.scene[i].getObj().setWireframe(wireframe);
-        }
-    }
-    getName() {
-        return this.name;
-    }
-    getScene() {
-        return this.scene;
-    }
-    setDevice(device) {
-        this.device = device;
-        this.propagateDevice(device);
-    }
-    propagateDevice(device) {
-        for (let i = 0; i < this.scene.length; i++) {
-            const el = this.scene[i].getObj();
-            if (el instanceof SceneCollection) {
-                el.setDevice(device);
-            }
-        }
-    }
-    getVertexCount() {
-        let total = 0;
-        for (let i = 0; i < this.scene.length; i++) {
-            total += this.scene[i].getObj().getVertexCount();
-        }
-        return total;
-    }
-    getSceneObjects() {
-        return this.scene.map((item) => item.getObj());
-    }
-    setSceneObjects(newScene) {
-        this.scene = toSceneObjInfoMany(newScene);
-    }
-    setScene(newScene) {
-        this.scene = newScene;
-    }
-    add(el, id) {
-        addObject(this.scene, el, this.device, id);
-    }
-    remove(el) {
-        removeObject(this.scene, el);
-    }
-    removeId(id) {
-        removeObjectId(this.scene, id);
-    }
-    /**
-     * @param lifetime - ms
-     */
-    setLifetime(el, lifetime) {
-        for (let i = 0; i < this.scene.length; i++) {
-            if (this.scene[i].getObj() === el)
-                this.scene[i].setLifetime(lifetime);
-        }
-    }
-    empty() {
-        this.scene = [];
-    }
-    getSceneBuffer() {
-        return this.scene.map((item) => item.getObj().getBuffer()).flat();
-    }
-    getWireframe() {
-        return this.getSceneBuffer();
-    }
-    getTriangles() {
-        return this.getSceneBuffer();
-    }
-    updateMatrix(camera) {
-        this.defaultUpdateMatrix(camera);
-    }
-}
-export class Camera {
-    pos;
-    rotation;
-    aspectRatio = 1;
-    updated;
-    screenSize = vector2();
-    constructor(pos, rotation = vector3()) {
-        this.pos = pos;
-        this.updated = false;
-        this.rotation = rotation;
-    }
-    setScreenSize(size) {
-        this.screenSize = size;
-        this.aspectRatio = size[0] / size[1];
-        this.updated = true;
-    }
-    getScreenSize() {
-        return this.screenSize;
-    }
-    hasUpdated() {
-        return this.updated;
-    }
-    updateConsumed() {
-        this.updated = false;
-    }
-    move(amount, t = 0, f) {
-        const initial = vector3();
-        vec3.clone(this.pos, initial);
-        return transitionValues((p) => {
-            const x = amount[0] * p;
-            const y = amount[1] * p;
-            const z = amount[2] * p;
-            const diff = vector3(x, y, z);
-            vec3.add(this.pos, diff, this.pos);
-        }, () => {
-            vec3.add(initial, amount, this.pos);
-        }, t, f);
-    }
-    moveTo(pos, t = 0, f) {
-        const diff = vector3();
-        vec3.sub(pos, this.pos, diff);
-        return transitionValues((p) => {
-            const x = diff[0] * p;
-            const y = diff[1] * p;
-            const z = diff[2] * p;
-            const amount = vector3(x, y, z);
-            vec3.add(this.pos, amount, this.pos);
-        }, () => {
-            vec3.clone(pos, this.pos);
-        }, t, f);
-    }
-    rotateTo(value, t = 0, f) {
-        const diff = vec3.clone(value);
-        vec3.sub(diff, diff, this.rotation);
-        return transitionValues((p) => {
-            const x = diff[0] * p;
-            const y = diff[1] * p;
-            const z = diff[2] * p;
-            vec3.add(this.rotation, this.rotation, vector3(x, y, z));
-            this.updated = true;
-        }, () => {
-            this.rotation = value;
-        }, t, f);
-    }
-    rotate(amount, t = 0, f) {
-        const initial = vector3();
-        vec3.clone(this.rotation, initial);
-        return transitionValues((p) => {
-            const x = amount[0] * p;
-            const y = amount[1] * p;
-            const z = amount[2] * p;
-            vec3.add(this.rotation, vector3(x, y, z), this.rotation);
-            this.updated = true;
-        }, () => {
-            vec3.add(initial, amount, this.rotation);
-        }, t, f);
-    }
-    getRotation() {
-        return this.rotation;
-    }
-    getPos() {
-        return this.pos;
-    }
-    getAspectRatio() {
-        return this.aspectRatio;
-    }
-}
 const defaultShaderCode = `
 struct Uniforms {
   worldProjectionMatrix: mat4x4<f32>,
@@ -679,8 +604,7 @@ struct Uniforms {
 
 @group(0) @binding(1) var<storage> instanceMatrices: array<mat4x4f>;
 `;
-export class ShaderGroup extends SceneCollection {
-    geometry;
+export class ShaderGroup extends EmptyElement {
     code;
     module;
     pipeline;
@@ -703,8 +627,7 @@ export class ShaderGroup extends SceneCollection {
         this.vertexParams = vertexParams;
         this.valueBuffers = null;
     }
-    propagateDevice(device) {
-        super.propagateDevice(device);
+    onDeviceChange(device) {
         this.module = device.createShaderModule({ code: this.code });
         const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
         const bindGroupLayout = device.createBindGroupLayout(baseBindGroupLayout);
@@ -728,16 +651,16 @@ export class ShaderGroup extends SceneCollection {
     getPipeline() {
         return this.pipeline;
     }
-    getBindGroupBuffers() {
+    getBindGroupBuffers(device) {
         if (this.bindGroup === null)
             return null;
-        if (this.device === null)
+        if (device === null)
             return null;
         const values = this.bindGroup.values();
         if (this.valueBuffers === null) {
             this.valueBuffers = [];
             for (let i = 0; i < values.length; i++) {
-                const buffer = this.createBuffer(this.device, values[i]);
+                const buffer = this.createBuffer(device, values[i]);
                 this.valueBuffers.push(buffer);
             }
         }
@@ -746,12 +669,12 @@ export class ShaderGroup extends SceneCollection {
                 const arrayConstructor = values[i].array;
                 const array = new arrayConstructor(values[i].value);
                 if (array.byteLength > this.valueBuffers[i].size) {
-                    const newBuffer = this.createBuffer(this.device, values[i]);
+                    const newBuffer = this.createBuffer(device, values[i]);
                     this.valueBuffers[i].destroy();
                     this.valueBuffers[i] = newBuffer;
                 }
                 else {
-                    this.device.queue.writeBuffer(this.valueBuffers[i], 0, array.buffer, array.byteOffset, array.byteLength);
+                    device.queue.writeBuffer(this.valueBuffers[i], 0, array.buffer, array.byteOffset, array.byteLength);
                 }
             }
         }
@@ -770,9 +693,6 @@ export class ShaderGroup extends SceneCollection {
         buffer.unmap();
         return buffer;
     }
-    updateMatrix(camera) {
-        this.defaultUpdateMatrix(camera);
-    }
     getVertexParamGenerator() {
         return this.paramGenerator;
     }
@@ -780,39 +700,3 @@ export class ShaderGroup extends SceneCollection {
         return !!this.bindGroup;
     }
 }
-export class Group extends SceneCollection {
-    constructor(name) {
-        super(name);
-    }
-    move(amount, t, f) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return this.loopElements((el) => el.move(amount, t, f));
-    }
-    moveTo(pos, t, f) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return this.loopElements((el) => el.moveTo(pos, t, f));
-    }
-    rotate(amount, t, f) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return this.loopElements((el) => el.rotate(amount, t, f));
-    }
-    rotateTo(rotation, t, f) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return this.loopElements((el) => el.rotateTo(rotation, t, f));
-    }
-    fill(newColor, t, f) {
-        return this.loopElements((el) => el.fill(newColor, t, f));
-    }
-    loopElements(cb) {
-        const scene = this.getScene();
-        const promises = Array(scene.length);
-        for (let i = 0; i < scene.length; i++) {
-            promises[i] = cb(scene[i].getObj());
-        }
-        return wrapVoidPromise(Promise.all(promises));
-    }
-}

package/dist/types.d.ts

@@ -65,6 +65,10 @@ export type LineGeometryParams = {
 export type PolygonGeometryParams = {
     points: Vertex[];
 };
+export type TraceLinesParams = {
+    vertices: Vertex[];
+    maxLength: number | null;
+};
 export type PipelineGroup = {
     triangleList: GPURenderPipeline;
     triangleStrip: GPURenderPipeline;

package/dist/utils.d.ts

@@ -21,9 +21,8 @@ export declare class Color {
 export declare class Vertex {
     private pos;
     private color;
-    private is3d;
     private uv;
-    constructor(x?: number, y?: number, z?: number, color?: Color, is3dPoint?: boolean, uv?: Vector2);
+    constructor(x?: number, y?: number, z?: number, color?: Color, uv?: Vector2);
     getPos(): Vector3;
     setPos(pos: Vector3): void;
     getColor(): Color | null;
@@ -33,18 +32,18 @@ export declare class Vertex {
     setX(x: number): void;
     setY(y: number): void;
     setZ(z: number): void;
-    setIs3d(is3d: boolean): void;
     clone(): Vertex;
     toBuffer(defaultColor: Color): number[];
 }
 /**
- * @param callback1 - called every frame until the animation is finished
- * @param callback2 - called after animation is finished (called immediately when t = 0)
+ * @param onFrame - called every frame until the animation is finished
+ * @param adjustment - called after animation is finished (called immediately when t = 0) if t > 0 it will only be called if `transformAdjustments` is enabled in settings
  * @param t - animation time (seconds)
  * @returns {Promise<void>}
  */
-export declare function transitionValues(callback1: (deltaT: number, t: number) => void, callback2: () => void, transitionLength: number, func?: (n: number) => number): Promise<void>;
-export declare function frameLoop<T extends (dt: number, ...args: any[]) => any>(cb: T): (...params: Parameters<T>) => void;
+export declare function transitionValues(onFrame: (deltaT: number, t: number, total: number) => void, adjustment: () => void, transitionLength: number, func?: (n: number) => number): Promise<void>;
+type Shift<T extends any[]> = T extends [] ? [] : T extends [unknown, ...infer R] ? R : never;
+export declare function frameLoop<T extends (dt: number, ...args: any[]) => any>(cb: T): (...params: Shift<Parameters<T>>) => void;
 export declare function clamp(num: number, min: number, max: number): number;
 export declare function lerp(a: number, b: number, t: number): number;
 export declare function smoothStep(t: number): number;
@@ -68,7 +67,7 @@ export declare function vector2FromVector3(vec: Vector3): Vector2;
 export declare function colorFromVector4(vec: Vector4): Color;
 export declare function randomInt(range: number, min?: number): number;
 export declare function randomColor(a?: number): Color;
-export declare function vertex(x?: number, y?: number, z?: number, color?: Color, is3dPoint?: boolean, uv?: Vector2): Vertex;
+export declare function vertex(x?: number, y?: number, z?: number, color?: Color, uv?: Vector2): Vertex;
 export declare function color(r?: number, g?: number, b?: number, a?: number): Color;
 export declare function colorf(val: number, a?: number): Color;
 export declare function splinePoint2d(end: Vertex, control1: Vector2, control2: Vector2, detail?: number): SplinePoint2d;
@@ -82,3 +81,4 @@ export declare function distance3d(vector1: Vector3, vector2: Vector3): number;
 export declare function toSceneObjInfo(el: AnySimulationElement, id?: string): SimSceneObjInfo;
 export declare function toSceneObjInfoMany(el: AnySimulationElement[], id?: (string | undefined)[]): SimSceneObjInfo[];
 export declare function interpolateColors(colors: Color[], t: number): Color;
+export {};