DA3 to Load3D Camera

This is the node ComfyUI-CameraPack exists for. DA3 to Load3D Camera takes the camera a Depth Anything V3 (DA3) model estimates - the extrinsics pose and the intrinsics matrix - and converts them into the LOAD3D_CAMERA format ComfyUI's native 3D nodes (Preview3D, Load3D) actually render with.

Why you need a translator at all

Depth Anything V3, which hit ComfyUI in late 2025, is the first mainstream depth model in this lineage that gives you the camera alongside the depth map. Its output isn't just a grayscale distance image - it estimates per-view camera extrinsics (a 4×4 world-to-camera pose) and intrinsics (a 3×3 K matrix), which is what unlocks things like gaussian-splat and point-cloud reconstruction from a handful of images.

The catch: the native 3D renderer doesn't speak EXTRINSICS/INTRINSICS. It wants a small dictionary of position, target, zoom, and cameraType. Those are two different languages for the same camera, and this node is the translator. The README's canonical wiring is dead simple:

[DA3 Giant] → extrinsics → [DA3 to Load3D Camera] → camera_info → [Preview 3D]
           → intrinsics ↗

How the conversion works

The math is straightforward rigid-body geometry, and the source code is open if you want the details. From the 4×4 extrinsics (rotation R, translation t):

• Camera position in world space: pos = −Rᵀ · t - you invert the world-to-camera transform to find where the camera actually sits.
• Forward direction: Rᵀ · [0, 0, 1], the camera's Z axis rotated into world space.
• Target point: pos + forward × target_distance. By default that's 1 unit ahead of the camera, and you can move it with the optional target_distance input.

The zoom is derived from the intrinsics: the node averages fx and fy from the K matrix, multiplies by the optional zoom_scale, and clamps the result to the 1–1000 range the native renderer expects.

The inputs it accepts are forgiving: extrinsics can arrive as a [B, 4, 4] batch (it takes the first item), a plain 4×4, or even a 3×4 with the bottom row added for you. Intrinsics just need to be 9 numbers.

Inputs and outputs

• extrinsics (EXTRINSICS) - required, the 4×4 pose from DA3.
• intrinsics (INTRINSICS) - required, the 3×3 K matrix from DA3.
• target_distance (optional, default 1.0) - distance from camera to target along the view direction, per the author's tooltip. This effectively controls how far the camera "looks" down its axis.
• zoom_scale (optional, default 1.0) - scales the focal-length-derived zoom. Crank it up to push in closer.
• Output: camera_info (LOAD3D_CAMERA), wired into Preview3D or any other LOAD3D_CAMERA consumer.

Installing

Part of ComfyUI-CameraPack (PozzettiAndrea). ComfyUI Manager → search "CameraPack" → install, or:

cd ComfyUI/custom_nodes
git clone https://github.com/PozzettiAndrea/ComfyUI-CameraPack.git

Restart ComfyUI and the node appears under 3d/camera. No new dependencies - numpy and torch are already there - and no model files to download. The DA3 model itself lives in whatever depth-estimation pack you're using; this node just converts its outputs. One gotcha: since Preview3D and LOAD3D_CAMERA are ComfyUI core features, keep ComfyUI current or the consumer won't exist.

Where people get burned

The forward-convention guess. The author's code assumes the camera looks along [0, 0, 1] in camera space and explicitly notes the other convention ([0, 0, −1]) exists - the comment says "we'll use [0, 0, 1] and let user adjust." If your Preview3D render shows the scene from behind or upside down, that's the axis convention disagreeing, not a broken install. And because the zoom is derived from focal length rather than read off a slider, don't be surprised if it lands at an odd-looking number; that's zoom_scale's job to fix. Small caveats on an otherwise one-plug conversion.