From 4adf2fe6460ab82f84a3a8b1ef2562fefc361cfc Mon Sep 17 00:00:00 2001 From: Lewis Jordan Date: Mon, 16 Mar 2020 21:44:42 +0000 Subject: [PATCH 1/6] Reviewed Contexts and terminology. --- .../Documentation~/ComponentAPI.md | 2 - .../Documentation~/Contexts.md | 157 +++++++++--------- .../Documentation~/GettingStarted.md | 2 +- .../Documentation~/GraphLogicAndPhilosophy.md | 12 +- .../Documentation~/Properties.md | 2 +- .../Documentation~/VisualEffectGraphWindow.md | 2 +- 6 files changed, 90 insertions(+), 87 deletions(-) diff --git a/com.unity.visualeffectgraph/Documentation~/ComponentAPI.md b/com.unity.visualeffectgraph/Documentation~/ComponentAPI.md index 1eb461a7982..69114dc49f6 100644 --- a/com.unity.visualeffectgraph/Documentation~/ComponentAPI.md +++ b/com.unity.visualeffectgraph/Documentation~/ComponentAPI.md @@ -1,5 +1,3 @@ -
Draft: The content on this page is complete, but it has not been reviewed yet.
- # Visual Effect component API To create an instance of a [Visual Effect Graph](VisualEffectGraphAsset.md) in a Scene, Unity uses the [Visual Effect component](VisualEffectComponent.md). The Visual Effect component attaches to GameObjects in your Scene and references a Visual Effect Graph which defines the visual effect. This allows you to create different instances of effects at various positions and orientations, and control each effect independently. To control an effect at runtime, Unity provides C# API that you can use to modify the Visual Effect component and set [Property](Properties.md) overrides. diff --git a/com.unity.visualeffectgraph/Documentation~/Contexts.md b/com.unity.visualeffectgraph/Documentation~/Contexts.md index 1334ca0a8aa..54d7c82ca45 100644 --- a/com.unity.visualeffectgraph/Documentation~/Contexts.md +++ b/com.unity.visualeffectgraph/Documentation~/Contexts.md @@ -1,137 +1,142 @@ -
Draft: The content on this page is complete, but it has not been reviewed yet.
# Contexts -Contexts are the main elements of the Graph Workflow logic (vertical) and define the succession and the relationships of operations and simulations. Every context defines one stage of computing, for example computing how many particles need to be spawned, creating new particles or updating all living particles. +Contexts are the main element of the Visual Effect Graph's **processing** (vertical) logic and determine how particles spawn and simulate. The way you organize Contexts on the graph defines order of operation for the processing workflow. For information on the processing workflow, see [Visual Effect Graph Logic](GraphLogicAndPhilosophy.md). Every Context defines one stage of computation. For example a Context can: -Context connect to each other when there is meaning : After creating new particles, an Initialize context can connect to a Update Particle context, or directly to a Output Particle Context to render the particles without simulating them. +* Calculate how many particles the effect should spawn. +* Create new particles. +* Update all living particles. + +Contexts connect to one another sequentially to define the lifecycle of particles. After a graph creates new particles, the **Initialize** Context can connect to an **Update Particle** Context to simulate each particle. Also, the **Initialize** Context can instead connect directly to an **Output Particle** Context to render the particles without simulating any behavior. ## Creating and Connecting Contexts -Contexts are Graph elements, so they can be created using the Right Click > Add Node Menu, Spacebar Menu or by making a workflow (vertical) connection from another context (providing only compatible contexts) +A Context is a type of [graph element](GraphLogicAndPhilosophy.md#graph-elements) so to create one, see [Adding graph elements](VisualEffectGraphWindow.md#adding-graph-elements). -Contexts connect to each other using the Ports at the top and the bottom. +Contexts connect to one another in a vertical, linear order. To achieve this, they use [flow slots](). Depending on which part of the particle lifecycle a Context defines, it may have flow slots on its top, its bottom, or both. ## Configuring Contexts -Adjusting Context [Settings](GraphLogicAndPhilosophy.md#settings) in the Node UI or the Inspector can change the way the Operator looks and behaves. +To change the behavior of the Context, adjust its [settings](GraphLogicAndPhilosophy.md#settings) in the Node UI or the Inspector. -> For instance, Changing the UV Mode of a `Quad Output` Context, from *Simple* to *FlipbookMotionBlend* will add Extra *Flipbook Size*, *Motion Vector Map* and *Motion Vector Scale* Properties to the Context Header. +Some settings also change how the Context looks. For example in a **Quad Output** Context, if you set the UV Mode to **FlipbookMotionBlend**, Unity adds the following extra properties to the Context header: **Flipbook Size**, **Motion Vector Map**, and **Motion Vector Scale**. ## Flow Compatibility -Not all contexts can be connected altogether, in any order. Some rules apply to keep a consistent workflow: +Not all Contexts can connect to one another. To keep a consistent workflow, the following rules apply: -* Contexts connect by compatible input/output data type. -* Events can connect to one or many events / initialize contexts. -* Initialize contexts can have one or many SpawnEvent source or one or many GPUSpawnEvent source, but these data type are mutually exclusive. -* Only One Initialize can be connected to one Update Context -* You can connect any Output Contexts to a Initialize / Update context. +* Contexts only connect to compatible input/output data types. +* [Events](Events.md) can connect to one or many Events or **Initialize** Contexts. +* **Initialize** Contexts can have one or many **SpawnEvent** sources or one or many **GPUSpawnEvent** sources, but these data type are mutually exclusive. +* Only one **Initialize** Context can connect to one **Update** Context. +* You can connect an **Output** Context to an **Initialize** or **Update** Context. - Here is a recap table of the context compatibility: +For a breakdown of context compatibility, see the table below. -| Context | Input Data Type | Output Data Type | Specific Comments | -| ------------------ | ------------------------------------ | ---------------- | ------------------------------------------------------------ | -| Event | None | SpawnEvent (1+) | | -| Spawn | SpawnEvent (1+) | SpawnEvent (1+) | Two input pins, start and stop the spawn context | -| GPU Event | None | SpawnEvent | Outputs to Initialize Context | -| Initialize | SpawnEvent (1+) / GPUSpawnEvent (1+) | Particle (1) | Can output to Particle Update or Particle Output. Input types SpawnEvent/GPUSpawnEvent are mutually exclusive. | -| Update | Particle (1) | Particle (1+) | Can output to a Particle Update or Particle Output | -| Particle Output | Particle (1) | None | Can either have input from an Initialize or Update | -| Static Mesh Output | None | None | Standalone Context | +| Context | Input Data Type | Output Data Type | Specific Comments | +| ---------------------- | --------------------------------------------- | ------------------- | ------------------------------------------------------------ | +| **Event** | **None** | **SpawnEvent** (1+) | **None** | +| **Spawn** | **SpawnEvent** (1+) | **SpawnEvent** (1+) | Has two input flow slots which start and stop the **Spawn** context respectively. | +| **GPU Event** | **None** | **SpawnEvent** | Outputs to **Initialize** Context | +| **Initialize** | **SpawnEvent** (1+) or **GPUSpawnEvent** (1+) | **Particle** (1) | Input types are either **SpawnEvent** or **GPUSpawnEvent**. These input types are mutually exclusive.
Can output to **Particle Update** or **Particle Output**. | +| **Update** | **Particle** (1) | **Particle** (1+) | Can output to a **Particle Update** or **Particle Output**. | +| **Particle Output** | **Particle** (1) | **None** | Can either have input from an **Initialize** or **Update** Context.
No output. | +| **Static Mesh Output** | **None** | **None** | Standalone Context. | # Context Type Overview -This section covers all the common settings of every kind of context. For more details about specific contexts, see [Context Library]() +This section covers all the common settings for every kind of Context. ## Event -Event Contexts only display a Name as a string that need to be called on the Component API in order to Send this event to the graph and activate a workflow from this Node. +Event Contexts only display their name, which is a string. To trigger an Event Context and activate a workflow from it, use the Event Context's name in the [component API](ComponentApi.md). For information on how to do this, see [Sending Events](ComponentApi.md#sending-events). ## Spawn -Spawn Contexts are standalone systems that have three States : Playing, Stopped and Delayed. - -* **Looping** (Running) state means that the Blocks are computed and will perform spawn of new particles -* **Finished** (Idle) state means that the spawn machine is off and will not spawn particles -* **DelayingBeforeLoop/DelayingAfterLoop** (Waiting) state stops spawning particles until the end of a user-set delay, then restarts spawning particles. +Spawn Contexts are standalone systems that have three States: Running, Idle, and Waiting. -Spawn contexts can be customized using compatible **Blocks**. +* **Looping** (Running): This state means that Unity computes the Blocks in the Context and spawns new particles. +* **Finished** (Idle): This state means that the spawn machine is off and does not compute Blocks in the Context or spawn particles. +* **DelayingBeforeLoop/DelayingAfterLoop** (Waiting): This state pauses the Context for the duration of a delay time which you can specify. After the delay, the Context resumes, computes Blocks in the Context, and spawns particles. -You can find Spawn Context API Reference [here](https://docs.unity3d.com/2019.3/Documentation/ScriptReference/VFX.VFXSpawnerLoopState.html). +To customize **Spawn** Contexts, you can add compatible **Blocks** to them. For information on the Spawn Context API, see the [Script Reference](https://docs.unity3d.com/2019.3/Documentation/ScriptReference/VFX.VFXSpawnerLoopState.html). -### Turning On and Off +### Enabling and disabling -Spawn Contexts expose two [Flow Input Slots](GraphLogicAndPhilosophy.md#processing-workflow-vertical-logic): Start and Stop: +Spawn Contexts expose two [flow slots](GraphLogicAndPhilosophy.md#processing-workflow-vertical-logic): **Start** and **Stop**: -- Start input **Resets** and/or **Start** the Spawn System : if not connected, it is implicitly bound to the `OnPlay` [Event](Events.md) . Hitting Start many times has the same effect as pushing it once. -- Stop input **Stops** the Spawn System : if not connected, it is implicitly bound to the `OnStop` [Event](Events.md) +- The **Start** input resets/starts the Spawn Context. If you do not connect anything to this flow slot, it implicitly uses the **OnPlay** [Event](Events.md). Using **Start** many times has the same effect as using it once. +- The **Stop** input stops the Spawn System. If you do not connect anything to this flow slot, it implicitly uses the **OnStop** [Event](Events.md). -### Looping and Delaying +### Looping and delaying -Spawn contexts contains a state and will perform spawning particles based on a looping system. +Each Spawn Context contains a state to determine when the Context spawns particles. -* The spawn context can emit during **loops of defined duration** (meaning the internal spawn time will reset at each loop's beginning) . By default the duration is **infinite**. - * In order to set the loop mode, select the context in the graph and change the loop duration popup in the Inspector. (Possible Values : Infinite, Constant, Random) -* Spawn contexts can perform **one**, **many** or an **infinity** of **loops**. - * In order to set this setting, select the spawn context in the graph and change the Loop count popup in the Inspector (Possible Values : Infinite, Constant, Random) -* Spawn contexts can perform a **delay** **before** and/or a**delay after** each loop. During a delay, the spawn time elapses normally but no spawn is performed. - * In order to set these setting, select the spawn context in the graph and change the Delay Before Loop and Delay After Loop popups in the Inspector (Possible Values: None, Constant, Random) +* The Spawn Context emits particles during loops of a particular duration. This means the internal spawn time resets when each loop starts. By default, the duration is **infinite**, but you can change this.
To set the loop mode: + 1. Select the Spawn Context in the graph. + 2. In the Inspector, click the **Loop Duration** drop-down. + 3. From the list, click either **Infinite**, **Constant**, or **Random**. +* Spawn Contexts can perform one, many, or an infinite number of loops.
To set the number of loops: + 1. Select the Spawn Context in the graph. + 2. In the Inspector, click the **Loop** drop-down. + 3. From the list, click either **Infinite**, **Constant**, or **Random**. +* Spawn Contexts can perform a delay before and after each loop. During a delay, the spawn time elapses normally but the Spawn Context does not spawn any particles.
To set the delay duration: + 1. Select the Spawn Context in the graph. + 2. In the Inspector, click either the **Delay Before Loop** or **Delay After Loop** drop-down. + 3. From the list, click either **None**, **Constant**, or **Random**. -Here is a visual illustration of the Looping and Delay System. +If you set **Loop Duration**, **Loop**, **Delay Before Loop**, or **Delay After Loop** to either **Constant** or **Random**, the Spawn Context displays extra properties in its header to control each behavior. To evaluates the values you set, Unity uses the following rules: -![Figure explaining the Loop/Delay System](Images/LoopDelaySystem.png) +- If set, Unity evaluates **Loop Count** when the **Start** flow input of the Context triggers. +- If set, Unity evaluates **Loop Duration** every time a loop starts. +- If set, Unity evaluates **Loop Before/After Delay** every time a delay starts. -Setting a loop count, loop duration and / or delays will display new connectable properties on the context's header. Evaluation of these values will follow these rules: +For a visualization of the looping and delay system, see the following illustration: -* If set : **Loop Count** is evaluated when the Start workflow input of the context is hit. -* If set : **Loop Duration** is evaluated every time a loop starts -* If set : **Loop Delay** (Before/After) is evaluated every time a delay starts. +![Figure explaining the Loop/Delay System](Images/LoopDelaySystem.png) ## GPU Event -GPU Event contexts are experimental contexts that connect inputs to output GPU Events from other systems. They differ from Traditional Spawn as they are computed by the GPU. Only one kind of Spawn can be connected to an Initialize Context (GPU Event and Spawn/Events are mutually Exclusive) +GPU Event Contexts are experimental Contexts that connect inputs to output GPU Events from other systems. They differ from the normal Event Contexts in two ways: -> GPU Event contexts cannot be customized with Blocks. -> +* The GPU computes GPU Events and the CPU computes normal Events. +* You can't customize GPU Event Contexts with Blocks. -## Initialize - -Initialize Contexts will generate new particles based on **SpawnEvent** Data, computed from Events, Spawn or GPU Event contexts. +**Note**: When you connect Spawn Events to an Initialize Context, be aware that GPU Spawn Events and normal Spawn Events are mutually Exclusive. You can only connect one type of Spawn Event to an **Initialize** Context at the same time. -> For example: upon receiving an order of creation of 200 new particles from a spawn context, the context will be processed and will result in executing the context's Blocks for all 200 new particles. +## Initialize -Initialize contexts can be customized using compatible **Blocks**. +Initialize Contexts generate new particles based on **SpawnEvent** Data, which Unity computes from Events, Spawn Contexts, or GPU Event Contexts. -Initialize contexts are the entry point of new systems. As such, they display information and configuration in their header: +For example: If a Spawn Context states that the effect should create 200 new particles, the Initialize Context processes its Blocks for all 200 new particles. -| Property/Setting | Description | -| ------------------ | ------------------------------------------- | -| Bounds (Property) | Controls the Bounding box of the System | -| Capacity (Setting) | Controls the allocation count of the System | +To customize **Initialize **Contexts, you can add compatible **Blocks** to them. +Initialize contexts are the entry point of new systems. As such, they display the following information and configuration details in their header: +| Property/Setting | Description | +| ---------------------- | -------------------------------------------- | +| **Bounds** (Property) | Controls the Bounding box of the System. | +| **Capacity** (Setting) | Controls the allocation count of the System. | ## Update -Update contexts update all living particles based on **Particle** Data computed from Initialize and Update Contexts. These contexts are executed every frame and will update every particle. +Update Contexts update all living particles in the system based on **Particle** Data, which Unity computes from Initialize and Update Contexts. Unity executes Update Contexts, and thus updates every particle, every frame. -Particle Update Contexts also process automatically some computations for particles in order to simplify common editing tasks. +Particle Update Contexts also automatically process some computations for particles in order to simplify common editing tasks. -Update contexts can be customized using compatible **Blocks**. +To customize **Update** Contexts, you can add compatible **Blocks** to them. -| Setting | Description | -| ------------------- | ------------------------------------------------------------ | -| Integration | None : No velocity Integration
Euler : Applies simple Euler velocity integration to the particles positions every frame. | -| Angular Integration | None : No velocity Integration
Euler : Applies simple Euler angular velocity integration to the particles angles every frame. | -| Age Particles | If Age attribute is used, Controls whether update will make particles age over time | -| Reap Particles | If Age and Lifetime attributes are used, Control whether update will kill all particles which age is greater than its lifetime. | +| Setting | Description | +| ----------------------- | ------------------------------------------------------------ | +| **Integration** | Specifies the type of velocity integration to use for the particles.
• **None**: No velocity Integration .
• **Euler**: Applies simple Euler velocity integration to the particles positions every frame. | +| **Angular Integration** | Specifies the type of angular integration to use for the particles.
• **None**: No velocity Integration .
• **Euler**: Applies simple Euler angular velocity integration to the particles angles every frame. | +| **Age Particles** | If the Context uses the Age attribute, this controls whether the Update Context makes particles age over time. | +| **Reap Particles** | If the Context uses the Age and Lifetime attributes, this control whether the Update Context removes a particles if the particle's age is greater than its lifetime. | ## Output -Output Contexts renders a system with different modes and settings depending on Particle Data incoming from an **Initialize** or **Update** context. Every element will be rendered using a specific configuration as a specific primitive. - -Output contexts can be customized using compatible **Blocks**. +Output Contexts render the particles in a system. They render the particles with different modes and settings depending on the particle Data from the **Initialize** and **Update** Contexts in the same system. It then renders the configuration as a particular primitive shape. -For more information, and a comprehensive list of all output contexts and their settings, see [Output Contexts Reference]() \ No newline at end of file +To customize **Output** Contexts, you can add compatible **Blocks** to them. diff --git a/com.unity.visualeffectgraph/Documentation~/GettingStarted.md b/com.unity.visualeffectgraph/Documentation~/GettingStarted.md index df250b9a17e..4e1ef871809 100644 --- a/com.unity.visualeffectgraph/Documentation~/GettingStarted.md +++ b/com.unity.visualeffectgraph/Documentation~/GettingStarted.md @@ -69,7 +69,7 @@ To preview an effect, you can: This lets you edit parameters directly in the Scene, see the lighting on your effect, and use the [Target GameObject Panel](VisualEffectGraphWindow.md#target-visual-effect-gameobject) features for the specific target instance of your effect. -## Manipulating Graph Elements +## Manipulating graph elements When you open an Asset inside the Visual Effect Graph window, you can see and edit the graph for that specific Asset. A Visual Effect Graph contains [Operator Nodes](Operators.md) and [Blocks](Blocks.md). Each Node is in charge of processing its input properties. You can link Nodes together to perform a series of calculations. All Nodes end up connecting into a Block (or a context) : A Block defines an operation on an effect, based on its input properties. diff --git a/com.unity.visualeffectgraph/Documentation~/GraphLogicAndPhilosophy.md b/com.unity.visualeffectgraph/Documentation~/GraphLogicAndPhilosophy.md index 801954492e2..77d16df37dc 100644 --- a/com.unity.visualeffectgraph/Documentation~/GraphLogicAndPhilosophy.md +++ b/com.unity.visualeffectgraph/Documentation~/GraphLogicAndPhilosophy.md @@ -9,7 +9,7 @@ The Visual Effect Graph uses two distinct workflows: ## Processing workflow (vertical logic) The processing workflow links together a succession of customizable stages to define the complete system logic. This is where you can determine when the spawn, initialization, updating, and rendering of the particles happen during the effect. -The processing workflow connects Contexts using their **Flow Slots** located at the top and the bottom of the Context Node. +The processing workflow connects Contexts using their **flow slots** located at the top and the bottom of the Context Node. The processing logic defines the different stages of processing of a visual effect. Each stage consists of a large colored container called a [Contexts](Contexts.md). Each Context connects to another compatible Context, which defines how the next stage of processing uses the current Context. @@ -23,13 +23,13 @@ The Visual Effect Graph comes with a large Block and Node library that you can t To customize how particles behave, you can connect horizontal Nodes to a Block to create a custom a mathematical expression. To do this, use the **Create Node** context menu to add Nodes, change their values, then connect the Nodes to Block properties. -## Graph Elements +## Graph elements -A Visual Effect Graph provides a workspace where you can create Graph Elements and connect them together to define effect behaviors. The Visual Effect Graph comes with many different types of Graph Elements that fit into the workspace. +A Visual Effect Graph provides a workspace where you can create graph elements and connect them together to define effect behaviors. The Visual Effect Graph comes with many different types of graph elements that fit into the workspace. ### Workspace -A Visual Effect Graph provides a **Workspace** where you can create Graph Elements and connect them together to define effect behaviors. +A Visual Effect Graph provides a **Workspace** where you can create graph elements and connect them together to define effect behaviors. ![The vertical workflow contains Systems, which then contain Contexts, which then contain Blocks. Together, they determine when something happens during the “lifecycle” of the visual effect.](Images/SystemVisual.png) @@ -74,7 +74,7 @@ While the graph elements are different, their contents and behavior tend to be t #### Settings -Settings are Fields that you cannot connect to using the property workflow. Every Graph Element displays settings: +Settings are Fields that you cannot connect to using the property workflow. Every graph element displays settings: * In the **Graph** : Between the Title and the property container in the Graph. * In the **Inspector** : When you select a Node, the Inspector displays additional, advanced settings. @@ -85,7 +85,7 @@ If you change the value of a setting, you need to recompile the Graph to see the [Properties](Properties.md) are Fields that you can edit and connect to using the property workflow. You can connect them to other properties contained in other graph elements. -## Other Graph Elements +## Other graph elements ### Groups diff --git a/com.unity.visualeffectgraph/Documentation~/Properties.md b/com.unity.visualeffectgraph/Documentation~/Properties.md index 61e82c08228..f9e04331ed3 100644 --- a/com.unity.visualeffectgraph/Documentation~/Properties.md +++ b/com.unity.visualeffectgraph/Documentation~/Properties.md @@ -1,7 +1,7 @@
Draft: The content on this page is complete, but it has not been reviewed yet.
# Properties -Properties are editable fields that you can connect to graph elements using [Property workflow](GraphLogicAndPhilosophy.md). They can be found on Graph Elements such as [Contexts](Contexts.md), [Blocks](Blocks.md) and [Operators](Operators.md). +Properties are editable fields that you can connect to graph elements using [Property workflow](GraphLogicAndPhilosophy.md). They can be found on graph elements such as [Contexts](Contexts.md), [Blocks](Blocks.md) and [Operators](Operators.md). ## Using Properties diff --git a/com.unity.visualeffectgraph/Documentation~/VisualEffectGraphWindow.md b/com.unity.visualeffectgraph/Documentation~/VisualEffectGraphWindow.md index 28a8063d03f..869c359a7bf 100644 --- a/com.unity.visualeffectgraph/Documentation~/VisualEffectGraphWindow.md +++ b/com.unity.visualeffectgraph/Documentation~/VisualEffectGraphWindow.md @@ -100,7 +100,7 @@ The navigation controls for the Node Workspace are similar to those that other g * **Duplicate**: Ctrl+D. * **Duplicate with edges**: Ctrl+Alt+D. -### Adding Graph Elements +### Adding graph elements To add graph elements, you can use any of the following methods: From 63437b8f2a45c24169f99fb8bf30f8e5b6d8ec6d Mon Sep 17 00:00:00 2001 From: Lewis Jordan Date: Wed, 18 Mar 2020 18:30:15 +0000 Subject: [PATCH 2/6] Began reviewing Events --- .../Documentation~/Contexts.md | 2 +- .../Documentation~/Events.md | 30 ++++++++++--------- 2 files changed, 17 insertions(+), 15 deletions(-) diff --git a/com.unity.visualeffectgraph/Documentation~/Contexts.md b/com.unity.visualeffectgraph/Documentation~/Contexts.md index 54d7c82ca45..1481768b53d 100644 --- a/com.unity.visualeffectgraph/Documentation~/Contexts.md +++ b/com.unity.visualeffectgraph/Documentation~/Contexts.md @@ -1,6 +1,6 @@ # Contexts -Contexts are the main element of the Visual Effect Graph's **processing** (vertical) logic and determine how particles spawn and simulate. The way you organize Contexts on the graph defines order of operation for the processing workflow. For information on the processing workflow, see [Visual Effect Graph Logic](GraphLogicAndPhilosophy.md). Every Context defines one stage of computation. For example a Context can: +Contexts are the main element of the Visual Effect Graph's **processing** (vertical) workflow and determine how particles spawn and simulate. The way you organize Contexts on the graph defines order of operation for the processing workflow. For information on the processing workflow, see [Visual Effect Graph Logic](GraphLogicAndPhilosophy.md). Every Context defines one stage of computation. For example a Context can: * Calculate how many particles the effect should spawn. * Create new particles. diff --git a/com.unity.visualeffectgraph/Documentation~/Events.md b/com.unity.visualeffectgraph/Documentation~/Events.md index 2468db25803..2da120b3f9c 100644 --- a/com.unity.visualeffectgraph/Documentation~/Events.md +++ b/com.unity.visualeffectgraph/Documentation~/Events.md @@ -1,35 +1,37 @@ -
Draft: The content on this page is complete, but it has not been reviewed yet.
# Events -Events are the Processing Workflow inputs of a Visual Effect Graph. Through Events, a Visual Effect can : +Events define the inputs for a Visual Effect Graph's [**processing** workflow](GraphLogicAndPhilosophy.md#processing-workflow-(vertical-logic)). The Spawn and Initialize [Contexts](Contexts.md) use Events as their inputs. Through Events, a Visual Effect Graph can : -* Start and stop spawning particles, -* Read Attribute payloads sent from C# - -Events are used in the graph as inputs for Spawn Contexts and Initialize +* Start and stop spawning particles. +* Read [Event Attribute payloads](#eventattribute-payloads) sent from C#. ## Creating Events ![](Images/EventContexts.png) -You can Create Events using Event Contexts. These contexts have no Flow input and connect to Spawn or Initialize Contexts. +In general, an Event is just a string that contains the name of the Event. To send an Event in the Visual Effect Graph, create an Event [Context](Contexts.md) and type the name of the Event in the **Event Name** property. Event Contexts have no flow input and can only connect their flow output to Spawn or Initialize Contexts. + +To create an Event Context: -In order to Create an Event Context, right click in an empty space of the Workspace and select Create Node, then Select **Event (Context)** from the Node Creation menu. +1. In the [Visual Effect Graph window](VisualEffectGraphWindow.md), right-click in an empty space. +2. From the menu, click **Create Node**. +3. In the Node Creation menu, click **Contexts > Event (Context)**. +4. In the **Event Name** input field, type the name of your Event. ## Default Events -Visual Effect Graphs provide two Default Events that are implicitly bound to the Start and Stop Flow Inputs of the Spawn Contexts: +The Visual Effect Graph provide two default Events: -* `OnPlay` for the intent *Enabling the Spawn of Particles*, is implicitly bound to the Start Flow input of any Spawn Context. -* `OnStop` for the intent of *Stopping the Spawn of Particles*, is implicitly bound to the Stop Flow input of any Spawn Context. +* **OnPlay**: To enable the spawning of particles. If you do not assign an Event to a Spawn Context's **Start** flow input, the Visual Effect Graph implicitly binds this Event to that flow input instead. +* **OnStop**: To disable the spawning of particles. If you do not assign an Event to a Spawn Context's **Stop** flow input, the Visual Effect Graph implicitly binds this Event to that flow input instead. -Connecting Event Contexts on the Start and Stop Flow inputs of a Spawn Contexts will remove the implicit binding to the `OnPlay` and `OnStop` Events +If you connect an Event Context to a Spawn Context's **Start** or **Stop** flow input, this removes the implicit binding to the **OnPlay** and **OnStop** Events. ## Custom Events -Custom Events can be created inside Visual Effect Graphs using Event Contexts. +If you do not want to use the default Events, you can use an Event Context to create your own custom Event. -In order to create a custom event, create an event using the **Create Node** menu, then change its name in the **Event Name** field +To create a custom event, create an event using the **Create Node** menu, then change its name in the **Event Name** field ## EventAttribute Payloads From d104d22661fb26a559e28c5e8174a33f8991fdfb Mon Sep 17 00:00:00 2001 From: Lewis Jordan Date: Thu, 19 Mar 2020 14:24:46 +0000 Subject: [PATCH 3/6] Added sticky notes doc and reviewed Events --- .../Documentation~/Events.md | 40 ++++++++-------- .../Documentation~/StickyNotes.md | 46 +++++++++++++++++++ .../Documentation~/TableOfContents.md | 1 + 3 files changed, 67 insertions(+), 20 deletions(-) create mode 100644 com.unity.visualeffectgraph/Documentation~/StickyNotes.md diff --git a/com.unity.visualeffectgraph/Documentation~/Events.md b/com.unity.visualeffectgraph/Documentation~/Events.md index 2da120b3f9c..5fc7788af91 100644 --- a/com.unity.visualeffectgraph/Documentation~/Events.md +++ b/com.unity.visualeffectgraph/Documentation~/Events.md @@ -3,13 +3,13 @@ Events define the inputs for a Visual Effect Graph's [**processing** workflow](GraphLogicAndPhilosophy.md#processing-workflow-(vertical-logic)). The Spawn and Initialize [Contexts](Contexts.md) use Events as their inputs. Through Events, a Visual Effect Graph can : * Start and stop spawning particles. -* Read [Event Attribute payloads](#eventattribute-payloads) sent from C#. +* Read [Event Attribute payloads](#eventattribute-payloads) sent from C# scripts. ## Creating Events ![](Images/EventContexts.png) -In general, an Event is just a string that contains the name of the Event. To send an Event in the Visual Effect Graph, create an Event [Context](Contexts.md) and type the name of the Event in the **Event Name** property. Event Contexts have no flow input and can only connect their flow output to Spawn or Initialize Contexts. +In general, an Event is just a string that represents the Event's name. To receive an Event in the Visual Effect Graph, create an Event [Context](Contexts.md) and type the name of the Event you want to receive in the **Event Name** property. Event Contexts have no input flow slots and can only connect their output flow slot to Spawn or Initialize Contexts. To create an Event Context: @@ -22,42 +22,42 @@ To create an Event Context: The Visual Effect Graph provide two default Events: -* **OnPlay**: To enable the spawning of particles. If you do not assign an Event to a Spawn Context's **Start** flow input, the Visual Effect Graph implicitly binds this Event to that flow input instead. -* **OnStop**: To disable the spawning of particles. If you do not assign an Event to a Spawn Context's **Stop** flow input, the Visual Effect Graph implicitly binds this Event to that flow input instead. +* **OnPlay**: To enable the spawning of particles. If you do not assign an Event to a Spawn Context's **Start** input flow slot, the Visual Effect Graph implicitly binds this Event to that input flow slot instead. +* **OnStop**: To disable the spawning of particles. If you do not assign an Event to a Spawn Context's **Stop** input flow slot, the Visual Effect Graph implicitly binds this Event to that input flow slot instead. -If you connect an Event Context to a Spawn Context's **Start** or **Stop** flow input, this removes the implicit binding to the **OnPlay** and **OnStop** Events. +If you connect an Event Context to a Spawn Context's **Start** or **Stop** input flow slot, this removes the implicit binding to the **OnPlay** and **OnStop** Events respectively. ## Custom Events If you do not want to use the default Events, you can use an Event Context to create your own custom Event. -To create a custom event, create an event using the **Create Node** menu, then change its name in the **Event Name** field +To do this, first [create an Event Context](#creating-events), then type the name of your custom Event in the **Event Name** property. -## EventAttribute Payloads +## Event Attribute Payloads -Event Attribute payloads are attributes attached on one event. You can set these attributes in Visual Effect Graph using the **Set [Attribute] Event Attribute>** Blocks in Spawn Contexts, but you can also attach them to events sent from the scene using the [Component API](ComponentAPI.md#event-attributes) . +Event Attribute payloads are attributes that you can attach to an Event. To set these attributes in a Visual Effect Graph, you can use the **Set [Attribute]** Blocks in Spawn Contexts, but you can also attach them to Events you send from C# scripts. For information on how to do that latter, see [Component API](ComponentAPI.md#event-attributes) . -EventAttribute Payloads are attributes that will implicitly travel through the graph from Events, through Spawn Systems, and that can be caught in Initialize Contexts using **Get Source Attribute Operators** and **Inherit [Attribute] Blocks** +Event Attribute Payloads are attributes that implicitly travel through the graph from Events, through Spawn Contexts, and eventually to an Initialize Context. To catch a payload in an Initialize Context, use **Get Source Attribute** Operators or **Inherit [Attribute]** Blocks. -## Default VisualEffect Event +## Default Visual Effect Event -The default Visual Effect Event defines the name of the event that is implicitly sent when a `Reset` is performed on a [Visual Effect](VisualEffectComponent.md) instance (this can happen at first start or any restart of the effect). +The default Visual Effect Event defines the name of the Event that the Visual Effect Graph implicitly sends when a [Visual Effect](VisualEffectComponent.md) instance **Resets**. This happens when the effect first starts, or when the effect restarts. -Default VisualEffect Event is defined in the [Visual Effect Graph Asset Inspector](VisualEffectGraphAsset.md) but can be overridden in any [Visual Effect Inspector](VisualEffectComponent.md) for any instance in the scene. +You can define the default Visual Effect Event for each [Visual Effect Graph Asset](VisualEffectGraphAsset.md) independently. You can also override this value for every instance of the Visual Effect Graph Asset. To override the default Visual Effect Event for an instance, see **Initial Event Name** in the [Visual Effect Inspector](VisualEffectComponent.md). ## GPU Events -GPU Events is an **Experimental feature** of Visual Effect Graph : It enables particle spawn based on other Particles. You can enable this option in [Visual Effect Preferences](VisualEffectPreferences.md) . +GPU Events are an **Experimental feature** of the Visual Effect Graph. They allow you to spawn particles based on other particles. To enable this option, enable the **Experimental Operators/Blocks** checkbox in the [Visual Effect Preferences](VisualEffectPreferences.md) . -![](Images/GPUEvent.png) +GPU Events are Event Contexts that rely on data sent from other systems, for example, when a particle dies. The following Update Blocks can send GPU Event Data: -GPU Events are Event Contexts that relies on Data sent from other Systems, for instance when a particle dies, or other conditions. The following Update Blocks can send GPU Event Data: +* **Trigger Event On Die**: Spawns N Particles on another system when a particle dies. +* **Trigger Event Rate**: Spawn N Particles per second (or per distance travelled), based on a particle from a system. +* **Trigger Event Always**: Spawns N Particles every frame. -* **Trigger Event On Die** : Spawns N Particles on another system when a particle dies -* **Trigger Event Rate** : Spawn N Particles per second (or per distance travelled), based on a particle from a system -* **Trigger Event Always** : Spawns N Particles every Frame. +These Blocks connect to a **GPUEvent** Context. This Context does not handle any Blocks, but instead connects to an Initialize Context of a child system. -These Blocks connect to a **GPUEvent** Context. This context does not handle any Blocks but instead connects to a Initialize Context of a child system. +To gather data from the parent particle, a child system must refer to [Source Attributes](Attributes.md) in its Initialize Context. To do this, a child system can use a **Get Source Attribute** Operator, or an **Inherit Attribute** Block. For a visual example, see the image below. -In order to gather data from the parent particle, the child system must refer to [Source Attributes](Attributes.md) in its Initialize Context, by using **Get Source Attribute Operator**, or **Inherit Attribute Block**,as shown as in the example above : The child System inherits the source position of the particle that created it, and inherits roughly 50% of its speed. +![](Images/GPUEvent.png)*In this example, the child System inherits the source position of the particle that creates it. It also inherit roughly 50% of the parent particle's speed.* diff --git a/com.unity.visualeffectgraph/Documentation~/StickyNotes.md b/com.unity.visualeffectgraph/Documentation~/StickyNotes.md new file mode 100644 index 00000000000..ed92fd3701d --- /dev/null +++ b/com.unity.visualeffectgraph/Documentation~/StickyNotes.md @@ -0,0 +1,46 @@ +# Sticky Notes + +Sticky Notes are objects in a graph view that you can write in. They are the graph view equivalent of a comment in code, and consist of a title and body. You can create as many as you want in the graph, and use them for a variety of purposes, for example: + +- To describe how a section of your graph works. +- To leave notes for yourself or others collaborating in your Unity Project. +- As a to-do list that includes tasks to complete at a later date. + +## Using Sticky Notes + +To create a Sticky Note, right-click an empty space in the graph view and, in the context menu, click **Create Sticky note**. You can now customize and add content to the new Sticky Note. There are two text areas that you can write to: + +- **Title**: The text area at the top of the Sticky Note is the title. Here you can concisely describe what the Sticky Note contains in its body text area. For example, this could be the name of the graph section the Sticky Note describes. +- **Body**: The larger text area below the title area is the body. You can write the full contents of the note here. + +### Controls + +This section describes how to edit text, move and resize the Sticky Note, and perform other actions. + +#### Editing text + +To edit text on a Sticky Note, double-click on a text area. This also selects all of the text in the area so be sure to move the text cursor before you edit the text. + +#### Moving and resizing + +You can move Sticky Notes anywhere on the graph. For information on how to do this, see [manipulating graph elements](VisualEffectGraphWindow.md#moving-elements). + +You can also resize Sticky Notes. You can resize the Sticky Note manually or the Sticky Note can resize itself automatically to fit its contents. For information on how to make the Sticky Note resize itself, see the **Fit To Text** option in the [Context menu](#context-menu). For information on how to resize the Sticky Note manually, see [manipulating graph elements](VisualEffectGraphWindow.md#moving-elements). + +#### Duplicating + +You can also cut, copy, paste, and duplicate Sticky Notes. For information on how to perform these actions, see [duplicating elements](VisualEffectGraphWindow.md#copy-cut-and-paste-and-duplicate-elements). + +#### Context menu + +To open the context menu for the Sticky Note, right-click anywhere on the Sticky Note. The options in the context menu are as follows. + +| **Option** | **Description** | +| -------------------------- | ------------------------------------------------------------ | +| **Dark Theme/Light Theme** | Toggles the color theme of the Sticky Note between light theme and dark theme. | +| **Text Size** | Resizes the font in the text areas to the following values: | +| Small | Title: 20
Body: 11 | +| Medium | Title: 40
Body: 24 | +| Large | Title: 60
Body: 36 | +| Huge | Title: 80
Body: 56 | +| **Fit To Text** | Resizes the Sticky Note so that it precisely fits the text areas.
**Note**: If your title spreads over more than a single line, this horizontally resizes the Sticky Note to the smallest size where the title text fits on a single line. | \ No newline at end of file diff --git a/com.unity.visualeffectgraph/Documentation~/TableOfContents.md b/com.unity.visualeffectgraph/Documentation~/TableOfContents.md index b0a7a6b6466..f3f30f776cc 100644 --- a/com.unity.visualeffectgraph/Documentation~/TableOfContents.md +++ b/com.unity.visualeffectgraph/Documentation~/TableOfContents.md @@ -12,6 +12,7 @@ * [Attributes](Attributes.md) * [Subgraph](Subgraph.md) * [Blackboard](Blackboard.md) + * [Sticky Notes](StickyNotes.md) * [Project Settings](VisualEffectProjectSettings.md) * [Preferences](VisualEffectPreferences.md) * [The Visual Effect Component](VisualEffectComponent.md) From 57f85b759791d391772fe505311f1e387b3ed291 Mon Sep 17 00:00:00 2001 From: Lewis Jordan Date: Thu, 19 Mar 2020 14:27:36 +0000 Subject: [PATCH 4/6] Update Contexts.md --- com.unity.visualeffectgraph/Documentation~/Contexts.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/com.unity.visualeffectgraph/Documentation~/Contexts.md b/com.unity.visualeffectgraph/Documentation~/Contexts.md index 1481768b53d..57ffb3e3b79 100644 --- a/com.unity.visualeffectgraph/Documentation~/Contexts.md +++ b/com.unity.visualeffectgraph/Documentation~/Contexts.md @@ -8,7 +8,7 @@ Contexts are the main element of the Visual Effect Graph's **processing** (verti Contexts connect to one another sequentially to define the lifecycle of particles. After a graph creates new particles, the **Initialize** Context can connect to an **Update Particle** Context to simulate each particle. Also, the **Initialize** Context can instead connect directly to an **Output Particle** Context to render the particles without simulating any behavior. -## Creating and Connecting Contexts +## Creating and connecting Contexts A Context is a type of [graph element](GraphLogicAndPhilosophy.md#graph-elements) so to create one, see [Adding graph elements](VisualEffectGraphWindow.md#adding-graph-elements). @@ -20,7 +20,7 @@ To change the behavior of the Context, adjust its [settings](GraphLogicAndPhilos Some settings also change how the Context looks. For example in a **Quad Output** Context, if you set the UV Mode to **FlipbookMotionBlend**, Unity adds the following extra properties to the Context header: **Flipbook Size**, **Motion Vector Map**, and **Motion Vector Scale**. -## Flow Compatibility +## Flow compatibility Not all Contexts can connect to one another. To keep a consistent workflow, the following rules apply: @@ -42,7 +42,7 @@ For a breakdown of context compatibility, see the table below. | **Particle Output** | **Particle** (1) | **None** | Can either have input from an **Initialize** or **Update** Context.
No output. | | **Static Mesh Output** | **None** | **None** | Standalone Context. | -# Context Type Overview +# Context type overview This section covers all the common settings for every kind of Context. From de25cbcf2b350ec3cec505af2b5e89e28e14ce48 Mon Sep 17 00:00:00 2001 From: Tristan Genevet Date: Tue, 24 Mar 2020 11:24:20 +0100 Subject: [PATCH 5/6] Formatted documentation. --- .../Documentation~/Contexts.md | 6 ++--- .../Documentation~/Events.md | 1 - .../Documentation~/StickyNotes.md | 4 +-- .../Documentation~/TableOfContents.md | 26 +++++++++---------- 4 files changed, 18 insertions(+), 19 deletions(-) diff --git a/com.unity.visualeffectgraph/Documentation~/Contexts.md b/com.unity.visualeffectgraph/Documentation~/Contexts.md index 358f824e71d..2c14c9fad61 100644 --- a/com.unity.visualeffectgraph/Documentation~/Contexts.md +++ b/com.unity.visualeffectgraph/Documentation~/Contexts.md @@ -16,7 +16,7 @@ Contexts connect to one another in a vertical, linear order. To achieve this, th ## Configuring Contexts -To change the behavior of the Context, adjust its [settings](GraphLogicAndPhilosophy.md#settings) in the Node UI or the Inspector. +To change the behavior of the Context, adjust its [settings](GraphLogicAndPhilosophy.md#settings) in the Node UI or the Inspector. Some settings also change how the Context looks. For example in a **Quad Output** Context, if you set the UV Mode to **FlipbookMotionBlend**, Unity adds the following extra properties to the Context header: **Flipbook Size**, **Motion Vector Map**, and **Motion Vector Scale**. @@ -52,7 +52,7 @@ Event Contexts only display their name, which is a string. To trigger an Event C ## Spawn -Spawn Contexts are standalone systems that have three States: Running, Idle, and Waiting. +Spawn Contexts are standalone systems that have three States: Running, Idle, and Waiting. * **Looping** (Running): This state means that Unity computes the Blocks in the Context and spawns new particles. * **Finished** (Idle): This state means that the spawn machine is off and does not compute Blocks in the Context or spawn particles. @@ -60,7 +60,7 @@ Spawn Contexts are standalone systems that have three States: Running, Idle, and To customize **Spawn** Contexts, you can add compatible **Blocks** to them. For information on the Spawn Context API, see the [Script Reference](https://docs.unity3d.com/2019.3/Documentation/ScriptReference/VFX.VFXSpawnerLoopState.html). -### Enabling and disabling +### Enabling and disabling Spawn Contexts expose two [flow slots](GraphLogicAndPhilosophy.md#processing-workflow-vertical-logic): **Start** and **Stop**: diff --git a/com.unity.visualeffectgraph/Documentation~/Events.md b/com.unity.visualeffectgraph/Documentation~/Events.md index 5fc7788af91..9778fa82eaa 100644 --- a/com.unity.visualeffectgraph/Documentation~/Events.md +++ b/com.unity.visualeffectgraph/Documentation~/Events.md @@ -60,4 +60,3 @@ These Blocks connect to a **GPUEvent** Context. This Context does not handle any To gather data from the parent particle, a child system must refer to [Source Attributes](Attributes.md) in its Initialize Context. To do this, a child system can use a **Get Source Attribute** Operator, or an **Inherit Attribute** Block. For a visual example, see the image below. ![](Images/GPUEvent.png)*In this example, the child System inherits the source position of the particle that creates it. It also inherit roughly 50% of the parent particle's speed.* - diff --git a/com.unity.visualeffectgraph/Documentation~/StickyNotes.md b/com.unity.visualeffectgraph/Documentation~/StickyNotes.md index ed92fd3701d..b354091c749 100644 --- a/com.unity.visualeffectgraph/Documentation~/StickyNotes.md +++ b/com.unity.visualeffectgraph/Documentation~/StickyNotes.md @@ -15,7 +15,7 @@ To create a Sticky Note, right-click an empty space in the graph view and, in th ### Controls -This section describes how to edit text, move and resize the Sticky Note, and perform other actions. +This section describes how to edit text, move and resize the Sticky Note, and perform other actions. #### Editing text @@ -43,4 +43,4 @@ To open the context menu for the Sticky Note, right-click anywhere on the Sticky | Medium | Title: 40
Body: 24 | | Large | Title: 60
Body: 36 | | Huge | Title: 80
Body: 56 | -| **Fit To Text** | Resizes the Sticky Note so that it precisely fits the text areas.
**Note**: If your title spreads over more than a single line, this horizontally resizes the Sticky Note to the smallest size where the title text fits on a single line. | \ No newline at end of file +| **Fit To Text** | Resizes the Sticky Note so that it precisely fits the text areas.
**Note**: If your title spreads over more than a single line, this horizontally resizes the Sticky Note to the smallest size where the title text fits on a single line. | diff --git a/com.unity.visualeffectgraph/Documentation~/TableOfContents.md b/com.unity.visualeffectgraph/Documentation~/TableOfContents.md index d4b910cb091..46e0417c594 100644 --- a/com.unity.visualeffectgraph/Documentation~/TableOfContents.md +++ b/com.unity.visualeffectgraph/Documentation~/TableOfContents.md @@ -3,19 +3,19 @@ * [Visual Effect Graph Assets](VisualEffectGraphAsset.md) * [Visual Effect Graph Window](VisualEffectGraphWindow.md) * [Graph Logic & Philosophy](GraphLogicAndPhilosophy.md) - * [Systems](Systems.md) - * [Contexts](Contexts.md) - * [Blocks](Blocks.md) - * [Operators](Operators.md) - * [Properties](Properties.md) - * [Events](Events.md) - * [Attributes](Attributes.md) - * [Subgraph](Subgraph.md) - * [Blackboard](Blackboard.md) + * [Systems](Systems.md) + * [Contexts](Contexts.md) + * [Blocks](Blocks.md) + * [Operators](Operators.md) + * [Properties](Properties.md) + * [Events](Events.md) + * [Attributes](Attributes.md) + * [Subgraph](Subgraph.md) + * [Blackboard](Blackboard.md) * [Sticky Notes](StickyNotes.md) - * [Project Settings](VisualEffectProjectSettings.md) - * [Preferences](VisualEffectPreferences.md) -* [The Visual Effect Component](VisualEffectComponent.md) + * [Project Settings](VisualEffectProjectSettings.md) + * [Preferences](VisualEffectPreferences.md) +* [The Visual Effect Component](VisualEffectComponent.md) * [C# Component API](ComponentAPI.md) * [Using Visual Effects with Timeline](Timeline.md) * [Property Binders](PropertyBinders.md) @@ -27,4 +27,4 @@ * [Point Cache Bake Tool](PointCacheBakeTool.md) * [Spawner Callbacks](SpawnerCallbacks.md) * Reference - * [Standard Attributes](Reference-Attributes.md) \ No newline at end of file + * [Standard Attributes](Reference-Attributes.md) From 33195d5aaec9fbee00a3eebb71b327fb93e61a3b Mon Sep 17 00:00:00 2001 From: Lewis Jordan Date: Mon, 30 Mar 2020 12:11:27 +0100 Subject: [PATCH 6/6] Update Contexts.md --- com.unity.visualeffectgraph/Documentation~/Contexts.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/com.unity.visualeffectgraph/Documentation~/Contexts.md b/com.unity.visualeffectgraph/Documentation~/Contexts.md index 2c14c9fad61..b88f7430276 100644 --- a/com.unity.visualeffectgraph/Documentation~/Contexts.md +++ b/com.unity.visualeffectgraph/Documentation~/Contexts.md @@ -129,8 +129,8 @@ To customize **Update** Contexts, you can add compatible **Blocks** to them. | Setting | Description | | ----------------------- | ------------------------------------------------------------ | -| **Integration** | Specifies the type of velocity integration to use for the particles.
• **None**: No velocity Integration .
• **Euler**: Applies simple Euler velocity integration to the particles positions every frame. | -| **Angular Integration** | Specifies the type of angular integration to use for the particles.
• **None**: No velocity Integration .
• **Euler**: Applies simple Euler angular velocity integration to the particles angles every frame. | +| **Update Position** | Specifies whether Unity applies velocity integration to the particles. When enabled, Unity applies simple Euler velocity integration to each particle's position every frame. When disabled, Unity does not apply any velocity integration. | +| **Update Rotation** | Specifies whether Unity applies angular integration to the particles. When enabled, Unity applies simple Euler integration to each particle's rotation every frame. When disabled, Unity does not apply any angular integration. | | **Age Particles** | If the Context uses the Age attribute, this controls whether the Update Context makes particles age over time. | | **Reap Particles** | If the Context uses the Age and Lifetime attributes, this control whether the Update Context removes a particles if the particle's age is greater than its lifetime. |