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 |
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 |
To quickly create a color mask by materials, assigned to the scene objects, for post-processing
you can use the following script:
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.
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.
In general, the “loop” is usually a sequential selection of several points, edges or polygons of a mesh.
However, there is an element in the mesh structure, which is also called a “loop”. It is a combination of one vertex with one edge of the mesh. Let’s try to learn what these “loops” are for.
When starting Blender from the console it processes all parameters passed through the command line. However, some scripts and add-ons for proper work may require specifying their unique command line arguments. If you specify such additional parameters in the command line, Blender will also try to process them, which is likely to result in an error. Blender provides a special way to exclude such arguments from own processing.
Continue reading “How to pass command line arguments to a Blender python script or add-on”
State switches so-called “radio buttons” are used in the case to limit the choice by one value from several available ones. There are a lot of such buttons in the Blender interface, for example, switching between RGB and BW rendering modes or setting the texture mapping mode. Such buttons can be created in the Blender add-ons interface too.
Let’s create our own radio button switcher.
Continue reading “Creating radio buttons in the Blender add-ons interface”
Single add-on or script can contain several different operators, and not all of them may be registered in the API by the register() function. To verify that the required operator is registered in the Blender API, run the following command:
|
1 |
hasattr(bpy.types, bpy.ops._operator_bl_idname_.idname()) |
Where:
_operator_bl_idname_ – the text value of the bl_idname operator property.
For example for an operator:
|
1 2 3 4 5 6 |
class TestOperator(bpy.types.Operator): bl_idname = 'test.operator' bl_label = 'Test operator' def execute(self, context): pass |
the command will look like this:
|
1 |
hasattr(bpy.types, bpy.ops.test.operator.idname()) |
To start working every Blender add-on must be registered by setting up the checkbox before add-on name in the User Preferences window – Add-ons page.
To programmatically find out if the required add-on is registered, run the following command:
|
1 |
'add-on_name' in the file bpy.context.user_preferences.addons |
Where:
add-on_name – the name of the add-on file (without the .py extension) or the name of the add-on package, if it was installed from the package.
Blender add-ons installation and uninstallation can be managed through the python API. Use the following commands in a script:
To deactivate the add-on:
|
1 |
bpy.ops.wm.addon_disable(module = 'add-on name') |
To uninstall the add-on:
|
1 |
bpy.ops.wm.addon_remove(module = 'add-on name') |
Continue reading “How to install and uninstall Blender add-on via python API”
New mesh Custom Property can be created through the Blender python API by executing the following code:
|
1 |
bpy.data.objects['object_name']['property_name'] = property_value |
with:
After executing this command, the new property will be created and will be available in the Properties window – Object panel – Custom Properties sub-panel.
Like any object custom properties, the created property has a number of parameters that can be accessed by clicking the Edit button. These parameters can also be changed through the API.
Continue reading “Mesh Custom Properties editing through the Blender API”
Active (selected) UV-Map:
|
1 |
bpy.context.active_object.data.uv_layers.active |
Access to the active UV-Map by its name:
|
1 |
bpy.context.active_object.data.uv_layers['UVMap'] |
Continue reading “Working with UV-Maps through the Blender API”
In addition to common panels (N/T/Properties) and their sub-panels, to display the user interface elements while developing Blender add-ons you can also use pop-up panels appearing on the screen when a user presses a certain key combination or perform any action. The simplest example of such panels is the panel that appears when the f6 key is pressed immediately after adding an object (shift+a) to the scene.
Blender API provides developers the ability to create such panels for their add-ons. Let’s consider the creating of a pop-up panel as an example of the “Message box” window.
Continue reading “Creating pop-up panels with user UI in Blender add-on”
How to access the active (selected) objects through the Blender Python API from scripts/add-ons:
|
1 |
bpy.context.area.spaces.active |
|
1 |
bpy.context.screen.scene |
|
1 |
bpy.context.active_object |
|
1 |
bpy.context.active_object.active_material.node_tree.nodes.active |
|
1 |
bpy.context.scene.node_tree.nodes.active |
|
1 |
bpy.context.area.spaces.active.text.as_string() |
|
1 |
bpy.context.active_object.data.uv_layers.active |
Writing scripts in Blender we often need to know the full list of object properties to access them through the Blender API. Consider how we can get a list of available object methods and properties.
Storing data in a remote database has become common practice in the development of software products. Blender is no exception. Writing scripts and add-ons, the developer may need to access the database to retrieve from it or write to it the necessary information. MySQL today is one of the most common and widely available databases and is well suited for working with Blender.
The interaction between Blender and MySQL database through the Blender Python API is not difficult, but it needs some preparation before stating:
Sometimes when creating an animation it is necessary to perform some actions according to the timeline or, the same, to the current animation frame number. Binding animation to timeline frames in Blender is possible using the built-in Python API.
As an example, let’s make a simple animation which turns one of the letters of any text from lowercase to uppercase in series.
To clear compositing window (completely remove all nodes from it), run the following code:
|
1 2 3 4 |
import bpy nodesField = bpy.context.scene.node_tree for currentNode in nodesField.nodes: nodesField.nodes.remove(currentNode) |