babylonjs-editor-cli 5.0.0

package/src/pack/scene.mts

@@ -0,0 +1,346 @@
+import { join, basename } from "node:path/posix";
+
+import fs from "fs-extra";
+
+import { readSceneDirectories } from "../tools/scene.mjs";
+
+import { compressFileToKtx } from "./assets/ktx.mjs";
+import { extractNodeMaterialTextures } from "./assets/material.mjs";
+import { getExtractedTextureOutputPath } from "./assets/texture.mjs";
+import { extractNodeParticleSystemSetTextures, extractParticleSystemTextures } from "./assets/particle-system.mjs";
+
+export interface ICreateBabylonSceneOptions {
+	sceneFile: string;
+	sceneName: string;
+	publicDir: string;
+	babylonjsEditorToolsVersion: string;
+	exportedAssets: string[];
+	optimize: boolean;
+	compressedTexturesEnabled: boolean;
+
+	config: any;
+	directories: Awaited<ReturnType<typeof readSceneDirectories>>;
+}
+
+export async function createBabylonScene(options: ICreateBabylonSceneOptions) {
+	const meshes: any[] = [];
+	const materials: any[] = [];
+	const transformNodes: any[] = [];
+	const morphTargetManagers: any[] = [];
+
+	// Meshes
+	await Promise.all(
+		options.directories.meshesFiles.map(async (file) => {
+			const data = await fs.readJSON(join(options.sceneFile, "meshes", file));
+			const mesh = data.meshes[0];
+
+			if (mesh.delayLoadingFile) {
+				mesh.delayLoadingFile = join(options.sceneName, basename(mesh.delayLoadingFile));
+			}
+
+			if (mesh.metadata?.parentId) {
+				mesh.parentId = mesh.metadata.parentId;
+			}
+
+			mesh.instances?.forEach((instance) => {
+				if (instance.metadata?.parentId) {
+					instance.parentId = instance.metadata.parentId;
+				}
+			});
+
+			if (data.basePoseMatrix) {
+				mesh.basePoseMatrix = data.basePoseMatrix;
+			}
+
+			meshes.push(mesh);
+
+			data.materials?.forEach((material) => {
+				const existingMaterial = materials.find((m) => m.id === material.id);
+				if (!existingMaterial) {
+					materials.push(material);
+				}
+			});
+		})
+	);
+
+	// Morph targets
+	await Promise.all(
+		options.directories.morphTargetManagerFiles.map(async (file) => {
+			const data = await fs.readJSON(join(options.sceneFile, "morphTargetManagers", file));
+
+			if (options.babylonjsEditorToolsVersion >= "5.2.6") {
+				data.targets.forEach((target) => {
+					if (target.delayLoadingFile) {
+						target.delayLoadingFile = join(options.sceneName, "morphTargets", basename(target.delayLoadingFile));
+					}
+				});
+			} else {
+				await Promise.all(
+					data.targets.map(async (target) => {
+						const binaryFileData = join(options.sceneFile, "morphTargets", basename(target.delayLoadingFile));
+						const buffer = (await fs.readFile(binaryFileData)).buffer;
+
+						if (target.positionsCount) {
+							target.positions = Array.prototype.slice.call(new Float32Array(buffer, target.positionsOffset, target.positionsCount));
+						}
+
+						if (target.normalsCount) {
+							target.normals = Array.prototype.slice.call(new Float32Array(buffer, target.normalsOffset, target.normalsCount));
+						}
+
+						if (target.tangentsCount) {
+							target.tangents = Array.prototype.slice.call(new Float32Array(buffer, target.tangentsOffset, target.tangentsCount));
+						}
+
+						if (target.uvsCount) {
+							target.uvs = Array.prototype.slice.call(new Float32Array(buffer, target.uvsOffset, target.uvsCount));
+						}
+
+						if (target.uv2sCount) {
+							target.uv2s = Array.prototype.slice.call(new Float32Array(buffer, target.uv2sOffset, target.uv2sCount));
+						}
+
+						delete target.delayLoadingFile;
+
+						delete target.positionsCount;
+						delete target.normalsCount;
+						delete target.tangentsCount;
+						delete target.uvsCount;
+						delete target.uv2sCount;
+
+						delete target.positionsOffset;
+						delete target.normalsOffset;
+						delete target.tangentsOffset;
+						delete target.uvsOffset;
+						delete target.uv2sOffset;
+					})
+				);
+			}
+
+			morphTargetManagers.push(data);
+		})
+	);
+
+	// Transform nodes
+	await Promise.all(
+		options.directories.nodesFiles.map(async (file) => {
+			const data = await fs.readJSON(join(options.sceneFile, "nodes", file));
+			if (data.metadata?.parentId) {
+				data.parentId = data.metadata.parentId;
+			}
+
+			transformNodes.push(data);
+		})
+	);
+
+	await Promise.all(
+		options.directories.spriteManagerFiles.map(async (file) => {
+			const data = await fs.readJSON(join(options.sceneFile, "sprite-managers", file));
+			if (data.metadata?.parentId) {
+				data.parentId = data.metadata.parentId;
+			}
+
+			transformNodes.push(data);
+		})
+	);
+
+	await Promise.all(
+		options.directories.spriteMapFiles.map(async (file) => {
+			const data = await fs.readJSON(join(options.sceneFile, "sprite-maps", file));
+			if (data.metadata?.parentId) {
+				data.parentId = data.metadata.parentId;
+			}
+
+			transformNodes.push(data);
+		})
+	);
+
+	// Extract materials
+	const extractedTexturesOutputPath = getExtractedTextureOutputPath(options.publicDir);
+	await fs.ensureDir(extractedTexturesOutputPath);
+
+	await Promise.all(
+		materials.map(async (material) => {
+			if (material.customType === "BABYLON.NodeMaterial") {
+				const result = await extractNodeMaterialTextures(material, {
+					extractedTexturesOutputPath,
+				});
+
+				await Promise.all(
+					result.map(async (relativePath) => {
+						const finalPath = join(options.publicDir, relativePath);
+						options.exportedAssets.push(finalPath);
+
+						if (options.optimize && options.compressedTexturesEnabled) {
+							await compressFileToKtx(finalPath, {
+								...options,
+								force: false,
+								exportedAssets: options.exportedAssets,
+							});
+						}
+					})
+				);
+			}
+		})
+	);
+
+	// Particle systems
+	const particleSystems = await Promise.all(
+		options.directories.particleSystemFiles.map(async (file) => {
+			const data = await fs.readJSON(join(options.sceneFile, "particleSystems", file));
+
+			const result = await extractParticleSystemTextures(data, {
+				extractedTexturesOutputPath,
+			});
+
+			if (result) {
+				const finalPath = join(options.publicDir, result);
+				options.exportedAssets.push(finalPath);
+
+				if (options.optimize && options.compressedTexturesEnabled) {
+					await compressFileToKtx(finalPath, {
+						...options,
+						force: false,
+						exportedAssets: options.exportedAssets,
+					});
+				}
+			}
+
+			return data;
+		})
+	);
+
+	// Node particle system sets
+	await Promise.all(
+		options.directories.nodeParticleSystemSetFiles.map(async (file) => {
+			const data = await fs.readJSON(join(options.sceneFile, "nodeParticleSystemSets", file));
+
+			if (data.metadata?.parentId) {
+				data.parentId = data.metadata.parentId;
+			}
+
+			if (data.nodeParticleSystemSet) {
+				const result = await extractNodeParticleSystemSetTextures(data.nodeParticleSystemSet, {
+					extractedTexturesOutputPath,
+				});
+
+				await Promise.all(
+					result.map(async (relativePath) => {
+						const finalPath = join(options.publicDir, relativePath);
+						options.exportedAssets.push(finalPath);
+
+						if (options.optimize && options.compressedTexturesEnabled) {
+							await compressFileToKtx(finalPath, {
+								...options,
+								force: false,
+								exportedAssets: options.exportedAssets,
+							});
+						}
+					})
+				);
+			}
+
+			meshes.push(data);
+		})
+	);
+
+	const scene = {
+		autoClear: true,
+		physicsEnabled: true,
+		collisionsEnabled: true,
+		useRightHandedSystem: false,
+		physicsEngine: "HavokPlugin",
+		iblIntensity: 1,
+
+		clearColor: options.config.clearColor,
+		ambientColor: options.config.ambientColor,
+
+		geometries: {
+			boxes: [],
+			spheres: [],
+			cylinders: [],
+			toruses: [],
+			grounds: [],
+			planes: [],
+			torusKnots: [],
+			vertexData: [],
+		},
+
+		gravity: options.config.gravity ?? [0, -9.81, 0],
+
+		fogColor: options.config.fog.fogColor,
+		fogStart: options.config.fog.fogStart,
+		fogEnd: options.config.fog.fogEnd,
+		fogDensity: options.config.fog.fogDensity,
+		fogMode: options.config.fog.fogMode,
+
+		physicsGravity: options.config.physics.gravity,
+
+		environmentIntensity: options.config.environment.environmentIntensity,
+		environmentTexture: options.config.environment.environmentTexture,
+
+		metadata: options.config.metadata,
+
+		animations: options.config.animations,
+
+		postProcesses: [],
+		multiMaterials: [],
+		spriteManagers: [],
+		reflectionProbes: [],
+
+		meshes,
+		materials,
+		morphTargetManagers,
+		transformNodes,
+		particleSystems,
+
+		animationGroups: await Promise.all(
+			options.directories.animationGroupFiles.map(async (file) => {
+				return fs.readJSON(join(options.sceneFile, "animationGroups", file));
+			})
+		),
+		skeletons: await Promise.all(
+			options.directories.skeletonFiles.map(async (file) => {
+				return fs.readJSON(join(options.sceneFile, "skeletons", file));
+			})
+		),
+		cameras: await Promise.all(
+			options.directories.cameraFiles.map(async (file) => {
+				const data = await fs.readJSON(join(options.sceneFile, "cameras", file));
+				if (data.metadata?.parentId) {
+					data.parentId = data.metadata.parentId;
+				}
+
+				return data;
+			})
+		),
+		lights: await Promise.all(
+			options.directories.lightsFiles.map(async (file) => {
+				const data = await fs.readJSON(join(options.sceneFile, "lights", file));
+				if (data.metadata?.parentId) {
+					data.parentId = data.metadata.parentId;
+				}
+
+				return data;
+			})
+		),
+		shadowGenerators: await Promise.all(
+			options.directories.shadowGeneratorFiles.map(async (file) => {
+				return fs.readJSON(join(options.sceneFile, "shadowGenerators", file));
+			})
+		),
+		sounds: await Promise.all(
+			options.directories.soundFiles.map(async (file) => {
+				return fs.readJSON(join(options.sceneFile, "sounds", file));
+			})
+		),
+	};
+
+	const destination = join(options.publicDir, `${options.sceneName}.babylon`);
+	await fs.writeJSON(destination, scene, {
+		encoding: "utf-8",
+		// spaces: "\t", // Useful for debug
+	});
+
+	options.exportedAssets.push(destination);
+}

package/src/tools/extract.mts

@@ -0,0 +1,74 @@
+import { join } from "node:path/posix";
+
+import fs from "fs-extra";
+import sharp from "sharp";
+
+import { executeSimpleWorker } from "./worker.mjs";
+
+export interface IExtractTextureAssetFromDataStringOptions {
+	extractedTexturesOutputPath: string;
+}
+
+export async function extractTextureAssetFromDataString(dataString: string, options: IExtractTextureAssetFromDataStringOptions) {
+	const split = dataString.split(",");
+	const header = split[0];
+
+	const headerSplit = header.split(";");
+	const dataType = headerSplit[1];
+
+	const byteString = split[1];
+
+	if (dataType === "base64") {
+		const buffer = Buffer.from(byteString, "base64");
+		const image = sharp(buffer);
+
+		const [metadata, hash] = await Promise.all([image.metadata(), executeSimpleWorker("workers/md5.mjs", buffer)]);
+
+		let filename: string;
+		switch (metadata.format) {
+			case "png":
+				filename = `${hash}.png`;
+				break;
+
+			case "jpg":
+			case "jpeg":
+				filename = `${hash}.jpg`;
+				break;
+
+			default:
+				console.error(`Unsupported embedded texture format while extracting texture: ${metadata.format}`);
+				return null;
+		}
+
+		const outputFilename = join(options.extractedTexturesOutputPath, filename);
+		if (!(await fs.pathExists(outputFilename))) {
+			await fs.writeFile(outputFilename, buffer);
+		}
+
+		return join("assets", "editor-generated_extracted-textures", filename).replace(/\\/g, "/");
+	}
+
+	return null;
+}
+
+export interface IExtractTextureAssetFromUrlOptions {
+	extractedTexturesOutputPath: string;
+}
+
+export async function extractTextureAssetFromUrl(url: string, options: IExtractTextureAssetFromUrlOptions) {
+	try {
+		const response = await fetch(url);
+		const arrayBuffer = await response.arrayBuffer();
+
+		const base64 = Buffer.from(arrayBuffer).toString("base64");
+		const dataString = `data:${response.headers.get("content-type") ?? "image/unknown"};base64,${base64}`;
+
+		return extractTextureAssetFromDataString(dataString, {
+			...options,
+		});
+	} catch (e) {
+		console.error(`Failed to extract texture from url "${url}": ${e.message}`);
+	}
+
+	return null;
+}

package/src/tools/fs.mts

@@ -0,0 +1,11 @@
+import { glob } from "glob";
+
+export async function normalizedGlob(...args: Parameters<typeof glob>) {
+	const result = await glob(...args);
+
+	result.forEach((_: unknown, index: number) => {
+		result[index] = result[index].toString().replace(/\\/g, "/");
+	});
+
+	return result as string[];
+}

package/src/tools/ktx.mts

@@ -0,0 +1,44 @@
+import os from "node:os";
+import { normalizedGlob } from "./fs.mjs";
+import { join } from "node:path/posix";
+
+export let pvrTexToolAbsolutePath: string | undefined;
+
+export function setPVRTexToolAbsolutePath(absolutePath: string) {
+	pvrTexToolAbsolutePath = absolutePath;
+}
+
+export async function locatePVRTexTool() {
+	if (process.env.PVRTexToolCLI) {
+		return (pvrTexToolAbsolutePath = process.env.PVRTexToolCLI);
+	}
+
+	const platform = os.platform();
+
+	let absolutePathToCheck: string | null = null;
+	switch (platform) {
+		case "darwin":
+			absolutePathToCheck = "/Applications/Imagination/";
+		case "win32":
+			absolutePathToCheck = "C:/Imagination Technologies/";
+		default:
+			break;
+	}
+
+	if (!absolutePathToCheck) {
+		return undefined;
+	}
+
+	const files = await normalizedGlob(join(absolutePathToCheck, "**"), {
+		nodir: true,
+	});
+
+	switch (platform) {
+		case "darwin":
+			return (pvrTexToolAbsolutePath = files.find((file) => file.endsWith("macOS/PVRTexToolCLI")));
+		case "win32":
+			return (pvrTexToolAbsolutePath = files.find((file) => file.endsWith("Windows_x86_64/PVRTexToolCLI.exe")));
+	}
+
+	return undefined;
+}

package/src/tools/process.mts

@@ -0,0 +1,21 @@
+import { exec } from "node:child_process";
+
+import chalk from "chalk";
+
+/**
+ * Executes the given command asynchronously using `child_process`
+ * @param command defines the command to execute.
+ */
+export function executeAsync(command: string): Promise<void> {
+	return new Promise<void>((resolve, reject) => {
+		exec(command, (error, stdout, stderr) => {
+			if (error) {
+				console.error(chalk.red(command), chalk.red(stderr));
+				reject(error);
+			} else {
+				console.log(chalk.gray(command), chalk.gray(stdout));
+				resolve();
+			}
+		});
+	});
+}

package/src/tools/scalar.mts

@@ -0,0 +1,28 @@
+/**
+ * Returns the power of two sizes until the given limit.
+ * @param limit The limit size.
+ * @param from The starting size. Default is 1.
+ * @returns An array of power of two sizes.
+ */
+export function getPowerOfTwoSizesUntil(limit: number = 4096, from?: number): number[] {
+	let size = from ?? 1;
+
+	const result: number[] = [];
+
+	while (size <= limit) {
+		result.push(size);
+		size <<= 1;
+	}
+
+	return result;
+}
+
+export function getPowerOfTwoUntil(limit: number): number {
+	let size = 1;
+
+	while (size <= limit) {
+		size <<= 1;
+	}
+
+	return size >> 1;
+}

package/src/tools/scene.mts

@@ -0,0 +1,90 @@
+import { join } from "node:path/posix";
+import { readdir } from "node:fs/promises";
+
+import fs from "fs-extra";
+
+export async function ensureSceneDirectories(scenePath: string) {
+	await Promise.all([
+		fs.ensureDir(join(scenePath, "nodes")),
+		fs.ensureDir(join(scenePath, "meshes")),
+		fs.ensureDir(join(scenePath, "lods")),
+		fs.ensureDir(join(scenePath, "lights")),
+		fs.ensureDir(join(scenePath, "cameras")),
+		fs.ensureDir(join(scenePath, "geometries")),
+		fs.ensureDir(join(scenePath, "skeletons")),
+		fs.ensureDir(join(scenePath, "shadowGenerators")),
+		fs.ensureDir(join(scenePath, "sceneLinks")),
+		fs.ensureDir(join(scenePath, "gui")),
+		fs.ensureDir(join(scenePath, "sounds")),
+		fs.ensureDir(join(scenePath, "particleSystems")),
+		fs.ensureDir(join(scenePath, "morphTargetManagers")),
+		fs.ensureDir(join(scenePath, "morphTargets")),
+		fs.ensureDir(join(scenePath, "animationGroups")),
+		fs.ensureDir(join(scenePath, "sprite-maps")),
+		fs.ensureDir(join(scenePath, "sprite-managers")),
+		fs.ensureDir(join(scenePath, "nodeParticleSystemSets")),
+	]);
+}
+
+export async function readSceneDirectories(scenePath: string) {
+	const [
+		nodesFiles,
+		meshesFiles,
+		lodsFiles,
+		lightsFiles,
+		cameraFiles,
+		skeletonFiles,
+		shadowGeneratorFiles,
+		sceneLinkFiles,
+		guiFiles,
+		soundFiles,
+		particleSystemFiles,
+		morphTargetManagerFiles,
+		morphTargetFiles,
+		animationGroupFiles,
+		spriteMapFiles,
+		spriteManagerFiles,
+		geometryFiles,
+		nodeParticleSystemSetFiles,
+	] = await Promise.all([
+		readdir(join(scenePath, "nodes")),
+		readdir(join(scenePath, "meshes")),
+		readdir(join(scenePath, "lods")),
+		readdir(join(scenePath, "lights")),
+		readdir(join(scenePath, "cameras")),
+		readdir(join(scenePath, "skeletons")),
+		readdir(join(scenePath, "shadowGenerators")),
+		readdir(join(scenePath, "sceneLinks")),
+		readdir(join(scenePath, "gui")),
+		readdir(join(scenePath, "sounds")),
+		readdir(join(scenePath, "particleSystems")),
+		readdir(join(scenePath, "morphTargetManagers")),
+		readdir(join(scenePath, "morphTargets")),
+		readdir(join(scenePath, "animationGroups")),
+		readdir(join(scenePath, "sprite-maps")),
+		readdir(join(scenePath, "sprite-managers")),
+		readdir(join(scenePath, "geometries")),
+		readdir(join(scenePath, "nodeParticleSystemSets")),
+	]);
+
+	return {
+		nodesFiles,
+		meshesFiles,
+		lodsFiles,
+		lightsFiles,
+		cameraFiles,
+		skeletonFiles,
+		shadowGeneratorFiles,
+		sceneLinkFiles,
+		guiFiles,
+		soundFiles,
+		particleSystemFiles,
+		morphTargetManagerFiles,
+		morphTargetFiles,
+		animationGroupFiles,
+		spriteMapFiles,
+		spriteManagerFiles,
+		geometryFiles,
+		nodeParticleSystemSetFiles,
+	};
+}

package/src/tools/worker.mts

@@ -0,0 +1,39 @@
+import { join } from "node:path/posix";
+import { Worker } from "node:worker_threads";
+
+/**
+ * Creates a new worker and returns its reference.
+ * @param path defines the relative path to the worker entry point relative to THIS file.
+ */
+export function loadWorker(path: string, workerData: WorkerMessageData) {
+	path = join(import.meta.dirname.replace(/\\/g, "/"), path);
+	return new Worker(path, {
+		workerData,
+	});
+}
+
+export type WorkerMessageData = { id?: string } & Record<string, any>;
+
+/**
+ * Creates a new worker and returns the result computed by the worker.
+ * Posts the given message data to the worker and waits until the worker posts a message back.
+ * @param path defines the relative path to the worker according to THIS file. Typically "workers/myWorker.js".
+ * @param data defines the data object posted to the worker once it has been initialized.
+ * @param transfer defines the optional transferable objects to pass to the worker.
+ * @returns a promise that resolves with the data posted by the worker.
+ */
+export async function executeSimpleWorker<T>(pathOrWorker: string, data: WorkerMessageData) {
+	const worker = loadWorker(pathOrWorker, data);
+
+	return new Promise<T>((resolve) => {
+		worker.on("message", (result) => {
+			if (data.id && result.id !== data.id) {
+				return;
+			} else if (!data.id) {
+				worker.terminate();
+			}
+
+			resolve(result);
+		});
+	});
+}

package/src/tools/workers/md5.mts

@@ -0,0 +1,13 @@
+import { workerData, parentPort } from "node:worker_threads";
+
+import md5 from "md5";
+import fs from "fs-extra";
+
+let content = workerData;
+
+if (typeof workerData === "string") {
+	content = await fs.readFile(workerData);
+}
+
+const hash = md5(content);
+parentPort?.postMessage(hash);

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleResolution": "node",
+		"sourceMap": true,
+		"declaration": true,
+		"outDir": "./build",
+		"declarationDir": "./declaration",
+		"strictNullChecks": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"allowSyntheticDefaultImports": true,
+		"resolveJsonModule": true,
+		"esModuleInterop": true,
+		"downlevelIteration": true,
+		"experimentalDecorators": true,
+		"skipLibCheck": true
+	},
+	"exclude": ["node_modules", "build", "declaration", "vitest.config.ts"]
+}