diff --git a/prototypes/project-cube-orbit/.gitignore b/prototypes/project-cube-orbit/.gitignore new file mode 100644 index 0000000000..967037f2aa --- /dev/null +++ b/prototypes/project-cube-orbit/.gitignore @@ -0,0 +1,40 @@ +# See https://help.github.com/articles/ignoring-files/ for more about ignoring files. + +# dependencies +/node_modules +/.pnp +.pnp.* +.yarn/* +!.yarn/patches +!.yarn/plugins +!.yarn/releases +!.yarn/versions + +# testing +/coverage + +# next.js +/.next/ +/.vinext/ +/out/ + +# misc +.DS_Store +*.pem + +# debug +npm-debug.log* +yarn-debug.log* +yarn-error.log* +.pnpm-debug.log* + +# env files (can opt-in for committing if needed) +.env* + +# vercel +.vercel + +/dist/ +/.wrangler/ +/outputs/ +/work/ diff --git a/prototypes/project-cube-orbit/README.md b/prototypes/project-cube-orbit/README.md new file mode 100644 index 0000000000..8a18d4d1ad --- /dev/null +++ b/prototypes/project-cube-orbit/README.md @@ -0,0 +1,21 @@ +# Buzz Project Orbit + +An isolated interaction prototype for exploring project cubes and task noodles +in Buzz. It reuses the Berd project cube renderer, model, textures, and agent +avatars. + +The prototype includes: + +- Manual 3D cube rotation with noodles that adapt to the visible cube edges. +- Draggable task noodles and task detail interactions. +- A pannable multi-project canvas. +- A swipeable Projects view with glass task cards and expandable task details. + +## Run locally + +```bash +npm install +npm run dev +``` + +Open the local URL printed by Vite. Use `npm run build` for a production build. diff --git a/prototypes/project-cube-orbit/app/berd-project-cube/ProjectArtifactRenderer.tsx b/prototypes/project-cube-orbit/app/berd-project-cube/ProjectArtifactRenderer.tsx new file mode 100644 index 0000000000..dfd55421f8 --- /dev/null +++ b/prototypes/project-cube-orbit/app/berd-project-cube/ProjectArtifactRenderer.tsx @@ -0,0 +1,2125 @@ +import { + Suspense, + useCallback, + type ComponentRef, + type MutableRefObject, + type PointerEvent as ReactPointerEvent, + type RefObject, + useEffect, + useMemo, + useRef, + useState, +} from "react"; +import { + Canvas, + type ThreeEvent, + useFrame, + useThree, +} from "@react-three/fiber"; +import { + Environment, + MeshTransmissionMaterial, + OrbitControls, + useGLTF, + useTexture, +} from "@react-three/drei"; +import * as THREE from "three"; +import { cn } from "./cn"; +import { PROJECT_ARTIFACT_CUBE_MODEL_URL } from "./assets"; +import { + applyProjectArtifactCubeTexture, + disposeProjectArtifactCubeMaterials, +} from "./projectArtifactThreeResources"; +import { useRenderWindowVisible } from "./renderVisibility"; +import type { + ProjectArtifactContentMode, + ProjectArtifactProjection, + ProjectArtifactRendererProps, + ProjectArtifactState, +} from "./types"; + +interface CubeGltf { + nodes: Record; +} + +interface CameraAngles { + azimuth: number; + polar: number; +} + +interface ArtifactRuntimeState { + clickPulse: number; + contentTransition: number; + cursorPosition: { x: number; y: number }; + dragVelocity: number; + imageIndex: number; + isDragging: boolean; + isHovered: boolean; + isIdle: boolean; + isPointerDown: boolean; + isTransitioning: boolean; + lastInteractionTime: number; +} + +type ArtifactRuntimeRef = MutableRefObject; +type CameraAnglesRef = MutableRefObject; +type TextureList = THREE.Texture[]; +type CubePointerEvent = ThreeEvent; + +interface TransmissionMaterialHandle { + anisotropy: number; + attenuationColor?: THREE.Color; + chromaticAberration: number; + color?: THREE.Color; + distortion: number; + distortionScale: number; + envMapIntensity: number; + iridescence: number; + iridescenceIOR: number; + roughness: number; + thickness: number; +} + +type OrbitControlsHandle = ComponentRef; + +const CUBE_UNIFORM_SIZE = 5; +const IDLE_THRESHOLD_MS = 30_000; +const SLEEP_THRESHOLD_MS = 300_000; +const CUBE_POINTER_CLICK_PX = 10; +const CUBE_POINTER_CLICK_MS = 500; +const CLICK_VISUAL_DURATION = 1.1; +const VISUAL_READY_FRAME_DELAY = 2; +const TILE_VISUAL_READY_FRAME_DELAY = 3; + +/** Persists across Home navigations so tile cubes skip the first-load fade on return. */ +let projectArtifactTileHasRevealed = false; + +const MATERIAL_ANIM = { + roughness: { min: 0.02, max: 0.075, speed: 2.2 }, + thickness: { min: 0.3, max: 0.6, speed: 0.4 }, + chromaticAberration: { min: 0, max: 0.03, speed: 1 }, + distortion: { min: 0, max: 0, speed: 1 }, + distortionScale: { min: 0.05, max: 0.4, speed: 1 }, + anisotropy: { min: 0, max: 0.3, speed: 1 }, + iridescence: { min: 0, max: 0, speed: 1 }, + iridescenceIOR: { min: 1, max: 1, speed: 1 }, +}; + +const SCENE_ANIM = { + baseTiltAmplitude: 1, + baseTiltSpeed: 1, + breathingAmplitude: 0.4, + breathingSpeed: 0.3, + clickPulseStrength: 1, + contentMicroDriftSpeed: 3, + contentMicroDriftX: 2.05, + contentMicroDriftY: 5, + contentMicroDriftZ: 3, + dragMomentumLag: 2, + floatingBobAmplitude: 1, + floatingBobSpeed: 1, + gentleDriftAmplitude: 0.7, + gentleDriftSpeed: 1, + idleFrostAmount: 1, + imageCycleDuration: 10, + innerCubeRotationSpeed: 0.6, + scrollParallax: 1, + uvDriftSpeed: 1, +}; + +const EFFECTS = { + bloomBoost: 0.5, + dofBokehScalePreview: 34, + dofBokehScaleTile: 18, + dofFocalLength: 0.25, + envIntensity: 0.5, + envMapIntensity: 1, + iridescenceBoost: 0.1, + lensDistortion: -0.05, + roughnessBoost: -0.05, + saturate: 0.9, + vignetteAmountPreview: 0.06, + vignetteAmountTile: 0.1, +}; + +const CANVAS_CAMERA = { + preview: { + position: [10.8, 12.6, 10.8] as const, + fov: 35, + }, + // Slightly closer than preview so the cube reads large in widgets, with headroom so + // glass/refraction and idle motion are not clipped by the canvas bounds. + tile: { + position: [7.1, 8.25, 7.1] as const, + fov: 36, + }, +} as const; + +function getCanvasCamera( + variant: NonNullable, + distanceScale = 1, +) { + const config = + variant === "tile" ? CANVAS_CAMERA.tile : CANVAS_CAMERA.preview; + return { + position: [ + config.position[0] * distanceScale, + config.position[1] * distanceScale, + config.position[2] * distanceScale, + ] as [number, number, number], + fov: config.fov, + near: 1, + far: 100, + }; +} + +const NUM_PLANES = 6; +const PLANE_SIZE = 4.2; +const STACK_DEPTH = 3.5; +const PLANE_OPACITY = 0.9; +const PLANE_FADE_DURATION = 3; +const PLANE_CASCADE_OFFSET = 0.15; +const PLANE_CORNER_RADIUS = 0.073; +const INNER_CUBE_SIZE = 7.8; +const SPHERE_RADIUS = 4.5; +const CONTENT_FADE_DURATION = 1.5; + +const tempVecA = new THREE.Vector3(); +const tempVecB = new THREE.Vector3(); +const tempVecC = new THREE.Vector3(); +const tempQuat = new THREE.Quaternion(); + +const roundedPlaneVertexShader = /* glsl */ ` + varying vec2 vUv; + void main() { + vUv = uv; + gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); + } +`; + +const roundedPlaneFragmentShader = /* glsl */ ` + uniform sampler2D uMap; + uniform float uOpacity; + uniform float uRadius; + varying vec2 vUv; + + float roundedBoxSDF(vec2 p, vec2 b, float r) { + vec2 d = abs(p) - b + r; + return length(max(d, 0.0)) - r; + } + + void main() { + vec2 p = vUv - 0.5; + float d = roundedBoxSDF(p, vec2(0.5), uRadius); + if (d > 0.0) discard; + + vec4 texColor = texture2D(uMap, vUv); + gl_FragColor = vec4(texColor.rgb, texColor.a * uOpacity); + } +`; + +const backdropVertexShader = /* glsl */ ` + varying vec3 vLocalPos; + varying vec3 vLocalNormal; + void main() { + vLocalPos = position; + vLocalNormal = normal; + gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); + } +`; + +const backdropFragmentShader = /* glsl */ ` + uniform sampler2D uMap; + uniform sampler2D uMapNext; + uniform float uMix; + uniform float uOpacity; + uniform vec3 uBoxSize; + varying vec3 vLocalPos; + varying vec3 vLocalNormal; + + vec3 blurSample(sampler2D tex, vec2 uv, float radius) { + vec3 col = vec3(0.0); + float total = 0.0; + for (float x = -1.0; x <= 1.0; x += 1.0) { + for (float y = -1.0; y <= 1.0; y += 1.0) { + float w = 1.0 - 0.3 * (abs(x) + abs(y)); + col += texture2D(tex, uv + vec2(x, y) * radius).rgb * w; + total += w; + } + } + return col / total; + } + + void main() { + vec3 blend = abs(vLocalNormal); + blend = pow(blend, vec3(2.0)); + blend /= (blend.x + blend.y + blend.z); + + vec2 uvXY = vLocalPos.xy / (uBoxSize.xy * 0.86) + 0.5; + vec2 uvXZ = vLocalPos.xz / (uBoxSize.xz * 0.86) + 0.5; + vec2 uvYZ = vLocalPos.yz / (uBoxSize.yz * 0.86) + 0.5; + + float blurRadius = 0.7; + vec3 colA_XY = blurSample(uMap, uvXY, blurRadius); + vec3 colA_XZ = blurSample(uMap, uvXZ, blurRadius); + vec3 colA_YZ = blurSample(uMap, uvYZ, blurRadius); + vec3 colorA = colA_XY * blend.z + colA_XZ * blend.y + colA_YZ * blend.x; + + vec3 colB_XY = blurSample(uMapNext, uvXY, blurRadius); + vec3 colB_XZ = blurSample(uMapNext, uvXZ, blurRadius); + vec3 colB_YZ = blurSample(uMapNext, uvYZ, blurRadius); + vec3 colorB = colB_XY * blend.z + colB_XZ * blend.y + colB_YZ * blend.x; + + vec3 color = mix(colorA, colorB, uMix); + float lum = dot(color, vec3(0.299, 0.587, 0.114)); + color = mix(vec3(lum), color, 1.35); + + gl_FragColor = vec4(color, uOpacity); + } +`; + +const flatProjectionVertexShader = /* glsl */ ` + varying vec3 vWorldPos; + void main() { + vWorldPos = (modelMatrix * vec4(position, 1.0)).xyz; + gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); + } +`; + +const flatProjectionFragmentShader = /* glsl */ ` + uniform sampler2D uTexture; + uniform sampler2D uTexture2; + uniform float uMix; + uniform float uOpacity; + uniform vec3 uBoundsMin; + uniform vec3 uBoundsSize; + varying vec3 vWorldPos; + + void main() { + vec2 uv = (vWorldPos.xy - uBoundsMin.xy) / uBoundsSize.xy; + vec4 texA = texture2D(uTexture, uv); + vec4 texB = texture2D(uTexture2, uv); + vec4 color = mix(texA, texB, uMix); + gl_FragColor = vec4(color.rgb, color.a * uOpacity); + } +`; + +interface ImageCycle { + currentIndex: number; + fadeProgress: number; + isFading: boolean; + lastCycleTime: number; + nextCycleVariance: number; + nextIndex: number; + transitionEndTime: number; +} + +function makeRuntime(initialImageIndex: number): ArtifactRuntimeState { + return { + clickPulse: 0, + contentTransition: 1, + cursorPosition: { x: 0, y: 0 }, + dragVelocity: 0, + imageIndex: initialImageIndex, + isDragging: false, + isHovered: false, + isIdle: false, + isPointerDown: false, + isTransitioning: false, + lastInteractionTime: Date.now(), + }; +} + +function makeImageCycle( + initialIndex: number, + textureCount: number, +): ImageCycle { + const normalizedIndex = wrapIndex(initialIndex, textureCount); + return { + currentIndex: normalizedIndex, + fadeProgress: 0, + isFading: false, + lastCycleTime: 0, + nextCycleVariance: (Math.random() - 0.5) * 10, + nextIndex: wrapIndex(normalizedIndex + 1, textureCount), + transitionEndTime: 0, + }; +} + +function wrapIndex(index: number, length: number) { + if (length <= 0) return 0; + return ((index % length) + length) % length; +} + +function initialImageIndexForState( + state: ProjectArtifactState, + imageCount: number, + variant: NonNullable, +) { + if (variant === "tile") return 0; + return wrapIndex(state.seed, imageCount); +} + +function triggerNextImage(cycle: ImageCycle, textureCount: number) { + if (cycle.isFading) return; + cycle.nextIndex = wrapIndex(cycle.currentIndex + 1, textureCount); + cycle.fadeProgress = 0; + cycle.isFading = true; +} + +function advanceImageCycle({ + cycle, + delta, + fadeDuration, + runtime, + textureCount, + time, + totalDuration = fadeDuration, +}: { + cycle: ImageCycle; + delta: number; + fadeDuration: number; + runtime: ArtifactRuntimeState; + textureCount: number; + time: number; + totalDuration?: number; +}) { + if (textureCount <= 0) return; + if (runtime.isTransitioning) cycle.transitionEndTime = time; + const blocked = + runtime.isTransitioning || time - cycle.transitionEndTime < 2.0; + + const cycleDuration = SCENE_ANIM.imageCycleDuration + cycle.nextCycleVariance; + if ( + !blocked && + !cycle.isFading && + time - cycle.lastCycleTime > cycleDuration + ) { + cycle.lastCycleTime = time; + cycle.nextCycleVariance = (Math.random() - 0.5) * 10; + triggerNextImage(cycle, textureCount); + } + + if (cycle.isFading) { + cycle.fadeProgress += delta / totalDuration; + if (cycle.fadeProgress >= 1) { + cycle.fadeProgress = 0; + cycle.isFading = false; + cycle.currentIndex = cycle.nextIndex; + runtime.imageIndex = cycle.currentIndex; + cycle.nextIndex = wrapIndex(cycle.currentIndex + 1, textureCount); + } + } +} + +function smoothstep(value: number) { + return value * value * (3 - 2 * value); +} + +function clamp01(value: number) { + return THREE.MathUtils.clamp(value, 0, 1); +} + +function clickEnvelope(elapsed: number, duration: number) { + if (elapsed < 0 || elapsed > duration) return 0; + const t = clamp01(elapsed / duration); + const eased = Math.sin(t * Math.PI); + return eased * eased; +} + +function recordInteraction(runtimeRef: ArtifactRuntimeRef) { + runtimeRef.current.lastInteractionTime = Date.now(); + runtimeRef.current.isIdle = false; +} + +function wave01(time: number, f1: number, f2: number, offset = 0) { + return ( + (Math.sin(time * f1 + offset) * 0.6 + + Math.sin(time * f2 + offset * 1.3) * 0.4) * + 0.5 + + 0.5 + ); +} + +function animatedMaterialValue( + prop: { min: number; max: number; speed: number }, + time: number, + f1: number, + f2: number, + offset = 0, +) { + if (prop.speed === 0) return prop.min; + const t = wave01(time, f1 * prop.speed, f2 * prop.speed, offset); + return prop.min + (prop.max - prop.min) * t; +} + +function textureAt(textures: TextureList, index: number) { + return textures[wrapIndex(index, textures.length)]; +} + +function useMemoryTextures(imageUrls: string[]) { + const textures = useTexture(imageUrls); + const textureArray = useMemo( + () => (Array.isArray(textures) ? textures : [textures]), + [textures], + ); + + useEffect(() => { + textureArray.forEach((texture) => { + texture.colorSpace = THREE.SRGBColorSpace; + texture.magFilter = THREE.LinearFilter; + texture.minFilter = THREE.LinearFilter; + texture.wrapS = THREE.ClampToEdgeWrapping; + texture.wrapT = THREE.ClampToEdgeWrapping; + texture.needsUpdate = true; + }); + }, [textureArray]); + + return textureArray; +} + +function useMorphedAccentColor(accentColor: string) { + const colorRef = useRef(new THREE.Color(accentColor)); + const targetRef = useRef(new THREE.Color(accentColor)); + + useEffect(() => { + targetRef.current.set(accentColor); + }, [accentColor]); + + useFrame((_, delta) => { + colorRef.current.lerp(targetRef.current, 1 - Math.exp(-delta * 5.4)); + }); + + return colorRef; +} + +function useGlassTint(accentColorRef: MutableRefObject) { + const tintRef = useRef(new THREE.Color("#ffffff")); + + useFrame(() => { + tintRef.current.set("#ffffff").lerp(accentColorRef.current, 0.5); + }); + + return tintRef; +} + +function useStrictModeSafeDisposal( + resource: T, + dispose: (resource: T) => void, +) { + const pendingDisposalRef = useRef<{ + resource: T; + timeoutId: number; + } | null>(null); + + useEffect(() => { + const pendingDisposal = pendingDisposalRef.current; + if (pendingDisposal?.resource === resource) { + window.clearTimeout(pendingDisposal.timeoutId); + pendingDisposalRef.current = null; + } + + return () => { + const timeoutId = window.setTimeout(() => { + if (pendingDisposalRef.current?.resource === resource) { + pendingDisposalRef.current = null; + } + dispose(resource); + }, 0); + pendingDisposalRef.current = { resource, timeoutId }; + }; + }, [dispose, resource]); +} + +function disposeThreeResource(resource: { dispose: () => void }) { + resource.dispose(); +} + +function getSceneBackgroundColor( + accentColor: string, + variant: NonNullable, +) { + const background = new THREE.Color("#f5f5f5"); + if (variant === "preview") { + background.lerp(new THREE.Color(accentColor), 0.14); + } + return `#${background.getHexString()}`; +} + +const TRANSPARENT_BACKGROUND_VARIANTS: readonly NonNullable< + ProjectArtifactRendererProps["variant"] +>[] = ["preview", "tile"]; + +function usesTransparentBackground( + variant: NonNullable, +) { + return TRANSPARENT_BACKGROUND_VARIANTS.includes(variant); +} + +function SceneBackground({ + color, + transparent, +}: { + color: string; + transparent: boolean; +}) { + const gl = useThree((state) => state.gl); + const scene = useThree((state) => state.scene); + + useEffect(() => { + const clearColor = transparent ? "#000000" : color; + scene.background = transparent ? null : new THREE.Color(color); + gl.domElement.style.background = transparent ? "transparent" : color; + gl.setClearColor(clearColor, transparent ? 0 : 1); + gl.setClearAlpha(transparent ? 0 : 1); + + return () => { + if (transparent) scene.background = null; + }; + }, [color, gl, scene, transparent]); + + return null; +} + +function SceneEnvironment({ environmentUrl }: { environmentUrl: string }) { + const ambientRef = useRef(null); + const scene = useThree((state) => state.scene); + + useFrame(() => { + scene.environmentIntensity = EFFECTS.envIntensity; + if (ambientRef.current) { + ambientRef.current.intensity += + (0.4 - ambientRef.current.intensity) * 0.03; + ambientRef.current.color.lerp(new THREE.Color("#f5f0eb"), 0.03); + } + }); + + return ( + <> + + + + ); +} + +function TransparentSceneRender() { + useFrame(({ gl, scene, camera }) => { + gl.render(scene, camera); + }, 1); + + return null; +} + +/** Keeps tile/preview canvases rendering after container resizes (home widget scaling). */ +function CanvasRenderSync({ + layoutEpoch = 0, + onContextRestored, + onNeedsRecovery, +}: { + layoutEpoch?: number; + onContextRestored?: () => void; + onNeedsRecovery?: () => void; +}) { + const gl = useThree((state) => state.gl); + const invalidate = useThree((state) => state.invalidate); + const size = useThree((state) => state.size); + + // biome-ignore lint/correctness/useExhaustiveDependencies: re-invalidate when widget layout or canvas size changes + useEffect(() => { + invalidate(); + }, [invalidate, layoutEpoch, size.height, size.width]); + + useEffect(() => { + if (size.width > 0 && size.height > 0) { + return; + } + + const parent = gl.domElement.parentElement; + if (!parent || parent.clientWidth <= 0 || parent.clientHeight <= 0) { + return; + } + + const timeout = window.setTimeout(() => { + onNeedsRecovery?.(); + }, 120); + + return () => window.clearTimeout(timeout); + }, [gl, onNeedsRecovery, size.height, size.width]); + + useEffect(() => { + const canvas = gl.domElement; + const handleContextLost = (event: Event) => { + event.preventDefault(); + }; + const handleContextRestored = () => { + invalidate(); + onContextRestored?.(); + }; + + canvas.addEventListener("webglcontextlost", handleContextLost); + canvas.addEventListener("webglcontextrestored", handleContextRestored); + return () => { + canvas.removeEventListener("webglcontextlost", handleContextLost); + canvas.removeEventListener("webglcontextrestored", handleContextRestored); + }; + }, [gl, invalidate, onContextRestored]); + + return null; +} + +function StackedPlanesContent({ + runtimeRef, + textures, +}: { + runtimeRef: ArtifactRuntimeRef; + textures: TextureList; +}) { + const groupRef = useRef(null); + const meshARef = useRef([]); + const meshBRef = useRef([]); + const backdropRef = useRef(null); + const antiParallelRot = useRef(0); + const cycleRef = useRef( + makeImageCycle(runtimeRef.current.imageIndex, textures.length), + ); + const planePositions = useMemo(() => { + const positions: number[] = []; + const halfDepth = STACK_DEPTH / 2; + for (let i = 0; i < NUM_PLANES; i += 1) { + positions.push(-halfDepth + (STACK_DEPTH / (NUM_PLANES - 1)) * i); + } + return positions; + }, []); + const uniforms = useRef({ + A: Array.from({ length: NUM_PLANES }, () => ({ + uMap: { value: null as THREE.Texture | null }, + uOpacity: { value: PLANE_OPACITY }, + uRadius: { value: PLANE_CORNER_RADIUS }, + })), + B: Array.from({ length: NUM_PLANES }, () => ({ + uMap: { value: null as THREE.Texture | null }, + uOpacity: { value: 0 }, + uRadius: { value: PLANE_CORNER_RADIUS }, + })), + backdrop: { + uBoxSize: { + value: new THREE.Vector3( + (PLANE_SIZE * 1.56) / 2, + (PLANE_SIZE * 1.56) / 2, + STACK_DEPTH * 1.3, + ), + }, + uMap: { value: null as THREE.Texture | null }, + uMapNext: { value: null as THREE.Texture | null }, + uMix: { value: 0 }, + uOpacity: { value: 1 }, + }, + }); + + useEffect(() => { + const initialTexture = textureAt(textures, runtimeRef.current.imageIndex); + uniforms.current.A.forEach((entry) => { + entry.uMap.value = initialTexture; + }); + uniforms.current.B.forEach((entry) => { + entry.uMap.value = initialTexture; + }); + uniforms.current.backdrop.uMap.value = initialTexture; + uniforms.current.backdrop.uMapNext.value = initialTexture; + }, [runtimeRef, textures]); + + useFrame((frameState, delta) => { + const cycle = cycleRef.current; + const runtime = runtimeRef.current; + const time = frameState.clock.elapsedTime; + advanceImageCycle({ + cycle, + delta, + fadeDuration: PLANE_FADE_DURATION, + runtime, + textureCount: textures.length, + time, + totalDuration: + PLANE_FADE_DURATION + + PLANE_CASCADE_OFFSET * (NUM_PLANES - 1) * PLANE_FADE_DURATION, + }); + + const texCurrent = textureAt(textures, cycle.currentIndex); + const texNext = textureAt(textures, cycle.nextIndex); + for (let i = 0; i < NUM_PLANES; i += 1) { + const meshA = meshARef.current[i]; + const meshB = meshBRef.current[i]; + if (!meshA || !meshB) continue; + const matA = meshA.material as THREE.ShaderMaterial; + const matB = meshB.material as THREE.ShaderMaterial; + const planeOffset = i * PLANE_CASCADE_OFFSET; + const localProgress = cycle.isFading + ? Math.min( + 1, + Math.max( + 0, + (cycle.fadeProgress - planeOffset) / + (1 - PLANE_CASCADE_OFFSET * (NUM_PLANES - 1)), + ), + ) + : 0; + const eased = smoothstep(localProgress); + matA.uniforms.uMap.value = texCurrent; + matB.uniforms.uMap.value = texNext; + matA.uniforms.uOpacity.value = PLANE_OPACITY * (1 - eased); + matB.uniforms.uOpacity.value = PLANE_OPACITY * eased; + } + + if (backdropRef.current) { + const material = backdropRef.current.material as THREE.ShaderMaterial; + const midOffset = ((NUM_PLANES - 1) / 2) * PLANE_CASCADE_OFFSET; + const midProgress = cycle.isFading + ? Math.min( + 1, + Math.max( + 0, + (cycle.fadeProgress - midOffset) / + (1 - PLANE_CASCADE_OFFSET * (NUM_PLANES - 1)), + ), + ) + : 0; + material.uniforms.uMap.value = texCurrent; + material.uniforms.uMapNext.value = texNext; + material.uniforms.uMix.value = smoothstep(midProgress); + } + + if (groupRef.current) { + const cameraPosition = frameState.camera.position; + const worldPos = groupRef.current.getWorldPosition(tempVecA); + tempVecB.copy(cameraPosition).sub(worldPos).normalize(); + tempVecC + .set(0, 0, 1) + .applyQuaternion(groupRef.current.getWorldQuaternion(tempQuat)); + const dotZ = Math.abs(tempVecB.dot(tempVecC)); + const threshold = 0.75; + const maxRotation = 0.35; + let targetRotY = 0; + if (dotZ < threshold) { + const t = 1 - dotZ / threshold; + const crossSign = + Math.sign(tempVecB.x * tempVecC.z - tempVecB.z * tempVecC.x) || 1; + targetRotY = t * t * maxRotation * crossSign; + } + antiParallelRot.current += (targetRotY - antiParallelRot.current) * 0.05; + groupRef.current.rotation.y = antiParallelRot.current; + groupRef.current.position.x = + Math.sin(time * 0.08 * SCENE_ANIM.gentleDriftSpeed) * + 0.15 * + SCENE_ANIM.gentleDriftAmplitude; + groupRef.current.position.y = + Math.cos(time * 0.06 * SCENE_ANIM.gentleDriftSpeed) * + 0.1 * + SCENE_ANIM.gentleDriftAmplitude; + const breatheWave = + Math.sin(time * 1.8 * SCENE_ANIM.breathingSpeed) * 0.6 + + Math.sin(time * 1.14 * SCENE_ANIM.breathingSpeed) * 0.4; + const breathe = + 1 - + 0.075 * SCENE_ANIM.breathingAmplitude + + 0.075 * SCENE_ANIM.breathingAmplitude * breatheWave; + groupRef.current.scale.setScalar(breathe); + } + }); + + return ( + + + + + + {planePositions.map((z, index) => ( + + { + if (element) meshARef.current[index] = element; + }} + > + + + + { + if (element) meshBRef.current[index] = element; + }} + > + + + + + ))} + + ); +} + +function ImageSphereContent({ + runtimeRef, + textures, +}: { + runtimeRef: ArtifactRuntimeRef; + textures: TextureList; +}) { + const groupRef = useRef(null); + const cycleRef = useRef( + makeImageCycle(runtimeRef.current.imageIndex, textures.length), + ); + const material = useMemo( + () => + new THREE.ShaderMaterial({ + depthTest: false, + fragmentShader: flatProjectionFragmentShader, + side: THREE.DoubleSide, + transparent: true, + uniforms: { + uBoundsMin: { + value: new THREE.Vector3( + -SPHERE_RADIUS, + -SPHERE_RADIUS, + -SPHERE_RADIUS, + ), + }, + uBoundsSize: { + value: new THREE.Vector3( + SPHERE_RADIUS * 2, + SPHERE_RADIUS * 2, + SPHERE_RADIUS * 2, + ), + }, + uMix: { value: 0 }, + uOpacity: { value: 0.9 }, + uTexture: { value: null }, + uTexture2: { value: null }, + }, + vertexShader: flatProjectionVertexShader, + }), + [], + ); + + useStrictModeSafeDisposal(material, disposeThreeResource); + + useFrame((frameState, delta) => { + const cycle = cycleRef.current; + const runtime = runtimeRef.current; + advanceImageCycle({ + cycle, + delta, + fadeDuration: CONTENT_FADE_DURATION, + runtime, + textureCount: textures.length, + time: frameState.clock.elapsedTime, + }); + material.uniforms.uTexture.value = textureAt(textures, cycle.currentIndex); + material.uniforms.uTexture2.value = textureAt(textures, cycle.nextIndex); + material.uniforms.uMix.value = cycle.isFading ? cycle.fadeProgress : 0; + + if (groupRef.current) { + const time = frameState.clock.elapsedTime; + const breatheWave = + Math.sin(time * 1.2 * SCENE_ANIM.breathingSpeed) * 0.6 + + Math.sin(time * 0.8 * SCENE_ANIM.breathingSpeed) * 0.4; + const breathe = + 1 - + 0.05 * SCENE_ANIM.breathingAmplitude + + 0.05 * SCENE_ANIM.breathingAmplitude * breatheWave; + groupRef.current.scale.setScalar(breathe); + } + }); + + return ( + + + + + + ); +} + +function InnerCubeContent({ + mode, + runtimeRef, + textures, +}: { + mode: "cube" | "cubeStatic"; + runtimeRef: ArtifactRuntimeRef; + textures: TextureList; +}) { + const groupRef = useRef(null); + const cubeRef = useRef(null); + const cycleRef = useRef( + makeImageCycle(runtimeRef.current.imageIndex, textures.length), + ); + const drifts = useMemo( + () => [ + { sx: 0.02, sy: 0.01 }, + { sx: -0.02, sy: 0.015 }, + { sx: 0.01, sy: 0.02 }, + { sx: -0.01, sy: -0.02 }, + { sx: 0.015, sy: -0.01 }, + { sx: -0.015, sy: 0.01 }, + ], + [], + ); + const materialsA = useMemo( + () => + Array.from( + { length: 6 }, + () => + new THREE.MeshBasicMaterial({ + depthTest: false, + map: textureAt(textures, runtimeRef.current.imageIndex), + opacity: 0.9, + side: THREE.FrontSide, + transparent: true, + }), + ), + [runtimeRef, textures], + ); + const materialsB = useMemo( + () => + Array.from( + { length: 6 }, + () => + new THREE.MeshBasicMaterial({ + depthTest: false, + map: textureAt(textures, runtimeRef.current.imageIndex + 1), + opacity: 0, + side: THREE.FrontSide, + transparent: true, + }), + ), + [runtimeRef, textures], + ); + + const materials = useMemo( + () => [...materialsA, ...materialsB], + [materialsA, materialsB], + ); + useStrictModeSafeDisposal(materials, disposeProjectArtifactCubeMaterials); + + const applyCubeTexture = ( + material: THREE.MeshBasicMaterial, + texture: THREE.Texture, + driftFaceIndex: number, + time: number, + ) => { + const map = applyProjectArtifactCubeTexture({ + cloneForUvTransform: mode === "cubeStatic", + material, + texture, + }); + + if (mode !== "cubeStatic") { + return; + } + + map.wrapS = THREE.RepeatWrapping; + map.wrapT = THREE.RepeatWrapping; + map.offset.x = drifts[driftFaceIndex].sx * time * SCENE_ANIM.uvDriftSpeed; + map.offset.y = drifts[driftFaceIndex].sy * time * SCENE_ANIM.uvDriftSpeed; + }; + + useFrame((frameState, delta) => { + const cycle = cycleRef.current; + const runtime = runtimeRef.current; + const time = frameState.clock.elapsedTime; + advanceImageCycle({ + cycle, + delta, + fadeDuration: CONTENT_FADE_DURATION, + runtime, + textureCount: textures.length, + time, + }); + + const texA = textureAt(textures, cycle.currentIndex); + const texB = textureAt(textures, cycle.nextIndex); + const mix = cycle.isFading ? cycle.fadeProgress : 0; + materialsA.forEach((material, index) => { + applyCubeTexture(material, texA, index, time); + material.opacity = 0.9 * (1 - mix); + }); + materialsB.forEach((material, index) => { + applyCubeTexture(material, texB, index, time); + material.opacity = 0.9 * mix; + }); + + if (cubeRef.current && mode === "cube") { + cubeRef.current.rotation.x += 0.001 * SCENE_ANIM.innerCubeRotationSpeed; + cubeRef.current.rotation.y += 0.002 * SCENE_ANIM.innerCubeRotationSpeed; + } + if (groupRef.current) { + const breatheWave = + Math.sin(time * 1.0 * SCENE_ANIM.breathingSpeed) * 0.6 + + Math.sin(time * 0.7 * SCENE_ANIM.breathingSpeed) * 0.4; + const breathe = + 1 - + 0.07 * SCENE_ANIM.breathingAmplitude + + 0.07 * SCENE_ANIM.breathingAmplitude * breatheWave; + groupRef.current.scale.setScalar(breathe); + } + }); + + return ( + + + + + + + + + + + ); +} + +function MemoryContent({ + mode, + runtimeRef, + textures, +}: { + mode: ProjectArtifactContentMode; + runtimeRef: ArtifactRuntimeRef; + textures: TextureList; +}) { + if (mode === "planes") { + return ; + } + if (mode === "sphere") { + return ; + } + return ( + + ); +} + +function PrototypeCube({ + cameraAnglesRef, + focusSide, + glassTintRef, + mode, + motionImpulse, + runtimeRef, + shellRef, + textures, + variant, +}: { + cameraAnglesRef: CameraAnglesRef; + focusSide: boolean; + glassTintRef: MutableRefObject; + mode: ProjectArtifactContentMode; + motionImpulse: ProjectArtifactRendererProps["motionImpulse"]; + runtimeRef: ArtifactRuntimeRef; + shellRef: MutableRefObject; + textures: TextureList; + variant: NonNullable; +}) { + const groupRef = useRef(null); + const contentRef = useRef(null); + const materialRef = useRef(null); + const { nodes } = useGLTF( + PROJECT_ARTIFACT_CUBE_MODEL_URL, + ) as unknown as CubeGltf; + const geometry = nodes.Cube?.geometry ?? null; + const clickTime = useRef(0); + const pointerDownPos = useRef<{ x: number; y: number } | null>(null); + const pointerDownTime = useRef(0); + const hoverLean = useRef({ x: 0, y: 0 }); + const hoverWarmth = useRef(0); + const proximityEnergy = useRef(0); + const contentLag = useRef({ x: 0, y: 0, z: 0 }); + const contentDrift = useRef({ x: 0, y: 0, z: 0 }); + const hoverSpin = useRef({ x: 0, y: 0 }); + const hoverSpinVelocity = useRef({ x: 0, y: 0 }); + const previousHoverSpin = useRef({ x: 0, y: 0 }); + const focusRotation = useRef({ x: 0, y: 0 }); + const previousFocusRotation = useRef({ x: 0, y: 0 }); + const dragVisualAmount = useRef(0); + const dragVisualPeak = useRef(0); + const scrollOffset = useRef(0); + const idleFrost = useRef(0); + const releaseBounceMat = useRef(0); + const releaseBounceVel = useRef(0); + const lastMotionImpulse = useRef(0); + const wasDragging = useRef(false); + const previousMode = useRef(mode); + const interactive = variant === "preview"; + + useEffect(() => { + if (previousMode.current !== mode) { + runtimeRef.current.contentTransition = 0; + runtimeRef.current.isTransitioning = true; + previousMode.current = mode; + } + }, [mode, runtimeRef]); + + useEffect(() => { + if (variant !== "tile" || !motionImpulse) return; + if (motionImpulse.sequence === lastMotionImpulse.current) return; + + lastMotionImpulse.current = motionImpulse.sequence; + hoverSpinVelocity.current.x = THREE.MathUtils.clamp( + hoverSpinVelocity.current.x + motionImpulse.deltaY * 11.5, + -5, + 5, + ); + hoverSpinVelocity.current.y = THREE.MathUtils.clamp( + hoverSpinVelocity.current.y + motionImpulse.deltaX * 11.5, + -5, + 5, + ); + }, [motionImpulse, variant]); + + useFrame((frameState, delta) => { + const runtime = runtimeRef.current; + const time = frameState.clock.elapsedTime; + const now = Date.now(); + runtime.isIdle = now - runtime.lastInteractionTime > IDLE_THRESHOLD_MS; + const isDormant = now - runtime.lastInteractionTime > SLEEP_THRESHOLD_MS; + + if (runtime.isTransitioning) { + runtime.contentTransition = Math.min( + 1, + runtime.contentTransition + delta / 1.1, + ); + if (runtime.contentTransition >= 1) runtime.isTransitioning = false; + } + + const cursorDist = Math.sqrt( + runtime.cursorPosition.x * runtime.cursorPosition.x + + runtime.cursorPosition.y * runtime.cursorPosition.y, + ); + const targetProximity = runtime.isHovered ? 1 : Math.max(0, 1 - cursorDist); + proximityEnergy.current += + (targetProximity - proximityEnergy.current) * 0.02; + + const attractStrength = interactive ? 0 : 0; + hoverLean.current.x += + (runtime.cursorPosition.x * attractStrength - hoverLean.current.x) * 0.06; + hoverLean.current.y += + (runtime.cursorPosition.y * attractStrength - hoverLean.current.y) * 0.06; + hoverWarmth.current += + ((runtime.isHovered ? 0.6 : 0) - hoverWarmth.current) * 0.03; + + const dragTarget = runtime.isDragging + ? clamp01((runtime.dragVelocity - 0.00025) / 0.004) + : 0; + dragVisualAmount.current += + (dragTarget - dragVisualAmount.current) * (dragTarget > 0 ? 0.18 : 0.08); + const dragAmount = dragVisualAmount.current; + const longPressAmount = dragAmount; + const dragActive = dragAmount > 0.03; + if (dragActive) { + dragVisualPeak.current = Math.max(dragVisualPeak.current, dragAmount); + } + + if (wasDragging.current && !dragActive) { + releaseBounceVel.current = 0.8 * dragVisualPeak.current; + dragVisualPeak.current = 0; + } + wasDragging.current = dragActive; + + const springForce = -25 * releaseBounceMat.current; + const dampForce = -4 * releaseBounceVel.current; + releaseBounceVel.current += (springForce + dampForce) * (1 / 60); + releaseBounceMat.current += releaseBounceVel.current * (1 / 60); + if ( + Math.abs(releaseBounceMat.current) < 0.001 && + Math.abs(releaseBounceVel.current) < 0.001 + ) { + releaseBounceMat.current = 0; + releaseBounceVel.current = 0; + } + + const targetFrost = + runtime.isIdle || isDormant ? 0.8 * SCENE_ANIM.idleFrostAmount : 0; + idleFrost.current += (targetFrost - idleFrost.current) * 0.005; + scrollOffset.current *= 0.95; + if (variant === "tile") { + const spinDelta = Math.min(delta, 1 / 30); + const spring = 8.2; + const damping = 0.965 ** (spinDelta * 60); + hoverSpinVelocity.current.x += -hoverSpin.current.x * spring * spinDelta; + hoverSpinVelocity.current.y += -hoverSpin.current.y * spring * spinDelta; + hoverSpinVelocity.current.x *= damping; + hoverSpinVelocity.current.y *= damping; + hoverSpin.current.x = THREE.MathUtils.clamp( + hoverSpin.current.x + hoverSpinVelocity.current.x * spinDelta, + -0.72, + 0.72, + ); + hoverSpin.current.y = THREE.MathUtils.clamp( + hoverSpin.current.y + hoverSpinVelocity.current.y * spinDelta, + -0.72, + 0.72, + ); + if (Math.abs(hoverSpin.current.x) < 0.0001) hoverSpin.current.x = 0; + if (Math.abs(hoverSpin.current.y) < 0.0001) hoverSpin.current.y = 0; + if (Math.abs(hoverSpinVelocity.current.x) < 0.0001) { + hoverSpinVelocity.current.x = 0; + } + if (Math.abs(hoverSpinVelocity.current.y) < 0.0001) { + hoverSpinVelocity.current.y = 0; + } + } else { + hoverSpin.current.x = 0; + hoverSpin.current.y = 0; + hoverSpinVelocity.current.x = 0; + hoverSpinVelocity.current.y = 0; + previousHoverSpin.current.x = 0; + previousHoverSpin.current.y = 0; + } + + const tileMotionScale = variant === "tile" ? 0.55 : 1; + const bobY = + (Math.sin(time * 0.6 * SCENE_ANIM.floatingBobSpeed) * 0.08 + + Math.sin(time * 0.23 * SCENE_ANIM.floatingBobSpeed) * 0.04) * + SCENE_ANIM.floatingBobAmplitude * + tileMotionScale; + const bobX = + Math.sin(time * 0.4 * SCENE_ANIM.floatingBobSpeed + 1) * + 0.03 * + SCENE_ANIM.floatingBobAmplitude * + tileMotionScale; + + if (shellRef.current) { + shellRef.current.scale.set( + CUBE_UNIFORM_SIZE, + CUBE_UNIFORM_SIZE, + CUBE_UNIFORM_SIZE, + ); + } + + if (contentRef.current) { + const momentumDecay = 0.987; + const momentumGain = 17.5 * SCENE_ANIM.dragMomentumLag; + const maxMomentum = 1.75; + if (Math.abs(runtime.dragVelocity) > 0.001) { + contentLag.current.x += + runtime.dragVelocity * Math.sin(time * 2.3) * momentumGain * 0.016; + contentLag.current.y += + runtime.dragVelocity * Math.cos(time * 1.7) * momentumGain * 0.016; + } + contentLag.current.x = THREE.MathUtils.clamp( + contentLag.current.x, + -maxMomentum, + maxMomentum, + ); + contentLag.current.y = THREE.MathUtils.clamp( + contentLag.current.y, + -maxMomentum, + maxMomentum, + ); + contentLag.current.x *= momentumDecay; + contentLag.current.y *= momentumDecay; + + const driftSpeed = SCENE_ANIM.contentMicroDriftSpeed; + contentDrift.current.x = + (Math.sin(time * 0.17 * driftSpeed + 1.3) * 0.04 + + Math.sin(time * 0.31 * driftSpeed) * 0.02) * + SCENE_ANIM.contentMicroDriftX; + contentDrift.current.y = + (Math.sin(time * 0.13 * driftSpeed + 2.7) * 0.03 + + Math.cos(time * 0.23 * driftSpeed) * 0.02) * + SCENE_ANIM.contentMicroDriftY; + contentDrift.current.z = + (Math.sin(time * 0.11 * driftSpeed + 4.1) * 0.04 + + Math.cos(time * 0.19 * driftSpeed) * 0.02) * + SCENE_ANIM.contentMicroDriftZ; + contentRef.current.rotation.x = + contentLag.current.x + contentDrift.current.x; + contentRef.current.rotation.y = + contentLag.current.y + contentDrift.current.y; + contentRef.current.rotation.z = contentDrift.current.z; + contentRef.current.position.z = + scrollOffset.current * 1.3 * SCENE_ANIM.scrollParallax; + } + + if (materialRef.current) { + const material = materialRef.current; + const energy = 1 + proximityEnergy.current * 0.5; + const bounce = releaseBounceMat.current; + const animatedRoughness = Math.max( + 0, + animatedMaterialValue(MATERIAL_ANIM.roughness, time, 0.16, 0.1) + + idleFrost.current * 0.15 + + EFFECTS.roughnessBoost, + ); + material.roughness = animatedRoughness; + material.thickness = + animatedMaterialValue(MATERIAL_ANIM.thickness, time, 0.44, 0.28, 2) + + bounce * 0.5; + material.chromaticAberration = + animatedMaterialValue( + MATERIAL_ANIM.chromaticAberration, + time, + 0.6, + 0.38, + 3, + ) * + energy + + hoverWarmth.current * 0.03; + material.distortion = + animatedMaterialValue(MATERIAL_ANIM.distortion, time, 0.2, 0.13, 4) * + energy + + Math.abs(bounce) * 0.15; + material.distortionScale = animatedMaterialValue( + MATERIAL_ANIM.distortionScale, + time, + 0.09, + 0.055, + 5, + ); + material.anisotropy = animatedMaterialValue( + MATERIAL_ANIM.anisotropy, + time, + 0.07, + 0.045, + 7, + ); + material.iridescence = + animatedMaterialValue(MATERIAL_ANIM.iridescence, time, 0.065, 0.04, 8) + + hoverWarmth.current * 0.1 + + EFFECTS.iridescenceBoost; + material.iridescenceIOR = animatedMaterialValue( + MATERIAL_ANIM.iridescenceIOR, + time, + 0.04, + 0.025, + 9, + ); + if (longPressAmount > 0.01) { + material.thickness += longPressAmount * 0.25; + material.distortion += longPressAmount * 0.25; + material.iridescence += longPressAmount * 0.05; + } + if (runtime.isTransitioning) { + const transitionPulse = Math.sin(runtime.contentTransition * Math.PI); + material.thickness += transitionPulse * 1.5; + material.roughness += transitionPulse * 0.12; + material.distortion += transitionPulse * 0.15; + material.chromaticAberration += transitionPulse * 0.02; + } + material.envMapIntensity = EFFECTS.envMapIntensity; + if (material.attenuationColor instanceof THREE.Color) { + material.attenuationColor.copy(glassTintRef.current); + } + if (material.color instanceof THREE.Color) { + material.color.copy(glassTintRef.current); + } + } + + if ( + clickTime.current > 0 && + SCENE_ANIM.clickPulseStrength > 0 && + shellRef.current + ) { + const elapsed = performance.now() / 1000 - clickTime.current; + const envelope = clickEnvelope(elapsed, CLICK_VISUAL_DURATION); + if (envelope > 0) { + const pulse = envelope * 0.018 * SCENE_ANIM.clickPulseStrength; + const scale = CUBE_UNIFORM_SIZE * (1 + pulse); + shellRef.current.scale.set(scale, scale, scale); + if (materialRef.current) { + const flash = envelope * SCENE_ANIM.clickPulseStrength; + materialRef.current.chromaticAberration += flash * 0.12; + materialRef.current.distortion += flash * 0.08; + } + } + } + + if (groupRef.current) { + const baseTiltX = + Math.sin(time * 0.15 * SCENE_ANIM.baseTiltSpeed) * + 0.015 * + SCENE_ANIM.baseTiltAmplitude; + const baseTiltZ = + Math.cos(time * 0.12 * SCENE_ANIM.baseTiltSpeed) * + 0.01 * + SCENE_ANIM.baseTiltAmplitude; + const dampFactor = 1 - dragAmount * 0.9; + groupRef.current.rotation.z += + (baseTiltZ * dampFactor - groupRef.current.rotation.z) * 0.03; + + const combinedAngle = + cameraAnglesRef.current.azimuth + groupRef.current.rotation.y; + const wrapped = + (((combinedAngle % (Math.PI / 2)) + Math.PI / 2) % (Math.PI / 2)) - + Math.PI / 4; + const force = -Math.sin(2 * wrapped); + const momentumFade = Math.max(0, 1 - runtime.dragVelocity / 0.003); + const antiFlatStrength = dragActive ? 0 : 0.006 * momentumFade; + const tileSpinX = variant === "tile" ? hoverSpin.current.x : 0; + const tileSpinY = variant === "tile" ? hoverSpin.current.y : 0; + const tileSpinDeltaX = tileSpinX - previousHoverSpin.current.x; + const tileSpinDeltaY = tileSpinY - previousHoverSpin.current.y; + previousHoverSpin.current.x = tileSpinX; + previousHoverSpin.current.y = tileSpinY; + const focusTargetX = focusSide ? -0.1 : 0; + const focusTargetY = focusSide ? 0.68 : 0; + focusRotation.current.x += + (focusTargetX - focusRotation.current.x) * 0.075; + focusRotation.current.y += + (focusTargetY - focusRotation.current.y) * 0.075; + const focusDeltaX = + focusRotation.current.x - previousFocusRotation.current.x; + const focusDeltaY = + focusRotation.current.y - previousFocusRotation.current.y; + previousFocusRotation.current.x = focusRotation.current.x; + previousFocusRotation.current.y = focusRotation.current.y; + + groupRef.current.rotation.y += + force * antiFlatStrength + tileSpinDeltaY + focusDeltaY; + groupRef.current.rotation.x += tileSpinDeltaX + focusDeltaX; + groupRef.current.rotation.x += + (baseTiltX * dampFactor - groupRef.current.rotation.x) * + (variant === "tile" ? 0.045 : 0.03); + + const camera = frameState.camera; + const matrix = camera.matrixWorld.elements; + const leanAmount = variant === "tile" ? 1.1 : 2.1; + const leanX = hoverLean.current.x * leanAmount; + const leanY = hoverLean.current.y * leanAmount; + const targetX = bobX + matrix[0] * leanX + matrix[4] * leanY; + const targetY = 0.25 + bobY + matrix[1] * leanX + matrix[5] * leanY; + const targetZ = matrix[2] * leanX + matrix[6] * leanY; + groupRef.current.position.x += + (targetX - groupRef.current.position.x) * 0.06; + groupRef.current.position.y += + (targetY - groupRef.current.position.y) * 0.06; + groupRef.current.position.z += + (targetZ - groupRef.current.position.z) * 0.06; + } + }); + + useFrame(() => { + if (contentRef.current) contentRef.current.visible = false; + }, 0.5); + + useFrame(() => { + if (contentRef.current) contentRef.current.visible = true; + }, 2); + + const handlePointerDown = (event: CubePointerEvent) => { + if (!interactive) return; + event.stopPropagation(); + pointerDownPos.current = { x: event.clientX, y: event.clientY }; + pointerDownTime.current = performance.now(); + runtimeRef.current.isPointerDown = true; + recordInteraction(runtimeRef); + }; + + const handlePointerUp = (event: CubePointerEvent) => { + if (!interactive || !pointerDownPos.current) return; + event.stopPropagation(); + const dx = event.clientX - pointerDownPos.current.x; + const dy = event.clientY - pointerDownPos.current.y; + const dist = Math.sqrt(dx * dx + dy * dy); + const elapsed = performance.now() - pointerDownTime.current; + pointerDownPos.current = null; + runtimeRef.current.isPointerDown = false; + if (dist < CUBE_POINTER_CLICK_PX && elapsed < CUBE_POINTER_CLICK_MS) { + clickTime.current = performance.now() / 1000; + runtimeRef.current.clickPulse = Date.now(); + recordInteraction(runtimeRef); + } + }; + + const handlePointerOver = () => { + if (!interactive) return; + runtimeRef.current.isHovered = true; + recordInteraction(runtimeRef); + }; + + const handlePointerOut = () => { + if (!interactive) return; + runtimeRef.current.isHovered = false; + runtimeRef.current.isPointerDown = false; + pointerDownPos.current = null; + }; + + return ( + + + {geometry ? null : } + + + + + + + ); +} + +function CubeInteraction({ + cameraAnglesRef, + runtimeRef, +}: { + cameraAnglesRef: CameraAnglesRef; + runtimeRef: ArtifactRuntimeRef; +}) { + const controlsRef = useRef(null); + const prevAzimuth = useRef(0); + const prevPolar = useRef(0); + + useFrame(() => { + if (!controlsRef.current) return; + const controls = controlsRef.current; + const azimuth = controls.getAzimuthalAngle(); + const polar = controls.getPolarAngle(); + cameraAnglesRef.current.azimuth = azimuth; + cameraAnglesRef.current.polar = polar; + const dAzimuth = azimuth - prevAzimuth.current; + const dPolar = polar - prevPolar.current; + const angularVelocity = Math.sqrt(dAzimuth * dAzimuth + dPolar * dPolar); + prevAzimuth.current = azimuth; + prevPolar.current = polar; + + const runtime = runtimeRef.current; + if (runtime.isDragging) { + runtime.dragVelocity = angularVelocity; + } else if (runtime.dragVelocity > 0.0001) { + runtime.dragVelocity *= 0.98; + } else { + runtime.dragVelocity = 0; + } + controls.autoRotate = false; + }); + + return ( + { + runtimeRef.current.isDragging = false; + }} + onStart={() => { + runtimeRef.current.isDragging = true; + recordInteraction(runtimeRef); + }} + rotateSpeed={1.2} + /> + ); +} + +const SILHOUETTE_SAMPLE_INTERVAL = 1 / 60; + +type ScreenPoint = { x: number; y: number }; + +function projectedConvexHull(points: ScreenPoint[]): ScreenPoint[] { + if (points.length <= 3) return points; + const sorted = [...points].sort((a, b) => a.x - b.x || a.y - b.y); + const cross = (origin: ScreenPoint, a: ScreenPoint, b: ScreenPoint) => + (a.x - origin.x) * (b.y - origin.y) - + (a.y - origin.y) * (b.x - origin.x); + const lower: ScreenPoint[] = []; + for (const point of sorted) { + while ( + lower.length >= 2 && + cross(lower[lower.length - 2], lower[lower.length - 1], point) <= 0 + ) { + lower.pop(); + } + lower.push(point); + } + const upper: ScreenPoint[] = []; + for (let index = sorted.length - 1; index >= 0; index -= 1) { + const point = sorted[index]; + while ( + upper.length >= 2 && + cross(upper[upper.length - 2], upper[upper.length - 1], point) <= 0 + ) { + upper.pop(); + } + upper.push(point); + } + lower.pop(); + upper.pop(); + return lower.concat(upper); +} + +function CubeProjectionReporter({ + shellRef, + onCubeProjection, +}: { + shellRef: MutableRefObject; + onCubeProjection?: (projection: ProjectArtifactProjection) => void; +}) { + const lastSampleTimeRef = useRef(Number.NEGATIVE_INFINITY); + const projectedVertexRef = useRef(new THREE.Vector3()); + + useFrame(({ camera, size, clock }) => { + const shell = shellRef.current; + const geometry = shell?.geometry; + if (!shell || !geometry || !onCubeProjection) return; + if ( + clock.elapsedTime - lastSampleTimeRef.current < + SILHOUETTE_SAMPLE_INTERVAL + ) { + return; + } + lastSampleTimeRef.current = clock.elapsedTime; + + shell.updateWorldMatrix(true, false); + const position = geometry.getAttribute("position"); + if (!position) return; + const projectedVertices: ScreenPoint[] = []; + const projectedVertex = projectedVertexRef.current; + for (let index = 0; index < position.count; index += 1) { + projectedVertex + .set(position.getX(index), position.getY(index), position.getZ(index)) + .applyMatrix4(shell.matrixWorld) + .project(camera); + projectedVertices.push({ + x: (projectedVertex.x * 0.5 + 0.5) * size.width, + y: (-projectedVertex.y * 0.5 + 0.5) * size.height, + }); + } + const contour = projectedConvexHull(projectedVertices); + if (contour.length < 3) return; + let minX = Number.POSITIVE_INFINITY; + let minY = Number.POSITIVE_INFINITY; + let maxX = Number.NEGATIVE_INFINITY; + let maxY = Number.NEGATIVE_INFINITY; + for (const point of contour) { + minX = Math.min(minX, point.x); + minY = Math.min(minY, point.y); + maxX = Math.max(maxX, point.x); + maxY = Math.max(maxY, point.y); + } + + onCubeProjection({ + x: minX, + y: minY, + width: maxX - minX, + height: maxY - minY, + contour, + }); + }); + + return null; +} + +function ArtifactScene({ + environmentUrl, + focusSide, + imageUrls, + motionImpulse, + runtimeRef, + state, + variant, + onCubeProjection, +}: { + environmentUrl: string; + focusSide: boolean; + imageUrls: string[]; + motionImpulse: ProjectArtifactRendererProps["motionImpulse"]; + runtimeRef: ArtifactRuntimeRef; + state: ProjectArtifactState; + variant: NonNullable; + onCubeProjection?: (projection: ProjectArtifactProjection) => void; +}) { + const textures = useMemoryTextures(imageUrls); + const shellRef = useRef(null); + const cameraAnglesRef = useRef({ azimuth: 0, polar: 0 }); + const accentColorRef = useMorphedAccentColor(state.accentColor); + const glassTintRef = useGlassTint(accentColorRef); + const backgroundColor = useMemo( + () => getSceneBackgroundColor(state.accentColor, variant), + [state.accentColor, variant], + ); + const hasTransparentBackground = usesTransparentBackground(variant); + + return ( + <> + + + + + + {hasTransparentBackground ? : null} + + ); +} + +function TileResizeRecovery({ + containerRef, + onResize, +}: { + containerRef: RefObject; + onResize: () => void; +}) { + useEffect(() => { + const root = containerRef.current; + if (!root) { + return; + } + + let frame = 0; + const observer = new ResizeObserver(() => { + cancelAnimationFrame(frame); + frame = requestAnimationFrame(() => { + if (root.clientWidth > 0 && root.clientHeight > 0) { + onResize(); + } + }); + }); + observer.observe(root); + + return () => { + cancelAnimationFrame(frame); + observer.disconnect(); + }; + }, [containerRef, onResize]); + + return null; +} + +export function ProjectArtifactRenderer({ + state, + environmentUrl, + imageUrls, + className, + cameraDistanceScale = 1, + focusSide = false, + gestureFreezeActive = false, + motionImpulse, + onGlCanvasReady, + onCubeProjection, + renderPaused = false, + variant = "preview", +}: ProjectArtifactRendererProps) { + const initialImageIndex = initialImageIndexForState( + state, + imageUrls.length, + variant, + ); + const runtimeRef = useRef( + makeRuntime(initialImageIndex), + ); + const containerRef = useRef(null); + const interactive = variant === "preview"; + const isRenderWindowVisible = useRenderWindowVisible(); + const pauseRenderLoop = renderPaused || !isRenderWindowVisible; + const hasTransparentBackground = usesTransparentBackground(variant); + const canvasBackground = useMemo( + () => getSceneBackgroundColor(state.accentColor, variant), + [state.accentColor, variant], + ); + const [contextRecoveryKey, setContextRecoveryKey] = useState(0); + const [layoutEpoch, setLayoutEpoch] = useState(0); + const lastContextRecoveryAtRef = useRef(0); + const requestSoftRecovery = useCallback(() => { + const now = Date.now(); + if (now - lastContextRecoveryAtRef.current < 250) { + return; + } + lastContextRecoveryAtRef.current = now; + setLayoutEpoch((epoch) => epoch + 1); + }, []); + + const requestHardRecovery = useCallback(() => { + const now = Date.now(); + if (now - lastContextRecoveryAtRef.current < 250) { + return; + } + lastContextRecoveryAtRef.current = now; + setContextRecoveryKey((key) => key + 1); + setLayoutEpoch((epoch) => epoch + 1); + }, []); + const handleTileResize = useCallback(() => { + setLayoutEpoch((epoch) => epoch + 1); + }, []); + const canvasKey = `${variant}-${ + hasTransparentBackground ? "transparent" : "opaque" + }-${contextRecoveryKey}`; + const getInitialVisualReady = () => + variant === "tile" && projectArtifactTileHasRevealed; + const [isVisualReady, setIsVisualReady] = useState(getInitialVisualReady); + const [visualReadyVariant, setVisualReadyVariant] = useState(variant); + + if (visualReadyVariant !== variant) { + setVisualReadyVariant(variant); + setIsVisualReady(getInitialVisualReady()); + } + + useEffect(() => { + const runtime = runtimeRef.current; + runtime.imageIndex = initialImageIndex; + runtime.clickPulse = 0; + runtime.contentTransition = 1; + runtime.isTransitioning = false; + runtime.lastInteractionTime = Date.now(); + }, [initialImageIndex]); + + useEffect(() => { + if (variant !== "tile" || gestureFreezeActive) { + return; + } + const frame = requestAnimationFrame(() => { + requestSoftRecovery(); + }); + return () => cancelAnimationFrame(frame); + }, [gestureFreezeActive, requestSoftRecovery, variant]); + + useEffect(() => { + if (variant === "tile" && projectArtifactTileHasRevealed) { + return; + } + + const frameIds: number[] = []; + let frame = 0; + const frameDelay = + variant === "tile" + ? TILE_VISUAL_READY_FRAME_DELAY + : VISUAL_READY_FRAME_DELAY; + const tick = () => { + frame += 1; + if (frame >= frameDelay) { + setIsVisualReady(true); + if (variant === "tile") { + projectArtifactTileHasRevealed = true; + } + return; + } + frameIds.push(requestAnimationFrame(tick)); + }; + frameIds.push(requestAnimationFrame(tick)); + + return () => { + frameIds.forEach(cancelAnimationFrame); + }; + }, [variant]); + + const handleWebGLContextRestored = useCallback(() => { + requestHardRecovery(); + }, [requestHardRecovery]); + + const updateCursorPosition = (event: ReactPointerEvent) => { + if (!interactive) return; + const rect = event.currentTarget.getBoundingClientRect(); + if (rect.width <= 0 || rect.height <= 0) return; + runtimeRef.current.cursorPosition = { + x: ((event.clientX - rect.left) / rect.width) * 2 - 1, + y: -(((event.clientY - rect.top) / rect.height) * 2 - 1), + }; + }; + + const handlePointerMove = (event: ReactPointerEvent) => { + updateCursorPosition(event); + if (interactive) recordInteraction(runtimeRef); + }; + + const handlePointerEnter = (event: ReactPointerEvent) => { + updateCursorPosition(event); + runtimeRef.current.isHovered = true; + recordInteraction(runtimeRef); + }; + + const handlePointerLeave = () => { + runtimeRef.current.isHovered = false; + runtimeRef.current.isPointerDown = false; + runtimeRef.current.isDragging = false; + }; + + return ( +
+ {variant === "tile" ? ( + + ) : null} + {variant === "preview" ? ( +
+ ) : null} +
+ { + gl.domElement.style.background = hasTransparentBackground + ? "transparent" + : canvasBackground; + gl.setClearAlpha(hasTransparentBackground ? 0 : 1); + gl.setClearColor( + hasTransparentBackground ? "#000000" : canvasBackground, + hasTransparentBackground ? 0 : 1, + ); + scene.environmentIntensity = EFFECTS.envIntensity; + onGlCanvasReady?.(gl.domElement); + }} + > + + + + + +
+
+ ); +} + +useGLTF.preload(PROJECT_ARTIFACT_CUBE_MODEL_URL); diff --git a/prototypes/project-cube-orbit/app/berd-project-cube/assets.ts b/prototypes/project-cube-orbit/app/berd-project-cube/assets.ts new file mode 100644 index 0000000000..7b90731285 --- /dev/null +++ b/prototypes/project-cube-orbit/app/berd-project-cube/assets.ts @@ -0,0 +1,3 @@ +import cubeModelUrl from "./assets/models/Cube_A_v001.gltf?url"; + +export const PROJECT_ARTIFACT_CUBE_MODEL_URL = cubeModelUrl; diff --git a/prototypes/project-cube-orbit/app/berd-project-cube/assets/models/Cube_A_v001.gltf b/prototypes/project-cube-orbit/app/berd-project-cube/assets/models/Cube_A_v001.gltf new file mode 100644 index 0000000000..d8ee2d0516 --- /dev/null +++ b/prototypes/project-cube-orbit/app/berd-project-cube/assets/models/Cube_A_v001.gltf @@ -0,0 +1,87 @@ +{ + "asset":{ + "version":"2.0", + "generator":"Maxon Cinema 4D 2026.1.0 (#200000219)" + }, + "nodes":[{ + "name":"Cube", + "mesh":0 + }], + "scenes":[{ + "nodes":[0] + }], + "buffers":[{ + "uri":"data:application/octet-stream;base64,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", + "byteLength":121728 + }], + "meshes":[{ + "name":"Cube", + "primitives":[{ + "attributes":{ + "POSITION":1, + "NORMAL":2, + "TEXCOORD_0":3 + }, + "indices":0 + }] + }], + "accessors":[{ + "max":[2843], + "bufferView":0, + "type":"SCALAR", + "componentType":5123, + "count":15360, + "byteOffset":0, + "min":[0] + }, + { + "max":[0.5, + 0.5, + 0.5], + "bufferView":1, + "type":"VEC3", + "componentType":5126, + "count":2844, + "byteOffset":0, + "min":[-0.5, + -0.5, + -0.5] + }, + { + "max":[1.0, + 1.0, + 1.0], + "bufferView":1, + "type":"VEC3", + "componentType":5126, + "count":2844, + "byteOffset":12, + "min":[-1.0, + -1.0, + -1.0] + }, + { + "max":[1.0, + 1.0], + "bufferView":1, + "type":"VEC2", + "componentType":5126, + "count":2844, + "byteOffset":24, + "min":[0.0, + 0.0] + }], + "bufferViews":[{ + "buffer":0, + "byteOffset":0, + "byteLength":30720, + "target":34963 + }, + { + "buffer":0, + "byteOffset":30720, + "byteLength":91008, + "target":34962, + "byteStride":32 + }] +} \ No newline at end of file diff --git a/prototypes/project-cube-orbit/app/berd-project-cube/cn.ts b/prototypes/project-cube-orbit/app/berd-project-cube/cn.ts new file mode 100644 index 0000000000..a5ef193506 --- /dev/null +++ b/prototypes/project-cube-orbit/app/berd-project-cube/cn.ts @@ -0,0 +1,6 @@ +import { clsx, type ClassValue } from "clsx"; +import { twMerge } from "tailwind-merge"; + +export function cn(...inputs: ClassValue[]) { + return twMerge(clsx(inputs)); +} diff --git a/prototypes/project-cube-orbit/app/berd-project-cube/projectArtifactThreeResources.ts b/prototypes/project-cube-orbit/app/berd-project-cube/projectArtifactThreeResources.ts new file mode 100644 index 0000000000..34b475910a --- /dev/null +++ b/prototypes/project-cube-orbit/app/berd-project-cube/projectArtifactThreeResources.ts @@ -0,0 +1,84 @@ +import type * as THREE from "three"; + +const CUBE_TEXTURE_CLONE_FLAG = "projectArtifactRendererCubeTextureClone"; +const SOURCE_TEXTURE_UUID = "sourceTextureUuid"; + +interface ProjectArtifactTextureUserData { + [CUBE_TEXTURE_CLONE_FLAG]?: boolean; + [SOURCE_TEXTURE_UUID]?: string; +} + +function textureUserData( + texture: THREE.Texture, +): ProjectArtifactTextureUserData { + return texture.userData as ProjectArtifactTextureUserData; +} + +function isCubeTextureClone( + texture: THREE.Texture | null | undefined, +): texture is THREE.Texture { + return Boolean(texture && textureUserData(texture)[CUBE_TEXTURE_CLONE_FLAG]); +} + +function createCubeTextureClone(texture: THREE.Texture) { + const clone = texture.clone(); + const userData = textureUserData(clone); + userData[CUBE_TEXTURE_CLONE_FLAG] = true; + userData[SOURCE_TEXTURE_UUID] = texture.uuid; + return clone; +} + +function disposeCubeTextureClone(material: THREE.MeshBasicMaterial) { + if (!isCubeTextureClone(material.map)) { + return; + } + + const texture = material.map; + material.map = null; + material.needsUpdate = true; + texture.dispose(); +} + +export function applyProjectArtifactCubeTexture({ + cloneForUvTransform, + material, + texture, +}: { + cloneForUvTransform: boolean; + material: THREE.MeshBasicMaterial; + texture: THREE.Texture; +}) { + if (!cloneForUvTransform) { + if (material.map !== texture) { + disposeCubeTextureClone(material); + material.map = texture; + material.needsUpdate = true; + } + return texture; + } + + if (!isCubeTextureClone(material.map)) { + material.map = createCubeTextureClone(texture); + material.needsUpdate = true; + } + + const clonedMap = material.map; + const userData = textureUserData(clonedMap); + if (userData[SOURCE_TEXTURE_UUID] !== texture.uuid) { + clonedMap.image = texture.image; + clonedMap.colorSpace = texture.colorSpace; + clonedMap.needsUpdate = true; + userData[SOURCE_TEXTURE_UUID] = texture.uuid; + } + + return clonedMap; +} + +export function disposeProjectArtifactCubeMaterials( + materials: readonly THREE.MeshBasicMaterial[], +) { + materials.forEach((material) => { + disposeCubeTextureClone(material); + material.dispose(); + }); +} diff --git a/prototypes/project-cube-orbit/app/berd-project-cube/renderVisibility.ts b/prototypes/project-cube-orbit/app/berd-project-cube/renderVisibility.ts new file mode 100644 index 0000000000..7edb48fa7c --- /dev/null +++ b/prototypes/project-cube-orbit/app/berd-project-cube/renderVisibility.ts @@ -0,0 +1,168 @@ +import { useSyncExternalStore } from "react"; +import type { Window as TauriWindow } from "@tauri-apps/api/window"; + +export function isDocumentVisible(): boolean { + return ( + typeof document === "undefined" || document.visibilityState !== "hidden" + ); +} + +async function isTauriWindowVisible(appWindow: TauriWindow): Promise { + const [isVisible, isMinimized] = await Promise.all([ + appWindow.isVisible().catch(() => true), + appWindow.isMinimized().catch(() => false), + ]); + + return isVisible && !isMinimized; +} + +export async function resolveRenderWindowVisible( + appWindow: TauriWindow | null, +): Promise { + if (!isDocumentVisible()) { + return false; + } + + if (!appWindow) { + return true; + } + + return isTauriWindowVisible(appWindow); +} + +type VisibilityListener = () => void; +type Unlisten = () => void; + +let currentVisibility = isDocumentVisible(); +let appWindow: TauriWindow | null = null; +let stopTracking: Unlisten | null = null; +let requestSequence = 0; +const listeners = new Set(); + +function getRenderWindowVisibleSnapshot(): boolean { + return currentVisibility; +} + +function setRenderWindowVisibleSnapshot(nextVisibility: boolean): void { + if (currentVisibility === nextVisibility) { + return; + } + + currentVisibility = nextVisibility; + for (const listener of listeners) { + listener(); + } +} + +function syncRenderWindowVisibility(): void { + const requestId = ++requestSequence; + const requestWindow = appWindow; + + void resolveRenderWindowVisible(requestWindow) + .then((nextVisibility) => { + if (requestId !== requestSequence) { + return; + } + + setRenderWindowVisibleSnapshot(nextVisibility && isDocumentVisible()); + }) + .catch(() => { + if (requestId !== requestSequence) { + return; + } + + setRenderWindowVisibleSnapshot(isDocumentVisible()); + }); +} + +function startTrackingRenderWindowVisibility(): void { + if (stopTracking) { + return; + } + + let stopped = false; + let unlistenFocus: Unlisten | undefined; + let unlistenResize: Unlisten | undefined; + const syncVisibility = () => syncRenderWindowVisibility(); + + if (typeof document !== "undefined") { + document.addEventListener("visibilitychange", syncVisibility); + } + + if (typeof window !== "undefined") { + window.addEventListener("focus", syncVisibility); + window.addEventListener("blur", syncVisibility); + + if (window.__TAURI_INTERNALS__) { + void import("@tauri-apps/api/window") + .then(async ({ getCurrentWindow }) => { + if (stopped) { + return; + } + + appWindow = getCurrentWindow(); + const [focusUnlisten, resizeUnlisten] = await Promise.all([ + appWindow.onFocusChanged(syncVisibility), + appWindow.onResized(syncVisibility), + ]); + + if (stopped) { + focusUnlisten(); + resizeUnlisten(); + return; + } + + unlistenFocus = focusUnlisten; + unlistenResize = resizeUnlisten; + syncVisibility(); + }) + .catch(() => { + if (!stopped) { + syncVisibility(); + } + }); + } + } + + syncVisibility(); + + stopTracking = () => { + stopped = true; + requestSequence += 1; + appWindow = null; + + if (typeof document !== "undefined") { + document.removeEventListener("visibilitychange", syncVisibility); + } + + if (typeof window !== "undefined") { + window.removeEventListener("focus", syncVisibility); + window.removeEventListener("blur", syncVisibility); + } + + unlistenFocus?.(); + unlistenResize?.(); + stopTracking = null; + }; +} + +function subscribeRenderWindowVisible(listener: VisibilityListener): Unlisten { + listeners.add(listener); + startTrackingRenderWindowVisibility(); + + return () => { + listeners.delete(listener); + + if (listeners.size === 0) { + stopTracking?.(); + } + }; +} + +export function useRenderWindowVisible(): boolean { + return useSyncExternalStore( + subscribeRenderWindowVisible, + getRenderWindowVisibleSnapshot, + isDocumentVisible, + ); +} diff --git a/prototypes/project-cube-orbit/app/berd-project-cube/types.ts b/prototypes/project-cube-orbit/app/berd-project-cube/types.ts new file mode 100644 index 0000000000..36152a6cff --- /dev/null +++ b/prototypes/project-cube-orbit/app/berd-project-cube/types.ts @@ -0,0 +1,78 @@ +export type ProjectArtifactMood = + | "dormant" + | "awakening" + | "serene" + | "active" + | "energetic" + | "contemplative"; + +export type ProjectArtifactContentMode = + | "planes" + | "sphere" + | "cube" + | "cubeStatic"; + +export interface ProjectArtifactInput { + projectId?: string | null; + name: string; + prompt?: string | null; + color?: string | null; + workingDirs?: string[]; + sessionCount?: number; + artifact?: ProjectArtifactMetadata | null; +} + +export interface ProjectArtifactState { + seed: number; + name: string; + accentColor: string; + accentCssColor: string; + mood: ProjectArtifactMood; + moodIntensity: number; + contentMode: ProjectArtifactContentMode; +} + +export interface ProjectArtifactMetadata { + seed: number; + color: string; + mood: ProjectArtifactMood; + moodIntensity: number; + contentMode: ProjectArtifactContentMode; +} + +export interface ProjectArtifactMotionImpulse { + sequence: number; + deltaX: number; + deltaY: number; +} + +export interface ProjectArtifactProjection { + x: number; + y: number; + width: number; + height: number; + /** Clockwise screen-space silhouette of the rendered cube shell. */ + contour?: Array<{ x: number; y: number }>; +} + +export interface ProjectArtifactRendererProps { + state: ProjectArtifactState; + imageUrls: string[]; + environmentUrl: string; + className?: string; + variant?: "preview" | "tile"; + motionImpulse?: ProjectArtifactMotionImpulse; + /** Springs the cube toward a side-facing task-detail orientation. */ + focusSide?: boolean; + /** Pauses continuous rendering while the home canvas drags/resizes the widget. */ + gestureFreezeActive?: boolean; + /** Pauses continuous rendering while a mounted preview is not visible. */ + renderPaused?: boolean; + onGlCanvasReady?: (canvas: HTMLCanvasElement) => void; + /** Reports the rendered cube shell bounds and silhouette in canvas pixels. */ + onCubeProjection?: (projection: ProjectArtifactProjection) => void; + /** Pulls the camera back to provide extra framing around oversized embeds. */ + cameraDistanceScale?: number; +} + +export type ProjectArtifactPinState = { projectId: string }; diff --git a/prototypes/project-cube-orbit/app/buzz-project-prototype.tsx b/prototypes/project-cube-orbit/app/buzz-project-prototype.tsx new file mode 100644 index 0000000000..e2ceb5c05f --- /dev/null +++ b/prototypes/project-cube-orbit/app/buzz-project-prototype.tsx @@ -0,0 +1,1038 @@ +"use client"; + +import { useEffect, useId, useRef, useState } from "react"; +import type { CSSProperties, MutableRefObject, PointerEvent as ReactPointerEvent } from "react"; +import { ChevronDown, Plus, Search, SquareDashed, X } from "lucide-react"; +import { ProjectArtifactRenderer } from "./berd-project-cube/ProjectArtifactRenderer"; +import type { + ProjectArtifactProjection, + ProjectArtifactState, +} from "./berd-project-cube/types"; + +const PRIMARY_PROJECT_STATE: ProjectArtifactState = { + seed: 381, + name: "Buzz navigation", + accentColor: "#b8d9ca", + accentCssColor: "#b8d9ca", + mood: "active", + moodIntensity: 0.72, + contentMode: "cube", +}; + +const SECONDARY_PROJECT_STATE: ProjectArtifactState = { + seed: 734, + name: "Agent workspace", + accentColor: "#d8ca94", + accentCssColor: "#d8ca94", + mood: "energetic", + moodIntensity: 0.68, + contentMode: "cube", +}; + +const TERTIARY_PROJECT_STATE: ProjectArtifactState = { + seed: 912, + name: "Blue sky prototype", + accentColor: "#27a9eb", + accentCssColor: "#27a9eb", + mood: "active", + moodIntensity: 0.76, + contentMode: "cube", +}; + +const RELAY_PROJECT_STATE: ProjectArtifactState = { + seed: 144, + name: "Relay handoffs", + accentColor: "#e38b6e", + accentCssColor: "#e38b6e", + mood: "energetic", + moodIntensity: 0.7, + contentMode: "cube", +}; + +const ATLAS_PROJECT_STATE: ProjectArtifactState = { + seed: 626, + name: "Atlas research", + accentColor: "#9d8bea", + accentCssColor: "#9d8bea", + mood: "active", + moodIntensity: 0.66, + contentMode: "cube", +}; + +const LANTERN_PROJECT_STATE: ProjectArtifactState = { + seed: 508, + name: "Lantern launch", + accentColor: "#78b98c", + accentCssColor: "#78b98c", + mood: "active", + moodIntensity: 0.74, + contentMode: "cube", +}; + +const PRIMARY_IMAGE_URLS = ["/berd-project-assets/memory-03.webp"]; +const SECONDARY_IMAGE_URLS = ["/berd-project-assets/memory-17.webp"]; +const TERTIARY_IMAGE_URLS = ["/berd-project-assets/memory-35.webp"]; + +type TaskNoodle = { + avatar: string; + label: string; + id: string; + context: string; + created: string; + assignee: string; +}; +type ProjectTasks = readonly [TaskNoodle, TaskNoodle, TaskNoodle]; + +type SelectedTask = { + projectKey: string; + projectName: string; + accentColor: string; + task: TaskNoodle; + taskIndex: number; +}; + +const COMMON_TASK_DETAILS = { + created: "Aug 26, 2026", + assignee: "Cynthia Chen", +}; + +const PRIMARY_TASKS: ProjectTasks = [ + { avatar: "/berd-agent-avatars/pushback-gloopies-5.png", label: "GIF support", id: "BUZZ-1892", context: "Add dependable animated GIF playback and previews throughout project conversations, including clear loading and failure states.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/builderbot-gloopies-20.png", label: "Nav polish", id: "BUZZ-1904", context: "Refine the primary navigation spacing, selected states, and responsive behavior so it stays quiet and legible.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/berdy-gloopies-22.png", label: "Review PR-381", id: "BUZZ-381", context: "Review the project workspace changes, check the interaction details, and leave actionable feedback before merge.", ...COMMON_TASK_DETAILS }, +]; + +const SECONDARY_TASKS: ProjectTasks = [ + { avatar: "/berd-agent-avatars/berdy-gloopies-22.png", label: "Agent CLI", id: "AGENT-214", context: "Prototype a compact command-line workflow for launching and inspecting workspace agents.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/pushback-gloopies-5.png", label: "Team astrology", id: "AGENT-227", context: "Explore a playful team activity that turns project signals into a lightweight weekly reading.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/builderbot-gloopies-20.png", label: "Run QA", id: "AGENT-231", context: "Exercise the key workspace flows and record any interaction or rendering regressions.", ...COMMON_TASK_DETAILS }, +]; + +const TERTIARY_TASKS: ProjectTasks = [ + { avatar: "/berd-agent-avatars/builderbot-gloopies-20.png", label: "Prototype CLI", id: "BLUE-104", context: "Build the smallest useful prototype for the new project command-line experience.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/berdy-gloopies-22.png", label: "Motion study", id: "BLUE-118", context: "Tune the hover, focus, and transition motion so the project objects feel physical but controlled.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/pushback-gloopies-5.png", label: "Ship demo", id: "BLUE-125", context: "Prepare the prototype for a focused internal demonstration and collect follow-up questions.", ...COMMON_TASK_DETAILS }, +]; + +const RELAY_TASKS: readonly TaskNoodle[] = [ + { avatar: "/berd-agent-avatars/pushback-gloopies-5.png", label: "Handoff timeline", id: "RELAY-42", context: "Make agent-to-agent handoffs readable as a single chronological thread with clear ownership changes.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/berdy-gloopies-22.png", label: "Retry states", id: "RELAY-57", context: "Design recoverable retry states for interrupted handoffs without duplicating completed work.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/builderbot-gloopies-20.png", label: "Connection audit", id: "RELAY-63", context: "Audit connection health signals and surface the smallest useful status summary for each relay.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/pushback-gloopies-5.png", label: "Latency budget", id: "RELAY-71", context: "Set a practical latency budget for each handoff stage and identify the slowest transitions.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/berdy-gloopies-22.png", label: "Owner fallback", id: "RELAY-79", context: "Define who takes over when the assigned agent becomes unavailable during an active relay.", ...COMMON_TASK_DETAILS }, +]; + +const ATLAS_TASKS: readonly TaskNoodle[] = [ + { avatar: "/berd-agent-avatars/builderbot-gloopies-20.png", label: "Source map", id: "ATLAS-88", context: "Map the research sources behind project decisions and show where each conclusion originated.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/pushback-gloopies-5.png", label: "Insight clusters", id: "ATLAS-96", context: "Group related findings into concise themes while preserving links back to the original evidence.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/berdy-gloopies-22.png", label: "Weekly digest", id: "ATLAS-103", context: "Generate a lightweight weekly digest of new findings, open questions, and changed assumptions.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/builderbot-gloopies-20.png", label: "Archive sources", id: "ATLAS-111", context: "Archive stale references while retaining a clear trail for decisions that still depend on them.", ...COMMON_TASK_DETAILS }, +]; + +const LANTERN_TASKS: readonly TaskNoodle[] = [ + { avatar: "/berd-agent-avatars/berdy-gloopies-22.png", label: "Launch checklist", id: "LANTERN-12", context: "Turn the launch plan into a shared checklist with owners, dependencies, and confidence signals.", ...COMMON_TASK_DETAILS }, + { avatar: "/berd-agent-avatars/builderbot-gloopies-20.png", label: "Audience notes", id: "LANTERN-19", context: "Collect audience-specific talking points and keep the latest approved narrative easy to find.", ...COMMON_TASK_DETAILS }, +]; + +const GOOSE_PROJECT_TASKS: readonly TaskNoodle[] = [ + ...SECONDARY_TASKS, + { avatar: "/berd-agent-avatars/pushback-gloopies-5.png", label: "Prompt presets", id: "AGENT-244", context: "Create reusable prompt presets for the most common workspace agent workflows.", ...COMMON_TASK_DETAILS }, +]; + +const BUZZ_PROJECT_TASKS: readonly TaskNoodle[] = TERTIARY_TASKS.slice(0, 2); + +type ProjectDefinition = { + key: string; + name: string; + state: ProjectArtifactState; + imageUrls: string[]; + tasks: readonly TaskNoodle[]; +}; + +const PROJECTS: readonly ProjectDefinition[] = [ + { key: "berd", name: "Berd", state: PRIMARY_PROJECT_STATE, imageUrls: PRIMARY_IMAGE_URLS, tasks: PRIMARY_TASKS }, + { key: "goose", name: "Goose", state: SECONDARY_PROJECT_STATE, imageUrls: SECONDARY_IMAGE_URLS, tasks: GOOSE_PROJECT_TASKS }, + { key: "buzz", name: "Buzz", state: TERTIARY_PROJECT_STATE, imageUrls: TERTIARY_IMAGE_URLS, tasks: BUZZ_PROJECT_TASKS }, + { key: "relay", name: "Relay", state: RELAY_PROJECT_STATE, imageUrls: SECONDARY_IMAGE_URLS, tasks: RELAY_TASKS }, + { key: "atlas", name: "Atlas", state: ATLAS_PROJECT_STATE, imageUrls: TERTIARY_IMAGE_URLS, tasks: ATLAS_TASKS }, + { key: "lantern", name: "Lantern", state: LANTERN_PROJECT_STATE, imageUrls: PRIMARY_IMAGE_URLS, tasks: LANTERN_TASKS }, +]; + +type LabelMotion = { + projection: ProjectArtifactProjection; + reduceMotion: boolean; +}; + +type NoodlePoint = { x: number; y: number }; +const NOODLE_STROKE_WIDTH = 60; +const MIN_NOODLE_PADDING = 1; +const NOODLE_CUBE_GAP = 26; +const NOODLE_TEXT_OFFSET = 62; +const NOODLE_TRAILING_PADDING = 4; + +function signedArea(points: NoodlePoint[]) { + return points.reduce((area, point, index) => { + const next = points[(index + 1) % points.length]; + return area + point.x * next.y - next.x * point.y; + }, 0) / 2; +} + +function resampleClosedContour(points: NoodlePoint[], count: number) { + if (points.length < 2) return points; + const ordered = signedArea(points) >= 0 ? points : [...points].reverse(); + const lengths = [0]; + for (let index = 0; index < ordered.length; index += 1) { + const point = ordered[index]; + const next = ordered[(index + 1) % ordered.length]; + lengths.push(lengths[lengths.length - 1] + Math.hypot(next.x - point.x, next.y - point.y)); + } + const perimeter = lengths[lengths.length - 1]; + const samples: NoodlePoint[] = []; + let edge = 0; + for (let sample = 0; sample < count; sample += 1) { + const distance = (sample / count) * perimeter; + while (edge < ordered.length - 1 && lengths[edge + 1] < distance) edge += 1; + const start = ordered[edge]; + const end = ordered[(edge + 1) % ordered.length]; + const edgeLength = lengths[edge + 1] - lengths[edge] || 1; + const progress = (distance - lengths[edge]) / edgeLength; + samples.push({ + x: start.x + (end.x - start.x) * progress, + y: start.y + (end.y - start.y) * progress, + }); + } + + const minY = Math.min(...samples.map((point) => point.y)); + const minX = Math.min(...samples.map((point) => point.x)); + const maxX = Math.max(...samples.map((point) => point.x)); + const topCenter = { x: (minX + maxX) / 2, y: minY }; + const startIndex = samples.reduce((best, point, index) => + Math.hypot(point.x - topCenter.x, point.y - topCenter.y) < + Math.hypot(samples[best].x - topCenter.x, samples[best].y - topCenter.y) + ? index + : best, + 0); + return samples.slice(startIndex).concat(samples.slice(0, startIndex)); +} + +function offsetContour(points: NoodlePoint[], distance: number) { + const clockwise = signedArea(points) >= 0; + const edgeNormal = (from: NoodlePoint, to: NoodlePoint) => { + const dx = to.x - from.x; + const dy = to.y - from.y; + const length = Math.hypot(dx, dy) || 1; + return clockwise + ? { x: dy / length, y: -dx / length } + : { x: -dy / length, y: dx / length }; + }; + return points.map((point, index) => { + const previous = points[(index - 1 + points.length) % points.length]; + const next = points[(index + 1) % points.length]; + const beforeNormal = edgeNormal(previous, point); + const afterNormal = edgeNormal(point, next); + const sumX = beforeNormal.x + afterNormal.x; + const sumY = beforeNormal.y + afterNormal.y; + const sumLength = Math.hypot(sumX, sumY) || 1; + const normal = { x: sumX / sumLength, y: sumY / sumLength }; + const projection = Math.max( + 0.67, + normal.x * afterNormal.x + normal.y * afterNormal.y, + ); + const miter = Math.min(distance * 1.45, distance / projection); + return { x: point.x + normal.x * miter, y: point.y + normal.y * miter }; + }); +} + +function contourRangeByLength( + points: NoodlePoint[], + start: number, + targetLength: number, + direction: 1 | -1, +) { + const startIndex = Math.round(start * points.length) % points.length; + const range = [points[startIndex]]; + let index = startIndex; + let traversed = 0; + while (range.length <= points.length && traversed < targetLength) { + const nextIndex = (index + direction + points.length) % points.length; + const point = points[index]; + const next = points[nextIndex]; + const segmentLength = Math.hypot(next.x - point.x, next.y - point.y) || 1; + if (traversed + segmentLength >= targetLength) { + const progress = (targetLength - traversed) / segmentLength; + range.push({ + x: point.x + (next.x - point.x) * progress, + y: point.y + (next.y - point.y) * progress, + }); + break; + } + traversed += segmentLength; + index = nextIndex; + range.push(next); + } + return range; +} + +function closedContourLength(points: NoodlePoint[]) { + return points.reduce((length, point, index) => { + const next = points[(index + 1) % points.length]; + return length + Math.hypot(next.x - point.x, next.y - point.y); + }, 0); +} + +function smoothPath(points: NoodlePoint[]) { + if (points.length < 2) return ""; + const commands = [`M ${points[0].x} ${points[0].y}`]; + for (let index = 0; index < points.length - 1; index += 1) { + const before = points[Math.max(0, index - 1)]; + const current = points[index]; + const next = points[index + 1]; + const after = points[Math.min(points.length - 1, index + 2)]; + const controlOne = { + x: current.x + (next.x - before.x) / 6, + y: current.y + (next.y - before.y) / 6, + }; + const controlTwo = { + x: next.x - (after.x - current.x) / 6, + y: next.y - (after.y - current.y) / 6, + }; + commands.push( + `C ${controlOne.x} ${controlOne.y}, ${controlTwo.x} ${controlTwo.y}, ${next.x} ${next.y}`, + ); + } + return commands.join(" "); +} + +function WrappedTaskLabels({ + motion, + tasks, + accentColor, + selectedIndex, + onSelect, +}: { + motion: MutableRefObject; + tasks: ProjectTasks; + accentColor: string; + selectedIndex: number | null; + onSelect: (taskIndex: number) => void; +}) { + const pathId = useId().replace(/:/g, ""); + const supportPathId = `${pathId}-support`; + const navPathId = `${pathId}-nav`; + const reviewPathId = `${pathId}-review`; + const supportPathRef = useRef(null); + const navPathRef = useRef(null); + const reviewPathRef = useRef(null); + const supportAvatarRef = useRef(null); + const navAvatarRef = useRef(null); + const reviewAvatarRef = useRef(null); + const supportTextRef = useRef(null); + const navTextRef = useRef(null); + const reviewTextRef = useRef(null); + const smoothedTraceRef = useRef(null); + const liveTraceRef = useRef([]); + const taskStartOverridesRef = useRef>([null, null, null]); + const dragRef = useRef<{ + index: number; + startX: number; + startY: number; + moved: boolean; + } | null>(null); + const [draggingIndex, setDraggingIndex] = useState(null); + + useEffect(() => { + let frame = 0; + const update = () => { + const projection = motion.current.projection; + const left = 55 + projection.x; + const top = 35 + projection.y; + const right = left + projection.width; + const bottom = top + projection.height; + const width = projection.width; + const height = projection.height; + const contour = projection.contour?.map((point) => ({ + x: point.x + 55, + y: point.y + 35, + })); + + if (contour && contour.length >= 4) { + const targetTrace = offsetContour( + resampleClosedContour(contour, 160), + NOODLE_STROKE_WIDTH / 2 + NOODLE_CUBE_GAP, + ); + if (!smoothedTraceRef.current || smoothedTraceRef.current.length !== targetTrace.length) { + smoothedTraceRef.current = targetTrace.map((point) => ({ ...point })); + } else { + const blend = motion.current.reduceMotion ? 1 : 0.52; + smoothedTraceRef.current.forEach((point, index) => { + point.x += (targetTrace[index].x - point.x) * blend; + point.y += (targetTrace[index].y - point.y) * blend; + }); + } + const trace = smoothedTraceRef.current; + liveTraceRef.current = trace; + const perimeter = closedContourLength(trace); + // Rounded stroke caps each consume half the stroke width. Keep a small + // sampling cushion while allowing the task noodles to sit more tightly. + const minimumGapFraction = + (NOODLE_STROKE_WIDTH + MIN_NOODLE_PADDING) / perimeter; + const topGap = Math.max(0.02, minimumGapFraction); + // The two left-side noodles meet near a broad projected corner, so the + // same perimeter distance reads much larger than the top seam. + const leftGap = Math.max(0.012, minimumGapFraction * 0.58); + const defaultSupportStart = 0.82; + const supportStart = taskStartOverridesRef.current[0] ?? defaultSupportStart; + const navStart = taskStartOverridesRef.current[1] ?? topGap / 2; + const reviewStart = + taskStartOverridesRef.current[2] ?? defaultSupportStart - leftGap; + const noodleLength = (text: SVGTextElement | null, fallback: number) => + NOODLE_TEXT_OFFSET + + (text?.getComputedTextLength() || fallback) + + NOODLE_TRAILING_PADDING; + + supportPathRef.current?.setAttribute( + "d", + smoothPath( + contourRangeByLength( + trace, + supportStart, + noodleLength(supportTextRef.current, 118), + 1, + ), + ), + ); + navPathRef.current?.setAttribute( + "d", + smoothPath( + contourRangeByLength( + trace, + navStart, + noodleLength(navTextRef.current, 112), + 1, + ), + ), + ); + reviewPathRef.current?.setAttribute( + "d", + smoothPath( + contourRangeByLength( + trace, + reviewStart, + noodleLength(reviewTextRef.current, 174), + -1, + ), + ), + ); + } else { + const margin = Math.max(28, Math.min(width, height) * 0.085); + const topY = top - margin; + const leftX = left - margin; + const rightX = right + margin; + const bottomY = bottom + margin; + supportPathRef.current?.setAttribute( + "d", + `M ${left + width * 0.43} ${topY} C ${left + width * 0.1} ${topY}, ${leftX} ${top + height * 0.08}, ${leftX} ${top + height * 0.48}`, + ); + navPathRef.current?.setAttribute( + "d", + `M ${left + width * 0.55} ${topY} C ${right - width * 0.08} ${topY}, ${rightX} ${top + height * 0.04}, ${rightX} ${top + height * 0.4}`, + ); + reviewPathRef.current?.setAttribute( + "d", + `M ${leftX} ${top + height * 0.56} C ${leftX} ${bottom - height * 0.08}, ${left + width * 0.06} ${bottomY}, ${left + width * 0.58} ${bottomY}`, + ); + } + + const placeAvatar = ( + path: SVGPathElement | null, + avatar: SVGImageElement | null, + distanceFromStart: number, + ) => { + if (!path || !avatar) return; + const length = path.getTotalLength(); + const point = path.getPointAtLength( + Math.min(length, distanceFromStart), + ); + const nextPoint = path.getPointAtLength( + Math.min(length, distanceFromStart + 2), + ); + const angle = + (Math.atan2(nextPoint.y - point.y, nextPoint.x - point.x) * 180) / + Math.PI; + const size = 46; + avatar.setAttribute("x", String(point.x - size / 2)); + avatar.setAttribute("y", String(point.y - size / 2)); + avatar.setAttribute("width", String(size)); + avatar.setAttribute("height", String(size)); + avatar.setAttribute( + "transform", + `rotate(${angle} ${point.x} ${point.y})`, + ); + }; + + placeAvatar(supportPathRef.current, supportAvatarRef.current, 22); + placeAvatar(navPathRef.current, navAvatarRef.current, 22); + placeAvatar(reviewPathRef.current, reviewAvatarRef.current, 22); + frame = requestAnimationFrame(update); + }; + frame = requestAnimationFrame(update); + return () => cancelAnimationFrame(frame); + }, [motion]); + + const moveTaskToPointer = ( + event: ReactPointerEvent, + taskIndex: number, + ) => { + const svg = event.currentTarget.ownerSVGElement; + const trace = liveTraceRef.current; + if (!svg || trace.length === 0) return; + const rect = svg.getBoundingClientRect(); + if (rect.width <= 0 || rect.height <= 0) return; + const x = ((event.clientX - rect.left) / rect.width) * 760; + const y = ((event.clientY - rect.top) / rect.height) * 720; + let nearestIndex = 0; + let nearestDistance = Number.POSITIVE_INFINITY; + trace.forEach((point, index) => { + const distance = (point.x - x) ** 2 + (point.y - y) ** 2; + if (distance < nearestDistance) { + nearestDistance = distance; + nearestIndex = index; + } + }); + taskStartOverridesRef.current[taskIndex] = nearestIndex / trace.length; + }; + + const beginTaskDrag = ( + event: ReactPointerEvent, + taskIndex: number, + ) => { + event.currentTarget.setPointerCapture(event.pointerId); + dragRef.current = { + index: taskIndex, + startX: event.clientX, + startY: event.clientY, + moved: false, + }; + setDraggingIndex(taskIndex); + }; + + const updateTaskDrag = ( + event: ReactPointerEvent, + taskIndex: number, + ) => { + const drag = dragRef.current; + if (!drag || drag.index !== taskIndex) return; + if (Math.hypot(event.clientX - drag.startX, event.clientY - drag.startY) > 4) { + drag.moved = true; + } + if (drag.moved) moveTaskToPointer(event, taskIndex); + }; + + const endTaskDrag = ( + event: ReactPointerEvent, + taskIndex: number, + ) => { + const drag = dragRef.current; + if (!drag || drag.index !== taskIndex) return; + if (event.currentTarget.hasPointerCapture(event.pointerId)) { + event.currentTarget.releasePointerCapture(event.pointerId); + } + dragRef.current = null; + setDraggingIndex(null); + if (!drag.moved) onSelect(taskIndex); + }; + + return ( + + + + + + + {[ + { task: tasks[0], pathId: supportPathId, avatarRef: supportAvatarRef, textRef: supportTextRef, className: "support-ribbon" }, + { task: tasks[1], pathId: navPathId, avatarRef: navAvatarRef, textRef: navTextRef, className: "nav-ribbon" }, + { task: tasks[2], pathId: reviewPathId, avatarRef: reviewAvatarRef, textRef: reviewTextRef, className: "review-ribbon" }, + ].map(({ task, pathId: taskPathId, avatarRef, textRef, className }, index) => ( + beginTaskDrag(event, index)} + onPointerMove={(event) => updateTaskDrag(event, index)} + onPointerUp={(event) => endTaskDrag(event, index)} + onPointerCancel={(event) => endTaskDrag(event, index)} + onKeyDown={(event) => { + if (event.key === "Enter" || event.key === " ") { + event.preventDefault(); + onSelect(index); + } + }} + > + + + + {task.label} + + ))} + + ); +} + +function ProjectOrbit({ + projectKey, + displayName, + className, + imageUrls, + state, + tasks, + selectedTask, + onSelectTask, +}: { + projectKey: string; + displayName: string; + className: string; + imageUrls: string[]; + state: ProjectArtifactState; + tasks: ProjectTasks; + selectedTask: SelectedTask | null; + onSelectTask: (selection: SelectedTask) => void; +}) { + const motion = useRef({ + projection: { x: 145, y: 135, width: 280, height: 300 }, + reduceMotion: false, + }); + const projectNamePillRef = useRef(null); + const [cubeHovered, setCubeHovered] = useState(false); + const isSelectedProject = selectedTask?.projectKey === projectKey; + const isDimmed = Boolean(selectedTask && !isSelectedProject); + + useEffect(() => { + const query = window.matchMedia("(prefers-reduced-motion: reduce)"); + const update = () => { motion.current.reduceMotion = query.matches; }; + update(); + query.addEventListener("change", update); + return () => query.removeEventListener("change", update); + }, []); + + return ( +
+ { + onSelectTask({ + projectKey, + projectName: displayName, + accentColor: state.accentCssColor, + task: tasks[taskIndex], + taskIndex, + }); + }} + /> +
{ + const rect = event.currentTarget.getBoundingClientRect(); + const projection = motion.current.projection; + const x = ((event.clientX - rect.left) / rect.width) * 650; + const y = ((event.clientY - rect.top) / rect.height) * 650; + setCubeHovered( + x >= projection.x && + x <= projection.x + projection.width && + y >= projection.y && + y <= projection.y + projection.height, + ); + }} + onPointerLeave={() => setCubeHovered(false)} + > + { + motion.current.projection = projection; + if (projectNamePillRef.current) { + projectNamePillRef.current.style.left = `${55 + projection.x + projection.width / 2}px`; + projectNamePillRef.current.style.top = `${35 + projection.y + projection.height - 42}px`; + } + }} + /> +
+ +
+ ); +} + +function ProjectsView() { + const [activeProjectIndex, setActiveProjectIndex] = useState(0); + const [expandedTaskId, setExpandedTaskId] = useState(null); + const carouselRowRef = useRef(null); + const carouselDragRef = useRef<{ + pointerId: number; + startX: number; + lastX: number; + moved: boolean; + } | null>(null); + const activeProject = PROJECTS[activeProjectIndex]; + + useEffect(() => { + setExpandedTaskId(null); + }, [activeProjectIndex]); + + const offsetForProject = (projectIndex: number) => { + let offset = projectIndex - activeProjectIndex; + const midpoint = PROJECTS.length / 2; + if (offset > midpoint) offset -= PROJECTS.length; + if (offset < -midpoint) offset += PROJECTS.length; + return offset; + }; + + const selectPreviousProject = () => { + setActiveProjectIndex((index) => (index - 1 + PROJECTS.length) % PROJECTS.length); + }; + + const selectNextProject = () => { + setActiveProjectIndex((index) => (index + 1) % PROJECTS.length); + }; + + const beginCarouselDrag = (event: ReactPointerEvent) => { + event.currentTarget.setPointerCapture(event.pointerId); + carouselDragRef.current = { + pointerId: event.pointerId, + startX: event.clientX, + lastX: event.clientX, + moved: false, + }; + carouselRowRef.current?.classList.add("is-dragging"); + }; + + const updateCarouselDrag = (event: ReactPointerEvent) => { + const drag = carouselDragRef.current; + const row = carouselRowRef.current; + if (!drag || !row || drag.pointerId !== event.pointerId) return; + drag.lastX = event.clientX; + const rawDelta = drag.lastX - drag.startX; + if (Math.abs(rawDelta) > 5) drag.moved = true; + const delta = Math.max(-row.clientWidth * 0.34, Math.min(row.clientWidth * 0.34, rawDelta)); + row.style.setProperty("--carousel-drag-x", `${delta}px`); + }; + + const endCarouselDrag = ( + event: ReactPointerEvent, + cancelled = false, + ) => { + const drag = carouselDragRef.current; + const row = carouselRowRef.current; + if (!drag || !row || drag.pointerId !== event.pointerId) return; + const delta = drag.lastX - drag.startX; + if (event.currentTarget.hasPointerCapture(event.pointerId)) { + event.currentTarget.releasePointerCapture(event.pointerId); + } + carouselDragRef.current = null; + row.classList.remove("is-dragging"); + + if (!cancelled && Math.abs(delta) >= 64) { + if (delta < 0) selectNextProject(); + else selectPreviousProject(); + } else if (!cancelled && !drag.moved) { + const rect = event.currentTarget.getBoundingClientRect(); + const position = (event.clientX - rect.left) / rect.width; + if (position < 0.34) selectPreviousProject(); + if (position > 0.66) selectNextProject(); + } + + requestAnimationFrame(() => { + row.style.setProperty("--carousel-drag-x", "0px"); + }); + }; + + return ( +
+
+ {PROJECTS.map((project, projectIndex) => { + const offset = offsetForProject(projectIndex); + const slot = offset === 0 ? "active" : Math.abs(offset) === 1 ? "neighbor" : "far"; + return ( + + ); + })} +
endCarouselDrag(event)} + onPointerCancel={(event) => endCarouselDrag(event, true)} + onKeyDown={(event) => { + if (event.key === "ArrowLeft") { + event.preventDefault(); + selectPreviousProject(); + } + if (event.key === "ArrowRight") { + event.preventDefault(); + selectNextProject(); + } + }} + /> +
+ +
+
+ + {activeProject.name} +
+ +
+ {activeProject.tasks.map((task) => { + const isExpanded = expandedTaskId === task.id; + return ( +
+ +
+
+
+ Context +

{task.context}

+
+
+
+ Messages +

#{activeProject.key}-{task.id.toLowerCase()}

+

Cynthia, Morgan, Arj

+
+
+ Agents +
+ + + +
+
+
+ +
+
+
+ ); + })} +
+
+
+ ); +} + +function TaskDetailPanel({ + selection, + onClose, +}: { + selection: SelectedTask; + onClose: () => void; +}) { + const { task, projectName } = selection; + const [responseOpen, setResponseOpen] = useState(false); + const [response, setResponse] = useState(""); + const responseRef = useRef(null); + + useEffect(() => { + setResponseOpen(false); + setResponse(""); + }, [task.id]); + + useEffect(() => { + if (!responseOpen) return; + const focusTimer = window.setTimeout(() => responseRef.current?.focus(), 100); + return () => window.clearTimeout(focusTimer); + }, [responseOpen]); + + useEffect(() => { + const closeOnEscape = (event: KeyboardEvent) => { + if (event.key !== "Escape") return; + if (responseOpen) setResponseOpen(false); + else onClose(); + }; + window.addEventListener("keydown", closeOnEscape); + return () => window.removeEventListener("keydown", closeOnEscape); + }, [onClose, responseOpen]); + + return ( +