Check DAZ Studio connectivity. Returns server status and version.

Execute inline DazScript code in DAZ Studio.

Scripts run in the DAZ Studio JavaScript environment. Global objects: Scene (DzScene), App (DzApp), MainWindow.

⚠️ CRITICAL GOTCHAS - READ BEFORE WRITING SCRIPTS:

1. ❌ NEVER use Action classes (DzNewCameraAction, DzNewLightAction, etc.) They pop modal dialogs and cause TIMEOUTS. ✅ Use direct constructors: new DzBasicCamera(), new DzSpotLight()

2. ❌ NEVER set "Point At" property for camera/light aiming. ✅ Use: node.aimAt(new DzVec3(x, y, z))

3. ✅ Wrap scripts returning values in IIFE: (function(){ return Scene.getNumNodes(); })()

4. ✅ Environment node is ALWAYS Scene.getNode(1) - not findNodeByLabel()

For detailed examples and documentation, use the daz_script_help tool first.

Args: script: DazScript (JavaScript) source code to execute. args: Optional JSON object accessible in script as args variable.

Returns: Object with keys: success, result, output (list of print() lines), error.

Execute a DazScript file on disk inside DAZ Studio.

Args: script_file: Absolute path to the .dsa/.ds script file on the DAZ Studio machine. args: Optional JSON-serialisable object accessible inside the script as args.

Returns: Object with keys: success, result, output (list of print() lines), error.

Get DazScript documentation, examples, and best practices.

Use this tool BEFORE writing DazScript to learn correct patterns and avoid common mistakes. Topics cover critical gotchas, working examples, and detailed API references.

Available topics:

• overview: DazScript environment basics

• gotchas: Critical mistakes that cause timeouts or incorrect results

• camera: Camera creation, positioning, and aiming

• light: Light creation, types, and three-point lighting setup

• environment: Iray environment settings and lighting modes

• scene: Scene management (new, save, load, selection)

• properties: Node properties, transforms, and morphs

• content: Browsing and loading content from library

• coordinates: Coordinate system and positioning reference

• posing: Figure posing, bone hierarchy, morphs vs poses, rotation gotchas

• morphs: Morph discovery, searching, value ranges, and management

• hierarchy: Scene hierarchy, parent-child relationships, parenting operations

• interaction: Multi-character interaction, look-at mechanics, world-space posing

• batch: Batch operations for efficient multi-node/multi-property modifications

• viewport: Viewport and camera control, positioning, framing, presets

• animation: Animation system, keyframing, timeline control, rendering animations

• rendering: Advanced rendering control, multi-camera, batch rendering, animation export

Args: topic: Documentation topic to retrieve (default: "overview")

Returns: Formatted documentation with examples for the requested topic.

Return a snapshot of the current DAZ Studio scene.

Returns figures (characters + clothing), cameras, lights, and the primary selection. Does not enumerate every scene node — use daz_execute for finer-grained queries.

Returns a dict with:

• sceneFile: path to the open .duf file, or empty string if unsaved

• selectedNode: label of the primary selection, or null

• figures: list of {name, label, type} for all DzSkeleton objects

• cameras: list of {name, label} for all cameras

• lights: list of {name, label, type} for all lights

• totalNodes: total node count in the scene

Return all numeric properties of a scene node by its label or internal name.

Useful for reading transforms (X Translate, Y Translate, Z Translate, X Rotate, Y Rotate, Z Rotate, Scale), morph dials, and any other numeric property on the node.

Args: node_label: The display label or internal name of the node (e.g. "Genesis 9"). Label is matched first; internal name is the fallback.

Returns a dict with:

• name: internal node name

• label: display label

• type: DazScript class name (e.g. DzFigure, DzBone, DzCamera)

• properties: mapping of property label → current numeric value

Set a numeric property on a scene node.

Works for transforms (e.g. "X Translate", "Y Rotate"), morphs (e.g. "Head Size"), and any other numeric dial. Use daz_get_node first to discover available property names.

DAZ Studio units: centimetres for translation, degrees for rotation, 0–1 (or percentage) for most morphs.

Args: node_label: Display label or internal name of the target node. property_name: Display label or internal name of the property to set. value: New numeric value.

Returns:

• node: node label as confirmed by DAZ Studio

• property: property label as confirmed by DAZ Studio

• value: the value read back after setting

Trigger a render in DAZ Studio using the current render settings.

Render dimensions, format, and other options are whatever is currently configured in DAZ Studio's Render Settings panel.

Args: output_path: Optional absolute path for the output image (e.g. "C:/renders/scene.png"). If omitted, DAZ Studio uses its currently configured output path.

Returns:

• success: true when the render was launched without error

Load a DAZ Studio file into the current scene.

Args: file_path: Absolute path to the file on the DAZ Studio machine (.duf, .daz, .obj, .fbx, etc.). merge: If True (default), merge the file into the existing scene. If False, replace the current scene entirely.

Returns:

• success: true on success

• file: the path that was loaded

List all morphs (numeric properties) on a node.

Returns all numeric properties on a node, which includes morphs (body shapes, facial expressions), transforms, and other numeric dials. Useful for discovering what morphs are available on a figure.

Args: node_label: Display label or internal name of the node (e.g., "Genesis 9"). include_zero: If True, return all morphs including those set to 0. If False (default), only return morphs with non-zero values (currently active morphs).

Returns:

• morphs: List of morph objects with:

  • label: Display label (e.g., "Head Size")

  • name: Internal name (e.g., "HeadSize")

  • value: Current numeric value

  • path: Property path for organization (e.g., "Morphs/Head")

• count: Number of morphs returned

• nodeLabel: Confirmed node label

Example: # List only active morphs on Genesis 9 result = daz_list_morphs("Genesis 9", include_zero=False) # result["morphs"] = [ # {"label": "Height", "name": "Height", "value": 1.05, "path": "Morphs/Body"}, # {"label": "Head Size", "name": "HeadSize", "value": 0.9, "path": "Morphs/Head"} # ]

# List all available morphs (including zero values)
result = daz_list_morphs("Genesis 9", include_zero=True)
# result["count"] might be 500+ morphs

Search for morphs matching a name pattern.

Search through all numeric properties (morphs) on a node for those matching a substring pattern. Useful for finding specific morphs like all facial expressions, body morphs, or morphs for a specific body part.

Args: node_label: Display label or internal name of the node (e.g., "Genesis 9"). pattern: Substring to search for in morph label or name (case-insensitive). Examples: "smile", "head", "muscle", "express" include_zero: If True, return all matching morphs including zero values. If False (default), only return matching morphs that are active.

Returns:

• morphs: List of matching morph objects with:

  • label: Display label

  • name: Internal name

  • value: Current value

  • path: Property path

• count: Number of matching morphs

• pattern: The search pattern used

• nodeLabel: Confirmed node label

Example: # Find all smile-related morphs result = daz_search_morphs("Genesis 9", "smile", include_zero=True) # result["morphs"] might include: "Smile", "Smile Open", "Smile Closed", etc.

# Find active head morphs
result = daz_search_morphs("Genesis 9", "head", include_zero=False)
# Only returns head morphs with non-zero values

# Find all facial expression morphs
result = daz_search_morphs("Genesis 9", "express", include_zero=True)

Get complete hierarchy tree for a node with all descendants.

Returns the full hierarchical structure of a node, including all children, grandchildren, etc. Useful for understanding skeleton structure, bone relationships, and complex scene hierarchies.

Args: node_label: Display label or internal name of the root node. max_depth: Maximum recursion depth (default 10, 0 = unlimited). Use to limit deep hierarchies (e.g., Genesis 9 skeleton has 100+ bones).

Returns:

• node: Root node label

• hierarchy: Nested structure with:

  • label: Node display label

  • name: Internal name

  • type: DazScript class name

  • children: List of child hierarchies (recursive)

• totalDescendants: Total number of descendants

Example: # Get skeleton hierarchy with depth limit result = daz_get_node_hierarchy("Genesis 9", max_depth=3) # Returns nested structure: hip -> abdomen -> chest -> ...

# Get full hierarchy (warning: can be large)
result = daz_get_node_hierarchy("Genesis 9", max_depth=0)
# Returns complete skeleton with all 100+ bones

# Get prop hierarchy
result = daz_get_node_hierarchy("Sword", max_depth=5)

List direct children of a node.

Returns only the immediate children (not grandchildren). Useful for exploring hierarchy one level at a time or checking if a node has children.

Args: node_label: Display label or internal name of the parent node.

Returns:

• node: Parent node label

• children: List of child objects with:

  • label: Child display label

  • name: Child internal name

  • type: DazScript class name

• count: Number of children

Example: # List children of Genesis 9 root result = daz_list_children("Genesis 9") # Returns: [{"label": "hip", "name": "hip", "type": "DzBone"}]

# Check if node has children
result = daz_list_children("Camera 1")
# result["count"] == 0 means no children

# List bones under hip
result = daz_list_children("hip")
# Returns: pelvis, lThighBend, rThighBend

Get parent node of a node.

Returns the immediate parent of a node, or null if the node is a root node (no parent). Useful for traversing hierarchy upward.

Args: node_label: Display label or internal name of the child node.

Returns:

• node: Child node label

• parent: Parent node object with label, name, type, or null if no parent

Example: # Get parent of a bone result = daz_get_parent("lHand") # Returns: {"parent": {"label": "lForearmBend", "name": "lForearmBend", ...}}

# Check if node is root (has no parent)
result = daz_get_parent("Genesis 9")
# result["parent"] == null

# Traverse hierarchy upward
node = "lIndex3"
while True:
    result = daz_get_parent(node)
    if not result["parent"]:
        break
    print(f"Parent of {node}: {result['parent']['label']}")
    node = result["parent"]["label"]

Set parent of a node (parenting operation).

Changes the parent of a node, effectively moving it in the scene hierarchy. Commonly used to attach props to figures (e.g., weapon to hand) or reorganize scene structure.

Args: node_label: Display label or internal name of node to parent. parent_label: Display label or internal name of new parent. maintain_world_transform: If True (default), adjust local transform to maintain the same world-space position/rotation. If False, keep local transform (node will move in world space).

Returns:

• success: true on success

• node: Node label

• newParent: New parent label

• previousParent: Previous parent label (or null if was root)

Example: # Attach sword to right hand (maintain position) result = daz_set_parent("Sword", "rHand", maintain_world_transform=True) # Sword stays in place, now follows hand movements

# Parent camera to figure (follows figure)
result = daz_set_parent("Camera 1", "Genesis 9", maintain_world_transform=True)

# Unparent node (make it root) - parent to Scene root
result = daz_set_parent("Prop", "Scene", maintain_world_transform=True)

Note: When maintain_world_transform=True, the node's world position is preserved, but its local transform values (X/Y/Z Translate, Rotate) will change to account for the new parent's transform.

Make character look at a world-space point with configurable body involvement.

This helper uses cascading rotations from eyes through the body to create natural-looking character attention. Different modes control how much of the body participates in the look direction.

Args: character_label: Display label or internal name of the character figure. target_x: World X coordinate (cm) to look at. target_y: World Y coordinate (cm) to look at. target_z: World Z coordinate (cm) to look at. mode: How much body to involve in the look. Options: - "eyes": Only rotate eyes - "head": Eyes + head rotation (default) - "neck": Eyes + head + neck - "torso": Eyes + head + neck + chest - "full": Complete body rotation including hip

Returns:

• success: true on success

• character: character label

• mode: the mode used

• rotatedBones: list of bone labels that were rotated

Example: # Character looks at point in front of them at eye level daz_look_at_point("Genesis 9", 0, 160, 200, mode="head")

# Full body turn to look behind
daz_look_at_point("Genesis 9", 0, 140, -150, mode="full")

Make one character look at another character's face.

Automatically finds the target character's head position and rotates the source character to look at it using cascading body rotations.

Args: source_label: Display label of the character who will look. target_label: Display label of the character to look at. mode: How much body to involve. Options: - "eyes": Only rotate eyes - "head": Eyes + head rotation (default) - "neck": Eyes + head + neck - "torso": Eyes + head + neck + chest - "full": Complete body rotation including hip

Returns:

• success: true on success

• source: source character label

• target: target character label

• mode: the mode used

• targetPosition: {x, y, z} world coordinates of target's head

• rotatedBones: list of bone labels that were rotated

Example: # Alice looks at Bob with head turn daz_look_at_character("Alice", "Bob", mode="head")

# Bob turns his whole body to face Alice
daz_look_at_character("Bob", "Alice", mode="full")

Position character's arm to reach toward a world-space point.

Uses pseudo-IK approximation to calculate shoulder and elbow rotations that position the hand near the target point. Automatically adjusts elbow bend based on target distance.

Args: character_label: Display label or internal name of the character. side: Which arm to use: "left" or "right". target_x: World X coordinate (cm) to reach toward. target_y: World Y coordinate (cm) to reach toward. target_z: World Z coordinate (cm) to reach toward.

Returns:

• success: true on success

• character: character label

• side: which arm was posed

• targetDistance: distance in cm from shoulder to target

• bones: list of bone labels that were rotated

Example: # Reach right hand toward point in front at chest height daz_reach_toward("Genesis 9", "right", 50, 130, 80)

# Reach left hand toward object on left side
daz_reach_toward("Genesis 9", "left", -60, 100, 50)

Note: This uses simplified IK approximation. For precise hand positioning or complex reaching, load an artist-created pose preset instead.

Coordinate two characters for interactive poses.

Applies complementary poses to two characters for common interaction scenarios. Handles both positioning and pose application.

Args: char1_label: Display label of first character. char2_label: Display label of second character. interaction_type: Type of interaction. Options: - "face-each-other": Position and rotate to face each other (default) - "hug": Both characters hug with arms around each other - "shoulder-arm": Char1 puts arm around char2's shoulders - "handshake": Both extend right hands for handshake distance: Optional spacing between characters in cm (default varies by type: face=100, hug=40, shoulder-arm=30, handshake=60).

Returns:

• success: true on success

• char1: first character label

• char2: second character label

• interactionType: the interaction type used

• applied: list of pose components that were applied

Example: # Position characters facing each other at conversation distance daz_interactive_pose("Alice", "Bob", "face-each-other", distance=120)

# Create tight hug
daz_interactive_pose("Alice", "Bob", "hug", distance=30)

# Bob puts arm around Alice's shoulders
daz_interactive_pose("Bob", "Alice", "shoulder-arm")

Note: These are simplified interaction poses. For natural-looking results, you may need to fine-tune positions and rotations using daz_set_property or load artist-created pose presets.

Set multiple properties on one or more nodes in a single call.

Executes multiple property-setting operations with individual error handling. Failed operations don't abort the entire batch - each operation returns success status and error details.

Args: operations: List of operation objects, each containing: - nodeLabel (str): Display label of the node - propertyName (str): Property label or internal name - value (float): New value for the property

Returns:

• results: Array of result objects with success, node, property, value, error

• successCount: Number of successful operations

• failureCount: Number of failed operations

• total: Total number of operations attempted

Example: # Set multiple properties on different nodes daz_batch_set_properties([ {"nodeLabel": "Genesis 9", "propertyName": "XTranslate", "value": 100}, {"nodeLabel": "Genesis 9", "propertyName": "YRotate", "value": 45}, {"nodeLabel": "Camera 1", "propertyName": "ZTranslate", "value": 300} ])

# Apply multiple morphs to a character
daz_batch_set_properties([
    {"nodeLabel": "Genesis 9", "propertyName": "PHMSmile", "value": 0.5},
    {"nodeLabel": "Genesis 9", "propertyName": "PHMEyesWide", "value": 0.3},
    {"nodeLabel": "Genesis 9", "propertyName": "PHMBrowsUp", "value": 0.4}
])

Note: This is significantly more efficient than calling daz_set_property individually for each operation. All operations execute in a single script call to DAZ Studio.

Apply the same transform properties to multiple nodes.

Useful for moving, rotating, or scaling multiple objects by the same amount. Only properties that exist on each node are applied (missing properties are silently skipped).

Args: node_labels: List of node display labels to transform. transforms: Dictionary of property names to values (e.g., {"XTranslate": 50, "YRotate": 45}).

Returns:

• results: Array of result objects with success, node, applied properties, error

• successCount: Number of nodes successfully transformed

• failureCount: Number of nodes that failed

• total: Total number of nodes attempted

Example: # Move multiple props to the right daz_batch_transform( ["Prop1", "Prop2", "Prop3"], {"XTranslate": 100} )

# Rotate and scale multiple objects
daz_batch_transform(
    ["Chair", "Table", "Lamp"],
    {"YRotate": 45, "Scale": 1.2}
)

# Reset rotation for all cameras
daz_batch_transform(
    ["Camera 1", "Camera 2", "Camera 3"],
    {"XRotate": 0, "YRotate": 0, "ZRotate": 0}
)

Note: Transform properties include: XTranslate, YTranslate, ZTranslate, XRotate, YRotate, ZRotate, Scale, XScale, YScale, ZScale.

Show or hide multiple nodes in the viewport and renders.

Args: node_labels: List of node display labels to modify. visible: True to show nodes, False to hide them (default: True).

Returns:

• results: Array of result objects with success, node, visible state, error

• successCount: Number of nodes successfully modified

• failureCount: Number of nodes that failed

• total: Total number of nodes attempted

Example: # Hide all cameras daz_batch_visibility(["Camera 1", "Camera 2", "Camera 3"], visible=False)

# Show multiple props
daz_batch_visibility(["Sword", "Shield", "Helmet"], visible=True)

# Hide environment elements for character close-up
daz_batch_visibility(["Ground", "Sky Dome", "Background"], visible=False)

Note: Hidden nodes are not visible in the viewport or renders, but remain in the scene. Use this for scene management, testing different configurations, or optimizing render times.

Select multiple nodes in the DAZ Studio scene.

Args: node_labels: List of node display labels to select. add_to_selection: If True, add to current selection; if False, replace current selection (default: False).

Returns:

• selected: Array of node labels that were successfully selected

• count: Number of nodes selected

• total: Total number of node labels provided

Example: # Select multiple characters daz_batch_select(["Genesis 9", "Genesis 8 Female"])

# Add props to current selection
daz_batch_select(["Sword", "Shield"], add_to_selection=True)

# Select all lights in scene
daz_batch_select(["Spot Light 1", "Distant Light 1", "Point Light 1"])

Note: Selection affects which nodes appear in the Scene/Parameters panes in DAZ Studio. Some operations apply to the current selection. Nodes that don't exist are silently skipped.

Set which camera is active in the DAZ Studio viewport.

Changes the active viewport camera to show the scene from the specified camera's perspective. The previous active camera is returned for reference.

Args: camera_label: Display label of the camera to activate.

Returns:

• success: true on success

• camera: label of the camera that was activated

• previousCamera: label of the previously active camera (or null)

Example: # Switch to a specific camera daz_set_active_camera("Camera 1")

# Switch to a custom camera
daz_set_active_camera("Close Up Camera")

# Switch back to default camera
daz_set_active_camera("Perspective View")

Note: The camera must exist in the scene. Use daz_scene_info() to list available cameras. The viewport updates immediately to show the camera's current view.

Position camera orbiting around a target node at specified angle and distance.

Uses spherical coordinates to position the camera at a specific angle around a target object. The camera is automatically aimed at the target after positioning.

Args: camera_label: Display label of the camera to position. target_label: Display label of the target node to orbit around. distance: Distance from target in centimeters (default: 200). angle_horizontal: Horizontal angle in degrees, 0=front/+Z, 90=right/+X (default: 45). angle_vertical: Vertical angle in degrees, positive=above, negative=below (default: 15).

Returns:

• success: true on success

• camera: camera label

• target: target node label

• position: camera world position {x, y, z}

• targetPosition: target world position {x, y, z}

Example: # Position camera at 45° to the right, slightly above, 200cm away daz_orbit_camera_around("Camera 1", "Genesis 9", distance=200, angle_horizontal=45, angle_vertical=15)

# Side view from the left
daz_orbit_camera_around("Camera 1", "Genesis 9", distance=150,
                        angle_horizontal=-90, angle_vertical=0)

# Bird's eye view
daz_orbit_camera_around("Camera 1", "Genesis 9", distance=300,
                        angle_horizontal=0, angle_vertical=60)

# Dramatic low angle
daz_orbit_camera_around("Camera 1", "Genesis 9", distance=180,
                        angle_horizontal=25, angle_vertical=-20)

Note: Angles use spherical coordinates: - Horizontal: 0°=front(+Z), 90°=right(+X), 180°=back(-Z), -90°=left(-X) - Vertical: positive=above horizon, negative=below

Camera is automatically aimed at the target's world position after positioning.

Frame camera to show a node by positioning at calculated distance.

Positions the camera to frame the specified node in view. Calculates the node's bounding box and positions the camera at an appropriate distance to show the entire object. Camera is positioned in front (+Z) and aimed at the node's center.

Args: camera_label: Display label of the camera to position. node_label: Display label of the node to frame. distance: Optional distance from node center in cm. If not specified, calculated as 2.5x the largest dimension of the node's bounding box.

Returns:

• success: true on success

• camera: camera label

• node: node label

• position: camera world position {x, y, z}

• nodeCenter: node bounding box center {x, y, z}

• nodeSize: node bounding box size {x, y, z}

Example: # Frame a character (auto distance) daz_frame_camera_to_node("Camera 1", "Genesis 9")

# Frame a prop with specific distance
daz_frame_camera_to_node("Camera 1", "Sword", distance=50)

# Frame entire scene
daz_frame_camera_to_node("Camera 1", "Scene", distance=500)

# Close-up on head
daz_frame_camera_to_node("Camera 1", "head", distance=30)

Note: - Auto-calculated distance is 2.5x the largest bounding box dimension - Camera is positioned in front of the node (+Z direction) - Camera is aimed at the center of the node's bounding box - Useful for automatically framing objects of varying sizes

Save camera position and rotation as preset data.

Captures the current transform properties of a camera (position, rotation, scale) and returns them as preset data. This data can be saved by the client and later restored using daz_load_camera_preset().

Args: camera_label: Display label of the camera to save.

Returns:

• preset: Dictionary containing:

  • label: camera label

  • transforms: Dictionary of property names to values (XTranslate, YTranslate, ZTranslate, XRotate, YRotate, ZRotate, XScale, YScale, ZScale)

Example: # Save camera position preset = daz_save_camera_preset("Camera 1")

# Client can store preset data (e.g., in a file or database)
import json
with open("my_camera_preset.json", "w") as f:
    json.dump(preset, f)

# Later, restore the camera
with open("my_camera_preset.json") as f:
    preset = json.load(f)
daz_load_camera_preset("Camera 1", preset["preset"])

Note: - Preset data is a plain dictionary that can be serialized (JSON, etc.) - Includes all transform properties (position, rotation, scale) - Does not include camera-specific settings (focal length, DOF, etc.) - Preset data can be applied to any camera, not just the original

Restore camera position and rotation from preset data.

Applies saved preset data (from daz_save_camera_preset()) to a camera, restoring its position, rotation, and scale.

Args: camera_label: Display label of the camera to modify. preset: Preset dictionary from daz_save_camera_preset(), containing: - transforms: Dictionary of property names to values

Returns:

• success: true on success

• camera: camera label

• applied: list of property names that were applied

Example: # Load previously saved preset with open("my_camera_preset.json") as f: preset = json.load(f)

result = daz_load_camera_preset("Camera 1", preset["preset"])
print(f"Applied properties: {result['applied']}")

# Apply same preset to multiple cameras
cameras = ["Camera 1", "Camera 2", "Camera 3"]
for cam in cameras:
    daz_load_camera_preset(cam, preset["preset"])

Note: - Preset can be applied to any camera, not just the original - Only properties present in the preset are modified - Useful for saving/loading camera positions across sessions - Can be used to synchronize multiple cameras

Set a keyframe on a property at specified frame.

Creates or updates a keyframe for a numeric property at the given frame number. This is the fundamental operation for creating property animations.

Args: node_label: Display label of the node. property_name: Property label or internal name. frame: Frame number (integer, typically 0-based). value: Value to set at this frame.

Returns:

• success: true on success

• node: node label

• property: property label

• frame: frame number

• value: value set at the keyframe

Example: # Animate character moving right (0 to 100cm over 30 frames) daz_set_keyframe("Genesis 9", "XTranslate", frame=0, value=0) daz_set_keyframe("Genesis 9", "XTranslate", frame=30, value=100)

# Animate rotation (0 to 90 degrees over 60 frames)
daz_set_keyframe("Genesis 9", "YRotate", frame=0, value=0)
daz_set_keyframe("Genesis 9", "YRotate", frame=60, value=90)

# Animate morph (fade in smile)
daz_set_keyframe("Genesis 9", "PHMSmile", frame=0, value=0)
daz_set_keyframe("Genesis 9", "PHMSmile", frame=15, value=0.8)

Note: - DAZ Studio interpolates between keyframes automatically - Setting a keyframe at an existing frame updates the value - Frames are typically 0-based integers - Use daz_set_frame_range() to define the animation length first

Get all keyframes for a property.

Returns all keyframes currently set on a property, including frame numbers and values. Useful for inspecting existing animations or copying keyframes.

Args: node_label: Display label of the node. property_name: Property label or internal name.

Returns:

• keyframes: Array of {frame, value} objects

• count: Number of keyframes

Example: # Get keyframes for a property result = daz_get_keyframes("Genesis 9", "XTranslate") print(f"Found {result['count']} keyframes:") for kf in result['keyframes']: print(f" Frame {kf['frame']}: {kf['value']}")

# Copy keyframes to another property
keyframes = daz_get_keyframes("Genesis 9", "XTranslate")
for kf in keyframes['keyframes']:
    daz_set_keyframe("Genesis 8", "XTranslate", kf['frame'], kf['value'])

# Check if property is animated
result = daz_get_keyframes("Genesis 9", "YRotate")
if result['count'] > 0:
    print("Property is animated")

Note: - Returns empty array if property has no keyframes - Keyframes are returned in frame order - Frame numbers are integers, values are floats

Remove a keyframe at specified frame.

Deletes a single keyframe from a property at the given frame number. Other keyframes on the property remain unchanged.

Args: node_label: Display label of the node. property_name: Property label or internal name. frame: Frame number of keyframe to remove.

Returns:

• success: true

• node: node label

• property: property label

• frame: frame number

• removed: true if keyframe existed and was removed, false if no keyframe at that frame

Example: # Remove specific keyframe daz_remove_keyframe("Genesis 9", "XTranslate", frame=15)

# Remove all keyframes one by one
keyframes = daz_get_keyframes("Genesis 9", "XTranslate")
for kf in keyframes['keyframes']:
    daz_remove_keyframe("Genesis 9", "XTranslate", kf['frame'])

Note: - If no keyframe exists at the frame, removed=false (not an error) - Other keyframes remain unchanged - Use daz_clear_animation() to remove all keyframes at once

Remove all keyframes from a property.

Clears all animation data from a property, returning it to a static (non-animated) state. More efficient than removing keyframes individually.

Args: node_label: Display label of the node. property_name: Property label or internal name.

Returns:

• success: true

• node: node label

• property: property label

• removed: number of keyframes removed

Example: # Clear animation from a property result = daz_clear_animation("Genesis 9", "XTranslate") print(f"Removed {result['removed']} keyframes")

# Clear all transform animations
transforms = ["XTranslate", "YTranslate", "ZTranslate",
              "XRotate", "YRotate", "ZRotate"]
for prop in transforms:
    daz_clear_animation("Genesis 9", prop)

Note: - Removes all keyframes in a single operation - More efficient than calling daz_remove_keyframe() repeatedly - Property retains its current value after clearing - Returns count of keyframes that were removed

Set current animation frame.

Moves the timeline to the specified frame. This updates the scene to show the state at that frame, evaluating all animated properties.

Args: frame: Frame number to move to (integer).

Returns:

• success: true

• frame: new current frame

• previousFrame: frame number before the change

Example: # Jump to specific frame daz_set_frame(30)

# Render each frame of animation
info = daz_get_animation_info()
for frame in range(info['startFrame'], info['endFrame'] + 1):
    daz_set_frame(frame)
    daz_render(output_path=f"frame_{frame:04d}.png")

# Preview keyframes
keyframes = daz_get_keyframes("Genesis 9", "XTranslate")
for kf in keyframes['keyframes']:
    daz_set_frame(kf['frame'])
    # ... preview or inspect ...

Note: - Scene updates to show animated state at the frame - All animated properties evaluate at the new frame - Frame numbers are typically 0-based integers - Use with daz_render() to export animation frames

Set animation frame range (start and end).

Defines the playback range for the animation timeline. This determines which frames are included when playing or exporting animation.

Args: start_frame: First frame of animation (typically 0). end_frame: Last frame of animation.

Returns:

• success: true

• startFrame: new start frame

• endFrame: new end frame

• previousStart: previous start frame

• previousEnd: previous end frame

Example: # Set 120-frame animation (4 seconds at 30fps) daz_set_frame_range(0, 119)

# Set 300-frame animation (10 seconds at 30fps)
daz_set_frame_range(0, 299)

# Set custom range starting from frame 10
daz_set_frame_range(10, 100)

Note: - Frame range is inclusive (both start and end frames are included) - Default FPS in DAZ Studio is typically 30 - Duration in seconds = (end - start + 1) / fps - Example: frames 0-29 at 30fps = 1 second (30 frames)

Get animation timeline info (current frame, range, fps).

Returns information about the current animation timeline state, including the current frame, frame range, and frames per second.

Returns:

• currentFrame: current timeline position

• startFrame: first frame of animation range

• endFrame: last frame of animation range

• fps: frames per second

• totalFrames: total number of frames (endFrame - startFrame + 1)

• durationSeconds: animation duration in seconds

Example: # Get timeline info info = daz_get_animation_info() print(f"Current frame: {info['currentFrame']}") print(f"Range: {info['startFrame']}-{info['endFrame']}") print(f"Duration: {info['durationSeconds']} seconds") print(f"FPS: {info['fps']}")

# Render entire animation
info = daz_get_animation_info()
for frame in range(info['startFrame'], info['endFrame'] + 1):
    daz_set_frame(frame)
    daz_render(output_path=f"output/frame_{frame:04d}.png")

# Check if at end of animation
info = daz_get_animation_info()
if info['currentFrame'] >= info['endFrame']:
    print("At end of animation")

Note: - FPS is typically 30 in DAZ Studio - Frame range is inclusive (both start and end are included) - totalFrames includes both start and end frames - Use before rendering animation to know frame count

Render from specific camera without changing active viewport camera.

Renders the scene from the specified camera's viewpoint. The viewport camera remains unchanged, making this ideal for multi-camera renders without disrupting the user's viewport.

Args: camera_label: Display label of the camera to render from. output_path: Optional output file path. If not specified, renders to viewport.

Returns:

• success: true on success

• camera: camera label used for render

• outputPath: output file path (or null if rendered to viewport)

Example: # Render from specific camera daz_render_with_camera("Camera 1", output_path="/path/to/render.png")

# Render from multiple cameras without changing viewport
cameras = ["Front", "Side", "Top", "Perspective"]
for cam in cameras:
    daz_render_with_camera(cam, output_path=f"renders/{cam}.png")

# Test render from camera (to viewport, no file)
daz_render_with_camera("Camera 1")

Note: - Viewport camera remains unchanged after render - Previous render camera is restored automatically - Use for multi-camera batch renders - Combine with daz_orbit_camera_around() to set up camera first

Get current render settings and configuration.

Returns information about the current render configuration, including render target, output path, aspect ratio, and render camera.

Returns:

• renderToFile: true if rendering to file, false if to viewport

• outputPath: current output file path (or null)

• currentCamera: label of current render camera (or null for viewport camera)

• aspectRatio: aspect ratio value

• aspectWidth: aspect width component

• aspectHeight: aspect height component

Example: # Check render settings settings = daz_get_render_settings() print(f"Render camera: {settings['currentCamera']}") print(f"Output: {settings['outputPath']}") print(f"Aspect: {settings['aspectWidth']}x{settings['aspectHeight']}")

# Verify render is configured correctly before batch render
settings = daz_get_render_settings()
if not settings['renderToFile']:
    print("Warning: Render is configured for viewport, not file output")

Note: - Aspect ratio determines render dimensions relative to each other - Pixel dimensions cannot be set reliably via DazScript - currentCamera may be null if using active viewport camera

Render from multiple cameras in sequence.

Renders the same scene from multiple camera angles in a single operation. Each camera generates a separate output file with the camera name appended.

Args: cameras: List of camera labels to render from. output_dir: Output directory for rendered images. base_filename: Base filename (default: "render"). Camera name is appended automatically.

Returns:

• success: true on success

• rendered: Array of {camera, outputPath} objects

• total: Total number of cameras attempted

Example: # Render from multiple preset cameras daz_batch_render_cameras( cameras=["Front", "Side", "Top", "Perspective"], output_dir="/path/to/renders", base_filename="character" ) # Generates: character_Front.png, character_Side.png, etc.

# Render turntable (8 cameras around character)
cameras = [f"Cam_{angle}" for angle in [0, 45, 90, 135, 180, 225, 270, 315]]
daz_batch_render_cameras(cameras, "/path/to/turntable", "frame")

# Render all cameras in scene
scene_info = daz_scene_info()
all_cameras = [cam['label'] for cam in scene_info['cameras']]
daz_batch_render_cameras(all_cameras, "/path/to/renders")

Note: - Camera names in filenames have non-alphanumeric chars replaced with underscores - All renders use current scene state (same lighting, poses, etc.) - Previous render camera is restored after batch completes - Cameras that don't exist are skipped

Render animation frame range as image sequence.

Renders each frame of an animation to separate image files. Automatically advances through frames and generates zero-padded filenames for proper sorting. This is the recommended way to export animations.

Args: output_dir: Output directory for rendered frames. start_frame: First frame to render (default: animation range start). end_frame: Last frame to render (default: animation range end). filename_pattern: Filename pattern (default: "frame"). Frame number is appended. camera: Optional camera label to render from (default: current render camera).

Returns:

• success: true on success

• rendered: Array of {frame, outputPath} objects

• total: Total number of frames rendered

• frames: {start, end} frame range rendered

Example: # Render entire animation daz_render_animation(output_dir="/path/to/animation") # Generates: frame_0000.png, frame_0001.png, ..., frame_0119.png

# Render specific frame range
daz_render_animation(
    output_dir="/path/to/animation",
    start_frame=30,
    end_frame=60,
    filename_pattern="clip"
)

# Render animation from specific camera
daz_render_animation(
    output_dir="/path/to/animation",
    camera="Camera 1"
)

# Render preview (every 5th frame)
info = daz_get_animation_info()
for frame in range(info['startFrame'], info['endFrame'] + 1, 5):
    daz_render_animation(
        output_dir="/path/to/preview",
        start_frame=frame,
        end_frame=frame,
        filename_pattern=f"preview_frame"
    )

Note: - Frame numbers are zero-padded to 4 digits (0000, 0001, etc.) - Current timeline frame is restored after render completes - If camera is specified, render camera is restored after completion - Use daz_get_animation_info() to get default frame range - Convert to video: ffmpeg -framerate 30 -i frame_%04d.png output.mp4

Get world-space position, local position, rotation, and scale of a node.

Useful for understanding where nodes are in 3D space before making relative positioning decisions.

Args: node_label: Display label of the node (e.g. "Genesis 9", "Camera 1")

Returns: { "node": "Genesis 9", "world_position": {"x": 0.0, "y": 0.0, "z": 0.0}, "local_position": {"x": 0.0, "y": 0.0, "z": 0.0}, "rotation": {"x": 0.0, "y": 0.0, "z": 0.0}, "scale": {"x": 1.0, "y": 1.0, "z": 1.0} }

Get the axis-aligned bounding box of a node.

Returns min/max corners, center point, and dimensions. Use this to auto-calculate camera distance, detect collisions, or anchor lights relative to a character's actual size.

Args: node_label: Display label of the node

Returns: { "node": "Genesis 9", "min": {"x": -30.0, "y": 0.0, "z": -15.0}, "max": {"x": 30.0, "y": 175.0, "z": 15.0}, "center": {"x": 0.0, "y": 87.5, "z": 0.0}, "width": 60.0, "height": 175.0, "depth": 30.0 }

Calculate the distance between two nodes.

Returns total distance, horizontal distance, vertical distance, and the direction vector. All distances in centimeters.

Args: node1_label: Display label of the first node node2_label: Display label of the second node

Returns: { "node1": "Genesis 9", "node2": "Camera 1", "distance": 250.5, "vector": {"dx": 0.0, "dy": 50.0, "dz": 245.0}, "horizontal_distance": 245.0, "vertical_distance": 50.0 }

Get the spatial relationship between two nodes in natural language.

Returns direction (front, back, left, right, above, below), angles, distance, and whether their bounding boxes overlap.

Horizontal angle uses DAZ coordinate system: 0°=front(+Z for Genesis figures), 90°=right(+X), 180°=back(-Z), -90°=left(-X).

Args: node1_label: The reference node (e.g. "Genesis 9") node2_label: The target node to describe relative to node1 (e.g. "Camera 1")

Returns: { "node1": "Genesis 9", "node2": "Camera 1", "distance": 250.5, "direction": "front", "angle_horizontal": 5.0, "angle_vertical": 12.0, "relative_position": "Camera 1 is front above of Genesis 9 (250 cm away)", "overlapping": false }

Check if two nodes have overlapping bounding boxes (collision detection).

Uses axis-aligned bounding box (AABB) intersection. Returns whether they overlap, the penetration depth, and a suggestion for resolving the collision.

Args: node1_label: Display label of the first node node2_label: Display label of the second node

Returns: { "node1": "Alice", "node2": "Bob", "overlapping": true, "penetration_depth": 15.0, "suggestion": "Move Bob 20 cm in +X direction to resolve collision" }

List all properties on a node with their types, values, and constraints.

Use this to discover what properties are available on a node before using daz_set_property. Much more reliable than guessing property names.

Args: node_label: Display label of the node property_type: Filter type — one of: "all" - all properties "numeric" - all numeric (float/bool) properties "transform" - XTranslate/YTranslate/ZTranslate/XRotate/YRotate/ZRotate/Scale "morph" - numeric properties that are not transforms "bool" - boolean properties only "string" - string properties only

Returns: { "node": "Spotlight 1", "properties": [ { "label": "Luminous Flux (Lumen)", "name": "Flux", "type": "DzFloatProperty", "value": 1500.0, "min": 0.0, "max": 100000.0, "path": "Light/Photometrics", "is_animatable": true } ], "count": 45 }

Get detailed metadata for a single named property on a node.

Accepts either the display label (e.g. "Luminous Flux (Lumen)") or the internal name (e.g. "Flux"). Use this to validate a value is within min/max range before setting it.

Args: node_label: Display label of the node property_name: Property label or internal name

Returns: { "label": "Luminous Flux (Lumen)", "name": "Flux", "type": "DzFloatProperty", "current_value": 1500.0, "default_value": 1500.0, "min": 0.0, "max": 100000.0, "is_animatable": true, "path": "Light/Photometrics", "node": "Spotlight 1" }

Check a DazScript string for known anti-patterns before execution.

Performs static analysis only — no script is sent to DAZ Studio. Returns errors for known crash/timeout patterns and warnings for deprecated or error-prone usage.

Args: script: DazScript (JavaScript) source code to validate

Returns: { "valid": false, "errors": [ { "line": 3, "pattern": "DzNewCameraAction", "message": "Action classes pop modal dialogs and cause timeouts", "suggestion": "Use: var cam = new DzBasicCamera(); Scene.addNode(cam);" } ], "warnings": [...], "suggestions": [...] }

Create a professional photography lighting setup in one command.

Removes any existing lights with the same names, creates new lights at positions calculated relative to the subject's bounding box, aims each light at the subject's face height, and sets the environment to scene-lights-only mode (disables the dome).

Available presets: three-point - Key (front-right) + Fill (front-left) + Rim (back). The most versatile general-purpose lighting setup. rembrandt - Key (45° side, high) + dim Fill. Creates triangle of light under opposite eye. Dramatic portrait lighting. butterfly - Key directly in front, high. Glamour/beauty lighting. Creates butterfly shadow under the nose. split - Key directly to one side (90°). Half face lit, half in shadow. Moody, high-contrast. loop - Key (35° side) + Fill + Rim. Natural-looking portrait. Small loop shadow on opposite cheek.

Args: preset: Lighting preset name (see above) subject_label: Optional node label to anchor lights around. If omitted, lights are placed relative to scene origin at 170cm height.

Returns: { "preset": "three-point", "subject": "Genesis 9", "lights_created": [ {"label": "Key Light", "type": "DzSpotLight", "position": {"x": 150, "y": 180, "z": 150}, "flux": 2000} ], "environment_mode": "Scene Only (3)" }

Validate the current scene for common issues before rendering.

Checks:

• Character/figure bounding box collisions (interpenetration)

• Lighting presence and quality

• Camera presence

• Empty scene (no figures)

Returns a score (0-100) and breakdown by category, plus actionable suggestions for any issues found.

Returns: { "valid": true, "issues": [ { "type": "collision", "severity": "high", "nodes": ["Alice", "Bob"], "description": "Alice and Bob bounding boxes overlap by ~15 cm", "suggestion": "Move one character away to resolve interpenetration" } ], "warnings": [...], "score": 75, "score_breakdown": { "lighting": 100, "collision": 30, "camera": 100, "figures": 100 }, "summary": { "figures": 2, "cameras": 1, "lights": 3, "environment_lighting": false } }

Start a render asynchronously — returns immediately with a request_id.

Use daz_get_request_status() to poll progress and daz_get_request_result() to retrieve the final result.

IMPORTANT: The scene is locked while the render runs. Do not modify the scene until the request status is "completed", "failed", or "cancelled".

Args: output_path: Optional file path for the rendered image.

Returns: {"request_id": "script-XXXXXXXX", "status": "queued", "submitted_at": "..."}

Start a camera-specific render asynchronously — returns immediately with a request_id.

Renders from the specified camera without changing the active viewport camera. Use daz_get_request_status() to poll and daz_get_request_result() for the result.

Args: camera_label: Display label of the camera to render from. output_path: Optional file path for the rendered image.

Returns: {"request_id": "script-XXXXXXXX", "status": "queued", "submitted_at": "..."}

Queue renders from multiple cameras — each becomes its own async request.

Submits one async render per camera and returns all request IDs immediately. Renders execute serially (DAZ is single-threaded), so they queue behind any already-running request. Each camera render is independently cancellable.

Args: cameras: List of camera display labels. output_dir: Directory where rendered images are saved. base_filename: Filename prefix. Output is _.png.

Returns: { "request_ids": ["script-XXXXXXXX", ...], "total": 3, "cameras": ["Cam_0", "Cam_45", "Cam_90"] }

Example: batch = await daz_batch_render_cameras_async( cameras=["Cam_0", "Cam_45", "Cam_90"], output_dir="/renders/turntable" ) # Monitor all renders for req_id in batch["request_ids"]: result = await daz_get_request_result(req_id, wait=True)

Start an animation render asynchronously — returns immediately with a request_id.

Queues a full animation render (all frames as an image sequence). This can take hours; use daz_get_request_status() to monitor progress and daz_get_request_result() to confirm completion.

Args: output_dir: Directory where frame images are saved. start_frame: First frame (default: animation range start). end_frame: Last frame (default: animation range end). filename_pattern: Filename prefix (default: "frame"). Frame number appended. camera: Optional camera label (default: current render camera).

Returns: {"request_id": "script-XXXXXXXX", "status": "queued", "submitted_at": "..."}

Get the current status of an async request (non-blocking, always fast).

Safe to call frequently — reads directly from the server's in-memory map without executing any DazScript.

Args: request_id: Request ID returned by an async submission tool.

Returns: { "request_id": "script-XXXXXXXX", "status": "running", # queued | running | completed | failed | cancelled "progress": 0.0, # 0.0 while running (DAZ single-frame renders have no # mid-frame progress), 1.0 when complete "elapsed_ms": 45000, # present while running "queue_position": 2 # present while queued }

Get the result of a completed async request.

Args: request_id: Request ID returned by an async submission tool. wait: If True (default), block until the request finishes (up to timeout). If False, return immediately with current status even if not done. timeout_seconds: Max seconds to wait when wait=True (default 3600 = 1 hour).

Returns when complete: { "request_id": "script-XXXXXXXX", "status": "completed", "success": true, "result": {...}, # same as sync tool result "output": [...], # captured DazScript print() output "error": null, "duration_ms": 267000, "completed_at": "2026-04-08T..." }

Raises ToolError if the request failed.

Cancel a queued or running async request.

For queued requests: cancellation is immediate. For running renders: sends a killRender() signal; may take a few seconds to take effect.

Args: request_id: Request ID returned by an async submission tool.

Returns: {"request_id": "...", "status": "cancelled", "cancelled_at": "..."}

Raises ToolError if the request is already finished (completed/failed/cancelled) or not found.

List all tracked async requests and their current statuses.

Args: status_filter: Optional filter — one of "queued", "running", "completed", "failed", "cancelled". Returns all if omitted.

Returns: { "requests": [ {"request_id": "...", "status": "...", "progress": 0.0, "submitted_at": "..."}, ... ], "total": 5, "queued": 2, "running": 1, "completed": 2, "failed": 0, "cancelled": 0 }

Set the Iray render quality preset.

Adjusts Max Samples and Render Quality on the active renderer, trading speed for quality. Use "draft" for quick composition checks and "final" for production renders.

Presets: draft - Very fast (seconds–2 min). Low quality. For quick checks. preview - Fast (2–5 min). Moderate quality. For composition review. good - Slow (10–20 min). Good quality. For client review. final - Very slow (30 min–2 hr). Maximum quality. For final output.

Args: preset: One of "draft", "preview", "good", "final".

Returns: { "preset": "draft", "propertiesSet": [ {"property": "Max Samples", "value": 100}, {"property": "Render Quality", "value": 0.5} ], "note": "..." # present only if some properties were not found }

Example: # Quick test render daz_set_render_quality("draft") daz_render("/test.png")

# Final quality async render
daz_set_render_quality("final")
req = await daz_render_async("/final.png")
result = await daz_get_request_result(req["request_id"], wait=True)

Apply an emotional expression to a character using morph candidates + body adjustment.

Args: character_label: Node label of the character to affect. emotion: One of: happy, sad, angry, surprised, fearful, disgusted, neutral, excited, bored, confident, shy, loving, contemptuous. intensity: Scale factor 0.0–1.0 applied to all morph and body values (default 0.7).

Returns: Dict with applied_morphs, body_adjustments, and not_found lists.

Notes: Morph candidates are tried in order; first match per slot wins. Not-found morphs are reported but do not raise errors — figures vary in available morphs.

List content library category subdirectories under a parent path.

Searches across all configured DAZ content directories and deduplicates by name.

Args: parent_path: Relative path within content directories to list (e.g. "People/Genesis 9"). Leave empty to list top-level categories.

Returns: Dict with parent, categories (list of {name, path, duf_count}), and count.

Example: daz_list_categories() # top-level: People, Props, Environments... daz_list_categories("People/Genesis 9") # sub-folders: Characters, Clothing, Hair...

List .duf content files in a content library category path.

Searches all configured DAZ content directories and deduplicates by filename.

Args: category_path: Relative path within content directories (e.g. "People/Genesis 9/Hair"). sort_by: Sort order — only "name" is currently supported (alphabetical).

Returns: Dict with category, items (list of {name, filename, full_path}), and count.

Example: daz_browse_category("People/Genesis 9/Hair") daz_browse_category("Props/Furniture")

Read metadata from a .duf content file without loading it into the scene.

Parses the JSON structure of a .duf file to extract name, type, contributor, and other available metadata fields.

Args: file_path: Absolute path to a .duf file on disk.

Returns: Dict with name, type, file_version, contributor, revision, modified, and any scene-level asset info found in the file.

Raises: ToolError: If the file does not exist, is not readable, or is not valid JSON.

Position camera so subject is framed according to a photography composition rule.

The camera maintains approximately its current horizontal distance from the subject while adjusting position and aim to satisfy the chosen rule.

Args: camera_label: Node label of the camera to reposition. subject_label: Node label of the subject to frame. rule: One of: - "rule-of-thirds" — Subject on right vertical third at eye level (default) - "golden-ratio" — Subject at the golden section (1.618 proportion) - "center-frame" — Subject centred, symmetric framing - "leading-lines" — Low angle with diagonal offset toward subject

Returns: Dict with camera, subject, rule, camera_position, and explanation string.

Frame camera to subject using a standard cinematic shot type.

Calculates camera distance and height from the subject's bounding box, then positions and aims the camera accordingly. Genesis figures face +Z, so the camera is placed in front (positive Z direction).

Args: camera_label: Node label of the camera to reposition. subject_label: Node label of the subject to frame. shot_type: One of: - "extreme-close-up" — Eyes/mouth detail (~25 cm) - "close-up" — Face and head (~50 cm) - "medium-close-up" — Head and shoulders (~90 cm) - "medium-shot" — Waist up (~140 cm) - "medium-full" — Knees up (~200 cm) - "full-shot" — Entire body (~400 cm) - "wide-shot" — Body within environment (~700 cm)

Returns: Dict with camera, subject, shot_type, distance, camera_height, and framing description.

Apply a standard camera angle preset relative to a subject.

Maintains the camera's current horizontal distance from the subject while adjusting vertical position and aim to achieve the specified angle. If the camera is closer than 50 cm it defaults to 250 cm.

Args: camera_label: Node label of the camera to reposition. subject_label: Node label of the subject. angle: One of: - "eye-level" — Camera at subject's eye height (neutral, default) - "high-angle" — Camera above subject (~1.5× head height), looking down - "low-angle" — Camera at shin level, looking up (powerful/dominant) - "dutch-angle" — Eye level with 15° Z-roll (unsettling, tense) - "overhead" — Camera directly above (bird's-eye view) - "worms-eye" — Camera at ground level looking straight up - "over-shoulder" — Camera behind and to one side of subject

Returns: Dict with camera, subject, angle, camera_position, and descriptive note.

Save current scene state as a named in-memory checkpoint.

Captures transforms (position, rotation, scale), active morphs, and light properties for all skeletons, cameras, and lights in the scene. Use this before experimental changes so you can restore with daz_restore_scene_state.

Args: checkpoint_name: Unique name for this checkpoint (e.g. "before_lighting_test"). Overwrites any existing checkpoint with the same name.

Returns: Dict with checkpoint_name, node_count, and saved_at (ISO timestamp).

Notes: Checkpoints are stored in the MCP server process memory and are lost if the server is restarted. They do not save materials, geometry, or HDR domes.

Restore scene state from a previously saved checkpoint.

Applies the transforms, morphs, and light properties captured by daz_save_scene_state back to the scene. Nodes that no longer exist are skipped and reported in the errors list.

Args: checkpoint_name: Name of the checkpoint to restore.

Returns: Dict with checkpoint_name, restored (list of node labels), and errors.

Raises: ToolError: If no checkpoint with the given name exists.

List all saved scene state checkpoints in the current session.

Returns: Dict with checkpoints (list of {name, node_count, saved_at}) and count.

Notes: Checkpoints are in-process memory; they are cleared when the server restarts.

Get a spatial map of all scene nodes with positions and bounding boxes.

Provides a bird's-eye view of where everything is positioned in the scene, useful for reasoning about character spacing, prop placement, and camera coverage.

Args: include_types: List of node type strings to include. Defaults to all types. Valid values: "figures", "cameras", "lights", "props".

Returns: Dict with nodes (list of {label, type, position, bounds?}) and count.

Example: daz_get_scene_layout() # everything daz_get_scene_layout(["figures", "cameras"]) # characters + cameras only daz_get_scene_layout(["lights"]) # just lights with flux values

Find all scene nodes within a specified radius of a target node.

Uses world-space positions to calculate distances. Returns nodes sorted nearest-first with cardinal direction labels.

Args: node_label: Label of the centre node to search around. radius: Search radius in centimetres (default 100 cm). include_types: Filter by type — "figures", "cameras", "lights", "props". None means return all types within radius.

Returns: Dict with center_node, radius, nearby_nodes (list of {label, type, distance, direction}), and count.

Example: daz_find_nearby_nodes("Genesis 9", radius=150) # everything within 1.5 m daz_find_nearby_nodes("Chair", radius=80, include_types=["figures"]) # people near chair