@directivegames/genesys.js 3.1.24

package/scripts/loc.ts

@@ -0,0 +1,112 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface FileStats {
+    file: string;
+    totalLines: number;
+    nonEmptyLines: number;
+    nonCommentLines: number;
+}
+
+interface CodeStats {
+    totalFiles: number;
+    totalLines: number;
+    nonEmptyLines: number;
+    nonCommentLines: number;
+    fileDetails: FileStats[];
+}
+
+function countLinesOfCode() {
+  let projectRoot = path.resolve(__dirname);
+  while(!fs.existsSync(path.join(projectRoot, 'package.json'))) {
+    projectRoot = path.resolve(projectRoot, '..');
+  }
+
+  const sourceFolder = path.join(projectRoot, 'src');
+
+  if (!fs.existsSync(sourceFolder)) {
+    console.error(`Source folder not found: ${sourceFolder}`);
+    return;
+  }
+
+  const stats: CodeStats = {
+    totalFiles: 0,
+    totalLines: 0,
+    nonEmptyLines: 0,
+    nonCommentLines: 0,
+    fileDetails: []
+  };
+
+  function walkDir(dir: string) {
+    const files = fs.readdirSync(dir);
+
+    files.forEach((file: string) => {
+      const fullPath = path.join(dir, file);
+
+      if (fs.statSync(fullPath).isDirectory()) {
+        walkDir(fullPath);
+      } else if (file.endsWith('.ts')) {
+        const content = fs.readFileSync(fullPath, 'utf8');
+        const lines = content.split('\n');
+
+        const fileStats: FileStats = {
+          file: path.relative(sourceFolder, fullPath),
+          totalLines: lines.length,
+          nonEmptyLines: 0,
+          nonCommentLines: 0
+        };
+
+        let inBlockComment = false;
+
+        lines.forEach((line: string) => {
+          const trimmedLine = line.trim();
+
+          // Count non-empty lines
+          if (trimmedLine.length > 0) {
+            fileStats.nonEmptyLines++;
+          }
+
+          // Handle block comments
+          if (trimmedLine.includes('/*')) {
+            inBlockComment = true;
+          }
+
+          // Count non-comment lines
+          if (!inBlockComment &&
+                        !trimmedLine.startsWith('//') &&
+                        !trimmedLine.startsWith('*') &&
+                        !trimmedLine.startsWith('/*') &&
+                        trimmedLine.length > 0) {
+            fileStats.nonCommentLines++;
+          }
+
+          if (trimmedLine.includes('*/')) {
+            inBlockComment = false;
+          }
+        });
+
+        stats.totalFiles++;
+        stats.totalLines += fileStats.totalLines;
+        stats.nonEmptyLines += fileStats.nonEmptyLines;
+        stats.nonCommentLines += fileStats.nonCommentLines;
+        stats.fileDetails.push(fileStats);
+      }
+    });
+  }
+
+  walkDir(sourceFolder);
+
+  // Generate report
+  console.log('\n=== TypeScript Lines of Code Report ===');
+  console.log(`Source folder: ${sourceFolder}`);
+  console.log(`Total TypeScript files: ${stats.totalFiles}`);
+  console.log(`Total lines: ${stats.totalLines}`);
+  console.log(`Non-empty lines: ${stats.nonEmptyLines}`);
+  console.log(`Non-comment lines: ${stats.nonCommentLines}`);
+}
+
+countLinesOfCode();

package/scripts/optimize-glb-wrapper.ts

@@ -0,0 +1,28 @@
+import { GLBWebPConverter } from './optimize-glb.js';
+
+async function main() {
+  try {
+    const filePaths = process.argv.slice(2);
+
+    if (filePaths.length === 0) {
+      console.log('ℹ️  No files provided to optimize');
+      return;
+    }
+
+    const optimizer = new GLBWebPConverter();
+    await optimizer.convertFiles(filePaths, {
+      inputFolder: '',
+      outputFolder: '',
+      quality: 80,
+      recursive: false,
+      preserveOriginal: false,
+      optimize: true,
+    });
+  } catch (error) {
+    console.error('❌ Fatal error:', error);
+    process.exit(1);
+  }
+}
+
+// Execute the main function
+main().catch(console.error);

package/scripts/optimize-glb.ts

@@ -0,0 +1,352 @@
+#!/usr/bin/env tsx
+
+import { existsSync } from 'fs';
+import { mkdir, readdir, readFile, stat, writeFile } from 'fs/promises';
+import { basename, extname, join, resolve } from 'path';
+import { dirname } from 'path';
+
+import { NodeIO } from '@gltf-transform/core';
+import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
+import { dedup, prune, textureCompress, weld } from '@gltf-transform/functions';
+import sharp from 'sharp';
+
+interface ConversionOptions {
+  inputFolder: string;
+  outputFolder?: string;
+  quality: number;
+  recursive: boolean;
+  preserveOriginal: boolean;
+  optimize: boolean;
+}
+
+/**
+ * Convert GLB files in a folder to use WebP texture compression using gltf-transform API
+ */
+class GLBWebPConverter {
+
+  private io: NodeIO;
+
+  constructor() {
+    this.io = new NodeIO().registerExtensions(ALL_EXTENSIONS);
+  }
+
+  /**
+   * Find all GLB files in a directory
+   */
+  async findGLBFiles(dir: string, recursive: boolean = true): Promise<string[]> {
+    const files: string[] = [];
+
+    try {
+      const entries = await readdir(dir);
+
+      for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stats = await stat(fullPath);
+
+        if (stats.isDirectory() && recursive) {
+          const subFiles = await this.findGLBFiles(fullPath, recursive);
+          files.push(...subFiles);
+        } else if (stats.isFile() && extname(entry).toLowerCase() === '.glb') {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      console.error(`Error reading directory ${dir}:`, error);
+    }
+
+    return files;
+  }
+
+  /**
+   * Get file size in bytes
+   */
+  private async getFileSize(filePath: string): Promise<number> {
+    const stats = await stat(filePath);
+    return stats.size;
+  }
+
+  /**
+   * Format file size in human-readable format
+   */
+  private formatFileSize(bytes: number): string {
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    if (bytes === 0) return '0 B';
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${sizes[i]}`;
+  }
+
+  /**
+   * Convert a single GLB file using gltf-transform API
+   */
+  async convertFile(inputPath: string, outputPath: string, options: ConversionOptions): Promise<void> {
+    try {
+      // Ensure output directory exists
+      const outputDir = dirname(outputPath);
+      if (!existsSync(outputDir)) {
+        await mkdir(outputDir, { recursive: true });
+      }
+
+      // Get original file size
+      const originalSize = await this.getFileSize(inputPath);
+
+      // Read and parse the GLB file
+      const inputBuffer = await readFile(inputPath);
+      const document = await this.io.readBinary(inputBuffer);
+
+      console.log('  🔧 Processing with gltf-transform API...');
+
+      // Apply transformations
+      await document.transform(
+        // Apply WebP texture compression
+        textureCompress({
+          encoder: sharp,
+          targetFormat: 'webp',
+          quality: options.quality, // Convert percentage to 0-1 range
+        }),
+      );
+
+      if (options.optimize) {
+        // Apply comprehensive optimizations
+        await document.transform(
+          // Weld vertices
+          weld(),
+          // Remove duplicate data
+          dedup(),
+          // Remove unused properties (nodes, materials, textures, etc.)
+          // keepAttributes is true to prevent unused vertex attributes from being removed, such as UVs not referenced by any material
+          prune({ keepAttributes: true })
+        );
+      }
+
+      // Write the optimized GLB file
+      const outputBuffer = await this.io.writeBinary(document);
+      await writeFile(outputPath, outputBuffer);
+
+      // Calculate file size reduction
+      const newSize = outputBuffer.byteLength;
+      const reduction = ((originalSize - newSize) / originalSize * 100).toFixed(1);
+
+      console.log(`  📊 info: ${this.formatFileSize(originalSize)} → ${this.formatFileSize(newSize)} (${reduction}% reduction)`);
+      console.log(`  ✅ Successfully converted to: ${outputPath}`);
+
+    } catch (error) {
+      console.error(`  ❌ Error processing ${inputPath}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Convert a list of GLB files
+   */
+  async convertFiles(filePaths: string[], options: ConversionOptions): Promise<void> {
+    const {
+      inputFolder,
+      outputFolder = inputFolder,
+      preserveOriginal,
+      optimize
+    } = options;
+
+    if (filePaths.length === 0) {
+      console.log('❌ No GLB files provided for processing');
+      return;
+    }
+
+    console.log(`📦 Processing ${filePaths.length} GLB file(s)`);
+    console.log('');
+
+    // Process each file
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (let i = 0; i < filePaths.length; i++) {
+      const inputPath = filePaths[i];
+
+      // Determine output path
+      let outputPath: string;
+      if (preserveOriginal) {
+        const baseName = basename(inputPath, '.glb');
+        const dir = dirname(inputPath.replace(inputFolder, outputFolder));
+        const suffix = optimize ? '-optimized' : '-webp';
+        outputPath = join(dir, `${baseName}${suffix}.glb`);
+      } else {
+        outputPath = inputPath.replace(inputFolder, outputFolder);
+      }
+
+      try {
+        console.log(`[${i + 1}/${filePaths.length}] Processing: ${inputPath}`);
+        await this.convertFile(inputPath, outputPath, options);
+        successCount++;
+      } catch (error) {
+        console.error(`Failed to process ${inputPath}:`, error);
+        errorCount++;
+      }
+      console.log('');
+    }
+
+    // Summary
+    console.log('📊 Conversion Summary:');
+    console.log(`  ✅ Successful: ${successCount}`);
+    console.log(`  ❌ Failed: ${errorCount}`);
+    console.log(`  📁 Total processed: ${filePaths.length}`);
+  }
+
+  /**
+   * Convert all GLB files in a folder
+   */
+  async convertFolder(options: ConversionOptions): Promise<void> {
+    const {
+      inputFolder,
+      outputFolder = inputFolder,
+      quality,
+      recursive,
+      preserveOriginal,
+      optimize
+    } = options;
+
+    console.log(`🔍 Scanning for GLB files in: ${inputFolder}`);
+    console.log(`📁 Output folder: ${outputFolder}`);
+    console.log(`🎨 WebP quality: ${quality}%`);
+    console.log(`📂 Recursive: ${recursive}`);
+    console.log(`💾 Preserve original: ${preserveOriginal}`);
+    console.log(`⚡ Optimize: ${optimize}`);
+    console.log('');
+
+    // Find all GLB files
+    const glbFiles = await this.findGLBFiles(inputFolder, recursive);
+
+    if (glbFiles.length === 0) {
+      console.log('❌ No GLB files found in the specified directory');
+      return;
+    }
+
+    // Use the new convertFiles API
+    await this.convertFiles(glbFiles, options);
+  }
+}
+
+/**
+ * Parse command line arguments
+ */
+function parseArguments(): ConversionOptions {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+GLB WebP Texture Compression Tool
+
+Uses gltf-transform API for reliable WebP compression and optimization.
+
+Usage: pnpm exec tsx scripts/optimize-glb.ts [options] <input-folder>
+
+Arguments:
+  input-folder          Path to folder containing GLB files
+
+Options:
+  --output, -o          Output folder (default: same as input)
+  --quality, -q         WebP quality 0-100 (default: 80)
+  --recursive, -r       Process subdirectories recursively (default: false)
+  --preserve            Preserve original files by adding suffix (default: false)
+  --optimize            Use full optimization (includes weld, dedup, etc.) (default: false)
+  --help, -h            Show this help message
+
+Examples:
+  pnpm exec tsx scripts/optimize-glb.ts ./assets/models
+  pnpm exec tsx scripts/optimize-glb.ts ./assets/models --output ./assets/models-webp --quality 90
+  pnpm exec tsx scripts/optimize-glb.ts ./assets/models --preserve --quality 75 --optimize
+  pnpm optimize-glb
+
+Notes:
+  - This script uses @gltf-transform/core, @gltf-transform/extensions, and @gltf-transform/functions
+  - The --optimize flag applies comprehensive optimizations including WebP compression
+`);
+    process.exit(0);
+  }
+
+  const options: ConversionOptions = {
+    inputFolder: '',
+    quality: 80,
+    recursive: false,
+    preserveOriginal: false, // Default to preserve original files
+    optimize: false,
+  };
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+
+    switch (arg) {
+      case '--output':
+      case '-o':
+        options.outputFolder = args[++i];
+        break;
+      case '--quality':
+      case '-q':
+        options.quality = parseInt(args[++i]);
+        if (isNaN(options.quality) || options.quality < 0 || options.quality > 100) {
+          console.error('❌ Quality must be a number between 0 and 100');
+          process.exit(1);
+        }
+        break;
+      case '--recursive':
+      case '-r':
+        options.recursive = true;
+        break;
+      case '--preserve':
+        options.preserveOriginal = true;
+        break;
+      case '--optimize':
+        options.optimize = true;
+        break;
+      default:
+        if (!options.inputFolder) {
+          options.inputFolder = arg;
+        } else {
+          console.error(`❌ Unknown argument: ${arg}`);
+          process.exit(1);
+        }
+        break;
+    }
+    i++;
+  }
+
+  if (!options.inputFolder) {
+    console.error('❌ Input folder is required');
+    process.exit(1);
+  }
+
+  // Resolve to absolute paths
+  options.inputFolder = resolve(options.inputFolder);
+  if (options.outputFolder) {
+    options.outputFolder = resolve(options.outputFolder);
+  }
+
+  // Check if input folder exists
+  if (!existsSync(options.inputFolder)) {
+    console.error(`❌ Input folder does not exist: ${options.inputFolder}`);
+    process.exit(1);
+  }
+
+  return options;
+}
+
+/**
+ * Main execution function
+ */
+async function main() {
+  try {
+    const options = parseArguments();
+    const converter = new GLBWebPConverter();
+    await converter.convertFolder(options);
+    console.log('🎉 Conversion completed!');
+  } catch (error) {
+    console.error('❌ Fatal error:', error);
+    process.exit(1);
+  }
+}
+
+// Execute if this file is run directly
+if (process.argv[1]?.includes('optimize-glb.')) {
+  main().catch(console.error);
+}
+
+export { GLBWebPConverter };