diff --git a/content/toolsAndResources/nge.md b/content/toolsAndResources/nge.md index ee6252cb6..e1cc2374a 100644 --- a/content/toolsAndResources/nge.md +++ b/content/toolsAndResources/nge.md @@ -131,6 +131,32 @@ When clicking on an empty portion of the graph, the parameters panel will displa ![Options for the graph color, grid, and zoom including save and load actions](/img/tools/nge/ngeOptions.jpg) +## Evaluating Context +Context is a new concept in our tool set introduced by Node Geometry. Context is used to describe the set of data which determines the geometry output at the current node in the graph. When reaching a node that requires context to output geometry in the graph, it evaluates each node that feeds it to determine the geometry to output. This is called **Evaluating context** which always happens at least once for each node that outputs geometry, though it is also possible to require that a node evaluates its context many times. There are times where it is desirable to output geometry once and pass the same geometry to each successive node. Additionally, it is also valid to require a node output unique geometry for each request made by connected nodes. To enable both scenarios, there is a property on all nodes that output geometry called **Evaluate context**. Enabling this property allows the node to pass unique geometry for each request by successive nodes while disabling it ensures the node only ever passes a single geometry to all requests for output. + +In practice, we don't have to set this parameter on each node as the property defaults to enabled. This is because it is common in procedural mesh generation to want to produce a variety of similar - but not identical - instances of geometry. However disabling it on a node in a graph will effectively prevent context from being evaluated more than once on all preceding nodes. To illustrate this, consider the following graph and preview. + +![Graph wired to create 4 boxes at random sizes and positions wired through a merge geometry node](/img/tools/nge/boxEvaluateContext.jpg) + +This example shows that **Evaluate context** is enabled on the `Box` node, all four `Transform` nodes, and the `Merge` node. This means that each node will evaluate its context once for each request for output made by connected nodes. For the `Merge` and `Transform` nodes, context will be evaluated only once even though **Evaluate context** is enabled because each of these nodes is receiving only one request for output from connected nodes. The `Box` node is different in this case as it is receiving four requests for output, one from each `Transform` node. With **Evaluate context** enabled on the `Box` node it will evaluate its context four times, one for each request. Since there is a `Random` node connected to width, height, and depth of the `Box` node, the `Box` node will prompt the `Random` node to generate values four times, resulting in four randomly sized boxes in the preview. If we wanted the boxes to all be the same size, we would make one simple change as illustrated below. + +![Graph wired to create 4 boxes at the same size in random positions wired through a merge geometry node](/img/tools/nge/boxNoEvaluateContext.jpg) + +In this example, the `Box` node has **Evaluate context** disabled, which means that the `Box` node will only evaluate it's context once. While the `Random` node will still generate three different values for width, height, and depth, this is the only time that the nodes connected to the `Box` node will be considered in the graph. Even though there are four requests for output from the `Box` node, since it is only evaluating context once, it will pass the same output to all nodes requesting geometry from it. + +### Performance and Evaluating Context +There are also times where **Evaluate context** should be disabled for performance reasons. If we consider the following graph which is just a slight change from the examples above, we have a `Box` node being instantiated on the vertices of a `Grid` node. + +![Graph wired to create 50 boxes at the same size in in a 10 by 10 grid at random grid locations with evaluate context enabled taking 5 ms](/img/tools/nge/perfEvaluateContext.jpg) + +The data feeding the `Box` node is static and sets the same values for width, height, and depth each time the box node is evaluated. In this case, the `Instantiate on vertices` node will loop through the 10 x 10 grid of vertices and instantiate a box on half of them randomly. This means that the `Box` node, with **Evaluate context** enabled will evaluate the float node feeding the box size and and generate a box 50 times. Even in this very simple example, we can see how that effect can be exponential as a graph gets more complex. In real terms, this graph takes 5 ms to build which can be seen on the `Geometry Output` node. This value will vary as there is some randomness in how long it takes to generate the instances being that it is randomly choosing vertices for instantiation, but this is still a good representation of the time this graph takes. Now let's see the difference if we disable **Evaluate context** on the `Box` node. + +![Graph wired to create 50 boxes at the same size in in a 10 by 10 grid at random grid locations with evaluate context disabled taking 0.4 ms](/img/tools/nge/perfNoEvaluateContext.jpg) + +In this case the `Box` node only evaluates its context once, the first time it is reached in the graph. The `Instantiate on vertices` node still makes 50 requests of the `Box` node, but each time the geometry passed is the one that was first generated and the `Box` node does no further calculation. With this one change we reduce the time to build this graph from 5 ms to 0.4 ms. Again, the time it takes to build the graph varies slightly, but will always build much faster when **Evaluate context** is disabled. + +When creating a graph in node geometry, always determine if each node generating output geometry needs to evaluate its context more than once. There will be times when enabling or disabling this parameter will have no effect on the build time of the graph, but those times will be due to there only being one request for output from connected nodes. However, there can be a significant savings in build time if the data feeding a node is static and output from the node is requested multiple times. Remember that these nodes always default to evaluating their context so the performance from evaluating context will always be at its worst if this property is not intentionally managed when creating a graph. It is always best practice to consider where time can be saved by determining if a node needs to regenerate its output for each request, or if it only needs to compute its output once. + ## Iterating and Debugging When creating `NodeGeometry` in a scene, it can always be edited simply by launching the Node Geometry Editor with the `NodeGeometry` mesh selected in the inspector. The **Edit** button to launch the Node Geometry Editor can be found under the _Node Geometry_ section of the mesh properties which appears right after the _Transforms_ section. diff --git a/content/toolsAndResources/nge/ngeBlocks.md b/content/toolsAndResources/nge/ngeBlocks.md index 183079d91..8a879f264 100644 --- a/content/toolsAndResources/nge/ngeBlocks.md +++ b/content/toolsAndResources/nge/ngeBlocks.md @@ -752,7 +752,7 @@ This function transforms the input geometry using either a custom Matrix or a Ve - **scaling** is an input field for a Vector3 value to be used to set the scale of the geometry. This property is only visible if there is no wire connected to the scaling input. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **value** is connected to a node providing the geometry to be used in the function. @@ -875,7 +875,7 @@ This node generates instances of non-null geometry wired to an input based on th - **scaling** is an input field for a Vector3 value to be used to set the scale of each instance. This property is only visible if there is no wire connected to the scaling input. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **instance** is connected to a node providing a geometry from which to create instances. @@ -897,7 +897,7 @@ This node generates instances of non-null geometry wired to the instance input o - **scaling** is an input field for a Vector3 value to be used to set the scale of each instance. This property is only visible if there is no wire connected to the scaling input. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry** is connected to a node providing a source geometry to distribute instances upon. @@ -919,7 +919,7 @@ This node generates instances of non-null geometry wired to the instance input o - **scaling** is an input field for a Vector3 value to be used to set the scale of each instance. This property is only visible if there is no wire connected to the scaling input. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. - **Remove duplicate positions** is used to prevent instances from being assigned to vertices that share the same position with another vertex in the source geometry. #### Inputs @@ -944,7 +944,7 @@ Note that this node needs to make several ray casts to ensure all instances fall - **scaling** is an input field for a Vector3 value to be used to set the scale of each instance. This property is only visible if there is no wire connected to the scaling input. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry** is connected to a node providing a source geometry to distribute instances upon. @@ -1017,7 +1017,7 @@ These nodes will update connected geometry in one of several ways. It could be a This node creates a collection of up to 10 geometry inputs. When used in conjunction with one of the instantiate nodes, the collection will provide one random geometry from the collection per iteration of the instantiate node. This allows for more randomization when creating a procedural mesh. The collection also provides a unique collection ID to each included geometry to help drive logic within the graph. The collection ID can be accessed with the GeometryInfo node. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry0** can optionally be connected to a node providing a Geometry type. @@ -1060,7 +1060,7 @@ When working with geometry, it is often necessary to create a new UV mapping for A common operation when creating procedural geometry is to merge two or more different meshes. This node will merge up to five geometry inputs into one using a simple merge. This node does not do any type of boolean operation and does not change the vertex lists or UV coordinates at all. If multiple meshes are merged which have different material IDs, a MultiMaterial will be created and assigned to keep the original material breaks of each geometry. When using the Merge node, please note that the advanced property Evaluate Context is disabled by default for performance reasons. If the prior context is not evaluated then any procedural generation of values done before the merge node will be executed only once. If the output of that merge node is then used in any instantiate loop, all instances will be exactly the same. If it is desired that merged geometry built procedurally be unique with each instance, the Evaluate Context property on the Merge node must be enabled. Remember that enabling Evaluate Context on a merge node will increase the time needed to generate the final geometry, so it is important to be prudent on how many nodes must be evaluated before merging, especially if the output of the merge is then used as the source for instancing. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry0** can optionally be connected to a node providing a Geometry type. @@ -1076,7 +1076,7 @@ A common operation when creating procedural geometry is to merge two or more dif There are times when a geometry will have unwelded vertices where multiple vertices occupy the same position. This is common when using glTF files as the specification states that vertices that lie on a UV seam should be split for optimization reasons. If working with geometry that has unwelded vertices that need to be merged, use the optimize node. This node does a simple operation that merges any vertices that share the same position within a certain epsilon. This operation is destructive in that it creates a new triangle list and deletes all vertex parameters other than positions. This means that any mesh that has been optimized will need new normals, tangents, and vertex colors. Typically, the first node connected after an Optimize node would be a ComputeNormals node. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. - **Epsilon** is the radius which defines which vertices will be merged. Any vertices within an epsilon of the current vertex will all be merged into one. #### Inputs @@ -1089,7 +1089,7 @@ There are times when a geometry will have unwelded vertices where multiple verti This node is one of the several which are responsible for defining geometry properties. This node will set the color of each vertex in the geometry according to the Vector4 value provided to the node. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry** is connected to a node providing a Geometry type. @@ -1105,7 +1105,7 @@ This node is one of the several which are responsible for defining geometry prop - **id** is an input field for an Int value to be used to determine the material ID for the geometry. This property is only visible if there is no wire connected to the ID input. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry** is connected to a node providing a Geometry type. @@ -1118,7 +1118,7 @@ This node is one of the several which are responsible for defining geometry prop This node is one of the several which are responsible for defining geometry properties. This node will set the normals of each vertex in the geometry according to the Vector3 value provided to the node. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry** is connected to a node providing a Geometry type. @@ -1131,7 +1131,7 @@ This node is one of the several which are responsible for defining geometry prop This node is one of the several which are responsible for defining geometry properties. This node will set the positions of each vertex in the geometry according to the Vector3 value provided to the node. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry** is connected to a node providing a Geometry type. @@ -1144,7 +1144,7 @@ This node is one of the several which are responsible for defining geometry prop This node is one of the several which are responsible for defining geometry properties. This node will set the tangents of each vertex in the geometry according to the Vector4 value provided to the node. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. #### Inputs - **geometry** is connected to a node providing a Geometry type. @@ -1157,7 +1157,7 @@ This node is one of the several which are responsible for defining geometry prop This node is one of the several which are responsible for defining geometry properties. This node will set the UVs of each vertex in the geometry according to the Vector2 value provided to the node. Using this node, a new UV set can be saved to any of the six available UV sets that the engine supports. Simply choose which set is desired in the Texture coordinates index property to assign the UV coordinates to that set. #### Advanced -- **Evaluate context** is used for optimization in the graph when using successive iterable nodes. If this property is set to true, each iteration in this node will also calculate all looped context feeding this node. If there are several iterable nodes connected in sequence, the calculations become exponential with every iteration of the current node calculating every iteration of the previous node back to the beginning of the chain. This can cause a spike in process time in the graph. Disabling evaluate context will prevent nodes from initiating evaluations of previous context each iteration which will greatly speed up the graph. However, since there may be a case where it is desireable to re-evaluate context with each iteration of a node, this parameter is available to the user and defaults to true. If a graph seems to be taking too long to process, check iterable nodes to see if disabling the evaluation of context will help improve performance. +- **Evaluate context** determines whether any nodes connected after this one can instruct this node to evaluate its context again. There are two considerations to keep in mind here. The first is the importance of this node delivering the same data to each connected node and the second is how much extra processing time is needed to evaluate context again. If it is important that this node return the same data for each connected node, set **Evaluate context** to false or any procedurally generated data feeding this node will generate new data for each connected node. If generating a new data set for each connected node is desireable, set this property to true. This also applies to nodes that loop which will request a new evaluation of the context for each iteration of the loop if this property is set to true. If there are no procedural nodes feeding this one or all procedural nodes are locked, disable this property to optimize build time. There is no reason to evaluate the context if the data feeding this node does not change. As the graph gets more complex and looping nodes nest it quickly becomes apparent that disabling **Evaluate context** improves performance and is recommended where possible. - **Texture coordinates index** is used to define which of the six supported UV sets should be used when writing this UV mapping. #### Inputs diff --git a/public/img/tools/nge/boxEvaluateContext.jpg b/public/img/tools/nge/boxEvaluateContext.jpg new file mode 100644 index 000000000..be12bd63a Binary files /dev/null and b/public/img/tools/nge/boxEvaluateContext.jpg differ diff --git a/public/img/tools/nge/boxNoEvaluateContext.jpg b/public/img/tools/nge/boxNoEvaluateContext.jpg new file mode 100644 index 000000000..94c73908f Binary files /dev/null and b/public/img/tools/nge/boxNoEvaluateContext.jpg differ diff --git a/public/img/tools/nge/perfEvaluateContext.jpg b/public/img/tools/nge/perfEvaluateContext.jpg new file mode 100644 index 000000000..35709bdc3 Binary files /dev/null and b/public/img/tools/nge/perfEvaluateContext.jpg differ diff --git a/public/img/tools/nge/perfNoEvaluateContext.jpg b/public/img/tools/nge/perfNoEvaluateContext.jpg new file mode 100644 index 000000000..cedf5957c Binary files /dev/null and b/public/img/tools/nge/perfNoEvaluateContext.jpg differ