Gaffer Wiki - User contributions [en]

Template:LatestGafferVersion

2024-09-10T16:32:08Z

Murraystevenson:

1.4.12.0

Template:LatestGafferVersion

2024-08-15T21:34:54Z

Murraystevenson:

1.4.11.0

OSL Image Manipulation

2024-08-12T00:49:43Z

Murraystevenson: /* P */

The [[OSLImage]] node allows the use of [https://open-shading-language.readthedocs.io OpenShadingLanguage] shaders to generate or modify pixel values in an image.
[[File:OslImageFractal.png|none|thumb|720x720px|Using an OSLImage node with a shader written in an OSLCode node to generate a fractal pattern.]]
Shaders can be built from an existing library of OSL shaders loaded via the [[OSLShader]] node, and arbitrary shader code can be evaluated via the [[OSLCode]] node. An image manipulation shader could be built entirely from existing nodes, written in a single OSLCode node, or assembled from a combination of OSL shaders and OSLCode nodes.

Shaders are evaluated per pixel in the image and typically would read that pixel value from one or more channels in the image, compute a value from those inputs and then output a new value that would replace the input pixel in an existing channel or layer, or create a new channel or layer.
[[File:OslImageLuminance.png|none|thumb|720x720px|Reading RGB values from and input image, using the OSL luminance shader to compute luminance values of those pixels, and outputting to a new channel named "luminance".]]

=== Writing channel data ===

==== Adding channels to OSLImage ====
Channels are written by adding inputs to the OSLImage node by clicking on the [[File:PlugAdderIcon.png]] button in the Node Editor or by clicking or dragging a plug onto the [[File:PlugAdderIcon.png]] on the left of the node in the Graph Editor.
[[File:OslImageAddInputFromNodeEditor.png|none|thumb|Adding an input from the Node Editor]]
[[File:OslImageAddInputGraphEditor.png|none|thumb|Adding an input from the Graph Editor]]
You can choose from common channel or layer names from the menu to write to RGB or RGBA layer, or to individual R, G, B, A channels.
[[File:OSLImageAddChannelsNodeEditor.gif|none|frame|Adding RGB and A plugs from the Node Editor.]]
You can also create arbitrary channels or layers via the <code>Custom->Channel</code>, <code>Custom->Layer</code> or <code>Custom->LayerRGBA</code> menu items. The channel or layer name can then be customised by by editing the name of the plug in the Node Editor.
[[File:OSLImageAddCustomChannelsGraphEditor.gif|none|frame|Adding a custom named "luminance" channel, and "diffuse" layer to the image.]]
{{tip | Behind the scenes, these actions are adding new child plugs to the `channels` plug of the OSLImage node.}}

{{info | The OSLImage node's channel inputs can either be a Color3fPlug or a FloatPlug, so choosing RGBA from the menu will create two plugs, a Color3fPlug for the RGB channels and a FloatPlug for the A channel. }}

Each channel or layer created provides an input connection ready to receive an OSL shader.

==== Disabling an output ====
Output layers and channels can be disabled by toggling their <code>enabled</code> plug.
[[File:OSLImageDisableChannel.gif|none|frame]]

==== Removing an output ====
Previously created output layers and channels can be removed by right clicking on the plug and selecting <code>Delete</code> from the context menu.
[[File:OSLImageDeleteChannel.gif|none|frame]]

=== Reading channel data ===

==== Reading channels from shaders ====
The <code>InChannel</code> OSL shader can be used to read a specific channel from the processed image.
[[File:OSLInChannelShuffle.gif|none|Shuffling channels with OSLImage by reading a single channel with an InChannel shader and writing the result to other channels.|thumb|900x900px]]
The <code>InLayer</code> OSL shader can be used to read the R, G, B channels of a specified image layer.
[[File:OSLInLayerShuffle.gif|none|Reading the R, G, B channels with an InLayer shader and shuffling them to a new "shuffled" layer.|thumb|900x900px]]

==== Reading channels in an OSLCode node ====
When writing an OSL shader in an [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/TutorialUsingTheOSLCodeNode/index.html OSLCode] node, Gaffer provides <code>inChannel( channelName, defaultValue )</code> and <code>inLayer( layerName, defaultValue )</code> functions to access the value of a specific channel or layer for the current pixel. <syntaxhighlight lang="c">
// Get the value of the "R" channel, returning 0 if the channel does not exist.
float R = inChannel( "R", 0.0 );

// Get the values of the "R", "G", "B" channels, returning black if the layer doesn't exist
// Providing "" as the layer name will return a color containing the value of the R, G, B channels.
color RGB = inLayer( "", color( 0.0 ) );

// Get the values of the "diffuse.R", "diffuse.G", "diffuse.B" channels, returning white if the layer doesn't exist
color diffuse = inLayer( "diffuse", color( 1.0 ) );
</syntaxhighlight>Channels can also be accessed via OSL's [https://open-shading-language.readthedocs.io/en/v1.13.9.0/stdlib.html#renderer-state-and-message-passing getattribute] function.<syntaxhighlight lang="c">
// Get the value of the "R" channel for the current pixel
float R;
getattribute( "R", R );

// Get the value of the "R" channel from the "diffuse" layer for the current pixel
float diffuseR;
getattribute( "diffuse.R", diffuseR );
</syntaxhighlight>
[[File:OSLCodeShuffle.gif|none|Shuffling channels using OSLCode.|thumb|900x900px]]

=== Pixel Coordinates ===
When generating patterns, it's important to know where in the image the currently shaded pixel is located. OSLImage provides two builtin variables for locating the currently shaded pixel.

==== P ====
<code>P</code> contains the position of the center of the current pixel relative to the origin of the image [https://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithImages/AnatomyOfAnImage/index.html#data-window data window].
[[File:OslImageP.png|none|thumb|900x900px|Visualising the values of <code>P</code> as colours, the bottom left pixel has a value of (0.5, 0.5, 0) and the top right pixel a value of ( 3.5, 3.5, 0 ).]]

==== u, v ====
<code>u</code> & <code>v</code> contain the position of the center of the current pixel remapped to 0-1 across the image [https://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithImages/AnatomyOfAnImage/index.html#display-window display window].
[[File:OslImageUV.png|none|thumb|900x900px|Visualising the values of <code>u</code> & <code>v</code> as colours. The bottom left pixel has a value of ( 0.125, 0.125, 0 ) and the top right pixel a value of ( 0.875, 0.875, 0 ).]]

OSL Image Manipulation

2024-08-12T00:49:14Z

Murraystevenson: /* u, v */

The [[OSLImage]] node allows the use of [https://open-shading-language.readthedocs.io OpenShadingLanguage] shaders to generate or modify pixel values in an image.
[[File:OslImageFractal.png|none|thumb|720x720px|Using an OSLImage node with a shader written in an OSLCode node to generate a fractal pattern.]]
Shaders can be built from an existing library of OSL shaders loaded via the [[OSLShader]] node, and arbitrary shader code can be evaluated via the [[OSLCode]] node. An image manipulation shader could be built entirely from existing nodes, written in a single OSLCode node, or assembled from a combination of OSL shaders and OSLCode nodes.

Shaders are evaluated per pixel in the image and typically would read that pixel value from one or more channels in the image, compute a value from those inputs and then output a new value that would replace the input pixel in an existing channel or layer, or create a new channel or layer.
[[File:OslImageLuminance.png|none|thumb|720x720px|Reading RGB values from and input image, using the OSL luminance shader to compute luminance values of those pixels, and outputting to a new channel named "luminance".]]

=== Writing channel data ===

==== Adding channels to OSLImage ====
Channels are written by adding inputs to the OSLImage node by clicking on the [[File:PlugAdderIcon.png]] button in the Node Editor or by clicking or dragging a plug onto the [[File:PlugAdderIcon.png]] on the left of the node in the Graph Editor.
[[File:OslImageAddInputFromNodeEditor.png|none|thumb|Adding an input from the Node Editor]]
[[File:OslImageAddInputGraphEditor.png|none|thumb|Adding an input from the Graph Editor]]
You can choose from common channel or layer names from the menu to write to RGB or RGBA layer, or to individual R, G, B, A channels.
[[File:OSLImageAddChannelsNodeEditor.gif|none|frame|Adding RGB and A plugs from the Node Editor.]]
You can also create arbitrary channels or layers via the <code>Custom->Channel</code>, <code>Custom->Layer</code> or <code>Custom->LayerRGBA</code> menu items. The channel or layer name can then be customised by by editing the name of the plug in the Node Editor.
[[File:OSLImageAddCustomChannelsGraphEditor.gif|none|frame|Adding a custom named "luminance" channel, and "diffuse" layer to the image.]]
{{tip | Behind the scenes, these actions are adding new child plugs to the `channels` plug of the OSLImage node.}}

{{info | The OSLImage node's channel inputs can either be a Color3fPlug or a FloatPlug, so choosing RGBA from the menu will create two plugs, a Color3fPlug for the RGB channels and a FloatPlug for the A channel. }}

Each channel or layer created provides an input connection ready to receive an OSL shader.

==== Disabling an output ====
Output layers and channels can be disabled by toggling their <code>enabled</code> plug.
[[File:OSLImageDisableChannel.gif|none|frame]]

==== Removing an output ====
Previously created output layers and channels can be removed by right clicking on the plug and selecting <code>Delete</code> from the context menu.
[[File:OSLImageDeleteChannel.gif|none|frame]]

=== Reading channel data ===

==== Reading channels from shaders ====
The <code>InChannel</code> OSL shader can be used to read a specific channel from the processed image.
[[File:OSLInChannelShuffle.gif|none|Shuffling channels with OSLImage by reading a single channel with an InChannel shader and writing the result to other channels.|thumb|900x900px]]
The <code>InLayer</code> OSL shader can be used to read the R, G, B channels of a specified image layer.
[[File:OSLInLayerShuffle.gif|none|Reading the R, G, B channels with an InLayer shader and shuffling them to a new "shuffled" layer.|thumb|900x900px]]

==== Reading channels in an OSLCode node ====
When writing an OSL shader in an [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/TutorialUsingTheOSLCodeNode/index.html OSLCode] node, Gaffer provides <code>inChannel( channelName, defaultValue )</code> and <code>inLayer( layerName, defaultValue )</code> functions to access the value of a specific channel or layer for the current pixel. <syntaxhighlight lang="c">
// Get the value of the "R" channel, returning 0 if the channel does not exist.
float R = inChannel( "R", 0.0 );

// Get the values of the "R", "G", "B" channels, returning black if the layer doesn't exist
// Providing "" as the layer name will return a color containing the value of the R, G, B channels.
color RGB = inLayer( "", color( 0.0 ) );

// Get the values of the "diffuse.R", "diffuse.G", "diffuse.B" channels, returning white if the layer doesn't exist
color diffuse = inLayer( "diffuse", color( 1.0 ) );
</syntaxhighlight>Channels can also be accessed via OSL's [https://open-shading-language.readthedocs.io/en/v1.13.9.0/stdlib.html#renderer-state-and-message-passing getattribute] function.<syntaxhighlight lang="c">
// Get the value of the "R" channel for the current pixel
float R;
getattribute( "R", R );

// Get the value of the "R" channel from the "diffuse" layer for the current pixel
float diffuseR;
getattribute( "diffuse.R", diffuseR );
</syntaxhighlight>
[[File:OSLCodeShuffle.gif|none|Shuffling channels using OSLCode.|thumb|900x900px]]

=== Pixel Coordinates ===
When generating patterns, it's important to know where in the image the currently shaded pixel is located. OSLImage provides two builtin variables for locating the currently shaded pixel.

==== P ====
<code>P</code> contains the position of the center of the current pixel relative to the origin of the image data window.
[[File:OslImageP.png|none|thumb|900x900px|Visualising the values of <code>P</code> as colours, the bottom left pixel has a value of (0.5, 0.5, 0) and the top right pixel a value of ( 3.5, 3.5, 0 ).]]

==== u, v ====
<code>u</code> & <code>v</code> contain the position of the center of the current pixel remapped to 0-1 across the image [https://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithImages/AnatomyOfAnImage/index.html#display-window display window].
[[File:OslImageUV.png|none|thumb|900x900px|Visualising the values of <code>u</code> & <code>v</code> as colours. The bottom left pixel has a value of ( 0.125, 0.125, 0 ) and the top right pixel a value of ( 0.875, 0.875, 0 ).]]

OSL Image Manipulation

2024-08-12T00:48:26Z

Murraystevenson: /* Pixel Coordinates */

The [[OSLImage]] node allows the use of [https://open-shading-language.readthedocs.io OpenShadingLanguage] shaders to generate or modify pixel values in an image.
[[File:OslImageFractal.png|none|thumb|720x720px|Using an OSLImage node with a shader written in an OSLCode node to generate a fractal pattern.]]
Shaders can be built from an existing library of OSL shaders loaded via the [[OSLShader]] node, and arbitrary shader code can be evaluated via the [[OSLCode]] node. An image manipulation shader could be built entirely from existing nodes, written in a single OSLCode node, or assembled from a combination of OSL shaders and OSLCode nodes.

Shaders are evaluated per pixel in the image and typically would read that pixel value from one or more channels in the image, compute a value from those inputs and then output a new value that would replace the input pixel in an existing channel or layer, or create a new channel or layer.
[[File:OslImageLuminance.png|none|thumb|720x720px|Reading RGB values from and input image, using the OSL luminance shader to compute luminance values of those pixels, and outputting to a new channel named "luminance".]]

=== Writing channel data ===

==== Adding channels to OSLImage ====
Channels are written by adding inputs to the OSLImage node by clicking on the [[File:PlugAdderIcon.png]] button in the Node Editor or by clicking or dragging a plug onto the [[File:PlugAdderIcon.png]] on the left of the node in the Graph Editor.
[[File:OslImageAddInputFromNodeEditor.png|none|thumb|Adding an input from the Node Editor]]
[[File:OslImageAddInputGraphEditor.png|none|thumb|Adding an input from the Graph Editor]]
You can choose from common channel or layer names from the menu to write to RGB or RGBA layer, or to individual R, G, B, A channels.
[[File:OSLImageAddChannelsNodeEditor.gif|none|frame|Adding RGB and A plugs from the Node Editor.]]
You can also create arbitrary channels or layers via the <code>Custom->Channel</code>, <code>Custom->Layer</code> or <code>Custom->LayerRGBA</code> menu items. The channel or layer name can then be customised by by editing the name of the plug in the Node Editor.
[[File:OSLImageAddCustomChannelsGraphEditor.gif|none|frame|Adding a custom named "luminance" channel, and "diffuse" layer to the image.]]
{{tip | Behind the scenes, these actions are adding new child plugs to the `channels` plug of the OSLImage node.}}

{{info | The OSLImage node's channel inputs can either be a Color3fPlug or a FloatPlug, so choosing RGBA from the menu will create two plugs, a Color3fPlug for the RGB channels and a FloatPlug for the A channel. }}

Each channel or layer created provides an input connection ready to receive an OSL shader.

==== Disabling an output ====
Output layers and channels can be disabled by toggling their <code>enabled</code> plug.
[[File:OSLImageDisableChannel.gif|none|frame]]

==== Removing an output ====
Previously created output layers and channels can be removed by right clicking on the plug and selecting <code>Delete</code> from the context menu.
[[File:OSLImageDeleteChannel.gif|none|frame]]

=== Reading channel data ===

==== Reading channels from shaders ====
The <code>InChannel</code> OSL shader can be used to read a specific channel from the processed image.
[[File:OSLInChannelShuffle.gif|none|Shuffling channels with OSLImage by reading a single channel with an InChannel shader and writing the result to other channels.|thumb|900x900px]]
The <code>InLayer</code> OSL shader can be used to read the R, G, B channels of a specified image layer.
[[File:OSLInLayerShuffle.gif|none|Reading the R, G, B channels with an InLayer shader and shuffling them to a new "shuffled" layer.|thumb|900x900px]]

==== Reading channels in an OSLCode node ====
When writing an OSL shader in an [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/TutorialUsingTheOSLCodeNode/index.html OSLCode] node, Gaffer provides <code>inChannel( channelName, defaultValue )</code> and <code>inLayer( layerName, defaultValue )</code> functions to access the value of a specific channel or layer for the current pixel. <syntaxhighlight lang="c">
// Get the value of the "R" channel, returning 0 if the channel does not exist.
float R = inChannel( "R", 0.0 );

// Get the values of the "R", "G", "B" channels, returning black if the layer doesn't exist
// Providing "" as the layer name will return a color containing the value of the R, G, B channels.
color RGB = inLayer( "", color( 0.0 ) );

// Get the values of the "diffuse.R", "diffuse.G", "diffuse.B" channels, returning white if the layer doesn't exist
color diffuse = inLayer( "diffuse", color( 1.0 ) );
</syntaxhighlight>Channels can also be accessed via OSL's [https://open-shading-language.readthedocs.io/en/v1.13.9.0/stdlib.html#renderer-state-and-message-passing getattribute] function.<syntaxhighlight lang="c">
// Get the value of the "R" channel for the current pixel
float R;
getattribute( "R", R );

// Get the value of the "R" channel from the "diffuse" layer for the current pixel
float diffuseR;
getattribute( "diffuse.R", diffuseR );
</syntaxhighlight>
[[File:OSLCodeShuffle.gif|none|Shuffling channels using OSLCode.|thumb|900x900px]]

=== Pixel Coordinates ===
When generating patterns, it's important to know where in the image the currently shaded pixel is located. OSLImage provides two builtin variables for locating the currently shaded pixel.

==== P ====
<code>P</code> contains the position of the center of the current pixel relative to the origin of the image data window.
[[File:OslImageP.png|none|thumb|900x900px|Visualising the values of <code>P</code> as colours, the bottom left pixel has a value of (0.5, 0.5, 0) and the top right pixel a value of ( 3.5, 3.5, 0 ).]]

==== u, v ====
<code>u</code> & <code>v</code> contain the position of the center of the current pixel remapped to 0-1 across the image display window.
[[File:OslImageUV.png|none|thumb|900x900px|Visualising the values of <code>u</code> & <code>v</code> as colours. The bottom left pixel has a value of ( 0.125, 0.125, 0 ) and the top right pixel a value of ( 0.875, 0.875, 0 ).]]

File:OslImageP.png

2024-08-12T00:46:32Z

Murraystevenson: Murraystevenson uploaded a new version of File:OslImageP.png

Visualisation of the value of P in OSLImage.

OSL Image Manipulation

2024-08-12T00:44:52Z

Murraystevenson:

The [[OSLImage]] node allows the use of [https://open-shading-language.readthedocs.io OpenShadingLanguage] shaders to generate or modify pixel values in an image.
[[File:OslImageFractal.png|none|thumb|720x720px|Using an OSLImage node with a shader written in an OSLCode node to generate a fractal pattern.]]
Shaders can be built from an existing library of OSL shaders loaded via the [[OSLShader]] node, and arbitrary shader code can be evaluated via the [[OSLCode]] node. An image manipulation shader could be built entirely from existing nodes, written in a single OSLCode node, or assembled from a combination of OSL shaders and OSLCode nodes.

Shaders are evaluated per pixel in the image and typically would read that pixel value from one or more channels in the image, compute a value from those inputs and then output a new value that would replace the input pixel in an existing channel or layer, or create a new channel or layer.
[[File:OslImageLuminance.png|none|thumb|720x720px|Reading RGB values from and input image, using the OSL luminance shader to compute luminance values of those pixels, and outputting to a new channel named "luminance".]]

=== Writing channel data ===

==== Adding channels to OSLImage ====
Channels are written by adding inputs to the OSLImage node by clicking on the [[File:PlugAdderIcon.png]] button in the Node Editor or by clicking or dragging a plug onto the [[File:PlugAdderIcon.png]] on the left of the node in the Graph Editor.
[[File:OslImageAddInputFromNodeEditor.png|none|thumb|Adding an input from the Node Editor]]
[[File:OslImageAddInputGraphEditor.png|none|thumb|Adding an input from the Graph Editor]]
You can choose from common channel or layer names from the menu to write to RGB or RGBA layer, or to individual R, G, B, A channels.
[[File:OSLImageAddChannelsNodeEditor.gif|none|frame|Adding RGB and A plugs from the Node Editor.]]
You can also create arbitrary channels or layers via the <code>Custom->Channel</code>, <code>Custom->Layer</code> or <code>Custom->LayerRGBA</code> menu items. The channel or layer name can then be customised by by editing the name of the plug in the Node Editor.
[[File:OSLImageAddCustomChannelsGraphEditor.gif|none|frame|Adding a custom named "luminance" channel, and "diffuse" layer to the image.]]
{{tip | Behind the scenes, these actions are adding new child plugs to the `channels` plug of the OSLImage node.}}

{{info | The OSLImage node's channel inputs can either be a Color3fPlug or a FloatPlug, so choosing RGBA from the menu will create two plugs, a Color3fPlug for the RGB channels and a FloatPlug for the A channel. }}

Each channel or layer created provides an input connection ready to receive an OSL shader.

==== Disabling an output ====
Output layers and channels can be disabled by toggling their <code>enabled</code> plug.
[[File:OSLImageDisableChannel.gif|none|frame]]

==== Removing an output ====
Previously created output layers and channels can be removed by right clicking on the plug and selecting <code>Delete</code> from the context menu.
[[File:OSLImageDeleteChannel.gif|none|frame]]

=== Reading channel data ===

==== Reading channels from shaders ====
The <code>InChannel</code> OSL shader can be used to read a specific channel from the processed image.
[[File:OSLInChannelShuffle.gif|none|Shuffling channels with OSLImage by reading a single channel with an InChannel shader and writing the result to other channels.|thumb|900x900px]]
The <code>InLayer</code> OSL shader can be used to read the R, G, B channels of a specified image layer.
[[File:OSLInLayerShuffle.gif|none|Reading the R, G, B channels with an InLayer shader and shuffling them to a new "shuffled" layer.|thumb|900x900px]]

==== Reading channels in an OSLCode node ====
When writing an OSL shader in an [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/TutorialUsingTheOSLCodeNode/index.html OSLCode] node, Gaffer provides <code>inChannel( channelName, defaultValue )</code> and <code>inLayer( layerName, defaultValue )</code> functions to access the value of a specific channel or layer for the current pixel. <syntaxhighlight lang="c">
// Get the value of the "R" channel, returning 0 if the channel does not exist.
float R = inChannel( "R", 0.0 );

// Get the values of the "R", "G", "B" channels, returning black if the layer doesn't exist
// Providing "" as the layer name will return a color containing the value of the R, G, B channels.
color RGB = inLayer( "", color( 0.0 ) );

// Get the values of the "diffuse.R", "diffuse.G", "diffuse.B" channels, returning white if the layer doesn't exist
color diffuse = inLayer( "diffuse", color( 1.0 ) );
</syntaxhighlight>Channels can also be accessed via OSL's [https://open-shading-language.readthedocs.io/en/v1.13.9.0/stdlib.html#renderer-state-and-message-passing getattribute] function.<syntaxhighlight lang="c">
// Get the value of the "R" channel for the current pixel
float R;
getattribute( "R", R );

// Get the value of the "R" channel from the "diffuse" layer for the current pixel
float diffuseR;
getattribute( "diffuse.R", diffuseR );
</syntaxhighlight>
[[File:OSLCodeShuffle.gif|none|Shuffling channels using OSLCode.|thumb|900x900px]]

=== Pixel Coordinates ===
When generating patterns, it's important to know where in the image the currently shaded pixel is located. OSLImage provides two builtin variables for locating the currently shaded pixel.

==== P ====
<code>P</code>contains the position of the center of each pixel relative to the origin of the image data window.
[[File:OslImageP.png|none|thumb|900x900px|Visualising the values of <code>P</code> as colours, the bottom left pixel has a value of (0.5, 0.5, 0) and the top right pixel a value of ( 3.5, 3.5, 0 ).]]

==== u, v ====
<code>u</code> & <code>v</code> contain the position of the center of each pixel remapped to 0-1 across the image display window.
[[File:OslImageUV.png|none|thumb|900x900px|Visualising the values of <code>u</code> & <code>v</code> as colours. The bottom left pixel has a value of ( 0.125, 0.125, 0 ) and the top right pixel a value of ( 0.875, 0.875, 0 ).]]

OSL Image Manipulation

2024-08-12T00:42:38Z

Murraystevenson:

The [[OSLImage]] node allows the use of [https://open-shading-language.readthedocs.io OpenShadingLanguage] shaders to generate or modify pixel values in an image.
[[File:OslImageFractal.png|none|thumb|720x720px|Using an OSLImage node with a shader written in an OSLCode node to generate a fractal pattern.]]
Shaders can be built from an existing library of OSL shaders loaded via the [[OSLShader]] node, and arbitrary shader code can be evaluated via the [[OSLCode]] node. An image manipulation shader could be built entirely from existing nodes, written in a single OSLCode node, or assembled from a combination of OSL shaders and OSLCode nodes.

Shaders are evaluated per pixel in the image and typically would read that pixel value from one or more channels in the image, compute a value from those inputs and then output a new value that would replace the input pixel in an existing channel or layer, or create a new channel or layer.
[[File:OslImageLuminance.png|none|thumb|720x720px|Reading RGB values from and input image, using the OSL luminance shader to compute luminance values of those pixels, and outputting to a new channel named "luminance".]]

=== Writing channel data ===

==== Adding channels to OSLImage ====
Channels are written by adding inputs to the OSLImage node by clicking on the [[File:PlugAdderIcon.png]] button in the Node Editor or by clicking or dragging a plug onto the [[File:PlugAdderIcon.png]] on the left of the node in the Graph Editor.
[[File:OslImageAddInputFromNodeEditor.png|none|thumb|Adding an input from the Node Editor]]
[[File:OslImageAddInputGraphEditor.png|none|thumb|Adding an input from the Graph Editor]]
You can choose from common channel or layer names from the menu to write to RGB or RGBA layer, or to individual R, G, B, A channels.
[[File:OSLImageAddChannelsNodeEditor.gif|none|frame|Adding RGB and A plugs from the Node Editor.]]
You can also create arbitrary channels or layers via the <code>Custom->Channel</code>, <code>Custom->Layer</code> or <code>Custom->LayerRGBA</code> menu items. The channel or layer name can then be customised by by editing the name of the plug in the Node Editor.
[[File:OSLImageAddCustomChannelsGraphEditor.gif|none|frame|Adding a custom named "luminance" channel, and "diffuse" layer to the image.]]
{{tip | Behind the scenes, these actions are adding new child plugs to the `channels` plug of the OSLImage node.}}

{{info | The OSLImage node's channel inputs can either be a Color3fPlug or a FloatPlug, so choosing RGBA from the menu will create two plugs, a Color3fPlug for the RGB channels and a FloatPlug for the A channel. }}

Each channel or layer created provides an input connection ready to receive an OSL shader.

==== Disabling an output ====
Output layers and channels can be disabled by toggling their <code>enabled</code> plug.
[[File:OSLImageDisableChannel.gif|none|frame]]

==== Removing an output ====
Previously created output layers and channels can be removed by right clicking on the plug and selecting <code>Delete</code> from the context menu.
[[File:OSLImageDeleteChannel.gif|none|frame]]

=== Reading channel data ===

==== Reading channels from shaders ====
The <code>InChannel</code> OSL shader can be used to read a specific channel from the processed image.
[[File:OSLInChannelShuffle.gif|none|frame|Shuffling channels with OSLImage by reading a single channel with an InChannel shader and writing the result to other channels.]]
The <code>InLayer</code> OSL shader can be used to read the R, G, B channels of a specified image layer.
[[File:OSLInLayerShuffle.gif|none|frame|Reading the R, G, B channels with an InLayer shader and shuffling them to a new "shuffled" layer.]]

==== Reading channels in an OSLCode node ====
When writing an OSL shader in an [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/TutorialUsingTheOSLCodeNode/index.html OSLCode] node, Gaffer provides <code>inChannel( channelName, defaultValue )</code> and <code>inLayer( layerName, defaultValue )</code> functions to access the value of a specific channel or layer for the current pixel. <syntaxhighlight lang="c">
// Get the value of the "R" channel, returning 0 if the channel does not exist.
float R = inChannel( "R", 0.0 );

// Get the values of the "R", "G", "B" channels, returning black if the layer doesn't exist
// Providing "" as the layer name will return a color containing the value of the R, G, B channels.
color RGB = inLayer( "", color( 0.0 ) );

// Get the values of the "diffuse.R", "diffuse.G", "diffuse.B" channels, returning white if the layer doesn't exist
color diffuse = inLayer( "diffuse", color( 1.0 ) );
</syntaxhighlight>Channels can also be accessed via OSL's [https://open-shading-language.readthedocs.io/en/v1.13.9.0/stdlib.html#renderer-state-and-message-passing getattribute] function.<syntaxhighlight lang="c">
// Get the value of the "R" channel for the current pixel
float R;
getattribute( "R", R );

// Get the value of the "R" channel from the "diffuse" layer for the current pixel
float diffuseR;
getattribute( "diffuse.R", diffuseR );
</syntaxhighlight>
[[File:OSLCodeShuffle.gif|none|frame|Shuffling channels using OSLCode.]]

=== Pixel Coordinates ===
When generating patterns, it's important to know where in the image the currently shaded pixel is located. OSLImage provides two builtin variables for locating the currently shaded pixel.

==== P ====
<code>P</code>contains the position of the center of each pixel relative to the origin of the image data window.
[[File:OslImageP.png|none|thumb|640x640px|Visualising the values of <code>P</code> as colours, the bottom left pixel has a value of (0.5, 0.5, 0) and the top right pixel a value of ( 3.5, 3.5, 0 ).]]

==== u, v ====
<code>u</code> & <code>v</code> contain the position of the center of each pixel remapped to 0-1 across the image display window.
[[File:OslImageUV.png|none|thumb|640x640px|Visualising the values of <code>u</code> & <code>v</code> as colours. The bottom left pixel has a value of ( 0.125, 0.125, 0 ) and the top right pixel a value of ( 0.875, 0.875, 0 ).]]

File:OslImageUV.png

2024-08-12T00:37:22Z

Murraystevenson:

Visualisation of the values of u & v in OSLImage

File:OslImageP.png

2024-08-12T00:36:47Z

Murraystevenson:

Visualisation of the value of P in OSLImage.

OSL Image Manipulation

2024-08-12T00:15:23Z

Murraystevenson:

The [[OSLImage]] node allows the use of [https://open-shading-language.readthedocs.io OpenShadingLanguage] shaders to generate or modify pixel values in an image.
[[File:OslImageFractal.png|none|thumb|720x720px|Using an OSLImage node with a shader written in an OSLCode node to generate a fractal pattern.]]
Shaders can be built from an existing library of OSL shaders loaded via the [[OSLShader]] node, and arbitrary shader code can be evaluated via the [[OSLCode]] node. An image manipulation shader could be built entirely from existing nodes, written in a single OSLCode node, or assembled from a combination of OSL shaders and OSLCode nodes.

Shaders are evaluated per pixel in the image and typically would read that pixel value from one or more channels in the image, compute a value from those inputs and then output a new value that would replace the input pixel in an existing channel or layer, or create a new channel or layer.
[[File:OslImageLuminance.png|none|thumb|720x720px|Reading RGB values from and input image, using the OSL luminance shader to compute luminance values of those pixels, and outputting to a new channel named "luminance".]]

=== Writing channel data ===

==== Adding channels to OSLImage ====
Channels are written by adding inputs to the OSLImage node by clicking on the [[File:PlugAdderIcon.png]] button in the Node Editor or by clicking or dragging a plug onto the [[File:PlugAdderIcon.png]] on the left of the node in the Graph Editor.
[[File:OslImageAddInputFromNodeEditor.png|none|thumb|Adding an input from the Node Editor]]
[[File:OslImageAddInputGraphEditor.png|none|thumb|Adding an input from the Graph Editor]]
You can choose from common channel or layer names from the menu to write to RGB or RGBA layer, or to individual R, G, B, A channels.
[[File:OSLImageAddChannelsNodeEditor.gif|none|frame|Adding RGB and A plugs from the Node Editor.]]
You can also create arbitrary channels or layers via the <code>Custom->Channel</code>, <code>Custom->Layer</code> or <code>Custom->LayerRGBA</code> menu items. The channel or layer name can then be customised by by editing the name of the plug in the Node Editor.
[[File:OSLImageAddCustomChannelsGraphEditor.gif|none|frame|Adding a custom named "luminance" channel, and "diffuse" layer to the image.]]
{{tip | Behind the scenes, these actions are adding new child plugs to the `channels` plug of the OSLImage node.}}

{{info | The OSLImage node's channel inputs can either be a Color3fPlug or a FloatPlug, so choosing RGBA from the menu will create two plugs, a Color3fPlug for the RGB channels and a FloatPlug for the A channel. }}

Each channel or layer created provides an input connection ready to receive an OSL shader.

==== Disabling an output ====
Output layers and channels can be disabled by toggling their <code>enabled</code> plug.
[[File:OSLImageDisableChannel.gif|none|frame]]

==== Removing an output ====
Previously created output layers and channels can be removed by right clicking on the plug and selecting <code>Delete</code> from the context menu.
[[File:OSLImageDeleteChannel.gif|none|frame]]

=== Reading channel data ===

==== Reading channels from shaders ====
The <code>InChannel</code> OSL shader can be used to read a specific channel from the processed image.
[[File:OSLInChannelShuffle.gif|none|frame|Shuffling channels with OSLImage by reading a single channel with an InChannel shader and writing the result to other channels.]]
The <code>InLayer</code> OSL shader can be used to read the R, G, B channels of a specified image layer.
[[File:OSLInLayerShuffle.gif|none|frame|Reading the R, G, B channels with an InLayer shader and shuffling them to a new "shuffled" layer.]]

==== Reading channels in an OSLCode node ====
When writing an OSL shader in an [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/TutorialUsingTheOSLCodeNode/index.html OSLCode] node, Gaffer provides <code>inChannel( channelName, defaultValue )</code> and <code>inLayer( layerName, defaultValue )</code> functions to access the value of a specific channel or layer for the current pixel. <syntaxhighlight lang="c">
// Get the value of the "R" channel, returning 0 if the channel does not exist.
float R = inChannel( "R", 0.0 );

// Get the values of the "R", "G", "B" channels, returning black if the layer doesn't exist
// Providing "" as the layer name will return a color containing the value of the R, G, B channels.
color RGB = inLayer( "", color( 0.0 ) );

// Get the values of the "diffuse.R", "diffuse.G", "diffuse.B" channels, returning white if the layer doesn't exist
color diffuse = inLayer( "diffuse", color( 1.0 ) );
</syntaxhighlight>Channels can also be accessed via OSL's [https://open-shading-language.readthedocs.io/en/v1.13.9.0/stdlib.html#renderer-state-and-message-passing getattribute] function.<syntaxhighlight lang="c">
// Get the value of the "R" channel for the current pixel
float R;
getattribute( "R", R );

// Get the value of the "R" channel from the "diffuse" layer for the current pixel
float diffuseR;
getattribute( "diffuse.R", diffuseR );
</syntaxhighlight>
[[File:OSLCodeShuffle.gif|none|frame|Shuffling channels using OSLCode.]]

OSL Image Manipulation

2024-08-12T00:12:47Z

Murraystevenson: /* Reading channels in an OSLCode node */

The [[OSLImage]] node allows the use of [https://open-shading-language.readthedocs.io OpenShadingLanguage] shaders to generate or modify pixel values in an image.
[[File:OslImageFractal.png|none|thumb|720x720px|Using an OSLImage node with a shader written in an OSLCode node to generate a fractal pattern.]]
Shaders can be built from an existing library of OSL shaders loaded via the [[OSLShader]] node, and arbitrary shader code can be evaluated via the [[OSLCode]] node. An image manipulation shader could be built entirely from existing nodes, written in a single OSLCode node, or assembled from a combination of OSL shaders and OSLCode nodes.

Shaders are evaluated per pixel in the image and typically would read that pixel value from one or more channels in the image, compute a value from those inputs and then output a new value that would replace the input pixel in an existing channel or layer, or create a new channel or layer.
[[File:OslImageLuminance.png|none|thumb|720x720px|Reading RGB values from and input image, using the OSL luminance shader to compute luminance values of those pixels, and outputting to a new channel named "luminance".]]

=== Writing channel data ===
Channels are written by adding inputs to the OSLImage node by clicking on the [[File:PlugAdderIcon.png]] button in the Node Editor or by clicking or dragging a plug onto the [[File:PlugAdderIcon.png]] on the left of the node in the Graph Editor.
[[File:OslImageAddInputFromNodeEditor.png|none|thumb|Adding an input from the Node Editor]]
[[File:OslImageAddInputGraphEditor.png|none|thumb|Adding an input from the Graph Editor]]
You can choose from common channel or layer names from the menu to write to RGB or RGBA layer, or to individual R, G, B, A channels.
[[File:OSLImageAddChannelsNodeEditor.gif|none|frame|Adding RGB and A plugs from the Node Editor.]]
You can also create arbitrary channels or layers via the <code>Custom->Channel</code>, <code>Custom->Layer</code> or <code>Custom->LayerRGBA</code> menu items. The channel or layer name can then be customised by by editing the name of the plug in the Node Editor.
[[File:OSLImageAddCustomChannelsGraphEditor.gif|none|frame|Adding a custom named "luminance" channel, and "diffuse" layer to the image.]]
{{tip | Behind the scenes, these actions are adding new child plugs to the `channels` plug of the OSLImage node.}}

{{info | The OSLImage node's channel inputs can either be a Color3fPlug or a FloatPlug, so choosing RGBA from the menu will create two plugs, a Color3fPlug for the RGB channels and a FloatPlug for the A channel. }}

Each channel or layer created provides an input connection ready to receive an OSL shader.

==== Disabling an output ====
Output layers and channels can be disabled by toggling their <code>enabled</code> plug.
[[File:OSLImageDisableChannel.gif|none|frame]]

==== Removing an output ====
Previously created output layers and channels can be removed by right clicking on the plug and selecting <code>Delete</code> from the context menu.
[[File:OSLImageDeleteChannel.gif|none|frame]]

=== Reading channel data ===
The <code>InChannel</code> OSL shader can be used to read a specific channel from the processed image.
[[File:OSLInChannelShuffle.gif|none|frame|Shuffling channels with OSLImage by reading a single channel with an InChannel shader and writing the result to other channels.]]
The <code>InLayer</code> OSL shader can be used to read the R, G, B channels of a specified image layer.
[[File:OSLInLayerShuffle.gif|none|frame|Reading the R, G, B channels with an InLayer shader and shuffling them to a new "shuffled" layer.]]

==== Reading channels in an OSLCode node ====
When writing an OSL shader in an [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/TutorialUsingTheOSLCodeNode/index.html OSLCode] node, Gaffer provides <code>inChannel( channelName, defaultValue )</code> and <code>inLayer( layerName, defaultValue )</code> functions to access the value of a specific channel or layer for the current pixel. <syntaxhighlight lang="c">
// Get the value of the "R" channel, returning 0 if the channel does not exist.
float R = inChannel( "R", 0.0 );

// Get the values of the "R", "G", "B" channels, returning black if the layer doesn't exist
// Providing "" as the layer name will return a color containing the value of the R, G, B channels.
color RGB = inLayer( "", color( 0.0 ) );

// Get the values of the "diffuse.R", "diffuse.G", "diffuse.B" channels, returning white if the layer doesn't exist
color diffuse = inLayer( "diffuse", color( 1.0 ) );
</syntaxhighlight>Channels can also be accessed via OSL's [https://open-shading-language.readthedocs.io/en/v1.13.9.0/stdlib.html#renderer-state-and-message-passing getattribute] function.<syntaxhighlight lang="c">
// Get the value of the "R" channel for the current pixel
float R;
getattribute( "R", R );

// Get the value of the "R" channel from the "diffuse" layer for the current pixel
float diffuseR;
getattribute( "diffuse.R", diffuseR );
</syntaxhighlight>
[[File:OSLCodeShuffle.gif|none|frame|Shuffling channels using OSLCode.]]

OSL Image Manipulation

2024-08-11T23:59:12Z

Murraystevenson: WIP guide to OSL Image Manipulation

The [[OSLImage]] node allows the use of [https://open-shading-language.readthedocs.io OpenShadingLanguage] shaders to generate or modify pixel values in an image.
[[File:OslImageFractal.png|none|thumb|720x720px|Using an OSLImage node with a shader written in an OSLCode node to generate a fractal pattern.]]
Shaders can be built from an existing library of OSL shaders loaded via the [[OSLShader]] node, and arbitrary shader code can be evaluated via the [[OSLCode]] node. An image manipulation shader could be built entirely from existing nodes, written in a single OSLCode node, or assembled from a combination of OSL shaders and OSLCode nodes.

Shaders are evaluated per pixel in the image and typically would read that pixel value from one or more channels in the image, compute a value from those inputs and then output a new value that would replace the input pixel in an existing channel or layer, or create a new channel or layer.
[[File:OslImageLuminance.png|none|thumb|720x720px|Reading RGB values from and input image, using the OSL luminance shader to compute luminance values of those pixels, and outputting to a new channel named "luminance".]]

=== Writing channel data ===
Channels are written by adding inputs to the OSLImage node by clicking on the [[File:PlugAdderIcon.png]] button in the Node Editor or by clicking or dragging a plug onto the [[File:PlugAdderIcon.png]] on the left of the node in the Graph Editor.
[[File:OslImageAddInputFromNodeEditor.png|none|thumb|Adding an input from the Node Editor]]
[[File:OslImageAddInputGraphEditor.png|none|thumb|Adding an input from the Graph Editor]]
You can choose from common channel or layer names from the menu to write to RGB or RGBA layer, or to individual R, G, B, A channels.
[[File:OSLImageAddChannelsNodeEditor.gif|none|frame|Adding RGB and A plugs from the Node Editor.]]
You can also create arbitrary channels or layers via the <code>Custom->Channel</code>, <code>Custom->Layer</code> or <code>Custom->LayerRGBA</code> menu items. The channel or layer name can then be customised by by editing the name of the plug in the Node Editor.
[[File:OSLImageAddCustomChannelsGraphEditor.gif|none|frame|Adding a custom named "luminance" channel, and "diffuse" layer to the image.]]
{{tip | Behind the scenes, these actions are adding new child plugs to the `channels` plug of the OSLImage node.}}

{{info | The OSLImage node's channel inputs can either be a Color3fPlug or a FloatPlug, so choosing RGBA from the menu will create two plugs, a Color3fPlug for the RGB channels and a FloatPlug for the A channel. }}

Each channel or layer created provides an input connection ready to receive an OSL shader.

==== Disabling an output ====
Output layers and channels can be disabled by toggling their <code>enabled</code> plug.
[[File:OSLImageDisableChannel.gif|none|frame]]

==== Removing an output ====
Previously created output layers and channels can be removed by right clicking on the plug and selecting <code>Delete</code> from the context menu.
[[File:OSLImageDeleteChannel.gif|none|frame]]

=== Reading channel data ===
The <code>InChannel</code> OSL shader can be used to read a specific channel from the processed image.
[[File:OSLInChannelShuffle.gif|none|frame|Shuffling channels with OSLImage by reading a single channel with an InChannel shader and writing the result to other channels.]]
The <code>InLayer</code> OSL shader can be used to read the R, G, B channels of a specified image layer.
[[File:OSLInLayerShuffle.gif|none|frame|Reading the R, G, B channels with an InLayer shader and shuffling them to a new "shuffled" layer.]]

==== Reading channels in an OSLCode node ====
When writing an OSL shader in an [[OSLCode]] node, Gaffer provides <code>inChannel( channelName, defaultValue )</code> and <code>inLayer( layerName, defaultValue )</code> functions to access the value of a specific channel or layer for the current pixel. Providing an empty <code>layerName</code> to <code>inLayer()</code> will return a color containing the value of the R, G, B channels.<syntaxhighlight lang="c">
// Get the value of the "R" channel, returning 0 if the channel does not exist.
float R = inChannel( "R", 0.0 );

// Get the values of the "R", "G", "B" channels, returning black if the layer doesn't exist
color RGB = inLayer( "", color( 0.0 ) );

// Get the values of the "diffuse.R", "diffuse.G", "diffuse.B" channels, returning white if the layer doesn't exist
color diffuse = inLayer( "diffuse", color( 1.0 ) );
</syntaxhighlight>Channels can also be accessed via OSL's [https://open-shading-language.readthedocs.io/en/v1.13.9.0/stdlib.html#renderer-state-and-message-passing getattribute] function.<syntaxhighlight lang="c">
// Get the value of the "R" channel for the current pixel
float R;
getattribute( "R", R );

// Get the value of the "R" channel from the "diffuse" layer for the current pixel
float diffuseR;
getattribute( "diffuse.R", diffuseR );
</syntaxhighlight>
[[File:OSLCodeShuffle.gif|none|frame|Shuffling channels using OSLCode.]]

File:OSLCodeShuffle.gif

2024-08-11T23:53:11Z

Murraystevenson:

Example of using an OSLCode node and OSLImage to shuffle channels.

File:OSLInLayerShuffle.gif

2024-08-11T23:35:35Z

Murraystevenson:

Example of using the InLayer OSL shader with an OSLImage to shuffle channels from one layer to another.

File:OSLInChannelShuffle.gif

2024-08-11T23:28:21Z

Murraystevenson:

GIF demonstrating basic usage of OSLInChannel and OSLImage by combining them to create a channel shuffle.

File:OSLImageDeleteChannel.gif

2024-08-11T23:15:39Z

Murraystevenson:

GIF of deleting plugs from an OSLImage node.

File:OSLImageDisableChannel.gif

2024-08-11T23:15:03Z

Murraystevenson:

GIF of disabling plugs on an OSLImage node.

File:OSLImageAddCustomChannelsGraphEditor.gif

2024-08-11T23:11:29Z

Murraystevenson:

GIF of adding custom channels to an OSLImage node from the Graph Editor and then editing the plug names in the Node Editor.

File:OSLImageAddChannelsNodeEditor.gif

2024-08-11T23:08:50Z

Murraystevenson:

A GIF showing creation of RGB and A channels on an OSLImage node from the Node Editor

File:PlugAdderIcon.png

2024-08-11T22:59:06Z

Murraystevenson:

Gaffer plug adder icon

File:OslImageAddInputGraphEditor.png

2024-08-11T22:56:43Z

Murraystevenson:

Screenshot of adding an input to an OSLImage node from the Graph Editor.

File:OslImageAddInputFromNodeEditor.png

2024-08-11T22:55:41Z

Murraystevenson:

Screenshot of adding an input to an OSLImage node from the Node Editor

File:OslImageLuminance.png

2024-08-11T22:51:08Z

Murraystevenson:

Example of using an OSL shader network to compute the luminance of an input image and output the values to a new channel.

File:OslImageFractal.png

2024-08-11T22:48:06Z

Murraystevenson:

Using an OSLImage and OSLCode node to generate a fractal image pattern.

ContactSheet

2024-07-26T19:32:00Z

Murraystevenson:

{{Node
|namespace=GafferImage
|description=Assembles multiple input images into a tiled grid, with customisable layout, labels and borders.
|categories=Image, ImageTransform
}}

Template:LatestGafferVersion

2024-07-26T19:30:28Z

Murraystevenson:

1.4.10.0

LocalDispatcher

2024-07-26T19:29:29Z

Murraystevenson: Created page with "{{Node |namespace=GafferDispatch |description=Schedules execution of task graphs on the local machine. Tasks may be dispatched in the background to keep the UI responsive. |categories=Dispatch }}"

{{Node
|namespace=GafferDispatch
|description=Schedules execution of task graphs on the local machine. Tasks may be dispatched in the background to keep the UI responsive.
|categories=Dispatch
}}

MeshTessellate

2024-07-26T19:27:45Z

Murraystevenson: Created page with "{{Node |namespace=GafferScene |description=Tessellates meshes according to their subdivision scheme, converting them into higher polygon meshes which follow the limit surface - usually the smooth regular quads of a Catmull-Clark scheme. |categories=Mesh }}"

{{Node
|namespace=GafferScene
|description=Tessellates meshes according to their subdivision scheme, converting them into higher polygon meshes which follow the limit surface - usually the smooth regular quads of a Catmull-Clark scheme.
|categories=Mesh
}}

DeepSlice

2024-07-26T19:26:32Z

Murraystevenson: Created page with "{{Node |namespace=GafferImage |description=Takes a slice out of an image with depth defined by Z (and optionally ZBack) channels by discarding everything outside of a clipping range. The range is half open, including point samples exactly at the near clip, but excluding point samples exactly at the far clip. This means that if you split an image into a front and back with two DeepSlices, they will composite back together to match the original. |categories=Deep }}"

{{Node
|namespace=GafferImage
|description=Takes a slice out of an image with depth defined by Z (and optionally ZBack) channels by discarding everything outside of a clipping range. The range is half open, including point samples exactly at the near clip, but excluding point samples exactly at the far clip. This means that if you split an image into a front and back with two DeepSlices, they will composite back together to match the original.
|categories=Deep
}}

ContactSheetCore

2024-07-26T19:24:55Z

Murraystevenson: Created page with "{{Node |namespace=GafferImage |description=Collects multiple input images, transforming them into tiles within the output image. Provides the core functionality of the ContactSheet node, and may be reused for making similar nodes. |categories=ImageTransform }}"

{{Node
|namespace=GafferImage
|description=Collects multiple input images, transforming them into tiles within the output image. Provides the core functionality of the ContactSheet node, and may be reused for making similar nodes.
|categories=ImageTransform
}}

ContactSheet

2024-07-26T19:24:05Z

Murraystevenson: Created page with "{{Node |namespace=GafferImage |description=Assembles multiple input images into a tiled grid, with customisable layout, labels and borders. |categories=Image }}"

{{Node
|namespace=GafferImage
|description=Assembles multiple input images into a tiled grid, with customisable layout, labels and borders.
|categories=Image
}}

RenderPassShader

2024-07-26T19:22:58Z

Murraystevenson: Created page with "{{Node |namespace=GafferScene |description=Sets up a global shader in the options to replace a shader used by a render pass type. |categories=RenderPass, Shader }}"

{{Node
|namespace=GafferScene
|description=Sets up a global shader in the options to replace a shader used by a render pass type.
|categories=RenderPass, Shader
}}

Scripting Box Nodes

2024-07-26T19:19:36Z

Murraystevenson: Undo revision 381 by Murraystevenson (talk)

Gaffer’s [[Box]] node is a staple building block sharing chunks of node graph (via the Reference system), or quickly building tools via expressions and promoted plugs.

[[File:ScriptingBoxNodes1.png]]

The Gaffer docs have a page covering [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html Box nodes and how to use them]. In this guide we take a quick look at how to re-create a simple GroundPlane tool made in the UI, using only Gaffer’s python API.

{{ warning | This guide assumes you are familiar with working with Box nodes in the UI, including [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html#promoting-and-demoting-a-plug promoting plugs] and how [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html#connecting-a-box-to-the-main-graph in/out nodes work]. You also need to be comfortable with using [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithThePythonScriptingAPI/TutorialNodeGraphEditingInPython/index.html Gaffer’s Python API to work with the node graph].
}}

== Introduction ==
[[File:ScriptingBoxNodes2.png|thumb|The internal network we'll create within the GroundPlane box.]]
For those reading who have used the Plane node. Its ‘z-up’ orientation is less than helpful if you just want a bit of ground for some reason or another. It is also tiny.

Here we’re going to make a simple box that encapsulates the network shown to the right so that you can add a plane with the right orientation to your scene. Exposing a few useful plugs to make it easy to tweak.

== The script ==
All of the code below can be run directly in the Python Editor. Let start first by importing a few pre-requisites we’ll need later:
<syntaxhighlight lang="python">
import Gaffer
import GafferScene
import imath
</syntaxhighlight>

=== Making the Box ===
The box node, as with all Gaffer nodes, is made by literally constructing an instance of the Box class and adding it to the graph. In this script, we’ll just put it at the root. In a real tool, you’d probably wan’t to use [https://github.com/GafferHQ/gaffer/blob/main/python/GafferUI/EditMenu.py#L91-L97 GafferUI.EditMenu.scope()] to get the root visible in the user’s Graph Editor.

<syntaxhighlight lang="python">
box = Gaffer.Box( "GroundPlane" )
root.addChild( box )
</syntaxhighlight>

{{ tip | As this is a script and we don’t know what nodes may already be in the graph, when creating new nodes, we work with the node instance directly rather than adding it to it’s parent and using the parent["NodeName"] syntax. The latter works in simple cases, but if there is already a node with that name, the new one will be renamed, so the sub-script syntax would give the existing node, not your new one! }}

=== The internal network ===
We need a Plane, to set some non-default values so it’s more useful, freeze it’s transform and use a Parent node to insert it into the incoming scene. Make these nodes, connect them up and add them to the Box:
<syntaxhighlight lang="python">
plane = GafferScene.Plane( "Plane" )
plane["transform"]["rotate"].setValue( imath.V3f( -90, 0, 0 ) )
plane["dimensions"].setValue( imath.V2f( 100, 100 ) )
plane["name"].setValue( "ground" )

freeze = GafferScene.FreezeTransform( "FreezeTransform" )

# Note, don't confuse 'parent' here with the built-in variable
# available in Python expressions. This is just a local holding
# our 'Parent' node (I should have used a less confusing example!)

parent = GafferScene.Parent( "Parent" )
parent["parent"].setValue("/")

freeze["in"].setInput( plane["out"] )
parent["child"].setInput( freeze["out"] )

box.addChild( plane )
box.addChild( freeze )
box.addChild( parent )
</syntaxhighlight>

=== Promoting plugs ===
We now have our network inside the box, but the box has no input or output. We can use the Gaffer.BoxIO node’s static promote method to promote the in/out plugs on the Parent node, as a user might do using the right-click menus in the UI:
<syntaxhighlight lang="python">
Gaffer.BoxIO.promote( parent["in"] )
Gaffer.BoxIO.promote( parent["out"] )
</syntaxhighlight>
You can use exactly the same function to promote plugs that appear in the Node Editor instead of in the Graph Editor (they’re all just plugs after all). BoxIO.promote preserves the plugs existing metadata, which is what controls where they’re presented, so it knows whether they should be on the top or bottom or sides of the box.
<syntaxhighlight lang="python">
Gaffer.BoxIO.promote( plane["name"] )
Gaffer.BoxIO.promote( parent["parent"] )
Gaffer.BoxIO.promote( plane["divisions"] )
Gaffer.BoxIO.promote( plane["dimensions"] )
</syntaxhighlight>
The promote() method takes care of creating, connecting and configuring BoxIn/ BoxOut nodes and plugs on the Box itself. You don’t need to manually manage these.

You should now have a functional Box just like the one made in the UI.

=== Disabling the node (a.k.a finding inputs and outputs). ===
In order to allow a user to disable/bypass the Box, we need to provide a pass-through connection ([http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html#setting-up-a-box-for-pass-through explained here]) that defines what to output when the Box is disabled. To do this, we’ll need to get the BoxIn and BoxOut nodes so we can connect the boxOutNode["passThrough"] plug to the boxInNode["out"] plug.

{{ info | Hang on, you said "out" on the BoxIn node? Don’t you mean "in"?

To understand this, we’ll have to look at a few details of how Box nodes work. A box node has in/out plugs. When you look at the box node from the outside you are looking at plugs on the box node itself. But you also want to see them when you’re looking at the graph inside the box so you can hook things up.

As its Gaffer, and we try to keep the fundamentals simple and consistent. Rather than invent something new and esoteric, the BoxIO code you used earlier creates child nodes that are either BoxIn or BoxOut to represent the box’s input/output plugs when viewing the graph inside the box in the Graph Editor and connects these from/to the box’s actual inputs and outputs so data can flow from outside, to inside and back again, ie:

[[File:ScriptingBoxNodes3.png]]

As they’re __ prefixed (ie: private plugs), you don’t see these ‘bridging’ plugs and connections in the UI (it’d just be confusing too).

The name of these internal nodes also determines the name of the plug on the outside of the box – which works well as these plug names need to be unique.

So, you need the out plug of the BoxIn node as thats the plug that’s visible when looking at the inside of the box, that carries the data from the in plug on the outside of the box. }}

Back, to connecting up the passthrough. There are a couple of ways to find the plugs to do this.

=== Getting the I/O nodes for an existing box ===
In this simple case, the Box node in plug is connected to its child BoxIn node, and it’s out plug is connected from it’s child BoxOut node. A such, you can use the following:
<syntaxhighlight lang="python">
boxInNode = box["in"].outputs()[0].node()
boxOutNode = box["out"].getInput().node()
boxOutNode["passThrough"].setInput( boxInNode["out"] )
</syntaxhighlight>

=== A safer route ===
The above works, but relies on knowing the correct names for the input/output plugs on the box. If you’ve promoted several inputs and outputs, they have to have unique names so they might not be what you think.

When you promote a plug using Gaffer.BoxIO.promote() it returns the corresponding plug on the outside of the box. So we could amend our promotion code to the following:
<syntaxhighlight lang="python">
boxInPlug = Gaffer.BoxIO.promote( parent["in"] )
boxOutPlug = Gaffer.BoxIO.promote( parent["out"] )

# Add a passthrough
boxOutNode = boxOutPlug.getInput().node()
boxInNode = boxInPlug.outputs()[0].node()
boxOutNode["passThrough"].setInput( boxInNode["out"] )
</syntaxhighlight>

You could also go backwards, from the '''parent''' node:
<syntaxhighlight lang="python">
boxOutNode = parent["out"].outputs()[0].node()
boxInNode = parent["in"].getInput().node()
</syntaxhighlight>
== Box Icons ==
By default, Box nodes are drawn with a ‘box’ icon. When you change this in the UI Editor, it simply edits the node’s metadata. You can do the same yourself if you want to remove (or change) the icon:
<syntaxhighlight lang="python">
# remove
Gaffer.Metadata.registerValue( box, 'icon', None )
# change
Gaffer.Metadata.registerValue( box, 'icon', 'grid.png' )
</syntaxhighlight>
{{ info | NOTE: Images specified by a relative path need to be on $GAFFER_IMAGE_PATHS. }}

== Useful links ==
[http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html# Box node introduction]

[http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithThePythonScriptingAPI/TutorialNodeGraphEditingInPython/index.html Working with the Node Graph scripting tutorial]

[https://github.com/GafferHQ/gaffer/blob/main/include/Gaffer/BoxIO.h The BoxIO module]

[https://github.com/GafferHQ/gaffer/blob/main/python/GafferUI/EditMenu.py#L91-L97 Finding the ‘current’ graph root with GafferUI.EditMenu.scope()]

== The final script ==
<syntaxhighlight lang="python" line>
import Gaffer
import GafferScene
import imath

# The box

box = Gaffer.Box( "GroundPlane" )
Gaffer.Metadata.registerValue( box, 'icon', None )
root.addChild( box )

# Internal network

plane = GafferScene.Plane( "Plane" )
plane["transform"]["rotate"].setValue( imath.V3f( -90, 0, 0 ) )
plane["dimensions"].setValue( imath.V2f( 100, 100 ) )
plane["name"].setValue( "ground" )

freeze = GafferScene.FreezeTransform( "FreezeTransform" )

parent = GafferScene.Parent( "Parent" )
parent["parent"].setValue("/")

freeze["in"].setInput( plane["out"] )
parent["child"].setInput( freeze["out"] )

box.addChild( plane )
box.addChild( freeze )
box.addChild( parent )

# Promote i/o
boxInPlug = Gaffer.BoxIO.promote( parent["in"] )
boxOutPlug = Gaffer.BoxIO.promote( parent["out"] )

# Promote useful Node Editor plugs
Gaffer.BoxIO.promote( plane["name"] )
Gaffer.BoxIO.promote( parent["parent"] )
Gaffer.BoxIO.promote( plane["divisions"] )
Gaffer.BoxIO.promote( plane["dimensions"] )

# Add a passthrough
boxOutNode = boxOutPlug.getInput().node()
boxInNode = boxInPlug.outputs()[0].node()
boxOutNode["passThrough"].setInput( boxInNode["out"] )
</syntaxhighlight>

Scripting Box Nodes

2024-07-26T19:18:34Z

Murraystevenson:

Gaffer’s [[Box]] node is a staple building block sharing chunks of node graph (via the Reference system), or quickly building tools via expressions and promoted plugs.

[[File:ScriptingBoxNodes1.png]]

The Gaffer docs have a page covering [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html Box nodes and how to use them]. In this guide we take a quick look at how to re-create a simple GroundPlane tool made in the UI, using only Gaffer’s python API.

{{ warning | This guide assumes you are familiar with working with Box nodes in the UI, including [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html#promoting-and-demoting-a-plug promoting plugs] and how [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html#connecting-a-box-to-the-main-graph in/out nodes work]. You also need to be comfortable with using [http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithThePythonScriptingAPI/TutorialNodeGraphEditingInPython/index.html Gaffer’s Python API to work with the node graph].
}}

== Introduction ==
[[File:ScriptingBoxNodes2.png|thumb|The internal network we'll create within the GroundPlane box.]]
For those reading who have used the Plane node. Its ‘z-up’ orientation is less than helpful if you just want a bit of ground for some reason or another. It is also tiny.

Here we’re going to make a simple box that encapsulates the network shown to the right so that you can add a plane with the right orientation to your scene. Exposing a few useful plugs to make it easy to tweak.

== The script ==
All of the code below can be run directly in the Python Editor. Let start first by importing a few pre-requisites we’ll need later:
<syntaxhighlight lang="python">
import Gaffer
import GafferScene
import imath
</syntaxhighlight>

=== Making the Box ===
The box node, as with all Gaffer nodes, is made by literally constructing an instance of the Box class and adding it to the graph. In this script, we’ll just put it at the root. In a real tool, you’d probably wan’t to use [https://github.com/GafferHQ/gaffer/blob/main/python/GafferUI/EditMenu.py#L91-L97 GafferUI.EditMenu.scope()] to get the root visible in the user’s Graph Editor.

<syntaxhighlight lang="python">
box = Gaffer.Box( "GroundPlane" )
root.addChild( box )
</syntaxhighlight>

{{ tip | As this is a script and we don’t know what nodes may already be in the graph, when creating new nodes, we work with the node instance directly rather than adding it to it’s parent and using the parent["NodeName"] syntax. The latter works in simple cases, but if there is already a node with that name, the new one will be renamed, so the sub-script syntax would give the existing node, not your new one! }}

=== The internal network ===
We need a Plane, to set some non-default values so it’s more useful, freeze it’s transform and use a Parent node to insert it into the incoming scene. Make these nodes, connect them up and add them to the Box:
<syntaxhighlight lang="python">
plane = GafferScene.Plane( "Plane" )
plane["transform"]["rotate"].setValue( imath.V3f( -90, 0, 0 ) )
plane["dimensions"].setValue( imath.V2f( 100, 100 ) )
plane["name"].setValue( "ground" )

freeze = GafferScene.FreezeTransform( "FreezeTransform" )

# Note, don't confuse 'parent' here with the built-in variable
# available in Python expressions. This is just a local holding
# our 'Parent' node (I should have used a less confusing example!)

parent = GafferScene.Parent( "Parent" )

freeze["in"].setInput( plane["out"] )
parent["child"].setInput( freeze["out"] )

box.addChild( plane )
box.addChild( freeze )
box.addChild( parent )
</syntaxhighlight>

=== Promoting plugs ===
We now have our network inside the box, but the box has no input or output. We can use the Gaffer.BoxIO node’s static promote method to promote the in/out plugs on the Parent node, as a user might do using the right-click menus in the UI:
<syntaxhighlight lang="python">
Gaffer.BoxIO.promote( parent["in"] )
Gaffer.BoxIO.promote( parent["out"] )
</syntaxhighlight>
You can use exactly the same function to promote plugs that appear in the Node Editor instead of in the Graph Editor (they’re all just plugs after all). BoxIO.promote preserves the plugs existing metadata, which is what controls where they’re presented, so it knows whether they should be on the top or bottom or sides of the box.
<syntaxhighlight lang="python">
Gaffer.BoxIO.promote( plane["name"] )
Gaffer.BoxIO.promote( parent["parent"] )
Gaffer.BoxIO.promote( plane["divisions"] )
Gaffer.BoxIO.promote( plane["dimensions"] )
</syntaxhighlight>
The promote() method takes care of creating, connecting and configuring BoxIn/ BoxOut nodes and plugs on the Box itself. You don’t need to manually manage these.

You should now have a functional Box just like the one made in the UI.

=== Disabling the node (a.k.a finding inputs and outputs). ===
In order to allow a user to disable/bypass the Box, we need to provide a pass-through connection ([http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html#setting-up-a-box-for-pass-through explained here]) that defines what to output when the Box is disabled. To do this, we’ll need to get the BoxIn and BoxOut nodes so we can connect the boxOutNode["passThrough"] plug to the boxInNode["out"] plug.

{{ info | Hang on, you said "out" on the BoxIn node? Don’t you mean "in"?

To understand this, we’ll have to look at a few details of how Box nodes work. A box node has in/out plugs. When you look at the box node from the outside you are looking at plugs on the box node itself. But you also want to see them when you’re looking at the graph inside the box so you can hook things up.

As its Gaffer, and we try to keep the fundamentals simple and consistent. Rather than invent something new and esoteric, the BoxIO code you used earlier creates child nodes that are either BoxIn or BoxOut to represent the box’s input/output plugs when viewing the graph inside the box in the Graph Editor and connects these from/to the box’s actual inputs and outputs so data can flow from outside, to inside and back again, ie:

[[File:ScriptingBoxNodes3.png]]

As they’re __ prefixed (ie: private plugs), you don’t see these ‘bridging’ plugs and connections in the UI (it’d just be confusing too).

The name of these internal nodes also determines the name of the plug on the outside of the box – which works well as these plug names need to be unique.

So, you need the out plug of the BoxIn node as thats the plug that’s visible when looking at the inside of the box, that carries the data from the in plug on the outside of the box. }}

Back, to connecting up the passthrough. There are a couple of ways to find the plugs to do this.

=== Getting the I/O nodes for an existing box ===
In this simple case, the Box node in plug is connected to its child BoxIn node, and it’s out plug is connected from it’s child BoxOut node. A such, you can use the following:
<syntaxhighlight lang="python">
boxInNode = box["in"].outputs()[0].node()
boxOutNode = box["out"].getInput().node()
boxOutNode["passThrough"].setInput( boxInNode["out"] )
</syntaxhighlight>

=== A safer route ===
The above works, but relies on knowing the correct names for the input/output plugs on the box. If you’ve promoted several inputs and outputs, they have to have unique names so they might not be what you think.

When you promote a plug using Gaffer.BoxIO.promote() it returns the corresponding plug on the outside of the box. So we could amend our promotion code to the following:
<syntaxhighlight lang="python">
boxInPlug = Gaffer.BoxIO.promote( parent["in"] )
boxOutPlug = Gaffer.BoxIO.promote( parent["out"] )

# Add a passthrough
boxOutNode = boxOutPlug.getInput().node()
boxInNode = boxInPlug.outputs()[0].node()
boxOutNode["passThrough"].setInput( boxInNode["out"] )
</syntaxhighlight>

You could also go backwards, from the '''parent''' node:
<syntaxhighlight lang="python">
boxOutNode = parent["out"].outputs()[0].node()
boxInNode = parent["in"].getInput().node()
</syntaxhighlight>
== Box Icons ==
By default, Box nodes are drawn with a ‘box’ icon. When you change this in the UI Editor, it simply edits the node’s metadata. You can do the same yourself if you want to remove (or change) the icon:
<syntaxhighlight lang="python">
# remove
Gaffer.Metadata.registerValue( box, 'icon', None )
# change
Gaffer.Metadata.registerValue( box, 'icon', 'grid.png' )
</syntaxhighlight>
{{ info | NOTE: Images specified by a relative path need to be on $GAFFER_IMAGE_PATHS. }}

== Useful links ==
[http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithTheNodeGraph/BoxNode/index.html# Box node introduction]

[http://www.gafferhq.org/documentation/{{latestGafferVersion}}/WorkingWithThePythonScriptingAPI/TutorialNodeGraphEditingInPython/index.html Working with the Node Graph scripting tutorial]

[https://github.com/GafferHQ/gaffer/blob/main/include/Gaffer/BoxIO.h The BoxIO module]

[https://github.com/GafferHQ/gaffer/blob/main/python/GafferUI/EditMenu.py#L91-L97 Finding the ‘current’ graph root with GafferUI.EditMenu.scope()]

== The final script ==
<syntaxhighlight lang="python" line>
import Gaffer
import GafferScene
import imath

# The box

box = Gaffer.Box( "GroundPlane" )
Gaffer.Metadata.registerValue( box, 'icon', None )
root.addChild( box )

# Internal network

plane = GafferScene.Plane( "Plane" )
plane["transform"]["rotate"].setValue( imath.V3f( -90, 0, 0 ) )
plane["dimensions"].setValue( imath.V2f( 100, 100 ) )
plane["name"].setValue( "ground" )

freeze = GafferScene.FreezeTransform( "FreezeTransform" )

parent = GafferScene.Parent( "Parent" )

freeze["in"].setInput( plane["out"] )
parent["child"].setInput( freeze["out"] )

box.addChild( plane )
box.addChild( freeze )
box.addChild( parent )

# Promote i/o
boxInPlug = Gaffer.BoxIO.promote( parent["in"] )
boxOutPlug = Gaffer.BoxIO.promote( parent["out"] )

# Promote useful Node Editor plugs
Gaffer.BoxIO.promote( plane["name"] )
Gaffer.BoxIO.promote( parent["parent"] )
Gaffer.BoxIO.promote( plane["divisions"] )
Gaffer.BoxIO.promote( plane["dimensions"] )

# Add a passthrough
boxOutNode = boxOutPlug.getInput().node()
boxInNode = boxInPlug.outputs()[0].node()
boxOutNode["passThrough"].setInput( boxInNode["out"] )
</syntaxhighlight>

Installing Gaffer on AWS with EC2 Image Builder

2024-07-22T17:25:15Z

Murraystevenson:

This is a guide to setting up Amazon Web Services EC2 Image Builder with Gaffer. The EC2 Image Builder is a service from AWS that allows you to create an '''AMI''' (Amazon Machine Image) for use with EC2 with all the software and configuration needed to run jobs on AWS. An '''EC2 instance''' is a preset configuration of processor, memory and network resources made available by AWS - the virtual equivalent of hardware. An EC2 instance needs to be launched with an AMI that defines the virtual machine that will be running - the operating system and installed software.

This guide is intended for users with some AWS knowledge but not expert level. After completing this guide, you will have a Linux-based EC2 AMI available to your AWS users that can be run on any EC2 instance type for running Gaffer tasks, optionally including Arnold rendering. These instances can be launched manually through the AWS management console, via Python scripts or the AWS terminal, or from applications like Thinkbox's Deadline.

=== Overview ===
The EC2 Image Builder is split into a number of different parts. We need to work with three of those to create our Gaffer image. [https://docs.aws.amazon.com/imagebuilder/latest/userguide/start-build-image-pipeline.html '''Image Pipelines'''] are run to create the AMI. With Image Pipelines, you determine the schedule with which it will be run (likely Manual for our purposes) and the Image Recipe that will be used to create the AMI.

An '''[https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-recipes.html Image Recipe]''' consists the the base image AMI that will be the starting point for the new AMI, optional additional storage to attach to the instance and a set of components that define the software to be installed.

A '''[https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-components.html Component]''' is a YAML script describing the set of steps to be performed to install and configure some logical unit of software.

Image Recipes and Components are both versioned. When you save, that version becomes immutable and you will create a new version when making changes or fixes.

This guide will show you how to create Components that can be used to install any version of Gaffer and Arnold through the use of Component parameters. This means you can only have one version of Gaffer and Arnold installed on your AMI. Alternatively, you could create a new Component for each version of Gaffer / Arnold then choose multiple components to install on the same AMI.

=== Getting Started ===
To start, log into the AWS Console. Pay attention to the region you have set - this setting is in the top-right of the console. The EC2 Image Builder components as well as the generated AMIs (and therefore the EC2 instances you launch with them) are unique per-region.

Choose EC2 Image Builder from the Services menu in the top-left. You can navigate between Image Pipelines, Image Recipes and Components from the left-side menu.

=== Gaffer Component ===
From the navigation menu, choose Components to see a list of your customized components, which is empty if this is your first time using it.

# Choose "Create component".
# Keep "Component type" set to <code>Build</code>
# Set the Component Details
## Choose <code>Linux</code> as the "Image operating system". This indicates this recipe is compatible with Linux-based Image Pipelines. You determine the operating system for your AMI in the Image Recipe configuration.
## From "Compatible OS Versions", choose the Linux versions you intend for this recipe to be compatible with.
## Enter a Component name and optionally a description.
## Enter a Component version, such as <code>1.0.0</code>
# Set the Content. This is the YAML script that will be run to install Gaffer. The YAML script below will setup Gaffer.
# Finally, choose "Save Component" at the bottom of the screen to save it.

<syntaxhighlight lang="YAML">
name: Gaffer Component
description: Installs software needed for running Gaffer on AWS.
schemaVersion: 1.0

parameters:
- gafferVersion:
type: string
default: '1.4.7.0'
description: 'The Gaffer version to install.'
- gccVersion:
type: string
default: '9'
description: 'The gcc version to target for the Gaffer install.'

phases:
- name: build
steps:
- name: DownloadGaffer
action: WebDownload
inputs:
- source: https://github.com/GafferHQ/gaffer/releases/download/{{gafferVersion}}/gaffer-{{gafferVersion}}-linux-gcc{{gccVersion}}.tar.gz
destination: /opt/gaffer-{{gafferVersion}}/gaffer-{{gafferVersion}}-gcc{{gccVersion}}.tar.gz

- name: ExtractGaffer
action: ExecuteBash
inputs:
commands:
- tar xvzf {{build.DownloadGaffer.inputs[0].destination}} --strip-components=1 -C /opt/gaffer-{{gafferVersion}}
- rm {{build.DownloadGaffer.inputs[0].destination}}
- echo 'GAFFER_ROOT=/opt/gaffer-{{gafferVersion}}' >> .env
- echo 'GAFFER_VERSION={{gafferVersion}}' >> .env

- name: validate
steps:
- name: ValidateGaffer
action: ExecuteBash
inputs:
commands:
- source .env
- $GAFFER_ROOT/bin/gaffer env python -c "print('Gaffer validated')"

</syntaxhighlight>The <code>name</code>, <code>description</code>, <code>schemaVersion</code> and the two items under <code>phases</code> are required. The <code>parameters</code> list is a helpful way of specifying variables. They can be referenced in multiple places, so they make your Components less error-prone. Their value can also be set from within an Image Recipe which makes for much fewer versions of your Component. Without <code>parameter</code> lists, you would need to version up your Component with each Gaffer version.

==== Build Phase ====
The first phase of a component build installs Gaffer. It first downloads Gaffer from the Github release URL. Then it extracts the archive to the <code>/opt</code> directory. Finally, an environment variable is set for other components to locate Gaffer's root directory.

The extraction step makes use of another helpful feature in Component scripts - referencing variables from a previous step. The <code><nowiki>{{build.DownloadGaffer.inputs[0].destination}}</nowiki></code> text indicates that the file path to extract is taken from the <code>DownloadGaffer</code> step of the <code>build</code> phase. This is another way to reduce errors from typos in your script.

Note that starting with Gaffer 1.4, a gcc11 and gcc9 build is available. Which of these archives you use depends on the Linux distribution you use as your base image (see "Choosing a base image below" for more information). If you're running on Amazon Linux 2, you should use the gcc9 build as the sample above does. If you're using the newer Amazon Linux 2023, you should use the gcc11 build.

==== Validate Phase ====
The second phase is for verifying that your installation succeeded. For our purposes, running a short Python script from within Gaffer will prove that the installation succeeded and Gaffer is operable. Implementing this phase helps identify problems before the AMI is created. If any of the validation steps fail, the Image Pipeline will be stopped and an error raised.

=== Arnold Component ===
Creating the Arnold Component is much like the Gaffer Component, with one significant difference. Arnold's installer is not available publicly so you will need to upload it to a location that EC2 Image Builder can access. It should be kept private to your organization, which makes AWS S3 a good solution. '''S3''' is a storage repository you can manually or programmatically upload to. EC2 Image Builder Components have an action for downloading from S3, which makes it easy to incorporate into Components.

# Upload the Arnold Linux archive to a bucket in your S3 storage and note it's URL. It will start with <code>s3://</code>.
# Choose "Create Component" to start a new Component.
# Set the Component details as you did with the Gaffer Component.
# An example Component Content script is below.
<syntaxhighlight lang="YAML">
name: Arnold Component
description: Installs Arnold for AWS.
schemaVersion: 1.0

parameters:
- arnoldVersion:
type: string
default: '7.2.5.3'
description: 'The Arnold version to install.'

phases:
- name: build
steps:
- name: DownloadArnold
action: S3Download
inputs:
- source: s3://hypotheticalinc-image-sources/Arnold-{{arnoldVersion}}-linux.tgz
destination: /opt/arnoldRoot/arnold-{{arnoldVersion}}.tgz

- name: ExtractArnold
action: ExecuteBash
inputs:
commands:
- mkdir /opt/arnoldRoot/{{arnoldVersion}}
- tar xvzf {{build.DownloadArnold.inputs[0].destination}} -C /opt/arnoldRoot/{{arnoldVersion}}
- rm {{build.DownloadArnold.inputs[0].destination}}
- echo 'export ARNOLD_ROOT=/opt/arnoldRoot/{{arnoldVersion}}' >> .env

- name: validate
steps:
- name: ValidateGafferArnold
action: ExecuteBash
inputs:
commands:
- source .env
- $GAFFER_ROOT/bin/gaffer env python -c "import GafferArnold;GafferArnold.ArnoldLight()"

</syntaxhighlight>The Arnold component is similar to the Gaffer Component. Instead of downloading from a publicly available Github release, we get the Arnold archive from our S3 upload. This method can be used for other private archives you may need to install, such as non-public Gaffer extensions.

The validation phase once again runs a Python script in Gaffer. Here we simply import <code>GafferArnold</code> and attempt to create an <code>ArnoldLight</code> to verify it is working.

=== Gaffer Prerequisites Component ===
Depending on the which Linux distribution you are using as the base image for your Image Pipeline, you may need some additional packages installed to run Gaffer. The Amazon Linux 2 base image, for example, needs <code>mesa-libGL</code> and <code>mesa-libGLU</code> to run Gaffer tasks. These can be installed with the following Component.<syntaxhighlight lang="YAML">
name: Gaffer Prerequisites
description: Required components to run Gaffer.
schemaVersion: 1.0

phases:
- name: build
steps:
- name: installPackages
action: ExecuteBash
inputs:
commands:
- yum install -y mesa-libGL mesa-libGLU
</syntaxhighlight>

=== Image Recipe ===
With your Components defined, you can now create the Image Recipe for generating your AMI. Choose "Image Recipes". The Recipe list will be empty if you haven't created on yet.

# Choose "Create image recipe".
# Enter a name for your Recipe and optionally a description.
# Enter a version number, such as <code>1.0.0</code>.
# Select an AMI to use as the base image for the Recipe. See the section below for more information about choosing a base image.
# Enable your <code>Gaffer</code>, <code>Arnold</code> and <code>GafferPrerequisites</code> Components you created above. You may need to change the search filter to <code>Owned by me</code>.
# As you enable each Component, it will be added to the "Selected Components" section.
# The Components will be added in the order they are listed. Make sure the <code>GafferPrerequisites</code> Component is first, followed by <code>Gaffer</code> and then <code>Arnold</code>. If they are not in the correct order, validation will fail.
# You can modify the version number to install in the "Selected Components" section. This is also where you can change the installed versions when making a new version of this Image Recipe for future releases.
# It is also a good idea to change the "Versioning Options" of your Components to <code>Use latest available component version</code>. This will ensure the latest component is used without needing to create new Image Recipe versions each time a Component is modified. Using the version variables in your Component allows you to update new software versions without needing to change the Component, only the Recipe.
# If you need to attach additional storage, you can do that in the "Storage (volumes)" section. This can be useful for storing assets on the instance.
# Choose "Create Recipe" to complete the Recipe.

==== Choosing a base image ====
The base image is the AMI that will be used as the starting point for your customized AMI. It is booted first, your components are added to it, and a snapshot is taken to be used as your custom AMI.

The Image Recipe creation wizard allows you to choose a variety of standard Linux distributions, images you've subscribed to from the AWS Marketplace, or a manually entered AMI ID.

If you are using Deadline, entering an AMI ID can be helpful for identifying the AMI provided by AWS / Thinkbox that has the needed Deadline components preinstalled. One way of finding this ID is to launch a Deadline worker from the AWS Portal in the Deadline Monitor. There are various options for AMIs with DCC software preinstalled. You can choose the generic Linux worker for a clean base AMI. Once the machine has started, go to your EC2 Instances in the AWS Web Console, locate the running instance and note its AMI ID.

=== Image Pipeline ===
The final step is to create an Image Pipeline. Choose Image Pipelines from the navigation menu to see the list of Pipelines, which is empty if this is your first time using it.

# Choose "Create Image Pipeline" to get started.
# Enter a name for the pipeline and optionally a description.
# Change the schedule option to "Manual" so it will only run when you trigger it.
# Proceed to the next step, to configure the Recipe.
# Choose the Recipe you created above.
# Proceed through the remaining wizard screens, accepting the default values.
When you are finished, refresh the Image Pipeline list. Select your new Pipeline and choose "Run Pipeline" from the "Actions" menu. Choosing the Pipeline in the list will take you to a list of Pipeline runs, your new submission should be in the <code>Building</code> status.

Once the image has been built and validated, it will be available in your EC2 AMI list for use!

=== Debugging ===
If your AMI is not successfully built, you can view the log stream for a detailed description of the steps EC2 Image Builder performed, including the results of your Component validation steps. This can be useful for finding what went wrong and making corrections to your Components.

=== Updating Installed Versions ===

# Select your Image Recipe.
# Choose "Create new version".
# Enter the new version numbers in the Component settings.
# Either create a new Image Pipeline for your new Image Recipe, or modify the existing Image Pipeline to use it in place.

=== GafferDeadline Component ===
Though it isn't necessary for using Gaffer on AWS, if you are using Deadline to queue jobs to AWS, you will also need to have GafferDeadline installed. The following script can be used as a Component for GafferDeadline.<syntaxhighlight lang="YAML">
name: GafferDeadline Component
description: Installs GafferDeadline for AWS.
schemaVersion: 1.0

parameters:
- gafferDeadlineVersion:
type: string
default: '0.58.0.0b2'
description: 'The GafferDeadline version to install.'

phases:
- name: build
steps:
- name: DownloadGafferDeadline
action: WebDownload
inputs:
- source: https://github.com/hypothetical-inc/GafferDeadline/archive/refs/tags/{{gafferDeadlineVersion}}.tar.gz
destination: /opt/GafferDeadline/gafferDeadline{{gafferDeadlineVersion}}.tar.gz

- name: ExtractGafferDeadline
action: ExecuteBash
inputs:
commands:
- tar -xvzf {{build.DownloadGafferDeadline.inputs[0].destination}} --strip-components=1 -C /opt/GafferDeadline
- rm {{build.DownloadGafferDeadline.inputs[0].destination}}

- name: validate
steps:
- name: ValidateGafferDeadline
action: ExecuteBash
inputs:
commands:
- source .env
- export GAFFER_EXTENSION_PATHS=/opt/GafferDeadline
- $GAFFER_ROOT/bin/gaffer env python -c "import GafferDeadline;print(help(GafferDeadline))"

</syntaxhighlight>

Adding Presets to Global Context Variables

2024-07-22T17:23:14Z

Murraystevenson:

Global context variables can be useful for ensuring a context variable is always accessible and set for the entire script. Unless it is overridden by a [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariables.html ContextVariables] or [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariableTweaks.html ContextVariablesTweaks] node in the node graph, all nodes will have access to the same global context variable. There are some global context variables added by Gaffer by default when creating a new script. You can see these, and add your own, from the <code>Variables</code> tab in the <code>Settings</code> dialog accessed from the <code>File.Settings</code>menu item.

The default user interface for a global context variable can be useful for many situations, but like all plugs in Gaffer, it is possible to customize how the plugs for global context variables are presented to the user. One such customization is adding presets for the user to choose from. This ensures only valid values can be assigned to the context variable. This guide will describe how to add presets to the widget controlling a global context variable.

=== Adding Presets to the <code>Settings</code> Dialog ===
Presets can be added to plugs in the <code>Settings</code> dialog by assigning metadata to the value plug for a global context variable. There are three steps to adding the needed metadata.

==== Identify the target plug ====
Before we assign metadata, we need to identify which plug represents the context variable you want to add presets to. Global context variables are stored in the <code>variables</code> child of the script node. In the Python editor, these are accessed by <code>root["variables"]</code>.

The entries in <code>root["variables"]</code> are of the type <code>NameValuePlug</code>. These plugs themselves have three child plugs: <code>name</code>, <code>enabled</code> and <code>value</code>. The <code>name</code> plug sets the name of the context variable and the <code>value</code> sets the value of the variable. The <code>enabled</code> plug is used to enable or disable the variable. Note that the value of <code>name</code> may be different from the name of the actual <code>NameValuePlug</code>.

To determine which child of <code>root["variables"]</code> you want to add metadata to, loop through all the children of <code>root["variables"]</code> checking the value of the <code>name</code> plug until you find the variable. The corresponding <code>value</code> child plug will be the plug we add metadata to.

==== Set the widget type ====
Next we need to tell Gaffer to use a presets dropdown widget for our value plug. That is done by setting <code>plugValueWidget:type</code> to <code>"GafferUI.PresetsPlugValueWidget"</code> : <syntaxhighlight lang="python">
Gaffer.Metadata.registerValue( variablePlug, "plugValueWidget:type", "GafferUI.PresetsPlugValueWidget" )
</syntaxhighlight>

==== Set the preset names and values ====
Now we add the presets themselves. This can be done in one of two ways. You can add a metadata entry starting with <code>preset:</code> followed by the display string of your preset set to the preset value. For example, <code>Gaffer.Metadata.registerValue( variablePlug, "preset:Shot 1004", "shot1004")</code>will create a preset showing in the UI as <code>Shot 1004</code>. When the user chooses that preset, the actual value of the context variable will be <code>shot1004</code>.

The second method sets all of the preset names and all of the values in one step each. This can be done by setting the <code>presetNames</code> metadata entry to a Cortex string vector (<code>IECore.StringVectorData</code>)holding all of the preset names. Setting <code>presetValues</code> to a Cortex vector of some type, such as <code>IECoreStringVectorData</code> or <code>IECoreFloatVectorData</code>.<syntaxhighlight lang="python">
Gaffer.Metadata.registerValue( variablePlug, "presetNames", IECore.StringVectorData( presetNames ) )
Gaffer.Metadata.registerValue( variablePlug, "presetValues", IECore.StringVectorData( presetValues ) )
</syntaxhighlight>

==== Resetting the <code>Settings</code> dialog ====

Note that the <code>Settings</code> UI is built once and then reused for subsequent showings. This means after adding presets, you need to force Gaffer to refresh the <code>Settings</code> dialog. You can force Gaffer to rebuild the <code>Settings</code> dialog by running the following code in the Python editor:<syntaxhighlight lang="python">
sw = GafferUI.ScriptWindow.acquire(root)
for window in sw.childWindows():
if hasattr( window, "_settingsEditor" ) :
sw.removeChild(window)
</syntaxhighlight>

Once you have registered the metadata for a plug in this way, it will be saved with the script so there is no need to register the metadata again.

==== Example Script ====

The following script is an example of all of the above steps condensed into a reusable function for adding presets for a global context variable.
<syntaxhighlight lang="python">
# Sets the preset names and values for a global context variable.
# `scriptNode` is the script node which you want to set global context variables for.
# `variableName` is the name of the variable to set presets for.
# `presetNames` is a list of strings to set the preset names to.
# `presetValues` is an `IECore.*VectorData` holding a list of preset values
# for each corresponding item in `presetNames`
def globalContextPresets( scriptNode, variableName, presetNames, presetValues ) :
if len( presetNames ) != len( presetValues ) :
raise ValueError( "`presetNames` and `presetValues` must be the same length" )

# Find the value plug for `variableName` global context variable.
variablePlug = None
for p in scriptNode["variables"] :
if p["name"].getValue() == variableName :
variablePlug = p["value"]
break

if variablePlug is None :
raise RuntimeError( "\"{}\" not found in global context variables".format( variableName ) )

# Set the widget to a presets dropdown.
Gaffer.Metadata.registerValue( variablePlug, "plugValueWidget:type", "GafferUI.PresetsPlugValueWidget" )

# Register the names and values.
Gaffer.Metadata.registerValue( variablePlug, "presetNames", IECore.StringVectorData( presetNames ) )
Gaffer.Metadata.registerValue( variablePlug, "presetValues", presetValues )

# Set the value to the first preset.
variablePlug.setValue( presetValues[0] )

# Tell Gaffer to rebuild the `Settings` dialog.
sw = GafferUI.ScriptWindow.acquire( scriptNode )
for window in sw.childWindows():
if hasattr( window, "_settingsEditor" ) :
sw.removeChild(window)
</syntaxhighlight>For example, to set a few presets for a global context variable named <code>shot</code> run the script above in the Python editor, then run the line below.<syntaxhighlight lang="python">
globalContextPresets( root, "shot", ["shot A", "shot B", "shot C"], IECore.StringVectorData( [ "shotA", "shotB", "shotC" ] ) )
</syntaxhighlight>

Template:LatestGafferVersion

2024-07-18T00:05:01Z

Murraystevenson:

1.4.9.0

UV camera projection

2024-07-09T23:03:01Z

Murraystevenson:

{{Example
|description=Example of using a MapProjection node to project a new UV set from camera.
|nodes=Camera, MapProjection
|file=MapProjectionExample.gfr
|screenshots=MapProjectionScreenshot.png
}}

Shortcuts and UI Interactions

2024-07-05T00:38:13Z

Murraystevenson:

This page provides examples of shortcut usage and UI interactions. A comprehensive list of shortcuts can be found in the [http://www.gafferhq.org/documentation/{{LatestGafferVersion}}/Interface/ControlsAndShortcuts/index.html Controls And Shortcuts] page of the Gaffer documentation.

=== Manipulators ===
[[File:GafferManipulatorScale.gif|frame|Manipulator size can be decreased with <code>-</code> and increased with <code>=</code>.|none]]
[[File:RotateManipHotkeys.gif|frame|Hold <code>Shift</code> while rotating to make precise adjustments. Hold <code>Ctrl</code> to step in 30 degree increments.|none]]
[[File:SnapToObjectInViewer.gif|frame|Hold <code>V</code> with the translate or rotate tools enabled to snap or aim at the point clicked.|none]]
[[File:MultiSelectSnapTo.gif|frame|Holding <code>V</code> to snap and aim also works with multiple selected objects.|none]]
=== Expressions and the Python Editor ===
[[File:PlugDragDropPythonEditor.gif|frame|Drag a plug from the Node Editor into the Python Editor for easy access.|none]]
[[File:ExpressionPlugDragDrop.gif|frame|Drag a plug into the expression editor to access the plug’s value.|none]]
=== Editing Plug Values ===
[[File:GangPlugs.gif|frame|Gang plug values together with <code>Ctrl</code> + <code>G</code>.|none]]
[[File:GafferPlugMath.gif|frame|Math operators can be used to edit plug values.|none]]
[[File:VirtualSliders.gif|frame|Edit plug values by holding <code>Ctrl</code> or <code>Ctrl</code> + <code>Shift</code> and click-dragging left or right.|none]]
[[File:CursorValueIncrement.gif|frame|Edit plug values with the <code>Up</code>, <code>Down</code>, <code>Left</code>, <code>Right</code> cursor keys.|none]]
=== Viewer ===
[[File:GafferVisualisersMenu.gif|none|frame|Adjusting visualiser scale in the Viewer.]]
[[File:CameraCopyFromViewer.gif|frame|Copy camera position from the Viewer.|none]]
[[File:SelectionMasking.gif|frame|Use selection masking to limit what is selectable in a Viewer.|none]]
[[File:SelectionTool.mp4|description=Selection tool modes allowing selection based on attributes such as usd:kind.]]
</br>
[[File:HighlightPlacement.mp4|description=Place highlights with the Light Tool's Highlight mode.]]
=== Graph Editor ===
[[File:ConnectToBookmark.gif|none|Using <code>Connect Bookmark</code> to quickly make connections from bookmarked nodes.|frame]]
[[File:SlashTool.gif|none|frame|Hold <code>X</code> to cut connections between nodes.]]
[[File:SelectAffectedObjects.gif|frame|Use <code>Select Affected Objects</code> to quickly select all objects affected by a filtered node.|none]]
[[File:SelectUpstreamDownstreamNodes.gif|frame|Select upstream nodes with <code>Shift</code>+<code>Alt</code>+<code>Click</code>. Select downstream nodes with <code>Ctrl</code>+<code>Alt</code>+<code>Click</code>.|none]]
[[File:MiddleDragToPin.gif|frame|Middle-drag a node from the Graph Editor to pin it to a Viewer or Editor. <code>N</code> quickly unpins a Viewer or Editor|none]]

Shortcuts and UI Interactions

2024-07-05T00:36:27Z

Murraystevenson:

This page provides examples of shortcut usage and UI interactions. A comprehensive list of shortcuts can be found in the [http://www.gafferhq.org/documentation/{{LatestGafferVersion}}/Interface/ControlsAndShortcuts/index.html Controls And Shortcuts] page of the Gaffer documentation.

=== Manipulators ===
[[File:GafferManipulatorScale.gif|frame|Manipulator size can be decreased with <code>-</code> and increased with <code>=</code>.|none]]
[[File:RotateManipHotkeys.gif|frame|Hold <code>Shift</code> while rotating to make precise adjustments. Hold <code>Ctrl</code> to step in 30 degree increments.|none]]
[[File:SnapToObjectInViewer.gif|frame|Hold <code>V</code> with the translate or rotate tools enabled to snap or aim at the point clicked.|none]]
[[File:MultiSelectSnapTo.gif|frame|Holding <code>V</code> to snap and aim also works with multiple selected objects.|none]]
=== Expressions and the Python Editor ===
[[File:PlugDragDropPythonEditor.gif|frame|Drag a plug from the Node Editor into the Python Editor for easy access.|none]]
[[File:ExpressionPlugDragDrop.gif|frame|Drag a plug into the expression editor to access the plug’s value.|none]]
=== Editing Plug Values ===
[[File:GangPlugs.gif|frame|Gang plug values together with <code>Ctrl</code> + <code>G</code>.|none]]
[[File:GafferPlugMath.gif|frame|Math operators can be used to edit plug values.|none]]
[[File:VirtualSliders.gif|frame|Edit plug values by holding <code>Ctrl</code> or <code>Ctrl</code> + <code>Shift</code> and click-dragging left or right.|none]]
[[File:CursorValueIncrement.gif|frame|Edit plug values with the <code>Up</code>, <code>Down</code>, <code>Left</code>, <code>Right</code> cursor keys.|none]]
=== Viewer ===
[[File:GafferVisualisersMenu.gif|none|frame|Adjusting visualiser scale in the Viewer.]]
[[File:CameraCopyFromViewer.gif|frame|Copy camera position from the Viewer.|none]]
[[File:SelectionMasking.gif|frame|Use selection masking to limit what is selectable in a Viewer.|none]]
[[File:SelectionTool.mp4|description=Selection tool modes allowing selection based on attributes such as usd:kind.]]
[[File:HighlightPlacement.mp4|description=Place highlights with the Light Tool's Highlight mode.]]
=== Graph Editor ===
[[File:ConnectToBookmark.gif|none|Using <code>Connect Bookmark</code> to quickly make connections from bookmarked nodes.|frame]]
[[File:SlashTool.gif|none|frame|Hold <code>X</code> to cut connections between nodes.]]
[[File:SelectAffectedObjects.gif|frame|Use <code>Select Affected Objects</code> to quickly select all objects affected by a filtered node.|none]]
[[File:SelectUpstreamDownstreamNodes.gif|frame|Select upstream nodes with <code>Shift</code>+<code>Alt</code>+<code>Click</code>. Select downstream nodes with <code>Ctrl</code>+<code>Alt</code>+<code>Click</code>.|none]]
[[File:MiddleDragToPin.gif|frame|Middle-drag a node from the Graph Editor to pin it to a Viewer or Editor. <code>N</code> quickly unpins a Viewer or Editor|none]]

File:HighlightPlacement.mp4

2024-07-05T00:35:13Z

Murraystevenson:

Demonstration of the highlight placement mode of the Light Tool

Shortcuts and UI Interactions

2024-07-05T00:32:22Z

Murraystevenson: /* Viewer */

This page provides examples of shortcut usage and UI interactions. A comprehensive list of shortcuts can be found in the [http://www.gafferhq.org/documentation/{{LatestGafferVersion}}/Interface/ControlsAndShortcuts/index.html Controls And Shortcuts] page of the Gaffer documentation.

=== Manipulators ===
[[File:GafferManipulatorScale.gif|frame|Manipulator size can be decreased with <code>-</code> and increased with <code>=</code>.|none]]
[[File:RotateManipHotkeys.gif|frame|Hold <code>Shift</code> while rotating to make precise adjustments. Hold <code>Ctrl</code> to step in 30 degree increments.|none]]
[[File:SnapToObjectInViewer.gif|frame|Hold <code>V</code> with the translate or rotate tools enabled to snap or aim at the point clicked.|none]]
[[File:MultiSelectSnapTo.gif|frame|Holding <code>V</code> to snap and aim also works with multiple selected objects.|none]]
=== Expressions and the Python Editor ===
[[File:PlugDragDropPythonEditor.gif|frame|Drag a plug from the Node Editor into the Python Editor for easy access.|none]]
[[File:ExpressionPlugDragDrop.gif|frame|Drag a plug into the expression editor to access the plug’s value.|none]]
=== Editing Plug Values ===
[[File:GangPlugs.gif|frame|Gang plug values together with <code>Ctrl</code> + <code>G</code>.|none]]
[[File:GafferPlugMath.gif|frame|Math operators can be used to edit plug values.|none]]
[[File:VirtualSliders.gif|frame|Edit plug values by holding <code>Ctrl</code> or <code>Ctrl</code> + <code>Shift</code> and click-dragging left or right.|none]]
[[File:CursorValueIncrement.gif|frame|Edit plug values with the <code>Up</code>, <code>Down</code>, <code>Left</code>, <code>Right</code> cursor keys.|none]]
=== Viewer ===
[[File:GafferVisualisersMenu.gif|none|frame|Adjusting visualiser scale in the Viewer.]]
[[File:CameraCopyFromViewer.gif|frame|Copy camera position from the Viewer.|none]]
[[File:SelectionMasking.gif|frame|Use selection masking to limit what is selectable in a Viewer.|none]]
[[File:SelectionTool.mp4|description=Selection tool modes allowing selection based on attributes such as usd:kind.]]

=== Graph Editor ===
[[File:ConnectToBookmark.gif|none|Using <code>Connect Bookmark</code> to quickly make connections from bookmarked nodes.|frame]]
[[File:SlashTool.gif|none|frame|Hold <code>X</code> to cut connections between nodes.]]
[[File:SelectAffectedObjects.gif|frame|Use <code>Select Affected Objects</code> to quickly select all objects affected by a filtered node.|none]]
[[File:SelectUpstreamDownstreamNodes.gif|frame|Select upstream nodes with <code>Shift</code>+<code>Alt</code>+<code>Click</code>. Select downstream nodes with <code>Ctrl</code>+<code>Alt</code>+<code>Click</code>.|none]]
[[File:MiddleDragToPin.gif|frame|Middle-drag a node from the Graph Editor to pin it to a Viewer or Editor. <code>N</code> quickly unpins a Viewer or Editor|none]]

File:SelectionTool.mp4

2024-07-05T00:14:14Z

Murraystevenson:

Demonstrating using the SelectionTool

Shortcuts and UI Interactions

2024-07-04T00:46:33Z

Murraystevenson: /* Graph Editor */

This page provides examples of shortcut usage and UI interactions. A comprehensive list of shortcuts can be found in the [http://www.gafferhq.org/documentation/{{LatestGafferVersion}}/Interface/ControlsAndShortcuts/index.html Controls And Shortcuts] page of the Gaffer documentation.

=== Manipulators ===
[[File:GafferManipulatorScale.gif|frame|Manipulator size can be decreased with <code>-</code> and increased with <code>=</code>.|none]]
[[File:RotateManipHotkeys.gif|frame|Hold <code>Shift</code> while rotating to make precise adjustments. Hold <code>Ctrl</code> to step in 30 degree increments.|none]]
[[File:SnapToObjectInViewer.gif|frame|Hold <code>V</code> with the translate or rotate tools enabled to snap or aim at the point clicked.|none]]
[[File:MultiSelectSnapTo.gif|frame|Holding <code>V</code> to snap and aim also works with multiple selected objects.|none]]
=== Expressions and the Python Editor ===
[[File:PlugDragDropPythonEditor.gif|frame|Drag a plug from the Node Editor into the Python Editor for easy access.|none]]
[[File:ExpressionPlugDragDrop.gif|frame|Drag a plug into the expression editor to access the plug’s value.|none]]
=== Editing Plug Values ===
[[File:GangPlugs.gif|frame|Gang plug values together with <code>Ctrl</code> + <code>G</code>.|none]]
[[File:GafferPlugMath.gif|frame|Math operators can be used to edit plug values.|none]]
[[File:VirtualSliders.gif|frame|Edit plug values by holding <code>Ctrl</code> or <code>Ctrl</code> + <code>Shift</code> and click-dragging left or right.|none]]
[[File:CursorValueIncrement.gif|frame|Edit plug values with the <code>Up</code>, <code>Down</code>, <code>Left</code>, <code>Right</code> cursor keys.|none]]
=== Viewer ===
[[File:GafferVisualisersMenu.gif|none|frame|Adjusting visualiser scale in the Viewer.]]
[[File:CameraCopyFromViewer.gif|frame|Copy camera position from the Viewer.|none]]
[[File:SelectionMasking.gif|frame|Use selection masking to limit what is selectable in a Viewer.|none]]
=== Graph Editor ===
[[File:ConnectToBookmark.gif|none|Using <code>Connect Bookmark</code> to quickly make connections from bookmarked nodes.|frame]]
[[File:SlashTool.gif|none|frame|Hold <code>X</code> to cut connections between nodes.]]
[[File:SelectAffectedObjects.gif|frame|Use <code>Select Affected Objects</code> to quickly select all objects affected by a filtered node.|none]]
[[File:SelectUpstreamDownstreamNodes.gif|frame|Select upstream nodes with <code>Shift</code>+<code>Alt</code>+<code>Click</code>. Select downstream nodes with <code>Ctrl</code>+<code>Alt</code>+<code>Click</code>.|none]]
[[File:MiddleDragToPin.gif|frame|Middle-drag a node from the Graph Editor to pin it to a Viewer or Editor. <code>N</code> quickly unpins a Viewer or Editor|none]]

File:SlashTool.gif

2024-07-04T00:45:20Z

Murraystevenson:

Demonstration of using the X shortcut to cut connections in the Graph Editor

Shortcuts and UI Interactions

2024-07-04T00:44:02Z

Murraystevenson: /* Graph Editor */

This page provides examples of shortcut usage and UI interactions. A comprehensive list of shortcuts can be found in the [http://www.gafferhq.org/documentation/{{LatestGafferVersion}}/Interface/ControlsAndShortcuts/index.html Controls And Shortcuts] page of the Gaffer documentation.

=== Manipulators ===
[[File:GafferManipulatorScale.gif|frame|Manipulator size can be decreased with <code>-</code> and increased with <code>=</code>.|none]]
[[File:RotateManipHotkeys.gif|frame|Hold <code>Shift</code> while rotating to make precise adjustments. Hold <code>Ctrl</code> to step in 30 degree increments.|none]]
[[File:SnapToObjectInViewer.gif|frame|Hold <code>V</code> with the translate or rotate tools enabled to snap or aim at the point clicked.|none]]
[[File:MultiSelectSnapTo.gif|frame|Holding <code>V</code> to snap and aim also works with multiple selected objects.|none]]
=== Expressions and the Python Editor ===
[[File:PlugDragDropPythonEditor.gif|frame|Drag a plug from the Node Editor into the Python Editor for easy access.|none]]
[[File:ExpressionPlugDragDrop.gif|frame|Drag a plug into the expression editor to access the plug’s value.|none]]
=== Editing Plug Values ===
[[File:GangPlugs.gif|frame|Gang plug values together with <code>Ctrl</code> + <code>G</code>.|none]]
[[File:GafferPlugMath.gif|frame|Math operators can be used to edit plug values.|none]]
[[File:VirtualSliders.gif|frame|Edit plug values by holding <code>Ctrl</code> or <code>Ctrl</code> + <code>Shift</code> and click-dragging left or right.|none]]
[[File:CursorValueIncrement.gif|frame|Edit plug values with the <code>Up</code>, <code>Down</code>, <code>Left</code>, <code>Right</code> cursor keys.|none]]
=== Viewer ===
[[File:GafferVisualisersMenu.gif|none|frame|Adjusting visualiser scale in the Viewer.]]
[[File:CameraCopyFromViewer.gif|frame|Copy camera position from the Viewer.|none]]
[[File:SelectionMasking.gif|frame|Use selection masking to limit what is selectable in a Viewer.|none]]
=== Graph Editor ===
[[File:ConnectToBookmark.gif|none|Using <code>Connect Bookmark</code> to quickly make connections from bookmarked nodes.|frame]]
[[File:SelectAffectedObjects.gif|frame|Use <code>Select Affected Objects</code> to quickly select all objects affected by a filtered node.|none]]
[[File:SelectUpstreamDownstreamNodes.gif|frame|Select upstream nodes with <code>Shift</code>+<code>Alt</code>+<code>Click</code>. Select downstream nodes with <code>Ctrl</code>+<code>Alt</code>+<code>Click</code>.|none]]
[[File:MiddleDragToPin.gif|frame|Middle-drag a node from the Graph Editor to pin it to a Viewer or Editor. <code>N</code> quickly unpins a Viewer or Editor|none]]

Shortcuts and UI Interactions

2024-07-04T00:43:03Z

Murraystevenson: /* Graph Editor */

This page provides examples of shortcut usage and UI interactions. A comprehensive list of shortcuts can be found in the [http://www.gafferhq.org/documentation/{{LatestGafferVersion}}/Interface/ControlsAndShortcuts/index.html Controls And Shortcuts] page of the Gaffer documentation.

=== Manipulators ===
[[File:GafferManipulatorScale.gif|frame|Manipulator size can be decreased with <code>-</code> and increased with <code>=</code>.|none]]
[[File:RotateManipHotkeys.gif|frame|Hold <code>Shift</code> while rotating to make precise adjustments. Hold <code>Ctrl</code> to step in 30 degree increments.|none]]
[[File:SnapToObjectInViewer.gif|frame|Hold <code>V</code> with the translate or rotate tools enabled to snap or aim at the point clicked.|none]]
[[File:MultiSelectSnapTo.gif|frame|Holding <code>V</code> to snap and aim also works with multiple selected objects.|none]]
=== Expressions and the Python Editor ===
[[File:PlugDragDropPythonEditor.gif|frame|Drag a plug from the Node Editor into the Python Editor for easy access.|none]]
[[File:ExpressionPlugDragDrop.gif|frame|Drag a plug into the expression editor to access the plug’s value.|none]]
=== Editing Plug Values ===
[[File:GangPlugs.gif|frame|Gang plug values together with <code>Ctrl</code> + <code>G</code>.|none]]
[[File:GafferPlugMath.gif|frame|Math operators can be used to edit plug values.|none]]
[[File:VirtualSliders.gif|frame|Edit plug values by holding <code>Ctrl</code> or <code>Ctrl</code> + <code>Shift</code> and click-dragging left or right.|none]]
[[File:CursorValueIncrement.gif|frame|Edit plug values with the <code>Up</code>, <code>Down</code>, <code>Left</code>, <code>Right</code> cursor keys.|none]]
=== Viewer ===
[[File:GafferVisualisersMenu.gif|none|frame|Adjusting visualiser scale in the Viewer.]]
[[File:CameraCopyFromViewer.gif|frame|Copy camera position from the Viewer.|none]]
[[File:SelectionMasking.gif|frame|Use selection masking to limit what is selectable in a Viewer.|none]]
=== Graph Editor ===
[[File:ConnectToBookmark.gif|none|thumb|650x650px|Using <code>Connect Bookmark</code> to quickly make connections from bookmarked nodes.]]
[[File:SelectAffectedObjects.gif|frame|Use <code>Select Affected Objects</code> to quickly select all objects affected by a filtered node.|none]]
[[File:SelectUpstreamDownstreamNodes.gif|frame|Select upstream nodes with <code>Shift</code>+<code>Alt</code>+<code>Click</code>. Select downstream nodes with <code>Ctrl</code>+<code>Alt</code>+<code>Click</code>.|none]]
[[File:MiddleDragToPin.gif|frame|Middle-drag a node from the Graph Editor to pin it to a Viewer or Editor. <code>N</code> quickly unpins a Viewer or Editor|none]]

File:ConnectToBookmark.gif

2024-07-04T00:41:22Z

Murraystevenson:

Demonstration of connecting to bookmarked nodes

Shortcuts and UI Interactions

2024-07-04T00:38:43Z

Murraystevenson:

This page provides examples of shortcut usage and UI interactions. A comprehensive list of shortcuts can be found in the [http://www.gafferhq.org/documentation/{{LatestGafferVersion}}/Interface/ControlsAndShortcuts/index.html Controls And Shortcuts] page of the Gaffer documentation.

=== Manipulators ===
[[File:GafferManipulatorScale.gif|frame|Manipulator size can be decreased with <code>-</code> and increased with <code>=</code>.|none]]
[[File:RotateManipHotkeys.gif|frame|Hold <code>Shift</code> while rotating to make precise adjustments. Hold <code>Ctrl</code> to step in 30 degree increments.|none]]
[[File:SnapToObjectInViewer.gif|frame|Hold <code>V</code> with the translate or rotate tools enabled to snap or aim at the point clicked.|none]]
[[File:MultiSelectSnapTo.gif|frame|Holding <code>V</code> to snap and aim also works with multiple selected objects.|none]]
=== Expressions and the Python Editor ===
[[File:PlugDragDropPythonEditor.gif|frame|Drag a plug from the Node Editor into the Python Editor for easy access.|none]]
[[File:ExpressionPlugDragDrop.gif|frame|Drag a plug into the expression editor to access the plug’s value.|none]]
=== Editing Plug Values ===
[[File:GangPlugs.gif|frame|Gang plug values together with <code>Ctrl</code> + <code>G</code>.|none]]
[[File:GafferPlugMath.gif|frame|Math operators can be used to edit plug values.|none]]
[[File:VirtualSliders.gif|frame|Edit plug values by holding <code>Ctrl</code> or <code>Ctrl</code> + <code>Shift</code> and click-dragging left or right.|none]]
[[File:CursorValueIncrement.gif|frame|Edit plug values with the <code>Up</code>, <code>Down</code>, <code>Left</code>, <code>Right</code> cursor keys.|none]]
=== Viewer ===
[[File:GafferVisualisersMenu.gif|none|frame|Adjusting visualiser scale in the Viewer.]]
[[File:CameraCopyFromViewer.gif|frame|Copy camera position from the Viewer.|none]]
[[File:SelectionMasking.gif|frame|Use selection masking to limit what is selectable in a Viewer.|none]]
=== Graph Editor ===
[[File:SelectAffectedObjects.gif|frame|Use <code>Select Affected Objects</code> to quickly select all objects affected by a filtered node.|none]]
[[File:SelectUpstreamDownstreamNodes.gif|frame|Select upstream nodes with <code>Shift</code>+<code>Alt</code>+<code>Click</code>. Select downstream nodes with <code>Ctrl</code>+<code>Alt</code>+<code>Click</code>.|none]]
[[File:MiddleDragToPin.gif|frame|Middle-drag a node from the Graph Editor to pin it to a Viewer or Editor. <code>N</code> quickly unpins a Viewer or Editor|none]]