DERIVE MANUAL

Installation

1. Open the package manager in Unity (Window -> Package Manager) and select ‘Packages: My Assets’.

2. Finde Derive in the list and expand it. Click the ‘Download’-button, to download the package. After the download is complete, the click the ‘Import’-button to import it into your project.

3. Unity will open the import dialogue. Make sure, all files are selected and click “Import”.

4. Derive will be installed into your “Assets” folder. The exact path is:

“../Assets/Dogmatic/Derive”

You can move the Asset to another location, it is however recommended that you leave it where it is.

After the import Derive is ready for use.

Editor Overview

The Derive Editor consists of 4 main views:

1. The canvass: This is where you build your node tree.

2. The property view: This view shows the project settings, the export settings and the node settings.

3. The preview area: This view consists of two parts, one for the preview settings and one, that renders a live preview of your current output.

4. The resources area: Here you will find additional resources and useful links.

The layout controls as shown the image above allow you to dynamically adjust, expand and collapse individual views to be able to focus on the parts of the editor that you currently need most.

There are two ways to open the Derive editor.

1. Way:

Inside Unity’s top menu go to “Window” -> “Derive” -> “Launch Editor”. Derive will open without opening a project.

2. Way:

Double-click a project file. The project will open in the Derive editor.

The following chapters will focus on the views, how to navigate and how to use them properly.

Creating Projects

There are two ways to create a new project in Derive.

1. Way:

Inside Unity’s top menu go to “Window” -> “Derive” -> “Launch Editor”. When the Derive Editor has opened, you will be prompted to either create a new project, load an existing one, or select a recently edited project from a list. Click “New Project” in the project manager. Select the folder where you want to save the project file, give it a name and click “Create”. The default folder for new projects is called “My Projects” and is located inside the “Derive”-folder.

2. Way:

Right-click into Unity’s project view and click “Create” -> “Derive Project”. The project will be created at the current path in your project view. Double-click the project file to open it in Derive.

Derive projects have a distinct file icon to easily identify them:

Another way to open a project, is to open Derive first and then clicking “Load” in the top bar. To close a currently open project, click “Close Project” in the top bar.

You can open and edit multiple projects simultaneously. Each project is opened as a tab in Derive.

Saving Projects:

Derive saves the current state of the project whenever changes are made to it. Manual saving is not required.

Views

The Derive editor is organized in four views or areas, as shown in the Editor Overview, whereas every area has it’s specific purpose. This section explains every view, how to navigate it and how to use it.

Canvass

The canvas is the main area of the editor inside which the node tree is built up. When creating a new project, the canvass will be empty except for the Master Node, which is always present in every project and cannot be deleted.

Navigation

The canvass can be navigated as follows:

– Pan the view by holding down the right or the middle mouse button and moving the mouse.

– Zoom in and out by scrolling with the mouse wheel.

Zooming and panning only works while the mouse cursor is inside the canvass.

Nodes

Derive is a node-based editor. Nodes added to the canvass each represent a certain operation performed on a texture. Every operation is performd on a per-pixel-basis. As an example, if using a MATH NODE to multiply a texture by a float value, every pixel of the input is multiplied by the same float. The connection of the nodes creates a system of texture operations that yields the final result.

Nodes are connected via their input and output connectors. Nodes that solely generate or import texture data have no input connector, while the master node has no output connectors. The canvass must be understood as data flow that goes from left to right, or from output to input, never vice versa.

The nodes are organized in categories, each of which is represented by the color of the node header. Seven node categories are available to choose from:

Node Category	Header Color	Description
Data	Red	Data nodes are used to introduce data into the project. The data can range from a simple color to a Texture node that imports a locally saved texture into the project. Data nodes have no input connectors.
Math	Blue	Math nodes perform a variety of mathematical operations on their inputs.
Filters	Yellow	Filter nodes are used to apply filters and effects, as well as to extract data from their inputs.
Generators	Teal	These nodes generate procedural data based on given parameters. Since the data is generated, these nodes have no input connectors.
Texture Operations	Black	Texture operation nodes are used to manipulate textures by treating their pixels as vectors, blending and manipulation of color channels.
Mapping	Orange	Mapping nodes perform basic mapping operations, such as rotation, tiling and offset, as well as seamless mapping and mirroring.
Misc	Bool	Additional nodes for offer operations that can help organize the node tree.

Within a project nodes handle two types of Data:

1. RGBA data is regular texture data. It is characterized as data, for which every color channel of a pixel holds a different value.

2. FLOAT data is also texture data, but is characterized as data for which every color channel of a pixel holds the same value. Thus this data type is always represented by a grayscale texture.

Important:

The data type is solely determined by a node’s output. This means, that a grayscale image can still be characterized as RGBA data. This is important to know, because not all nodes can take both data types as input. The data type outputted by a node is indicated by the color of the connection:

1. FLOAT data connection: grey

2. RGBA data connection: purple

Futher Note:

Within the Editor pixel data can be any float data. The final output however connsists of standardized texture data. This means, that all pixel values are clamped between 0 and 1. It is important to make sure, that no pixel data is outside of this range, to avoid incorrect rendering.

Most nodes provide a preview thumbnail that can be expanded and collapsed. To expand and collapse the preview thumbnail, click on the small triangle at the bottom of a node.

For more detailed information on the individual nodes and their functionality, please see the

Node Reference >>

Placing, Positioning and Connecting Nodes

There are several ways to add nodes to your node tree.

Adding a node directly

Right-click somewhere into the canvass. The Node menu will open and show you the node categories and a search field. Click on the small triangle next to the category name to expand it and list the available nodes. Click on the node you want to add. The node will be added at the current position of the mouse cursor.

Adding a node with connection to another node

If you already have an existing node, you can add another node, that is already connected to it. Left-click on the node’s output connector and drag the mouse holding the mouse button pressed. This will draw a connection from the connector to your mouse cursor. Once you release the mouse button, the node menu will appear and the connection will be awaiting a new node. Select a node as before, to add a node and directly connect it to the previous node.

Using the search function

When you add a node, you don’t always have to look for the right node in the right category. If you already know which node you would like to add, you can use the search bar at the top of the node menu. Type in what you are looking for, the menu will then filter the available options, to accelerate the workflow.

Connecting and disconnecting nodes

Left-click on the node’s output connector and drag the mouse holding the mouse button pressed. This will draw a connection from the connector to your mouse cursor. Bring the cursor to the connector of another node and release the mouse button to establish the connection. You can connect from output to input and vice versa.

Nodes can be disconnected by clicking and holding the left mouse button on the input of a node, that has another node connected to it and move the connection away from the connector. When the mouse button is released, the connection is removed.

Attention: Derive does not allow recursive connections. This means, you can not connect nodes in a way that creates a closed loop. The Editor will prevent such connections.

Moving, Copying and deleting nodes

You can select one or multiple nodes by either

1. Left-clicking on a node.

2. Box-selecting multiple nodes using the left mouse button.

3. Holding down the Ctrl key and then left-click nodes you want to add to the selection.

Selected nodes are highlighted by a green frame around them.

– To unselect all nodes left-click somewhere on the canvass without hitting a node

– To unselect individual nodes, hold down the Ctrl key and unselect individual nodes to remove them from the selection

To move nodes, hold down the left mouse button when the cursor is over a selected node, and drag the mouse. All selected nodes will follow the mouse movement until you release the mouse button.

Nodes can be copied and pasted. Use the following shortcuts to do that:

– Press Ctrl + C to copy nodes to the clipboard.

– Press Ctrl + V to paste nodes from the clipboard to the canvass.

When copy-pasting multiple nodes that are connected with each other, the connections will be copied as well. In case you have two connected nodes that are connected, but you copy only one of the nodes, the pasted node will have no connection.

Nodes can also be copied from one project and pasted to another. To do this, both projects must be opened, each in one tab.

– Press the Del key to delete selected nodes.

All of the above actions can be undone.

Property View

The property view is the area of the editor where project settings and node settings can be found. It is the left side of the editor and can be expanded as well as collapsed. The view ise used to display both, project settings, as well as node settings. When you select a single node in your canvass, the project view will display the settings for that node. Otherwise it will display the project settings for the current project. The property view is vital and the editor can not be used without it.

Project Settings

The project are displayed in the property view, when one of the following conditions is met:

– No node is selected

– The master node is selected

– Multiple nodes are selected

The project settings have the following parameters to adjust:

Property Name	Property Type	Description
Editor Resolution	Enumerator	Select the texture resolution to be used in the editor. This resolution is also used to render the live preview. Increasing this will make the live preview more accurate but will also increase the memory usage and make the editor more demanding.
Export Resolution	Enumerator	Select the texture resolution to be used for the final output. Higher resolutions will require more memory to perform the export.
Albedo	Bool	If the box is checked, Derive will export the Master Node's Albedo input, otherwise it won't.
Output Format	Enumerator	* Select the format of the output texture. Available formats are PNG, TIFF and JPEG.
Normal Map	Bool	If the box is checked, Derive will export the Master Node's Normal Map input, otherwise it won't. The exported normal map will automatically be set to be a normal map in it's import settings.
Output Format	Enumerator	* Select the format of the output texture. Available formats are PNG, TIFF and JPEG.
Displacement Map	Bool	If the box is checked, Derive will export the Master Node's Displacement Map input, otherwise it won't.
Output Format	Enumerator	* Select the format of the output texture. Available formats are PNG, TIFF and JPEG.
Ambient Occlusion Map	Bool	If the box is checked, Derive will export the Master Node's Ambient Occlusion Map input, otherwise it won't.
Output Format	Enumerator	* Select the format of the output texture. Available formats are PNG, TIFF and JPEG.
Specular Map	Bool	If the box is checked, Derive will export the Master Node's Specular Map input, otherwise it won't.
Output Format	Enumerator	* Select the format of the output texture. Available formats are PNG, TIFF and JPEG.
Create Sample Materials	Bool	If the box is checked, Derive will create four materials using the same settings as you have set for the live preview and add the exported textures to them. The materials will use the following shaders: "Unity Standard", "Derive POM" (Parallax Occlusion Mapping), "Derive Tessellated" and "Derive Mobile". **
Output Name	String	Give the output a name. Derive will create a subfolder with the given name and use it as a prefix for the exported textures.
Select Output Folder	Button	Opens a folder dialog to select which folder to save the output to.
Export	Button	Starts the baking process. Exporting textures may take between a few seconds and up to a minute, depending on the size of the node tree and the desired output resolution.

* JPEG files have no alpha-channel. If you have data stored in a texture’s alpha-channel, you must export it in PNG or TIFF format to avoid losing data.

** More information on Derive’s included shaders can be read in chapter 4.3.2.

Node Settings

When a single node is selected, the property view shows the settings for the selected node. Those settings are specific to that node alone. This is how to control what each node does exactly. Some nodes have an operation that does not require changing any parameters, they perform a direct operation, such as getting the square root of an input value.

When selecting a node and showing the node settings in the property view, every node (except the master node) will also show a tab called “Output Preview”. Like the preview thumbnail on the nodes, this area will show a preview of the data that the node outputs given the current settings. Unlike the thumbnail, which is shown at low resolution, the output preview in the property area shows the output in the specified editor resolution.This can be very useful to detect potential artifacts or to simply have a better view at the result and see if there is still something that may be optimized.

Changes made to the node settings are processed instantly and don’t need manual updating. All changes can be undone:

To undo changes to the properties, press Ctrl + Z.

For information on the properties of each node, please see the Derive Node Reference >>

Preview Area

The preview area is located in the top right corner of the editor. It offers all neccessary settings to preview the current results under different lighting settings on different objects and rendered with different shaders. The settings panel is collapsed and can be expanded by clicking the small white triangle on the right side of the area. This chapter will highlight these settings and how to navigate the preview.

The preview area can be resized, expanded and collapsed by left-clicking and holding on the small diagonal lines in the bottom left corner of the preview area, while moving the mouse.

When looking at the preview we can see the preview object. In a new project the preview object is always a plane. The bottom right corner of the preview shows a flashlight gizmo that indicates the current light direction.

Preview Naviation

The navigation of the preview is straight forward. The object can be rotated, as well as the light. Additionally zooming and panning are available to examine details of the current state of the project. Naviation is done solely using the mouse. By clicking and dragging the mouse we can rearrange both the preview object and the light:

– Rotating the preview object: Hold down the left mouse button (LMB) and move the mouse.

– Panning the view: Hold down the right mouse button (RMB) and move the mouse.

– Rotating the light: Hold down the middle mouse button (MMB) and move the mouse.

– Zooming: Scroll using the middle mouse button (MMB)

Preview Settings

Derive offers several preview settings that can be adjusted in the settings panel on the right side of the preview area. The settings allow adjustment of the shader settings used to render the preview, as well as certain camera settings and preview objects. This chapter gives an overview of the available settings.

Property Name	Property Type	Description
Preview Content	Enumerator	Select whether you want to see the current output rendered on a 3D-Object or the individual maps as 2D textures. Default: Three Dimensional
Preview Mesh	Enumerator	Select one of the available preview meshes or select "Custom Mesh" to use a mesh of your own for previewing the result. Available Options: - Plane - UV-Sphere - Torus - Rounded Cube - Cloth 1 - Cloth 2 - Gold Bar - Pipe - Bridge - D-Cube - D-Cylinder - Custom Mesh Default: Plane
Mesh	Object Parameter	Select a mesh from your project to render the current result on. This option is only available when choosing "Custom Mesh" as Preview Mesh. All meshes must have a proper UV-Layout. Without UV-Layout preview rendering will fail.
Reset Transforms	Button	Resets the rotation and position of the preview object, as well as the light rotation.
Rendering Path	Enumerator	Select the desired rendering path of the preview camera. Choose between Forward and Deferred rendering mode. Default: Deferred
Lighting	Enumerator	Select if the preview should feature only basic lighting with directional light only, or if ambient light and ambient reflections are to be considered for a more nuanced rendering of the current output. Default: Directional and Ambient
Preview Shader	Enumerator	Select the shader, that should be used to render the preview. The following options are available: - Unity Standard: Unity's Standard Shader with specular setup. This shader features parallax mapping to render height maps. Using this shader for the preview is useful, if you plan to also use the exported output with Unity's Standard Shader. - Derive POM: Very similar to Unity's Standard shader, but it features parallax occlusion mapping as opposed to simple parallax mapping. - Derive Tessellated: A shader that uses physical vertex displacement and tessellation for height rendering. This shader is the most accurate, but also the least performant. - Derive Mobile: Similar to Derive POM, but using the Blinn-Phong lighting model, instead of PBR-rendering. This shader has a higher performance, which is useful for mobile devices, but the result looks different from the PBR-output. The Mobile Shader does not support Ambient Occlusion. Default: Derive POM
Tiling	Float Input	Set the tiling of the textures on the preview object. The value is automatically applied for all maps. Default: 1
Normal Strength	Float Slider	Set the normal strength property in the shader. Default: 0
Specular Color Source	Enumerator	Select the source of the specularity information. - For Unity's Standard shader: Select whether the specularity information should be read from the alpha channel of either the specular map or the albedo map, that is inputted into the master node. - For Derive's POM and Tessellation shaders: Select whether the specularity information should be read from the alpha channel of the specular map, that is inputted into the master node or whether to use a given uniform specular color. - For Derive's Mobile shader: No Options available due to the lighting model. All specularity is given by a preselected specular color. NOTE: If Specular information is read from a texture, it will ALWAYS be read from the texture's alpha channel! Make sure, the alpha-channel contains the specularity information, by using an "Append"-Node. Otherwise the specular map may seem correct in the node preview, but the live-preview will not render any specularity, as long as the alpha-channel does not contain that information.
Specular Color	Color Picker	Select the specular color. Default: White (Only available with setups that use a uniform specular color) (Not available for Unity's Standard shader)
Gloss	Float Slider	Set the glossiness property in the shader. Default: 0
Displacement	Float Slider	Set the displacement property in the shader. Default: 0
Ambient Occlusion	Float Slider	Set the strength of the ambient occlusion property in the shader. Default: 0 (Not available for Derive's Mobile shader)
Tessellation	Float Slider	Set the value of the tessellation property in the shader. Default: 1 (Only available for Derive's Tessellation shader)

While editing your textures, you may have to change and adjust settings to check if the final output will meet your requirements. Not every texture will rewuire all maps. Surfaces like that of a polished steel will for instance not need physical displacement, while cartoon textures or stylized textures may not require a normal map. Test the settings to get a feeling for what they do and how they impact the look of your textures.

Resource Area

Derive’s resource area is located in the bottom right corner of the editor. It can be expanded and collapsed in conjunction with the preview area. By resizing the preview area, the resource area is automatically resized too. The area is organised in a number of tabs containing resources and useful links. This chapter will explain them.

Tabs

The resources are meant to provide informations on updates and access to Derive’s support and information database. Additional resources, such as patterns and height maps can be accessed from here and imported into existing projects via drag-and-drop. Also it is possible to showcase existing work by sharing it on social media or making it available to the Derive community.

The following table gives an overview of the resource tabs and what they are for. Tabs can be expanded and collapsed by clicking on the small triangle next to the tab name.

Tab	Description
Latest News	This tab contains a feed with latest news from Derive. From here you can access recent news article if you find anything interesting for you. If you would like to continue reading an article, click the "Continue reading"-button beneath the headline. The article will then be opened in your standard web browser. If there are any new articles you have not seen yet, the tab will turn green until expanded.
Share your work	This tab is all about sharing your work with others. Derive attempts to make this as easy as possible. First you can capture the current preview by clicking the "Capture"-button and save it as an image file. You can then share the image on social media or on the Unity forum. Select click one or more of the available services. They will open up in your standard web browser, allowing you to post your newly captured image. You can also submit your work to the Derive content gallery. Here you have additional options of also sharing the maps and the project files. For more information, please click here >>
Knowledge Base	The "Knowledge Base"-tab contains links to Derive's documentation. The following content is available: - Manual (the webpage you are currently on) - Beginner's Guide - Node Reference - Examples & Tutorials Clicking one of the buttons will open the desired content in your standard web browser,
Feedback	The "Feedback"-tab can take you to Derive's Asset Store page, where you can leave a review.
Resources	The "Resources"-tab contains resources in the form of textures. Dogmatic will occasionally publish free resources for use with Derive. These resources will be available for download from the Unity Asset store. The "Resources"-tab has two subtabs: - Available Resources - Download Resources On startup Derive will check if there are any new resource packages available for download. If there are, the tab will turn green until it is expanded. The "Download Resources"-tab shows what resources packages are available for download and which ones of them are already imported. If a resource package is not yet imported, a "Download"-button will appear next to it's name. clicking it will open the package's asset store page in your standard browser. The "Available Resources"-tab will organize imported resources into three additional subtabs: - Patterns - Heightmaps - Albedo Textures Expanding the tabs shows the resources available in each category. They can be imported into the project by dragging and dropping them on the canvass. When doing that, a Data-node that points to the dropped resource will be added to the canvass. Attention: Derive reads resources via their paths and names. Resources are imported into the "Dogmatic"-folder inside the assets folder, where Derive is too. DO NOT RELOCATE OR RENAME THE RESOURCE PACKAGE FOLDERS! If you do, they will disappear from Derive's Resources tab. If you wish to delete a resource package, you can do so by deleting the package's folder.
Help and Support	This tab contains links to the support infrastructure. The following links are available: - FAQ: See if there is a quick answer to your question. - Derive Forum: Ask the community and the publisher for support. - Unity Forum: Same as on the Derive Forum, but on Unity's board. - Issue tracker: See if your issue is a known bug, or submit a report if you think you have found a new bug. - Contact form: Submit a support ticket to Dogmatic to get a direct response. To make things easier you can also capture a screenshot of the Derive editor. At the very bottom of the tab, the button "Capture Editor" will create a screenshot of the editor's current state. This can be very useful when running into an issue, because it allows you to show the state of your project to others and help identify possible issues.
Change Log	This tab contains the change log for the currently installed version, relative to the previous release. At the end of the release notes, the full change log for all releases can be accessed via link.

Exporting Textures

Once the node tree produces the desired result, it must still be exported in order to be baked into local textures and further used. This chapter will explain the nuts and bolts of exporting the final result.

Requirements

In order to be able to export the result, it must be connected to the Master Node’s input. Every input represents a map that can (but does not have to be) exported. The master node has the following input connectors:

Connector Name	Allowed Datatype	Description
Albedo	RGBA & FLOAT	Data connected to this connector will be trated as the albedo of the texture.
Normal Map	RGBA & FLOAT	Data connected to this connector will be trated as the normal map of the texture.
Displacement Map	RGBA & FLOAT	Data connected to this connector will be trated as the displacement map (heightmap) of the texture.
Ambient Occlusion Map	RGBA & FLOAT	Data connected to this connector will be trated as the ambient occlusion map of the texture.
Specular Map	RGBA & FLOAT	Data connected to this connector will be trated as the specular map of the texture.

Selecting the master node will show the project settings and the export settings in the property view. The export resolution is the resolution the exported maps will have.

Attention: Derive will recalculate the entire node tree to produce the result in the desired export resolution. Depending on that resolution, the size of the node tree and the speed of the machine Derive is running on, recalculation may take some time.

In the Export settings there is a checkbox for each map. Those can be used to select which maps to export. Also the output format is selectable for each map individually. The following formats are available:

– PNG (lossless)

– TIFF (lossless)

– JPG (lossy)

If desired, Derive will create four sample materials upon export and add the exported textures to their properties. This can be convenient, if you want to use either Unity’s Standard shader or one of Derive’s included shaders. This feature can be enabled by checking the box that says “Create Sample Materials” in the export settings.

The sample materials will use the same shaders that are available for the live preview and will be given the same settings as in the live preview. This means that the created materials and the exported textures will produce the exact same result, as the live preview with the exception that the exported maps have a higher resolution than those used for the live preview.

Once everything is set up for export, an output name must be given. By default the name is the same as the project name. Clicking “Select Output Folder” will open a folder dialog, where you can select where the exported files are to be saved. Derive will create a subfolder with the specified name and use the same name as a prefix for all maps. If Derive is to create sample materials, it will add a folder called “Materials” inside the subfolder where the ready made sample materials will be stored.

Upon clicking the “Export”-button, Derive will start running through the nodes to recalculate the output with the desired resolution. When this process is finished the final output is saved to the specified location.

Tips & Tricks

As with every tool, there are common practices when using Derive. Some of them are good practice, others not so much. This last chapter will highlight some pitfalls and give some advice on how to best use the editor without losing overview when building a larger node tree. Also it will show some possibilities on how to keep the performance of both the editor as well as the output optimal.

Organizing the Node Tree

Especially when building up larger node trees for more sophisticated surfaces, it can become difficult to keep track of all nodes and operations that the project performs. At a certain point you might see some undesired effect, but have trouble finding the source of it because the node tree has become confusing.

To avoid this, it is important to keep the node tree organized. One way to do this, is to use “getters” and “setters”. Setters are nodes (Set Variable Node) that store their input in such a way that it can be accessed by getters (Get Variable Node). This way, when you have a long sequence of nodes, you can split it up in partial sequences, each performing only one task, such as extracting a normal map from a height map.

Using getters and setters is an elegant way to organize node trees. However be aware that each additional node will produce more load on the editor and excessive use of them may slow down the editor and increase the memory usage. Best practice is to lay out the project in a sensible way to begin with.

Connection Relays

Another handy tool to use when building up complex node trees, are connection relays. They are not to be confused with Derive’s Relay node. While the relay node takes an input and outputs it without changes, the connection relay acts merely as a redirection point for the drawing of a connection in the editor.

Connection relays are best used in situation in which a connection would otherwise cut through nodes, affecting the readability of a node tree. Below you see an example of connection relays in effect.

Placing, moving and removing connection relays is pretty straight forward:

– Move the mouse over a connection.

– When the connection is green, double click on it. A relay will appear where the mouse cursor is.

– Drag the relay to the desired location using the left mouse button.

– Double click on an existing relay to remove it.

– Removing a connection will also remove all of it’s relays.

Getting the best performance

When using the Derive editor, performance may become an issue, depending on what you are looking to achieve. While the editor itself is very light on performance, large node trees can become very demanding in terms of hardware requirements. The key term is memory. Since Derive – unlike layer-based texture editors – is non-destructive, every node produces an output that is preserved throughout the project. Thus larger node trees require more memory.

Also when you have a sequence of nodes and make changes to one of them, each node along the connection that leaves it, has to redo it’s operation to adjust it’s result to the changes you made. this means, that the further at the beginning of a node sequence a node is, the more processing the editor has to do, whenever you make changes to that node. However there are several ways to optimize the performance of the editor.

Avoid unneccessary nodes

As mentioned, more nodes require more memory and cause more processing of data. The obvious solution is to keep the amount of nodes to as few as possible. Of course it is neccessary to have certain node sequences to achieve certain results, but there are also situations in which optimizing and organizing the node tree correctly can drastically reduce the amount of nodes.

In the previous chapter it is shown, how using getters and setters can help make your node tree more readable. However this is something that should only be done for readability, not just because it is possible. As with all other nodes, getters and setters add to the workload of the machine. So while using getters and setters is great for organizing a node tree, one must always keep track of the consequence of having additional nodes and keep getters and setters to a minimum.

If we take the example from the figures in the last chapter, both node trees produce the exact same result, but if we look at the amount of nodes for each tree, we see that the organized node tree has 13 more nodes than the organized one. To make it clearer, let’s compare the absolute amounts of nodes:

The unorganized node tree has 16 nodes, while the organized one has 29 nodes. This means in effect, that the workload of the organized node tree is 81 % higher than that of the unorganized node tree.

Try working with low editor resolutions

As mentioned above, nodes have to reperform their operation, if inputting nodes have changed their output values. The performance impact of these operations are not only determined by the sized of the node tree and the length of the node sequences, but also by the resolution at which the output is created.

In simple terms, the higher the editor resolution, the higher the workload on the machine. This is why the project settings offer two sets of resolutions, one for the editor and one for the final output. Of course sometimes one may want to preview the result at a higher resolution. In such cases it may be tolerable to increase the editor resolution for the sake of previewing the result. However it is not advised to keep working in the editor at that resolution.

While resolutions of 1024 x 1024 pixels may require too much memory for large node trees, a resolution of 256 x 256 pixels may be too low to effectively decide whether the current result is satisfactory or not. Generally a resolution of 512 x 512 pixels for the editor is sufficient in most cases. In some cases you may temporarily need more, however that should not happen too oftern.

Attention:

Using very high resolutions for the exported files may not only take a while to render, it may also need more memory than what is available. In such a case exporting may take even longer, or if the memory excession is extreme, the editor may even freeze. In order to export large node trees at a 4k resolution, it is recommended to have 16 GB of memory or morre.

Choosing the right output formats

Derive allows exporting textures using several formats, the pros and cons of which are highlighted in this chapter. Down below you can see an overview of the available output formats.

Format	Color Space/Model	Description
PNG	RGBA	This is the most common format for high-quality textures. It has an alpha channel, thus every pixel can store 4 values with a color resolution of up to 16 bits per channel. PNG is recommended for high-resolution outputs with little to no loss in quality. It requires a lot of disc space and increases the workload on the rendering hardware.
JPEG	RGB	A lossy compression format without an alpha channel with a bit depth of up to 16 bits per channel, mostly however only 8 bits per channel. This format is ideal for light-weight and low-resolution data. The quality difference between JPEG and lossless formats becomes lower, the lower the resolution. It is the most common format for mobile and web applications, since it requires less disc space and does not add much load to the rendering hardware. The biggest con of the format, is that it does not have an alpha-channel. Since most shaders, including Derive's shader and Unity's shaders, read specularity information from a texture's alpha-channel, JPEG files can not store specularity data, unless it is being used with a custom shader that reads the data from the RGB-Channels. In that case, specularity may be stored in those channels.
TIFF	RGBA, *CMYK (subtractive color model)	The TIFF format is another lossless format with an alpha channel, similar to PNG, with slightly higher quality, but also with drastically increased disc space requirement. It is not as much a texture format, as it is a data container. TIFF can store multiple images within one file. While this may be useful for certain usecases, it is not a practical feature for realtime rendering textures. It is only advised to use this format for high resolution outputs with as little quality loss as possible on machines that offer powerful rendering hardware.
TGA	RGBA	TGA or Targa image file is a rather old - short for 'Truevision Advanced Raster Graphics Array' is a lossless format, that also features lossless run-length-encoding. This is particularly useful for post-editing images and explains why this format is still popular despite having been published in 1984.
EXR	RGBA	EXR is a lossless HDR-format that supports high color ranges. It can store 16 bit values per channel, making it suitable for high-quality graphics. The most obvious downside is the enormous file size, it creates and thus it is not the best choice for applications targeting less powerful machines.
Bitmap	RGB	Bitmaps contain RGB-data. The format uses either uncompressed data, or run-length-encoded data. The rather weak compression method often make Bitmaps larger than PNG-files, despite the fact that they have no alpha-channel. Remarkably however, bitmaps are very quick to access, once loaded to the memory, which makes them quite performant in spite of their size. This probably explains, why they are still popular among game developers.

* Not directly applicable via Derive

When exporting with Derive, you can choose an output format for each map individually. While it is common to use the same format for all maps, it may be a good idea in some cases to use the best suited format for each map. If the output is supposed to have a low resolution, such as 512 by 512 pixels, the best performance-quality-ratio can be achieved using the JPEG format for all maps, except the Specular map, which must have specularity data stored on the alpha-channel. For Specularity maps it is therefore best to export to PNG.

While there may be concerns about the quality of the output when using lossy formats, such as JPEG, the quality loss at low resolutions is usually so low, that it cannot even be seen without thorogh examination. Below you can find a comparison of a normal map exported to lossless PNG (left) and to lossy JPEG (right).

As for the TIFF format and the EXR format, it is recommended to avoid them, unless the output needs to be of the highest possible quality and resolution and unless performance is not an issue.

Table of Contents