Scripts • B3D - Interplanety

Operators for globally hiding objects in all project scenes

Leave a Comment / Blender 3D / By Nikita / 13.09.2021 09.09.2021

To hide an object in the 3D Viewport window for the current scene we use the “object.hide_view_set” operator, which calls when we clicking the icon with an “eye” in the outliner. However, to hide the object in the viewport for all scenes of the project at once (clicking on the icon with the “monitor” image) a special operator is not provided. We can make it ourselves.

Content on Patreon

Operators for globally hiding objects in all project scenesRead More »

Compiling a video from a sequence of frames using the FFmpeg codec

Leave a Comment / Blender 3D / By Nikita / 04.08.2021 09.09.2021

Rendering directly to a video file in Blender is not always useful. More often, a sequence (a set) of frames is received after render, which then, for example, after additional post-processing, must be assembled to the final video file.

Content on Patreon

We can compile a sequence of frames into a video with Blender itself, with the Visual Screen Editor (VSE). Or we can use third-party codecs, for example, FFmpeg.

Compiling a video from a sequence of frames using the FFmpeg codecRead More »

Origin to active

Leave a Comment / Blender 3D / By Nikita / 02.08.2021 11.06.2021

A simple script for transferring the origin of all selected objects to the origin of the active object.

Origin to activeRead More »

Objects pointers brokes if undo/redo operation is used

Leave a Comment / Blender 3D / By Nikita / 25.05.2020 11.04.2020

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.

Objects pointers brokes if undo/redo operation is usedRead More »

Global materials override for the Blender EEVEE render engine

Leave a Comment / Blender 3D / By Nikita / 17.04.2020 16.04.2020

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.

Global materials override for the Blender EEVEE render engineRead More »

Setting operator parameters features

Leave a Comment / Blender 3D / By Nikita / 18.03.2020 10.03.2020

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:

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

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.

Setting operator parameters featuresRead More »

Render from console only on the specified GPU devices

Leave a Comment / Blender 3D / By Nikita / 16.03.2020 16.03.2020

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.

Render from console only on the specified GPU devicesRead More »

How to check the direction of a Bezier curve

Leave a Comment / Blender 3D / By Nikita / 07.02.2020 05.01.2020

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:

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

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

How to save mesh data to text

Leave a Comment / Blender 3D / By Nikita / 27.12.2019 19.11.2019

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:

How to save mesh data to textRead More »

Calling functions by pressing buttons in Blender custom UI

8 Comments / Blender 3D / By Nikita / 02.12.2019 12.06.2020

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.

Calling functions by pressing buttons in Blender custom UIRead More »

Executing operators with parameters

Leave a Comment / Blender 3D / By Nikita / 06.11.2019 05.10.2019

When making your own custom operators, sometimes it is necessary to pass them certain values – execute operator with parameters.

The passed parameter must be defined as an operator property.

Executing operators with parametersRead More »

Transfer selection from the UV-map to mesh

Leave a Comment / Blender 3D / By Nikita / 04.11.2019 29.09.2019

The UV-map is directly linked to the mesh through meshloops. We can use that to transfer the selection from the UV-map to the mesh.

To transfer the selection from the UV-map to the mesh, we need to cycle through the mesh polygons, check which meshloops are selected and select the corresponding vertices on the mesh itself.

Transfer selection from the UV-map to meshRead More »

Fake-bpy-module

Leave a Comment / Blender 3D / By Nikita / 26.07.2019 23.07.2019

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.

Decorators for node tree updation delay

Leave a Comment / Blender 3D / By Nikita / 08.07.2019 05.07.2019

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.

Decorators for node tree updation delayRead More »

Class for creating nodes by type

Leave a Comment / Blender 3D / By Nikita / 03.07.2019 02.07.2019

Class for quick node creation by their type.

Code by Skarn.

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

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

Class for creating nodes by typeRead More »

Changing objects visibility in the viewport and while rendering

Leave a Comment / Blender 3D / By Nikita / 17.06.2019 27.05.2019

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

“hide_render” property can not be animated

However, using the Blender Python API, we can control the visibility of such objects.

Changing objects visibility in the viewport and while renderingRead More »

Blender autocomplete modules

Leave a Comment / Blender 3D / By Nikita / 27.05.2019 10.05.2019

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

How to get global vertex coordinates

Leave a Comment / Blender 3D / By Nikita / 22.05.2019 04.05.2019

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:

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

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

Color mask by scene materials

Leave a Comment / Blender 3D / By Nikita / 15.04.2019 04.04.2019

To quickly create a color mask by materials, assigned to the scene objects, for post-processing

you can use the following script:

Color mask by scene materialsRead More »

Add-on preferences panel

Leave a Comment / Blender 3D / By Nikita / 25.03.2019 12.03.2019

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.

Add-on preferences panelRead More »

How to check what version of Python interpreter is used in Blender

Leave a Comment / Blender 3D / By Nikita / 01.02.2019 27.01.2019

To find what Python interpreter version is used in current Blender version type the following commands in Python Console window in Blender:

import sys
print(sys.version_info)

# sys.version_info(major=3, minor=7, micro=0, releaselevel='final', serial=0)

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:

print('.'.join(map(str, sys.version_info[:3])))
# 3.7.0

1 2	print('.'.join(map(str, sys.version_info[:3]))) # 3.7.0

or with full info:

print(sys.version)
# 3.7.0 (default, Aug 26 2018, 16:05:01) [MSC v.1900 64 bit (AMD64)]

1 2	print(sys.version) # 3.7.0 (default, Aug 26 2018, 16:05:01) [MSC v.1900 64 bit (AMD64)]

Porting add-on from Blender 2.7 to Blender 2.8

Leave a Comment / Blender 3D / By Nikita / 28.01.2019 29.01.2019

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:

Porting add-on from Blender 2.7 to Blender 2.8Read More »

Using Microsoft Visual Studio Code as external IDE for writing Blender scripts/add-ons

2 Comments / Blender 3D / By Nikita / 09.01.2019 10.05.2019

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.

Using Microsoft Visual Studio Code as external IDE for writing Blender scripts/add-onsRead More »

Learning loops

1 Comment / Blender 3D / By Nikita / 26.06.2018 26.06.2018

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.

Learning loopsRead More »

How to pass command line arguments to a Blender python script or add-on

Leave a Comment / Blender 3D / By Nikita / 17.04.2018 17.04.2018

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.

How to pass command line arguments to a Blender python script or add-onRead More »