pptx-angular-viewer 4.6.0 → 4.8.0

package/fesm2022/pptx-angular-viewer-view-scene-Bn9SJZk9.mjs

@@ -0,0 +1,862 @@
+import { x as hexToRgb, y as smartArt3DGradientColor, z as shadeSmartArt3DVertices, A as smartArt3DGradientCoordinate, B as threeViewOverflowFromNdc, N as NO_THREE_VIEW_OVERFLOW, E as hasThreeViewOverflow, F as overflowViewOffset, G as smartArt3DCameraMatrix, H as smartArt3DEyeInDiagram, I as resolveSmartArt3DLightModel } from './pptx-angular-viewer-pptx-angular-viewer-Cf08ueRA.mjs';
+
+/** Supersampling factor for crisp text at any zoom. */
+const SUPERSAMPLE = 3;
+/** Build a canvas texture rendering `block`'s pre-wrapped lines, or `null` off-DOM. */
+function buildTextBlockTexture(three, block) {
+    if (typeof document === 'undefined' || block.lines.every((l) => l.text.length === 0)) {
+        return null;
+    }
+    const worldWidth = Math.max(1, block.maxWidth);
+    const worldHeight = Math.max(1, block.maxHeight);
+    const canvas = document.createElement('canvas');
+    canvas.width = Math.max(8, Math.round(worldWidth * SUPERSAMPLE));
+    canvas.height = Math.max(8, Math.round(worldHeight * SUPERSAMPLE));
+    const ctx2d = canvas.getContext('2d');
+    if (!ctx2d) {
+        return null;
+    }
+    const weight = block.fontWeight ?? 400;
+    const italic = block.fontStyle === 'italic' ? 'italic ' : '';
+    const family = block.fontFamily
+        ? `${block.fontFamily}, system-ui, sans-serif`
+        : 'system-ui, -apple-system, Segoe UI, Roboto, sans-serif';
+    const px = Math.max(6, block.fontSize) * SUPERSAMPLE;
+    ctx2d.clearRect(0, 0, canvas.width, canvas.height);
+    ctx2d.fillStyle = block.color;
+    ctx2d.textAlign = 'center';
+    // `dy` places each line's CENTRE (as `centeredSvgTextLines` lays it out,
+    // and the 2D renderers draw with `dominant-baseline: central`).
+    ctx2d.textBaseline = 'middle';
+    ctx2d.font = `${italic}${weight} ${px}px ${family}`;
+    const centerX = canvas.width / 2;
+    const centerY = canvas.height / 2;
+    for (const line of block.lines) {
+        if (!line.text) {
+            continue;
+        }
+        // `dy` is a y-up offset from the block centre; canvas y grows downward.
+        ctx2d.fillText(line.text, centerX, centerY - line.dy * SUPERSAMPLE);
+    }
+    const texture = new three.CanvasTexture(canvas);
+    texture.colorSpace = three.SRGBColorSpace;
+    texture.minFilter = three.LinearFilter;
+    texture.magFilter = three.LinearFilter;
+    // See `smartart-3d/text-texture.ts` for why flipY must stay false with a
+    // compensating UV flip: WebGL2 forbids UNPACK_FLIP_Y_WEBGL for some texture
+    // targets, and leaving it enabled pollutes global pixel-store state.
+    texture.flipY = false;
+    texture.premultiplyAlpha = false;
+    texture.wrapT = three.RepeatWrapping;
+    texture.repeat.set(1, -1);
+    texture.offset.set(0, 1);
+    texture.needsUpdate = true;
+    return { texture, worldWidth, worldHeight };
+}
+
+/** z-lift of the stroke outline above its fill, so the two don't z-fight. */
+const STROKE_Z_LIFT = 0.05;
+function buildShape(three, mesh) {
+    const shape = new three.Shape(mesh.outline.map((p) => new three.Vector2(p.x, p.y)));
+    for (const hole of mesh.holes ?? []) {
+        shape.holes.push(new three.Path(hole.map((p) => new three.Vector2(p.x, p.y))));
+    }
+    return shape;
+}
+/** Build the fill mesh for a flat (zero-depth) `SmartArt3DMesh`. */
+function buildFlatFill(three, mesh, shape, disposables) {
+    if (mesh.fillNone) {
+        return null;
+    }
+    const geometry = new three.ShapeGeometry(shape);
+    const material = new three.MeshBasicMaterial({
+        color: mesh.fill,
+        side: three.DoubleSide,
+        transparent: mesh.opacity < 1,
+        opacity: mesh.opacity,
+    });
+    disposables.push(geometry, material);
+    return new three.Mesh(geometry, material);
+}
+/** Build the stroke outline (and hole outlines) as line loops. */
+function buildStrokeLines(three, mesh, disposables) {
+    if (mesh.strokeWidth <= 0 || mesh.stroke === 'transparent') {
+        return [];
+    }
+    const material = new three.LineBasicMaterial({ color: mesh.stroke });
+    disposables.push(material);
+    const loops = [mesh.outline, ...(mesh.holes ?? [])];
+    return loops.map((loop) => {
+        const geometry = new three.BufferGeometry().setFromPoints(loop.map((p) => new three.Vector3(p.x, p.y, STROKE_Z_LIFT)));
+        disposables.push(geometry);
+        return new three.LineLoop(geometry, material);
+    });
+}
+/** Build the text label plane, or `null` when the mesh has no text. */
+function buildTextPlane(three, mesh, group, disposables) {
+    if (!mesh.textBlock) {
+        return;
+    }
+    const built = buildTextBlockTexture(three, mesh.textBlock);
+    if (!built) {
+        return;
+    }
+    disposables.push(built.texture);
+    const geometry = new three.PlaneGeometry(built.worldWidth, built.worldHeight);
+    const material = new three.MeshBasicMaterial({
+        map: built.texture,
+        transparent: true,
+        depthWrite: false,
+    });
+    disposables.push(geometry, material);
+    const plane = new three.Mesh(geometry, material);
+    // `textBlock` carries its own world position (already includes the
+    // shape's rotation applied to its centre); the group itself is placed at
+    // the shape's own centre, so offset back to absolute world space here.
+    plane.position.set(mesh.textBlock.x - mesh.position.x, mesh.textBlock.y - mesh.position.y, mesh.textBlock.z - mesh.position.z);
+    group.add(plane);
+}
+/** Build the complete `Object3D` for one flat mesh. */
+function buildFlatMeshObject(three, mesh) {
+    const disposables = [];
+    const group = new three.Group();
+    group.position.set(mesh.position.x, mesh.position.y, mesh.position.z);
+    const shape = buildShape(three, mesh);
+    const fill = buildFlatFill(three, mesh, shape, disposables);
+    if (fill) {
+        group.add(fill);
+    }
+    for (const line of buildStrokeLines(three, mesh, disposables)) {
+        group.add(line);
+    }
+    buildTextPlane(three, mesh, group, disposables);
+    return { group, disposables };
+}
+
+/** Points closer than this are treated as the same vertex. */
+const EPSILON = 1e-6;
+/** Longest mitre, as a multiple of the offset distance (sharp spikes are clipped). */
+const MITER_LIMIT = 4;
+/** Drop repeated consecutive points and the closing duplicate of the first point. */
+function cleanRing(points) {
+    const out = [];
+    for (const p of points) {
+        const last = out[out.length - 1];
+        if (!last || Math.hypot(p.x - last.x, p.y - last.y) > EPSILON) {
+            out.push({ x: p.x, y: p.y });
+        }
+    }
+    while (out.length > 1) {
+        const first = out[0];
+        const last = out[out.length - 1];
+        if (Math.hypot(first.x - last.x, first.y - last.y) > EPSILON) {
+            break;
+        }
+        out.pop();
+    }
+    return out;
+}
+/** Shoelace signed area: positive for a counter-clockwise ring in y-up space. */
+function ringSignedArea(ring) {
+    let area = 0;
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i];
+        const b = ring[(i + 1) % ring.length];
+        area += a.x * b.y - b.x * a.y;
+    }
+    return area / 2;
+}
+/** A cleaned, counter-clockwise (y-up) copy of `points`. */
+function toCcwRing(points) {
+    const ring = cleanRing(points);
+    return ringSignedArea(ring) < 0 ? ring.reverse() : ring;
+}
+/**
+ * Unit inward normal of every edge `i -> i + 1` of a counter-clockwise ring
+ * (the interior is on the edge's left).
+ */
+function ringEdgeNormals(ring) {
+    return ring.map((a, i) => {
+        const b = ring[(i + 1) % ring.length];
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const len = Math.hypot(dx, dy) || 1;
+        return { x: -dy / len, y: dx / len };
+    });
+}
+/**
+ * Offset a counter-clockwise ring by `distance` along its inward normals
+ * (negative grows it). Each vertex moves along its mitre, clipped at
+ * {@link MITER_LIMIT} times the distance so a sharp spike stays bounded.
+ */
+function offsetRing(ring, distance) {
+    if (distance === 0) {
+        return ring.map((p) => ({ x: p.x, y: p.y }));
+    }
+    const normals = ringEdgeNormals(ring);
+    const n = ring.length;
+    return ring.map((p, i) => {
+        const prev = normals[(i - 1 + n) % n];
+        const next = normals[i];
+        const denom = Math.max(0.05, 1 + prev.x * next.x + prev.y * next.y);
+        let ox = ((prev.x + next.x) / denom) * distance;
+        let oy = ((prev.y + next.y) / denom) * distance;
+        const len = Math.hypot(ox, oy);
+        const max = Math.abs(distance) * MITER_LIMIT;
+        if (len > max) {
+            ox = (ox / len) * max;
+            oy = (oy / len) * max;
+        }
+        return { x: p.x + ox, y: p.y + oy };
+    });
+}
+/**
+ * The in-plane inward direction to shade each edge's two ends with.
+ *
+ * `result[i]` is `[atStart, atEnd]` for edge `i -> i + 1`. Where the ring
+ * turns by less than `smoothDeg` (a curve's tessellation) the two edges share
+ * the averaged normal, so a circle shades smoothly; at a real corner each
+ * edge keeps its own normal, so a rectangle's sides shade flat.
+ */
+function ringShadingNormals(ring, smoothDeg = 30) {
+    const normals = ringEdgeNormals(ring);
+    const n = ring.length;
+    const cosLimit = Math.cos((smoothDeg * Math.PI) / 180);
+    const vertexNormal = (own, other) => {
+        if (own.x * other.x + own.y * other.y < cosLimit) {
+            return own;
+        }
+        const x = own.x + other.x;
+        const y = own.y + other.y;
+        const len = Math.hypot(x, y) || 1;
+        return { x: x / len, y: y / len };
+    };
+    return normals.map((own, i) => [
+        vertexNormal(own, normals[(i - 1 + n) % n]),
+        vertexNormal(own, normals[(i + 1) % n]),
+    ]);
+}
+
+/**
+ * `a:bevelT/@prst` cross-sections for the lit SmartArt 3D solids
+ * (framework-agnostic, pure).
+ *
+ * A profile is a polyline from the shape's outline (`s = 0`, `t = 0`) to the
+ * inner edge of the bevel (`s = 1`, `t = 1`): `s` is the inset as a fraction
+ * of the bevel width, `t` the height as a fraction of the bevel height. The
+ * shapes follow the ECMA-376 20.1.10.9 preset silhouettes, tuned against the
+ * PowerPoint exports of the SmartArt bevel quick styles
+ * (`e2e/fixtures/three-d-parity/gt`): `circle` (Polished) is a quarter round,
+ * `relaxedInset` (Inset) dips into a groove before rising to the face, which
+ * is what paints its dark outer line and bright inner ridge.
+ *
+ * @module render/smartart-3d-bevel-profile
+ */
+/** Samples used for the curved profiles. */
+const CURVE_SEGMENTS = 8;
+function sampleCurve(fn) {
+    const points = [];
+    for (let i = 0; i <= CURVE_SEGMENTS; i++) {
+        points.push(fn(i / CURVE_SEGMENTS));
+    }
+    return points;
+}
+const QUARTER = Math.PI / 2;
+const PROFILES = {
+    // Quarter round: vertical at the outline, flat where it meets the face.
+    circle: () => sampleCurve((u) => ({ s: 1 - Math.cos(u * QUARTER), t: Math.sin(u * QUARTER) })),
+    // Round, but reaching the outline at a slant instead of vertically.
+    convex: () => sampleCurve((u) => ({ s: u, t: Math.sin(u * QUARTER) })),
+    softRound: () => sampleCurve((u) => ({ s: u, t: 1 - (1 - u) * (1 - u) })),
+    // A groove next to the outline, then a rounded rise onto the face.
+    relaxedInset: () => sampleCurve((u) => ({
+        s: u,
+        t: u * u * (3 - 2 * u) - 0.3 * Math.sin(Math.PI * u) * (1 - u),
+    })),
+    divot: () => sampleCurve((u) => ({
+        s: u,
+        t: u - 0.5 * Math.sin(Math.PI * u),
+    })),
+    angle: () => [
+        { s: 0, t: 0 },
+        { s: 1, t: 1 },
+    ],
+    slope: () => [
+        { s: 0, t: 0 },
+        { s: 1, t: 1 },
+    ],
+    coolSlant: () => [
+        { s: 0, t: 0 },
+        { s: 0.3, t: 0.75 },
+        { s: 1, t: 1 },
+    ],
+    hardEdge: () => [
+        { s: 0, t: 0 },
+        { s: 0.2, t: 0.9 },
+        { s: 1, t: 1 },
+    ],
+    cross: () => [
+        { s: 0, t: 0 },
+        { s: 0.5, t: 1 },
+        { s: 1, t: 1 },
+    ],
+    riblet: () => [
+        { s: 0, t: 0 },
+        { s: 0.33, t: 1 },
+        { s: 0.66, t: 0.5 },
+        { s: 1, t: 1 },
+    ],
+    artDeco: () => [
+        { s: 0, t: 0 },
+        { s: 0.25, t: 0.5 },
+        { s: 0.5, t: 0.5 },
+        { s: 0.75, t: 1 },
+        { s: 1, t: 1 },
+    ],
+};
+/**
+ * The cross-section for a bevel preset token; unknown tokens fall back to
+ * `circle` (the ECMA-376 default for an `a:bevelT` without `@prst`).
+ */
+function getSmartArtBevelProfile(profile) {
+    const build = (profile && PROFILES[profile]) || PROFILES.circle;
+    return build();
+}
+
+/** Contour rims sit this far in front of the plane they ring, so they win the depth test. */
+const CONTOUR_Z_LIFT = 0.05;
+/** Slope used for a vertical profile segment (an outward, horizontal normal). */
+const VERTICAL_SLOPE = 1e3;
+function emptyTriangles() {
+    return { positions: [], normals: [] };
+}
+function pushVertex(out, p, z, n) {
+    out.positions.push(p.x, p.y, z);
+    out.normals.push(n[0], n[1], n[2]);
+}
+function normalize(x, y, z) {
+    const len = Math.hypot(x, y, z) || 1;
+    return [x / len, y / len, z / len];
+}
+/** Push the two triangles of quad `a b c d` (in order around the quad). */
+function pushQuad(out, corners) {
+    const [a, b, c, d] = corners;
+    for (const v of [a, b, c, a, c, d]) {
+        pushVertex(out, v.p, v.z, v.n);
+    }
+}
+/**
+ * A bevel band from `ring` (at `zOuter`) inward to `ring` inset by the bevel
+ * width, rising by the bevel height toward `facing` (+1 front, -1 back).
+ * Returns the band's inner ring.
+ */
+function addBand(out, ring, bevel, zOuter, facing) {
+    const profile = getSmartArtBevelProfile(bevel.profile);
+    const rings = profile.map((pt) => offsetRing(ring, bevel.width * pt.s));
+    const shading = ringShadingNormals(ring);
+    const n = ring.length;
+    for (let k = 0; k < profile.length - 1; k++) {
+        const ds = profile[k + 1].s - profile[k].s;
+        const dt = profile[k + 1].t - profile[k].t;
+        const slope = Math.abs(ds) < 1e-6
+            ? Math.sign(dt || 1) * VERTICAL_SLOPE
+            : (bevel.height * dt) / (bevel.width * ds);
+        const z0 = zOuter + facing * bevel.height * profile[k].t;
+        const z1 = zOuter + facing * bevel.height * profile[k + 1].t;
+        for (let i = 0; i < n; i++) {
+            const j = (i + 1) % n;
+            const [mi, mj] = shading[i];
+            const ni = normalize(-slope * mi.x, -slope * mi.y, facing);
+            const nj = normalize(-slope * mj.x, -slope * mj.y, facing);
+            pushQuad(out, [
+                { p: rings[k][i], z: z0, n: ni },
+                { p: rings[k][j], z: z0, n: nj },
+                { p: rings[k + 1][j], z: z1, n: nj },
+                { p: rings[k + 1][i], z: z1, n: ni },
+            ]);
+        }
+    }
+    return rings[rings.length - 1];
+}
+/** Vertical walls around `ring` from `zTop` down to `zBottom`, facing outward. */
+function addWalls(out, ring, zTop, zBottom) {
+    if (zTop - zBottom <= 0) {
+        return;
+    }
+    const shading = ringShadingNormals(ring);
+    const n = ring.length;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const [mi, mj] = shading[i];
+        const ni = normalize(-mi.x, -mi.y, 0);
+        const nj = normalize(-mj.x, -mj.y, 0);
+        pushQuad(out, [
+            { p: ring[i], z: zTop, n: ni },
+            { p: ring[j], z: zTop, n: nj },
+            { p: ring[j], z: zBottom, n: nj },
+            { p: ring[i], z: zBottom, n: ni },
+        ]);
+    }
+}
+/**
+ * Build the geometry for one solid from its mesh-local outline (and holes,
+ * which are cut from the caps but not bevelled).
+ */
+function buildSmartArt3DSolidGeometry(outline, holes, solid) {
+    const ring = toCcwRing(outline);
+    const body = emptyTriangles();
+    const sides = emptyTriangles();
+    const topHeight = solid.bevelTop?.height ?? 0;
+    const zShoulder = -topHeight;
+    const zBackShoulder = zShoulder - solid.extrusion;
+    const backHeight = solid.bevelBottom?.height ?? 0;
+    const zBack = zBackShoulder - backHeight;
+    const holeRings = holes.map((hole) => toCcwRing(hole)).filter((hole) => hole.length >= 3);
+    const frontRing = solid.bevelTop ? addBand(body, ring, solid.bevelTop, zShoulder, 1) : ring;
+    addWalls(sides, ring, zShoulder, zBackShoulder);
+    const hasDepth = zBack < 0;
+    const backRing = hasDepth && solid.bevelBottom
+        ? addBand(sides, ring, solid.bevelBottom, zBackShoulder, -1)
+        : ring;
+    const contourCaps = [];
+    if (solid.contourWidth > 0) {
+        const rim = offsetRing(ring, -solid.contourWidth);
+        const inner = [...ring].reverse();
+        contourCaps.push({ ring: rim, holes: [inner], z: zShoulder + CONTOUR_Z_LIFT, facing: 1 });
+        if (hasDepth) {
+            contourCaps.push({ ring: rim, holes: [inner], z: zBack - CONTOUR_Z_LIFT, facing: -1 });
+        }
+    }
+    return {
+        body,
+        sides,
+        frontCap: { ring: frontRing, holes: holeRings, z: 0, facing: 1 },
+        ...(hasDepth ? { backCap: { ring: backRing, holes: holeRings, z: zBack, facing: -1 } } : {}),
+        contourCaps,
+    };
+}
+
+/** Depth between two side layers, layout px (fine enough to read as a wall). */
+const TEXT_LAYER_STEP = 0.4;
+/** Most side layers one label gets. */
+const MAX_TEXT_LAYERS = 32;
+/**
+ * sRGB factor on the side colour. Read off the Bird's Eye Scene export
+ * (`gt/sa-014.webp`): white letters show walls around (164, 172, 175) under
+ * a front face reading (245, 248, 249).
+ */
+const TEXT_SIDE_SHADE = 0.69;
+function shadeHex(hex, factor) {
+    const match = /^#?([0-9a-f]{6})$/iu.exec(hex.trim());
+    if (!match) {
+        return hex;
+    }
+    const n = Number.parseInt(match[1], 16);
+    const channel = (shift) => Math.round(((n >> shift) & 255) * factor)
+        .toString(16)
+        .padStart(2, '0');
+    return `#${channel(16)}${channel(8)}${channel(0)}`;
+}
+/**
+ * The stacked layers for an extruded label, or `undefined` when the label is
+ * flat (no `extrusion`).
+ */
+function smartArt3DTextLayers(block) {
+    const depth = block.extrusion ?? 0;
+    if (!(depth > 0)) {
+        return undefined;
+    }
+    const count = Math.max(1, Math.min(MAX_TEXT_LAYERS, Math.ceil(depth / TEXT_LAYER_STEP)));
+    const sideZ = [];
+    for (let i = 0; i < count; i++) {
+        sideZ.push(block.z + (depth * i) / count);
+    }
+    return {
+        sideZ,
+        frontZ: block.z + depth,
+        sideColor: shadeHex(block.extrusionColor ?? block.color, TEXT_SIDE_SHADE),
+    };
+}
+
+/**
+ * Planes showing `block` at each of `zs` (sharing one texture, geometry and
+ * material).
+ */
+function textPlanes(three, mesh, block, zs, light, disposables) {
+    const built = zs.length > 0 ? buildTextBlockTexture(three, block) : null;
+    if (!built) {
+        return [];
+    }
+    const geometry = new three.PlaneGeometry(built.worldWidth, built.worldHeight);
+    const material = new three.MeshBasicMaterial({
+        map: built.texture,
+        transparent: true,
+        depthWrite: false,
+    });
+    // The rig's tint is a linear factor, like the solids' vertex colours.
+    material.color.setRGB(light.tint[0], light.tint[1], light.tint[2]);
+    disposables.push(built.texture, geometry, material);
+    return zs.map((z) => {
+        const plane = new three.Mesh(geometry, material);
+        // Text blocks carry world positions; the group sits at the mesh position.
+        plane.position.set(block.x - mesh.position.x, block.y - mesh.position.y, z - mesh.position.z);
+        return plane;
+    });
+}
+/** Add the lit label (flat or extruded) of `mesh` to `group`. */
+function buildLitTextObject(three, mesh, group, light, disposables) {
+    const block = mesh.textBlock;
+    if (!block) {
+        return;
+    }
+    const layers = smartArt3DTextLayers(block);
+    const planes = [
+        ...(layers
+            ? textPlanes(three, mesh, { ...block, color: layers.sideColor }, layers.sideZ, light, disposables)
+            : []),
+        ...textPlanes(three, mesh, block, [layers?.frontZ ?? block.z], light, disposables),
+    ];
+    for (const plane of planes) {
+        group.add(plane);
+    }
+}
+
+/** Width of the 1D gradient lookup texture. */
+const GRADIENT_TEXELS = 256;
+/** Append a triangulated planar cap to a triangle list. */
+function appendCap(three, out, cap) {
+    if (cap.ring.length < 3) {
+        return;
+    }
+    const contour = cap.ring.map((p) => new three.Vector2(p.x, p.y));
+    const holes = cap.holes.map((hole) => hole.map((p) => new three.Vector2(p.x, p.y)));
+    const all = [...contour, ...holes.flat()];
+    for (const face of three.ShapeUtils.triangulateShape(contour, holes)) {
+        for (const index of face) {
+            const p = all[index];
+            out.positions.push(p.x, p.y, cap.z);
+            out.normals.push(0, 0, cap.facing);
+        }
+    }
+}
+function buildGradientTexture(three, gradient) {
+    if (typeof document === 'undefined') {
+        return null;
+    }
+    const canvas = document.createElement('canvas');
+    canvas.width = GRADIENT_TEXELS;
+    canvas.height = 1;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        return null;
+    }
+    const paint = ctx.createLinearGradient(0, 0, GRADIENT_TEXELS, 0);
+    for (const stop of gradient.stops) {
+        paint.addColorStop(stop.offset, stop.color);
+    }
+    ctx.fillStyle = paint;
+    ctx.fillRect(0, 0, GRADIENT_TEXELS, 1);
+    const texture = new three.CanvasTexture(canvas);
+    texture.colorSpace = three.SRGBColorSpace;
+    texture.wrapS = three.ClampToEdgeWrapping;
+    texture.needsUpdate = true;
+    return texture;
+}
+function buildPart(three, part, light, eye, disposables) {
+    const { positions, normals } = part.triangles;
+    if (positions.length === 0) {
+        return null;
+    }
+    const gradient = part.gradient;
+    const flatColor = hexToRgb(part.color);
+    const baseAt = (p) => (gradient ? smartArt3DGradientColor(gradient, p) : flatColor);
+    const geometry = new three.BufferGeometry();
+    geometry.setAttribute('position', new three.Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('color', new three.BufferAttribute(shadeSmartArt3DVertices(positions, normals, baseAt, light, eye), 3));
+    const texture = gradient ? buildGradientTexture(three, gradient) : null;
+    if (gradient && texture) {
+        const uv = [];
+        for (let i = 0; i < positions.length; i += 3) {
+            uv.push(smartArt3DGradientCoordinate({ x: positions[i], y: positions[i + 1] }, gradient), 0.5);
+        }
+        geometry.setAttribute('uv', new three.Float32BufferAttribute(uv, 2));
+        disposables.push(texture);
+    }
+    const material = new three.MeshBasicMaterial({
+        color: texture ? '#ffffff' : part.color,
+        map: texture,
+        vertexColors: true,
+        side: three.DoubleSide,
+        transparent: part.opacity < 1,
+        opacity: part.opacity,
+    });
+    disposables.push(geometry, material);
+    return new three.Mesh(geometry, material);
+}
+/**
+ * Build the complete `Object3D` for one lit mesh (in diagram space; a scene
+ * camera's rotation is applied by the caller's parent group).
+ *
+ * @param eye - a perspective scene camera's position in diagram space.
+ */
+function buildLitMeshObject(three, mesh, light, eye) {
+    const localEye = eye
+        ? { x: eye.x - mesh.position.x, y: eye.y - mesh.position.y, z: eye.z - mesh.position.z }
+        : undefined;
+    const disposables = [];
+    const group = new three.Group();
+    group.position.set(mesh.position.x, mesh.position.y, mesh.position.z);
+    if (!mesh.fillNone && mesh.outline.length >= 3) {
+        const holes = mesh.holes ?? [];
+        const geometry = mesh.solid
+            ? buildSmartArt3DSolidGeometry(mesh.outline, holes, mesh.solid)
+            : undefined;
+        const body = geometry?.body ?? { positions: [], normals: [] };
+        appendCap(three, body, geometry?.frontCap ?? { ring: toCcwRing(mesh.outline), holes, z: 0, facing: 1 });
+        const sides = geometry?.sides ?? { positions: [], normals: [] };
+        if (geometry?.backCap) {
+            appendCap(three, sides, geometry.backCap);
+        }
+        const contour = { positions: [], normals: [] };
+        for (const cap of geometry?.contourCaps ?? []) {
+            appendCap(three, contour, cap);
+        }
+        const parts = [
+            { triangles: body, color: mesh.fill, gradient: mesh.gradient, opacity: mesh.opacity },
+            {
+                triangles: sides,
+                color: mesh.solid?.extrusionColor ?? mesh.fill,
+                opacity: mesh.opacity,
+            },
+            {
+                triangles: contour,
+                color: mesh.solid?.contourColor ?? mesh.fill,
+                opacity: mesh.opacity,
+            },
+        ];
+        for (const part of parts) {
+            const built = buildPart(three, part, light, localEye, disposables);
+            if (built) {
+                if (mesh.opacity < 1) {
+                    // A translucent fill (Basic Venn): the whole solid shows through.
+                    const material = built.material;
+                    material.transparent = true;
+                    material.opacity = mesh.opacity;
+                }
+                group.add(built);
+            }
+        }
+    }
+    for (const line of buildStrokeLines(three, mesh, disposables)) {
+        group.add(line);
+    }
+    buildLitTextObject(three, mesh, group, light, disposables);
+    return { group, disposables };
+}
+
+/** Orthographic camera distance from the origin along +z (near/far only). */
+const ORTHO_DISTANCE = 1000;
+/** Half-extents of the view frustum at z = 0, letterboxed to the view's aspect. */
+function frameHalfExtents(bounds, size) {
+    const halfW = Math.max(1, bounds.width) / 2;
+    const halfH = Math.max(1, bounds.height) / 2;
+    const aspect = Math.max(1, size.pixelWidth) / Math.max(1, size.pixelHeight);
+    const fitHalfH = Math.max(halfH, halfW / aspect);
+    return { halfW: fitHalfH * aspect, halfH: fitHalfH };
+}
+/** The camera for a model, framed for `size`. */
+function buildSmartArtViewCamera(three, bounds, sceneCamera, size) {
+    let camera;
+    if (sceneCamera?.projection === 'perspective') {
+        const distance = Math.max(1, sceneCamera.distance);
+        camera = new three.PerspectiveCamera(30, 1, distance / 20, distance * 20);
+        camera.position.set(0, 0, distance);
+    }
+    else {
+        camera = new three.OrthographicCamera(-1, 1, 1, -1, -ORTHO_DISTANCE * 2, ORTHO_DISTANCE * 2);
+        camera.position.set(0, 0, ORTHO_DISTANCE);
+    }
+    camera.zoom = sceneCamera?.zoom ?? 1;
+    camera.lookAt(0, 0, 0);
+    fitSmartArtViewCamera(camera, bounds, size);
+    return camera;
+}
+/** Re-frame a camera from {@link buildSmartArtViewCamera} for a new view size. */
+function fitSmartArtViewCamera(camera, bounds, size) {
+    const { halfW, halfH } = frameHalfExtents(bounds, size);
+    if ('isPerspectiveCamera' in camera && camera.isPerspectiveCamera) {
+        camera.aspect = halfW / halfH;
+        camera.fov = (2 * Math.atan(halfH / camera.position.length()) * 180) / Math.PI;
+    }
+    else {
+        const ortho = camera;
+        ortho.left = -halfW;
+        ortho.right = halfW;
+        ortho.top = halfH;
+        ortho.bottom = -halfH;
+    }
+    camera.updateProjectionMatrix();
+}
+
+/**
+ * Project the corners of every mesh's bounding box through `camera` (with no
+ * view offset) and measure how far they reach past the element box.
+ */
+function measureOverflow(three, root, camera) {
+    root.updateMatrixWorld(true);
+    camera.updateMatrixWorld(true);
+    const points = [];
+    const corner = new three.Vector3();
+    root.traverse((object) => {
+        const geometry = object.geometry;
+        if (!geometry?.getAttribute?.('position')) {
+            return;
+        }
+        if (!geometry.boundingBox) {
+            geometry.computeBoundingBox();
+        }
+        const box = geometry.boundingBox;
+        if (!box || box.isEmpty()) {
+            return;
+        }
+        for (let i = 0; i < 8; i++) {
+            corner
+                .set(i & 1 ? box.max.x : box.min.x, i & 2 ? box.max.y : box.min.y, i & 4 ? box.max.z : box.min.z)
+                .applyMatrix4(object.matrixWorld)
+                .project(camera);
+            points.push({ x: corner.x, y: corner.y });
+        }
+    });
+    return threeViewOverflowFromNdc(points);
+}
+/**
+ * Frame `camera` for the element box plus the diagram's overflow, and return
+ * that overflow. `turned` is false for a face-on diagram, which always fits
+ * its box (no overflow is measured).
+ */
+function frameSmartArtOverflow(three, root, camera, size, turned) {
+    camera.clearViewOffset();
+    if (!turned) {
+        return NO_THREE_VIEW_OVERFLOW;
+    }
+    const overflow = measureOverflow(three, root, camera);
+    if (hasThreeViewOverflow(overflow)) {
+        const offset = overflowViewOffset(size, overflow);
+        camera.setViewOffset(offset.fullWidth, offset.fullHeight, offset.x, offset.y, offset.width, offset.height);
+    }
+    return overflow;
+}
+
+/**
+ * `<pptx-three-view>` scene module for 3D SmartArt.
+ *
+ * Flat quick styles (Simple Fill, White Outline, Subtle, Moderate, Intense):
+ * every mesh is a zero-depth `ShapeGeometry` face, unlit (`MeshBasicMaterial`),
+ * under a fixed orthographic camera framing the diagram's own viewBox
+ * (`model.bounds`) - the same geometry/fills/text the 2D SVG renderer draws,
+ * built by `render/smartart-3d-drawing-model.ts`.
+ *
+ * Bevel and scene quick styles (`model.styleCategory` `'bevel'`/`'scene'`):
+ * each mesh becomes a lit solid (`lit-mesh-object.ts`: bevel bands,
+ * extrusion, contour, per-vertex shading from the model's light rig). A scene
+ * style also turns the whole diagram by its quick-style camera
+ * (`model.camera`, `view-camera.ts`).
+ *
+ * Must not import `three` at runtime (use `ctx.three`): this module is
+ * reachable from the main barrel through the scene registry.
+ *
+ * @module smartart-3d/view-scene
+ */
+async function mountSmartArt3DView(model, ctx) {
+    const { three } = ctx;
+    const scene = new three.Scene();
+    if (model.background) {
+        scene.background = new three.Color(model.background);
+    }
+    const disposables = [];
+    const lit = model.styleCategory === 'bevel' || model.styleCategory === 'scene';
+    const view = model.camera ? smartArt3DCameraMatrix(model.camera) : undefined;
+    const eye = model.camera ? smartArt3DEyeInDiagram(model.camera) : undefined;
+    const root = new three.Group();
+    if (view) {
+        root.matrixAutoUpdate = false;
+        root.matrix.set(view[0], view[1], view[2], 0, view[3], view[4], view[5], 0, view[6], view[7], view[8], 0, 0, 0, 0, 1);
+    }
+    scene.add(root);
+    for (const mesh of model.meshes) {
+        const built = lit
+            ? buildLitMeshObject(three, mesh, resolveSmartArt3DLightModel(model.lighting, mesh.solid?.material, eye !== undefined), eye)
+            : buildFlatMeshObject(three, mesh);
+        root.add(built.group);
+        disposables.push(...built.disposables);
+    }
+    const camera = buildSmartArtViewCamera(three, model.bounds, model.camera, ctx.size);
+    const authoredPosition = camera.position.clone();
+    // A turned diagram draws past its box as PowerPoint does (view-overflow.ts).
+    let overflow = frameSmartArtOverflow(three, root, camera, ctx.size, Boolean(model.camera));
+    let controls = null;
+    let dampingActive = false;
+    if (ctx.OrbitControls) {
+        controls = new ctx.OrbitControls(camera, ctx.eventTarget);
+        controls.enableDamping = true;
+        controls.enablePan = false;
+        controls.enabled = ctx.interactive;
+        controls.enableRotate = ctx.interactive;
+        controls.enableZoom = ctx.interactive;
+        const onChange = () => {
+            dampingActive = true;
+            ctx.requestRender();
+        };
+        controls.addEventListener('change', onChange);
+    }
+    const resetView = () => {
+        camera.position.copy(authoredPosition);
+        camera.lookAt(0, 0, 0);
+        if (controls) {
+            controls.target.set(0, 0, 0);
+            controls.update();
+        }
+        ctx.requestRender();
+    };
+    const onDoubleClick = () => resetView();
+    ctx.eventTarget.addEventListener('dblclick', onDoubleClick);
+    return {
+        render(renderer) {
+            if (controls) {
+                dampingActive = controls.update();
+            }
+            renderer.render(scene, camera);
+        },
+        resize(size) {
+            fitSmartArtViewCamera(camera, model.bounds, size);
+            overflow = frameSmartArtOverflow(three, root, camera, size, Boolean(model.camera));
+        },
+        overflow() {
+            return overflow;
+        },
+        isAnimating() {
+            return dampingActive;
+        },
+        setInteractive(on) {
+            if (!controls) {
+                return;
+            }
+            controls.enabled = on;
+            controls.enableRotate = on;
+            controls.enableZoom = on;
+            if (!on) {
+                resetView();
+            }
+        },
+        dispose() {
+            ctx.eventTarget.removeEventListener('dblclick', onDoubleClick);
+            controls?.dispose();
+            for (const d of disposables) {
+                d.dispose();
+            }
+        },
+    };
+}
+
+export { mountSmartArt3DView };
+//# sourceMappingURL=pptx-angular-viewer-view-scene-Bn9SJZk9.mjs.map