Sigilism LiDAR Bridge: ARKit to Torus Pipeline

ForgeChainOS — Sigilism Component Spec
Date: March 29, 2026
Status: SPEC

The Insight

Every iPhone Pro and iPad Pro ships with a TrueDepth camera (Face ID) and/or a LiDAR scanner. These sensors produce 3D data at hardware speed. Zero latency. No cloud. On-device neural engine.

Apple uses this for:
- Face ID (authentication)
- AR placement (dropping objects in camera view)
- Portrait mode (depth-based blur)

Apple does NOT use this for:
- Media production
- Spatial audio
- Depth-aware color grading
- 3D asset extraction for game engines
- Measurement and documentation
- Chain-stamped volumetric proof

Sigilism does.

What the Hardware Already Produces

TrueDepth Camera (Front-Facing)

30,000 infrared dots projected in known pattern
Depth map at 640x480 resolution
Face mesh: 1,220 vertices, real-time tracking
52 blend shape coefficients (facial expression)
Runs at 60fps on neural engine
Available on: iPhone X and later (all current iPhones)

LiDAR Scanner (Rear-Facing)

Direct time-of-flight measurement
Range: 0-5 meters
Point cloud density: ~100,000 points per scan
Depth map resolution matches camera resolution
Scene mesh: real-time 3D reconstruction of environment
Available on: iPhone 12 Pro and later, iPad Pro 2020 and later

ARKit Exposes (Already Available to Apps)

ARFaceAnchor
  - geometry: ARFaceGeometry (1,220 vertices, triangulated mesh)
  - blendShapes: [ARFaceAnchor.BlendShapeLocation: Float]
  - transform: simd_float4x4 (position/rotation in world space)

ARMeshAnchor (Scene Reconstruction)
  - geometry: ARMeshGeometry (vertices, normals, faces, classification)
  - classifications: floor, wall, ceiling, table, seat, door, window
  - transform: simd_float4x4

ARPointCloud
  - points: [simd_float3] (xyz positions)
  - identifiers: [UInt64] (stable tracking IDs)

ARDepthData
  - depthMap: CVPixelBuffer (per-pixel depth in meters)
  - confidenceMap: CVPixelBuffer (per-pixel confidence 0-2)

All of this is available RIGHT NOW to any iOS app. No special hardware. No jailbreak. Standard ARKit API.

The Bridge: ARKit to Torus

Data Flow

iPhone/iPad Sensor
    │
    ├── RGB video (camera)
    ├── Depth map (LiDAR/TrueDepth)
    ├── Face mesh (1,220 vertices)
    ├── Scene mesh (room geometry)
    └── Point cloud (spatial data)
    │
    ▼
Sigilism iOS App (capture)
    │
    ├── Map depth to torus coordinates
    │     depth_meters → theta (position on torus tube)
    │     horizontal_angle → phi (position around torus hole)
    │
    ├── Compute frequency from position
    │     f = 432 * (torus_position / 9)
    │     Near field → higher frequency (warmer)
    │     Far field → lower frequency (cooler)
    │
    ├── Apply Sigil Codec at capture
    │     632nm color shift (depth-weighted)
    │     24fps governed frame rate
    │     432 Hz audio pipeline
    │
    └── Package and transmit
          │
          ▼
    ForgeChainOS (Elder/Bro Horse)
          │
          ├── Sigilism Edit Engine (timeline + depth)
          ├── ForgeRender (GPU render on Bro Horse)
          ├── ForgeVerse (UE5 import of scanned meshes)
          └── Chain stamp (BSV mainnet)

Torus Mapping of Depth Data

The key transform: depth in meters becomes position on the torus.

Input: depth_map[x][y] = distance in meters (0.0 to 5.0)
       camera_angle[x][y] = horizontal angle (-FOV/2 to +FOV/2)

Torus mapping:
  theta = (depth / max_depth) * 2 * PI
    → 0 meters = top of torus (closest, cipher 9, 432 Hz)
    → 5 meters = bottom of torus (farthest, cipher 3, 144 Hz)
    → The throat (2.5m) is the midpoint: cipher 6, 288 Hz

  phi = (camera_angle / FOV) * 2 * PI
    → Left edge = 0
    → Center = PI
    → Right edge = 2*PI

  frequency = 432 * (1 - depth/max_depth * 6/9)
    → 0m = 432 Hz (root, near field, warm)
    → 2.5m = 288 Hz (structure, mid field, neutral)
    → 5m = 144 Hz (throat, far field, cool)

This means: every pixel in the depth map has a FREQUENCY. The image is a score. The depth map is a chord chart. Close objects sing at the root. Far objects hum at the throat. The room itself is music.

Depth-Aware Color Grading

For each pixel:
  depth = depth_map[x][y]
  warmth = 1.0 - (depth / max_depth)

  red_boost = 0.08 * warmth    (close = warm, far = neutral)
  blue_cut  = 0.08 * warmth    (close = less blue, far = natural)

  Apply 632nm LUT with depth-weighted intensity.
  Near field: full 632nm warmth.
  Far field: natural color (the world as-is).
  The transition IS the torus: near hemisphere (structure) to far hemisphere (resonance).

Spatial Audio from Depth

For each sound source detected in the scene:
  position = ARKit world coordinate
  depth = distance from camera
  frequency = torus_frequency(depth)

  Place in 3D audio mix:
    pan = azimuth angle
    distance_attenuation = 1 / depth^2
    frequency_color = torus chord at that depth's frequency

  The room shapes the sound. Not a reverb plugin guessing.
  The ACTUAL room geometry governs the audio space.

Face Mesh to ForgeVerse

ARFaceAnchor.geometry:
  1,220 vertices → export as OBJ/FBX
  52 blend shapes → animation channels
  Real-time tracking → live puppet/avatar

Pipeline:
  1. Capture face mesh in Sigilism iOS app
  2. Apply governed vertex positions (torus-mapped)
  3. Export to UE5 via ForgeRender on Bro Horse
  4. Live avatar in ForgeVerse driven by face tracking
  5. Chain-stamp the face geometry (biometric sovereignty)

Scene Mesh for Measurement

ARMeshAnchor provides classified surfaces:
  - floor, wall, ceiling, table, seat, door, WINDOW

For Eclipse Window Film:
  1. Point phone at window
  2. ARKit classifies it as "window"
  3. Mesh vertices give exact dimensions
  4. Square footage calculated instantly
  5. Quote generated from measurement
  6. Video of the window + measurement data = chain-stamped deliverable
  7. Before/after: scan before install, scan after. Proof of work.

For Eclipse Film Crew:
  1. Scan client location
  2. Full 3D model of the space
  3. Plan shots using the model
  4. Present to client in VR/AR before the shoot
  5. Chain-stamped location record

iOS App Architecture

SigilismCapture (iOS App)
│
├── CaptureSession
│   ├── ARSession (ARKit)
│   │   ├── ARWorldTrackingConfiguration
│   │   ├── frameSemantics: .sceneDepth, .smoothedSceneDepth
│   │   ├── sceneReconstruction: .meshWithClassification
│   │   └── faceTrackingConfiguration (front camera mode)
│   │
│   ├── AVCaptureSession (video + audio)
│   │   ├── 768x1296 governed resolution (or nearest hardware supported)
│   │   ├── 24fps
│   │   └── 48kHz audio
│   │
│   └── Synchronized output
│       ├── RGB frame (governed color via Metal shader LUT)
│       ├── Depth frame (CVPixelBuffer)
│       ├── Mesh frame (ARMeshAnchor array)
│       └── Audio buffer (pitch-shifted to 432 Hz in real-time)
│
├── TorusMapper
│   ├── depth_to_torus(depth_map) → frequency_map
│   ├── depth_to_color_weight(depth_map) → warmth_map
│   └── mesh_to_measurement(mesh_anchors) → dimensions
│
├── SigilCodec (on-device encode)
│   ├── Metal shader: LUT + depth-weighted grading + luminance breath
│   ├── Audio: 432 Hz pipeline + optional chord underlay
│   └── Output: h264 + depth sidecar + mesh sidecar
│
├── TransmitEngine
│   ├── Local save (on-device)
│   ├── Stream to Elder/BH via ForgePipe (LAN)
│   ├── Stream to theta.forgechainos.com (tunnel)
│   └── Chain stamp (BSV direct from device)
│
└── UI
    ├── Viewfinder with depth overlay
    ├── Torus frequency visualization (per-pixel)
    ├── Consonance meter (real-time)
    ├── Measurement mode (tap surfaces for dimensions)
    └── Record / Stop / Review / Publish

What Ships First (MVP)

Phase 1: Capture + Encode

iOS app captures video + depth simultaneously
Sigil Codec applied on-device (Metal shader for LUT, CPU for audio pitch)
Output: governed .mp4 + depth map .exr sidecar
Stream to ForgeChainOS over WiFi

Phase 2: Depth-Aware Grading

Near/far field color weighting from depth map
Spatial audio placement prototype
Measurement mode for Eclipse Window Film

Phase 3: Full Sigilism Integration

Timeline editing with depth channel
ForgeVerse mesh export
Face tracking to avatar pipeline
Chain stamp from capture through delivery

The Competitive Moat

Apple built the sensor. We built the protocol. ARKit gives raw data. Sigilism gives it meaning through torus geometry. Apple can't replicate the math because the math is our IP on chain.
LiDAR + media production is virgin territory. DaVinci Resolve has no depth channel. Premiere has no spatial audio from room scans. Nobody does depth-aware color grading from live capture.
The phone is already in every filmmaker's pocket. No new hardware. No rental house. No crew. One phone. One app. One protocol. Shoot.
Measurement + production in one capture. Eclipse Window Film and Eclipse Film Crew converge. The tool that films the job IS the tool that measures the job IS the tool that proves the job. One scan. Three businesses.
Chain-native from frame one. Every capture has a genesis TX. No watermarks. No metadata stripping. The chain IS the proof. This is how content ownership works in a sovereign world.

The sensor exists. The math is proven. The protocol is governed. Connect these speakers.