@divinevoxel/vlox 0.0.74 → 0.0.76

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.js

@@ -0,0 +1,58 @@
+import { VoxelFaceNameArray } from "../../../Math";
+export class VoxelModelPlacingStrategy {
+    _faceMap = new Map();
+    _defaultState;
+    constructor(data) {
+        if (typeof data == "string") {
+            this._defaultState = data;
+        }
+        else {
+            for (const stragety of data) {
+                let faceArray = this._faceMap.get(stragety.face);
+                if (!faceArray) {
+                    faceArray = [];
+                    this._faceMap.set(stragety.face, faceArray);
+                }
+                faceArray.push(stragety);
+            }
+        }
+    }
+    getState(picked, alt = null) {
+        if (this._defaultState)
+            return this._defaultState;
+        const face = picked.unitNormalFace;
+        const delta = picked.delta;
+        const direction = picked.unitRayDirection;
+        const stragetegies = this._faceMap.get(typeof face == "number" ? VoxelFaceNameArray[face] : face);
+        if (!stragetegies)
+            return null;
+        let match = true;
+        for (const strat of stragetegies) {
+            if (alt !== null) {
+                if (strat.alt == undefined) {
+                    match = false;
+                }
+                if (strat.alt !== alt) {
+                    match = false;
+                }
+            }
+            if (strat.delta) {
+                if (!delta) {
+                    match = false;
+                }
+                else if (!(delta >= strat.delta[0] && delta <= strat.delta[1])) {
+                    match = false;
+                }
+            }
+            if (strat.direction[0] !== direction.x)
+                match = false;
+            if (strat.direction[1] !== direction.y)
+                match = false;
+            if (strat.direction[2] !== direction.z)
+                match = false;
+            if (match)
+                return strat.state;
+        }
+        return null;
+    }
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.types.d.ts

@@ -0,0 +1,15 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelFaceNames } from "../../../Math";
+/** Defines the state the model should be placed in given the parameters. */
+export interface VoxelPlacingStrategyData {
+    /** The closest voxel face of the intersected voxel model. */
+    face: VoxelFaceNames;
+    /** The direction of the ray that intersected the voxel that is being placed upon.  */
+    direction: Vec3Array;
+    /** The delta of the virtual voxel cube face intersected. If it was intersected halfway, it would be 0.5. */
+    delta?: [min: number, max: number];
+    /** Defines an alternative ID to override the same parameters. */
+    alt?: number;
+    /** The resulting state string of the model. */
+    state: string;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.types.js

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

package/Voxels/Interaction/Placing/VoxelPlacingStrategyRegister.d.ts

@@ -0,0 +1,7 @@
+import { VoxelPlacingStrategyData } from "./VoxelPlacingStrategy.types";
+import { VoxelModelPlacingStrategy } from "./VoxelPlacingStrategy";
+export declare class VoxelPlacingStrategyRegister {
+    static _stragies: Map<string, VoxelModelPlacingStrategy>;
+    static register(id: string, data: VoxelPlacingStrategyData[] | string): void;
+    static get(id: string): VoxelModelPlacingStrategy | null;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategyRegister.js

@@ -0,0 +1,13 @@
+import { VoxelModelPlacingStrategy } from "./VoxelPlacingStrategy";
+export class VoxelPlacingStrategyRegister {
+    static _stragies = new Map();
+    static register(id, data) {
+        this._stragies.set(id, new VoxelModelPlacingStrategy(data));
+    }
+    static get(id) {
+        const stragety = this._stragies.get(id);
+        if (!stragety)
+            return null;
+        return stragety;
+    }
+}

package/Voxels/Interaction/VoxelPickResult.d.ts

@@ -0,0 +1,51 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../Math";
+import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export interface VoxelPickResultData {
+    /**The origin of the ray */
+    rayOrigin: Vector3Like;
+    /**The direction of the ray */
+    rayDirection: Vector3Like;
+    /**The length of the ray */
+    rayLength: number;
+    /**The space position of the voxel */
+    position: Vector3Like;
+    /**The normal of the unit voxel that was hit */
+    normal: Vector3Like;
+    /**The distance from the ray start to the intersection point */
+    distance: number;
+    /**Position + the unit  normal */
+    normalPosition: Vector3Like;
+    /**The voxel data */
+    voxelData: RawVoxelData;
+    /**Closest unit normal of the ray direction */
+    unitRayDirection: Vector3Like;
+    /**Closest voxel face of the ray direction */
+    unitRayVoxelFace: VoxelFaces;
+    /**Closest unit normal of the picked normal */
+    unitNormal: Vector3Like;
+    /**Closest voxel face of the picked normal */
+    unitNormalFace: VoxelFaces;
+    delta: number;
+}
+export declare class VoxelPickResult implements VoxelPickResultData {
+    rayOrigin: Vector3Like;
+    rayDirection: Vector3Like;
+    rayLength: number;
+    voxelData: RawVoxelData;
+    position: Vector3Like;
+    normal: Vector3Like;
+    distance: number;
+    normalPosition: Vector3Like;
+    unitRayDirection: Vector3Like;
+    unitRayVoxelFace: VoxelFaces;
+    unitNormal: Vector3Like;
+    unitNormalFace: VoxelFaces;
+    delta: number;
+    voxel: VoxelCursor;
+    static FromJSON(data: VoxelPickResultData): VoxelPickResult;
+    constructor(rayOrigin: Vector3Like, rayDirection: Vector3Like, rayLength: number, voxelData: RawVoxelData, position: Vector3Like, normal: Vector3Like, distance: number, normalPosition: Vector3Like, unitRayDirection: Vector3Like, unitRayVoxelFace: VoxelFaces, unitNormal: Vector3Like, unitNormalFace: VoxelFaces, delta: number);
+    clone(): VoxelPickResult;
+    toJSON(): VoxelPickResultData;
+}

package/Voxels/Interaction/VoxelPickResult.js

@@ -0,0 +1,58 @@
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export class VoxelPickResult {
+    rayOrigin;
+    rayDirection;
+    rayLength;
+    voxelData;
+    position;
+    normal;
+    distance;
+    normalPosition;
+    unitRayDirection;
+    unitRayVoxelFace;
+    unitNormal;
+    unitNormalFace;
+    delta;
+    voxel;
+    static FromJSON(data) {
+        return new VoxelPickResult(data.rayOrigin, data.rayDirection, data.rayLength, data.voxelData, data.position, data.normal, data.distance, data.normalPosition, data.unitRayDirection, data.unitRayVoxelFace, data.unitNormal, data.unitNormalFace, data.delta);
+    }
+    constructor(rayOrigin, rayDirection, rayLength, voxelData, position, normal, distance, normalPosition, unitRayDirection, unitRayVoxelFace, unitNormal, unitNormalFace, delta) {
+        this.rayOrigin = rayOrigin;
+        this.rayDirection = rayDirection;
+        this.rayLength = rayLength;
+        this.voxelData = voxelData;
+        this.position = position;
+        this.normal = normal;
+        this.distance = distance;
+        this.normalPosition = normalPosition;
+        this.unitRayDirection = unitRayDirection;
+        this.unitRayVoxelFace = unitRayVoxelFace;
+        this.unitNormal = unitNormal;
+        this.unitNormalFace = unitNormalFace;
+        this.delta = delta;
+        this.voxel = new VoxelCursor();
+        this.voxel.setRaw(voxelData);
+        this.voxel.loadIn();
+    }
+    clone() {
+        return VoxelPickResult.FromJSON(this.toJSON());
+    }
+    toJSON() {
+        return {
+            rayOrigin: { ...this.rayOrigin },
+            rayDirection: { ...this.rayDirection },
+            rayLength: this.rayLength,
+            position: { ...this.position },
+            normal: { ...this.normal },
+            distance: this.distance,
+            normalPosition: { ...this.normalPosition },
+            unitRayDirection: { ...this.unitRayDirection },
+            unitRayVoxelFace: this.unitRayVoxelFace,
+            unitNormal: { ...this.unitNormal },
+            unitNormalFace: this.unitNormalFace,
+            voxelData: [...this.voxelData],
+            delta: this.delta,
+        };
+    }
+}

package/Voxels/Logic/Classes/Types/VoxelLogicPoweredType.d.ts

@@ -0,0 +1,8 @@
+import { VoxelLogicEffects, VoxelLogicPoweredData } from "../../VoxelLogic.types";
+import { VoxelCursorInterface } from "../../../Cursor/VoxelCursor.interface";
+import { VoxelLogicType } from "../VoxelLogicType";
+export declare class VoxelLogicPoweredType extends VoxelLogicType<VoxelLogicPoweredData> {
+    init(): void;
+    run(voxel: VoxelCursorInterface): boolean;
+    getEffects(): Generator<VoxelLogicEffects>;
+}

package/Voxels/Logic/Classes/Types/VoxelLogicPoweredType.js

@@ -0,0 +1,13 @@
+import { VoxelLogicType } from "../VoxelLogicType";
+export class VoxelLogicPoweredType extends VoxelLogicType {
+    init() { }
+    run(voxel) {
+        return voxel.getPower() > 0;
+    }
+    *getEffects() {
+        for (const effect of this.data.on)
+            yield effect;
+        for (const effect of this.data.off)
+            yield effect;
+    }
+}

package/Voxels/Logic/Classes/Types/VoxelLogicStateType.d.ts

@@ -0,0 +1,9 @@
+import { VoxelLogicEffects, VoxelLogicStateData } from "../../VoxelLogic.types";
+import { VoxelCursorInterface } from "../../../Cursor/VoxelCursor.interface";
+import { VoxelLogicType } from "../VoxelLogicType";
+export declare class VoxelLogicStateType extends VoxelLogicType<VoxelLogicStateData> {
+    keys: string[];
+    init(): void;
+    run(voxel: VoxelCursorInterface): boolean;
+    getEffects(): Generator<VoxelLogicEffects>;
+}

package/Voxels/Logic/Classes/Types/VoxelLogicStateType.js

@@ -0,0 +1,23 @@
+import { VoxelLogicType } from "../VoxelLogicType";
+export class VoxelLogicStateType extends VoxelLogicType {
+    keys;
+    init() {
+        this.keys = Object.keys(this.data.value);
+    }
+    run(voxel) {
+        this.voxelLogic.schema.state.startEncoding(voxel.getState());
+        for (let i = 0; i < this.keys.length; i++) {
+            const key = this.keys[i];
+            if (this.data.value[key] !== this.voxelLogic.schema.state.get(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    *getEffects() {
+        for (const effect of this.data.true)
+            yield effect;
+        for (const effect of this.data.false)
+            yield effect;
+    }
+}

package/Voxels/Logic/Classes/VoxelLogic.d.ts

@@ -1,11 +1,14 @@
+import { VoxelSchema } from "../../State/Schema/VoxelSchema";
 import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
 import { VoxelLogicData } from "../VoxelLogic.types";
 import { VoxelLogicType } from "./VoxelLogicType";
 export declare class VoxelLogic {
-    types: VoxelLogicType[];
-    effectedTags: Map<string, VoxelLogicType[]>;
-    constructor(data: VoxelLogicData[]);
+    voxelId: string;
+    types: VoxelLogicType<any>[];
+    effectedTags: Map<string, VoxelLogicType<any>[]>;
+    schema: VoxelSchema;
+    constructor(voxelId: string, data: VoxelLogicData[]);
     getTagValue(tagId: string, cursor: VoxelCursorInterface): any;
-    registerEffectOnTag(tagId: string, effect: VoxelLogicType): void;
+    registerEffectOnTag(tagId: string, effect: VoxelLogicType<any>): void;
     hasTag(tag: string): boolean;
 }

package/Voxels/Logic/Classes/VoxelLogic.js

@@ -1,28 +1,33 @@
 import { VoxelLogicRegister } from "../VoxelLogicRegister";
+import { SchemaRegister } from "../../State/SchemaRegister";
 export class VoxelLogic {
+    voxelId;
     types = [];
     effectedTags = new Map();
-    constructor(data) {
-        for (const type of data) {
-            const logicType = VoxelLogicRegister.types.get(type.type);
-            this.types.push(logicType);
-            if (type.type == "powered") {
-                for (const effect of type.on)
-                    if (effect.type == "tag")
-                        this.registerEffectOnTag(effect.tagId, logicType);
-                for (const effect of type.off)
-                    if (effect.type == "tag")
-                        this.registerEffectOnTag(effect.tagId, logicType);
-            }
-            if (type.type == "state") {
-                for (const effect of type.true)
-                    if (effect.type == "tag")
-                        this.registerEffectOnTag(effect.tagId, logicType);
-                for (const effect of type.false)
-                    if (effect.type == "tag")
-                        this.registerEffectOnTag(effect.tagId, logicType);
+    schema;
+    constructor(voxelId, data) {
+        this.voxelId = voxelId;
+        this.schema = SchemaRegister.getVoxelSchemas(voxelId);
+        for (const logicData of data) {
+            const LogicTypeClass = VoxelLogicRegister.get(logicData.type);
+            const newLogicType = new LogicTypeClass(this, logicData);
+            this.types.push(newLogicType);
+            for (const effect of newLogicType.getEffects()) {
+                if (effect.type == "tag") {
+                    let effects = this.effectedTags.get(effect.tagId);
+                    if (!effects) {
+                        effects = [];
+                        this.effectedTags.set(effect.tagId, effects);
+                    }
+                    if (!effects.includes(newLogicType)) {
+                        effects.push(newLogicType);
+                    }
+                }
             }
         }
+        for (const type of this.types) {
+            type.init();
+        }
     }
     getTagValue(tagId, cursor) {
         let effects = this.effectedTags.get(tagId);
@@ -35,14 +40,7 @@ export class VoxelLogic {
         }
         return finalValue;
     }
-    registerEffectOnTag(tagId, effect) {
-        let effects = this.effectedTags.get(tagId);
-        if (!effects) {
-            effects = [];
-            this.effectedTags.set(tagId, effects);
-        }
-        effects.push(effect);
-    }
+    registerEffectOnTag(tagId, effect) { }
     hasTag(tag) {
         return this.effectedTags.has(tag);
     }

package/Voxels/Logic/Classes/VoxelLogicType.d.ts

@@ -1,4 +1,14 @@
 import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
-export declare abstract class VoxelLogicType {
+import { VoxelLogicEffects } from "../VoxelLogic.types";
+import { VoxelLogic } from "./VoxelLogic";
+export interface VoxelLogicTypeConstructor<Data> {
+    new (voxelLogic: VoxelLogic, data: Data): VoxelLogicType<Data>;
+}
+export declare abstract class VoxelLogicType<Data> {
+    voxelLogic: VoxelLogic;
+    data: Data;
+    constructor(voxelLogic: VoxelLogic, data: Data);
+    abstract init(): void;
     abstract run(task: VoxelCursorInterface): boolean;
+    abstract getEffects(): Generator<VoxelLogicEffects>;
 }

package/Voxels/Logic/Classes/VoxelLogicType.js

@@ -1,2 +1,8 @@
 export class VoxelLogicType {
+    voxelLogic;
+    data;
+    constructor(voxelLogic, data) {
+        this.voxelLogic = voxelLogic;
+        this.data = data;
+    }
 }

package/Voxels/Logic/VoxelLogic.types.d.ts

@@ -11,13 +11,15 @@ export type VoxelLogicEffects = {
     key: string;
     value: string | number;
 };
-export type VoxelLogicData = {
+export type VoxelLogicPoweredData = {
     type: "powered";
     on: VoxelLogicEffects[];
     off: VoxelLogicEffects[];
-} | {
+};
+export type VoxelLogicStateData = {
     type: "state";
-    value: string;
+    value: Record<string, number | string>;
     true: VoxelLogicEffects[];
     false: VoxelLogicEffects[];
 };
+export type VoxelLogicData = VoxelLogicPoweredData | VoxelLogicStateData;

package/Voxels/Logic/VoxelLogicRegister.d.ts

@@ -1,9 +1,10 @@
 import { VoxelLogic } from "./Classes/VoxelLogic";
 import { VoxelLogicData } from "./VoxelLogic.types";
-import { VoxelLogicType } from "./Classes/VoxelLogicType";
+import { VoxelLogicTypeConstructor } from "./Classes/VoxelLogicType";
 export declare class VoxelLogicRegister {
     static voxels: VoxelLogic[];
-    static types: Map<string, VoxelLogicType>;
+    static types: Map<string, VoxelLogicTypeConstructor<any>>;
+    static get(id: string): VoxelLogicTypeConstructor<any>;
     static register(id: string, logicData: VoxelLogicData[]): void;
-    static registerType(id: string, logic: VoxelLogicType): void;
+    static registerType(id: string, logic: VoxelLogicTypeConstructor<any>): void;
 }

package/Voxels/Logic/VoxelLogicRegister.js

@@ -1,15 +1,23 @@
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelLogic } from "./Classes/VoxelLogic";
-import { VoxelPoweredLogicType } from "./Classes/Default/Types/VoxelPoweredLogicType";
+import { VoxelLogicPoweredType } from "./Classes/Types/VoxelLogicPoweredType";
+import { VoxelLogicStateType } from "./Classes/Types/VoxelLogicStateType";
 export class VoxelLogicRegister {
     static voxels = [];
     static types = new Map();
+    static get(id) {
+        const typeClass = VoxelLogicRegister.types.get(id);
+        if (!typeClass)
+            throw new Error(`Logic type ${id} does not exist`);
+        return typeClass;
+    }
     static register(id, logicData) {
-        const voxelId = VoxelPalettesRegister.voxels.getNumberId(id);
-        this.voxels[voxelId] = new VoxelLogic(logicData);
+        const voxelId = VoxelPalettesRegister.voxelIds.getNumberId(id);
+        this.voxels[voxelId] = new VoxelLogic(id, logicData);
     }
     static registerType(id, logic) {
         this.types.set(id, logic);
     }
 }
-VoxelLogicRegister.registerType("powered", new VoxelPoweredLogicType());
+VoxelLogicRegister.registerType("powered", VoxelLogicPoweredType);
+VoxelLogicRegister.registerType("state", VoxelLogicStateType);

package/Voxels/Models/CompiledVoxelModel.types.d.ts

@@ -0,0 +1,46 @@
+import { AOOcclusionFaceIndexData } from "../Models/Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndexData } from "../Models/Indexing/CulledOcclusionFaceIndex";
+import { VoxelStateSchemaData, StateLogicStatement } from "../State/State.types";
+import { CullingProcedureData } from "../Models/VoxelModel.types";
+import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
+import { CompiledGeomtryNodes } from "../../Mesher/Models/Nodes/Types/GeomtryNode.types";
+export type CompiledVoxelGeometrySyncData = {
+    id: string;
+    cullingProcedure: CullingProcedureData;
+    nodes: CompiledGeomtryNodes[];
+};
+export interface CompiledVoxelModelData {
+    id: string;
+    schema: VoxelStateSchemaData;
+    effects: VoxelEffectSyncData[];
+    stateTree: any[];
+    stateMap: number[][];
+    stateGeometryMap: number[][];
+    stateRelativeGeometryMap: number[][];
+    relativeGeometryByteIndexMap: number[];
+    condiotnalStatements: StateLogicStatement[];
+    condiotnalStateMap: number[][];
+    condiotnalShapeStateMap: number[][][];
+    condiotanlGeometryStatePalette: number[][][];
+    condiotnalShapeStateRelativeGeometryMap: number[][];
+    condiotnalStateTree: any[];
+}
+export interface CompiledVoxelModelInputData {
+    id: string;
+    materialId: string;
+    modelId: string;
+    modSchema: VoxelStateSchemaData;
+    modStateTree: any[];
+    baseGeometryInputMap: any[][];
+    condiotnalGeometryInputMap: any[][];
+}
+export interface FinalCompiledVoxelModelData {
+    geometryPalette: string[];
+    geometry: CompiledVoxelGeometrySyncData[];
+    aoIndex: AOOcclusionFaceIndexData;
+    faceCullIndex: CulledOcclusionFaceIndexData;
+    vertexHitMap: number[][][];
+    faceCullMap: number[][];
+    models: CompiledVoxelModelData[];
+    voxels: CompiledVoxelModelInputData[];
+}

package/Voxels/Models/CompiledVoxelModel.types.js

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

package/{Models → Voxels/Models}/Defaults/CubeVoxelGeometry.js

@@ -12,10 +12,6 @@ export const cube = {
             type: "int",
             default: 0,
         },
-        upTexTransparent: {
-            type: "boolean",
-            default: false,
-        },
         downTex: {
             type: "texture",
         },
@@ -27,10 +23,6 @@ export const cube = {
             type: "int",
             default: 0,
         },
-        downTexTransparent: {
-            type: "boolean",
-            default: false,
-        },
         northTex: {
             type: "texture",
         },
@@ -42,10 +34,6 @@ export const cube = {
             type: "int",
             default: 0,
         },
-        northTexTransparent: {
-            type: "boolean",
-            default: false,
-        },
         southTex: {
             type: "texture",
         },
@@ -57,10 +45,6 @@ export const cube = {
             type: "int",
             default: 0,
         },
-        southTexTransparent: {
-            type: "boolean",
-            default: false,
-        },
         eastTex: {
             type: "texture",
         },
@@ -72,10 +56,6 @@ export const cube = {
             type: "int",
             default: 0,
         },
-        eastTexTransparent: {
-            type: "boolean",
-            default: false,
-        },
         westTex: {
             type: "texture",
         },
@@ -87,10 +67,6 @@ export const cube = {
             type: "int",
             default: 0,
         },
-        westTexTransparent: {
-            type: "boolean",
-            default: false,
-        },
     },
     nodes: [
         {
@@ -104,37 +80,31 @@ export const cube = {
                     texture: "@upTex",
                     uv: "@upUvs",
                     rotation: "@upTexRotation",
-                    transparent: "@upTexTransparent",
                 },
                 down: {
                     texture: "@downTex",
                     uv: "@downUvs",
                     rotation: "@downTexRotation",
-                    transparent: "@downTexTransparent",
                 },
                 north: {
                     texture: "@northTex",
                     uv: "@northUvs",
                     rotation: "@northTexRotation",
-                    transparent: "@northTexTransparent",
                 },
                 south: {
                     texture: "@southTex",
                     uv: "@southUvs",
                     rotation: "@southTexRotation",
-                    transparent: "@southTexTransparent",
                 },
                 east: {
                     texture: "@eastTex",
                     uv: "@eastUvs",
                     rotation: "@eastTexRotation",
-                    transparent: "@eastTexTransparent",
                 },
                 west: {
                     texture: "@westTex",
                     uv: "@westUvs",
                     rotation: "@westTexRotation",
-                    transparent: "@westTexTransparent",
                 },
             },
         },

package/{Models → Voxels/Models}/Defaults/CubeVoxelModels.d.ts

@@ -1,5 +1,7 @@
 import { VoxelModelData } from "../VoxelModel.types";
 export declare const simpleCube: VoxelModelData;
+export declare const simpleTransparentCube: VoxelModelData;
+export declare const simpleNoCulledCube: VoxelModelData;
 export declare const orientedCube: VoxelModelData;
 export declare const simpleHalfCube: VoxelModelData;
 export declare const pillarCube: VoxelModelData;