blender/blender-manual
24
24
Fork 104
Code Issues 80 Pull Requests 8 Projects 1 Releases Wiki Activity

Improvements for "Texture Nodes" section #104466

Merged
Aaron Carlisle merged 1 commits from Matthew-Hinson/blender-manual:texture-node-editor into main 2023-12-08 05:57:49 +01:00
Conversation 2 Commits 1 Files Changed 20 +277 -306
20 changed files with 277 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
manual/compositing/types/color/adjust/hue_saturation.rst
View File

@ -1,7 +1,8 @@
.. index:: Compositor Nodes; Hue/Saturation/Value
.. _bpy.types.CompositorNodeHueSat:
.. Editor's Note: This page gets copied into:
.. - :doc:`</render/cycles/nodes/types/color/hue_saturation>`
.. - :doc:`</render/shader_nodes/color/hue_saturation>`
.. - :doc:`</editors/texture_node/types/color/hue_saturation>`
.. --- copy below this line ---
@ -20,32 +21,23 @@ Inputs
======
Factor
Controls the amount of influence the node exerts on the output image.
Image
The amount of influence the node exerts on the image.
Image/Color
Standard color input.
Properties
==========
The transformations are relative shifts.
In the shader and texture context the following properties are available as input sockets.
Hue
Specifies the hue rotation of the image. 360° are mapped to (0 to 1).
The hue shifts of 0 (-180°) and 1 (+180°) have the same result.
The hue rotation offset, from 0 (-180°) to 1 (+180°). Note that
0 and 1 have the same result.
Saturation
A saturation of 0 removes hues from the image, resulting in a grayscale image.
A shift greater than 1.0 increases saturation.
A value of 0 removes color from the image, making it black-and-white.
A value greater than 1.0 increases saturation.
Value
Value is the overall brightness of the image.
De/Increasing values shift an image darker/lighter.
The value shift. 0 makes the color black, 1 keeps it the same, and higher
values make it brighter.
Outputs
=======
Image
Image/Color
Standard color output.
@ -54,25 +46,14 @@ Hue/Saturation Tips
Some things to keep in mind that might help you use this node better:
Hues are vice versa
A blue image, with a Hue setting at either end of the spectrum (0 or 1),
is output as yellow (recall that white, minus blue, equals yellow).
A yellow image, with a Hue setting at 0 or 1, is blue.
Hue and Saturation work together.
So, a Hue of 0.5 keeps the blues the same shade of blue,
but *Saturation* can deepen or lighten the intensity of that color.
Gray & White are neutral hues
A gray image, where the RGB values are equal, has no hue. Therefore,
this node can only affect it with *Value*. This applies to all shades of gray,
from black to white; wherever the values are equal.
Hues are laid out on a circle
If you apply a Hue offset of 1 (+180°) to a blue image, you get the diametrically opposite
color, which is yellow. If you apply a Hue offset of 1 to that yellow image, you get blue again.
Grayscale images have no hue
Trying to change the Hue or Saturation of a grayscale image has no effect. You can only brighten
or darken it by adjusting the Value. To add color, use the Mix node instead.
Changing the effect over time
The Hue and Saturation values can be animated with a *Time Node* or by animating the property.
.. note:: Tinge
This HSV node simply shifts hues that are already there.
To colorize a gray image, or to add a tint to an image,
use a Mix node to add in a static color from an RGB input node with your image.
The different values can be animated using a *Time Curve* node or by setting keyframes.
HSV Example

40
manual/compositing/types/color/adjust/rgb_curves.rst
View File

@ -1,7 +1,10 @@
.. index:: Compositor Nodes; RGB Curves
.. _bpy.types.CompositorNodeCurveRGB:
.. Editor's Note: This page gets copied into :doc:`</render/cycles/nodes/types/color/rgb_curves>`
.. Editor's Note: This page gets copied into:
.. - :doc:`</render/shader_nodes/color/rgb_curves>`
.. - :doc:`</editors/texture_node/types/color/rgb_curves>`
.. - :doc:`</modeling/geometry_nodes/utilities/color/rgb_curves>`
.. --- copy below this line ---
@ -13,21 +16,20 @@ RGB Curves Node
:align: right
:alt: RGB Curves Node.
The *RGB Curves Node* allows color corrections for each color channel
and levels adjustments in the compositing context.
The *RGB Curves Node* performs level adjustments on each color channel.
Inputs
======
Factor
Controls the amount of influence the node exerts on the output image.
Image
Controls the amount of influence the node exerts on the image.
Image/Color
Standard color input.
Black Level :guilabel:`Compositor Only`
Defines the input color that is (linear) mapped to black.
Defines the input color that should be mapped to black.
White Level :guilabel:`Compositor Only`
Defines the input color that is (linear) mapped to white.
Defines the input color that should be mapped to white.
.. container:: lead
@ -35,29 +37,33 @@ White Level :guilabel:`Compositor Only`
.. tip::
To define the levels, use the :ref:`eyedropper <ui-eyedropper>` to select a color sample of a displayed image.
To define the black and white levels, use the :ref:`eyedropper <ui-eyedropper>` to select a color sample of a displayed image.
Properties
==========
Tone :guilabel:`Compositor Only`
:Standard: TODO 2.8
:Film Like: TODO 2.8
:Standard: The Combined curve is applied to each channel individually, which may result in a change of hue.
:Filmlike: Keeps the hue constant.
Channel
Clicking on one of the channels displays the curve for each.
The curve to show.
:C: Combined
:R: Red
:G: Green
:B: Blue
C (Combined RGB), R (Red), G (Green), B (Blue)
Curve
A Bézier curve that varies the input levels (X axis) to produce an output level (Y axis).
For the curve controls see: :ref:`Curve widget <ui-curve-widget>`.
A Bézier curve that maps each input level (X axis) to an output level (Y axis).
For the curve controls, see :ref:`Curve widget <ui-curve-widget>`.
Outputs
=======
Image
Image/Color
Standard color output.
@ -83,8 +89,8 @@ Color Correction using Curves
In this example, the image has too much red in it,
so we run it through an *RGB Curves* node and reduce the Red channel.
Also, read on for examples of the Darken and Contrast Enhancement curves,
:doc:`here </compositing/types/color/mix/mix_color>`.
The documentation for the :doc:`/compositing/types/color/mix/mix_color` has an additional
example about fixing overexposure.
Color Correction using Black/White Levels

38
manual/compositing/types/color/color_ramp.rst
View File

@ -1,9 +1,9 @@
.. index:: Compositor Nodes; Color Ramp
.. _bpy.types.CompositorNodeValToRGB:
.. Editors Note: This page gets copied into:
.. - :doc:`/render/cycles/nodes/types/converter/color_ramp`
.. - :doc:`/modeling/modifiers/nodes/color/color_ramp`
.. - :doc`/compositing/types/converter/color_ramp`
.. - :doc:`/render/shader_nodes/converter/color_ramp`
.. - :doc:`/modeling/geometry_nodes/utilities/color/color_ramp`
.. - :doc:`/editors/texture_node/types/converter`
.. --- copy below this line ---
***************
@ -21,20 +21,20 @@ Inputs
======
Factor
The Factor input is used as an index for the color ramp.
The value to map. 0.0 results in the leftmost color, while 1.0 results in the rightmost.
Properties
==========
Color Ramp
For controls see :ref:`ui-color-ramp-widget`.
See :ref:`ui-color-ramp-widget`.
Outputs
=======
Image
Image/Color
Standard color output.
Alpha
Standard alpha output.
@ -46,40 +46,32 @@ Examples
Creating an Alpha Mask
----------------------
An often overlooked use case of the Color Ramp is to create an alpha mask,
or a mask that is overlaid on top of another image.
Such a mask allows you to select parts of the background to be shown through.
An often overlooked use case of the Color Ramp is to turn a black-and-white image
into a colored image with transparency.
.. figure:: /images/compositing_types_converter_color-ramp_create-alpha-mask.png
:width: 600px
Using the Color Ramp node to create an alpha mask.
In the map above, a black-and-white swirl image, which is lacking an alpha channel,
In the example above, a black-and-white swirl image, which is lacking an alpha channel,
is fed into the Color Ramp node as a *Factor*.
The Color Ramp node is set to a purely transparent color on the left end of the gradient,
and a fully red color on the right. As you can see in the Viewer node,
the Color Ramp node puts out a mask that is fully transparent where the image is black.
Black is zero, so Color Ramp outputs the color at the left end of the gradient,
which is set to transparent.
The Color Ramp image is fully red and opaque where the image is white (which is 1).
You can verify that the output image mask is indeed transparent
by overlaying it on top of another image.
the Color Ramp node outputs an image that is transparent where the input is black,
and opaque where the input is white.
Colorizing an Image
-------------------
In this example multiple colors are added to the color gradient
In this example, multiple colors are added to the color gradient,
converting a black-and-white image into a flaming swirl.
.. figure:: /images/compositing_types_converter_color-ramp_colorizing-image.png
:width: 600px
The shades of gray in the input image are mapped to three colors:
blue, yellow, and red, all fully opaque (alpha of 1). Where the image is black,
Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
blue, yellow, and red, all fully opaque. Where the image is black,
the Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
the Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
Where the image is fully white, the Color Ramp outputs red.

13
manual/compositing/types/color/invert_color.rst
View File

@ -1,7 +1,8 @@
.. index:: Compositor Nodes; Invert Color
.. _bpy.types.CompositorNodeInvert:
.. Editor's Note: This page gets copied into:
.. - :doc:`</render/cycles/nodes/types/color/invert>`
.. - :doc:`</render/shader_nodes/color/invert_color>`
.. - :doc:`</editors/texture_node/types/color/invert_color>`
.. --- copy below this line ---
Aaron Carlisle commented 2023-06-04 04:40:54 +02:00
Outdated
Review
Copy Link

This node was renamed to "Invert Color" in Blender 3.6

This node was renamed to "Invert Color" in Blender 3.6
@ -13,14 +14,14 @@ Invert Color Node
:align: right
:alt: Invert Color Node.
The *Invert Color Node* inverts the colors in the input image, producing a negative.
Inverts the colors in the input image, producing a negative.
Inputs
======
Factor
Controls the amount of influence the node exerts on the output image.
The amount of influence the node exerts on the image.
Color
Standard color input.
@ -28,12 +29,12 @@ Color
Properties
==========
In the compositing context this node has the following properties.
In the compositing context, this node has the following properties:
RGB
De/activation of the color channel inversion.
Invert the color channels.
Alpha
De/activation of the alpha channel inversion.
Invert the alpha channel.
Outputs

204
manual/compositing/types/color/mix/mix_color.rst
View File

@ -3,8 +3,7 @@
.. Editor's Note: This page gets copied into:
.. - :doc:`</render/shader_nodes/color/mix>`
.. - :doc:`</modeling/geometry_nodes/utilities/color/mix_rgb>`
.. - :doc:`</render/shader_nodes/converter/mix>`
.. - :doc:`</modeling/geometry_nodes/utilities/mix>`
.. - :doc:`</editors/texture_node/types/color/mix_rgb>`
.. --- copy below this line ---
@ -16,117 +15,123 @@ Mix Node
:align: right
:alt: Mix Node.
The *Mix Node* mixes images by working on the individual and corresponding pixels
of the two input images. Called "Mix Color" in the shader, geometry, and texture context.
Blends two images together, much like how an image editing program blends two layers.
.. important::
As of Blender 3.4 this node has been updated in Shader and Geometry node editors.
Files saved with the new node are not forward compatible.
As of Blender 3.4, this node has been updated in the Shader and Geometry node editors.
Files saved with the new node are not backward compatible.
Inputs
======
Factor
Controls the amount of influence the node exerts on the output image.
Image
The background image. The image size and resolution sets the dimensions of the output image.
Image
The opacity of the foreground image.
Image/A/Color1
The background image. Determines the dimensions of the output.
Image/B/Color2
The foreground image.
Keep in mind that, unlike image editing programs where the foreground layer is on top,
the foreground slot in Blender is on the bottom.
Properties
==========
Mix
The Blend modes can be selected in the select menu.
See :term:`Color Blend Modes` for details on each blending mode.
Add, Subtract, Multiply, Screen, Divide, Difference, Exclusion,
Darken, Lighten, Overlay, Color Dodge, Color Burn,
Hue, Saturation, Value, Color, Soft Light, Linear Light
Data Type :guilabel:`Shader Editor` :guilabel:`Geometry Node Editor`
The type of data to mix: Float, Vector, or Color.
Factor Mode :guilabel:`Shader Editor` :guilabel:`Geometry Node Editor`
Uniform
The same single Factor is applied to all three Vector coordinates.
Non-Uniform
You can specify a different Factor for each Vector coordinate.
Blending Mode
The :term:`blending mode <Color Blend Modes>` to use.
Mix
Regular alpha blending. Typically called *Normal* in image editing programs.
`Darken <https://docs.krita.org/en/reference_manual/blending_modes/darken.html#bm-darken>`__
For each color component, takes the smallest of the two values being blended.
`Multiply <https://docs.krita.org/en/reference_manual/blending_modes/arithmetic.html#bm-multiply>`__
Multiplies the colors component by component. Blending with a white pixel
(value 1.0) has no effect, while blending with a black one (0.0) always
results in black.
`Color Burn <https://docs.krita.org/en/reference_manual/blending_modes/darken.html#bm-color-burn>`__
Inverts the background color, divides it by the foreground color, and inverts the result.
`Lighten <https://docs.krita.org/en/reference_manual/blending_modes/lighten.html#bm-lighten>`__
For each color component, takes the largest of the two values being blended.
`Screen <https://docs.krita.org/en/reference_manual/blending_modes/lighten.html#bm-screen>`__
Inverts both colors, multiplies them, and inverts the result.
`Color Dodge <https://docs.krita.org/en/reference_manual/blending_modes/lighten.html#bm-color-dodge>`__
Divides the background color by the inverted foreground color.
`Add <https://docs.krita.org/en/reference_manual/blending_modes/arithmetic.html#addition>`__
Adds the two colors together.
`Overlay <https://docs.krita.org/en/reference_manual/blending_modes/mix.html#overlay>`__
Applies Multiply blending if the foreground color's lightness is below 0.5,
or Screen blending if it's above.
`Soft Light <https://docs.krita.org/en/reference_manual/blending_modes/lighten.html#bm-soft-light>`__
Like Overlay, but more subtle.
`Linear Light <https://docs.krita.org/en/reference_manual/blending_modes/lighten.html#bm-linear-light>`__
Applies Linear Burn blending (background + foregound - 1) if the foreground color's lightness
is below 0.5, or Linear Dodge (background + foreground) if it's above.
`Difference <https://docs.krita.org/en/reference_manual/blending_modes/negative.html#bm-difference>`__
For each component, subtracts the lower value from the higher value.
`Exclusion <https://docs.krita.org/en/reference_manual/blending_modes/negative.html#bm-exclusion>`__
Adds the two colors, then subtracts their multiple twice.
`Subtract <https://docs.krita.org/en/reference_manual/blending_modes/arithmetic.html#subtract>`__
Subtracts the foreground color from the background color.
`Divide <https://docs.krita.org/en/reference_manual/blending_modes/arithmetic.html#divide>`__
Divides the background color by the foreground color.
`Hue <https://docs.krita.org/en/reference_manual/blending_modes/hsx.html#bm-hue>`__
Combines the saturation and value of the background color with the hue of the foreground color.
`Saturation <https://docs.krita.org/en/reference_manual/blending_modes/hsx.html#bm-saturation>`__
Combines the hue and value of the background color with the saturation of the foreground color.
`Color <https://docs.krita.org/en/reference_manual/blending_modes/hsx.html#bm-color>`__
Combines the value of the background color with the hue and saturation of the foreground color.
`Value <https://docs.krita.org/en/reference_manual/blending_modes/hsx.html#bm-luminosity>`__
Combines the hue and saturation of the background color with the value of the foreground color.
Use Alpha
If activated, by clicking on the *Color and Alpha* icon,
the Alpha channel of the second image is used for mixing.
When deactivated, the default, the icon background is a light gray.
The alpha channel of the base image is always used.
Clamp
Limit the output value between 0.0 and 1.0.
Whether to use the alpha channel of the foreground image during mixing.
The alpha channel of the background image is always used.
Clamp/Clamp Result
Clamp the output value to the [0.0, 1.0] range.
Clamp Factor :guilabel:`Shader Editor` :guilabel:`Geometry Node Editor`
Clamp the Factor to the [0.0, 1.0] range.
Outputs
=======
Image
Standard color output.
Image/Result/Color
The result of the mixing operation.
Examples
========
Below are samples of common mix modes and uses, mixing a color or checker with a mask.
Below are examples of blending modes, as well as some practical use cases.
.. figure:: /images/compositing_types_color_mix_blend-modes.png
:width: 700px
Some explanation of the mixing methods above might help you use the Mix node effectively:
Blending a colored pattern with a flat color (top row) and a circular mask (bottom row).
Add
Adding blue to blue keeps it blue, but adding blue to red makes purple.
White already has a full amount of blue, so it stays white.
Use this to shift a color of an image. Adding a blue tinge makes the image feel colder.
Subtract
Taking Blue away from white leaves Red and Green, which combined make Yellow.
Taking Blue away from Purple leaves Red. Use this to desaturate an image.
Taking away yellow makes an image bluer and more depressing.
Multiply
Black (0.0) times anything leaves black. Anything times White (1.0) is itself.
Use this to mask out garbage, or to colorize a black-and-white image.
Hue
Shows you how much of a color is in an image,
ignoring all colors except what is selected: makes a monochrome picture (style 'Black & Hue').
Mix
Combines the two images, averaging the two.
Lighten
Like bleach makes your whites whiter. Used with a mask to lighten up a little.
Difference
It takes out a color. The color needed to turn Yellow into White is Blue.
Use this to compare two very similar images to see what had been done to one to make it the other;
sort of like a change log for images. You can use this to see a watermark (see `Watermark images`_)
you have placed in an image for theft detection.
Darken
With the colors set here, it's like looking at the world through rose-colored glasses.
Fixing overexposure
-------------------
.. note::
Only add, subtract, multiply and divide are suitable for :term:`Scene Referenced` images.
Contrast Enhancement
--------------------
Here is a small node tree showing the effects of two other common uses for the RGB Curve:
*Darken* and *Contrast Enhancement*.
You can see the effect each curve has independently,
and the combined effect when they are *mixed* equally.
The Compositing setup below shows how to fix an overexposed render by
darkening it and increasing contrast.
.. figure:: /images/compositing_types_color_mix_contrast-enhancement.png
:width: 700px
Example node setup showing "Darken", "Enhance Contrast" and "Mix" nodes for composition.
Example node setup showing two RGB Curves nodes and a Mix node for composition.
As you can hopefully see, our original magic monkey was overexposed by too much light.
To cure an overexposure, you must both darken the image and enhance the contrast.
The top :doc:`/compositing/types/color/adjust/rgb_curves` darkens the image by linearly scaling each
color value to a smaller one.
In the top RGB curve, *Darken*, only the right side of the curve was lowered; thus,
any X input along the bottom results in a geometrically less Y output.
The *Enhance Contrast* RGB (S-shaped) curve scales the output such that middle values of X change dramatically;
namely, the middle brightness scale is expanded,
and thus, whiter whites and blacker blacks are output. To make this curve,
simply click on the curve and a new control point is added.
Drag the point around to bend the curve as you wish.
The Mix node combines these two effects equally, and Suzanne feels much better.
The bottom curve node increases constract by making small values smaller and large values larger.
Finally, the Mix node blends the two together.
Watermark Images
@ -135,11 +140,14 @@ Watermark Images
In the old days, a pattern was pressed into the paper mush as it dried,
creating a mark that identified who made the paper and where it came from.
The mark was barely perceptible except in just the right light.
Probably the first form of subliminal advertising. Nowadays,
people watermark their images to identify them as personal intellectual property,
Probably the first form of subliminal advertising.
Nowadays, people watermark their images to identify them as personal intellectual property,
for subliminal advertising of the author or hosting service,
or simply to track their image's proliferation throughout the web. Blender provides a complete
set of tools for you to both encode your watermark and to tell if an image has your watermark.
or simply to track their image's proliferation throughout the web.
Blender provides a complete set of tools for you to both encode your watermark
and to tell if an image has your watermark.
Encoding your Watermark in an Image
@ -149,48 +157,38 @@ First, construct your own personal watermark.
You can use your name, a word, or a shape or image not easily replicated.
While neutral gray works best using the encoding method suggested,
you are free to use other colors or patterns.
It can be a single pixel or a whole gradient; it is up to you. In the example below,
we are encoding the watermark in a specific location in the image using the *Translate* node;
It can be a single pixel or a whole gradient; it is up to you.
In the example below, we are encoding the watermark in a specific location
in the image using the *Translate* node;
this helps later because we only have to look at a specific location for the mark.
We then use the RGB to BW node to convert the image to numbers
that the Map Value node can use to make the image subliminal.
In this case, it reduces the mark to one-tenth of its original intensity.
The Add node adds the corresponding pixels,
We then use the *RGB to BW node* to convert the color image to grayscale numbers,
which we then feed into the *Map Range* node to reduce the mark to one-tenth of
its original intensity.
The *Add* node (*Mix* node with blending mode *Add*) adds the corresponding pixels,
making the ones containing the mark ever-so-slightly brighter.
.. figure:: /images/compositing_types_color_mix_watermark-encode.png
:width: 700px
Embedding your mark in an image using a mark and specific position.
Embedding a watermark in an image.
Of course, if you *want* people to notice your mark, do not scale it so much,
or make it a contrasting color. There are also many other ways,
using other mix settings and fancier rigs. Feel free to experiment!
.. hint:: Additional uses
You can also use this technique, using settings that result in visible effects,
in title sequences to make the words appear to be cast on the water's surface,
or as a special effect to make words appear on the possessed girl's forearm.
Decoding an Image for your Watermark
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
When you see an image that you think might be yours,
use the node tree below to compare it to your stock image (pre-watermarked original).
In this tree, the Mix node is set to Difference,
and the Map Value node amplifies any difference. The result is routed to a viewer,
and you can see how the original mark clearly stands out.
In this tree, the *Mix* node is set to Difference,
and the *Map Value* node amplifies any difference.
You can see how the original mark clearly stands out.
.. figure:: /images/compositing_types_color_mix_watermark-decode.png
:width: 700px
Checking an image for your watermark.
Various image compression algorithms lose some of the original; the difference shows as noise.
Experiment with different compression settings and marks to see which works best for you by
having the encoding node group in one scene, and the decoding group in another.
Use them while changing Blender's image format settings,
reloading the watermarked image after saving, to get an acceptable result.
In the example above, the mark was clearly visible all the way up to ``JPEG`` compression of 50%.

12
manual/compositing/types/color/rgb_to_bw.rst
View File

@ -1,6 +1,8 @@
.. index:: Compositor Nodes; RGB TO BW
.. _bpy.types.CompositorNodeRGBToBW:
.. Editor's Note: This page gets copied into :doc:`</render/cycles/nodes/types/converter/rgb_to_bw>`
.. Editor's Note: This page gets copied into:
.. - :doc:`</render/shader_nodes/converter/rgb_to_bw>`
.. - :doc:`</editors/texture_node/types/converter/rgb_to_bw>`
.. --- copy below this line ---
@ -12,8 +14,12 @@ RGB to BW Node
:align: right
:alt: RGB to BW Node.
The *RGB to BW Node* maps an RGB color image to a gray-scale by the luminance.
The *RGB to BW Node* makes a color image black-and-white by outputting its luminance.
.. note::
You can directly connect Color sockets to Value sockets in node graphs,
which also converts the image to black-and-white. As such, this node is
not always necessary.
Inputs
======
@ -32,6 +38,6 @@ Outputs
=======
Value
Gray-scale value output.
Grayscale value output.
.. (TODO add) examples of why this might be useful

20
manual/compositing/types/groups.rst
View File

@ -9,28 +9,30 @@
Group
*****
:doc:`Group Nodes </interface/controls/nodes/groups>` are a collection of nodes
that can be combined into a single node while selectively exposing inputs of the embedded nodes.
Group nodes can simplify a node tree by allowing instancing and hiding parts of the tree.
A :doc:`Group Node </interface/controls/nodes/groups>` combines a set of nodes into a single one,
and selectively exposes inputs and outputs of those nodes.
Group nodes can simplify a node tree by hiding away complexity and reusing functionality.
Group Input
===========
Adds a group input node, this serves as a convenient way to re-add the input node in case it is accidentally deleted.
Note, groups can only have one input, if more than one is added they are duplicates of each other.
Exposes the inputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
bringing in each input right where you need it (rather than dragging long links all across your graph).
The input slots can be edited in the *Group* tab of the *Sidebar*.
Group Output
============
Adds a group output node, this serves as a convenient way to re-add the output node
in case it is accidentally deleted. Note, groups can only have one output,
if more than one is added they are duplicates of each other.
Receives the outputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
outputting each result right where it's produced (rather than dragging long links all across your graph).
The output slots can be edited in the *Group* tab of the *Sidebar*.
Node Groups
===========
This section lists all the node groups either from the current blend-file or
This section lists all the node groups, both those in the current blend-file and those
:doc:`Linked or Appended </files/linked_libraries/link_append>` from another blend-file.

9
manual/compositing/types/input/scene/time_curve.rst
View File

@ -26,7 +26,7 @@ Properties
Curve
The Y value defined by the curve is the factor output.
For the curve controls see: :ref:`Curve widget <ui-curve-widget>`.
For the curve controls, see :ref:`Curve widget <ui-curve-widget>`.
.. tip::
@ -43,14 +43,13 @@ Outputs
=======
Factor
A speed of time factor (from 0.0 to 1.0) relative to the scene's :ref:`Frame Rate <bpy.types.RenderSettings.fps>`.
The factor changes according to the defined curve.
The Y value of the curve at the current frame.
.. hint:: Output values
.. hint::
The :doc:`Map Value </compositing/types/utilities/map_value>`
node can be used to map the output to a more appropriate value.
With sometimes curves, it is possible that the Time Curve node
With some curves, it is possible that the Time Curve node
may output a number larger than one or less than zero.
To be safe, use the Min/Max clamping function of the Map Value node to limit output.

38
manual/compositing/types/utilities/math.rst
View File

@ -21,8 +21,8 @@ The *Math Node* performs math operations.
Inputs
======
The inputs of the node are dynamic. Some inputs are only available in certain operations.
For instance, the *Addend* input is only available in the *Multiply Add* operator.
The inputs of the node are dynamic. Some inputs are only available for certain operations.
For instance, the *Addend* input is only available for the *Multiply Add* operator.
Value
Input Value. Trigonometric functions read this value as radians.
@ -110,7 +110,7 @@ Operation
Outputs a value between *Min* and *Max* based on the absolute difference between
the input value and the nearest integer multiple of *Max* less than the value.
:Snap: Rounds the input value down to the nearest integer multiple of *Increment*.
:Ping-pong: The output value is moved between 0.0 and the *Scale* based on the input value.
:Ping-pong: Bounces back and forth between 0.0 and the *Scale* as the input value increases.
Trigonometric
:Sine:
@ -160,21 +160,19 @@ Manual Z-Mask
Minimum and maximum function example.
This example has one scene input by the top *Render Layers* node,
which has a cube that is about 10 units from the camera.
The bottom *Render Layers* node inputs a scene
with a plane that covers the left half of the view and is 7 units from the camera.
Both are fed through their respective *Map Value* nodes to divide the Z-buffer by 20
(multiply by 0.05, as shown in the Size field)
and clamped to be a min/max of 0.0/1.0 respectively.
The top *Render Layers* node has a cube that is about 10 units from the camera.
The bottom *Render Layers* node has a plane that covers the left half of the view
and is 7 units from the camera.
Both are fed through their respective *Map Value* nodes to multiply the depth value by
0.05 and clamp it to [0.0, 1.0], bringing it into a suitable range for displaying it as a color.
For the minimum function,
the node selects those Z values where the corresponding pixel is closer to the camera;
so it chooses the Z values for the plane and part of the cube.
The background has an infinite Z value, so it is clamped to 1.0 (shown as white).
In the maximum example, the Z values of the cube are greater than the plane,
so they are chosen for the left side, but the plane *Render Layers* Z are infinite
(mapped to 1.0) for the right side, so they are chosen.
The Minimum node selects the smallest of the two depth values at each pixel. In the left half,
it chooses the plane (because it's closer than the cube), and in the right half,
it chooses the cube (because it's closer than the background, which is infinitely far away).
The Maximum node selects the largest of the two depth values at each pixel. In the left half,
it chooses the cube (because it's farther away than the plane), and in the right half,
it chooses the background (because it's farther away than the cube).
Using Sine Function to Pulsate
@ -189,9 +187,9 @@ At frame 25, the output value is 0.25.
That value is multiplied by 2 × pi (6.28) and converted to 1.0 by the Sine function,
since :math:`sin(2 × pi/ 4) = sin(pi/ 2) = +1.0`.
Since the sine function can put out values between (-1.0 to 1.0),
Since the sine function can output values between (-1.0 to 1.0),
the *Map Value* node scales that to 0.0 to 1.0 by taking the input (-1 to 1), adding 1
(making 0 to 2), and multiplying the result by one-half (thus scaling the output between 0 to 1).
(making 0 to 2), and multiplying the result by 0.5 (thus scaling the output between 0 to 1).
The default *Color Ramp* converts those values to a gray-scale.
Thus, medium gray corresponds to a 0.0 output by the sine, black to -1.0,
and white to 1.0. As you can see, :math:`sin(pi/ 2) = 1.0`. Like having your own visual color calculator!
@ -241,5 +239,5 @@ rounds the value to the nearest whole number (produces 0, 1, 2, 3, 4, 5),
and then divides the image pixel color by five (0.0, 0.2, 0.4, 0.6, 0.8, 1.0).
In the case of a color image,
you need to split it into separate RGB channels using *Separate/Combine RGBA* nodes
you need to split it into separate RGB channels using *Separate/Combine Color* nodes
and perform this operation on each channel independently.

85
manual/editors/texture_node/introduction.rst
View File

@ -5,68 +5,61 @@
Introduction
************
The Texture Node Editor allows creating custom textures by combining colors,
procedural patterns, and images in various ways. This is a step up from the
:doc:`built-in textures </render/materials/legacy_textures/introduction>`,
where you can select a type from a list and not much more.
.. note::
The texture node system is legacy and expected to be replaced by a new system.
Due to this, the manual is not up to date with the latest version of Blender.
Textures -- both built-in ones and node-based ones -- are a legacy feature.
For their original main purpose, which was of course texturing objects,
they have been replaced by :doc:`Materials </render/materials/introduction>`
which are set up in the :doc:`/editors/shader_editor`.
Blender includes a node-based texture generation system, which enables textures
creation by combining colors, patterns and other textures in the same way as
shader writing with :doc:`material nodes </render/shader_nodes/index>`.
Today, the use of Textures is limited to:
* :doc:`Brushes </sculpt_paint/brush/texture>`.
* The :doc:`/modeling/modifiers/deform/displace`.
* Influencing size, density etc. of :doc:`particle systems </physics/particles/texture_influence>`.
* Influencing emission locations of :ref:`fire/smoke simulations <bpy.types.FluidFlowSettings.use_texture>`.
* :doc:`Compositing </compositing/types/input/texture>`.
In addition, the Displace modifier and fire/smoke simulations don't support
node-based textures, instead only working with the built-in ones.
.. figure:: /images/editors_texture-node_introduction_types-combined.png
:width: 600px
Combined textures based on nodes.
These textures can be used for brushes, compositing and inside particle systems.
Using Texture Nodes
===================
To use texture nodes with the current texture, open the Texture Node editor.
The default Blender layout has no workspace containing the Texture Node Editor.
You need to manually open it in an :doc:`area </interface/window_system/areas>` of choice.
A new texture can be created by either clicking the *New* button in the Texture Node editor,
or the *New* button in the Texture panel. Once a texture is selected,
it can be toggled to a function as a regular texture or a node texture by
clicking the *Use Nodes* option in the Texture Node editor.
The default node setup will appear: a red-and-white checkerboard node
connected to an *Output* named "Default". For texture nodes,
multiple Outputs can exist in the node setup.
Compare to other types of node contexts, which are limited to one active Output node.
See the next section for details.
For instructions on how to add, remove and manipulate the nodes in the tree,
see the :doc:`nodes </interface/controls/nodes/index>` reference.
Using Multiple Outputs
======================
Each texture defined with texture nodes can have several outputs,
which can then be used for different things. For example,
a texture that defines both a diffuse (color) map and a normal map.
This can be done by:
#. Create two texture slots in the texture list, and set them to the same texture data-block.
#. Add two *Output* nodes to the node tree,
and type new names into their *Name* text fields: e.g. "Diffuse" for one and "Normal" for the other.
#. Underneath the texture list view in the Texture panel, a selector with the names of the outputs is shown.
For each entry in the Texture list, select the desired output by changing the menu entry
(e.g. set one to *Diffuse* and the other to *Normal*).
These named outputs could be used, when the material is defined with material nodes.
In this case, Texture Channels are probably not used. Instead, insert
the texture nodes into the material node tree by using :menuselection:`Add --> Input --> Texture`.
Inside the just added texture node the output to use can then be selected (e.g. *Diffuse* or *Normal*).
Once the editor is open, you first need to set the empty *Texture Type* selector to *Brush*,
after which you can use the :doc:`/interface/controls/templates/data_block`
to start creating textures. Note that you need to enable *Use Nodes* in the header
before you can add nodes.
Header
======
Pin (pin icon)
The pin button will keep the current texture selection fixed.
When a texture is pinned, it will remain visible in the Texture Editor
even when another object or simulation is selected elsewhere.
See :doc:`Nodes </interface/controls/nodes/introduction>` for the header items common to
all node editors.
Texture Type
World
Deprecated -- the scene's :doc:`/render/lights/world` is now defined using
a Material rather than a Texture.
Brush
Show brush Textures in the data-block menu. Because the other two types are deprecated,
this effectively shows all Textures.
Line Style
Deprecated -- :doc:`Line Styles </render/freestyle/view_layer/line_style/introduction>`
for the Freestyle renderer are now defined using Materials rather than Textures.

8
manual/editors/texture_node/types/input/coordinates.rst
View File

@ -25,9 +25,5 @@ Outputs
=======
Coordinates
The Coordinates node outputs the geometry local coordinates,
relative to its bounding box as RGB colors:
- Red channel corresponds to X value.
- Green channel corresponds to Y value.
- Blue channel corresponds to Z value.
The Coordinates node outputs the local geometry coordinates,
relative to the bounding box.

5
manual/editors/texture_node/types/input/texture.rst
View File

@ -8,7 +8,7 @@ Texture Node
:align: right
:alt: Texture node.
The Texture node can be used to load another node-based or non-node-based texture.
The Texture node loads another node-based or non-node-based texture.
Inputs
@ -26,8 +26,7 @@ Properties
==========
Texture
The texture could be selected from a list of textures available in the current blend-file or link in textures.
The textures themselves could not be edited in this node, but in the Texture panel.
The texture to load -- either from the current blend-file, or from a linked one.
Outputs

2
manual/editors/texture_node/types/output/index.rst
View File

@ -3,7 +3,7 @@
Output Nodes
################
These nodes serve as outputs for node textures.
These nodes serve as outputs for node-based textures.
.. toctree::
:maxdepth: 1

10
manual/editors/texture_node/types/output/output.rst
View File

@ -8,10 +8,7 @@ Output Node
:align: right
:alt: Output node.
This node contains the result of the node texture.
Multiple output nodes can exist in a node texture, however, only one of them is active.
The active one is set in the Texture Panel in the *Output* selector.
This node receives the result of the node-based texture.
Inputs
@ -24,8 +21,9 @@ Color
Properties
==========
File Path
Output ID.
Output Name
The name of the output. (Originally, it was possible for textures to
have multiple outputs with different names.)
Outputs

2
manual/editors/texture_node/types/patterns/bricks.rst
View File

@ -8,7 +8,7 @@ Bricks Node
:align: right
:alt: Bricks node.
The Bricks node creates a brick like pattern.
The Bricks node creates a brick-like pattern.
Inputs

2
manual/editors/texture_node/types/patterns/checker.rst
View File

@ -15,7 +15,7 @@ Inputs
======
Color 1, Color 2
Image inputs setting the color of the squares.
The colors of the squares.
Size
The scale of the checker pattern.

7
manual/interface/controls/nodes/arranging.rst
View File

@ -11,10 +11,11 @@ Snapping
The snapping options can be found on the rightmost side
of the node editor's header.
Snap
Toggle snapping on or off.
Snap :kbd:`Shift-Tab`
Toggle snapping on or off. You can also do this temporarily by holding :kbd:`Ctrl` after starting to drag
one or more nodes around.
Snap Node Element
Snap Node Element :kbd:`Shift-Ctrl-Tab`
What to snap the selected nodes to:
:Grid: Snap to the grid in the background.

3
manual/interface/controls/nodes/introduction.rst
View File

@ -58,13 +58,14 @@ Use Nodes
Tells the render engine to use the node tree when computing the material color or rendering the final image,
or not. If not, the tree is ignored. For materials, this is mostly a legacy option, because in the past
materials could not be created with node trees.
Use Pinned
Pin
When enabled, the editor will retain the material or texture, even when the user selects a different object.
A node tree can then be edited independent of the object selection in the 3D Viewport.
Parent Node Tree
Leaves the current :doc:`node group </interface/controls/nodes/groups>` and returns to the parent node group/tree.
Snapping
Change options for snapping node positions to achieve a cleaner node tree layout.
See :doc:`/interface/controls/nodes/arranging`.
.. _bpy.types.SpaceNodeOverlay.show_overlays:

16
manual/modeling/geometry_nodes/utilities/color/combine_color.rst
View File

@ -10,28 +10,28 @@ Combine Color Node
:align: right
:alt: Combine Color Node.
The *Combine Color Node* combines an image from its composite color channels.
The node can combine multiple :term:`Color Models <Color Model>` depending on the Mode property.
Combines four grayscale channels into one color image,
based on a particular :term:`Color Model`.
Inputs
======
The outputs of this node depends on the Mode property (see below).
The inputs of this node depend on the Mode property (see below).
Alpha
The color channel that is responsible for the image's transparency.
The opacity of the output color.
Properties
==========
Mode
The color model to output.
The color model to use.
:RGB: Combine the three inputs: Red, Green, and Blue color channels into a single color.
:HSV: Combine the three inputs: Hue, Saturation, and Value color channels into a single color.
:HSL: Combine the three inputs: Hue, Saturation, and Lightness color channels into a single color.
:RGB: Red, Green, Blue.
:HSV: Hue, Saturation, Value.
:HSL: Hue, Saturation, Lightness.
Output

14
manual/modeling/geometry_nodes/utilities/color/separate_color.rst
View File

@ -10,8 +10,8 @@ Separate Color Node
:align: right
:alt: Separate Color Node.
The *Separate Color Node* splits an image into its composite color channels.
The node can output multiple :term:`Color Models <Color Model>` depending on the Mode property.
Splits an image into its channels,
based on a particular :term:`Color Model`.
Inputs
@ -27,15 +27,15 @@ Properties
Mode
The color model to output.
:RGB: Split the input colors into it's three outputs: Red, Green, and Blue color channels.
:HSV: Split the input colors into it's three outputs: Hue, Saturation, and Value color channels.
:HSL: Split the input colors into it's three outputs: Hue, Saturation, and Lightness color channels.
:RGB: Red, Green, Blue.
:HSV: Hue, Saturation, Value.
:HSL: Hue, Saturation, Lightness.
Outputs
=======
The outputs of this node depends on the Mode property (see above).
The outputs of this node depend on the Mode property (see above).
Alpha
The color channel that is responsible for the image's transparency.
The opacity value.