babylonjs-editor-cli 5.0.0

package/src/pack/assets/material.mts

@@ -0,0 +1,86 @@
+import { join } from "node:path/posix";
+
+import fs from "fs-extra";
+
+import { extractTextureAssetFromDataString, extractTextureAssetFromUrl } from "../../tools/extract.mjs";
+
+import { compressFileToKtx } from "./ktx.mjs";
+import { getExtractedTextureOutputPath } from "./texture.mjs";
+
+export interface IProcessExportedMaterialOptions {
+	force: boolean;
+	publicDir: string;
+	exportedAssets: string[];
+	optimize: boolean;
+}
+
+export async function processExportedMaterial(absolutePath: string, options: IProcessExportedMaterialOptions) {
+	const materialData = await fs.readJSON(absolutePath);
+	if (materialData.customType !== "BABYLON.NodeMaterial") {
+		return;
+	}
+
+	const extractedTexturesOutputPath = getExtractedTextureOutputPath(options.publicDir);
+	await fs.ensureDir(extractedTexturesOutputPath);
+
+	const relativePaths = await extractNodeMaterialTextures(materialData, {
+		extractedTexturesOutputPath,
+	});
+
+	await fs.writeJSON(absolutePath, materialData, {
+		encoding: "utf-8",
+	});
+
+	await Promise.all(
+		relativePaths.map(async (relativePath) => {
+			const finalPath = join(options.publicDir, relativePath);
+
+			options.exportedAssets.push(finalPath);
+
+			await compressFileToKtx(finalPath, {
+				force: options.force,
+				exportedAssets: options.exportedAssets,
+			});
+		})
+	);
+}
+
+export interface IExtractNodeMaterialTexturesOptions {
+	extractedTexturesOutputPath: string;
+}
+
+export async function extractNodeMaterialTextures(materialData: any, options: IExtractNodeMaterialTexturesOptions) {
+	const blocks = materialData.blocks.filter(
+		(block: any) => (block.customType === "BABYLON.TextureBlock" || block.customType === "BABYLON.ImageSourceBlock") && block.texture?.name
+	);
+
+	const relativePaths: string[] = [];
+
+	await Promise.all(
+		blocks.map(async (block: any) => {
+			if (block.texture?.name?.startsWith("http://") || block.texture.name.startsWith("https://")) {
+				const relativePath = await extractTextureAssetFromUrl(block.texture.name, {
+					...options,
+				});
+
+				if (relativePath) {
+					relativePaths.push(relativePath);
+					block.texture.name = block.texture.url = relativePath;
+				}
+			}
+
+			if (block.texture.name?.startsWith("data:")) {
+				const relativePath = await extractTextureAssetFromDataString(block.texture.name, {
+					...options,
+				});
+
+				if (relativePath) {
+					relativePaths.push(relativePath);
+					block.texture.name = block.texture.url = relativePath;
+				}
+			}
+		})
+	);
+
+	return relativePaths;
+}

package/src/pack/assets/particle-system.mts

@@ -0,0 +1,109 @@
+import { join } from "node:path/posix";
+
+import fs from "fs-extra";
+
+import { extractTextureAssetFromDataString, extractTextureAssetFromUrl } from "../../tools/extract.mjs";
+
+import { compressFileToKtx } from "./ktx.mjs";
+import { getExtractedTextureOutputPath } from "./texture.mjs";
+
+export interface IProcessExportedMaterialOptions {
+	force: boolean;
+	publicDir: string;
+	exportedAssets: string[];
+	optimize: boolean;
+}
+
+export async function processExportedNodeParticleSystemSet(absolutePath: string, options: IProcessExportedMaterialOptions) {
+	const particleSystemData = await fs.readJSON(absolutePath);
+	if (particleSystemData.customType !== "BABYLON.NodeParticleSystemSet") {
+		return;
+	}
+
+	const extractedTexturesOutputPath = getExtractedTextureOutputPath(options.publicDir);
+	await fs.ensureDir(extractedTexturesOutputPath);
+
+	const relativePaths = await extractNodeParticleSystemSetTextures(particleSystemData, {
+		extractedTexturesOutputPath,
+	});
+
+	await fs.writeJSON(absolutePath, particleSystemData, {
+		encoding: "utf-8",
+	});
+
+	await Promise.all(
+		relativePaths.map(async (relativePath) => {
+			const finalPath = join(options.publicDir, relativePath);
+
+			options.exportedAssets.push(finalPath);
+
+			if (options.optimize) {
+				await compressFileToKtx(finalPath, {
+					force: options.force,
+					exportedAssets: options.exportedAssets,
+				});
+			}
+		})
+	);
+}
+
+export interface IExtractParticleSystemTexturesOptions {
+	extractedTexturesOutputPath: string;
+}
+
+export async function extractParticleSystemTextures(particleSystemData: any, options: IExtractParticleSystemTexturesOptions) {
+	let relativePath: string | null = null;
+
+	if (particleSystemData.texture?.name.startsWith("http://") || particleSystemData.texture?.name.startsWith("https://")) {
+		relativePath = await extractTextureAssetFromUrl(particleSystemData.texture.name, {
+			...options,
+		});
+	} else if (particleSystemData.texture?.name.startsWith("data:")) {
+		relativePath = await extractTextureAssetFromDataString(particleSystemData.texture.name, {
+			...options,
+		});
+	}
+
+	if (relativePath) {
+		particleSystemData.texture.name = relativePath;
+		particleSystemData.texture.url = particleSystemData.texture.name;
+	}
+
+	return relativePath;
+}
+
+export async function extractNodeParticleSystemSetTextures(particleSystemData: any, options: IExtractParticleSystemTexturesOptions) {
+	const blocks = particleSystemData.blocks.filter((block) => block.customType === "BABYLON.ParticleTextureSourceBlock");
+
+	const relativePaths: string[] = [];
+
+	await Promise.all(
+		blocks.map(async (block: any) => {
+			if (block.url?.startsWith("http://") || block.url?.startsWith("https://")) {
+				const relativePath = await extractTextureAssetFromUrl(block.url, {
+					...options,
+				});
+
+				if (relativePath) {
+					relativePaths.push(relativePath);
+					block.url = `/scene/${relativePath}`;
+				}
+			}
+
+			if (block.textureDataUrl?.startsWith("data:")) {
+				const relativePath = await extractTextureAssetFromDataString(block.textureDataUrl, {
+					...options,
+				});
+
+				if (relativePath) {
+					relativePaths.push(relativePath);
+					delete block.textureDataUrl;
+					block.url = `/scene/${relativePath}`;
+					block.serializedCachedData = false;
+				}
+			}
+		})
+	);
+
+	return relativePaths;
+}

package/src/pack/assets/process.mts

@@ -0,0 +1,102 @@
+import { basename, extname, join } from "node:path/posix";
+
+import fs from "fs-extra";
+
+import { compressFileToKtx } from "./ktx.mjs";
+import { ICreateAssetsOptions } from "./assets.mjs";
+import { processExportedTexture } from "./texture.mjs";
+import { processExportedMaterial } from "./material.mjs";
+import { processExportedNodeParticleSystemSet } from "./particle-system.mjs";
+
+const supportedImagesExtensions: string[] = [".jpg", ".jpeg", ".webp", ".png", ".bmp"];
+const supportedCubeTexturesExtensions: string[] = [".env", ".dds"];
+const supportedAudioExtensions: string[] = [".mp3", ".wav", ".wave", ".ogg"];
+const supportedJsonExtensions: string[] = [".material", ".gui", ".cinematic", ".npss", ".json"];
+const supportedMiscExtensions: string[] = [".3dl", ".exr", ".hdr"];
+
+const supportedExtensions: string[] = [
+	...supportedImagesExtensions,
+	...supportedCubeTexturesExtensions,
+	...supportedAudioExtensions,
+	...supportedJsonExtensions,
+	...supportedMiscExtensions,
+];
+
+export interface IProcessAssetFileOptions extends ICreateAssetsOptions {
+	outputAssetsDir: string;
+	exportedAssets: string[];
+	optimize: boolean;
+	cache: Record<string, string>;
+	compressedTexturesEnabled: boolean;
+}
+
+export async function processAssetFile(file: string, options: IProcessAssetFileOptions) {
+	const isNavMesh = file.includes(".navmesh");
+	const extension = extname(file).toLocaleLowerCase();
+
+	if (!isNavMesh && !supportedExtensions.includes(extension)) {
+		return;
+	}
+
+	if (basename(file).startsWith("editor_preview")) {
+		return;
+	}
+
+	const relativePath = file.replace(join(options.projectDir, "/"), "");
+	const split = relativePath.split("/");
+
+	let path = "";
+	for (let i = 0; i < split.length - 1; ++i) {
+		try {
+			await fs.ensureDir(join(options.publicDir, path, split[i]));
+		} catch (e) {
+			// Catch silently.
+		}
+
+		path = join(path, split[i]);
+	}
+
+	let isNewFile = false;
+
+	const fileStat = await fs.stat(file);
+	const hash = fileStat.mtimeMs.toString();
+
+	isNewFile = !options.cache[relativePath] || options.cache[relativePath] !== hash;
+
+	options.cache[relativePath] = hash;
+
+	const finalPath = join(options.publicDir, relativePath);
+	const finalPathExists = await fs.pathExists(finalPath);
+
+	if (isNewFile || !finalPathExists) {
+		await fs.copyFile(file, finalPath);
+	}
+
+	options.exportedAssets.push(finalPath);
+
+	if (options.optimize && options.compressedTexturesEnabled) {
+		await compressFileToKtx(finalPath, {
+			force: isNewFile,
+			exportedAssets: options.exportedAssets,
+		});
+	}
+
+	if (options.optimize) {
+		if (supportedImagesExtensions.includes(extension)) {
+			await processExportedTexture(finalPath, {
+				...options,
+				force: isNewFile,
+			});
+		} else if (extension === ".material") {
+			await processExportedMaterial(finalPath, {
+				...options,
+				force: isNewFile,
+			});
+		} else if (extension === ".npss") {
+			await processExportedNodeParticleSystemSet(finalPath, {
+				...options,
+				force: isNewFile,
+			});
+		}
+	}
+}

package/src/pack/assets/texture.mts

@@ -0,0 +1,91 @@
+import { basename, dirname, extname, join } from "node:path/posix";
+
+import sharp from "sharp";
+import fs from "fs-extra";
+
+import { getPowerOfTwoUntil } from "../../tools/scalar.mjs";
+
+import { compressFileToKtx } from "./ktx.mjs";
+
+export function getExtractedTextureOutputPath(publicDir: string) {
+	return join(publicDir, "assets", "editor-generated_extracted-textures");
+}
+
+export interface IComputeExportedTextureOptions {
+	force: boolean;
+	exportedAssets: string[];
+	compressedTexturesEnabled: boolean;
+}
+
+export async function processExportedTexture(absolutePath: string, options: IComputeExportedTextureOptions): Promise<void> {
+	const extension = extname(absolutePath).toLocaleLowerCase();
+
+	const metadata = await sharp(absolutePath).metadata();
+	if (!metadata.width || !metadata.height) {
+		return console.error(`Failed to compute exported image "${absolutePath}". Image metadata is invalid.`);
+	}
+
+	const width = metadata.width;
+	const height = metadata.height;
+
+	const isPowerOfTwo = width === getPowerOfTwoUntil(width) || height === getPowerOfTwoUntil(height);
+
+	type _DownscaledTextureSize = {
+		width: number;
+		height: number;
+	};
+
+	const availableSizes: _DownscaledTextureSize[] = [];
+
+	let midWidth = (width * 0.66) >> 0;
+	let midHeight = (height * 0.66) >> 0;
+
+	if (isPowerOfTwo) {
+		midWidth = getPowerOfTwoUntil(midWidth);
+		midHeight = getPowerOfTwoUntil(midHeight);
+	}
+
+	availableSizes.push({
+		width: midWidth,
+		height: midHeight,
+	});
+
+	let lowWidth = (width * 0.33) >> 0;
+	let lowHeight = (height * 0.33) >> 0;
+
+	if (isPowerOfTwo) {
+		lowWidth = getPowerOfTwoUntil(lowWidth);
+		lowHeight = getPowerOfTwoUntil(lowHeight);
+	}
+
+	availableSizes.push({
+		width: lowWidth,
+		height: lowHeight,
+	});
+
+	for (const size of availableSizes) {
+		const nameWithoutExtension = basename(absolutePath).replace(extension, "");
+		const finalName = `${nameWithoutExtension}_${size.width}_${size.height}${extension}`;
+		const finalPath = join(dirname(absolutePath), finalName);
+
+		options.exportedAssets.push(finalPath);
+
+		if (options.force || !(await fs.pathExists(finalPath))) {
+			try {
+				const buffer = await sharp(absolutePath).resize(size.width, size.height).toBuffer();
+
+				await fs.writeFile(finalPath, buffer);
+
+				console.log(`Exported scaled texture "${finalName}"`);
+			} catch (e) {
+				console.error(`Failed to export image scaled image "${finalName}"`);
+			}
+		}
+
+		if (options.compressedTexturesEnabled) {
+			await compressFileToKtx(finalPath, {
+				...options,
+			});
+		}
+	}
+}

package/src/pack/geometry.mts

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

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