babylonjs-editor-cli 5.0.0 → 5.0.2

package/src/pack/geometry.mts

@@ -1,38 +0,0 @@
-import { join } from "node:path/posix";
-
-import fs from "fs-extra";
-
-import { readSceneDirectories } from "../tools/scene.mjs";
-
-export interface ICreateGeometryFilesOptions {
-	sceneFile: string;
-	sceneName: string;
-	publicDir: string;
-	exportedAssets: string[];
-	babylonjsEditorToolsVersion: string;
-
-	directories: Awaited<ReturnType<typeof readSceneDirectories>>;
-}
-
-export async function createGeometryFiles(options: ICreateGeometryFilesOptions) {
-	await fs.ensureDir(join(options.publicDir, options.sceneName));
-	await fs.ensureDir(join(options.publicDir, options.sceneName, "morphTargets"));
-
-	await Promise.all(
-		options.directories.geometryFiles.map(async (file) => {
-			const destination = join(options.publicDir, options.sceneName, file);
-			await fs.copyFile(join(options.sceneFile, "geometries", file), destination);
-			options.exportedAssets.push(destination);
-		})
-	);
-
-	if (options.babylonjsEditorToolsVersion >= "5.2.6") {
-		await Promise.all(
-			options.directories.morphTargetFiles.map(async (file) => {
-				const destination = join(options.publicDir, options.sceneName, "morphTargets", file);
-				await fs.copyFile(join(options.sceneFile, "morphTargets", file), destination);
-				options.exportedAssets.push(destination);
-			})
-		);
-	}
-}

package/src/pack/pack.mts

@@ -1,159 +0,0 @@
-import fs from "fs-extra";
-import { resolve } from "node:path";
-import { basename, extname, join } from "node:path/posix";
-
-import ora from "ora";
-import cliSpinners from "cli-spinners";
-
-import { normalizedGlob } from "../tools/fs.mjs";
-import { locatePVRTexTool, setPVRTexToolAbsolutePath } from "../tools/ktx.mjs";
-import { ensureSceneDirectories, readSceneDirectories } from "../tools/scene.mjs";
-
-import { createAssets } from "./assets/assets.mjs";
-import { createBabylonScene } from "./scene.mjs";
-import { createGeometryFiles } from "./geometry.mjs";
-
-export interface IPackOptions {
-	optimize: boolean;
-	pvrTexToolAbsolutePath?: string;
-}
-
-export async function pack(projectDir: string, options: IPackOptions) {
-	const cwd = process.cwd();
-
-	if (projectDir !== cwd) {
-		projectDir = resolve(cwd, projectDir);
-	}
-
-	projectDir = projectDir.replace(/\\/g, "/");
-
-	// Load project configuration
-	const projectFiles = await fs.readdir(projectDir);
-	const projectConfigurationFile = projectFiles.find((file) => extname(file).toLowerCase() === ".bjseditor");
-
-	let projectConfiguration = {
-		compressedTexturesEnabled: false,
-	};
-
-	if (projectConfigurationFile) {
-		projectConfiguration = await fs.readJSON(join(projectDir, projectConfigurationFile));
-	}
-
-	// Locate PVRTexToolCLI
-	if (projectConfiguration.compressedTexturesEnabled) {
-		if (options.pvrTexToolAbsolutePath) {
-			setPVRTexToolAbsolutePath(options.pvrTexToolAbsolutePath);
-		} else {
-			await locatePVRTexTool();
-		}
-	}
-
-	const assetsDirectory = join(projectDir, "assets");
-	const publicDir = join(projectDir, "public/scene");
-
-	await fs.ensureDir(publicDir);
-
-	const baseAssetsDir = join(projectDir, "assets");
-	const outputAssetsDir = join(publicDir, "assets");
-
-	await fs.ensureDir(outputAssetsDir);
-
-	const exportedAssets: string[] = [];
-
-	let cache: Record<string, string> = {};
-	try {
-		cache = await fs.readJSON(join(projectDir, "assets/.export-cache.json"));
-	} catch (e) {
-		// Catch silently.
-	}
-
-	// Pack assets
-	const assetsLog = ora(`Packing assets...`);
-	assetsLog.spinner = cliSpinners.dots14;
-	assetsLog.start();
-
-	await createAssets({
-		...options,
-		...projectConfiguration,
-		cache,
-		projectDir,
-		publicDir,
-		baseAssetsDir,
-		outputAssetsDir,
-		exportedAssets,
-	});
-
-	assetsLog.succeed(`Packed assets`);
-
-	// Get babylonjs-editor-tools version
-	let babylonjsEditorToolsVersion = "5.0.0";
-	try {
-		const pkg = await fs.readJSON(join(projectDir, "node_modules/babylonjs-editor-tools/package.json"));
-		babylonjsEditorToolsVersion = pkg.version;
-	} catch (e) {
-		// Catch silently.
-	}
-
-	// Pack scenes
-	const sceneFiles = await normalizedGlob(`${assetsDirectory}/**/*`, {
-		nodir: false,
-		ignore: {
-			ignored: (p) => !p.isDirectory() || extname(p.name).toLocaleLowerCase() !== ".scene",
-		},
-	});
-
-	for (const sceneFile of sceneFiles) {
-		const sceneFilename = basename(sceneFile);
-		const sceneName = basename(sceneFile, extname(sceneFile));
-
-		const sceneLog = ora(`Packing ${sceneFilename}...`);
-		sceneLog.spinner = cliSpinners.dots14;
-		sceneLog.start();
-
-		await ensureSceneDirectories(sceneFile);
-
-		const directories = await readSceneDirectories(sceneFile);
-		const config = await fs.readJSON(join(sceneFile, "config.json"));
-
-		await createBabylonScene({
-			...options,
-			...projectConfiguration,
-			config,
-			directories,
-			publicDir,
-			sceneFile,
-			sceneName,
-			exportedAssets,
-			babylonjsEditorToolsVersion,
-		});
-
-		// Copy geometry files
-		await createGeometryFiles({
-			directories,
-			publicDir,
-			sceneFile,
-			sceneName,
-			exportedAssets,
-			babylonjsEditorToolsVersion,
-		});
-
-		sceneLog.succeed(`Packed ${sceneFilename}`);
-	}
-
-	// Save cache
-	await fs.writeJSON(join(projectDir, "assets/.export-cache.json"), cache, {
-		encoding: "utf-8",
-		spaces: "\t",
-	});
-
-	// Clean
-	const publicFiles = await normalizedGlob(join(publicDir, "**/*"), {
-		nodir: true,
-	});
-
-	publicFiles.forEach((file) => {
-		if (!exportedAssets.includes(file.toString())) {
-			fs.remove(file);
-		}
-	});
-}

package/src/pack/scene.mts

@@ -1,346 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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();
-			}
-		});
-	});
-}