@divinevoxel/vlox 0.0.73 → 0.0.75

package/Voxels/Logic/Classes/VoxelLogic.js

@@ -0,0 +1,47 @@
+import { VoxelLogicRegister } from "../VoxelLogicRegister";
+import { SchemaRegister } from "../../State/SchemaRegister";
+export class VoxelLogic {
+    voxelId;
+    types = [];
+    effectedTags = new Map();
+    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);
+        if (!effects)
+            return null;
+        let finalValue = null;
+        for (let i = 0; i < effects.length; i++) {
+            const effect = effects[i];
+            finalValue = effect.run(cursor);
+        }
+        return finalValue;
+    }
+    registerEffectOnTag(tagId, effect) { }
+    hasTag(tag) {
+        return this.effectedTags.has(tag);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
+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

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

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

@@ -0,0 +1,25 @@
+export type VoxelLogicEffects = {
+    type: "tag";
+    tagId: string;
+    value: any;
+} | {
+    type: "state";
+    key: string;
+    value: string | number;
+} | {
+    type: "mod";
+    key: string;
+    value: string | number;
+};
+export type VoxelLogicPoweredData = {
+    type: "powered";
+    on: VoxelLogicEffects[];
+    off: VoxelLogicEffects[];
+};
+export type VoxelLogicStateData = {
+    type: "state";
+    value: Record<string, number | string>;
+    true: VoxelLogicEffects[];
+    false: VoxelLogicEffects[];
+};
+export type VoxelLogicData = VoxelLogicPoweredData | VoxelLogicStateData;

package/Voxels/Logic/VoxelLogic.types.js

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

package/Voxels/Logic/VoxelLogicRegister.d.ts

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

package/Voxels/Logic/VoxelLogicRegister.js

@@ -0,0 +1,23 @@
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLogic } from "./Classes/VoxelLogic";
+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.voxelIds.getNumberId(id);
+        this.voxels[voxelId] = new VoxelLogic(id, logicData);
+    }
+    static registerType(id, logic) {
+        this.types.set(id, logic);
+    }
+}
+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;