pptx-angular-viewer 4.24.2 → 4.25.0

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

@@ -1,836 +0,0 @@
-import { a as overflowViewOffset, f as smartArt3DGradientColor, g as resolveSmartArt3DLightModel, h as shadeSmartArt3DVertices, m as hexToRgb, n as hasThreeViewOverflow, p as smartArt3DGradientCoordinate, s as threeViewOverflowFromNdc, t as NO_THREE_VIEW_OVERFLOW, v as smartArt3DCameraMatrix, y as smartArt3DEyeInDiagram } from "./pptx-angular-viewer-view-overflow-BBD8nZlq.mjs";
-const CLEAR_FACE_ALPHA = .2;
-const CLEAR_EDGE_GAIN = 2;
-const CLEAR_EDGE_EXPONENT = 1;
-function isSmartArt3DGlassMaterial(material) {
-	return material === "clear";
-}
-function smartArt3DSurfaceAlpha(material, opacity, facing) {
-	if (!isSmartArt3DGlassMaterial(material)) return opacity;
-	const tilt = 1 - Math.max(0, Math.min(1, facing));
-	const share = CLEAR_FACE_ALPHA + CLEAR_EDGE_GAIN * tilt ** CLEAR_EDGE_EXPONENT;
-	return Math.max(0, Math.min(1, opacity * share));
-}
-function smartArt3DVertexAlphas(positions, normals, material, opacity, eye) {
-	const out = new Float32Array(positions.length / 3);
-	for (let i = 0, v = 0; i < positions.length; i += 3, v++) {
-		let view = {
-			x: 0,
-			y: 0,
-			z: 1
-		};
-		if (eye) {
-			const dx = eye.x - positions[i];
-			const dy = eye.y - positions[i + 1];
-			const dz = eye.z - positions[i + 2];
-			const len = Math.hypot(dx, dy, dz) || 1;
-			view = {
-				x: dx / len,
-				y: dy / len,
-				z: dz / len
-			};
-		}
-		const facing = normals[i] * view.x + normals[i + 1] * view.y + normals[i + 2] * view.z;
-		out[v] = smartArt3DSurfaceAlpha(material, opacity, facing);
-	}
-	return out;
-}
-function orientSmartArt3DTriangles(triangles) {
-	const { positions: p, normals: n } = triangles;
-	for (let t = 0; t + 9 <= p.length; t += 9) {
-		const ux = p[t + 3] - p[t];
-		const uy = p[t + 4] - p[t + 1];
-		const uz = p[t + 5] - p[t + 2];
-		const vx = p[t + 6] - p[t];
-		const vy = p[t + 7] - p[t + 1];
-		const vz = p[t + 8] - p[t + 2];
-		const cx = uy * vz - uz * vy;
-		const cy = uz * vx - ux * vz;
-		const cz = ux * vy - uy * vx;
-		const nx = n[t] + n[t + 3] + n[t + 6];
-		const ny = n[t + 1] + n[t + 4] + n[t + 7];
-		const nz = n[t + 2] + n[t + 5] + n[t + 8];
-		if (cx * nx + cy * ny + cz * nz < 0) for (const arr of [p, n]) for (let c = 0; c < 3; c++) {
-			const b = arr[t + 3 + c];
-			arr[t + 3 + c] = arr[t + 6 + c];
-			arr[t + 6 + c] = b;
-		}
-	}
-}
-function isSmartArt3DTranslucentMesh(mesh) {
-	return !mesh.fillNone && (mesh.opacity < 1 || isSmartArt3DGlassMaterial(mesh.solid?.material));
-}
-function smartArt3DGlassLightModel(model) {
-	return {
-		...model,
-		ambient: 1,
-		diffuse: 0
-	};
-}
-const SUPERSAMPLE = 3;
-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";
-	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;
-		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;
-	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
-	};
-}
-const STROKE_Z_LIFT = .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;
-}
-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);
-}
-function buildStrokeLines(three, mesh, disposables) {
-	if (mesh.strokeWidth <= 0 || mesh.stroke === "transparent") return [];
-	const material = new three.LineBasicMaterial({ color: mesh.stroke });
-	disposables.push(material);
-	return [mesh.outline, ...mesh.holes ?? []].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);
-	});
-}
-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);
-	plane.position.set(mesh.textBlock.x - mesh.position.x, mesh.textBlock.y - mesh.position.y, mesh.textBlock.z - mesh.position.z);
-	group.add(plane);
-}
-function buildFlatMeshObject(three, mesh) {
-	const disposables = [];
-	const group = new three.Group();
-	group.position.set(mesh.position.x, mesh.position.y, mesh.position.z);
-	const fill = buildFlatFill(three, mesh, buildShape(three, mesh), 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
-	};
-}
-const EPSILON = 1e-6;
-const MITER_LIMIT = 4;
-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;
-}
-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;
-}
-function toCcwRing(points) {
-	const ring = cleanRing(points);
-	return ringSignedArea(ring) < 0 ? ring.reverse() : ring;
-}
-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
-		};
-	});
-}
-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(.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
-		};
-	});
-}
-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])]);
-}
-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 = {
-	circle: () => sampleCurve((u) => ({
-		s: 1 - Math.cos(u * QUARTER),
-		t: Math.sin(u * QUARTER)
-	})),
-	convex: () => sampleCurve((u) => ({
-		s: u,
-		t: Math.sin(u * QUARTER)
-	})),
-	softRound: () => sampleCurve((u) => ({
-		s: u,
-		t: 1 - (1 - u) * (1 - u)
-	})),
-	relaxedInset: () => sampleCurve((u) => ({
-		s: u,
-		t: u * u * (3 - 2 * u) - .3 * Math.sin(Math.PI * u) * (1 - u)
-	})),
-	divot: () => sampleCurve((u) => ({
-		s: u,
-		t: u - .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: .3,
-			t: .75
-		},
-		{
-			s: 1,
-			t: 1
-		}
-	],
-	hardEdge: () => [
-		{
-			s: 0,
-			t: 0
-		},
-		{
-			s: .2,
-			t: .9
-		},
-		{
-			s: 1,
-			t: 1
-		}
-	],
-	cross: () => [
-		{
-			s: 0,
-			t: 0
-		},
-		{
-			s: .5,
-			t: 1
-		},
-		{
-			s: 1,
-			t: 1
-		}
-	],
-	riblet: () => [
-		{
-			s: 0,
-			t: 0
-		},
-		{
-			s: .33,
-			t: 1
-		},
-		{
-			s: .66,
-			t: .5
-		},
-		{
-			s: 1,
-			t: 1
-		}
-	],
-	artDeco: () => [
-		{
-			s: 0,
-			t: 0
-		},
-		{
-			s: .25,
-			t: .5
-		},
-		{
-			s: .5,
-			t: .5
-		},
-		{
-			s: .75,
-			t: 1
-		},
-		{
-			s: 1,
-			t: 1
-		}
-	]
-};
-function getSmartArtBevelProfile(profile) {
-	return (profile && PROFILES[profile] || PROFILES.circle)();
-}
-const CONTOUR_Z_LIFT = .05;
-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
-	];
-}
-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);
-}
-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];
-}
-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
-			}
-		]);
-	}
-}
-function buildSmartArt3DSolidGeometry(outline, holes, solid) {
-	const ring = toCcwRing(outline);
-	const body = emptyTriangles();
-	const sides = emptyTriangles();
-	const zShoulder = -(solid.bevelTop?.height ?? 0);
-	const zBackShoulder = zShoulder - solid.extrusion;
-	const zBack = zBackShoulder - (solid.bevelBottom?.height ?? 0);
-	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
-	};
-}
-const TEXT_LAYER_STEP = .4;
-const MAX_TEXT_LAYERS = 32;
-const TEXT_SIDE_SHADE = .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)}`;
-}
-function smartArt3DTextLayers(block) {
-	const depth = block.extrusion ?? 0;
-	if (!(depth > 0)) return;
-	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)
-	};
-}
-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
-	});
-	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);
-		plane.position.set(block.x - mesh.position.x, block.y - mesh.position.y, z - mesh.position.z);
-		return plane;
-	});
-}
-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);
-}
-const LABEL_RENDER_ORDER = 3;
-const GRADIENT_TEXELS = 256;
-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 withAlpha(rgb, alpha) {
-	const out = new Float32Array(alpha.length * 4);
-	for (let v = 0; v < alpha.length; v++) {
-		out.set(rgb.subarray(v * 3, v * 3 + 3), v * 4);
-		out[v * 4 + 3] = alpha[v];
-	}
-	return out;
-}
-function buildPart(three, part, light, eye, disposables) {
-	if (part.triangles.positions.length === 0) return null;
-	const glass = isSmartArt3DGlassMaterial(part.material);
-	const translucent = part.opacity < 1 || glass;
-	if (translucent) orientSmartArt3DTriangles(part.triangles);
-	const { positions, normals } = part.triangles;
-	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));
-	const shading = shadeSmartArt3DVertices(positions, normals, baseAt, glass ? smartArt3DGlassLightModel(light) : light, eye);
-	geometry.setAttribute("color", glass ? new three.BufferAttribute(withAlpha(shading, smartArt3DVertexAlphas(positions, normals, part.material, part.opacity, eye)), 4) : new three.BufferAttribute(shading, 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), .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: translucent ? three.FrontSide : three.DoubleSide,
-		transparent: translucent,
-		opacity: glass ? 1 : part.opacity,
-		depthWrite: !translucent
-	});
-	disposables.push(geometry, material);
-	return new three.Mesh(geometry, material);
-}
-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
-	} : void 0;
-	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) : void 0;
-		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 material = mesh.solid?.material;
-		[
-			{
-				triangles: body,
-				color: mesh.fill,
-				gradient: mesh.gradient,
-				opacity: mesh.opacity,
-				material
-			},
-			{
-				triangles: sides,
-				color: mesh.solid?.extrusionColor ?? mesh.fill,
-				opacity: mesh.opacity,
-				material
-			},
-			{
-				triangles: contour,
-				color: mesh.solid?.contourColor ?? mesh.fill,
-				opacity: mesh.opacity
-			}
-		].forEach((part, order) => {
-			const built = buildPart(three, part, light, localEye, disposables);
-			if (built) {
-				built.renderOrder = order;
-				group.add(built);
-			}
-		});
-	}
-	for (const line of buildStrokeLines(three, mesh, disposables)) group.add(line);
-	const labelsFrom = group.children.length;
-	buildLitTextObject(three, mesh, group, light, disposables);
-	for (const label of group.children.slice(labelsFrom)) label.renderOrder = LABEL_RENDER_ORDER;
-	return {
-		group,
-		disposables
-	};
-}
-const ORTHO_DISTANCE = 1e3;
-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
-	};
-}
-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, -2e3, 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;
-}
-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();
-}
-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);
-}
-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;
-}
-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) : void 0;
-	const eye = model.camera ? smartArt3DEyeInDiagram(model.camera) : void 0;
-	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);
-	model.meshes.forEach((mesh, index) => {
-		const built = lit ? buildLitMeshObject(three, mesh, resolveSmartArt3DLightModel(model.lighting, mesh.solid?.material, eye !== void 0, model.camera !== void 0), eye) : buildFlatMeshObject(three, mesh);
-		if (lit && isSmartArt3DTranslucentMesh(mesh)) built.group.renderOrder = index + 1;
-		root.add(built.group);
-		disposables.push(...built.disposables);
-	});
-	const camera = buildSmartArtViewCamera(three, model.bounds, model.camera, ctx.size);
-	let overflow = frameSmartArtOverflow(three, root, camera, ctx.size, Boolean(model.camera));
-	return {
-		render(renderer) {
-			renderer.render(scene, camera);
-		},
-		resize(size) {
-			fitSmartArtViewCamera(camera, model.bounds, size);
-			overflow = frameSmartArtOverflow(three, root, camera, size, Boolean(model.camera));
-		},
-		overflow() {
-			return overflow;
-		},
-		dispose() {
-			for (const d of disposables) d.dispose();
-		}
-	};
-}
-export { mountSmartArt3DView };
-
-//# sourceMappingURL=pptx-angular-viewer-view-scene-htTUkvvA.mjs.map