ComfyUI-qwenmultiangle: 3D camera controls for Qwen angle prompts

The ComfyUI node and its Qwen LoRA target

ComfyUI-qwenmultiangle solves a narrow prompt-authoring problem for users of `Qwen-Image-Edit-2511-Multiple-Angles-LoRA`. Instead of typing a sequence such as an azimuth term, elevation term, and shot distance by hand, the node exposes those choices as linked controls and assembles the English prompt string. Its documentation places the node under `image/multiangle` and identifies its display name as `Qwen Multiangle Camera`.

The project is a ComfyUI custom node rather than a standalone image generator, model, or workflow environment. The generated image model is external to this repository. The node prepares control text, and the README links the corresponding LoRA separately. That division matters when diagnosing a result: changing the viewport may alter the prompt string, but the README does not claim that this node performs image generation or guarantees a particular visual result.

Its main audience is a ComfyUI user who already understands the target LoRA and wants a repeatable way to express camera position. A user who needs arbitrary focal length, lens distortion, depth-of-field language, object placement, or free-form camera direction has more than this node offers. The documented controls cover orientation and distance vocabulary only.

How the Three.js viewport becomes an angle prompt

The repository separates the frontend from the ComfyUI backend. The documented frontend uses Vue 3, TypeScript, and Vite, while `SceneCanvas.vue` hosts the Three.js view. `CameraWidget.ts` acts as the headless camera control engine, and `useCameraWidget.ts` bridges reactive frontend state and that engine. On the Python side, `nodes.py` defines a ComfyUI V3 node.

Three values form the core data flow: `horizontal_angle` for azimuth, `vertical_angle` for elevation, and `zoom` for the documented distance or zoom level. Their documented ranges are 0 to 360 degrees, negative 30 to positive 60 degrees, and 0 to 10 respectively. The README also defines named presets for each dimension. Preset selection updates the 3D handles and slider widgets, while direct manipulation of handles or camera orbit controls updates the widgets. This is a bidirectional synchronization design rather than a set of independent preview controls.

The final output follows this shape:

<sks> {azimuth} {elevation} {distance}

For example, selecting front, eye-level, and medium values produces `<sks> front view eye-level shot medium shot`. The README lists eight azimuth terms, four elevation terms, and three distance terms. Although sliders expose numeric values, the README does not document the mapping of arbitrary intermediate values to generated terms. That is an important distinction between the continuous control surface and the named prompt vocabulary.

Installing the node, LoRA, and frontend assets

The documented installation path uses Git to place the repository in ComfyUI's custom nodes directory. The committed `js/` directory is described as build output for distribution, so the README does not require a local frontend build for this installation route.

cd ComfyUI/custom_nodes

This changes into the custom nodes directory named by the README. From there, clone this repository:

git clone https://github.com/jtydhr88/ComfyUI-qwenmultiangle.git

Restart ComfyUI after cloning. The README also instructs users to download `Qwen-Image-Edit-2511-Multiple-Angles-LoRA` from its Hugging Face repository into the `lora` folder. The repository does not document an exact `lora` path for every ComfyUI installation, so that folder location remains installation-specific.

For frontend development, `package.json` identifies Node.js 18+ and npm as prerequisites. Install the JavaScript dependencies with:

npm install

The production build command is:

npm run build

The documented scripts also include `npm run dev` for a Vite watch build and `npm run typecheck` for TypeScript checking. The repository metadata and `pyproject.toml` both list version `0.7.0`. The README says the build output is committed under `js/`, which means local build commands are primarily relevant to contributors or users modifying the frontend.

Creating the first Qwen Multiangle Camera prompt

After restarting ComfyUI, add `Qwen Multiangle Camera` from the `image/multiangle` category. An `IMAGE` input is optional. Connecting one displays the image in the Three.js scene as a card with its front rendered as an image and its back shown as a grid pattern. Without an image, the camera controls remain available, but the README does not describe a placeholder visual scene.

Start with one of the documented presets rather than trying to infer an arbitrary slider-to-prompt conversion. For example, right-side, high-angle, and close-up values can produce:

<sks> right side view high-angle shot close-up

The output remains English even when the ComfyUI interface is set to Chinese, Japanese, or Korean. The node also has an optional companion node, `Qwen Multiangle Camera Translate`, that translates camera terms when the base prompt uses Chinese, Japanese, or Korean.

The colored handles provide direct manipulation: pink controls horizontal angle, cyan controls vertical angle, and gold controls distance. Enabling `camera_view` changes the preview to the camera indicator's perspective. The README lists mouse dragging and scrolling as controls, and says orbit changes synchronize with the sliders. Before connecting the output into the rest of a workflow, inspect that it contains the expected `<sks>` prefix and one supported term from each of the three categories.

Preset vocabulary, preview modes, and compatibility limits

The presets make the node predictable, but they also define its boundary. Azimuth choices cover front, quarter, side, and back views. Elevation choices map `low-angle shot` to negative 30 degrees, `eye-level shot` to 0 degrees, `elevated shot` to 30 degrees, and `high-angle shot` to 60 degrees. Distance choices are `close-up`, `medium shot`, and `wide shot`. The output must match the format expected by the named Qwen Multiple Angles LoRA.

The README does not document interpolation for a slider position such as an angle between `front view` and `front-right quarter view`. It also does not explain how the numeric `zoom` range maps to a distance term at every value. As a result, users should verify the generated string whenever they move sliders instead of assuming that every numeric value has a documented phrase.

`default_prompts` remains available only for backward compatibility and has no effect. `camera_view` is a preview mode, not a separate output type. The image card is also a navigation aid, not evidence that this node performs 3D reconstruction. Based on the repository layout and README, the scene represents the camera controls and an optional input image, not a reconstructed point cloud or editable 3D subject.

This makes the node wrong for workflows that need continuous numeric camera language, target models with a different trigger syntax, or a general-purpose camera system. It is also a poor fit if translated camera terminology must be produced directly by the main node. Those needs require the companion node or another prompt-construction method.

Manual prompt workflows and the project's upgrade burden

A real alternative is a static ComfyUI workflow that constructs the three-part LoRA prompt from ordinary text inputs, or writes one prompt manually before generation. The difference is directness. ComfyUI-qwenmultiangle adds a synchronized Three.js viewport, image-card preview, camera perspective, draggable handles, and preset dropdowns. A manual approach has less interface code and no Vue or Three.js dependency, but it offers no visual camera indicator and leaves composition and spelling to the author.

For users who change angles frequently, the custom node can reduce repetitive prompt assembly while keeping the target LoRA's vocabulary visible. For occasional use or text-first experimentation, a static prompt may be easier to inspect and version. Neither approach, as described here, proves how a particular image model will interpret a given term.

The repository is not archived, and its last push was on 2026-09-13. That supports treating the current repository as recently changed, but there are no GitHub releases to establish a release history from the supplied information. Frontend maintenance uses Vue 3, TypeScript, Three.js, and Vite, so changes to the node's controls may require corresponding work across `CameraWidget.ts`, `useCameraWidget.ts`, the Vue components, and the prompt-producing backend behavior. Type checking is available through `npm run typecheck`.

`pyproject.toml` and the repository metadata identify the license as MIT. The LICENSE file should be reviewed for its exact obligations when redistributing or incorporating the code. This is a technical note about the published terms, not legal advice.

Editorial conclusion

Adopt ComfyUI-qwenmultiangle if your ComfyUI workflow uses Qwen-Image-Edit-2511-Multiple-Angles-LoRA and you want named angle prompts through an interactive viewport. Do not treat it as a general 3D compositor or a free-form camera-prompt generator, because the documented output is restricted to its supported terms. Verify first that your ComfyUI installation recognizes the `Qwen Multiangle Camera` node, that the LoRA files are present in the expected `lora` folder, and that your workflow consumes the resulting English prompt correctly.

Frequently asked questions

Official sources

1. Issues
2. jtydhr88/ComfyUI-qwenmultiangle on GitHub
3. License: MIT
4. README