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”

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.

Continue reading “Assigning custom properties to vertexes”

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:

Continue reading “How to save mesh data to text”

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.

Continue reading “Custom property”

Calling functions by pressing buttons in Blender custom UI

Button click in basically connected with the operator calling in 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”

Solving the problem of the discrepancy between the size of the track section and the profile applied to it

By Andrew M.

“Many letters about the simple”

I need a frame. No, two frames: one larger, the other smaller, but made from one profile. I drew a rectangle, set the desired dimensions, duplicated, set other sizes. I drew a separate profile. For a section to both rectangles I applied this profile. … why did I get different frames? And none matches the size of the profile? Ah, I forgot to apply the scale. Applied. The dimensions of the cross-section changed, became different, but again not equal to the profile. How to make them equal – read below!

Solving the problem of the discrepancy between the size of the track section and the profile applied to it

This problem occurs when the path for profiling is constructed in any way but then scaled to the desired size. In this case, it does not matter if its scale is 1 or not. If we apply the profile we need to it, then it will be different in size from the set … Why? We will see now.

Continue reading “Solving the problem of the discrepancy between the size of the track section and the profile applied to it”

Creating points on a Bezier curve

Bezier curves are drawing by four points: two main points (p0, p1) and two handle points (p0_hr, ​​p1_hl).

To add an additional point p2 to a curve at a moment t, with t changes from 0 to 1 and represents the ratio of the p2 point location to the total length of the curve, we need to do the following:

Continue reading “Creating points on a Bezier curve”

Fluid simulation in Blender 2.80

By Pavel_Blend

What is this article about?

In this article, I will talk about the fluid simulator in Blender 2.80. This simulator was first added to the blender at the end of 2005, in version 2.40. Since then, it has not changed significantly (the changes were mainly in the beginning, after the introduction of the blender). The simulator code was written by a third-party developer Nils Thuerey. He wrote a fluid simulation library and named it El’Beem. The engine is voxel-based on the method of lattice Boltzmann equations. It is best suited for creating water, but it has the ability to create viscous liquids (honey, chocolate …) that are not very well implemented. Soon, a new Mantaflow simulator will be introduced into the blender (by the way, Nils Thuerey is taking part in its development).

Continue reading “Fluid simulation in Blender 2.80”

EEVEE Shadow Catcher

There is a convenient opportunity in the Cycles render engine to render an object with shadows on a transparent background using material with the “shadow catcher” option. There is no such material in EEVEE render engine, however, in EEVEE we can make our own “shadow catcher” based only on nodes.

Completed “EEVEE Shadow Catcher” material you can get from the BIS library.

Continue reading “EEVEE Shadow Catcher”

How to make a pattern from the single element of the BIS library

A single procedural element from the BIS library can be easily transformed into a repeating pattern.

Let’s get a single circular elemetn from the library and place it in the center of the plane.

Continue reading “How to make a pattern from the single element of the BIS library”

Texture pixelization

The simplest way to pixelate texture, procedural or not – get the color from the single pixel and fill the region with required width and height (resolution) with this color.

Here is the gradient texture with red – green – blue colors:

To pixelate it with the first step of resolution we can make some vectors manipulations.

Continue reading “Texture pixelization”

How to protect your add-on from downloading through aggregators

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”

Changing objects visibility in the viewport and while rendering

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”

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”

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”

Tiling procedural textures in Blender

Creating separate elements of procedural textures in Blender is quite simply – find the desired formula, rebuilt it using mathematical nodes, and as a result, get the desired shape. However, textures created this way have one feature – no tiling. Tiling – a cyclic texture duplication, most time is considered harmful, and professional 3D artists try to avoid texture tiling. But sometimes tiling is necessary, for example, when creating patterns or ornaments.

The procedural texture element is always created in a single instance. This is because all the mathematics that forms the actual procedural image is based on the initial data – coordinates that start from 0, spread out to infinity and not repeat. However, the same mathematics helps us to solve this problem.

Continue reading “Tiling procedural textures in Blender”