Python – Blender – Interplanety

Changes in add-ons registration through the API in Blender 2.8

Add-on registration and removing were made with the “Window manager” (wm) in Blender 2.7 Python API:

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')

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”:

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')

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 in Blender 2.8 Python API

3D-cursor location property

context.scene.cursor_location

1	context.scene.cursor_location

in Blender 2.8 API moved to “cursor” object

context.scene.cursor.location

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’

Add-on preferences panel

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.

Continue reading “Add-on preferences panel”

Matrix, vector and quaternion multiplication in Blender 2.8 Python API

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:

bpy.context.region_data.view_rotation @ Vector((0.0, 0.0, 1.0))

1	bpy.context.region_data.view_rotation @ Vector((0.0, 0.0, 1.0))

Snapping elements property in Blender 2.8 Python API

The snapping elements property from Blender 2.7

bpy.context.scene.tool_settings.snap_element

1	bpy.context.scene.tool_settings.snap_element

changed in Blender 2.8 API to

bpy.context.scene.tool_settings.snap_elements
# {'EDGE'}

1 2	bpy.context.scene.tool_settings.snap_elements # {'EDGE'}

Accessing the pivot point type in Blender 2.8 Python API

The “pivot_point” property from Blender 2.7

bpy.context.area.spaces[0].pivot_point
# 'BOUNDING_BOX_CENTER':

1 2	bpy.context.area.spaces[0].pivot_point # 'BOUNDING_BOX_CENTER':

in Blender 2.8 API moved to:

bpy.context.scene.tool_settings.transform_pivot_point
# 'MEDIAN_POINT'

1 2	bpy.context.scene.tool_settings.transform_pivot_point # 'MEDIAN_POINT'

use_drag_immediately property in Blender 2.8 Python API

The “use_drag_immediately” property from Blender 2.7

bpy.context.preferences.edit.use_drag_immediately

1	bpy.context.preferences.edit.use_drag_immediately

in Blender 2.8 API moved to

bpy.context.preferences.inputs.use_drag_immediately
# True

1 2	bpy.context.preferences.inputs.use_drag_immediately # True

Changing the current coordinate system in Blender Python API

In Blender 2.7 the current coordinate system could be changed through the

bpy.context.space_data.transform_orientation

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.

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'

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'

How to set object (mesh) to active in Blender 2.8 Python API

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:

obj = bpy.context.window.scene.objects[0]
bpy.context.view_layer.objects.active = obj    # 'obj' is the active object now

1 2	obj = bpy.context.window.scene.objects[0] bpy.context.view_layer.objects.active = obj # 'obj' is the active object now

Selecting objects (meshes) in Blender 2.8 Python API

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:

bpy.context.active_object.select_get()
# True

1 2	bpy.context.active_object.select_get() # True

To select an object in Blender 2.8 use a setter:

bpy.context.active_object.select_set(state=True)

1	bpy.context.active_object.select_set(state=True)

To unselect an object use the same setter:

bpy.context.active_object.select_set(state=False)

1	bpy.context.active_object.select_set(state=False)

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

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

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”

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

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.

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

How to check if Blender object property/attribute is read-only

To check is an attribute/property of any Blender object (mesh, node, modifier, etc.) read-only:

With the is_property_readonly function, execute the following command:

<object> .is_property_readonly (‘<property name>’)

Through the rna structure, execute the following command:

<object> .bl_rna.properties [‘<property name>’]. is_readonly

For example, for the “is_editmode” mesh property (is the mesh in edit mode or not):

bpy.context.active_object.data.is_property_readonly('is_editmode')

# True


bpy.context.active_object.data.bl_rna.properties['is_editmode'].is_readonly

# True

bpy.context.active_object.data.is_property_readonly('is_editmode')

# True

bpy.context.active_object.data.bl_rna.properties['is_editmode'].is_readonly

# True

How to get the version of the add-on installed in Blender

A complete list of add-ons installed in Blender we can get using the addon_utils:

import addon_utils
print(addon_utils.modules()[:])

# <module 'space_view3d_3d_navigation' from ...

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:

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)

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	# (-1,-1,-1)

How to programmatically switch between vertex, edge and face selection mode

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:

bpy.context.tool_settings.mesh_select_mode = (True, False, False)

1	bpy.context.tool_settings.mesh_select_mode = (True, False, False)

Edge selection mode:

bpy.context.tool_settings.mesh_select_mode = (False, True, False)

1	bpy.context.tool_settings.mesh_select_mode = (False, True, False)

And face selection mode:

bpy.context.tool_settings.mesh_select_mode = (False, False, True)

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:

bpy.context.tool_settings.mesh_select_mode = (True, False, True)

1	bpy.context.tool_settings.mesh_select_mode = (True, False, True)

In BMesh for vertex, edge and face selection mode:

bm.select_mode = {'VERT'}
bm.select_mode = {'EDGE'}
bm.select_mode = {'FACE'}

bm.select_mode = {'VERT'}

bm.select_mode = {'EDGE'}

bm.select_mode = {'FACE'}

For multi-select in BMesh:

bm.select_mode = {'VERT', 'EDGE', 'FACE'}

1	bm.select_mode = {'VERT', 'EDGE', 'FACE'}

Learning loops

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.

Continue reading “Learning loops”

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

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”

Creating radio buttons in the Blender add-ons interface

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”

How to programmatically check if the operator is registered in Blender API

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:

hasattr(bpy.types, bpy.ops._operator_bl_idname_.idname())

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:

class TestOperator(bpy.types.Operator):
    bl_idname = 'test.operator'
    bl_label = 'Test operator'

    def execute(self, context):
        pass

class TestOperator(bpy.types.Operator):

bl_idname = 'test.operator'

bl_label = 'Test operator'

def execute(self, context):

pass

the command will look like this:

hasattr(bpy.types, bpy.ops.test.operator.idname())

1	hasattr(bpy.types, bpy.ops.test.operator.idname())

How to programmatically check if the Blender add-on is registered

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:

'add-on_name' in the file bpy.context.user_preferences.addons

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.

Debugging multifile Blender add-on by quick reinstall

It is convenient to use the following system for debugging developing multi-file Blender add-ons. But it has one drawback: modules imported in __init__.py file becomes available only after the file running (after the execution of the register() function). This means that any access to the imported modules before they are registered will cause an error. This is not critical in most cases, but it will cause a problem if, for example, in one imported module is used inheritance from the class, described in the other imported module, because the classes descriptions are processed before the add-on registration.

To get more freedom working with imported modules, we can use another way to debug the add-on – do not run the add-on directly from the development directory, but install it in Blender and check its “live” work. However, manual add-on reinstallation requires a set of routine actions, which complicates such sort of debugging. This issue can be solved by reinstalling the add-on in automatic mode.

Continue reading “Debugging multifile Blender add-on by quick reinstall”

How to install and uninstall Blender add-on via python API

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:

bpy.ops.wm.addon_disable(module = 'add-on name')

1	bpy.ops.wm.addon_disable(module = 'add-on name')

To uninstall the add-on:

bpy.ops.wm.addon_remove(module = 'add-on name')

1	bpy.ops.wm.addon_remove(module = 'add-on name')

Continue reading “How to install and uninstall Blender add-on via python API”

Mesh Custom Properties editing through the Blender API

New mesh Custom Property can be created through the Blender python API by executing the following code:

bpy.data.objects['object_name']['property_name'] = property_value

1	bpy.data.objects['object_name']['property_name'] = property_value

with:

object_name – name of the mesh
property_name – new custom property name
property_value – value of this new property

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”

Working with UV-Maps through the Blender API

Active (selected) UV-Map:

bpy.context.active_object.data.uv_layers.active

1	bpy.context.active_object.data.uv_layers.active

Access to the active UV-Map by its name:

bpy.context.active_object.data.uv_layers['UVMap']

1	bpy.context.active_object.data.uv_layers['UVMap']

Continue reading “Working with UV-Maps through the Blender API”