@plasius/gpu-shared 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasius/gpu-shared",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Shared browser-safe demo runtime and asset helpers for the Plasius gpu-* package family.",
   "type": "module",
   "sideEffects": false,
@@ -33,7 +33,7 @@
     "demo": "python3 -m http.server --directory ..",
     "demo:example": "node demo/example.js",
     "generate:assets": "node scripts/generate-showcase-assets.mjs",
-    "typecheck": "node --check src/index.js && node --check src/showcase-runtime.js && node --check src/gltf-loader.js && node --check demo/main.js",
+    "typecheck": "node --check src/index.js && node --check src/showcase-runtime.js && node --check src/gltf-loader.js && node --check src/product-studio-runtime.js && node --check demo/main.js",
     "audit:eslint": "eslint . --max-warnings=0",
     "audit:deps": "npm ls --all --omit=optional --omit=peer > /dev/null 2>&1 || true",
     "audit:npm": "npm audit --audit-level=high --omit=dev",
@@ -56,24 +56,21 @@
   ],
   "author": "Plasius LTD <development@plasius.co.uk>",
   "license": "Apache-2.0",
-  "dependencies": {
-    "@plasius/gpu-cloth": "^0.1.4",
-    "@plasius/gpu-debug": "^0.1.5",
-    "@plasius/gpu-fluid": "^0.1.4",
-    "@plasius/gpu-lighting": "^0.1.16",
-    "@plasius/gpu-performance": "^0.1.6",
-    "@plasius/gpu-physics": "^0.1.13"
-  },
   "peerDependencies": {
+    "@plasius/gpu-renderer": "^0.1.15",
     "@plasius/translations": "^1.0.17"
   },
   "peerDependenciesMeta": {
+    "@plasius/gpu-renderer": {
+      "optional": true
+    },
     "@plasius/translations": {
       "optional": true
     }
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@plasius/gpu-lighting": "^0.1.19",
     "@plasius/translations": "^1.0.17",
     "c8": "^11.0.0",
     "eslint": "^10.3.0",

package/src/feature-flags.js

@@ -1 +1,2 @@
 export const GPU_SHOWCASE_REALISTIC_MODELS_FEATURE = "gpu_showcase_realistic_models_v1";
+export const GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE = "gpu_showcase_product_studio_wavefront_v1";

package/src/gltf-loader.js

@@ -139,6 +139,18 @@ function computeBounds(positions) {
   });
 }
 
+function appendValues(target, values) {
+  for (let index = 0; index < values.length; index += 1) {
+    target.push(values[index]);
+  }
+}
+
+function appendIndicesWithOffset(target, values, vertexOffset) {
+  for (let index = 0; index < values.length; index += 1) {
+    target.push(values[index] + vertexOffset);
+  }
+}
+
 function resolveBrowserRequestBaseUrl() {
   if (
     typeof document !== "undefined" &&
@@ -406,8 +418,8 @@ async function buildGltfModel(document, baseUrl) {
 
   for (const primitive of scene.primitives) {
     const vertexOffset = aggregatePositions.length / 3;
-    aggregatePositions.push(...primitive.positions);
-    aggregateIndices.push(...primitive.indices.map((index) => index + vertexOffset));
+    appendValues(aggregatePositions, primitive.positions);
+    appendIndicesWithOffset(aggregateIndices, primitive.indices, vertexOffset);
   }
 
   const color = scene.primitives[0]?.material?.color ?? { r: 0.56, g: 0.33, b: 0.22, a: 1 };

package/src/index.d.ts

@@ -57,6 +57,23 @@ export type ShowcaseFocusMode =
   | "performance"
   | "debug";
 
+export type ShowcaseDemoMode = "harbor" | "product-studio" | "product" | "studio" | "eames";
+
+export interface ProductStudioMesh {
+  readonly id: number;
+  readonly positions: readonly number[];
+  readonly indices: readonly number[];
+  readonly normals?: readonly number[] | null;
+  readonly uvs?: readonly number[] | null;
+  readonly color: readonly number[];
+  readonly emission?: readonly number[];
+  readonly materialKind: string | number;
+  readonly materialRefId?: number;
+  readonly roughness?: number;
+  readonly metallic?: number;
+  readonly opacity?: number;
+}
+
 export type GpuSharedTranslationValue =
   | string
   | number
@@ -137,7 +154,17 @@ export function createGpuSharedTranslator(
 ): (key: GpuSharedTranslationKey, args?: GpuSharedTranslationArgs) => string;
 
 export interface MountGpuShowcaseOptions {
+  __showcaseFeatureLoaders?: {
+    cloth?: () => Promise<unknown>;
+    fluid?: () => Promise<unknown>;
+    lighting?: () => Promise<unknown>;
+    performance?: () => Promise<unknown>;
+    debug?: () => Promise<unknown>;
+    physics?: () => Promise<unknown>;
+  };
   root?: HTMLElement;
+  demoMode?: ShowcaseDemoMode;
+  mode?: ShowcaseDemoMode;
   focus?: ShowcaseFocusMode | string;
   packageName?: string;
   title?: string;
@@ -145,6 +172,16 @@ export interface MountGpuShowcaseOptions {
   translate?: GpuSharedTranslate;
   captureMode?: boolean;
   renderScale?: number;
+  productAssetUrl?: string | URL;
+  assetUrl?: string | URL;
+  width?: number;
+  height?: number;
+  maxDepth?: number;
+  tileSize?: number;
+  samplesPerPixel?: number;
+  denoise?: boolean;
+  lightingPreset?: string;
+  lightingIntensity?: number;
   createState?: () => unknown;
   updateState?: (state: unknown, scene: Record<string, unknown>, dt: number) => unknown;
   describeState?: (state: unknown, scene: Record<string, unknown>) => Record<string, unknown> | null;
@@ -158,7 +195,30 @@ export interface MountGpuShowcaseResult {
   destroy(): void;
 }
 
+export interface MountGpuProductStudioResult {
+  readonly state: Readonly<{
+    featureFlags: unknown;
+    modelName: string;
+    sourceTriangleCount: number;
+    meshCount: number;
+    geometryMode: string;
+    requiresTriangleMeshRenderer: boolean;
+    displayQuality: boolean;
+    requiresMeshBvhForDisplayQuality: boolean;
+    rendererStats: Record<string, unknown>;
+  }>;
+  readonly model: GltfModel;
+  readonly productModel: GltfModel;
+  readonly canvas: HTMLCanvasElement;
+  readonly renderer: unknown;
+  readonly meshes: readonly ProductStudioMesh[];
+  destroy(): void;
+}
+
 export const showcaseFocusModes: readonly ShowcaseFocusMode[];
+export const showcaseDemoModes: readonly ShowcaseDemoMode[];
+export const GPU_SHOWCASE_REALISTIC_MODELS_FEATURE: "gpu_showcase_realistic_models_v1";
+export const GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE: "gpu_showcase_product_studio_wavefront_v1";
 
 export function resolveShowcaseAssetUrl(
   baseUrlOrAssetName?: string | URL | ShowcaseAssetName,
@@ -167,6 +227,18 @@ export function resolveShowcaseAssetUrl(
 
 export function loadGltfModel(url: string | URL): Promise<GltfModel>;
 
+export function createProductStudioMeshes(
+  model: GltfModel,
+  options?: {
+    targetCenter?: readonly number[];
+    targetSize?: number;
+  }
+): readonly ProductStudioMesh[];
+
+export function mountGpuProductStudio(
+  options?: MountGpuShowcaseOptions
+): Promise<MountGpuProductStudioResult>;
+
 export function mountGpuShowcase(
   options?: MountGpuShowcaseOptions
-): Promise<MountGpuShowcaseResult>;
+): Promise<MountGpuShowcaseResult | MountGpuProductStudioResult>;

package/src/index.js

@@ -1,3 +1,8 @@
+import {
+  GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE,
+  GPU_SHOWCASE_REALISTIC_MODELS_FEATURE,
+} from "./feature-flags.js";
+
 export { resolveShowcaseAssetUrl } from "./asset-url.js";
 export {
   createGpuSharedTranslator,
@@ -6,6 +11,14 @@ export {
   translateGpuSharedText,
 } from "./i18n.js";
 export { gpuSharedEnGbTranslations } from "./translations/en-GB.js";
+export {
+  GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE,
+  GPU_SHOWCASE_REALISTIC_MODELS_FEATURE,
+};
+export {
+  createProductStudioMeshes,
+  mountGpuProductStudio,
+} from "./product-studio-runtime.js";
 
 export const showcaseFocusModes = Object.freeze([
   "integrated",
@@ -16,13 +29,66 @@ export const showcaseFocusModes = Object.freeze([
   "performance",
   "debug",
 ]);
+export const showcaseDemoModes = Object.freeze(["harbor", "product-studio"]);
 
 export async function loadGltfModel(url) {
   const module = await import("./gltf-loader.js");
   return module.loadGltfModel(url);
 }
 
+function isProductStudioFeatureEnabled(featureFlags) {
+  if (typeof featureFlags?.get === "function") {
+    return featureFlags.get(GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE) === true;
+  }
+
+  const direct = featureFlags?.[GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE];
+  if (typeof direct === "boolean") {
+    return direct;
+  }
+
+  const flagsValue = featureFlags?.flags?.[GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE];
+  if (typeof flagsValue === "boolean") {
+    return flagsValue;
+  }
+
+  const enabledValue = featureFlags?.enabled?.[GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE];
+  if (typeof enabledValue === "boolean") {
+    return enabledValue;
+  }
+
+  return false;
+}
+
 export async function mountGpuShowcase(options = {}) {
+  const demoMode = options.demoMode ?? options.mode;
+  if (
+    demoMode === "product-studio" ||
+    demoMode === "product" ||
+    demoMode === "studio" ||
+    demoMode === "eames"
+  ) {
+    if (!isProductStudioFeatureEnabled(options.__featureFlags)) {
+      throw new Error(
+        `${GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE} must be enabled before Product Studio can mount.`
+      );
+    }
+
+    const productRuntimeLoader =
+      typeof options.__productRuntimeLoader === "function"
+        ? options.__productRuntimeLoader
+        : () => import("./product-studio-runtime.js");
+    const productModule = await productRuntimeLoader();
+    if (typeof productModule.mountGpuProductStudio !== "function") {
+      throw new Error("product runtime loader must provide mountGpuProductStudio.");
+    }
+
+    const productOptions = { ...options, demoMode };
+    delete productOptions.__runtimeLoader;
+    delete productOptions.__productRuntimeLoader;
+    delete productOptions.__featureFlags;
+    return productModule.mountGpuProductStudio(productOptions, options.__featureFlags);
+  }
+
   const runtimeLoader =
     typeof options.__runtimeLoader === "function"
       ? options.__runtimeLoader
@@ -34,6 +100,7 @@ export async function mountGpuShowcase(options = {}) {
 
   const publicOptions = { ...options };
   delete publicOptions.__runtimeLoader;
+  delete publicOptions.__productRuntimeLoader;
   delete publicOptions.__featureFlags;
   return module.mountGpuShowcase(publicOptions, options.__featureFlags);
 }