Blender 3D: tutorials, articles, tips, notes
Code autocomplete greatly simplifies writing scripts or developing add-ons for Blender. One of the best autocomplete modules for today is developed by Nutti. Last updated 20190718.
The project is hosted on the author’s GitHub: https://github.com/nutti/fake-bpy-module
The modules are distributed via pip or as a pre-generated-modules. Author also provides a module generator with which you can assemble autocomplete modules yourself.
When we create a field on the add-on interface panel, the value of which changes something in the node tree, each time the user changes the field value the node tree recompiles. If the user changes the value in that field by holding and moving the mouse, too frequent node tree recompilation will cause Blender to hangs.
This problem can be solved using decorators for deferred updating of the node tree.
Code by Skarn.
Class for quick node creation by their type.
Code by Skarn.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
class NodeTreeBuilder: def __init__( self , node_tree : bpy.types.NodeTree , x : float = -200 , y : float = -200 , delimeter : float = 300 ): self._x = x self._y = y self.tree = node_tree self.delimeter = delimeter self.purge_tree() def purge_tree(self): for node in self.tree.nodes: self.tree.nodes.remove(node) def add_node( self , node_type : str , node_name : str , column : int , row : int , node_descr : str = "" ): node = self.tree.nodes.new(node_type) node.name = node_name node.label = node_descr if node_descr else node_name node.location = (self.delimeter * column + self._x, -self.delimeter * row + self._y) return node |
With the Blender popularity growing, the number of add-ons created for it by third-party developers is growing too. A lot of high-quality professional add-ons are written for Blender now. Over time, the number of add-ons is becoming more and more. And on this wave aggregators appeared – programs and services independently searching for add-ons and allowing Blender users to install add-ons quickly, many at once, and bypassing add-on distribution channels selected by their authors. What caused a negative reaction of add-on developers.
Continue reading “How to protect your add-on from downloading through aggregators”
The following command returns the 3D View areas list with enabled Local View mode:
|
1 2 3 |
[area for area in bpy.context.screen.areas if area.type =='VIEW_3D' and area.spaces[0].local_view] # [bpy.data.screens['Layout']...Area] |
The easiest way to hide and show rendering objects is to assign animation keys to them. To do this, move the cursor over the eye icon (visibility in the viewport) or camera (visibility when rendering) in the Outliner window, press the “i” key and then manage the created condition in the Graph Editor like the ordinary animation keys.
But this method is not always available. For example, we cannot assign visibility animation keys for collections, Blender will generate errors like:
“hide_viewport” property cannot be animated
or
“hide_render” property can not be animated
However, using the Blender Python API, we can control the visibility of such objects.
Continue reading “Changing objects visibility in the viewport and while rendering”
Nutti, the author of the “fake-bpy-modules” project, has made the installation of the Blender Python API autocomplete modules through the pip platform. Pip installation is faster and easier, but sometimes we just need to copy the autocomplete modules to our project but now they are not included in the Nutti’s GitHub.
Copies of the autocomplete modules for Blender versions 2.79 and 2.80 can be downloaded directly from here: https://github.com/Korchy/blender_autocomplete
To get the vertex coordinates in the scene global coordinate system when the object’s scale was not applied, we need to multiply the local vertex coordinates by the object world transformation matrix:
|
1 2 3 |
object = bpy.data.objects['_MY_OBJECT_'] v_local = object.data.vertices[_VERT_NUMBER_].co # local vertex coordinate v_global = object.matrix_world @ v_local # global vertex coordinates |
In Blender 2.8 API the requirements for the class and their identifiers naming are becoming tougher. The class name must match the following convention:
|
1 |
UPPER_CASE_{SEPARATOR}_mixed_case |
Where the {SEPARATOR} is two letters denoting the class belonging to a certain type (from which type the class is inherited):
The class identifier “bl_idname” mast match the class name.
Continue reading “Class naming conventions in Blender 2.8 Python API”
Add-on registration and removing were made with the “Window manager” (wm) in Blender 2.7 Python API:
|
1 2 3 4 5 |
bpy.ops.wm.addon_install(filepath='_path_to_addon', overwrite=True) bpy.ops.wm.addon_enable(module='addon_name') bpy.ops.wm.addon_remove(module='addon_name') |
In Blender 2.8 API add-on operators moved to the “preferences”:
|
1 2 3 4 5 |
bpy.ops.preferences.addon_install(filepath='_path_to_addon', overwrite=True) bpy.ops.preferences.addon_enable(module='addon_name') bpy.ops.preferences.addon_remove(module='addon_name') |
3D-cursor location property
|
1 |
context.scene.cursor_location |
in Blender 2.8 API moved to “cursor” object
|
1 |
context.scene.cursor.location |
When trying to get the cursor location through the “context.scene.cursor_location” Blender throws an error:
‘Scene’ object has no attribute ‘cursor_location’
When developing add-ons it is often necessary to give an ability to set a number of parameters that affect the whole add-on work to the user. For example, the user can specify a directory for saving/loading files, set some default variables or switch between add-on modes. Of course, the interface for setting such parameters can be placed in the add-on panel, but it is better to place it in a separate add-on preferences panel, which is located in the “Preferences” window under the add-on installation panel.
The main advantage of the add-on preferences is that they don’t reset when Blender restarts. The user does not need to configure the add-on preferences each time, it’s enough to set the necessary parameters once, personalizing the add-on for convenient work.
Let’s create an add-on and define a parameter, placing it in the add-on preferences panel.
In Blender 2.7 the “*” (star) operator is used in the matrix, vector, and quaternion multiplication. In Blender 2.8 it is replaced with the “@” (at) operator.
If the “*” operator is used in vector, matrix or quaternion multiplication in Blender 2.8 it throws an error:
Element-wise multiplication: not supported between ‘Matrix’ and ‘Matrix’ types
Proper use of the “@” operator:
|
1 |
bpy.context.region_data.view_rotation @ Vector((0.0, 0.0, 1.0)) |
The snapping elements property from Blender 2.7
|
1 |
bpy.context.scene.tool_settings.snap_element |
changed in Blender 2.8 API to
|
1 2 |
bpy.context.scene.tool_settings.snap_elements # {'EDGE'} |
The “pivot_point” property from Blender 2.7
|
1 2 |
bpy.context.area.spaces[0].pivot_point # 'BOUNDING_BOX_CENTER': |
in Blender 2.8 API moved to:
|
1 2 |
bpy.context.scene.tool_settings.transform_pivot_point # 'MEDIAN_POINT' |
The “use_drag_immediately” property from Blender 2.7
|
1 |
bpy.context.preferences.edit.use_drag_immediately |
in Blender 2.8 API moved to
|
1 2 |
bpy.context.preferences.inputs.use_drag_immediately # True |
In Blender 2.7 the current coordinate system could be changed through the
|
1 |
bpy.context.space_data.transform_orientation |
property. In Blender 2.8 coordinate system access moved to the scene collection of “TransformOrientatiosSlots” objects. To get or set the current coordinate system the “transform_orientation_slots” collection is used.
|
1 2 3 4 5 6 7 8 |
bpy.context.window.scene.transform_orientation_slots[0].type # 'GLOBAL' bpy.context.window.scene.transform_orientation_slots[0].type = 'LOCAL' bpy.context.window.scene.transform_orientation_slots[0].type # 'LOCAL' |
To set mesh (object) as active in Blender 2.8 Python API the “context.view_layer” is used instead of “context.scene”.
When trying to make object active with “bpy.context.scene.objects.active” Blender throws an error:
AttributeError: bpy_prop_collection: attribute “active” not found
To make object active in Blender 2.8 use the following code:
|
1 2 |
obj = bpy.context.window.scene.objects[0] bpy.context.view_layer.objects.active = obj # 'obj' is the active object now |
According to Blender 2.8 Python API changes mesh (object) can be selected with using getters and setters.
When trying to check the selected status of the mesh through the “bpy.context.active_object.select” property, Blender throws an error:
AttributeError: ‘Object’ object has no attribute ‘select’
To check whether an object is selected in Blender 2.8 use a getter:
|
1 2 |
bpy.context.active_object.select_get() # True |
To select an object in Blender 2.8 use a setter:
|
1 |
bpy.context.active_object.select_set(state=True) |
To unselect an object use the same setter:
|
1 |
bpy.context.active_object.select_set(state=False) |
To find what Python interpreter version is used in current Blender version type the following commands in Python Console window in Blender:
|
1 2 3 4 |
import sys print(sys.version_info) # sys.version_info(major=3, minor=7, micro=0, releaselevel='final', serial=0) |
It means that the version of Python used in Blender is 3.7.0.
To make it more readable type the following command:
|
1 2 |
print('.'.join(map(str, sys.version_info[:3]))) # 3.7.0 |
or with full info:
|
1 2 |
print(sys.version) # 3.7.0 (default, Aug 26 2018, 16:05:01) [MSC v.1900 64 bit (AMD64)] |
In the latest version 2.8 of Blender developers have made many changes in API, so all the scripts and add-ons written for earlier Blender versions (2.7 and below) have stopped working. To run your add-ons in the new Blender 2.8, you need to port them – correct their code to work properly with the new Blender API.
To enable your add-on in Blender 2.80 you have to make the following changes in code:
Continue reading “Porting add-on from Blender 2.7 to Blender 2.8”
Blender has its own built-in text editor for writing scripts and add-ons, but it’s much convenient to develop them in external IDEs that provide the user with more features such as autocomplete, syntax highlighting, integration with version control systems and other tools that make development faster and easier.
One of these IDEs is Visual Studio Code from Microsoft. This is a free universal environment that supports development with various programming languages, including the Blender API language – Python.
To check is an attribute/property of any Blender object (mesh, node, modifier, etc.) read-only:
<object> .is_property_readonly (‘<property name>’)
<object> .bl_rna.properties [‘<property name>’]. is_readonly
For example, for the “is_editmode” mesh property (is the mesh in edit mode or not):
|
1 2 3 4 5 6 7 8 |
bpy.context.active_object.data.is_property_readonly('is_editmode') # True bpy.context.active_object.data.bl_rna.properties['is_editmode'].is_readonly # True |
A complete list of add-ons installed in Blender we can get using the addon_utils:
|
1 2 3 4 |
import addon_utils print(addon_utils.modules()[:]) # <module 'space_view3d_3d_navigation' from ... |
Having the add-ons list, we can get the version of the desired add-on by its name with the following code:
|
1 2 3 4 |
import addon_utils print([addon.bl_info.get('version', (-1,-1,-1)) for addon in addon_utils.modules() if addon.bl_info['name'] == 'ADD-ON_NAME'][0]) # (1,4,0) |
Where the ADD-ON_NAME is the name of the desired add-on.
If the add-on is missing a version indication, the default result will be returned.
|
1 |
# (-1,-1,-1) |
Change the mesh_select_mode property to switch in mesh edit mode between vertex, edge and polygon selection mode in Blender.
For vertex selection mode:
|
1 |
bpy.context.tool_settings.mesh_select_mode = (True, False, False) |
Edge selection mode:
|
1 |
bpy.context.tool_settings.mesh_select_mode = (False, True, False) |
And face selection mode:
|
1 |
bpy.context.tool_settings.mesh_select_mode = (False, False, True) |
The multi-select mode is enabled too. For example for vertex and face selection mode:
|
1 |
bpy.context.tool_settings.mesh_select_mode = (True, False, True) |
In BMesh for vertex, edge and face selection mode:
|
1 2 3 |
bm.select_mode = {'VERT'} bm.select_mode = {'EDGE'} bm.select_mode = {'FACE'} |
For multi-select in BMesh:
|
1 |
bm.select_mode = {'VERT', 'EDGE', 'FACE'} |