In Blender 2.81 with the “Vector Math” node we can simple regulate the subsurface radius:
Simon Thommes published his stream about making a circuit board with shader nodes in the nodevember challenge.
Hans Chiu shared a stream about making a procedural animated zipper material.
The official Blender documentation provides a method to get the “Specular” value for the PBR-material reflections if the “IOR” value is known. To get the “Specular” value from the “IOR” value, we can use the following equation:
It is not difficult to create it with nodes:
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.
In Blender Cycles using common lamps we can illuminate objects with any texture, not just a single color.
Add an object, for example – sphere, to the scene:
shift+a – Mesh – UVSphere
and set a simple diffuse shader to it.
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.
Except for the “Gradient Texture” node, we can obtain a gradient factor by using some simple equations. Look for the mathematics with a spherical gradient sample.
- Uniform gradient
Can be created based on a downward-facing cone equation.
In Blender 2.8, the displacement node in Cycles render-engine was changed from scalar to vector. If you simply connect a black and white height map to the Displace input of the material output node, like in Blender 2.7, it will not give the desired result.
To make the correct node displacement in Blender 2.8 add “CombineXYZ” and “VectorDisplacement” nodes to the material node tree. Connect the height map to the “Y” input of the “CombineXYZ” node and its “Vector” output to the “Vector” input of the “VectorDisplacement” node. After that, connect the “Displacement” output of the “VectorDisplacement” node to the “Displacement” input of the material output node.
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.
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
for node in self.tree.nodes:
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)
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.
To make an integer input/output in the node group:
- Install the BIS add-on 1.5.2. version or later,
- Select the desired node group in the Node Editor,
- In T-panel in the “BIS” tab, “Tools” section: click “+ Input” to create an input or “+ Output” to create an output in the selected node group.
Example of tiling the procedural texture with random z-axis rotation with procedural nodes.
All used nodes are available in the Blender material library BIS.
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.
All procedural textures in Blender are based on math. Even such irregular structures as “Voronoi” and “Noise” are actually generated according to the mathematical formulas. An exact mathematical algorithm is sewed up into each base material node to obtain the desired image as a result.
We can not specify such algorithms in Blender in the usual mathematical format. However, among other nodes, Blender provides us the “Math” nodes – the wrap over simple mathematical operations. Using these nodes we can build complex mathematical algorithms yourself, generating interesting textures.
The single object visualization most often is performed on a clear white background. It is difficult to achieve this through the common configuring the scene – increasing the illumination of the scene “lights up” the object, decreasing – the background becomes gray instead of white. If the object itself can be simply rendered on a transparent background and then imposed on white, but what about its reflections?
Let’s consider the way how we can render the object and its reflection on a white background.
In order to achieve the desired texture mapping on the object surface, we need a convenient tool for manipulating the texture coordinates. Especially for procedural textures mapped to the object without using UV-s.
The “Mapping” node combines tools for texture moving, rotating and scaling is suitable for most of the texturing tasks. But sometimes its power is not enough. Its major drawback is that it allows setting adjustment values only in certain fields within the node body. These fields have no inputs and cannot be connected to the other nodes.
However, we can implement the required functionality devoid of the “Mapping” node lack with the help of some other nodes. Let’s consider how to build a node tree to rotate the texture around the Z-axis of the object by a random value.
Creating a node tree in the compositing window, sometimes it is necessary to see the intermediate result given by some parts of the node tree. For fast viewing click left mouse button on the desired node with the “ctrl” and “shift” keys pressed. Blender adds a new View node (or uses one of the existing) and connects the output of the selected node to it. The result is displayed on the backdrop (if the corresponding checkbox checked) or in the UV/Image Editor window in “Viewer Node” mode.
If the clicked node has several outputs, each subsequent click on that node switches the view to its next output.