@divinevoxel/vlox 0.0.78 → 0.0.80

package/Voxels/Functions/BuildLUTs.js

@@ -0,0 +1,361 @@
+import { VoxelLUT } from "../Data/VoxelLUT";
+import { BinarySchema } from "../State/Schema/BinarySchema";
+import { VoxelSchemas } from "../State/VoxelSchemas";
+import { EngineStats } from "../../Stats/EngineStats";
+import { BuildGeomeetryLUT } from "./Geometry/BuildGeometryLUT";
+import { ReltionalStateBuilder } from "../State/Reltional/ReltionalStateBuilder";
+function recurse(index, current, result, valuePairs) {
+    if (index === valuePairs.length) {
+        result.push(current.join(","));
+        return;
+    }
+    const [key, values] = valuePairs[index];
+    for (const value of values) {
+        current.push(`${key}=${value}`);
+        recurse(index + 1, current, result, valuePairs);
+        current.pop();
+    }
+}
+function getAllCombinations(valuePairs) {
+    const result = [];
+    recurse(0, [], result, valuePairs);
+    return result;
+}
+function buildScehmas(voxels, models) {
+    //build state schemas
+    for (const model of models) {
+        VoxelLUT.models.register(model.id);
+        //build state schema
+        const schemaNodes = [];
+        for (const schemaNode of model.stateSchema) {
+            const node = {
+                name: schemaNode.name,
+                bitIndex: schemaNode.bitIndex,
+                bitSize: schemaNode.bitSize,
+            };
+            if (schemaNode.values) {
+                node.values = schemaNode.values;
+            }
+            schemaNodes.push(node);
+        }
+        const stateSchema = new BinarySchema(schemaNodes);
+        VoxelSchemas.state.set(model.id, stateSchema);
+        //build reltional state schema
+        const reltionalSchemaNodes = [];
+        let bitIndex = 0;
+        for (const schemaNode of model.relationsSchema) {
+            const node = {
+                name: schemaNode.name,
+                bitIndex: bitIndex,
+                bitSize: 1,
+                values: ["false", "true"],
+            };
+            bitIndex++;
+            reltionalSchemaNodes.push(node);
+        }
+        const reltionalStateSchema = new BinarySchema(reltionalSchemaNodes);
+        VoxelSchemas.reltioanlState.set(model.id, reltionalStateSchema);
+        const reltionalStateBuilder = new ReltionalStateBuilder(reltionalStateSchema, model.relationsSchema);
+        VoxelSchemas.reltionalStateBuilder.set(model.id, reltionalStateBuilder);
+    }
+    //build mod schemas
+    for (const voxel of voxels) {
+        const modelData = voxel.properties["dve_model_data"];
+        const trueVoxelId = VoxelLUT.voxelIds.register(voxel.id);
+        VoxelLUT.materialMap[trueVoxelId] = VoxelLUT.material.getNumberId(voxel.properties["dve_rendered_material"] || "dve_solid");
+        VoxelLUT.substanceMap[trueVoxelId] = VoxelLUT.material.getNumberId(voxel.properties["dve_substance"] || "dve_solid");
+        if (!modelData)
+            continue;
+        VoxelLUT.modelsIndex[trueVoxelId] = VoxelLUT.models.getNumberId(modelData.id);
+        //build state schema
+        const schemaNodes = [];
+        if (modelData.modSchema) {
+            for (const schemaNode of modelData.modSchema) {
+                const node = {
+                    name: schemaNode.name,
+                    bitIndex: schemaNode.bitIndex,
+                    bitSize: schemaNode.bitSize,
+                };
+                if (schemaNode.values) {
+                    node.values = schemaNode.values;
+                }
+                schemaNodes.push(node);
+            }
+        }
+        const stateSchema = new BinarySchema(schemaNodes);
+        VoxelSchemas.mod.set(voxel.id, stateSchema);
+        //build reltional mod schema
+        const reltionalSchemaNodes = [];
+        if (modelData.modRelationSchema) {
+            let bitIndex = 0;
+            for (const schemaNode of modelData.modRelationSchema) {
+                const node = {
+                    name: schemaNode.name,
+                    bitIndex: bitIndex,
+                    bitSize: 1,
+                    values: ["false", "true"],
+                };
+                bitIndex++;
+                reltionalSchemaNodes.push(node);
+            }
+        }
+        const reltionalStateSchema = new BinarySchema(reltionalSchemaNodes);
+        VoxelSchemas.reltioanlMod.set(voxel.id, reltionalStateSchema);
+        const reltionalModBuilder = new ReltionalStateBuilder(reltionalStateSchema, modelData.modRelationSchema || []);
+        VoxelSchemas.reltionalModBuilder.set(voxel.id, reltionalModBuilder);
+    }
+}
+function buildStatePalette(voxels, models) {
+    const modelStateArray = new Map();
+    for (const model of models) {
+        const schema = VoxelSchemas.state.get(model.id);
+        const valuePairs = [];
+        for (const node of schema.nodes) {
+            valuePairs.push([
+                node.name,
+                node.valuePalette
+                    ? node.valuePalette._palette
+                    : new Array(node.bitMask + 1).fill(0).map((_, i) => `${i}`),
+            ]);
+        }
+        const stateStrings = getAllCombinations(valuePairs);
+        const statePalette = [];
+        for (const state of stateStrings) {
+            const value = schema.readString(!state ? "*" : state);
+            statePalette.push(value);
+        }
+        modelStateArray.set(model.id, statePalette);
+    }
+    const finalPalette = [[0, 0, 0]];
+    const finalPaletteRecord = [[[0]]];
+    let voxelIdCount = 1;
+    for (const voxel of voxels) {
+        const modelData = voxel.properties["dve_model_data"];
+        if (!modelData)
+            continue;
+        const schema = VoxelSchemas.mod.get(voxel.id);
+        const valuePairs = [];
+        if (schema) {
+            for (const node of schema.nodes) {
+                valuePairs.push([
+                    node.name,
+                    node.valuePalette
+                        ? node.valuePalette._palette
+                        : new Array(node.bitMask + 1).fill(0).map((_, i) => `${i}`),
+                ]);
+            }
+        }
+        const stateStrings = getAllCombinations(valuePairs);
+        const modPalette = [];
+        if (valuePairs.length && schema) {
+            for (const state of stateStrings) {
+                const value = schema.readString(!state ? "*" : state);
+                modPalette.push(value);
+            }
+        }
+        else {
+            modPalette.push(0);
+        }
+        const voxelId = VoxelLUT.voxelIds.getNumberId(voxel.id);
+        const statePalette = modelStateArray.get(modelData.id);
+        VoxelLUT.totalStates[voxelId] = statePalette.length;
+        VoxelLUT.totalMods[voxelId] = modPalette.length;
+        finalPaletteRecord[voxelId] = new Array(modPalette.length).fill(-1);
+        for (let modIndex = 0; modIndex < modPalette.length; modIndex++) {
+            finalPaletteRecord[voxelId][modPalette[modIndex]] = new Array(statePalette.length).fill(-1);
+            for (let stateIndex = 0; stateIndex < statePalette.length; stateIndex++) {
+                finalPalette[voxelIdCount] = [
+                    voxelId,
+                    statePalette[stateIndex],
+                    modPalette[modIndex],
+                ];
+                finalPaletteRecord[voxelId][modPalette[modIndex]][statePalette[stateIndex]] = voxelIdCount;
+                VoxelLUT.voxelIdToModelState[voxelIdCount] = statePalette[stateIndex];
+                voxelIdCount++;
+            }
+        }
+    }
+    EngineStats.palette.paletteSize = finalPalette.length;
+    VoxelLUT.voxels = finalPalette;
+    VoxelLUT.voxelRecord = finalPaletteRecord;
+}
+function buildReltionalStatePalette(voxels, models) {
+    const modelStateArray = new Map();
+    for (const model of models) {
+        const schema = VoxelSchemas.reltioanlState.get(model.id);
+        const valuePairs = [];
+        for (const node of schema.nodes) {
+            valuePairs.push([node.name, ["false", "true"]]);
+        }
+        const stateStrings = getAllCombinations(valuePairs);
+        const statePalette = [];
+        for (const state of stateStrings) {
+            const value = schema.readString(!state ? "*" : state);
+            statePalette.push(value);
+        }
+        modelStateArray.set(model.id, statePalette);
+    }
+    const finalPalette = [[0, 0, 0]];
+    const finalPaletteRecord = [[[0]]];
+    let voxelIdCount = 1;
+    for (const voxel of voxels) {
+        const modelData = voxel.properties["dve_model_data"];
+        if (!modelData)
+            continue;
+        const schema = VoxelSchemas.reltioanlMod.get(voxel.id);
+        const valuePairs = [];
+        if (schema) {
+            for (const node of schema.nodes) {
+                valuePairs.push([node.name, ["false", "true"]]);
+            }
+        }
+        const stateStrings = getAllCombinations(valuePairs);
+        const modPalette = [];
+        if (valuePairs.length && schema) {
+            for (const state of stateStrings) {
+                const value = schema.readString(!state ? "*" : state);
+                modPalette.push(value);
+            }
+        }
+        else {
+            modPalette.push(0);
+        }
+        const voxelId = VoxelLUT.voxelIds.getNumberId(voxel.id);
+        const statePalette = modelStateArray.get(modelData.id);
+        VoxelLUT.totalReltionalStates[voxelId] = statePalette.length;
+        VoxelLUT.totalReltionalMods[voxelId] = modPalette.length;
+        finalPaletteRecord[voxelId] = new Array(modPalette.length).fill(-1);
+        for (let modIndex = 0; modIndex < modPalette.length; modIndex++) {
+            finalPaletteRecord[voxelId][modPalette[modIndex]] = new Array(statePalette.length).fill(-1);
+            for (let stateIndex = 0; stateIndex < statePalette.length; stateIndex++) {
+                finalPalette[voxelIdCount] = [
+                    voxelId,
+                    statePalette[stateIndex],
+                    modPalette[modIndex],
+                ];
+                finalPaletteRecord[voxelId][modPalette[modIndex]][statePalette[stateIndex]] = voxelIdCount;
+                voxelIdCount++;
+            }
+        }
+    }
+    EngineStats.palette.reltionalPaletteSize = finalPalette.length;
+    VoxelLUT.reltioanlVoxels = finalPalette;
+    VoxelLUT.reltionalVoxelRecord = finalPaletteRecord;
+}
+export function BuildLUTs(materials, substances, voxels, geometry, models) {
+    for (const material of materials) {
+        VoxelLUT.material.register(material.id);
+    }
+    for (const substance of substances) {
+        VoxelLUT.substance.register(substance.id);
+    }
+    buildScehmas(voxels, models);
+    buildStatePalette(voxels, models);
+    buildReltionalStatePalette(voxels, models);
+    const { finalModelStateMap, finalModelConditionalMap, finalVoxelStateInputMap, finalVoxelConditionalInputMap, } = BuildGeomeetryLUT(voxels, geometry, models);
+    for (const voxel of voxels) {
+        const voxelModelData = voxel.properties["dve_model_data"];
+        if (!voxelModelData)
+            continue;
+        const trueVoxelId = VoxelLUT.voxelIds.getNumberId(voxel.id);
+        const modelStateMap = finalModelStateMap.get(voxelModelData.id);
+        const modelConditonalMap = finalModelConditionalMap.get(voxelModelData.id);
+        const stateSchema = VoxelSchemas.state.get(voxelModelData.id);
+        const reltionalStateSchema = VoxelSchemas.reltioanlState.get(voxelModelData.id);
+        const modSchema = VoxelSchemas.mod.get(voxel.id);
+        const reltionalModSchema = VoxelSchemas.reltioanlMod.get(voxel.id);
+        const inputs = finalVoxelStateInputMap.get(voxel.id);
+        const conditonalInputs = finalVoxelConditionalInputMap.get(voxel.id);
+        for (const modKey in voxelModelData.inputs) {
+            const [modString, modReltionalString] = modKey.split("|");
+            const modValue = modSchema ? modSchema.readString(modString) : 0;
+            const reltionalModValue = modReltionalString && reltionalModSchema
+                ? reltionalModSchema.readString(modReltionalString)
+                : 0;
+            for (const stateKey in modelStateMap) {
+                const [stateString, reltionalString] = stateKey.split("|");
+                const stateValue = stateSchema
+                    ? stateSchema.readString(stateString)
+                    : 0;
+                const reltionalStateValue = reltionalString && reltionalStateSchema
+                    ? reltionalStateSchema.readString(reltionalString)
+                    : 0;
+                const voxelId = VoxelLUT.getVoxelId(trueVoxelId, stateValue, modValue);
+                const reltionalVoxelId = VoxelLUT.getReltionalVoxelId(trueVoxelId, reltionalStateValue, reltionalModValue);
+                VoxelLUT.geometryIndex[voxelId] ??= [];
+                VoxelLUT.geometryInputsIndex[voxelId] ??= [];
+                const totalReltionalStates = reltionalStateSchema
+                    ? Math.pow(2, reltionalStateSchema.nodes.length)
+                    : 0;
+                if (!totalReltionalStates) {
+                    VoxelLUT.geometryIndex[voxelId][reltionalVoxelId] =
+                        modelStateMap[stateKey];
+                    VoxelLUT.geometryInputsIndex[voxelId][reltionalVoxelId] =
+                        inputs[modKey][stateKey];
+                }
+                else {
+                    const baseReltionalVoxelId = VoxelLUT.getReltionalVoxelId(trueVoxelId, 0, 0);
+                    for (let i = baseReltionalVoxelId; i < baseReltionalVoxelId + totalReltionalStates; i++) {
+                        VoxelLUT.geometryIndex[voxelId][i] = modelStateMap[stateKey];
+                        VoxelLUT.geometryInputsIndex[voxelId][i] = inputs[modKey][stateKey];
+                    }
+                }
+            }
+            for (const stateKey in modelConditonalMap) {
+                const [stateString, reltionalString] = stateKey.split("|");
+                const stateValue = stateSchema
+                    ? stateSchema.readString(stateString)
+                    : 0;
+                const reltionalStateValue = reltionalString && reltionalStateSchema
+                    ? reltionalStateSchema.readString(reltionalString)
+                    : 0;
+                const geoId = modelConditonalMap[stateKey];
+                const voxelId = VoxelLUT.getVoxelId(trueVoxelId, stateValue, modValue);
+                const reltionalVoxelId = VoxelLUT.getReltionalVoxelId(trueVoxelId, reltionalStateValue, reltionalModValue);
+                const totalReltionalStates = reltionalStateSchema
+                    ? Math.pow(2, reltionalStateSchema.nodes.length)
+                    : 0;
+                VoxelLUT.conditionalGeometryInputIndex[geoId] ??= [];
+                VoxelLUT.conditionalGeometryInputIndex[geoId][voxelId] ??= [];
+                if (!totalReltionalStates) {
+                    VoxelLUT.conditionalGeometryInputIndex[geoId][voxelId][reltionalVoxelId] = conditonalInputs[modKey][stateKey];
+                }
+                else {
+                    const baseReltionalVoxelId = VoxelLUT.getReltionalVoxelId(trueVoxelId, 0, 0);
+                    for (let i = baseReltionalVoxelId; i < baseReltionalVoxelId + totalReltionalStates; i++) {
+                        VoxelLUT.conditionalGeometryInputIndex[geoId][voxelId][i] =
+                            conditonalInputs[modKey][stateKey];
+                    }
+                }
+            }
+        }
+        for (const stateKey in modelConditonalMap) {
+            const [stateString, reltionalString] = stateKey.split("|");
+            const stateValue = stateSchema ? stateSchema.readString(stateString) : 0;
+            const totalReltionalStates = reltionalStateSchema
+                ? Math.pow(2, reltionalStateSchema.nodes.length) *
+                    (reltionalModSchema
+                        ? Math.pow(2, reltionalModSchema.nodes.length)
+                        : 1)
+                : 0;
+            const enabledArray = new Array(totalReltionalStates || 1).fill(true);
+            if (reltionalStateSchema) {
+                const reltionalNodes = ((reltionalString ? reltionalString.split(",") : []).map((v) => v.split("=")));
+                for (let i = 0; i < totalReltionalStates; i++) {
+                    reltionalStateSchema.startEncoding(i);
+                    for (const [key, value] of reltionalNodes) {
+                        if (reltionalStateSchema.getValue(key) !== value) {
+                            enabledArray[i] = false;
+                        }
+                    }
+                }
+            }
+            VoxelLUT.conditionalGeometryIndex[trueVoxelId] ??= [];
+            VoxelLUT.conditionalGeometryIndex[trueVoxelId].push([
+                modelConditonalMap[stateKey],
+                stateValue,
+                enabledArray,
+            ]);
+        }
+    }
+}

package/Voxels/Functions/BuildTagData.d.ts

@@ -1,13 +1,15 @@
 import { VoxelData } from "../Types/Voxel.types";
 import { VoxelMaterialData } from "../Types/VoxelMaterial.types";
 import { VoxelSubstanceData } from "../Types/VoxelSubstances.types";
-import { CompiledVoxelTagAndPaletteData } from "../Types/VoxelModelCompiledData.types";
+import { CompiledvVxelTags } from "../Types/VoxelModelCompiledData.types";
+import { VoxelModelData } from "../../Voxels/Models/VoxelModel.types";
 export type BuildTagDataProps = {
     voxels: VoxelData[];
+    models: VoxelModelData[];
     voxelsOverrides?: Record<string, (value: any) => any>;
     substances: VoxelSubstanceData[];
     substancesOverrides?: Record<string, (value: any) => any>;
     materials: VoxelMaterialData[];
     materialsOverrides?: Record<string, (value: any) => any>;
 };
-export declare function BuildTagAndPaletteData(props: BuildTagDataProps): CompiledVoxelTagAndPaletteData;
+export declare function BuildTagAndPaletteData(props: BuildTagDataProps): CompiledvVxelTags;

package/Voxels/Functions/BuildTagData.js

@@ -1,31 +1,28 @@
 import { VoxelTagsRegister } from "../Data/VoxelTagsRegister";
-import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
-import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
 import { VoxelPropertiesRegister } from "../Data/VoxelPropertiesRegister";
 import { VoxelPlacingStrategyRegister } from "../../Voxels/Interaction/Placing/VoxelPlacingStrategyRegister";
+import { VoxelLUT } from "../../Voxels/Data/VoxelLUT";
 export function BuildTagAndPaletteData(props) {
     const logic = {};
+    const models = new Map(props.models.map((_) => [_.id, _]));
     for (const voxel of props.voxels) {
         const tags = {};
-        if (VoxelPalettesRegister.voxelIds._map[voxel.id] !== undefined) {
-            throw new Error(`Voxel with id [${voxel.id}] is already registered.`);
-        }
-        const voxelId = VoxelPalettesRegister.voxelIds.register(voxel.id);
+        const voxelId = VoxelLUT.voxelIds.getNumberId(voxel.id);
         VoxelPropertiesRegister.VoxelProperties[voxelId] = voxel.properties;
         if (voxel.properties["dve_model_data"]) {
             tags["dve_model_id"] = voxel.properties["dve_model_data"].id;
-            const model = VoxelModelRuleBuilderRegister.models.get(voxel.properties["dve_model_data"].id);
-            if (model?.data.properties) {
-                for (const tagId in model.data.properties) {
-                    voxel.properties[tagId] = model.data.properties[tagId];
+            const model = models.get(tags["dve_model_id"]);
+            if (model) {
+                if (model?.properties) {
+                    for (const tagId in model.properties) {
+                        voxel.properties[tagId] = model.properties[tagId];
+                    }
                 }
             }
         }
         if (voxel.properties["dve_placing_strategy"]) {
             VoxelPlacingStrategyRegister.register(voxel.id, voxel.properties["dve_placing_strategy"]);
         }
-        VoxelPalettesRegister.voxelIdToNameMap.set(voxel.id, voxel.name || "");
-        VoxelPalettesRegister.voxelNametoIdMap.set(voxel.name || voxel.id, voxel.id);
         if (voxel.properties["dve_logic_data"]) {
             logic[voxel.id] = voxel.properties["dve_logic_data"];
         }
@@ -44,11 +41,11 @@ export function BuildTagAndPaletteData(props) {
     }
     for (const substance of props.substances) {
         const tags = {};
-        const substanceId = VoxelPalettesRegister.substance.register(substance.id);
+        const substanceId = VoxelLUT.substance.getNumberId(substance.id);
         for (const tag of VoxelTagsRegister.IncludedSubstnacesTags) {
             if (substance.properties[tag] === undefined) {
                 tags[tag] =
-                    VoxelTagsRegister.SubstanceStagDefaults[tag] || false;
+                    VoxelTagsRegister.SubstanceTagDefaults[tag] || false;
                 continue;
             }
             if (props?.substancesOverrides?.[tag]) {
@@ -57,25 +54,11 @@ export function BuildTagAndPaletteData(props) {
             }
             tags[tag] = substance.properties[tag];
         }
-        VoxelTagsRegister.SubstanceStags[substanceId] = tags;
-    }
-    for (const material of props.materials) {
-        VoxelPalettesRegister.material.register(material.id);
+        VoxelTagsRegister.SubstanceTags[substanceId] = tags;
     }
     return {
-        data: {
-            logic,
-            palette: [],
-            record: [],
-            idPalette: VoxelPalettesRegister.voxelIds._palette,
-            tags: VoxelTagsRegister.VoxelTags,
-            idToNameMap: [...VoxelPalettesRegister.voxelIdToNameMap.entries()],
-            nameToIdMap: [...VoxelPalettesRegister.voxelNametoIdMap.entries()],
-        },
-        substances: {
-            tags: VoxelTagsRegister.SubstanceStags,
-            palette: VoxelPalettesRegister.substance._palette,
-        },
-        materials: { palette: VoxelPalettesRegister.material._palette },
+        logic,
+        tags: VoxelTagsRegister.VoxelTags,
+        substanceTags: VoxelTagsRegister.SubstanceTags,
     };
 }

package/Voxels/Functions/Geometry/BuildGeometryLUT.d.ts

@@ -0,0 +1,11 @@
+import { VoxelModelData } from "../../Models/VoxelModel.types";
+import { VoxelData } from "../../Types/Voxel.types";
+import { VoxelGeometryData } from "../../Geometry/VoxelGeometry.types";
+type FinalMappedVoxelInputs = Record<string, Record<string, number>>;
+export declare function BuildGeomeetryLUT(voxels: VoxelData[], geomtries: VoxelGeometryData[], models: VoxelModelData[]): {
+    finalModelStateMap: Map<string, Record<string, number>>;
+    finalModelConditionalMap: Map<string, Record<string, number>>;
+    finalVoxelStateInputMap: Map<string, FinalMappedVoxelInputs>;
+    finalVoxelConditionalInputMap: Map<string, FinalMappedVoxelInputs>;
+};
+export {};