minerender 1.4.11 → 2.0.0-alpha.1

package/src/model/multiblock/MultiBlockStructure.ts

@@ -0,0 +1,14 @@
+import { TripleArray } from "../Model";
+import { BlockStateProperties } from "../block/BlockStateProperties";
+import { Block } from "../block/Block";
+
+export interface MultiBlockStructure {
+
+    readonly size: TripleArray;
+    readonly blocks: MultiBlockBlock[];
+
+}
+
+export interface MultiBlockBlock extends Block {
+    position: TripleArray;
+}

package/src/model/multiblock/SchematicParser.ts

@@ -0,0 +1,11 @@
+import { MultiBlockStructure } from "./MultiBlockStructure";
+
+export class SchematicParser {
+
+    public static async parse(): Promise<MultiBlockStructure> {
+        //TODO
+        // @ts-ignore
+        return Promise.resolve({  });
+    }
+
+}

package/src/model/multiblock/StructureParser.ts

@@ -0,0 +1,109 @@
+import { MultiBlockBlock, MultiBlockStructure } from "./MultiBlockStructure";
+import { TripleArray } from "../Model";
+import { NBT } from "prismarine-nbt";
+import { MineRenderError } from "../../error/MineRenderError";
+import { BlockStateProperties } from "../block/BlockStateProperties";
+
+export class StructureParser {
+
+    public static async parse(_nbt: NBT, paletteIndex?: number): Promise<MultiBlockStructure> {
+        const nbt = _nbt.value as unknown as StructureNBT;
+
+        let palette: Palette;
+        if ("palette" in nbt) {
+            palette = nbt.palette!;
+        } else if ("palettes" in nbt) {
+            palette = nbt.palettes![paletteIndex ?? 0];
+        } else {
+            throw new MineRenderError("Structure does not have palette(s)");
+        }
+
+        const blocks: MultiBlockBlock[] =
+            nbt.blocks.value.value.map(block => {
+                const state = palette.value.value[block.state.value];
+                if (state.Name.value === "minecraft:air") return undefined;
+
+                const props: BlockStateProperties = {};
+                for (let k in state.Properties?.value) {
+                    props[k] = state.Properties.value[k].value;
+                }
+                return <MultiBlockBlock>{
+                    type: state.Name.value,
+                    properties: props,
+                    position: block.pos.value.value,
+                    nbt: block.nbt
+                }
+            }).filter(m => typeof m !== "undefined") as  MultiBlockBlock[] ;
+        return {
+            blocks: blocks,
+            size: nbt.size.value.value
+        }
+    }
+
+}
+
+export interface StructureNBT {
+    DataVersion: {
+        type: "int";
+        value: number;
+    }
+    size: {
+        type: "list";
+        value: {
+            type: "int";
+            value: TripleArray;
+        }
+    }
+    palette?: Palette;
+    palettes?: Palette[];
+    blocks: {
+        type: "list";
+        value: {
+            type: "compound";
+            value: BlockEntry[];
+        }
+    }
+    entities: {};//TODO
+}
+
+interface Palette {
+    type: "list";
+    value: {
+        type: "compound";
+        value: PaletteEntry[]
+    }
+}
+
+interface PaletteEntry {
+    Name: {
+        type: "string";
+        value: string;
+    }
+    Properties: {
+        type: "compound";
+        value: { [property: string]: PalettePropertyValue; };
+    }
+}
+
+interface PalettePropertyValue {
+    type: string;
+    value: string;
+}
+
+interface BlockEntry {
+    pos: {
+        type: "list";
+        value: {
+            type: "int";
+            value: TripleArray;
+        }
+    }
+    state: {
+        type: "int";
+        value: number;
+    }
+    nbt: {
+        type: "compound";
+        value: any;
+    }
+}

package/src/model/scene/ModelObject.ts

@@ -0,0 +1,185 @@
+import { SceneObject } from "../../renderer/SceneObject";
+import { Model, TextureAsset } from "../Model";
+import { Materials } from "../../Materials";
+import { ModelTextures } from "../../assets/ModelTextures";
+import webpack from "webpack";
+import { Assets } from "../../assets/Assets";
+import { Maybe, toRadians } from "../../util/util";
+import { UVMapper } from "../../UVMapper";
+import { TextureAtlas } from "../../texture/TextureAtlas";
+import { BoxGeometry, BoxHelper, BufferAttribute,  EdgesGeometry, InstancedMesh, LineBasicMaterial, LineSegments, Matrix4, Mesh, MeshBasicMaterial } from "three";
+import { mergeBufferGeometries } from "../../three/BufferGeometryUtils";
+import { SceneObjectOptions } from "../../renderer/SceneObjectOptions";
+import { addBox3WireframeToObject, addWireframeToMesh, addWireframeToObject, applyElementRotation } from "../../util/model";
+import { Ticker } from "../../Ticker";
+import merge from "ts-deepmerge";
+import { BufferGeometry } from "three/src/core/BufferGeometry";
+import { BlockObject } from "../block/scene/BlockObject";
+import { prefix } from "../../util/log";
+
+
+const p = prefix("ModelObject");
+
+//TODO: might want to abstract this out into a generic model, and create a separate class for Block models
+export class ModelObject extends SceneObject {
+
+    public readonly isModelObject: true = true;
+
+    public static readonly DEFAULT_OPTIONS: ModelObjectOptions = merge({}, SceneObject.DEFAULT_OPTIONS, <ModelObjectOptions>{});
+    public readonly options: ModelObjectOptions;
+
+    private atlas?: TextureAtlas;
+
+    public blockParent: Maybe<BlockObject>;
+
+    private meshesCreated: boolean = false;
+
+    constructor(readonly originalModel: Model, options?: Partial<ModelObjectOptions>) {
+        super();
+        this.options = merge({}, ModelObject.DEFAULT_OPTIONS, options ?? {});
+    }
+
+    async init(): Promise<void> {
+        // load textures first so we have the updated UV coordinates from the atlas
+        await this.loadTextures();
+
+        this.createMeshes();
+        this.applyTextures();
+    }
+
+    dispose() {
+        super.dispose();
+        this.atlas?.dispose();
+    }
+
+    public get textureAtlas(): Maybe<TextureAtlas> {
+        return this.atlas;
+    }
+
+    //TODO: support for replacing textures
+
+    protected async loadTextures(): Promise<void> {
+        this.atlas = await UVMapper.getAtlas(this.originalModel);
+    }
+
+
+    protected createMeshes(force: boolean = false) {
+        if (this.meshesCreated && !force) return;
+
+        const mat = Materials.MISSING_TEXTURE;
+
+        let allGeos: BufferGeometry[] = [];
+
+        if (this.atlas) {
+            if (this.atlas.model.elements) {
+                this.atlas.model.elements?.forEach(el => {
+                    const elGeo = this._getBoxGeometryFromElement(el).clone();
+
+                    // elGeo.applyMatrix4(new THREE.Matrix4().makeTranslation(-8,-8,-8));
+
+
+                    elGeo.applyMatrix4(new Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+                    elGeo.applyMatrix4(new Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+
+                    if (el.rotation) {
+                        applyElementRotation(el.rotation, elGeo);
+                    }
+
+
+                    elGeo.applyMatrix4(new Matrix4().makeTranslation(-8, -8, -8));
+
+                    if (this.options.mergeMeshes) {
+                        allGeos.push(elGeo);
+                    } else {
+                        const mesh = this.createAndAddMesh(undefined, undefined, elGeo, mat);
+                        if (this.options.wireframe) {
+                            addWireframeToMesh(elGeo, mesh);
+                        }
+                    }
+                });
+            } else {
+                console.debug(p, this.atlas.model, "has no elements")
+            }
+        } else {
+            console.debug(p, "Missing atlas for", this);
+        }
+
+        if (this.options.mergeMeshes) {
+            let combinedGeo: BufferGeometry;
+            if (allGeos.length > 0) {
+                // if (this.options.wireframe) {
+                //     allGeos.push(new BoxGeometry(16, 16, 16, 1, 1, 1))
+                // }
+
+                combinedGeo = mergeBufferGeometries(allGeos);
+            } else {
+                combinedGeo = new BoxGeometry(16, 16, 16);
+            }
+            combinedGeo.computeBoundingBox();
+            // combinedGeo.translate(-8, -8, -8);
+            // TODO: cache the combined geometry
+            let mesh: Mesh;
+            if (this.options.instanceMeshes) {
+                mesh = this.createInstancedMesh(undefined, combinedGeo, mat, this.options.maxInstanceCount || 50);
+                this.add(mesh);
+                this._isInstanced = true;
+                //TODO
+            } else {
+                mesh = this.createAndAddMesh(undefined, undefined, combinedGeo, mat)
+            }
+            if (this.options.wireframe) {
+                addWireframeToMesh(combinedGeo, mesh, 0x0000ff, 4);
+                addBox3WireframeToObject(combinedGeo.boundingBox!, mesh, 0x00ffff, 3);
+            }
+        }
+
+        if (this.options.wireframe) {
+            addWireframeToObject(this, 0x00ff00, 3)
+        }
+
+        this.meshesCreated = true;
+    }
+
+
+    protected applyTextures() {
+        // if (this.atlas!.model.textures) {
+        //     for (let textureKey in this.atlas!.model.textures) {
+        //         let asset = this.textureMap[textureKey];
+        //         if (asset) {
+        //TODO: transparency
+        if (this.atlas) {
+            let mat = Materials.createShadedCanvasMaterial(this.atlas.image!.canvas! as HTMLCanvasElement, this.atlas.hasTransparency, false/*TODO: get this from render options*/);
+            this.iterateAllMeshes(mesh => {
+                mesh.material = mat;
+            });
+
+            //TODO: move this somewhere else
+            //TODO: this seems to be ticking way too fast atm
+            if (this.atlas.hasAnimation) {
+                if (typeof this.atlas.ticker === "undefined") { //TODO: fix missing texture update for reused atlas
+                    this.atlas.ticker = Ticker.add(() => {
+                        for (let key in this.atlas!.animatorFunctions) {
+                            this.atlas!.animatorFunctions[key]();
+                        }
+                        if ("map" in mat) {
+                            (mat as any).map!.needsUpdate = true;
+                        }
+                    });
+                }
+            }
+        }
+        //         }
+        //     }
+        // }
+    }
+
+
+}
+
+export interface ModelObjectOptions extends SceneObjectOptions {
+
+}
+
+export function isModelObject(obj: any): obj is ModelObject {
+    return (<ModelObject>obj).isModelObject;
+}

package/src/nbt/NBTHelper.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { NBT } from "prismarine-nbt";
+import { MinecraftAsset } from "../MinecraftAsset";
+export declare class NBTHelper {
+    static fromBuffer(buffer: Buffer): Promise<NBTAsset>;
+}
+export interface NBTAsset extends MinecraftAsset, NBT {
+}

package/src/nbt/NBTHelper.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NBTHelper = void 0;
+const prismarineNbt = __importStar(require("prismarine-nbt"));
+class NBTHelper {
+    static async fromBuffer(buffer) {
+        const { parsed, type, metadata } = await prismarineNbt.parse(buffer);
+        console.log(parsed);
+        return parsed;
+    }
+}
+exports.NBTHelper = NBTHelper;
+//# sourceMappingURL=NBTHelper.js.map

package/src/nbt/NBTHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NBTHelper.js","sourceRoot":"./","sources":["src/nbt/NBTHelper.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,8DAAgD;AAIhD,MAAa,SAAS;IAEX,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,MAAc;QACzC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,MAAM,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACrE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACpB,OAAO,MAAM,CAAC;IAClB,CAAC;CAEJ;AARD,8BAQC"}

package/src/nbt/NBTHelper.ts

@@ -0,0 +1,15 @@
+import * as prismarineNbt from "prismarine-nbt";
+import { NBT } from "prismarine-nbt";
+import { MinecraftAsset } from "../MinecraftAsset";
+
+export class NBTHelper {
+
+    public static async fromBuffer(buffer: Buffer): Promise<NBTAsset> {
+        const { parsed, type, metadata } = await prismarineNbt.parse(buffer);
+        return parsed;
+    }
+
+}
+
+export interface NBTAsset extends MinecraftAsset, NBT {
+}

package/src/renderer/MineRenderScene.ts

@@ -0,0 +1,132 @@
+import { Object3D, Scene } from "three";
+import { SceneObject } from "./SceneObject";
+import { isSceneObject } from "../util/three";
+import merge from "ts-deepmerge";
+import { Model } from "../model/Model";
+import { ModelObject, ModelObjectOptions } from "../model/scene/ModelObject";
+import { InstanceReference } from "../instance/InstanceReference";
+import { SceneStats } from "../SceneStats";
+import { SSAOPassOUTPUT } from "three/examples/jsm/postprocessing/SSAOPass";
+import { BasicMinecraftAsset, MinecraftAsset } from "../MinecraftAsset";
+import { SceneObjectOptions } from "./SceneObjectOptions";
+import { BlockState } from "../model/block/BlockState";
+import { BlockObject, BlockObjectOptions, isBlockObject } from "../model/block/scene/BlockObject";
+import { InstanceManager } from "../instance/InstanceManager";
+import { DeepPartial, sleep } from "../util/util";
+import { SkinObject, SkinObjectOptions } from "../skin/scene/SkinObject";
+import { EntityObject, EntityObjectOptions } from "../entity/scene/EntityObject";
+import { EntityModel } from "../entity/EntityModel";
+import { AssetKey, isAssetKey } from "../assets/AssetKey";
+
+export class MineRenderScene extends Scene {
+
+    public readonly isMineRenderScene: true = true;
+
+    public static readonly DEFAULT_OPTIONS: MineRenderSceneOptions = merge({}, <MineRenderSceneOptions>{});
+    public readonly options: MineRenderSceneOptions;
+
+    readonly stats: SceneStats = new SceneStats();
+    protected readonly instanceManager: InstanceManager = new InstanceManager();
+
+    public dirty: boolean = true;
+
+    constructor(options?: DeepPartial<MineRenderSceneOptions>) {
+        super();
+        this.options = merge({}, MineRenderScene.DEFAULT_OPTIONS, options ?? {});
+    }
+
+    add(...object): this {
+        this.dirty = true;
+        this.stats.objectCount += object.length;
+        for (let obj of object) {
+            if (isSceneObject(obj)) {
+                this.stats.sceneObjectCount++;
+            }
+            // obj.addEventListener('dirty',event=>{
+            //     this.dirty = true;
+            // });
+            obj.addEventListener('change',event=>{
+                this.dirty = true;
+            });
+        }
+        return super.add(...object);
+    }
+
+    remove(...object): this {
+        this.dirty = true;
+        return super.remove(...object);
+    }
+
+    public async initAndAdd(...object: SceneObject[]): Promise<this> {
+        this.dirty = true;
+        for (let obj of object) {
+            await obj.init();
+        }
+        return this.add(...object);
+    }
+
+    async addSceneObject<A extends BasicMinecraftAsset, T extends SceneObject, O extends SceneObjectOptions>(asset: A, objectSupplier: () => T | Promise<T>, options?: Partial<O>, parent: Object3D = this): Promise<T | InstanceReference<T>> {
+        console.log("addSceneObject")
+        console.log("parent", parent)
+        this.dirty = true;
+        // console.log(this.instanceCache)
+        if (options?.instanceMeshes && asset.key &&  (<AssetKey>asset.key)?.assetType === "models"/*TODO*/) {
+            // console.log("instanceMeshes + key")
+            // check for existing instances
+            const key = asset.key.serialize();
+            return this.instanceManager.getOrCreate(key, async () => {
+                const obj = await objectSupplier();
+                obj.scene = this;
+                await obj.init();
+                parent.add(obj);
+                // await sleep(500)//TODO
+                return obj;
+            });
+        } else {
+            // console.log("!instanceMeshes | !key")
+            const obj = await objectSupplier();
+            obj.scene = this;
+            // await this.initAndAdd(obj);
+            await obj.init();
+            if (!isBlockObject(obj)) { //TODO: adding block objects slows things down (since each block has its own)
+                parent.add(obj);
+            }
+            // await sleep(500)//TODO
+            return obj;
+        }
+    }
+
+    public async addModel(model: Model, options?: Partial<ModelObjectOptions>, parent: Object3D = this): Promise<ModelObject | InstanceReference<ModelObject>> {
+        return this.addSceneObject<Model, ModelObject, ModelObjectOptions>(model, () => new ModelObject(model, options), options, parent);
+    }
+
+    public async addBlock(blockState: BlockState, options?: Partial<BlockObjectOptions>, parent: Object3D = this): Promise<BlockObject | InstanceReference<BlockObject>> {
+        return this.addSceneObject<BlockState, BlockObject, BlockObjectOptions>(blockState, () => new BlockObject(blockState, options), options, parent);
+    }
+
+    public async addSkin(skin?: string, options?: Partial<SkinObjectOptions>, parent: Object3D = this): Promise<SkinObject> {
+        this.dirty = true;
+        const obj = new SkinObject(options);
+        obj.scene = this;
+        await obj.init();
+        if (skin) {
+            obj.setSkinTexture(skin);
+        }
+        parent.add(obj);
+        return obj;
+    }
+
+    public async addEntity(entity: EntityModel, options?: Partial<EntityObjectOptions>, parent: Object3D = this): Promise<EntityObject | InstanceReference<EntityObject>> {
+        return this.addSceneObject<EntityModel, EntityObject, BlockObjectOptions>(entity, () => new EntityObject(entity, options), options, parent);
+    }
+
+}
+
+export interface MineRenderSceneOptions {
+
+}
+
+
+export function isMineRenderScene(obj: any): obj is MineRenderScene {
+    return (<MineRenderScene>obj).isMineRenderScene;
+}