@divinevoxel/vlox 0.0.75 → 0.0.77

package/Builder/World/InitTasks.js

@@ -0,0 +1,129 @@
+import { WorldSimulation } from "../../WorldSimulation";
+import { Threads } from "@amodx/threads";
+import { Vector3Like } from "@amodx/math";
+import { VoxelTemplateRegister } from "../../Templates/VoxelTemplateRegister";
+import { VoxelPath } from "../../Templates/Path/VoxelPath";
+import PickVoxelWorld from "../../Voxels/Interaction/Functions/PickVoxelWorld";
+import { WorldCursor } from "../../World";
+import LockSectors from "../../World/Lock/Function/LockSectors";
+import UnLockSectors from "../../World/Lock/Function/UnLockSectors";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { VoxelSurfaceSelection } from "../../Templates/Selection/VoxelSurfaceSelection";
+import { VoxelBFSSelection } from "../../Templates/Selection/VoxelBFSSelection";
+import CreateFullTemplate from "../../Templates/Full/Functions/CreateFullTemplate";
+import { ExtrudeSelection } from "../../Templates/Functions/ExtrudeSelection";
+export function InitTasks() {
+    const dimension = WorldSimulation.getDimension(0);
+    const brush = dimension.getBrush();
+    const cursor = new WorldCursor();
+    const surfaceSelection = new VoxelSurfaceSelection();
+    const bfsSelection = new VoxelBFSSelection();
+    const updateData = {
+        includedAreas: [],
+    };
+    const buildAreaBounds = new BoundingBox();
+    Threads.registerTask("get-box-area-template", async ([min, max]) => {
+        await LockSectors(cursor.dimension, buildAreaBounds);
+        const archived = CreateFullTemplate(cursor, { min, max });
+        await UnLockSectors(cursor.dimension, buildAreaBounds);
+        return [archived];
+    });
+    Threads.registerTask("set-build-area", async ([min, max]) => {
+        buildAreaBounds.setMinMax(Vector3Like.Create(...min), Vector3Like.Create(...max));
+        updateData.includedAreas = [[min, max]];
+    });
+    Threads.registerTask("pick-voxel", async ([position, direction, length]) => {
+        const pickedVoxel = await PickVoxelWorld(cursor, position, direction, length);
+        //pick voxels error when not using shared memory if the secotrs are check out
+        return [pickedVoxel?.toJSON() || null];
+    });
+    /**
+     * Selections
+     */
+    Threads.registerTask("get-voxel-surface-selection", async ([position, normal, extrusion, maxSize]) => {
+        await LockSectors(cursor.dimension, buildAreaBounds);
+        surfaceSelection.reConstruct(cursor, position, normal, extrusion, maxSize);
+        await UnLockSectors(cursor.dimension, buildAreaBounds);
+        return [surfaceSelection.toJSON()];
+    });
+    Threads.registerTask("get-extruded-voxel-selection-template", async ([selectionData, normal]) => {
+        const selection = VoxelTemplateRegister.createSelection(selectionData);
+        await LockSectors(cursor.dimension, selection.bounds);
+        const fullVoxelTemplate = ExtrudeSelection(cursor, selection, normal);
+        await UnLockSectors(cursor.dimension, selection.bounds);
+        return [fullVoxelTemplate.toJSON()];
+    });
+    Threads.registerTask("get-voxel-bfs-selection", async ([position, maxSize]) => {
+        await LockSectors(cursor.dimension, buildAreaBounds);
+        bfsSelection.reConstruct(cursor, position, maxSize);
+        await UnLockSectors(cursor.dimension, buildAreaBounds);
+        return [bfsSelection.toJSON()];
+    });
+    /**
+     * Painting
+     */
+    Threads.registerTask("paint-voxel", async ([location, raw]) => {
+        await LockSectors(location[0], buildAreaBounds);
+        brush.setXYZ(location[1], location[2], location[3]);
+        brush.setRaw(raw);
+        brush.paint(updateData);
+        await UnLockSectors(location[0], buildAreaBounds);
+    });
+    Threads.registerTask("erase-voxel", async (location) => {
+        await LockSectors(location[0], buildAreaBounds);
+        brush.dimension = location[0];
+        brush.setXYZ(location[1], location[2], location[3]);
+        brush.erase(updateData);
+        await UnLockSectors(location[0], buildAreaBounds);
+    });
+    Threads.registerTask("create-voxel-template", async ([location, bounds]) => {
+        const boundingBox = new BoundingBox(bounds.min, bounds.max);
+        await LockSectors(location[0], boundingBox);
+        const template = CreateFullTemplate(cursor, bounds);
+        await UnLockSectors(location[0], boundingBox);
+        return [template];
+    });
+    Threads.registerTask("paint-voxel-template", async ([location, data]) => {
+        const template = VoxelTemplateRegister.create(data);
+        brush.dimension = location[0];
+        await LockSectors(location[0], template.bounds);
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .paintTemplate(template, updateData);
+        await UnLockSectors(location[0], template.bounds);
+    });
+    Threads.registerTask("erase-voxel-template", async ([location, data]) => {
+        brush.dimension = location[0];
+        const template = VoxelTemplateRegister.create(data);
+        await LockSectors(location[0], template.bounds);
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .eraseTemplate(template, updateData);
+        await UnLockSectors(location[0], template.bounds);
+    });
+    Threads.registerTask("erase-voxel-selection", async ([location, selectionData]) => {
+        brush.dimension = location[0];
+        const selection = VoxelTemplateRegister.createSelection(selectionData);
+        await LockSectors(location[0], selection.bounds);
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .eraseSelection(selection, updateData);
+        await UnLockSectors(location[0], selection.bounds);
+    });
+    Threads.registerTask("paint-voxel-path", async ([location, data]) => {
+        await LockSectors(location[0], buildAreaBounds);
+        brush.dimension = location[0];
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .paintPath(new VoxelPath(data), updateData);
+        await UnLockSectors(location[0], buildAreaBounds);
+    });
+    Threads.registerTask("erase-voxel-path", async ([location, data]) => {
+        await LockSectors(location[0], buildAreaBounds);
+        brush.dimension = location[0];
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .erasePath(new VoxelPath(data), updateData);
+        await UnLockSectors(location[0], buildAreaBounds);
+    });
+}

package/Builder/World/VoxelBuildSpaceWorld.d.ts

@@ -0,0 +1,4 @@
+export declare class VoxelBuildSpaceWorld {
+    private static BuildTaskInit;
+    constructor();
+}

package/Builder/World/VoxelBuildSpaceWorld.js

@@ -0,0 +1,10 @@
+import { InitTasks } from "./InitTasks";
+export class VoxelBuildSpaceWorld {
+    static BuildTaskInit = false;
+    constructor() {
+        if (!VoxelBuildSpaceWorld.BuildTaskInit) {
+            InitTasks();
+            VoxelBuildSpaceWorld.BuildTaskInit = true;
+        }
+    }
+}

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -31,26 +31,26 @@ export declare class DivineVoxelEngineRender {
         getSettingsCopy(): any;
         createEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null): EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null;
         addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null, options?: AddEventListenerOptions): void;
         removeEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null): void;
         dispatch<K extends "synced">(type: K, detail: {
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]): boolean;
         dispatchEvent(event: Event): boolean;

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -22,26 +22,26 @@ export declare class DivineVoxelEngineWorld {
         getSettingsCopy(): any;
         createEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null): EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null;
         addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null, options?: AddEventListenerOptions): void;
         removeEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null): void;
         dispatch<K extends "synced">(type: K, detail: {
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]): boolean;
         dispatchEvent(event: Event): boolean;

package/Mesher/Geomtry/Proto/ProtoMesh.d.ts

@@ -0,0 +1,18 @@
+import { Vector3Like } from "@amodx/math";
+import { ProtoVertexBuffer, ProtoIndiceBuffer } from "./ProtoMeshBuffer";
+export declare class ProtoMesh {
+    vertexFloatSize: number;
+    indicieCount: number;
+    vertexCount: number;
+    minBounds: Vector3Like;
+    maxBounds: Vector3Like;
+    readonly buffer: ProtoVertexBuffer;
+    readonly indices: ProtoIndiceBuffer;
+    constructor(vertexFloatSize: number);
+    create(): {
+        vertexArray: Float32Array<ArrayBuffer>;
+        indiciesArray: Uint32Array<ArrayBuffer> | Uint16Array<ArrayBuffer>;
+    };
+    addVerticies(vertexCount: number, indicesCount: number): void;
+    clear(): void;
+}

package/Mesher/Geomtry/Proto/ProtoMesh.js

@@ -0,0 +1,73 @@
+import { Vector3Like } from "@amodx/math";
+import { ProtoVertexBuffer, ProtoIndiceBuffer } from "./ProtoMeshBuffer";
+export class ProtoMesh {
+    vertexFloatSize;
+    indicieCount = 0;
+    vertexCount = 0;
+    minBounds = Vector3Like.Create(Infinity, Infinity, Infinity);
+    maxBounds = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+    buffer;
+    indices;
+    constructor(vertexFloatSize) {
+        this.vertexFloatSize = vertexFloatSize;
+        this.buffer = new ProtoVertexBuffer(vertexFloatSize, 1024);
+        this.indices = new ProtoIndiceBuffer(1024);
+    }
+    create() {
+        const totalVerticies = this.vertexCount * this.vertexFloatSize;
+        const vertexArray = new Float32Array(totalVerticies);
+        const vertexBuffers = this.buffer._buffers;
+        let start = 0;
+        let done = false;
+        for (let i = 0; i < vertexBuffers.length; i++) {
+            const buffer = vertexBuffers[i];
+            for (let j = 0; j < buffer.length; j++) {
+                vertexArray[start] = buffer[j];
+                start++;
+                if (start > totalVerticies) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+        const indiciesArray = this.indicieCount > 65535
+            ? new Uint32Array(this.indicieCount)
+            : new Uint16Array(this.indicieCount);
+        const indiceBuffers = this.indices._buffers;
+        start = 0;
+        done = false;
+        for (let i = 0; i < indiceBuffers.length; i++) {
+            const buffer = indiceBuffers[i];
+            for (let j = 0; j < buffer.length; j++) {
+                indiciesArray[start] = buffer[j];
+                start++;
+                if (start > this.indicieCount) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+        return {
+            vertexArray,
+            indiciesArray,
+        };
+    }
+    addVerticies(vertexCount, indicesCount) {
+        this.vertexCount += vertexCount;
+        this.indicieCount += indicesCount;
+    }
+    clear() {
+        this.indicieCount = 0;
+        this.vertexCount = 0;
+        this.minBounds.x = Infinity;
+        this.minBounds.y = Infinity;
+        this.minBounds.z = Infinity;
+        this.maxBounds.x = -Infinity;
+        this.maxBounds.y = -Infinity;
+        this.maxBounds.z = -Infinity;
+    }
+}

package/Mesher/Geomtry/{VoxelMeshBuffers.d.ts → Proto/ProtoMeshBuffer.d.ts}

@@ -1,4 +1,4 @@
-export declare class VoxelVertexBuffer {
+export declare class ProtoVertexBuffer {
     vertexFloatSize: number;
     sectorVertexSize: number;
     _buffers: Float32Array[];
@@ -9,7 +9,7 @@ export declare class VoxelVertexBuffer {
     _index: number;
     setIndex(index: number): void;
 }
-export declare class VoxelIndiceBuffer {
+export declare class ProtoIndiceBuffer {
     sectorSize: number;
     _buffers: Uint32Array[];
     constructor(sectorSize: number, startingSectorSize?: number);

package/Mesher/Geomtry/{VoxelMeshBuffers.js → Proto/ProtoMeshBuffer.js}

@@ -1,4 +1,4 @@
-export class VoxelVertexBuffer {
+export class ProtoVertexBuffer {
     vertexFloatSize;
     sectorVertexSize;
     _buffers = [];
@@ -25,7 +25,7 @@ export class VoxelVertexBuffer {
         this.currentArray = this._buffers[bufferIndex];
     }
 }
-export class VoxelIndiceBuffer {
+export class ProtoIndiceBuffer {
     sectorSize;
     _buffers = [];
     constructor(sectorSize, startingSectorSize = 8) {

package/Mesher/Geomtry/Shapes/Box.d.ts

@@ -1,17 +1,10 @@
 import { Vec3Array } from "@amodx/math";
 import { Quad } from "../Primitives";
+import { VoxelFaces } from "../../../Math";
 type BoxPoints = [Vec3Array, Vec3Array];
-type BoxQuads = [
-    up: Quad,
-    down: Quad,
-    north: Quad,
-    south: Quad,
-    east: Quad,
-    west: Quad
-];
 export declare class Box {
     static Create(points?: BoxPoints): Box;
-    quads: BoxQuads;
+    quads: Record<VoxelFaces, Quad>;
     constructor(data: {
         points?: BoxPoints;
     });

package/Mesher/Geomtry/Shapes/Box.js

@@ -1,4 +1,5 @@
 import { Quad } from "../Primitives";
+import { VoxelFaces } from "../../../Math";
 export class Box {
     static Create(points = [
         [0, 0, 0],
@@ -23,43 +24,37 @@ export class Box {
     setPoints(points) {
         const [startX, startY, startZ] = points[0];
         const [endX, endY, endZ] = points[1];
-        //top
-        this.quads[0].setPositions([
+        this.quads[VoxelFaces.Up].setPositions([
             [endX, endY, endZ],
             [startX, endY, endZ],
             [startX, endY, startZ],
             [endX, endY, startZ],
         ]);
-        //bottom
-        this.quads[1].setPositions([
+        this.quads[VoxelFaces.Down].setPositions([
             [startX, startY, endZ],
             [endX, startY, endZ],
             [endX, startY, startZ],
             [startX, startY, startZ],
         ]);
-        //north
-        this.quads[2].setPositions([
+        this.quads[VoxelFaces.North].setPositions([
             [startX, endY, endZ],
             [endX, endY, endZ],
             [endX, startY, endZ],
             [startX, startY, endZ],
         ]);
-        //south
-        this.quads[3].setPositions([
+        this.quads[VoxelFaces.South].setPositions([
             [endX, endY, startZ],
             [startX, endY, startZ],
             [startX, startY, startZ],
             [endX, startY, startZ],
         ]);
-        //east
-        this.quads[4].setPositions([
+        this.quads[VoxelFaces.East].setPositions([
             [endX, endY, endZ],
             [endX, endY, startZ],
             [endX, startY, startZ],
             [endX, startY, endZ],
         ]);
-        //west
-        this.quads[5].setPositions([
+        this.quads[VoxelFaces.West].setPositions([
             [startX, endY, startZ],
             [startX, endY, endZ],
             [startX, startY, endZ],

package/Mesher/Geomtry/Transform/TransformBox.js

@@ -1,9 +1,11 @@
 import { QuadVerticies } from "../Geometry.types";
 import { AMath, Vector3Like } from "@amodx/math";
+import { VoxelFacesArray } from "../../../Math";
 export function TransformBox(box, transform) {
     // Collect all unique vertices from the quads
     const vertexMap = new Map();
-    for (const quad of box.quads) {
+    for (const face of VoxelFacesArray) {
+        const quad = box.quads[face];
         const vertices = [
             quad.positions.vertices[QuadVerticies.TopRight],
             quad.positions.vertices[QuadVerticies.TopLeft],
@@ -123,7 +125,8 @@ export function TransformBox(box, transform) {
         }
     }
     // Update the quads with transformed vertices
-    for (const quad of box.quads) {
+    for (const face of VoxelFacesArray) {
+        const quad = box.quads[face];
         const originalVertices = [
             quad.positions.vertices[QuadVerticies.TopRight],
             quad.positions.vertices[QuadVerticies.TopLeft],

package/Mesher/InitMesher.js

@@ -1,7 +1,7 @@
-import { RenderedMaterials } from "./Models/RenderedMaterials";
-import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
-import { LiquidGeometryNode } from "./Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
-import { VoxelConstructor } from "./Models/VoxelConstructor.js";
+import { RenderedMaterials } from "./Voxels/Models/RenderedMaterials";
+import { VoxelModelConstructorRegister } from "./Voxels/Models/VoxelModelConstructorRegister.js";
+import { LiquidGeometryNode } from "./Voxels/Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
+import { VoxelConstructor } from "./Voxels/Models/VoxelConstructor.js";
 import { AOOcclusionFaceIndex } from "../Voxels/Models/Indexing/AOOcclusionFaceIndex";
 import { CulledOcclusionFaceIndex } from "../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export default function (materials, modelData) {

package/Mesher/InitTask.js

@@ -1,9 +1,9 @@
 import { Threads } from "@amodx/threads";
 import { WorldRegister } from "../World/WorldRegister";
-import { MeshSection } from "./Functions/MeshSection";
+import { MeshSection } from "./Voxels/MeshSection";
 import { TasksIds } from "../Tasks/TasksIds";
 import { getLocationData } from "../Util/LocationData";
-import { MeshSectionSnapShot } from "./Functions/MeshSectionSnapShot";
+import { MeshSectionSnapShot } from "./Voxels/MeshSectionSnapShot";
 import { SectionSnapShot, } from "../World/SnapShot/SectionSnapShot";
 export default function (rendererThread) {
     Threads.registerBinaryTask(TasksIds.BuildSection, (view) => {

package/Mesher/Items/Base/CompactItemMesh.d.ts

@@ -0,0 +1,3 @@
+import { CompactMeshData } from "../../Types/Mesher.types";
+import { ItemModelBuilder } from "../Models/ItemModelBuilder";
+export declare function CompactItemMesh(tools: ItemModelBuilder[], transfers?: any[]): CompactMeshData;

package/Mesher/Items/Base/CompactItemMesh.js

@@ -0,0 +1,20 @@
+export function CompactItemMesh(tools, transfers = []) {
+    const data = [];
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        if (!tool.mesh.vertexCount)
+            continue;
+        const { vertexArray, indiciesArray } = tool.mesh.create();
+        const minBounds = tool.mesh.minBounds;
+        const maxBounds = tool.mesh.maxBounds;
+        data.push([
+            tool.id,
+            vertexArray,
+            indiciesArray,
+            [minBounds.x, minBounds.y, minBounds.z],
+            [maxBounds.x, maxBounds.y, maxBounds.z],
+        ]);
+        transfers.push(vertexArray.buffer, indiciesArray.buffer);
+    }
+    return data;
+}

package/Mesher/Items/Geomtry/ItemGeometryBuilder.d.ts

@@ -0,0 +1,5 @@
+import { ItemModelBuilder } from "../Models/ItemModelBuilder";
+import { Quad } from "../../Geomtry/Primitives/Quad";
+import { Triangle } from "../../Geomtry/Primitives";
+export declare function addItemTriangle(builder: ItemModelBuilder, tri: Triangle): void;
+export declare function addItemQuad(builder: ItemModelBuilder, quad: Quad): void;

package/Mesher/Items/Geomtry/ItemGeometryBuilder.js

@@ -0,0 +1,131 @@
+import { QuadVerticies } from "../../Geomtry/Geometry.types";
+import { ItemMeshVertexConstants } from "./ItemMeshVertexStructCursor";
+export function addItemTriangle(builder, tri) {
+    if (!builder.mesh)
+        return;
+    const origin = builder.origin;
+    const texture = builder.vars.textureIndex;
+    const topRightPos = tri.positions.vertices[0];
+    const topLeftPos = tri.positions.vertices[1];
+    const bottomLeftPos = tri.positions.vertices[2];
+    const topRightNor = tri.normals.vertices[0];
+    const topLeftNor = tri.normals.vertices[1];
+    const bottomLeftNor = tri.normals.vertices[2];
+    const indices = builder.mesh.indices;
+    let indIndex = builder.mesh.indicieCount;
+    let sides = tri.doubleSided ? 2 : 1;
+    const baseIndex = builder.mesh.vertexCount;
+    while (sides--) {
+        const baseIndex = builder.mesh.vertexCount;
+        builder.mesh.buffer.setIndex(baseIndex);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topRightPos, topRightNor, tri.uvs.vertices[QuadVerticies.TopRight], texture);
+        builder.mesh.buffer.setIndex(baseIndex + 1);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, tri.uvs.vertices[QuadVerticies.TopLeft], texture);
+        builder.mesh.buffer.setIndex(baseIndex + 2);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, tri.uvs.vertices[QuadVerticies.BottomLeft], texture);
+        builder.mesh.addVerticies(3, 3);
+    }
+    if (!tri.doubleSided) {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+    }
+    else {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        index += 3;
+        indIndex += 3;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index + 3;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 1;
+    }
+    builder.vars.reset();
+}
+export function addItemQuad(builder, quad) {
+    if (!builder.mesh)
+        return;
+    const origin = builder.origin;
+    const texture = builder.vars.textureIndex;
+    const topRightPos = quad.positions.vertices[0];
+    const topLeftPos = quad.positions.vertices[1];
+    const bottomLeftPos = quad.positions.vertices[2];
+    const bottomRightPos = quad.positions.vertices[3];
+    const topRightNor = quad.normals.vertices[0];
+    const topLeftNor = quad.normals.vertices[1];
+    const bottomLeftNor = quad.normals.vertices[2];
+    const bottomRightNor = quad.normals.vertices[3];
+    const indices = builder.mesh.indices;
+    let indIndex = builder.mesh.indicieCount;
+    const baseIndex = builder.mesh.vertexCount;
+    builder.mesh.buffer.setIndex(baseIndex);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topRightPos, topRightNor, quad.uvs.vertices[QuadVerticies.TopRight], texture);
+    builder.mesh.buffer.setIndex(baseIndex + 1);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, quad.uvs.vertices[QuadVerticies.TopLeft], texture);
+    builder.mesh.buffer.setIndex(baseIndex + 2);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[QuadVerticies.BottomLeft], texture);
+    builder.mesh.buffer.setIndex(baseIndex + 3);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[QuadVerticies.BottomRight], texture);
+    if (!quad.doubleSided) {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        builder.mesh.addVerticies(4, 6);
+    }
+    else {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        indIndex += 6;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        builder.mesh.addVerticies(4, 12);
+    }
+    builder.vars.reset();
+}
+function addVertex(index, array, origin, position, normal, uvs, texture) {
+    index *= ItemMeshVertexConstants.VertexFloatSize;
+    array[ItemMeshVertexConstants.PositionOffset + index] = position.x + origin.x;
+    array[ItemMeshVertexConstants.PositionOffset + index + 1] =
+        position.y + origin.y;
+    array[ItemMeshVertexConstants.PositionOffset + index + 2] =
+        position.z + origin.z;
+    array[ItemMeshVertexConstants.UVOffset + index] = uvs.x;
+    array[ItemMeshVertexConstants.UVOffset + index + 1] = uvs.y;
+    array[ItemMeshVertexConstants.NormalOffset + index] = normal.x;
+    array[ItemMeshVertexConstants.NormalOffset + index + 1] = normal.y;
+    array[ItemMeshVertexConstants.NormalOffset + index + 2] = normal.z;
+    array[ItemMeshVertexConstants.TextureIndexOffset + index] = texture;
+}