�
XfXiH� � �� � d Z ddlZddlmZmZmZ ddlmZmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZmZmZmZ dedefd�Zdedefd �Z de defd
�Z defd �Z de
defd �Z de defd
�Z de defd�Z!de
defd�Z"dedefd�Z#dedefd�Z$dedefd�Z%dedefd�Z&dedefd�Z'dedefd�Z(dedefd�Z)dedefd�Z*defd�Z+defd�Z,dedefd�Z-dedefd�Z.dedefd �Z/dedefd �Z0dS ) a Blender operations - pure functions that interact with bpy
This module contains all the core Blender operations that perform actual
work with the bpy API. These functions are pure business logic with no
MCP dependencies, making them testable and reusable.
� N)�List�Optional�
TYPE_CHECKING� )�CreateCubeInput�CreateSphereInput�MoveObjectInput�DeleteObjectInput�SelectObjectInput�CreateMaterialInput�AssignMaterialInput�RotateObjectInput�ScaleObjectInput�GetObjectInfoInput�CreateCameraInput�CreateLightInput�RenderSceneInput�CreateCylinderInput�CreatePlaneInput�DuplicateObjectInput�SetActiveCameraInput�
SaveFileInput�
OpenFileInput�input�returnc �8 � ddl }|j j � | j | j �� � |j j }|r&| j |_ d| j � d| j � d| j � �S dS # t $ r Y dS t $ r }d t |� � � �cY d}~S d}~ww xY w)
a�
Create a cube in the Blender scene.
This function demonstrates:
- Using bpy.ops to create mesh primitives
- Accessing the active object after creation
- Setting object properties (name)
- Proper error handling for Blender operations
- Informative return messages
Args:
input: Validated input parameters containing:
- name: Name for the cube object (1-63 characters)
- size: Edge length of the cube (must be > 0.001 and <= 1000.0)
- location: Tuple of (x, y, z) coordinates for cube position
Returns:
Success message with cube details including name, size, and location.
Format: "Successfully created cube '{name}' with size {size} at location {location}"
Raises:
Exception: If Blender operation fails or bpy module is not available.
Returns error message string instead of raising exception.
r N��size�locationzSuccessfully created cube '� ' with size �
at location z9Error: Cube created but could not get reference to object�BError: bpy module not found. Tool must run in Blender environment.zError [Create Cube]: ) �bpy�ops�mesh�primitive_cube_addr r �context�
active_object�name� ImportError� Exception�str)r r# �cube�es �a/Users/gajanmohanraj/Documents/afterquery/candidate-1767282743/blender_takehome/src/operations.py� create_cuber0 ! s � �20� �
�
�
� �� �'�'����^� (�
�
�
�
�{�(�� � O� �
�D�I�G�e�j� G� G� "�Z�G� G�6;�n�G� G�
�
O�N�� � T� T� T�S�S�S� � 0� 0� 0�/�s�1�v�v�/�/�/�/�/�/�/�/�����0���s$ �A"A' �'
B�4 B�=B�B�Bc � � ddl }|j j � | j | j | j | j | j | j | j
| j | j �� � |j
j }|r6| j |_ d| j � d| j � d| j � d| j � d| j
� �
S d S # t $ r Y d
S t" $ r }d t% |� � � �cY d}~S d}~ww xY w) aw
Create a UV sphere in the Blender scene.
This function demonstrates:
- Creating UV sphere primitives with full parameter control
- Using segments and ring_count for sphere resolution
- Setting object properties (location, rotation, scale)
- Controlling UV generation and edit mode entry
- Setting object names after creation
- Handling Blender mesh creation operations
- Proper error handling and informative messages
Args:
input: Validated input parameters containing:
- name: Name for the sphere object (1-63 characters)
- segments: Number of vertical segments (3-100000)
- ring_count: Number of horizontal rings (3-100000)
- radius: Radius of the sphere (>= 0.0 and <= 1000.0)
- calc_uvs: Whether to generate UV map (default: True)
- enter_editmode: Whether to enter edit mode (default: False)
- align: Alignment mode ('WORLD', 'VIEW', or 'CURSOR')
- location: Tuple of (x, y, z) coordinates for sphere position
- rotation: Tuple of (x, y, z) Euler rotation angles in radians
- scale: Tuple of (x, y, z) scale factors (use (0,0,0) for default)
Returns:
Success message with sphere details including name, radius, segments, ring_count, and location.
Format: "Successfully created sphere '{name}' with radius {radius} (segments={segments}, rings={ring_count}) at location {location}"
Raises:
Exception: If Blender operation fails or bpy module is not available.
Returns error message string instead of raising exception.
r N) �segments�
ring_count�radius�calc_uvs�enter_editmode�alignr �rotation�scalez Successfully created sphere '�' with radius z (segments=z, rings=�) at location z;Error: Sphere created but could not get reference to objectr" zError [Create Sphere]: )r# r$ r% �primitive_uv_sphere_addr2 r3 r4 r5 r6 r7 r r8 r9 r' r( r) r* r+ r, )r r# �spherer. s r/ �
create_spherer> T sC � �D!2� �
�
�
� �� �,�,��^� �'��<��^� �/��+��^��^��+� -�
�
�
� ��*�� � Q� �*�F�K�0��
� 0� 0� $�|�0� 0� "�^�0� 0�5:�5E�0� 0� %�~�0� 0�
� Q�P�� � T� T� T�S�S�S� � 2� 2� 2�1��Q���1�1�1�1�1�1�1�1�����2���s$ �B B! �!
C�. C�7C�C�Cc �j � ddl }|j j � | j � � }|� d| j � d�S ||j j j _ |� d� � | j |_ d| j � d| j � �S # t $ r Y dS t $ r }d t |� � � �cY d}~S d}~ww xY w)
a]
Move an object to a new location in 3D space.
This function demonstrates:
- Accessing objects from bpy.data.objects collection
- Checking object existence before operations
- Setting object location property directly
- Making objects active and selected for context
- Proper error handling for missing objects
Args:
input: Validated input parameters containing:
- name: Name of the object to move (must exist in scene)
- location: Tuple of (x, y, z) coordinates for new position
Returns:
Success message confirming the move operation.
Format: "Successfully moved object '{name}' to location {location}"
Raises:
Exception: If object is not found or Blender operation fails.
Returns error message string instead of raising exception.
r N�Error: Object '� ' not foundTzSuccessfully moved object 'z' to location r" zError [Move Object]: )
r# �data�objects�getr) r' �
view_layer�active�
select_setr r* r+ r, �r r# �objr. s r/ � move_objectrJ � s� � �00� �
�
�
��h� �"�"�5�:�.�.�� �;�<�U�Z�<�<�<� <�03�� � �&�-� ���t� � � � �~�� �
,�%�*�
,�
,� �>�
,�
,�
��
� T� T� T�S�S�S� � 0� 0� 0�/�s�1�v�v�/�/�/�/�/�/�/�/�����0���s) �4B �AB �
B2�
B2�B-�'B2�-B2c � � ddl } | j j }t |� � dk rdS g }|D ]>}d|j � d|j � dt
|j � � � �}|� |� � �?dt |� � � d�d � |� � z S # t $ r Y d
S t $ r }d t |� � � �cY d}~S d}~ww xY w) a1
List all objects in the current Blender scene.
This function demonstrates:
- Accessing bpy.data.objects collection
- Iterating through all objects in the scene
- Accessing object properties (name, type, location)
- Formatting output for readability
- Handling empty scenes gracefully
Args:
None: This function takes no parameters and lists all objects.
Returns:
Formatted string listing all objects with their properties.
Format: "Found {count} object(s):
- {name} ({type}) at location {location}
..."
Returns "Scene is empty - no objects found" if scene is empty.
Raises:
Exception: If Blender operation fails or bpy module is not available.
Returns error message string instead of raising exception.
r Nz!Scene is empty - no objects foundz - z (r; zFound z object(s):
�
r" zError [List Objects]: )
r# rB rC �lenr) �type�tupler �append�joinr* r+ r, )r# rC �obj_listrI �obj_infor. s r/ � list_objectsrT � s# � �.1� �
�
�
��(�"�� �w�<�<�1� � �6�6� ��� &� &�C�5�s�x� 5� 5�3�8� 5� 5� $�S�\� 2� 2�5� 5�
�
�O�O�H� %� %� %� %�3��G� � �3�3�3�d�i�i��6I�6I�I�I�� � T� T� T�S�S�S� � 1� 1� 1�0��A���0�0�0�0�0�0�0�0�����1���s) �#B �A+B �
C� C�)C �:C� Cc �, � ddl }|j j � | j � � }|� d| j � d�S |j j � |� � d| j � d�S # t $ r Y dS t $ r }dt |� � � �cY d}~S d}~ww xY w) a�
Delete an object from the Blender scene.
This function demonstrates:
- Accessing objects from bpy.data.objects collection
- Checking object existence before deletion
- Using bpy.data.objects.remove() to delete objects
- Proper cleanup and error handling
- Confirming deletion with informative messages
Args:
input: Validated input parameters containing:
- name: Name of the object to delete (must exist in scene)
Returns:
Success message confirming deletion.
Format: "Successfully deleted object '{name}'"
Raises:
Exception: If object is not found or deletion fails.
Returns error message string instead of raising exception.
r Nr@ rA z Successfully deleted object '�'r" zError [Delete Object]: ) r# rB rC rD r) �remover* r+ r, rH s r/ �
delete_objectrX � s� � �.2� �
�
�
��h� �"�"�5�:�.�.�� �;�<�U�Z�<�<�<� <� ��� � ��$�$�$�<�u�z�<�<�<�<�� � T� T� T�S�S�S� � 2� 2� 2�1��Q���1�1�1�1�1�1�1�1�����2���s( �4A! �)A! �!
B�. B�7B�B�Bc � � ddl }|j j � | j � � }|� d| j � d�S |j j � d�� � |� d� � ||j j
j _ d| j � d �S # t $ r Y d
S t $ r }d t |� � � �cY d}~S d}~ww xY w) a<
Select an object by name, making it the active object.
This function demonstrates:
- Accessing objects from bpy.data.objects collection
- Deselecting all objects before selecting one
- Using bpy.ops.object.select_all() operator
- Setting object selection state with select_set()
- Making objects active for context-dependent operations
- Proper error handling for missing objects
Args:
input: Validated input parameters containing:
- name: Name of the object to select (must exist in scene)
Returns:
Success message confirming selection.
Format: "Successfully selected object '{name}'"
Raises:
Exception: If object is not found or selection fails.
Returns error message string instead of raising exception.
r Nr@ rA �DESELECT��actionTz Successfully selected object 'rV r" zError [Select Object]: )r# rB rC rD r) r$ �object�
select_allrG r' rE rF r* r+ r, rH s r/ �
select_objectr_ # s� � �02� �
�
�
��h� �"�"�5�:�.�.�� �;�<�U�Z�<�<�<� <� ���!�!��!�4�4�4� ���t� � � �03�� � �&�-�=��
�=�=�=�=�� � T� T� T�S�S�S� � 2� 2� 2�1��Q���1�1�1�1�1�1�1�1�����2���s) �4B
�AB
�
B?� B?�#B:�4B?�:B?c �� � ddl }| j |j j v r d| j � d�S |j j � | j �� � }|j rX|j j � d� � }|r7| j d | j d | j d d f|j d
_
d | j � d | j � �S # t $ r Y d
S t $ r }dt |� � � �cY d}~S d}~ww xY w)al
Create a new material with a base color.
This function demonstrates:
- Checking for existing materials before creation
- Creating materials with bpy.data.materials.new()
- Accessing material node trees (materials always use nodes in Blender 5.0+)
- Setting Principled BSDF shader properties
- Configuring base color in RGBA format
- Proper error handling for material creation
Note: In Blender 5.0+, materials always use nodes (use_nodes is deprecated).
The node_tree is automatically available for new materials.
Args:
input: Validated input parameters containing:
- name: Name for the material (1-63 characters, must be unique)
- color: Tuple of (r, g, b) color values (0.0 to 1.0 for each)
Returns:
Success message with material details including name and color.
Format: "Successfully created material '{name}' with color RGB{color}"
Raises:
Exception: If material already exists, creation fails, or bpy module unavailable.
Returns error message string instead of raising exception.
r N�Error: Material 'z' already exists)r) zPrincipled BSDFr � g �?z
Base Colorz Successfully created material 'z' with color RGBr" zError [Create Material]: )r# r) rB � materials�new� node_tree�nodesrD �color�inputs�
default_valuer* r+ r, )r r# �mat�bsdfr. s r/ �create_materialrl P s? � �8'4� �
�
�
� �:���+� +� +�C�u�z�C�C�C� C�
�h� �$�$�%�*�$�5�5�� �=� ��=�&�*�*�+<�=�=�D��
� �K��N��K��N��K��N�� ;�� �L�)�7�
+�e�j�
+�
+� "�[�
+�
+�
��
� T� T� T�S�S�S� � 4� 4� 4�3�3�q�6�6�3�3�3�3�3�3�3�3�����4���s) �!B: �BB: �:
C,� C,�C'�!C,�'C,c �� � ddl }|j j � | j � � }|� d| j � d�S |j j � | j � � }|� d| j � d�S |j j r||j j d< n |j j � |� � d| j � d| j � d�S # t $ r Y d S t $ r }d
t |� � � �cY d}~S d}~ww xY w) a�
Assign a material to an object.
This function demonstrates:
- Checking object existence before assignment
- Checking material existence before assignment
- Accessing object data (mesh data)
- Working with object material slots
- Replacing existing materials vs appending new ones
- Proper error handling for missing objects/materials
Args:
input: Validated input parameters containing:
- object_name: Name of the object to assign material to (must exist)
- material_name: Name of the material to assign (must exist)
Returns:
Success message confirming material assignment.
Format: "Successfully assigned material '{material_name}' to object '{object_name}'"
Raises:
Exception: If object or material is not found, or assignment fails.
Returns error message string instead of raising exception.
r Nr@ rA ra z Successfully assigned material 'z
' to object 'rV r" zError [Assign Material]: ) r# rB rC rD � object_namerc �
material_namerP r* r+ r, )r r# rI rj r. s r/ �assign_materialrp � sB � �24� �
�
�
��h� �"�"�5�#4�5�5�� �;�C�U�%6�C�C�C� C��h� �$�$�U�%8�9�9�� �;�G�u�':�G�G�G� G� �8� � +�$'�C�H� �q� !� !� �H� � %� %�c� *� *� *�
/�u�/B�
/�
/� �+�
/�
/�
/�
��
� T� T� T�S�S�S� � 4� 4� 4�3�3�q�6�6�3�3�3�3�3�3�3�3�����4���s/ �4B6 �0B6 �(A
B6 �6
C(� C(� C#� C(�#C(c � � ddl }|j j � | j � � }|� d| j � d�S | j |_ d| j � d| j � �S # t $ r Y dS t $ r }dt |� � � �cY d}~S d}~ww xY w) a;
Rotate an object by setting its rotation angles.
This function demonstrates:
- Accessing objects from bpy.data.objects collection
- Setting object rotation property (Euler angles)
- Converting rotation values to Blender's rotation format
- Proper error handling for missing objects
Args:
input: Validated input parameters containing:
- name: Name of the object to rotate (must exist in scene)
- rotation: Tuple of (x, y, z) rotation values in radians (Euler angles)
Returns:
Success message confirming rotation.
Format: "Successfully rotated object '{name}' to rotation {rotation}"
Raises:
Exception: If object is not found or rotation fails.
Returns error message string instead of raising exception.
r Nr@ rA z Successfully rotated object 'z' to rotation r" zError [Rotate Object]: )
r# rB rC rD r) r8 �rotation_eulerr* r+ r, rH s r/ �
rotate_objectrs � s� � �.2� �
�
�
��h� �"�"�5�:�.�.�� �;�<�U�Z�<�<�<� <� "�^���
,�E�J�
,�
,� �>�
,�
,�
��
� T� T� T�S�S�S� � 2� 2� 2�1��Q���1�1�1�1�1�1�1�1�����2����( �4A � A �
B�" B�+B�<B�Bc � � ddl }|j j � | j � � }|� d| j � d�S | j |_ d| j � d| j � �S # t $ r Y dS t $ r }dt |� � � �cY d}~S d}~ww xY w) a
Scale an object by setting its scale factors.
This function demonstrates:
- Accessing objects from bpy.data.objects collection
- Setting object scale property (x, y, z scale factors)
- Validating scale values are positive
- Proper error handling for missing objects
Args:
input: Validated input parameters containing:
- name: Name of the object to scale (must exist in scene)
- scale: Tuple of (x, y, z) scale factors (must be positive)
Returns:
Success message confirming scaling.
Format: "Successfully scaled object '{name}' to scale {scale}"
Raises:
Exception: If object is not found or scaling fails.
Returns error message string instead of raising exception.
r Nr@ rA z Successfully scaled object 'z ' to scale r" zError [Scale Object]: ) r# rB rC rD r) r9 r* r+ r, rH s r/ � scale_objectrv � s� � �.1� �
�
�
��h� �"�"�5�:�.�.�� �;�<�U�Z�<�<�<� <��K�� �
&�5�:�
&�
&� � �
&�
&�
��
� T� T� T�S�S�S� � 1� 1� 1�0��A���0�0�0�0�0�0�0�0�����1���rt c � � ddl }|j j � | j � � }|� d| j � d�S d|j � �d|j � �dt
|j � � � �dt
|j � � � �d t
|j � � � �g}|j d
k re|j r^|�
d t |j j � � � �� � |�
d t |j j
� � � �� � d
� |� � S # t $ r Y dS t $ r }dt# |� � � �cY d}~S d}~ww xY w)aw
Get detailed information about an object in the scene.
This function demonstrates:
- Accessing objects from bpy.data.objects collection
- Reading multiple object properties (location, rotation, scale, type)
- Formatting object information for display
- Handling missing objects gracefully
Args:
input: Validated input parameters containing:
- name: Name of the object to get information about (must exist in scene)
Returns:
Detailed information string about the object including:
- Name and type
- Location (x, y, z)
- Rotation (x, y, z) in radians
- Scale (x, y, z)
Format: Multi-line string with object properties
Raises:
Exception: If object is not found or info retrieval fails.
Returns error message string instead of raising exception.
r Nr@ rA zObject: zType: z
Location: z
Rotation: zScale: �MESHz
Vertices: zFaces: rL r" zError [Get Object Info]: )r# rB rC rD r) rN rO r rr r9 rP rM �vertices�polygonsrQ r* r+ r, )r r# rI �
info_linesr. s r/ �get_object_infor| & s� � �44� �
�
�
��h� �"�"�5�:�.�.�� �;�<�U�Z�<�<�<� <�
"�s�x� !� !� �S�X� � � .��s�|�,�,� .� .� 4��s� 1�2�2� 4� 4� (�e�C�I�&�&� (� (� !
�
� �8�v� � �#�(� � � � � C�3�s�x�/@�+A�+A� C� C� D� D� D� � � � @��C�H�,=�(>�(>� @� @� A� A� A��y�y��$�$�$�� � T� T� T�S�S�S� � 4� 4� 4�3�3�q�6�6�3�3�3�3�3�3�3�3�����4���s) �4D �CD �
E� E�(D?�9E�?Ec �8 � ddl }|j j � | j | j �� � |j j }|�dS | j |_ d| j � d| j � d| j � �S # t $ r Y dS t $ r }d t |� � � �cY d}~S d}~ww xY w)
a�
Create a camera in the Blender scene.
This function demonstrates:
- Using bpy.ops to create camera objects
- Setting camera location and rotation
- Accessing the active object after creation
- Setting object properties (name)
- Proper error handling for Blender operations
Args:
input: Validated input parameters containing:
- name: Name for the camera object (1-63 characters)
- location: Tuple of (x, y, z) coordinates for camera position
- rotation: Tuple of (x, y, z) rotation values in radians (Euler angles)
Returns:
Success message with camera details including name, location, and rotation.
Format: "Successfully created camera '{name}' at location {location} with rotation {rotation}"
Raises:
Exception: If Blender operation fails or bpy module is not available.
Returns error message string instead of raising exception.
r N)r r8 z;Error: Camera created but could not get reference to objectz Successfully created camera '�' at location z with rotation r" zError [Create Camera]: ) r# r$ r] �
camera_addr r8 r' r( r) r* r+ r, )r r# �camerar. s r/ �
create_camerar� ] s� � �22� �
�
�
� ���!�!��^��^� "�
�
�
�
��*�� �>�P�P��j�� �
K�E�J�
K�
K� �>�
K�
K�:?�.�
K�
K�
��
� T� T� T�S�S�S� � 2� 2� 2�1��Q���1�1�1�1�1�1�1�1�����2����) �=A' �%A' �'
B�4 B�=B�B�Bc � � ddl }| j dk r'|j j � d| j �� � n�| j dk r'|j j � d| j �� � nc| j dk r'|j j � d| j �� � n1| j dk r&|j j � d| j �� � |j j }|�dS | j |_ |j r| j
|j _
d | j � d
| j � d | j � d | j
� �S # t $ r Y d
S t $ r }dt |� � � �cY d}~S d}~ww xY w)a�
Create a light in the Blender scene.
This function demonstrates:
- Using bpy.ops to create different types of lights
- Setting light location and energy
- Accessing light data properties
- Setting object properties (name)
- Proper error handling for Blender operations
Args:
input: Validated input parameters containing:
- name: Name for the light object (1-63 characters)
- light_type: Type of light (SUN, POINT, SPOT, or AREA)
- location: Tuple of (x, y, z) coordinates for light position
- energy: Light energy/intensity (0.0 to 1000.0)
Returns:
Success message with light details including name, type, location, and energy.
Format: "Successfully created {type} light '{name}' at location {location} with energy {energy}"
Raises:
Exception: If Blender operation fails or bpy module is not available.
Returns error message string instead of raising exception.
r N�SUN)rN r �POINT�SPOT�AREAz:Error: Light created but could not get reference to objectzSuccessfully created z light 'r~ z
with energy r" zError [Create Light]: )r# �
light_typer$ r] � light_addr r' r( r) rB �energyr* r+ r, )r r# �lightr. s r/ � create_lightr� � s� � �4!1� �
�
�
� � �u� $� $� �G�N� $� $�%�%�.� $� I� I� I� I�
�
��
(�
(� �G�N� $� $�'�E�N� $� K� K� K� K�
�
��
'�
'� �G�N� $� $�&�5�>� $� J� J� J� J�
�
��
'�
'� �G�N� $� $�&�5�>� $� J� J� J�� �)�� �=�O�O��Z��
� �:� -� %� �E�J� �
G�E�$4�
G�
G�e�j�
G�
G� �>�
G�
G�8=� �
G�
G�
��
� T� T� T�S�S�S� � 1� 1� 1�0��A���0�0�0�0�0�0�0�0�����1���s+ �CD# � AD# �#
E�0 E�9E�
E�Ec � � ddl }|j j j �dS | j |j j j _ | j |j j j _ | j |j j j _ |j j � d�� � d| j � d| j � d| j � �S # t $ r Y d S t $ r }d
t |� � � �cY d}~S d}~ww xY w) a>
Render the current scene to an image file.
This function demonstrates:
- Configuring render settings (resolution)
- Setting output filepath
- Checking for active camera before rendering
- Using bpy.ops.render.render() to render the scene
- Saving rendered image to file
- Proper error handling for rendering operations
Args:
input: Validated input parameters containing:
- filepath: File path to save the rendered image (must have valid image extension)
- resolution_x: Horizontal resolution in pixels (default: 1920, range: 1-10000)
- resolution_y: Vertical resolution in pixels (default: 1080, range: 1-10000)
Returns:
Success message with render details including filepath and resolution.
Format: "Successfully rendered scene to '{filepath}' at resolution {resolution_x}x{resolution_y}"
Raises:
Exception: If rendering fails, filepath is invalid, or bpy module is not available.
Returns error message string instead of raising exception.
r NzOError [Render Scene]: No active camera found. Create a camera before rendering.T)� write_stillz Successfully rendered scene to 'z' at resolution �xr" zError [Render Scene]: ) r# r' �scener� � resolution_x�render� resolution_y�filepathr$ r* r+ r, )r r# r. s r/ � render_scener� � s" � �41� �
�
�
� �;� � #� +�d�d� 16�0B�� �� �-�05�0B�� �� �-� -2�N�� �� �)� ��� � �$� �/�/�/�
G�u�~�
G�
G� "� /�
G�
G�27�2D�
G�
G�
��
� T� T� T�S�S�S� � 1� 1� 1�0��A���0�0�0�0�0�0�0�0�����1���s) �B$ �B
B$ �$
C�1 C�:C� C�Cc � � ddl }ddl}|j � | j � � }|r1|j � |� � s|� |d�� � |j j � | j �� � d| j � d�S # t $ r Y dS t $ r }d t |� � � �cY d}~S d}~ww xY w)
a�
Save the current Blender scene to a .blend file.
This function demonstrates:
- Using bpy.ops.wm.save_as_mainfile() to save the scene
- Setting the filepath before saving
- Handling file save operations
- Proper error handling for file operations
Args:
input: Validated input parameters containing:
- filepath: Full path where to save the .blend file (must end with .blend)
Returns:
Success message with filepath.
Format: "Successfully saved Blender file to '{filepath}'"
Raises:
Exception: If file save fails or bpy module is not available.
Returns error message string instead of raising exception.
r NT)�exist_ok�r� z$Successfully saved Blender file to 'rV r" zError [Save File]: )
r# �os�path�dirnamer� �exists�makedirsr$ �wm�save_as_mainfiler* r+ r, )r r# r� � directoryr. s r/ � save_filer� s� � �,.��
�
�
�� � � � �G�O�O�E�N�3�3� � � 2�R�W�^�^�I� 6� 6� 2� �K�K� �D�K� 1� 1� 1� ��
�#�#�U�^�#�<�<�<�G�e�n�G�G�G�G�� � T� T� T�S�S�S� � .� .� .�-�S��V�V�-�-�-�-�-�-�-�-�����.���s$ �B B �
B>� B>�"B9�3B>�9B>c �2 � ddl }ddl}|j � | j � � s d| j � d�S |j j � | j �� � d| j � d�S # t $ r Y dS t $ r }dt |� � � �cY d}~S d}~ww xY w) a�
Open a .blend file in Blender.
This function demonstrates:
- Using bpy.ops.wm.open_mainfile() to load a Blender file
- Handling file open operations
- Proper error handling for file operations
Args:
input: Validated input parameters containing:
- filepath: Full path to the .blend file to open (must exist and end with .blend)
Returns:
Success message with filepath.
Format: "Successfully opened Blender file '{filepath}'"
Raises:
Exception: If file open fails, file doesn't exist, or bpy module is not available.
Returns error message string instead of raising exception.
r Nz$Error [Open File]: File not found: 'rV r� z"Successfully opened Blender file 'r" zError [Open File]: ) r# r� r� r� r� r$ r� �
open_mainfiler* r+ r, )r r# r� r. s r/ � open_filer� 1 s� � �*.��
�
�
�� � � � �w�~�~�e�n�-�-� L�K�%�.�K�K�K� K� ��
� � �%�.� �9�9�9�E�E�N�E�E�E�E�� � T� T� T�S�S�S� � .� .� .�-�S��V�V�-�-�-�-�-�-�-�-�����.���s( �1A$ �/A$ �$
B�1 B�:B� B�Bc � � ddl } | j j }|rd|� �S dS # t $ r Y dS t $ r }dt |� � � �cY d}~S d}~ww xY w)a�
Get the filepath of the current Blender file.
This function demonstrates:
- Accessing bpy.data.filepath to get the current .blend file path
- Handling unsaved files (filepath is empty)
- Formatting file path information
Args:
None: This function takes no parameters.
Returns:
String containing the current Blender file path.
Returns "File not saved yet (unsaved file)" if the file hasn't been saved.
Format: "Current Blender file: {filepath}" or "File not saved yet (unsaved file)"
Raises:
Exception: If bpy module is not available.
Returns error message string instead of raising exception.
r NzCurrent Blender file: z!File not saved yet (unsaved file)r" z Error [Get Scene Filepath]: )r# rB r� r* r+ r, )r# r� r. s r/ �get_scene_filepathr� Y s� � �* 7��
�
�
��8�$�� � 7�6�H�6�6� 6�6�6�� � T� T� T�S�S�S� � 7� 7� 7�6�c�!�f�f�6�6�6�6�6�6�6�6�����7���s � �
A
� A
�A�A
�A
c �D � ddl } | j j }t |� � }|dk rdS | j j � d�� � | j j � � � d|� d�S # t $ r Y dS t $ r }d t |� � � �cY d}~S d}~ww xY w)
a�
Clear all objects from the current Blender scene.
This function demonstrates:
- Selecting all objects in the scene
- Deleting all selected objects
- Proper error handling for scene operations
Args:
None: This function takes no parameters and clears all objects.
Returns:
Success message with count of deleted objects.
Format: "Successfully cleared scene - removed {count} object(s)"
Returns "Scene was already empty" if no objects existed.
Raises:
Exception: If clearing fails or bpy module is not available.
Returns error message string instead of raising exception.
r NzScene was already empty�SELECTr[ z%Successfully cleared scene - removed z
object(s)r" zError [Clear Scene]: ) r# rB rC rM r$ r] r^ �deleter* r+ r, )r# rC �countr. s r/ � clear_scener� } s� � �*0� �
�
�
��(�"����\�\�� �A�:�:�,�,� ���!�!��!�2�2�2� ��� � � � � �H�u�H�H�H�H�� � T� T� T�S�S�S� � 0� 0� 0�/�s�1�v�v�/�/�/�/�/�/�/�/�����0���s) �%A- �AA- �-
B �: B �B�B �B c �. � ddl }|j j � | j � � }|� d| j � d�S |j j � d�� � |� d� � ||j j
j _ |j j � � � |j j
}|�dS | j |_ | j � | j |_ d | j � d
| j � d �S # t $ r Y d S t" $ r }d
t% |� � � �cY d}~S d}~ww xY w)a�
Duplicate an object in the Blender scene.
This function demonstrates:
- Accessing objects from bpy.data.objects collection
- Checking object existence before duplication
- Using bpy.ops.object.duplicate() to clone objects
- Setting location and name of duplicate
- Proper error handling for missing objects
Args:
input: Validated input parameters containing:
- name: Name of the object to duplicate (must exist in scene)
- new_name: Name for the duplicated object (1-63 characters)
- location: Optional new location for duplicate (if None, uses original location)
Returns:
Success message confirming duplication.
Format: "Successfully duplicated object '{name}' as '{new_name}'"
Raises:
Exception: If object is not found or duplication fails.
Returns error message string instead of raising exception.
r Nr@ rA rZ r[ Tz4Error: Object duplicated but could not get referencez Successfully duplicated object 'z' as 'rV r" zError [Duplicate Object]: )r# rB rC rD r) r$ r] r^ rG r' rE rF � duplicater( �new_namer r* r+ r, )r r# rI r� r. s r/ �duplicate_objectr� � sM � �2 5� �
�
�
��h� �"�"�5�:�.�.�� �;�<�U�Z�<�<�<� <� ���!�!��!�4�4�4� ���t� � � �03�� � �&�-� ��� � �"�"�"� �K�-� � � �I�I� � � �� �>� %�!&� �I� �U�%�*�U�U�E�N�U�U�U�U�� � T� T� T�S�S�S� � 5� 5� 5�4�C��F�F�4�4�4�4�4�4�4�4�����5���s/ �4C" �A7C" �01C" �"
D�/ D�8D� D�Dc �L � ddl }|j j � | j � � }|� d| j � d�S |j dk rd| j � d|j � d�S ||j j _ d | j � d
�S # t $ r Y d S t $ r }d t |� � � �cY d}~S d}~ww xY w)
a�
Set the active camera for rendering.
This function demonstrates:
- Accessing cameras from bpy.data.objects collection
- Checking camera existence and type
- Setting bpy.context.scene.camera property
- Proper error handling for missing cameras
Args:
input: Validated input parameters containing:
- camera_name: Name of the camera to set as active (must exist and be a camera)
Returns:
Success message confirming camera activation.
Format: "Successfully set '{camera_name}' as active camera"
Raises:
Exception: If camera is not found or setting fails.
Returns error message string instead of raising exception.
r NzError: Camera 'rA �CAMERAr@ z' is not a camera (type: �)zSuccessfully set 'z' as active camerar" zError [Set Active Camera]: ) r# rB rC rD � camera_namerN r' r� r� r* r+ r, )r r# �
camera_objr. s r/ �set_active_camerar� � s� � �,6� �
�
�
��X�%�)�)�%�*;�<�<�
� � �C�U�%6�C�C�C� C� �?�h� &� &�c�U�%6�c�c�Q[�Q`�c�c�c� c� $.�� �� �I�E�$5�I�I�I�I�� � T� T� T�S�S�S� � 6� 6� 6�5�S��V�V�5�5�5�5�5�5�5�5�����6���s. �4A1 � A1 �A1 �1
B#�> B#�B �B#� B#c �` � ddl }|j j � | j | j | j | j �� � |j j }|�dS | j
|_
d| j
� d| j � d| j � d| j � �S # t $ r Y d S t $ r }d
t |� � � �cY d}~S d}~ww xY w) a�
Create a cylinder in the Blender scene.
This function demonstrates:
- Using bpy.ops to create cylinder mesh primitives
- Setting cylinder properties (radius, depth, vertices)
- Accessing the active object after creation
- Setting object properties (name)
- Proper error handling for Blender operations
Args:
input: Validated input parameters containing:
- name: Name for the cylinder object (1-63 characters)
- radius: Radius of the cylinder (must be > 0.001 and <= 1000.0)
- depth: Height/depth of the cylinder (must be > 0.001 and <= 1000.0)
- location: Tuple of (x, y, z) coordinates for cylinder position
- vertices: Number of vertices in the base (3-256)
Returns:
Success message with cylinder details including name, radius, depth, and location.
Format: "Successfully created cylinder '{name}' with radius {radius} and depth {depth} at location {location}"
Raises:
Exception: If Blender operation fails or bpy module is not available.
Returns error message string instead of raising exception.
r N)r4 �depthr ry z=Error: Cylinder created but could not get reference to objectz Successfully created cylinder 'r: z and depth r! r" zError [Create Cylinder]: )r# r$ r% �primitive_cylinder_addr4 r� r ry r' r( r) r* r+ r, )r r# �cylinderr. s r/ �create_cylinderr� s � �64� �
�
�
� �� �+�+��<��+��^��^� ,�
�
�
� �;�,�� � �R�R� �
��
�
_�e�j�
_�
_� �<�
_�
_�49�K�
_�
_�NS�n�
_�
_�
��
� T� T� T�S�S�S� � 4� 4� 4�3�3�q�6�6�3�3�3�3�3�3�3�3�����4���s* �A A; �
-A; �;
B-� B-�B(�"B-�(B-c �8 � ddl }|j j � | j | j �� � |j j }|�dS | j |_ d| j � d| j � d| j � �S # t $ r Y dS t $ r }d t |� � � �cY d}~S d}~ww xY w)
a�
Create a plane in the Blender scene.
This function demonstrates:
- Using bpy.ops to create plane mesh primitives
- Setting plane size
- Accessing the active object after creation
- Setting object properties (name)
- Proper error handling for Blender operations
Args:
input: Validated input parameters containing:
- name: Name for the plane object (1-63 characters)
- size: Size of the plane (must be > 0.001 and <= 1000.0)
- location: Tuple of (x, y, z) coordinates for plane position
Returns:
Success message with plane details including name, size, and location.
Format: "Successfully created plane '{name}' with size {size} at location {location}"
Raises:
Exception: If Blender operation fails or bpy module is not available.
Returns error message string instead of raising exception.
r Nr z:Error: Plane created but could not get reference to objectz Successfully created plane 'r r! r" zError [Create Plane]: ) r# r$ r% �primitive_plane_addr r r' r( r) r* r+ r, )r r# �planer. s r/ � create_planer� L s� � �21� �
�
�
� �� �(�(����^� )�
�
�
�
� �)�� �=�O�O��Z��
�
C�5�:�
C�
C� ��
C�
C�27�.�
C�
C�
��
� T� T� T�S�S�S� � 1� 1� 1�0��A���0�0�0�0�0�0�0�0�����1���r� )1�__doc__r# �typingr r r �modelsr r r r
r r r
r r r r r r r r r r r r r, r0 r> rJ rT rX r_ rl rp rs rv r| r� r� r� r� r� r� r� r� r� r� r� � � r/ �<module>r� s ��� � �
�
�
� 0� 0� 0� 0� 0� 0� 0� 0� 0� 0�� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �.00�� 00�3� 00� 00� 00� 00�fC2�*� C2�s� C2� C2� C2� C2�L-0�� -0�3� -0� -0� -0� -0�`-1�c� -1� -1� -1� -1�`&2�*� &2�s� &2� &2� &2� &2�R*2�*� *2�s� *2� *2� *2� *2�ZC4�.� C4�3� C4� C4� C4� C4�L34�.� 34�3� 34� 34� 34� 34�l*2�*� *2�s� *2� *2� *2� *2�Z*1�(� *1�S� *1� *1� *1� *1�Z44�-� 44�#� 44� 44� 44� 44�n12�*� 12�s� 12� 12� 12� 12�h;1�(� ;1�S� ;1� ;1� ;1� ;1�|51�(� 51�S� 51� 51� 51� 51�p'.�]� '.�s� '.� '.� '.� '.�T%.�]� %.�s� %.� %.� %.� %.�P!7�C� !7� !7� !7� !7�H+0�S� +0� +0� +0� +0�\95� 0� 95�S� 95� 95� 95� 95�x*6� 1� *6�c� *6� *6� *6� *6�Z54�.� 54�3� 54� 54� 54� 54�p11�(� 11�S� 11� 11� 11� 11� 11� 11r�
