Python API

PivotBreeze exposes bpy.ops.wm.ih_pivot_breeze_* operators for scripts, the Python Console, and other add-ons. The shared action operators adapt to the active 3D View or UV Editor workflow. State and configuration queries return JSON through one Window Manager property.

API at a glance

Every recommended Window Manager operator follows the same catalog format: a readable action name, its copyable API call, and one short description. Detailed behavior, parameters, results, and safety notes remain in the sections below.

Actions

Open Pie Menu
```
bpy.ops.wm.ih_pivot_breeze_pie()
```
Open the Pie Menu in the active or nearest supported editor.
Activate Pivot
```
bpy.ops.wm.ih_pivot_breeze_toggle()
```
Start a regular pivot session, or apply and finish the active session.
Activate Bounding Box Pivot
```
bpy.ops.wm.ih_pivot_breeze_toggle_bounds()
```
Place mesh pivots on Global or Local bounding-box anchors.
Pivot by 3 Points
```
bpy.ops.wm.ih_pivot_breeze_toggle_three_points()
```
Build a 3D pivot frame from three geometry picks.
Reset Pivot
```
bpy.ops.wm.ih_pivot_breeze_reset_pivot()
```
Reset pivot position and rotation using the active editor workflow.
Reset Pivot Position
```
bpy.ops.wm.ih_pivot_breeze_reset_position()
```
Reset only the pivot or cursor position.
Reset Pivot Rotation
```
bpy.ops.wm.ih_pivot_breeze_reset_rotation()
```
Reset only the 3D pivot orientation.
Move to Zero
```
bpy.ops.wm.ih_pivot_breeze_move_to_zero()
```
Move objects, editable geometry, or UVs to zero.
Pivot to Zero
```
bpy.ops.wm.ih_pivot_breeze_pivot_to_zero()
```
Move object origins or the active editor cursor to zero.

Runtime, sessions, and transforms

Get Runtime State
```
bpy.ops.wm.ih_pivot_breeze_runtime_get()
```
Read whether PivotBreeze runtime services are enabled.
Set Runtime State
```
bpy.ops.wm.ih_pivot_breeze_runtime_set()
```
Idempotently enable or disable runtime services.
Toggle Runtime State
```
bpy.ops.wm.ih_pivot_breeze_addon_enabled_toggle()
```
Toggle runtime services without returning JSON.
Get Session State
```
bpy.ops.wm.ih_pivot_breeze_session_get()
```
Read the current 3D or UV session state.
Start Session
```
bpy.ops.wm.ih_pivot_breeze_session_start()
```
Start regular, bounding-box, or three-point pivot editing.
Finish Session
```
bpy.ops.wm.ih_pivot_breeze_session_finish()
```
Apply and close the active session.
Cancel Session
```
bpy.ops.wm.ih_pivot_breeze_session_cancel()
```
Cancel the active session and restore captured cursor state where supported.
Get Active Pivot Transform
```
bpy.ops.wm.ih_pivot_breeze_transform_get()
```
Read the active 3D helper transform in world space.
Set Active Pivot Transform
```
bpy.ops.wm.ih_pivot_breeze_transform_set()
```
Assign the active 3D helper location and rotation.

Preferences

Set Placement Limit
```
bpy.ops.wm.ih_pivot_breeze_placement_limit_set()
```
Set the geometry budget or enable/disable picking.
Get Exit Preference
```
bpy.ops.wm.ih_pivot_breeze_exit_setting_get()
```
Read one context-specific exit preference.
Set Exit Preference
```
bpy.ops.wm.ih_pivot_breeze_exit_setting_set()
```
Idempotently set one context-specific exit preference.
Toggle Exit Preference
```
bpy.ops.wm.ih_pivot_breeze_exit_setting_toggle()
```
Toggle one context-specific exit preference.
Get Reset Preference
```
bpy.ops.wm.ih_pivot_breeze_reset_setting_get()
```
Read one context-specific reset preference.
Set Reset Preference
```
bpy.ops.wm.ih_pivot_breeze_reset_setting_set()
```
Idempotently set one context-specific reset preference.
Toggle Reset Preference
```
bpy.ops.wm.ih_pivot_breeze_reset_setting_toggle()
```
Toggle one context-specific reset preference.

Hotkeys and Pie Menu

Get Hotkey
```
bpy.ops.wm.ih_pivot_breeze_hotkey_get()
```
Read one stored hotkey definition.
Set Hotkey State
```
bpy.ops.wm.ih_pivot_breeze_hotkey_set_enabled()
```
Idempotently enable or disable one hotkey.
Toggle Hotkey State
```
bpy.ops.wm.ih_pivot_breeze_hotkey_toggle_enabled()
```
Toggle one hotkey between enabled and disabled.
Rebind Hotkey
```
bpy.ops.wm.ih_pivot_breeze_hotkey_rebind()
```
Replace one hotkey event, value, and modifier combination.
Get Hotkey Conflicts
```
bpy.ops.wm.ih_pivot_breeze_hotkey_conflicts_get()
```
Inspect Blender keymap conflicts for one hotkey.
Reset Hotkey
```
bpy.ops.wm.ih_pivot_breeze_hotkey_reset()
```
Restore one hotkey to its default definition.
Reset All Hotkeys
```
bpy.ops.wm.ih_pivot_breeze_hotkeys_reset_all()
```
Restore every PivotBreeze hotkey to its defaults.
Get Pie Menu Slot
```
bpy.ops.wm.ih_pivot_breeze_pie_slot_get()
```
Read the action assigned to one Pie Menu slot.
Set Pie Menu Slot
```
bpy.ops.wm.ih_pivot_breeze_pie_slot_set()
```
Assign an action or NONE to one Pie Menu slot.

Discovery

Get Configuration
```
bpy.ops.wm.ih_pivot_breeze_config_get()
```
Read the complete API-managed configuration snapshot.
Get Capabilities
```
bpy.ops.wm.ih_pivot_breeze_capabilities_get()
```
Discover API metadata, identifiers, schemas, and supported features.

Getting started

Capability discovery and compatibility

The package filename does not describe the scripting contract. Query capabilities before configuring shortcuts, Pie Menu slots, placement modes, or editor-specific actions, and verify the fields and operators that your integration requires.

import bpy
import json

status = bpy.ops.wm.ih_pivot_breeze_capabilities_get()
if status != {'FINISHED'}:
    raise RuntimeError("Could not query PivotBreeze capabilities")
capabilities = json.loads(bpy.context.window_manager.ih_pivot_breeze_api_result)
print(capabilities['pie_menu']['open'])
print(capabilities['zero_actions'])

Quick start

import bpy

# Start in the supported editor under the current context.
bpy.ops.wm.ih_pivot_breeze_toggle()

# Any activation action applies and closes the active session.
bpy.ops.wm.ih_pivot_breeze_toggle()

Use explicit session control when an integration must distinguish apply from cancel:

import bpy

bpy.ops.wm.ih_pivot_breeze_session_start(placement_mode="NONE")
# Move the pivot interactively or use transform_set in a 3D session.
bpy.ops.wm.ih_pivot_breeze_session_finish()

Interactive Enter / Numpad Enter corresponds to applying a session, while Esc cancels and restores the starting pivot/cursor. During a native Blender transform, the first key press confirms/cancels that transform; a second press handles the session. Incomplete three-point input cannot be applied with Enter.

Calling operators

The activation and reset wm wrappers use the active PivotBreeze session’s editor when a session exists. Without a session, a current UV Editor in Mesh Edit Mode is preferred when the call is made from that editor; otherwise PivotBreeze locates a usable 3D View in the current Blender window set.

The two zero-action wrappers accept editor="AUTO" (default), "VIEW_3D", or "UV". AUTO uses the current 3D View or UV Editor. From other editors, it prefers an active session, then a suitable 3D View. An explicit editor prefers a matching active session; incompatible sessions or missing editors fail without changing editor types.

A 3D action requires an open 3D View and Object, Edit Mesh, Edit Curve, Edit Surface, or Sculpt Mode. A UV action requires an open UV Editor, Mesh Edit Mode, an editable Mesh, and an active UV map. Contextual view3d and uv operators have stricter current-area polling requirements.

Blender can raise RuntimeError for a failed poll or an operator error report, even if the operator itself returned a status set. Invalid RNA arguments may fail before execution. Check statuses and handle exceptions before reading JSON; poll() alone does not validate geometry, data ownership, or constraints. A failed start does not leave a partial session. These calling rules follow the Blender operator API.

Statuses and JSON results

Operators return Blender status sets such as {'FINISHED'} and {'CANCELLED'}. Operators documented as returning JSON write it to:

bpy.context.window_manager.ih_pivot_breeze_api_result

Read the property immediately after a successful call. The next state or configuration operator overwrites it, and a cancelled call may leave the previous value unchanged.

import bpy
import json

result = bpy.ops.wm.ih_pivot_breeze_session_get()
if result == {'FINISHED'}:
    state = json.loads(
        bpy.context.window_manager.ih_pivot_breeze_api_result
    )

Actions

Editor mapping

Public action	3D View	UV Editor
Toggle	Move and rotate a 3D pivot	Move the UV 2D Cursor
Bounding Box	27 Global/Local mesh anchors	Unavailable
Pivot by 3 Points	Position, axis and plane from mesh geometry picks	Unavailable
Reset Pivot	Position and rotation	Cursor position; optional 2D Cursor pivot mode
Reset Position	Position only	Cursor position only
Reset Rotation	Rotation only	Unavailable
Move to Zero	Translate objects or editable geometry to zero according to the mode	Move selected UV corners relative to the cursor, or center fully visible islands when nothing is selected
Pivot to Zero	Move origins or the 3D Cursor to zero according to the mode	Move only the 2D Cursor to `(0, 0)`

The shared action operators use this mapping and Blender’s native snapping. Only one session can be active. Regular activation toggles apply and close it; an incomplete three-point session is cancelled when toggled off. To choose a different placement workflow, finish or cancel first, then start it explicitly.

bpy.ops.wm.ih_pivot_breeze_pie()

Opens the configured Pie Menu in the active PivotBreeze session, the current supported editor, or the nearest compatible 3D View or UV Editor in an open window. It dispatches to the same contextual operator as the configured shortcut. The Pie Menu must be enabled in Preferences. Returns a status set and does not write JSON.

Activate Pivot

bpy.ops.wm.ih_pivot_breeze_toggle()

Starts a regular session without replacing the current snap configuration, or applies and closes the active session. In UV it edits the 2D Cursor with a translation-only gizmo. Returns a status set and does not write JSON.

Activate Bounding Box Pivot

bpy.ops.wm.ih_pivot_breeze_toggle_bounds()

Starts Bounding Box Pivot for Mesh objects in Object, Edit Mesh, or Sculpt. Press R for Global/Local and click one of 27 anchors to apply and finish. Object Mode uses each selected mesh’s own box; Edit uses combined selected components and the active object’s axes in Local; Sculpt affects only the active mesh. New sessions start in Global. No UV equivalent. Returns a status set without JSON.

Pivot by 3 Points

bpy.ops.wm.ih_pivot_breeze_toggle_three_points()

Starts three-point placement in Object Mesh, Edit Mesh, or Sculpt. Picks define position, first axis, then the plane; R cycles axes and Backspace revisits a point. The third valid pick applies; Esc or toggling off incomplete input cancels. Object origins share the frame, Edit changes the 3D Cursor, and Sculpt affects the active mesh. No UV equivalent. Returns a status set without JSON.

Reset Pivot

bpy.ops.wm.ih_pivot_breeze_reset_pivot()

Resets the active 3D helper without closing its session, or applies the context-specific reset outside a session. In UV it resets the 2D Cursor to the session selection center, current selected bounds center, or (0, 0) when no UV is selected. The UV reset preference can also select the 2D Cursor pivot mode. Returns a status set and does not write JSON.

Reset Pivot Position

bpy.ops.wm.ih_pivot_breeze_reset_position()

Resets only location. Object Mode uses selected object bounds, with optional independent descendant-bound targets for selected Empties. Edit modes use selected editable elements, Sculpt uses the active object’s bounds, and UV uses the selected UV bounds or (0, 0). UV Reset Position never changes the UV pivot mode. Returns a status set and does not write JSON.

Reset Pivot Rotation

bpy.ops.wm.ih_pivot_breeze_reset_rotation()

Resets only 3D orientation to the world identity while preserving position. Sculpt also updates Blender’s native Sculpt Pivot. The call is cancelled in a UV context because UV pivot rotation is unsupported. Returns a status set and does not write JSON.

Move to Zero

bpy.ops.wm.ih_pivot_breeze_move_to_zero(editor="VIEW_3D")

Accepts AUTO (default), VIEW_3D, or UV. In Object Mode, each selected object moves by its origin to world zero. Sculpt moves the entire active object, ignoring masks and Face Sets. In Edit modes, visible selected elements move by the negative 3D Cursor position, and the cursor becomes zero. With no Edit selection, each edited object’s complete geometry, including hidden elements, is centered independently by its world bounds while its origin stays fixed.

In UV, selected corners move by the negative UV cursor position. With no visible UV selection, each fully visible island is centered independently at (0, 0); partially hidden islands are skipped with a warning. The cursor becomes zero. This does not pack islands, preserve tile membership, or move all corners of a partially selected island.

# Requires Mesh Edit Mode and an open UV Editor.
bpy.ops.wm.ih_pivot_breeze_move_to_zero(editor="UV")

Pivot to Zero

bpy.ops.wm.ih_pivot_breeze_pivot_to_zero(editor="VIEW_3D")

Accepts the same explicit editor parameter. Object and Sculpt modes move origins to world zero while preserving base geometry and child world transforms. Edit modes move only the 3D Cursor. Sculpt also updates its native Sculpt Pivot; origin-dependent modifiers may evaluate differently.

# Moves only the UV 2D Cursor, leaving UV coordinates unchanged.
bpy.ops.wm.ih_pivot_breeze_pivot_to_zero(editor="UV")

Both zero commands return status sets and do not write JSON. They validate targets before applying an existing session, perform the action, then resume the same workflow with its snap settings retained. No session is started if none was active. Object/Sculpt transforms reject locks, active constraints, and animation; data-changing paths require local single-user data and valid transforms. See the complete safety rules.

Runtime control

Get Runtime State

bpy.ops.wm.ih_pivot_breeze_runtime_get()

Reads whether PivotBreeze runtime services are enabled and writes a runtime JSON payload.

Set Runtime State

bpy.ops.wm.ih_pivot_breeze_runtime_set(enabled=True)

Idempotently enables or disables runtime services. Disabling runtime cancels the active 3D or UV session, unregisters PivotBreeze hotkeys, and stops monitoring. Enabling restores owned hotkeys and tracking. The operator writes {"kind":"runtime","enabled":true} or the corresponding disabled state.

Toggle Runtime State

bpy.ops.wm.ih_pivot_breeze_addon_enabled_toggle()

Toggles runtime services. The call is not idempotent and does not write JSON; query Get Runtime State when the resulting state is required.

Sessions and transforms

Explicit session control

Use these operators when an integration owns the start, apply, and cancel choice. The ordinary activation actions are simpler for interactive scripts.

Get Session State

bpy.ops.wm.ih_pivot_breeze_session_get()

With no session, writes {"active":false,"kind":"session"}. An active payload contains workflow, mode, placement_mode, editor, and the helper name when a 3D helper exists.

A 3D payload uses editor: "VIEW_3D" and includes world-space location and a WXYZ rotation_quaternion. A UV payload uses editor: "UV", reports the 2D location, sets rotation to null, and has no helper object.

Start Session

bpy.ops.wm.ih_pivot_breeze_session_start(placement_mode="NONE")

Accepts NONE, BOUNDS, or THREE_POINTS. UV supports NONE only. The operation is idempotent: an existing session keeps its workflow and placement mode. Writes the active session payload. Check whether a session already exists before assuming ownership of finishing or cancelling it.

Finish Session

bpy.ops.wm.ih_pivot_breeze_session_finish(keep_selection=False)

Applies and closes the active session. It is safe when no session is active. keep_selection=True preserves a newly made selection only where the Object workflow supports it; other workflows restore their captured selection. Writes the inactive session payload after success.

Cancel Session

bpy.ops.wm.ih_pivot_breeze_session_cancel()

Cancels the active session. In 3D, it skips transfer of the helper transform to object origins and restores the session-entry 3D Cursor position, rotation, and rotation mode (Euler, quaternion, or axis-angle). This includes previously completed helper moves and rotations. In UV, it restores the 2D Cursor captured at session start. The operation is safe with no active session and writes the inactive payload. Cancelling a session resumed by a zero command does not undo that command’s geometry change. Use Blender Undo to reverse an already completed action.

Placement scope and input state

Active 3D session queries expose placement with scope (SELECTED, ALL_VISIBLE, DISABLED), reason, enabled, vertex_limit, and admitted objects. Reasons are null on successful admission or USER_DISABLED, LIMIT_EXCEEDED, NO_GEOMETRY, or SOURCE_MISSING. Queries resolve the owning viewport even when called from another editor.

Bounds sessions add bounds_orientation (GLOBAL or LOCAL). Three-point sessions add three_points.points in world coordinates, primary_axis, and current_axis (X, Y, Z). These fields are absent from UV sessions. Treat helper-dependent transform fields as conditional.

The default budget is 100,000 vertices. Original selected objects must fit first; all visible supported geometry is admitted only when its total fits. Otherwise use the original selection, or disable picking when that selection exceeds the limit. Bounds remain selected-only. Each admitted object’s original Wireframe display is restored on exit, cancellation, activation failure, and Undo suspension. There is no public click-picking or wireframe command; use transform_set for deterministic scripted placement.

Active 3D helper transform

These two operators require an active 3D session and a live helper. They are not available for the translation-only UV session.

Get Active Pivot Transform

bpy.ops.wm.ih_pivot_breeze_transform_get()

Writes a pivot_transform payload containing active: true, space: "WORLD", three-number location, and four-number WXYZ rotation_quaternion. Returns {'CANCELLED'} when no usable 3D helper exists.

Set Active Pivot Transform

bpy.ops.wm.ih_pivot_breeze_transform_set(location=(0, 0, 0), rotation_quaternion=(1, 0, 0, 0))

Sets the active helper in world space and synchronizes the 3D Cursor without finishing the session or immediately applying the helper to object origins. The quaternion is WXYZ and normalized using a stable norm, including large nonzero components. Zero quaternions and non-finite stored values are rejected before mutation. RNA properties can clamp out-of-range values before execution, so validate external numerical input before passing it to Blender as well. Helper scale is preserved. Writes the resulting pivot_transform payload.

This is a complete assignment: omitted location uses (0, 0, 0), and omitted rotation uses identity (1, 0, 0, 0). To change only location, first read and explicitly preserve rotation:

import bpy
import json

# Requires an active 3D session.
status = bpy.ops.wm.ih_pivot_breeze_transform_get()
if status != {'FINISHED'}:
    raise RuntimeError("Could not read the active pivot transform")
transform = json.loads(bpy.context.window_manager.ih_pivot_breeze_api_result)
bpy.ops.wm.ih_pivot_breeze_transform_set(
    location=(1.0, 2.0, 3.0),
    rotation_quaternion=transform['rotation_quaternion'],
)

Preferences

Exit and reset APIs use the same context identifiers: OBJECT, EDIT, UV, and SCULPT. All eight settings are enabled by default.

Exit preferences

Identifier	Enabled behavior after apply
`OBJECT`	Leave Local orientation and Bounding Box Center pivot
`EDIT`	Leave Cursor orientation and 3D Cursor pivot
`UV`	Leave the 2D Cursor pivot point
`SCULPT`	Leave Local orientation and Bounding Box Center pivot

Get Exit Preference

bpy.ops.wm.ih_pivot_breeze_exit_setting_get(setting="OBJECT")

Reads one context-specific exit preference and writes an exit_setting payload with setting and Boolean enabled.

Set Exit Preference

bpy.ops.wm.ih_pivot_breeze_exit_setting_set(setting="OBJECT", enabled=True)

Idempotently enables or disables one exit preference and writes the updated exit_setting payload.

Toggle Exit Preference

bpy.ops.wm.ih_pivot_breeze_exit_setting_toggle(setting="OBJECT")

Toggles one exit preference and writes the updated exit_setting payload. A disabled preference restores the corresponding setting captured at session start instead of leaving the PivotBreeze result.

Reset preferences

Identifier	Enabled behavior after reset
`OBJECT`	Set Local orientation and Bounding Box Center pivot
`EDIT`	Set Cursor orientation and 3D Cursor pivot
`UV`	Reset Pivot selects the 2D Cursor pivot point
`SCULPT`	Set Local orientation and Bounding Box Center pivot

Get Reset Preference

bpy.ops.wm.ih_pivot_breeze_reset_setting_get(setting="OBJECT")

Reads one context-specific reset preference and writes a reset_setting payload with setting and Boolean enabled.

Set Reset Preference

bpy.ops.wm.ih_pivot_breeze_reset_setting_set(setting="OBJECT", enabled=True)

Idempotently enables or disables one reset preference and writes the updated reset_setting payload.

Toggle Reset Preference

bpy.ops.wm.ih_pivot_breeze_reset_setting_toggle(setting="OBJECT")

Toggles one reset preference and writes the updated reset_setting payload. The UV preference affects Reset Pivot; Reset Position always changes only the cursor location.

Hotkey identifiers

Identifier	Shared action	Initial binding
`ACTIVATE_PIVOT`	Activate Pivot	Disabled placeholder: 1
`ACTIVATE_PIVOT_BOUNDS`	Bounding Box Pivot; no UV	Disabled placeholder: 2
`ACTIVATE_PIVOT_THREE_POINTS`	Pivot by 3 Points; no UV	Disabled placeholder: 3
`RESET_PIVOT`	Reset Pivot	Disabled placeholder: 4
`RESET_PIVOT_POSITION`	Reset Position	Disabled placeholder: 5
`RESET_PIVOT_ROTATION`	Reset Rotation; unavailable in UV	Disabled placeholder: 6
`MOVE_TO_ZERO`	Move objects, geometry, or UVs to zero	Disabled placeholder: 7
`PIVOT_TO_ZERO`	Move origins or cursors to zero	Disabled placeholder: 8
`PIVOT_PIE_MENU`	Open context-aware Pie Menu	Enabled: Ctrl + D

Aim is fixed to Shift + Left Click, not a configurable direct shortcut. The number bindings are disabled storage placeholders. Each configurable row uses Blender’s native mapping-type and full-event controls, including keyboard, mouse, NDOF, tweak, text-input, and timer events. Query capabilities to discover the event identifiers accepted by the installed version.

Get Hotkey

bpy.ops.wm.ih_pivot_breeze_hotkey_get(hotkey="ACTIVATE_PIVOT")

Reads one stored hotkey definition and writes a hotkey payload.

Set Hotkey State

bpy.ops.wm.ih_pivot_breeze_hotkey_set_enabled(hotkey="ACTIVATE_PIVOT", enabled=True)

Idempotently enables or disables one hotkey and writes the updated hotkey payload.

Toggle Hotkey State

bpy.ops.wm.ih_pivot_breeze_hotkey_toggle_enabled(hotkey="ACTIVATE_PIVOT")

Toggles one hotkey between enabled and disabled and writes the updated hotkey payload.

Rebind Hotkey

bpy.ops.wm.ih_pivot_breeze_hotkey_rebind(
    hotkey="ACTIVATE_PIVOT",
    key="BUTTON4MOUSE",
    value="PRESS",
    ctrl=False,
    shift=False,
    alt=False,
    oskey=False,
)

Replaces the complete event and modifier combination, writes a hotkey payload containing hotkey, enabled, key, value, ctrl, shift, alt, and oskey, and leaves a disabled action disabled. Unknown Blender event types or values are rejected.

Get Hotkey Conflicts

bpy.ops.wm.ih_pivot_breeze_hotkey_conflicts_get(hotkey="ACTIVATE_PIVOT")

Inspects Blender keymaps without changing them and writes a hotkey_conflicts payload. Each match reports its key configuration, keymap, operator, shortcut, and description.

Reset Hotkey

bpy.ops.wm.ih_pivot_breeze_hotkey_reset(hotkey="ACTIVATE_PIVOT")

Restores one stored definition and writes its default hotkey payload.

Reset All Hotkeys

bpy.ops.wm.ih_pivot_breeze_hotkeys_reset_all()

Restores the eight disabled placeholders and the enabled Ctrl + D Pie Menu binding, then writes a hotkeys_reset payload.

Slot	Direction	Default action
0	Left	`MOVE_TO_ZERO`
1	Right	`PIVOT_TO_ZERO`
2	Bottom	`RESET_PIVOT`
3	Top	`ACTIVATE_PIVOT`
4	Top Left	`ACTIVATE_BOUNDS`
5	Top Right	`ACTIVATE_THREE_POINTS`
6	Bottom Left	`RESET_POSITION`
7	Bottom Right	`RESET_ROTATION`

bpy.ops.wm.ih_pivot_breeze_pie_slot_get(slot=0)

Reads one assignment and writes a pie_slot payload with slot, direction, and action.

bpy.ops.wm.ih_pivot_breeze_pie_slot_set(slot=0, action="NONE")

Assigns NONE or a capability-reported Pie action and writes the updated pie_slot payload. Slots range from 0 to 7; validate external values because RNA may clamp integers. Setting a slot does not enable the Pie Menu. Unavailable actions remain disabled in unsupported contexts. Review saved assignments through capability discovery when building a dynamic integration.

Set Placement Limit

bpy.ops.wm.ih_pivot_breeze_placement_limit_set(vertex_limit=100000, enabled=True)

Sets the geometry budget and returns kind='placement_limit', vertex_limit, and enabled. Both arguments are independently optional: omit enabled to keep its state, or pass only enabled=False to keep the stored limit. Nonnegative integers are required; RNA can clamp values. No active session is required. Zero or a disabled checkbox disables picking, aiming, bounds, and three-point placement, not manual gizmos or UV editing.

Discovery

Get Configuration

bpy.ops.wm.ih_pivot_breeze_config_get()

Writes a config payload containing runtime_enabled, four exit_settings, four reset_settings, all nine hotkeys, and eight Pie Menu slots. It also reports snap memory, center-handle appearance, and Empty hierarchy behavior. Appearance, snap memory, and Empty hierarchy settings have no dedicated public setters. Configuration also exposes placement.vertex_limit, placement.enabled, and the effective fixed aim binding. Snap memory’s enabled field also controls persistence between Blender sessions.

Get Capabilities

bpy.ops.wm.ih_pivot_breeze_capabilities_get()

Writes a capabilities payload. Capabilities include:

addon_version and the integer api_version discovery field.
editors: VIEW_3D and UV; placement_modes: NONE, BOUNDS, THREE_POINTS.
Exit/reset identifiers, accepted event keys, hotkey defaults, and Pie actions.
Result-property name and the 3D transform space/quaternion convention.
zero_actions operator IDs, editor selection, and resume_active_session: true.
UV move-only metadata, empty reset (0, 0), and only regular placement.
aim: configurable=False, button='LEFTMOUSE', requires_modifier=True.
placement_limit: setter ID, default 100000, unit VERTICES, and zero_disables_picking=True.

Dynamic integrations should query capabilities instead of copying option catalogs from another PivotBreeze version.

Undo and failure handling

The zero operators and transform_set declare Blender’s native UNDO option. For scripts that need Blender to record an operator call in history, its positional call arguments accept an execution context followed by an Undo flag:

# Requires an active 3D session; records the helper edit in native history.
bpy.ops.wm.ih_pivot_breeze_transform_set(
    'EXEC_DEFAULT', True,
    location=(0, 0, 0),
    rotation_quaternion=(1, 0, 0, 0),
)

Use an explicit editor for zero-action calls in the same form. The action coordinates session apply, mutation, and resumption; do not add another toggle afterward, because it would close the resumed session. Blender stores geometry history, and PivotBreeze handlers reconcile cursor and temporary session state.

An expected validation failure leaves the existing session and targets intact. An unexpected error after data changes can preserve a native Undo step while still reporting an error to Python. Handle the exception and inspect the scene before retrying; a failed call is not a promise that no data changed. Re-query session state after Undo/Redo rather than keeping references to helper objects.

The initial release verification passed 112 fast checks. The source-linked runtime suites passed 334 tests with three expected skips in Blender 4.2.0 and 336 tests with one expected skip in Blender 5.2.2. Both reached 83% coverage; native-window checks passed in both versions, and GPU overlay checks passed in 5.2.2. These are upstream results, not Blender tests run by the website build. macOS, ARM, and arbitrary third-party add-on combinations are not verified.

Contextual operators

PivotBreeze keymaps and the Pie Menu use current-area operators. External integrations should normally prefer the wm wrappers because they resolve the active session editor and construct a consistent Blender context override.

3D View operators:

view3d.ih_pivot_breeze_toggle
view3d.ih_pivot_breeze_toggle_bounds
view3d.ih_pivot_breeze_toggle_three_points
view3d.ih_pivot_breeze_reset_pivot
view3d.ih_pivot_breeze_reset_position
view3d.ih_pivot_breeze_reset_rotation
view3d.ih_pivot_breeze_move_to_zero
view3d.ih_pivot_breeze_pivot_to_zero
view3d.ih_pivot_breeze_pie

UV Editor operators:

uv.ih_pivot_breeze_toggle
uv.ih_pivot_breeze_reset_pivot
uv.ih_pivot_breeze_reset_position
uv.ih_pivot_breeze_move_to_zero
uv.ih_pivot_breeze_pivot_to_zero
uv.ih_pivot_breeze_pie

Within their matching active 3D sessions:

view3d.ih_pivot_breeze_bounds_orientation_toggle(): Global/Local, like R; no arguments, with native Undo.
view3d.ih_pivot_breeze_three_points_back(): remove the latest accepted point, like Backspace; no arguments.
view3d.ih_pivot_breeze_three_points_cycle_axis(): cycle X/Y/Z while preserving accepted points, like R; no arguments.

The contextual zero commands have no editor parameter; their namespace selects the editor. wm.ih_pivot_breeze_pie() is the canonical context-independent Pie Menu entry point. It resolves a compatible editor and invokes the same view3d or uv operator used by the configured shortcut.

The internal view3d.ih_pivot_breeze_exit and uv.ih_pivot_breeze_exit operators are owned by keymaps and session monitoring. wm.ih_pivot_breeze_hotkey_conflicts_info is a Preferences tooltip operator. They are not part of the public scripting contract.

A current-area operator must poll successfully in its editor and mode. A script running from another editor should call the corresponding bpy.ops.wm.ih_pivot_breeze_* wrapper instead of constructing its own area override. Check the returned status before reading JSON, and query capabilities_get before building dynamic controls for an installed version.

Python API

API at a glance

Actions

Runtime, sessions, and transforms

Preferences

Hotkeys and Pie Menu

Discovery

Getting started

Capability discovery and compatibility

Quick start

Calling operators

Statuses and JSON results

Actions

Editor mapping

Open Pie Menu

Activate Pivot

Activate Bounding Box Pivot

Pivot by 3 Points

Reset Pivot

Reset Pivot Position

Reset Pivot Rotation

Move to Zero

Pivot to Zero

Runtime control

Get Runtime State

Set Runtime State

Toggle Runtime State

Sessions and transforms

Explicit session control

Get Session State

Start Session

Finish Session

Cancel Session

Placement scope and input state

Active 3D helper transform

Get Active Pivot Transform

Set Active Pivot Transform

Preferences

Exit preferences

Get Exit Preference

Set Exit Preference

Toggle Exit Preference

Reset preferences

Get Reset Preference

Set Reset Preference

Toggle Reset Preference

Hotkeys and Pie Menu

Hotkey identifiers

Get Hotkey

Set Hotkey State

Toggle Hotkey State

Rebind Hotkey

Get Hotkey Conflicts

Reset Hotkey

Reset All Hotkeys

Pie Menu slots

Get Pie Menu Slot

Set Pie Menu Slot

Set Placement Limit

Discovery

Get Configuration

Get Capabilities

Undo and failure handling

Contextual operators