Blender 3D add-on for converting material nodes into python source code and storing it in the library.
| Gumroad |
Tag: Python
How to rotate objects through the Blender Python API
For objects rotation, we can use the “rotation_euler” property. This property is a list of three items, each of them corresponds to the rotation angle around the X, Y, and Z-axis. The otation_euler[0] contains the rotation angle around the X-axis, rotation_euler[1] – around the Y-axis, and rotation_euler[2] – around the Z-axis. To rotate an object we must set a rotation angle to the appropriate field of the property.
For example, to rotate an active object around the X-axis to the 90 degrees angle we must execute the following command:
|
1 2 |
import math bpy.context.active_object.rotation_euler[0] = math.radians(90) |
math.radians is used to convert degrees to radians.
How to switch between flat and smooth shading through the Blender Python API
The flat/smooth shading mode is regulated through the “use_smooth” property of each polygon of the mesh.
To enable smooth shading we need to set the “use_smooth” property of each mesh polygon to “True”.
For active object:
|
1 |
bpy.context.object.data.polygons.foreach_set('use_smooth', [True] * len(bpy.context.object.data.polygons)) |
To enable flat shading – set the “use_smooth” property of each polygon to “False”.
|
1 |
bpy.context.object.data.polygons.foreach_set('use_smooth', [False] * len(bpy.context.object.data.polygons)) |
To make new shading mode visible – force update mesh data:
|
1 |
bpy.context.object.data.update() |
Switching to the view from camera throug the python API
To switch to the view from the active camera we can execute the following command:
|
1 |
bpy.ops.view3d.view_camera() |
This operator works in the toggle mode, so the next executing of the same command returns the view to the previous state.
Continue reading “Switching to the view from camera throug the python API”
Switching between coordinate systems
To switch from a global coordinate system to a local coordinate system of an object, we need to multiply the global coordinates by the inverted matrix of an object:
|
1 2 3 4 5 |
import copy object_matrix_inverted = copy.copy(bpy.context.object.matrix_world) object_matrix_inverted.invert() cursor_location_local = object_matrix_inverted @ bpy.context.scene.cursor.location |
To switch from the local coordinate system of the object to the global coordinate system, we need to multiply the local coordinates by the matrix of an object:
|
1 2 3 4 5 |
import copy object_matrix = copy.copy(bpy.context.object.matrix_world) vertex_0 = bpy.context.object.data.vertices[0].co vertex_0_global = object_matrix @ vertex_0 |
Objects pointers brokes if undo/redo operation is used
In Blender 2.8x the undo/redo operation system (ctrl+z / ctrl+shift+z) has been completely rebuilt. One of the results of this API change is when the undo operation is performed, all objects in the scene are fully recreated – the current object is destroyed, and a completely new object is created instead. Pointers to the old objects (before the undo operation) now point to invalid objects that can no longer be used.
Continue reading “Objects pointers brokes if undo/redo operation is used”
Where did the code completion in the python console in Blender 2.82 disappear
In Blender 2.81 and earlier, you could see the possible code completion by pressing “ctrl + space” in the python console. This key-shot shows nothing in Blender 2.82.
Code autocompletion in the python console was not removed in 2.82, it was moved to the “tab” key.
User interface elements alignment by columns
Interface elements in custom user panels often do not correspond to each other in size. As a result – the overall panel layout does not look beautiful. As an example, let’s create a custom panel and place an operator button and an input text field on it.
Can we make it more accurate?
Continue reading “User interface elements alignment by columns”
How to get all collectons list
To get a list of collections with all internal collections, we can use the following function:
|
1 2 3 4 |
def collections(collection, col_list): col_list.append(collection) for sub_collection in collection.children: collections(sub_collection, col_list) |
Global materials override for the Blender EEVEE render engine
Some times we need to make a render of the scene with the single material, for example, for clay or wireframe renders. Blender has the global materials override option for the Cycles render engine in the “View Layer Properties” – “Override” but not for the EEVEE render engine.
Quick materials override for the EEVEE rendering engine can be made with a small script, as shown in the following video:
Script and video by Vitaly Sokol.
Continue reading “Global materials override for the Blender EEVEE render engine”
Setting operator parameters features
When you make a button in a custom UI to call the operator with passing the necessary parameters to it, pay attention that only the parameters specified explicitly will be sent to the operator. Other operator parameters will remain with default values.
For example, we need to execute the “transform_apply” operator – applying object transformations with applying just the scale.
If we call the operator as follows:
|
1 2 3 4 5 6 7 8 9 |
class TESTPANEL_PT_panel(Panel): bl_idname = 'TESTPANEL_PT_panel' bl_label = 'Testpanel' bl_space_type = 'VIEW_3D' bl_region_type = 'UI' bl_category = 'Testpanel' def draw(self, context): self.layout.operator('context.object.transform_apply', text='Apply Scale').scale = True |
But all transformation (scale, rotation, and position) will still be applied to the object.
Render from console only on the specified GPU devices
Sometimes, to effectively distribute the hardware load it is necessary to make a render from Blender only on certain video cards of several of them.
To do this we can use a simple script in which specify the numbers of devices to be used for rendering.
Continue reading “Render from console only on the specified GPU devices”
How to check the direction of a Bezier curve
The direction of a Bezier curve, visually indicated by its normals slope, can be checked by the indices of its points.
The Bezier curve points indices always ascending in the curve direction.
So, having two points on the curve we can get the direction through their indices:
|
1 2 3 4 5 6 7 8 |
bezier_spline = bpy.context.object.data.splines[0] p0 = bezier_spline.bezier_points[0] p1 = bezier_spline.bezier_points[1] p0_index = next(iter([point[0] for point in bezier_spline.bezier_points.items() if point[1] == p0]), None) p1_index = next(iter([point[0] for point in bezier_spline.bezier_points.items() if point[1] == p1]), None) direction = 'p0 to p1' if p0_index < p1_index else 'p1 to p0' print(direction) # p0 to p1 |
Updation autocomplete modules fake-bpy-modules for Blender Python API
Blender Python API autocomplete modules by Nutti update – added branch for Blender 2.81a.
Last release: 2020.01.11.
Author GitHub: https://github.com/nutti/fake-bpy-module
Only files (without pip installation) https://github.com/Korchy/blender_autocomplete
Assigning custom properties to vertexes
Working with mesh geometry, it may be necessary to assign each vertex some custom properties or data that must be written to the blend-file when saved, and which must be accessed later.
However, an attempt to assign the necessary data to the vertexes through the creation of custom properties fails. Instead of the custom vertex property, only a tuple with reference to the type of the property is created.
How to split and join Blender interface windows thruough the python API
A set of operators is provided in Blender for manipulating with the location of its interface windows.
To split the current window (using the current context) into two in a specified ratio, we need to execute the following operator:
|
1 |
bpy.ops.screen.area_split(direction='VERTICAL', factor=0.5) |
With:
- direction – set the splitting direction (‘HORIZONTAL’ or ‘VERTICAL’)
- factor – percentage ratio of splitting windows
Continue reading “How to split and join Blender interface windows thruough the python API”
How to save mesh data to text
Sometimes it is necessary to save data for creating a mesh (its vertices and polygon indices arrays) to text, for example, for further use in a script or addon.
We can export the mesh to one of the open formats, for example, to *.obj, but if we need only its vertexes and polygons data, we can use the following simple script:
Custom property
The Blender API provides a set of simple property types described in bpy.props (IntProperty, BoolProperty, etc.). But the basic types are not always enough, sometimes we need more complex ones. The Blender API allows to group simple properties to make complex properties.
Let’s consider such complex property creation and make the 3×3 matrix property as an example.
How to get current Blender version number through the Python API
To get current Blender version number through the Python API we need to execute the following command:
|
1 2 3 |
bpy.app.version # (2, 81, 16) |
or
|
1 2 3 |
bpy.app.version_string # '2.81 (sub 16)' |
Continue reading “How to get current Blender version number through the Python API”
Drawing in Blender viewport
The Blender 2.80 API provides an ability to draw in a viewport (3D Viewport) using the “gpu” module.
As an example let’s draw a simple coordinate system widget in the center of the scene, consisting of three lines with different colors.
Calling functions by pressing buttons in Blender custom UI
The button click is basically connected with the operator calling in the Blender user interface. However, some times actions, that need to be performed when a button is pressed, are quite simple and do not require a separate operator for them. And it makes no sense to fill a registered operators stack with a multitude of specific operators designed to perform one highly specialized function. It would be much more convenient to associate a button press with a separate function call but the Blender API allows to associate buttons only with an operator call.
To solve the problem of creating a separate operator for each button we can use the fact that the operator can be called with the input parameters.
Continue reading “Calling functions by pressing buttons in Blender custom UI”
How to get a list with all possible values of an EnumProperty
To correctly set values to an EnumProperty type we need to know all its possible entries.
If we try to set a value to an EnumProperty that is out of its available variants, Blender will throw an error:
TypeError: bpy_struct: item.attr = val: enum “xxx” not found in (‘value_001′, value_002’, …)
where:
xxx – the value we tried to set to an EnumProperty
value_001, value_002, … – possible EnumProperty values
Continue reading “How to get a list with all possible values of an EnumProperty”
How to move cursor to vertex
To translate cursor to the desired mesh vertex execute the following code:
|
1 |
bpy.context.scene.cursor.location = bpy.context.object.matrix_world @ bpy.context.object.data.vertices[_VERTEX_NUMBER_].co |
Attention to the multiplication order – world matrix should be left.
How to link a new object to a scene in Blender 2.80 Python API
In Blender 2.79 Python API we can add a new object to a scene with:
|
1 |
bpy.context.scene.objects.link(new_object) |
If we try to do this in Blender 2.80, it throws an error:
‘bpy_prop_collection’ object has no attribute ‘link’
In Blender 2.80 API new objects mast be linked not to the scene, but to the scene collections:
To link a new object to the active scene collection:
|
1 |
bpy.context.scene.collection.objects.link(new_object) |
To link a new object to the collection by its name:
|
1 |
bpy.data.collections['collection_name'].objects.link(new_object) |
How to move the cursor to the active strip start/end position in Blender VSE
To move the cursor to the start position of the active strip in Blender VSE:
|
1 |
bpy.context.scene.frame_current = bpy.context.scene.sequence_editor.active_strip.frame_start |
To move the cursor to the end position of the active strip:
|
1 |
bpy.context.scene.frame_current = bpy.context.scene.sequence_editor.active_strip.frame_final_end |