minerender 1.4.11 → 2.0.0-alpha.1

package/src/renderer/SceneObject.ts

@@ -0,0 +1,446 @@
+import { BoxGeometry, Color, EdgesGeometry, Euler, InstancedMesh, LineBasicMaterial, LineSegments, MathUtils, Matrix4, Mesh, Object3D, Quaternion, Scene, Vector3 } from "three";
+import { ModelElement, ModelFaces } from "../model/ModelElement";
+import { Geometries } from "../Geometries";
+import { UVMapper } from "../UVMapper";
+import { DoubleArray, TripleArray } from "../model/Model";
+import { Axis, axisToVec3 } from "../Axis";
+import { BufferGeometry } from "three/src/core/BufferGeometry";
+import { Material } from "three/src/materials/Material";
+import { SkinPart } from "../skin/SkinPart";
+import { changeEvent, Maybe } from "../util/util";
+import { InstanceReference } from "../instance/InstanceReference";
+import { MineRenderError } from "../error/MineRenderError";
+import { isInstancedMesh, isMesh } from "../util/three";
+import { Disposable, isDisposable } from "../Disposable";
+import { SceneObjectOptions } from "./SceneObjectOptions";
+import merge from "ts-deepmerge";
+import { Instanceable } from "../instance/Instanceable";
+import { isMineRenderScene, MineRenderScene } from "./MineRenderScene";
+import { Transformable } from "../Transformable";
+import generateUUID = MathUtils.generateUUID;
+import { prefix } from "../util/log";
+
+const p = prefix("SceneObject");
+
+export class SceneObject extends Object3D implements Disposable, Instanceable, Transformable {
+
+    public readonly isSceneObject: true = true;
+
+    public static readonly DEFAULT_OPTIONS: SceneObjectOptions = merge({}, <SceneObjectOptions>{
+        instanceMeshes: true,
+        maxInstanceCount: 50,
+        mergeMeshes: true,
+        wireframe: false
+    });
+    public readonly options: SceneObjectOptions;
+
+    private _scene: Maybe<MineRenderScene>;
+
+    private materialCallbacks: { [key: string]: Array<(mat: Material, key: string) => void>; } = {};
+
+    protected _isInstanced: boolean = false;
+    _instanceCounter: number = 0;
+
+    constructor(options?: Partial<SceneObjectOptions>) {
+        super();
+        this.options = merge({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
+    }
+
+    public set scene(scene: MineRenderScene) {
+        if (!!this._scene) throw new MineRenderError("Scene already set");
+        this._scene = scene;
+    }
+
+    public get scene(): MineRenderScene {
+        if (!this._scene) throw new MineRenderError("Scene not set");
+        return this._scene;
+    }
+
+    async init(): Promise<void> {
+    }
+
+    public notifyDirty() {
+        this.dispatchEvent(changeEvent);
+    }
+
+    //<editor-fold desc="GROUPS">
+
+    protected createAndAddGroup(name?: string, x: number = 0, y: number = 0, z: number = 0, offsetAxis?: Axis, offset: number = 0): Object3D {
+        const group = this.createGroup(name, x, y, z, offsetAxis, offset);
+        this.add(group);
+        this.notifyDirty();
+        return group;
+    }
+
+    protected createGroup(name?: string, x: number = 0, y: number = 0, z: number = 0, offsetAxis?: Axis, offset: number = 0): Object3D {
+        const obj = new Object3D();
+        if (name) {
+            obj.name = `group:${ name }`;
+        }
+        if (x > 0 || y > 0 || z > 0) {
+            obj.position.set(x, y, z);
+        }
+        if (offsetAxis) {
+            obj.translateOnAxis(axisToVec3(offsetAxis), offset);
+        }
+        return obj;
+    }
+
+    /**
+     * Get a group by its name
+     */
+    public getGroupByName(name: string): Maybe<Object3D> {
+        return this.getObjectByName(`group:${ name }`) as Object3D;
+    }
+
+    /**
+     * Toggle visibility of a group
+     * @param name name of the group
+     * @param visible set the visibility directly, if not set toggles it
+     */
+    public toggleGroupVisibility(name: string, visible?: boolean): boolean {
+        return this.toggleObjectVisibility(this.getGroupByName(name), visible);
+    }
+
+    //</editor-fold>
+
+    //<editor-fold desc="MESHES">
+
+    protected createAndAddMesh(name?: string, group?: Object3D, geometry?: BufferGeometry, material?: Material | Material[], offsetAxis?: Axis, offset: number = 0): Mesh {
+        const mesh = this.createMesh(name, geometry, material, offsetAxis, offset);
+        if (group) {
+            group.add(mesh);
+        } else {
+            this.add(mesh);
+        }
+        this.notifyDirty();
+        return mesh;
+    }
+
+    protected createMesh(name?: string, geometry?: BufferGeometry, material?: Material | Material[], offsetAxis?: Axis, offset: number = 0): Mesh {
+        const mesh = new Mesh(geometry, material);
+        if (name) {
+            mesh.name = `mesh:${ name }`;
+        }
+
+        //TODO
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+
+        if (offsetAxis) {
+            mesh.translateOnAxis(axisToVec3(offsetAxis), offset);
+        }
+        return mesh;
+    }
+
+    protected createInstancedMesh(name: Maybe<string>, geometry: BufferGeometry, material: Material | Material[], count: number): InstancedMesh {
+        const mesh = new InstancedMesh(geometry, material, count);
+        if (name) {
+            mesh.name = `mesh:${ name }`;
+        }
+        return mesh;
+    }
+
+    /**
+     * Get a mesh by its name
+     */
+    public getMeshByName(name: string): Maybe<Mesh> {
+        return this.getObjectByName(`mesh:${ name }`) as Mesh;
+    }
+
+    /**
+     * Toggle visibility of a mesh
+     * @param name name of the mesh
+     * @param visible set the visibility directly, if not set toggles it
+     */
+    public toggleMeshVisibility(name: string, visible?: boolean): boolean {
+        return this.toggleObjectVisibility(this.getMeshByName(name), visible);
+    }
+
+    public iterateAllMeshes(cb: (mesh: Mesh) => void) {
+        this.children.forEach(obj => {
+            if ((<Mesh>obj).isMesh) {
+                cb(obj as Mesh);
+            }
+            obj.children.forEach(obj1 => {
+                if ((<Mesh>obj1).isMesh) {
+                    cb(obj1 as Mesh);
+                }
+            })
+        })
+    }
+
+    //</editor-fold>
+
+    //<editor-fold desc="GEOMETRIES">
+
+    protected _getBoxGeometryFromDimensions([width, height, depth]: TripleArray, faces: ModelFaces, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray): BoxGeometry {
+        const uv = UVMapper.facesToUvArray(faces, originalTextureSize, actualTextureSize);
+        return Geometries.getBox({
+            width,
+            height,
+            depth,
+            uv
+        });
+    }
+
+    protected _getBoxGeometryFromElement(element: ModelElement): BoxGeometry {
+        const width = element.to[0] - element.from[0];
+        const height = element.to[1] - element.from[1];
+        const depth = element.to[2] - element.from[2];
+
+        const uv = element.mappedUv;
+
+        return Geometries.getBox({
+            width,
+            height,
+            depth,
+            uv
+        });
+    }
+
+    protected _getBoxGeometryForDimensionsAndUv(width: number, height: number, depth: number, uv: number[]): BoxGeometry {
+        return Geometries.getBox({
+            width,
+            height,
+            depth,
+            uv
+        });
+    }
+
+    //</editor-fold>
+
+    //<editor-fold desc="INSTANCING">
+
+    get isInstanced(): boolean {
+        return this._isInstanced;
+    }
+
+    get instanceCounter(): number {
+        return this._instanceCounter;
+    }
+
+    protected constructInstanceReference(i: number): InstanceReference<SceneObject> {
+        return new InstanceReference<this>(this, i);
+    }
+
+    nextInstance(): InstanceReference<SceneObject> {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        const i = this._instanceCounter++;
+        this.setMatrixAt(i, new Matrix4());
+        console.debug(p,"nextInstance " + i);
+        if (i === this.options.maxInstanceCount) {
+            console.warn(p,"Max instance count reached for " + this);
+        }
+        if (this.scene) {
+            this.scene.stats.instanceCount++;
+        }
+        this.notifyDirty();
+        return this.constructInstanceReference(i);
+    }
+
+    //</editor-fold>
+
+    //<editor-fold desc="TRANSFORMATION">
+
+    getMatrixAt(index: number, matrix: Matrix4 = new Matrix4()): Matrix4 {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        const child = this.children[0];
+        if (child && isInstancedMesh(child)) {//TODO: figure out why child isn't set
+            child.getMatrixAt(index, matrix);
+        }
+        return matrix;
+    }
+
+    setMatrixAt(index: number, matrix: Matrix4) {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        const child = this.children[0];
+        if (child && isInstancedMesh(child)) {//TODO: figure out why child isn't set
+            child.setMatrixAt(index, matrix);
+            child.instanceMatrix.needsUpdate = true;
+        }
+        this.notifyDirty();
+    }
+
+    setPositionRotationScaleAt(index: number, position?: Vector3, rotation?: Euler, scale?: Vector3) {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+
+        const oldPosition = new Vector3();
+        const oldRotation = new Quaternion();
+        const oldScale = new Vector3();
+
+        const matrix = new Matrix4();
+        if (!scale || !rotation || !position) {
+            this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
+        }
+
+        matrix.compose(
+            position ? position : oldPosition,
+            rotation ? new Quaternion().setFromEuler(rotation) : oldRotation,
+            scale ? scale : oldScale
+        );
+
+        this.setMatrixAt(index, matrix);
+    }
+
+    setPositionAt(index: number, position: Vector3) {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        this.setPositionRotationScaleAt(index, position);
+    }
+
+    getPositionAt(index: number, vector: Vector3 = new Vector3()): Vector3 {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        const matrix = this.getMatrixAt(index)
+        vector.setFromMatrixPosition(matrix);
+        return vector;
+    }
+
+    setRotationAt(index: number, rotation: Euler) {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        this.setPositionRotationScaleAt(index, undefined, rotation, undefined);
+    }
+
+    getRotationAt(index: number, euler: Euler = new Euler()): Euler {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        const matrix = this.getMatrixAt(index)
+        euler.setFromRotationMatrix(matrix);
+        return euler;
+    }
+
+    setScaleAt(index: number, scale: Vector3) {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        this.setPositionRotationScaleAt(index, undefined, undefined, scale);
+    }
+
+    getScaleAt(index: number, vector: Vector3 = new Vector3()): Vector3 {
+        if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
+        const matrix = this.getMatrixAt(index)
+        vector.setFromMatrixScale(matrix);
+        return vector;
+    }
+
+    setPositionRotationScale(position?: Vector3, rotation?: Euler, scale?: Vector3): void {
+        if (this.isInstanced) {
+            //TODO: specific instance
+            for (let i = 0; i < this.instanceCounter; i++) {
+                this.setPositionRotationScaleAt(i, position, rotation, scale);
+            }
+        } else {
+            if (position) {
+                this.position.set(position.x, position.y, position.z);
+            }
+            if (rotation) {
+                this.rotation.set(rotation.x, rotation.y, rotation.z);
+            }
+            if (scale) {
+                this.scale.set(scale.x, scale.y, scale.z);
+            }
+        }
+        this.notifyDirty();
+    }
+
+    setPosition(position: Vector3) {
+        if (this.isInstanced) {
+            //TODO: specific instance
+            for (let i = 0; i < this.instanceCounter; i++) {
+                this.setPositionRotationScaleAt(i, position);
+            }
+        } else {
+            this.position.set(position.x, position.y, position.z);
+        }
+        this.notifyDirty();
+    }
+
+    getPosition(): Vector3 {
+        if (this.isInstanced) {
+            return this.getPositionAt(0);
+        } else {
+            return this.position;
+        }
+    }
+
+    setRotation(rotation: Euler) {
+        if (this.isInstanced) {
+            //TODO: specific instance
+            for (let i = 0; i < this.instanceCounter; i++) {
+                this.setPositionRotationScaleAt(i, undefined, rotation);
+            }
+        } else {
+            this.rotation.set(rotation.x, rotation.y, rotation.z);
+        }
+        this.notifyDirty();
+    }
+
+    getRotation(): Euler {
+        if (this.isInstanced) {
+            return this.getRotationAt(0);
+        } else {
+            return this.rotation;
+        }
+    }
+
+    setScale(scale: Vector3) {
+        if (this.isInstanced) {
+            //TODO: specific instance
+            for (let i = 0; i < this.instanceCounter; i++) {
+                this.setPositionRotationScaleAt(i, undefined, undefined, scale);
+            }
+        } else {
+            this.scale.set(scale.x, scale.y, scale.z);
+        }
+        this.notifyDirty();
+    }
+
+    getScale(): Vector3 {
+        if (this.isInstanced) {
+            return this.getScaleAt(0);
+        } else {
+            return this.scale;
+        }
+    }
+
+    //</editor-fold>
+
+    protected toggleObjectVisibility(object?: Object3D, visible?: boolean): boolean {
+        if (object) {
+            if (typeof visible !== "undefined") {
+                object.visible = visible;
+            } else {
+                object.visible = !object.visible;
+            }
+            return object.visible;
+        }
+        this.notifyDirty();
+        return false;
+    }
+
+    //<editor-fold desc="CLEANUP">
+
+    public dispose() {
+        this.disposeAndRemoveAllChildren();
+        this.notifyDirty();
+    }
+
+    public disposeAndRemoveAllChildren() {
+        while (this.children.length > 0) {
+            let c = this.children[0];
+            if (isDisposable(c)) {
+                c.dispose();
+            }
+            this.remove(c);
+        }
+        this.notifyDirty();
+    }
+
+    public removeFromScene() {
+        this._scene?.remove(this);
+        this.notifyDirty();
+    }
+
+    //</editor-fold>
+
+}
+
+export function isSceneObject(obj: any): obj is SceneObject {
+    return (<SceneObject>obj).isSceneObject;
+}

package/src/renderer/SceneObjectOptions.ts

@@ -0,0 +1,6 @@
+export interface SceneObjectOptions {
+    wireframe: boolean;
+    mergeMeshes: boolean;
+    instanceMeshes: boolean;
+    maxInstanceCount: number;
+}

package/src/request/Requests.ts

@@ -0,0 +1,44 @@
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
+import { JobQueue } from "jobqu";
+import { Time } from "@inventivetalent/time";
+import { prefix } from "../util/log";
+
+const p = prefix("Requests");
+
+if (typeof window === "undefined") {
+    axios.defaults.headers["User-Agent"] = "MineRender";
+}
+
+export class Requests {
+
+    private static axiosInstance: AxiosInstance = axios.create({});
+
+    private static mcAssetInstance: AxiosInstance = axios.create({
+    })
+
+    private static mcAssetRequestQueue: JobQueue<AxiosRequestConfig, AxiosResponse>
+        = new JobQueue<AxiosRequestConfig, AxiosResponse>(request => Requests.mcAssetInstance.request(request), Time.millis(10));
+
+    public static genericRequest(request: AxiosRequestConfig): Promise<AxiosResponse> {
+        return this.axiosInstance.request(request);
+    }
+
+    public static mcAssetRequest(request: AxiosRequestConfig): Promise<AxiosResponse> {
+        return this.mcAssetRequestQueue.add(request).catch(e=>{
+            console.debug(p, "mcAssetRequest catch " + e);
+            throw e;
+        });
+        // return Requests.mcAssetInstance.request(request)
+    }
+
+    public static setMcAssetRoot(root: string) {
+        this.mcAssetInstance.defaults.baseURL = root;
+    }
+
+    public static get queueSizes() {
+        return {
+            mcAsset: this.mcAssetRequestQueue.size
+        }
+    }
+
+}

package/src/skin/SkinGeometries.d.ts

@@ -0,0 +1,5 @@
+import { SkinPart } from "./SkinPart";
+import { TripleArray } from "../model/Model";
+export declare type SkinGeometries = Record<SkinPart, TripleArray>;
+export declare const classicSkinGeometries: SkinGeometries;
+export declare const slimSkinGeometries: SkinGeometries;

package/src/skin/SkinGeometries.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slimSkinGeometries = exports.classicSkinGeometries = void 0;
+const ts_deepmerge_1 = __importDefault(require("ts-deepmerge"));
+const box8inner = [8, 8, 8];
+const box8outer = [8.504, 8.504, 8.504];
+const box8_12_4inner = [8, 12, 4];
+const box8_12_4outer = [8.504, 12.504, 4.504];
+const box4_12_4inner = [4, 12, 4];
+const box4_12_4outer = [4.504, 12.504, 4.504];
+const box3_12_4inner = [3, 12, 4];
+const box3_12_4outer = [3.504, 12.504, 4.504];
+const box10_16_1 = [10, 16, 1];
+const baseSkinGeometries = {
+    head: box8inner,
+    hat: box8outer,
+    body: box8_12_4inner,
+    jacket: box8_12_4outer,
+    leftArm: box4_12_4inner,
+    leftSleeve: box4_12_4outer,
+    rightArm: box4_12_4inner,
+    rightSleeve: box4_12_4outer,
+    leftLeg: box4_12_4inner,
+    leftTrousers: box4_12_4outer,
+    rightLeg: box4_12_4inner,
+    rightTrousers: box4_12_4outer,
+    cape: box10_16_1
+};
+exports.classicSkinGeometries = ts_deepmerge_1.default(baseSkinGeometries);
+exports.slimSkinGeometries = ts_deepmerge_1.default(baseSkinGeometries, {
+    leftArm: box3_12_4inner,
+    leftSleeve: box3_12_4outer,
+    rightArm: box3_12_4inner,
+    rightSleeve: box3_12_4outer,
+});
+//# sourceMappingURL=SkinGeometries.js.map

package/src/skin/SkinGeometries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkinGeometries.js","sourceRoot":"./","sources":["src/skin/SkinGeometries.ts"],"names":[],"mappings":";;;;;;AAEA,gEAAiC;AAIjC,MAAM,SAAS,GAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AACzC,MAAM,SAAS,GAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAErD,MAAM,cAAc,GAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AAC/C,MAAM,cAAc,GAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAE3D,MAAM,cAAc,GAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AAC/C,MAAM,cAAc,GAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAE3D,MAAM,cAAc,GAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AAC/C,MAAM,cAAc,GAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAE3D,MAAM,UAAU,GAAgB,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AAE5C,MAAM,kBAAkB,GAAmB;IACvC,IAAI,EAAE,SAAS;IACf,GAAG,EAAE,SAAS;IAEd,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,cAAc;IAEtB,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,cAAc;IAE1B,QAAQ,EAAE,cAAc;IACxB,WAAW,EAAE,cAAc;IAE3B,OAAO,EAAE,cAAc;IACvB,YAAY,EAAE,cAAc;IAE5B,QAAQ,EAAE,cAAc;IACxB,aAAa,EAAE,cAAc;IAE7B,IAAI,EAAE,UAAU;CACnB,CAAA;AAEY,QAAA,qBAAqB,GAAmB,sBAAK,CAAC,kBAAkB,CAAC,CAAC;AAClE,QAAA,kBAAkB,GAAmB,sBAAK,CAAC,kBAAkB,EAAE;IACxE,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,cAAc;IAE1B,QAAQ,EAAE,cAAc;IACxB,WAAW,EAAE,cAAc;CAC9B,CAAC,CAAC"}

package/src/skin/SkinGeometries.ts

@@ -0,0 +1,50 @@
+import { SkinPart } from "./SkinPart";
+import { TripleArray } from "../model/Model";
+import merge from "ts-deepmerge";
+
+export type SkinGeometries = Record<SkinPart, TripleArray>;
+
+const box8inner: TripleArray = [8, 8, 8];
+const box8outer: TripleArray = [8.504, 8.504, 8.504];
+
+const box8_12_4inner: TripleArray = [8, 12, 4];
+const box8_12_4outer: TripleArray = [8.504, 12.504, 4.504];
+
+const box4_12_4inner: TripleArray = [4, 12, 4];
+const box4_12_4outer: TripleArray = [4.504, 12.504, 4.504];
+
+const box3_12_4inner: TripleArray = [3, 12, 4];
+const box3_12_4outer: TripleArray = [3.504, 12.504, 4.504];
+
+const box10_16_1: TripleArray = [10, 16, 1];
+
+const baseSkinGeometries: SkinGeometries = {
+    head: box8inner,
+    hat: box8outer,
+
+    body: box8_12_4inner,
+    jacket: box8_12_4outer,
+
+    leftArm: box4_12_4inner,
+    leftSleeve: box4_12_4outer,
+
+    rightArm: box4_12_4inner,
+    rightSleeve: box4_12_4outer,
+
+    leftLeg: box4_12_4inner,
+    leftTrousers: box4_12_4outer,
+
+    rightLeg: box4_12_4inner,
+    rightTrousers: box4_12_4outer,
+
+    cape: box10_16_1
+}
+
+export const classicSkinGeometries: SkinGeometries = merge(baseSkinGeometries);
+export const slimSkinGeometries: SkinGeometries = merge(baseSkinGeometries, {
+    leftArm: box3_12_4inner,
+    leftSleeve: box3_12_4outer,
+
+    rightArm: box3_12_4inner,
+    rightSleeve: box3_12_4outer,
+});

package/src/skin/SkinPart.d.ts

@@ -0,0 +1,16 @@
+export declare enum SkinPart {
+    HEAD = "head",
+    BODY = "body",
+    RIGHT_ARM = "rightArm",
+    LEFT_ARM = "leftArm",
+    RIGHT_LEG = "rightLeg",
+    LEFT_LEG = "leftLeg",
+    HAT = "hat",
+    JACKET = "jacket",
+    RIGHT_SLEEVE = "rightSleeve",
+    LEFT_SLEEVE = "leftSleeve",
+    RIGHT_TROUSERS = "rightTrousers",
+    LEFT_TROUSERS = "leftTrousers",
+    CAPE = "cape"
+}
+export declare const SKIN_PARTS: SkinPart[];

package/src/skin/SkinPart.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKIN_PARTS = exports.SkinPart = void 0;
+var SkinPart;
+(function (SkinPart) {
+    SkinPart["HEAD"] = "head";
+    SkinPart["BODY"] = "body";
+    SkinPart["RIGHT_ARM"] = "rightArm";
+    SkinPart["LEFT_ARM"] = "leftArm";
+    SkinPart["RIGHT_LEG"] = "rightLeg";
+    SkinPart["LEFT_LEG"] = "leftLeg";
+    SkinPart["HAT"] = "hat";
+    SkinPart["JACKET"] = "jacket";
+    SkinPart["RIGHT_SLEEVE"] = "rightSleeve";
+    SkinPart["LEFT_SLEEVE"] = "leftSleeve";
+    SkinPart["RIGHT_TROUSERS"] = "rightTrousers";
+    SkinPart["LEFT_TROUSERS"] = "leftTrousers";
+    SkinPart["CAPE"] = "cape";
+})(SkinPart = exports.SkinPart || (exports.SkinPart = {}));
+exports.SKIN_PARTS = Object.values(SkinPart);
+//# sourceMappingURL=SkinPart.js.map

package/src/skin/SkinPart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkinPart.js","sourceRoot":"./","sources":["src/skin/SkinPart.ts"],"names":[],"mappings":";;;AAAA,IAAY,QAgBX;AAhBD,WAAY,QAAQ;IAChB,yBAAa,CAAA;IACb,yBAAa,CAAA;IACb,kCAAsB,CAAA;IACtB,gCAAoB,CAAA;IACpB,kCAAsB,CAAA;IACtB,gCAAoB,CAAA;IAEpB,uBAAW,CAAA;IACX,6BAAiB,CAAA;IACjB,wCAA4B,CAAA;IAC5B,sCAA0B,CAAA;IAC1B,4CAAgC,CAAA;IAChC,0CAA8B,CAAA;IAE9B,yBAAa,CAAA;AACjB,CAAC,EAhBW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAgBnB;AAEY,QAAA,UAAU,GAAe,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC"}

package/src/skin/SkinPart.ts

@@ -0,0 +1,19 @@
+export enum SkinPart {
+    HEAD = "head",
+    BODY = "body",
+    RIGHT_ARM = "rightArm",
+    LEFT_ARM = "leftArm",
+    RIGHT_LEG = "rightLeg",
+    LEFT_LEG = "leftLeg",
+
+    HAT = "hat",
+    JACKET = "jacket",
+    RIGHT_SLEEVE = "rightSleeve",
+    LEFT_SLEEVE = "leftSleeve",
+    RIGHT_TROUSERS = "rightTrousers",
+    LEFT_TROUSERS = "leftTrousers",
+
+    CAPE = "cape"
+}
+
+export const SKIN_PARTS: SkinPart[] = Object.values(SkinPart);

package/src/skin/SkinTextureCoordinates.d.ts

@@ -0,0 +1,5 @@
+import { SkinPart } from "./SkinPart";
+import { ModelFaces } from "../model/ModelElement";
+export declare type SkinTextureCoordinates = Record<SkinPart, ModelFaces>;
+export declare const classicSkinTextureCoordinates: Readonly<SkinTextureCoordinates>;
+export declare const slimSkinTextureCoordinates: Readonly<SkinTextureCoordinates>;