Interaction with PhysX Shapes

Turbulence actors can interact with PhysX shapes if the collision filtering settings are set correctly (set in the Turbulence asset or actor).

Controlling the effect of PhysX Shapes

Colliding PhysX Shapes impart angular and linear velocity onto the grid, and this velocity is determined by the current and previous pose of the shape. There are additionally four parameters that can be set per Turbulence Actor which will affect how colliding shapes affect the grid’s velocity field. These are AngularVelocityMultiplier, AngularVelocityClamp, LinearVelocityMultiplier and LinearVelocityClamp. The Multiplier will be multiplied with the computed velocity, and the resultant velocity will be clamped to the Clamp value. Artists can use these variables to control how much or how little the collision objects affect the grid. To set these values you can use these two API calls on the TurbulenceFS actor:

setAngularVelocityMultiplierAndClamp
setLinearVelocityMultiplierAndClamp

Definition of BasicFS

Turbulence Jets have now been replaced by a new Module called BasicFS. BasicFS acts like a jet force inside the turbulence grid and as a torroidal force directly affecting the particles outside the grid. Both the force direction and amount can be specified and these variables can be animated/oscillated over time. Besides Jets BasicFS provides Attractors which attract particles to specified point with specified force.

BasicFS Asset

BasicFS assets can be authored by artists. Here are some of the important attributes of the BasicFS asset:

Variables for affecting the shape of basic field samplers in a grid

gridShapeRadius(float) Radius of sphere or capsule shape inside of the grid
gridShapeHeight(float) Height of capsule shape inside of the grid
gridBoundaryFadePercentage(float) Percentage of distance from boundary to center where fade out starts. FadePercentage of 0 removes
the fade region, and FadePercentage of 1 makes the fade region take up the entire region of the shape (fade region will start at center of shape)

Variables for affecting the shape of the Turbulence shape outside the grid

nearRadius(float)radius of field core, velocity up to this radius is constant
pivotRadius(float) the center of the toroid
farRadius(float)the outside radius of the toroid
directionalStretch(float) the ratio of the height of the shape to its base

Variables for direction and strength

fieldDirection(VEC3)
fieldDirectionDeviationAngle(float)
fieldDirectionOscillationPeriod(float)
fieldStrength(float)
fieldStrengthDeviationPercentage(float)
fieldStrengthOscillationPeriod(float)
averageStartDistance(float)
averageEndDistance(float)

How to Use

In order to use heat in the simulation you have to:

1. Enable it using: TurbulenceFSActor::setUseHeat(bool). If heat is not enabled the simulation will ignore all heat sources, and the temperature field. Heat is disabled by default since its use does increase workload and decrease performance. 2. Add heat sources to the simulation, covered in “Heat Sources” below. 3. Configure how the simulation should react to the temperature, covered in “Extra Parameters” below.

Heat Sources

Heat is added to the system using two types of heat sources, under the NvParameterized included reference, geometryType:

• Box - PxVec3 extents
• Sphere - PxF32 radius

Heat sources can be manipulated by

1. Modifying their underlying APEXShape properties; you can access the APEXShape by calling the interface HeatSourceActor::getSphereShape()or HeatSourceActor::getBoxShape()
2. Setting their temperature, defined by an average and a standard deviation. All fluid cells falling inside the heat source will get a random temperature defined by this average and standard deviation.

void HeatSourceActor::setTemperature(float averageTemperature, float stdTemperature);

Extra Parameters

The user has the ability to configure how the simulation should react to the temperature, and these options are set through the interface:

TurbulenceFSActor::setHeatBasedParameters(float forceMultiplier, float ambientTemperature, PxVec3 heatForceDirection);

The ambient temperature provides a cutoff for the minimum temperature that adds velocity in the system - if the temperature of the fluid is less than the ambient temperature no velocity is added to the simulation.

The forceMultiplier controls how much the difference in temperature affects the velocity, based on the simple formula:

Impulse_strength = forceMultiplier*(temp - ambientTemp);

The force direction controls what direction the heat induced velocity is applied in - if we want to create hot air rising up then the axis would be set to the up vector, and if we want to create a cold fluid sinking under gravity we would set this axis to -up. An example of using Turbulence heat is shown in the SimpleTurbulence sample in the scene TurbulenceHeatScene (scene 5).

Visualizing Velocity Fields

Velocity Fields can be visualized in two ways. The first is with 3d veleocity vectors and the second allows visualization of how particles flow through the grid which are termed stream lines. Turbulence debug visualization provides methods of viewing the spatially varying values of velocity fields.

Velocity Vectors

The velocity field can be visualized as shaded lines originating at the simulation grid cell centers and extending in the direction of the local velocity (these lines are shaded white at their beginning and red at their end). These parameters control the visualization of the velocity vectors:

VISUALIZE_TURBULENCE_FS_FIELD
TURBULENCE_FS_FIELD_SCALE
TURBULENCE_FS_FIELD_SPACING

Stream Lines

The velocity field can also be visualized as streamlines. Streamlines render the paths of particles initialized at regular intervals on the grid and traced through the velocity field.

These parameters control the visualization of the streamlines:

VISUALIZE_TURBULENCE_FS_STREAMLINES
TURBULENCE_FS_STREAMLINES.grid
TURBULENCE_FS_STREAMLINES.tstep
TURBULENCE_FS_STREAMLINES.tmax

Temperature

The temperature field is visualized as 3D crosses centered at grid cell centers. The size of the cross denotes the temperature amount at that cell.

These parameters control the visualization of the temperature:

VISUALIZE_TURBULENCE_FS_TEMPERATURE
TURBULENCE_FS_TEMPERATURE_SCALE
TURBULENCE_FS_TEMPERATURE_SPACING

Plane

Hit ‘Z’ on running sample to display the plane which is intersecting the bounding box. Lines where faces of bounding box are intersected by the plane will be highlighted.

After you turn plane visualization on both velocity vectors and streamlines start originate on the plane (but still in the box).

These parameters control the visualization of the temperature:

VISUALIZE_TURBULENCE_FS_PLANE
TURBULENCE_FS_PLANE.normal
TURBULENCE_FS_PLANE.offset

Given plane also intersects Euler’s grid, each box (parallelepiped in common case) at some angle. To visualize this, hit ‘X’ while running sample with debug visualization turned on or set the parameter (but note that enabling this option will significantly affect performance and reduce FPS).

VISUALIZE_TURBULENCE_FS_GRID

Implicit Collision Transforms

The collision implicit in the Turbulence asset can be arbitrarily transformed using two variables:

implicitCollisionRadius; // 3D radius of collision implicit
                         //implicitXForm a 4x4 column major matrix denoting the orientation and translation of the implicit

For example, to get an object with a 45 degree rotation around the z axis and a translation of (1,0,0) the implicitXForm is set to

<value name="implicitXForm" type="Mat44">(0.707,0.707,0,0, -0.707,0.707,0,0, 0,0,1,0, -1.0,0,0.0,1)</value>

Add a Single Direction Velocity to a Grid

External Actors can add a single directional velocity to the grid using the interface

TurbulenceFSActor::setExternalVelocity(PxVec3 vel);

Note that if multiple calls to this function are made only the last call is honored (i.e. the velocities are not accumulated). Also note that that the value set by this function is persistent across simulation frames (you can call the function once to set the external wind value and until you call this function again with a new value, potentially many frames later, the previous value will continue to get used).