AndrewAltimit
diff --git a/‎.gitattributes‎
Lines changed: 1 addition & 0 deletions b/‎.gitattributes‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎scripts/blueprint-screenshot.js‎
Lines changed: 118 additions & 0 deletions b/‎scripts/blueprint-screenshot.js‎
Lines changed: 118 additions & 0 deletions
diff --git a/‎scripts/fbx-to-glb.html‎
Lines changed: 90 additions & 0 deletions b/‎scripts/fbx-to-glb.html‎
Lines changed: 90 additions & 0 deletions
diff --git a/‎scripts/fbx-to-glb.js‎
Lines changed: 176 additions & 0 deletions b/‎scripts/fbx-to-glb.js‎
Lines changed: 176 additions & 0 deletions
@@ -9,3 +9,4 @@
 *.json text eol=lf
 *.yaml text eol=lf
 *.yml text eol=lf
+*.glb filter=lfs diff=lfs merge=lfs -text
@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// Takes screenshots of blueprint.html from multiple camera angles.
+// Usage: node scripts/blueprint-screenshot.js [diagram]
+// Starts a local HTTP server, launches headless Chromium, captures screenshots.
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const puppeteer = require('puppeteer');
+
+const SITE_DIR = path.join(__dirname, '..', 'site');
+const OUT_DIR = path.join(__dirname, '..', 'screenshots', 'blueprint');
+const DIAGRAM = process.argv[2] || 'psp-usb-adapter';
+const WIDTH = 1366;
+const HEIGHT = 768;
+
+// Camera presets: [phi, theta, r] — spherical coords
+const VIEWS = [
+  { name: 'front',      phi: Math.PI/2,   theta: 0,          r: 30,  desc: 'straight-on front' },
+  { name: 'hero',       phi: Math.PI/2.8, theta: Math.PI/8,  r: 30,  desc: 'hero angle (default)' },
+  { name: 'top-down',   phi: 0.3,         theta: 0,          r: 35,  desc: 'near top-down' },
+  { name: 'side-left',  phi: Math.PI/2.5, theta: Math.PI/2,  r: 28,  desc: 'left side' },
+  { name: 'close-top',  phi: Math.PI/3,   theta: Math.PI/6,  r: 18,  desc: 'close-up on top edge' },
+  { name: 'exploded',   phi: Math.PI/3,   theta: Math.PI/5,  r: 40,  desc: 'exploded view' },
+];
+
+// Simple static file server
+function startServer() {
+  return new Promise((resolve) => {
+    const MIME = {
+      '.html': 'text/html', '.css': 'text/css', '.js': 'application/javascript',
+      '.png': 'image/png', '.jpg': 'image/jpeg', '.svg': 'image/svg+xml'
+    };
+    const server = http.createServer((req, res) => {
+      const urlPath = req.url.split('?')[0];
+      let filePath = path.join(SITE_DIR, urlPath === '/' ? 'index.html' : urlPath);
+      const ext = path.extname(filePath);
+      fs.readFile(filePath, (err, data) => {
+        if (err) { res.writeHead(404); res.end('Not found'); return; }
+        res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
+        res.end(data);
+      });
+    });
+    server.listen(0, '127.0.0.1', () => {
+      const port = server.address().port;
+      resolve({ server, port });
+    });
+  });
+}
+
+async function main() {
+  fs.mkdirSync(OUT_DIR, { recursive: true });
+
+  const { server, port } = await startServer();
+  console.log(`Server on http://127.0.0.1:${port}`);
+
+  const browser = await puppeteer.launch({
+    headless: 'new',
+    executablePath: '/snap/bin/chromium',
+    args: ['--no-sandbox', '--disable-setuid-sandbox',
+           '--enable-webgl', '--use-gl=angle', '--use-angle=swiftshader',
+           '--enable-unsafe-swiftshader',
+           `--window-size=${WIDTH},${HEIGHT}`],
+  });
+
+  const page = await browser.newPage();
+  await page.setViewport({ width: WIDTH, height: HEIGHT });
+
+  const url = `http://127.0.0.1:${port}/blueprint.html?diagram=${DIAGRAM}`;
+  console.log(`Loading ${url}`);
+  await page.goto(url, { waitUntil: 'load', timeout: 15000 });
+  // Wait for Three.js to render
+  await new Promise(r => setTimeout(r, 2000));
+
+  for (const view of VIEWS) {
+    console.log(`  Capturing: ${view.name} (${view.desc})`);
+
+    // Set camera via orbit controls and optionally explode slider
+    await page.evaluate((v) => {
+      if (window.orbit) {
+        window.orbit.phi = v.phi;
+        window.orbit.theta = v.theta;
+        window.orbit.r = v.r;
+        window.camUpdate();
+      }
+    }, { phi: view.phi, theta: view.theta, r: view.r });
+
+    // For exploded view, push the slider
+    if (view.name === 'exploded') {
+      await page.evaluate(() => {
+        const slider = document.getElementById('explode');
+        if (slider) {
+          slider.value = 80;
+          slider.dispatchEvent(new Event('input'));
+        }
+      });
+    } else {
+      await page.evaluate(() => {
+        const slider = document.getElementById('explode');
+        if (slider) {
+          slider.value = 20;
+          slider.dispatchEvent(new Event('input'));
+        }
+      });
+    }
+
+    await new Promise(r => setTimeout(r, 500)); // let render settle
+    const filename = path.join(OUT_DIR, `${DIAGRAM}-${view.name}.png`);
+    await page.screenshot({ path: filename });
+    console.log(`    -> ${filename}`);
+  }
+
+  await browser.close();
+  server.close();
+  console.log(`\nDone! ${VIEWS.length} screenshots in ${OUT_DIR}`);
+}
+
+main().catch(e => { console.error(e); process.exit(1); });
@@ -0,0 +1,90 @@
+<!DOCTYPE html>
+<html>
+<head><title>FBX to GLB Converter</title></head>
+<body>
+<script src="../site/js/three.min.js"></script>
+<script src="../site/js/fflate.js"></script>
+<script src="../site/js/NURBSUtils.js"></script>
+<script src="../site/js/NURBSCurve.js"></script>
+<script src="../site/js/FBXLoader.js"></script>
+<script>
+// Load FBX, extract geometry stats, and export wireframe data
+window.convertFBX = function(arrayBuffer) {
+  var loader = new THREE.FBXLoader();
+  var scene = loader.parse(arrayBuffer);
+
+  var stats = { meshes: [], totalVertices: 0, totalFaces: 0 };
+  var allPositions = [];
+  var allIndices = [];
+  var vertexOffset = 0;
+
+  scene.traverse(function(child) {
+    if (child.isMesh && child.geometry && child.name !== 'ground') {
+      var geo = child.geometry;
+      var pos = geo.attributes.position;
+      var idx = geo.index;
+
+      // Apply world transform
+      child.updateWorldMatrix(true, false);
+      geo.applyMatrix4(child.matrixWorld);
+
+      var vCount = pos.count;
+      var fCount = idx ? idx.count / 3 : vCount / 3;
+
+      stats.meshes.push({
+        name: child.name,
+        vertices: vCount,
+        faces: fCount
+      });
+      stats.totalVertices += vCount;
+      stats.totalFaces += fCount;
+
+      // Collect positions
+      for (var i = 0; i < pos.count; i++) {
+        allPositions.push(pos.getX(i), pos.getY(i), pos.getZ(i));
+      }
+
+      // Collect indices (offset by vertex count of previous meshes)
+      if (idx) {
+        for (var i = 0; i < idx.count; i++) {
+          allIndices.push(idx.getX(i) + vertexOffset);
+        }
+      } else {
+        for (var i = 0; i < vCount; i++) {
+          allIndices.push(i + vertexOffset);
+        }
+      }
+      vertexOffset += vCount;
+    }
+  });
+
+  stats.positionsLength = allPositions.length;
+  stats.indicesLength = allIndices.length;
+
+  // Compute bounding box
+  var minX=Infinity, minY=Infinity, minZ=Infinity;
+  var maxX=-Infinity, maxY=-Infinity, maxZ=-Infinity;
+  for (var i = 0; i < allPositions.length; i += 3) {
+    var x = allPositions[i], y = allPositions[i+1], z = allPositions[i+2];
+    if (x < minX) minX = x; if (x > maxX) maxX = x;
+    if (y < minY) minY = y; if (y > maxY) maxY = y;
+    if (z < minZ) minZ = z; if (z > maxZ) maxZ = z;
+  }
+  stats.boundingBox = {
+    min: [minX, minY, minZ],
+    max: [maxX, maxY, maxZ],
+    size: [maxX-minX, maxY-minY, maxZ-minZ]
+  };
+
+  // Export as merged geometry JSON (positions + indices)
+  window._exportData = {
+    positions: new Float32Array(allPositions),
+    indices: new Uint32Array(allIndices),
+    stats: stats
+  };
+
+  return stats;
+};
+</script>
+</body>
+</html>
@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+// Converts FBX to a lightweight GLB using puppeteer + Three.js FBXLoader
+// Usage: node scripts/fbx-to-glb.js <input.fbx> <output.glb>
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const puppeteer = require('puppeteer');
+
+const INPUT = process.argv[2];
+if (!INPUT) {
+  console.error('Usage: node scripts/fbx-to-glb.js <input.fbx> [output.glb]');
+  process.exit(1);
+}
+const OUTPUT = process.argv[3] || path.join(__dirname, '..', 'site', 'models', 'psp.glb');
+
+const PROJ_ROOT = path.join(__dirname, '..');
+
+async function main() {
+  // Serve project root so HTML can load scripts from site/js/
+  const server = http.createServer((req, res) => {
+    const urlPath = req.url.split('?')[0];
+    const filePath = path.join(PROJ_ROOT, urlPath === '/' ? 'index.html' : urlPath);
+    fs.readFile(filePath, (err, data) => {
+      if (err) { res.writeHead(404); res.end('Not found'); return; }
+      res.writeHead(200); res.end(data);
+    });
+  });
+
+  await new Promise(r => server.listen(0, '127.0.0.1', r));
+  const port = server.address().port;
+
+  const browser = await puppeteer.launch({
+    headless: 'new',
+    executablePath: '/snap/bin/chromium',
+    args: ['--no-sandbox', '--disable-setuid-sandbox', '--enable-webgl',
+           '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader']
+  });
+
+  const page = await browser.newPage();
+  page.on('console', m => console.log('PAGE:', m.text()));
+  page.on('pageerror', e => console.log('ERR:', e.message));
+
+  await page.goto(`http://127.0.0.1:${port}/scripts/fbx-to-glb.html`, {
+    waitUntil: 'networkidle0', timeout: 15000
+  });
+
+  // Read FBX file and pass to browser
+  const fbxData = fs.readFileSync(INPUT);
+  console.log(`Loading FBX: ${INPUT} (${(fbxData.length/1024).toFixed(0)} KB)`);
+
+  // Transfer buffer to page and convert
+  const stats = await page.evaluate(async (fbxBase64) => {
+    const binary = atob(fbxBase64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return window.convertFBX(bytes.buffer);
+  }, fbxData.toString('base64'));
+
+  console.log('Mesh stats:', JSON.stringify(stats, null, 2));
+
+  // Extract positions and indices arrays
+  const exportData = await page.evaluate(() => {
+    const d = window._exportData;
+    return {
+      positions: Array.from(d.positions),
+      indices: Array.from(d.indices)
+    };
+  });
+
+  console.log(`Positions: ${exportData.positions.length/3} vertices`);
+  console.log(`Indices: ${exportData.indices.length/3} triangles`);
+
+  // Build a minimal GLB (glTF binary)
+  const glb = buildGLB(
+    new Float32Array(exportData.positions),
+    new Uint32Array(exportData.indices),
+    stats.boundingBox
+  );
+
+  fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
+  fs.writeFileSync(OUTPUT, glb);
+  console.log(`\nWrote: ${OUTPUT} (${(glb.length/1024).toFixed(0)} KB)`);
+
+  await browser.close();
+  server.close();
+}
+
+// Build minimal GLB with just positions + indices
+function buildGLB(positions, indices, bbox) {
+  const posBytes = Buffer.from(positions.buffer);
+  const idxBytes = Buffer.from(indices.buffer);
+
+  // Pad to 4-byte alignment
+  const posPad = (4 - posBytes.length % 4) % 4;
+  const idxPad = (4 - idxBytes.length % 4) % 4;
+
+  const binLength = posBytes.length + posPad + idxBytes.length + idxPad;
+
+  const gltf = {
+    asset: { version: '2.0', generator: 'oasis-blueprint-converter' },
+    scene: 0,
+    scenes: [{ nodes: [0] }],
+    nodes: [{ mesh: 0, name: 'PSP-3001' }],
+    meshes: [{
+      primitives: [{
+        attributes: { POSITION: 0 },
+        indices: 1,
+        mode: 4 // TRIANGLES
+      }]
+    }],
+    accessors: [
+      {
+        bufferView: 0,
+        componentType: 5126, // FLOAT
+        count: positions.length / 3,
+        type: 'VEC3',
+        min: bbox.min,
+        max: bbox.max
+      },
+      {
+        bufferView: 1,
+        componentType: 5125, // UNSIGNED_INT
+        count: indices.length,
+        type: 'SCALAR'
+      }
+    ],
+    bufferViews: [
+      {
+        buffer: 0,
+        byteOffset: 0,
+        byteLength: posBytes.length,
+        target: 34962 // ARRAY_BUFFER
+      },
+      {
+        buffer: 0,
+        byteOffset: posBytes.length + posPad,
+        byteLength: idxBytes.length,
+        target: 34963 // ELEMENT_ARRAY_BUFFER
+      }
+    ],
+    buffers: [{ byteLength: binLength }]
+  };
+
+  const jsonStr = JSON.stringify(gltf);
+  const jsonPad = (4 - jsonStr.length % 4) % 4;
+  const jsonBuf = Buffer.from(jsonStr + ' '.repeat(jsonPad));
+  const binBuf = Buffer.concat([posBytes, Buffer.alloc(posPad), idxBytes, Buffer.alloc(idxPad)]);
+
+  // GLB header: magic(4) + version(4) + length(4) = 12 bytes
+  // JSON chunk: length(4) + type(4) + data
+  // BIN chunk: length(4) + type(4) + data
+  const totalLength = 12 + 8 + jsonBuf.length + 8 + binBuf.length;
+
+  const out = Buffer.alloc(totalLength);
+  let off = 0;
+
+  // Header
+  out.writeUInt32LE(0x46546C67, off); off += 4; // glTF magic
+  out.writeUInt32LE(2, off); off += 4;           // version
+  out.writeUInt32LE(totalLength, off); off += 4;
+
+  // JSON chunk
+  out.writeUInt32LE(jsonBuf.length, off); off += 4;
+  out.writeUInt32LE(0x4E4F534A, off); off += 4; // JSON type
+  jsonBuf.copy(out, off); off += jsonBuf.length;
+
+  // BIN chunk
+  out.writeUInt32LE(binBuf.length, off); off += 4;
+  out.writeUInt32LE(0x004E4942, off); off += 4; // BIN type
+  binBuf.copy(out, off);
+
+  return out;
+}
+
+main().catch(e => { console.error(e); process.exit(1); });