import * as THREE from 'three'; import { GLTFLoader, GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js'; import {Skin, determineModelType, Cape} from '../skins'; import { reactive } from "vue"; export interface RenderResult { forwards: string; backwards: string; } class BatchSkinRenderer { private renderer: THREE.WebGLRenderer; private readonly scene: THREE.Scene; private readonly camera: THREE.PerspectiveCamera; private modelCache: Map = new Map(); private textureCache: Map = new Map(); private currentModel: THREE.Group | null = null; private capeModel: THREE.Object3D | null = null; private bodyNode: THREE.Object3D | null = null; private capeAttached: boolean = false; constructor(width: number = 215, height: number = 215*2) { const canvas = document.createElement('canvas'); canvas.width = width; canvas.height = height; this.renderer = new THREE.WebGLRenderer({ canvas: canvas, antialias: true, alpha: true, preserveDrawingBuffer: true }); this.renderer.outputColorSpace = THREE.SRGBColorSpace; this.renderer.toneMapping = THREE.NoToneMapping; this.renderer.setClearColor(0x000000, 0); this.renderer.setSize(width, height); this.scene = new THREE.Scene(); this.camera = new THREE.PerspectiveCamera(20, width/height, 0.4, 1000); const ambientLight = new THREE.AmbientLight(0xffffff, 2); this.scene.add(ambientLight); } private async loadModel(modelUrl: string): Promise { if (this.modelCache.has(modelUrl)) { return this.modelCache.get(modelUrl)!; } const loader = new GLTFLoader(); return new Promise((resolve, reject) => { loader.load( modelUrl, (gltf) => { this.modelCache.set(modelUrl, gltf); resolve(gltf); }, undefined, reject ); }); } private async loadTexture(textureUrl: string): Promise { if (this.textureCache.has(textureUrl)) { return this.textureCache.get(textureUrl)!; } return new Promise((resolve) => { const textureLoader = new THREE.TextureLoader(); textureLoader.load(textureUrl, (texture) => { texture.colorSpace = THREE.SRGBColorSpace; texture.flipY = false; texture.magFilter = THREE.NearestFilter; texture.minFilter = THREE.NearestFilter; this.textureCache.set(textureUrl, texture); resolve(texture); }); }); } private applyTexture(model: THREE.Object3D, texture: THREE.Texture): void { model.traverse(child => { if ((child as THREE.Mesh).isMesh) { const mesh = child as THREE.Mesh; if (mesh.name === "Cape") return; const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material]; materials.forEach((mat: THREE.Material) => { if (mat instanceof THREE.MeshStandardMaterial) { mat.map = texture; mat.metalness = 0; mat.color.set(0xffffff); mat.toneMapped = false; mat.roughness = 1; mat.needsUpdate = true; } }); } }); } private applyCapeTexture(model: THREE.Object3D, texture: THREE.Texture): void { model.traverse(child => { if ((child as THREE.Mesh).isMesh) { const mesh = child as THREE.Mesh; const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material]; materials.forEach((mat: THREE.Material) => { if (mat instanceof THREE.MeshStandardMaterial) { mat.map = texture; mat.metalness = 0; mat.color.set(0xffffff); mat.toneMapped = false; mat.roughness = 1; mat.side = THREE.DoubleSide; mat.needsUpdate = true; } }); } }); } private attachCapeToBody(): void { if (!this.bodyNode || !this.capeModel || this.capeAttached) return; if (this.capeModel.parent) { this.capeModel.parent.remove(this.capeModel); } this.capeModel.position.set(0, -1, -0.01); this.capeModel.rotation.set(0, -Math.PI / 2, 0); this.bodyNode.add(this.capeModel); this.capeAttached = true; } public async renderSkin(textureUrl: string, modelUrl: string, capeUrl?: string, capeModelUrl?: string): Promise { await this.setupModel(modelUrl, textureUrl, capeModelUrl, capeUrl); const headPart = this.currentModel!.getObjectByName('Head'); let lookAtTarget: [number, number, number]; if (headPart) { const headPosition = new THREE.Vector3(); headPart.getWorldPosition(headPosition); lookAtTarget = [headPosition.x, headPosition.y, headPosition.z]; } else { throw new Error("Failed to find 'Head' object in model.") } const frontCameraPos: [number, number, number] = [2, 1, -2.5]; const backCameraPos: [number, number, number] = [2, 1, 6.0]; const forwards = await this.renderView(frontCameraPos, lookAtTarget); const backwards = await this.renderView(backCameraPos, lookAtTarget); return { forwards, backwards }; } private async renderView(cameraPosition: [number, number, number], lookAtPosition: [number, number, number]): Promise { this.camera.position.set(...cameraPosition); this.camera.lookAt(...lookAtPosition); this.renderer.render(this.scene, this.camera); return new Promise((resolve, reject) => { this.renderer.domElement.toBlob((blob) => { if (blob) { const url = URL.createObjectURL(blob); resolve(url); } else { reject(new Error("Failed to create blob from canvas")); } }, 'image/png'); }); } private async setupModel(modelUrl: string, textureUrl: string, capeModelUrl?: string, capeUrl?: string): Promise { if (this.currentModel) { this.scene.remove(this.currentModel); } this.bodyNode = null; this.capeAttached = false; const [gltf, texture] = await Promise.all([ this.loadModel(modelUrl), this.loadTexture(textureUrl) ]); const model = gltf.scene.clone(); this.applyTexture(model, texture); model.traverse(node => { if (node.name === 'Body') { this.bodyNode = node; } }); const group = new THREE.Group(); group.add(model); group.position.set(0, -0.5, 1.95); group.scale.set(0.8, 0.8, 0.8); this.scene.add(group); this.currentModel = group; if (capeModelUrl && capeUrl) { const [capeGltf, capeTexture] = await Promise.all([ this.loadModel(capeModelUrl), this.loadTexture(capeUrl) ]); this.capeModel = capeGltf.scene.clone(); this.applyCapeTexture(this.capeModel, capeTexture); if (this.bodyNode && this.capeModel) { this.attachCapeToBody(); } } } public dispose(): void { Array.from(this.textureCache.values()).forEach(texture => { texture.dispose(); }); this.renderer.dispose(); this.textureCache.clear(); this.modelCache.clear(); } } function getModelUrlForVariant(variant: string): string { switch (variant) { case 'SLIM': return '/src/assets/models/slim_player.gltf'; case 'CLASSIC': case 'UNKNOWN': default: return '/src/assets/models/classic_player.gltf'; } } export const map = reactive(new Map()); const DEBUG_MODE = false; export async function generateSkinPreviews(skins: Skin[], capes: Cape[]): Promise { const renderer = new BatchSkinRenderer(); const capeModelUrl = '/src/assets/models/cape.gltf'; try { for (const skin of skins) { const key = `${skin.texture_key}+${skin.variant}+${skin.cape_id ?? 'no-cape'}` if (map.has(key)) { if (DEBUG_MODE) { const result = map.get(key)! URL.revokeObjectURL(result.forwards) URL.revokeObjectURL(result.backwards) map.delete(key) } else continue; } let variant = skin.variant; if (variant === 'UNKNOWN') { try { variant = await determineModelType(skin.texture); } catch (error) { console.error(`Failed to determine model type for skin ${key}:`, error); variant = 'CLASSIC'; } } const modelUrl = getModelUrlForVariant(variant); const cape: Cape | undefined = capes.find(_cape => _cape.id === skin.cape_id); const renderResult = await renderer.renderSkin( skin.texture, modelUrl, cape?.texture, capeModelUrl ); map.set(key, renderResult); } } finally { renderer.dispose(); } }