bucciafico-lib 1.0.4-BETA

package/src/plugins/IOPlugin.js

@@ -0,0 +1,156 @@
+/**
+ * Plugin responsible for Import/Export of the entire scene state.
+ * It gathers data from Core and all other Plugins to create a comprehensive JSON snapshot.
+ */
+export class IOPlugin {
+    constructor() {
+        this.name = 'IOPlugin';
+    }
+
+    init(viewer) {
+        this.viewer = viewer;
+    }
+
+    /**
+     * Exports the scene state based on provided options.
+     * @param {Object} options - Filters for export.
+     * @param {boolean} options.skin - Include skin source (username/url).
+     * @param {boolean} options.camera - Include camera position/target.
+     * @param {boolean} options.effects - Include effects config.
+     * @param {boolean} options.pose - Include character pose.
+     * @param {boolean} options.items - Include items.
+     */
+    exportState(options = { skin: true, camera: true, effects: true, pose: true, items: true }) {
+        const state = {
+            meta: {
+                generator: "Bucciafico Studio",
+                version: "1.0.4-BETA",
+                timestamp: Date.now()
+            },
+            core: {}
+        };
+
+        if (options.skin) {
+            state.core.skin = this.viewer.skinData || null;
+        }
+
+        // 2. Camera & Config
+        if (options.camera) {
+            state.core.camera = this.viewer.cameraManager.getSettingsJSON();
+            state.core.config = {
+                bgColor: this.viewer.config.bgColor,
+                transparent: this.viewer.config.transparent,
+                showGrid: this.viewer.config.showGrid
+            };
+        }
+
+        // 3. Pose
+        if (options.pose) {
+            state.pose = this.viewer.skinModel.getPose();
+        }
+
+        // 4. Effects
+        if (options.effects) {
+            const effectsPlugin = this.viewer.getPlugin('EffectsPlugin');
+            if (effectsPlugin) {
+                state.effects = {
+                    backlight: effectsPlugin.getConfig()
+                };
+            }
+        }
+
+        // 5. Items
+        if (options.items) {
+            const itemsPlugin = this.viewer.getPlugin('ItemsPlugin');
+            if (itemsPlugin && itemsPlugin.items.length > 0) {
+                state.items = itemsPlugin.items.map(item => ({
+                    name: item.name,
+                    uuid: item.uuid,
+                    sourceUrl: item.userData.sourceUrl || null,
+                    transform: {
+                        pos: item.position.toArray(),
+                        rot: item.rotation.toArray(),
+                        scale: item.scale.toArray()
+                    }
+                }));
+            }
+        }
+
+        return state;
+    }
+
+    /**
+     * Imports a full state from a JSON object.
+     * Reconstructs the scene step-by-step.
+     * @param {Object|string} jsonData
+     * @returns {Promise<void>}
+     */
+    async importState(jsonData) {
+        const data = typeof jsonData === 'string' ? JSON.parse(jsonData) : jsonData;
+
+        // 1. Core Config (Background, Grid)
+        if (data.core?.config) {
+            const cfg = data.core.config;
+            this.viewer.config.showGrid = cfg.showGrid;
+            this.viewer.sceneSetup.setGridVisible(cfg.showGrid);
+            if (!cfg.transparent && cfg.bgColor) {
+                this.viewer.scene.background.setHex(cfg.bgColor);
+            }
+        }
+
+        // 2. Camera
+        if (data.core?.camera) {
+            this.viewer.cameraManager.loadSettingsJSON(data.core.camera);
+        }
+
+        // 3. Skin (Async)
+        if (data.core?.skin) {
+            const skinInfo = data.core.skin;
+            try {
+                if (skinInfo.type === 'username') {
+                    await this.viewer.loadSkinByUsername(skinInfo.value);
+                } else if (skinInfo.value) {
+                    await this.viewer.loadSkin(skinInfo.value);
+                }
+            } catch (e) {
+                console.warn("Failed to load skin from import:", e);
+            }
+        }
+
+        // 4. Effects
+        if (data.effects?.backlight) {
+            const fx = this.viewer.getPlugin('EffectsPlugin');
+            if (fx) fx.updateConfig(data.effects.backlight);
+        }
+
+        // 5. Items (Async & Complex)
+        const itemsPlugin = this.viewer.getPlugin('ItemsPlugin');
+        if (itemsPlugin) {
+            [...itemsPlugin.items].forEach(item => itemsPlugin.removeItem(item));
+
+            if (data.items && Array.isArray(data.items)) {
+                const promises = data.items.map(async (itemData) => {
+                    if (!itemData.sourceUrl) return;
+
+                    try {
+                        const mesh = await itemsPlugin.addItem(itemData.sourceUrl, itemData.name);
+                        // Apply Transform
+                        if (itemData.transform) {
+                            mesh.position.fromArray(itemData.transform.pos);
+                            mesh.rotation.fromArray(itemData.transform.rot);
+                            mesh.scale.fromArray(itemData.transform.scale);
+                        }
+                    } catch (e) {
+                        console.warn(`Failed to import item ${itemData.name}:`, e);
+                    }
+                });
+                await Promise.all(promises);
+            }
+        }
+
+        // 6. Pose
+        if (data.pose) {
+            this.viewer.setPose(data.pose);
+        }
+    }
+}

package/src/plugins/ItemsPlugin.js

@@ -0,0 +1,71 @@
+import { ItemFactory } from '../objects/ItemFactory.js';
+
+/**
+ * Plugin responsible for managing 3D Items (Swords, Blocks).
+ */
+export class ItemsPlugin {
+    constructor() {
+        this.name = 'ItemsPlugin';
+        /** @type {Array<THREE.Mesh>} List of current items on scene */
+        this.items = [];
+    }
+
+    init(viewer) {
+        this.viewer = viewer;
+    }
+
+    /**
+     * Creates and adds an item to the scene.
+     * @param {string} url - Texture URL.
+     * @param {string} name - Item name.
+     */
+    addItem(url, name) {
+        const editor = this.viewer.getPlugin('EditorPlugin');
+        if (editor) editor.saveHistory();
+
+        return ItemFactory.createFromURL(url, name).then(mesh => {
+            mesh.position.set(8, 8, 8);
+            mesh.userData.sourceUrl = url;
+            this.viewer.scene.add(mesh);
+            this.items.push(mesh);
+
+            // Auto-select if editor is present
+            if (editor) editor.selectObject(mesh);
+            return mesh;
+        });
+    }
+
+    removeItem(mesh) {
+        const editor = this.viewer.getPlugin('EditorPlugin');
+        if (editor) editor.saveHistory();
+
+        this.viewer.scene.remove(mesh);
+        this.items = this.items.filter(i => i !== mesh);
+
+        if (editor) editor.deselect();
+    }
+
+    // --- SNAPSHOT HELPERS ---
+
+    getSnapshot() {
+        return this.items.map(item => ({
+            name: item.name,
+            uuid: item.uuid,
+            pos: item.position.toArray(),
+            rot: item.rotation.toArray(),
+            scale: item.scale.toArray()
+        }));
+    }
+
+    restoreSnapshot(itemsState) {
+        itemsState.forEach(state => {
+            // Try to find the item by UUID first, then Name
+            const item = this.items.find(i => i.uuid === state.uuid || i.name === state.name);
+            if (item) {
+                item.position.fromArray(state.pos);
+                item.rotation.fromArray(state.rot);
+                item.scale.fromArray(state.scale);
+            }
+        });
+    }
+}

package/src/utils/SkinUtils.js

@@ -0,0 +1,66 @@
+/**
+ * Calculates UV coordinates for standard Minecraft skin layout.
+ */
+export function getUV(x, y, w, h) {
+    const imgW = 64;
+    const imgH = 64;
+    return { u0: x/imgW, u1: (x+w)/imgW, v0: (imgH-y-h)/imgH, v1: (imgH-y)/imgH };
+}
+
+/**
+ * Maps UV coordinates to a box geometry (Cube mapping).
+ */
+export function applySkinUVs(geometry, x, y, w, h, d) {
+    const uvAttr = geometry.attributes.uv;
+
+    /**
+     * Helper to map a single face.
+     * @param {number} idx - Face index (0-5).
+     * @param {number} uX - Texture X.
+     * @param {number} uY - Texture Y.
+     * @param {number} uW - Texture Width.
+     * @param {number} uH - Texture Height.
+     * @param {boolean} flipX - Mirror horizontally.
+     * @param {boolean} flipY - Mirror vertically.
+     */
+    const map = (idx, uX, uY, uW, uH, flipX = false, flipY = false) => {
+        const uv = getUV(uX, uY, uW, uH);
+        const i = idx * 4;
+
+        // Handle flipping
+        const u0 = flipX ? uv.u1 : uv.u0;
+        const u1 = flipX ? uv.u0 : uv.u1;
+        const v0 = flipY ? uv.v1 : uv.v0;
+        const v1 = flipY ? uv.v0 : uv.v1;
+
+        uvAttr.setXY(i+0, u0, v1);
+        uvAttr.setXY(i+1, u1, v1);
+        uvAttr.setXY(i+2, u0, v0);
+        uvAttr.setXY(i+3, u1, v0);
+    };
+
+    map(0, x + d + w, y + d, d, h); // Right
+    map(1, x, y + d, d, h); // Left
+    map(2, x + d, y, w, d); // Top
+    map(3, x + d + w, y, w, d, false, true); // Bottom
+    map(4, x + d, y + d, w, h); // Front
+    map(5, x + d + w + d, y + d, w, h); // Back
+
+    uvAttr.needsUpdate = true;
+}
+
+/**
+ * Detects if a skin is Slim (Alex model) by checking the pixel at (55, 20).
+ * If transparent, it's Slim. If opaque, it's Classic.
+ * @param {HTMLImageElement} image
+ * @returns {boolean} True if Slim.
+ */
+export function detectSlimSkin(image) {
+    const canvas = document.createElement('canvas');
+    canvas.width = image.width;
+    canvas.height = image.height;
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(image, 0, 0);
+    // Check specific pixel transparency
+    return ctx.getImageData(55, 20, 1, 1).data[3] === 0;
+}

package/src/utils/Voxelizer.js

@@ -0,0 +1,58 @@
+import * as THREE from 'three';
+import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+
+/**
+ * Converts the 2nd layer of a skin (Hat, Jacket) into 3D Voxels.
+ * This gives the skin actual depth instead of flat planes.
+ * @param {THREE.Texture} texture
+ * @param {Object} layerDef - Definition of UVs and dimensions.
+ * @returns {THREE.BufferGeometry|null} Merged geometry of all voxels.
+ */
+export function createVoxelLayer(texture, layerDef) {
+    const canvas = document.createElement('canvas');
+    canvas.width = 64; canvas.height = 64;
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(texture.image, 0, 0);
+    const imgData = ctx.getImageData(0, 0, 64, 64).data;
+
+    const geometries = [];
+    const { outer } = layerDef.uv;
+    const { w, h, d } = layerDef.size;
+
+    // Mapping faces of the body part to UV coordinates
+    const faces = [
+        { u: outer.x+d, v: outer.y+d, w: w, h: h, pos: (i,j) => new THREE.Vector3(i-w/2+0.5, j-h/2+0.5, d/2+0.25) },
+        { u: outer.x+d+w+d, v: outer.y+d, w: w, h: h, pos: (i,j) => new THREE.Vector3(-(i-w/2+0.5), j-h/2+0.5, -d/2-0.25) },
+        { u: outer.x, v: outer.y+d, w: d, h: h, pos: (i,j) => new THREE.Vector3(-w/2-0.25, j-h/2+0.5, i-d/2+0.5), sx: 0.5 },
+        { u: outer.x+d+w, v: outer.y+d, w: d, h: h, pos: (i,j) => new THREE.Vector3(w/2+0.25, j-h/2+0.5, -(i-d/2+0.5)), sx: 0.5 },
+        { u: outer.x+d, v: outer.y, w: w, h: d, pos: (i,j) => new THREE.Vector3(i-w/2+0.5, h/2+0.25, -(j-d/2+0.5)), sy: 0.5 },
+        { u: outer.x+d+w, v: outer.y, w: w, h: d, pos: (i,j) => new THREE.Vector3(i-w/2+0.5, -h/2-0.25, (d - 1 - j) - d/2 + 0.5), sy: 0.5 }
+    ];
+
+    const baseGeo = new THREE.BoxGeometry(1, 1, 1);
+
+    faces.forEach(f => {
+        for(let i=0; i<f.w; i++) {
+            for(let j=0; j<f.h; j++) {
+                const u = f.u + i;
+                const v = f.v + j;
+
+                if(imgData[(v*64+u)*4+3] > 0) {
+                    const geo = baseGeo.clone();
+
+                    const uvAttr = geo.attributes.uv;
+                    for(let k=0; k<uvAttr.count; k++) uvAttr.setXY(k, (u+0.5)/64, 1.0-(v+0.5)/64);
+
+                    const m = new THREE.Matrix4();
+                    const scale = new THREE.Vector3(f.sx||1, f.sy||1, f.sz||1);
+                    if(f === faces[0] || f === faces[1]) scale.z = 0.5;
+                    m.compose(f.pos(i, (f.h-1)-j), new THREE.Quaternion(), scale);
+                    geo.applyMatrix4(m);
+                    geometries.push(geo);
+                }
+            }
+        }
+    });
+
+    return geometries.length > 0 ? BufferGeometryUtils.mergeGeometries(geometries) : null;
+}