Implement a particle trail system

Author: AlexDunn

RtxOptions.md

@@ -502,6 +502,7 @@ Tables below enumerate all the options and their defaults set by RTX Remix. Note
 |rtx.particles.globalPreset.collisionRestitution|float|0.5|The fraction of velocity retained after a collision with scene geometry\. 1\.0 = perfectly elastic \(no speed loss\), 0\.0 = completely inelastic \(velocity zeroed\)\. Values outside \[0,1\] will be clamped to this range\.|
 |rtx.particles.globalPreset.collisionThickness|float|5|The maximum penetration depth \(in world units\) at which a particle will still collide with geometry\.  Particles that penetrate deeper than this value are considered to have passed through thin objects and will not collide\.|
 |rtx.particles.globalPreset.enableCollisionDetection|bool|False|Enables particle collisions with the world\.|
+|rtx.particles.globalPreset.enableMotionTrail|bool|False|Elongates the particle with respect to velocity, texture edges are preserved, with only the center being stretched which provides a motion blur like effect on the particles themselves\.  This will automatically align particles rotation with their individual velocitys \(similar to rtx\.particles\.globalPreset\.alignParticlesToVelocity\) and so rotation parameters are no longer taken into account when this setting is enabled\.|
 |rtx.particles.globalPreset.gravityForce|float|-0.5|Net influence of gravity acting on each particle \(meters per second squared\)\.|
 |rtx.particles.globalPreset.initialVelocityConeAngleDegrees|float|0|Specifies the half angle, in degrees, of the random emission cone  around the triangles surface normal when spawning a new particle\.  A value in the range of 0 to 180 degrees is expected\.|
 |rtx.particles.globalPreset.initialVelocityFromNormal|float|10|Initial speed to apply on spawn \(units/sec\) along the normal vector of the spawning triangle\.|
@@ -514,6 +515,7 @@ Tables below enumerate all the options and their defaults set by RTX Remix. Note
 |rtx.particles.globalPreset.minParticleSize|float|1|Minimum size \(in world units\) to give to a particle when spawned\.|
 |rtx.particles.globalPreset.minRotationSpeed|float|0.1|Minimum rotation speed \(in revolutions per second\) to give to a particle when spawned\.|
 |rtx.particles.globalPreset.minSpawnColor|float4|1, 1, 1, 1|Minimum range of the color to tint a particle with when spawned\.|
+|rtx.particles.globalPreset.motionTrailMultiplier|float|1|When enableMotionTrail is set to enabled, this value can be used to increase \(or decrease\) the length of the tail artificially, which is determined by the velocity\.  A value of 1 \(the default\) will ensure each particle is the exact size of the motion over the previous frame\.  Values geater than 1 will increase that size linearly\.  Likewise for smaller than 1\.  0 and below is an invalid value\.|
 |rtx.particles.globalPreset.numberOfParticlesPerMaterial|int|98304|Maximum number of particles to simulate per material simultaneously\.  There is a performance consideration, lower numbers are more performant\.  Ideal is to tune this number for your specific needs\.|
 |rtx.particles.globalPreset.spawnRatePerSecond|int|100|Number of particles \(per system\) to spawn per second on average\.|
 |rtx.particles.globalPreset.turbulenceAmplitude|float|5|How much turbulence influences the force of a particle\.|

src/dxvk/rtx_render/rtx_mod_usd.cpp

@@ -586,12 +586,14 @@ bool UsdMod::Impl::processParticleSystem(Args& args, const pxr::UsdPrim& prim) {
   READ_ATTR(float, TurbulenceAmplitude, turbulenceAmplitude);
   READ_ATTR(float, CollisionThickness, collisionThickness);
   READ_ATTR(float, CollisionRestitution, collisionRestitution);
+  READ_ATTR(float, MotionTrailMultiplier, motionTrailMultiplier);
   READ_ATTR(int, MaxNumParticles, maxNumParticles);
   READ_ATTR(bool, UseTurbulence, useTurbulence);
   READ_ATTR(bool, UseSpawnTexcoords, useSpawnTexcoords);
   READ_ATTR(bool, EnableCollisionDetection, enableCollisionDetection);
   READ_ATTR(bool, AlignParticlesToVelocity, alignParticlesToVelocity);
-  READ_ATTR(bool, SpawnRatePerSecond, spawnRate);
+  READ_ATTR(bool, EnableMotionTrail, enableMotionTrail);
+  READ_ATTR(float, SpawnRatePerSecond, spawnRate);
   READ_ATTR_CONV(GfVec4f, MaxSpawnColor, maxSpawnColor, toFloat4);
   READ_ATTR_CONV(GfVec4f, MinSpawnColor, minSpawnColor, toFloat4);
 

src/dxvk/rtx_render/rtx_particle_system.cpp

@@ -105,6 +105,10 @@ namespace dxvk {
           ImGui::DragFloat("Max Speed", &maxSpeedObject(), 0.01f, 0.f, 100000.f, "%.2f", ImGuiSliderFlags_AlwaysClamp);
 
           ImGui::Checkbox("Align Particles with Velocity", &alignParticlesToVelocityObject());
+          ImGui::Checkbox("Enable Motion Trail", &enableMotionTrailObject());
+          ImGui::BeginDisabled(!enableMotionTrail());
+          ImGui::DragFloat("Motion Trail Length Multiplier", &motionTrailMultiplierObject(), 0.01f, 0.001f, 10000.f, "%.2f", ImGuiSliderFlags_AlwaysClamp);
+          ImGui::EndDisabled();
 
           ImGui::Checkbox("Enable Particle World Collisions", &enableCollisionDetectionObject());
           ImGui::BeginDisabled(!enableCollisionDetection());
@@ -141,6 +145,7 @@ namespace dxvk {
     constants.upDirection.y = ctx->getSceneManager().getSceneUp().y;
     constants.upDirection.z = ctx->getSceneManager().getSceneUp().z;
     constants.deltaTimeSecs = GlobalTime::get().deltaTime() * timeScale();
+    constants.invDeltaTimeSecs = 1.f / constants.deltaTimeSecs;
     constants.absoluteTimeSecs = GlobalTime::get().absoluteTimeMs() * 0.001f * timeScale();
   }
 
@@ -172,6 +177,8 @@ namespace dxvk {
     desc.alignParticlesToVelocity = RtxParticleSystemManager::alignParticlesToVelocity() ? 1 : 0;
     desc.collisionRestitution = RtxParticleSystemManager::collisionRestitution();
     desc.collisionThickness = RtxParticleSystemManager::collisionThickness();
+    desc.enableMotionTrail = RtxParticleSystemManager::enableMotionTrail() ? 1 : 0;
+    desc.motionTrailMultiplier = RtxParticleSystemManager::motionTrailMultiplier();
     return desc;
   }
 
@@ -198,7 +205,7 @@ namespace dxvk {
   uint32_t RtxParticleSystemManager::getNumberOfParticlesToSpawn(ParticleSystem* particleSystem, const DrawCallState& drawCallState) {
     ScopedCpuProfileZone();
 
-    float lambda = spawnRatePerSecond() * GlobalTime::get().deltaTime();
+    float lambda = particleSystem->context.desc.spawnRate * GlobalTime::get().deltaTime();
 
     // poisson dist wont work well with these values (inf loop)
     if (isnan(lambda) || lambda < 0.0f) {
@@ -423,6 +430,46 @@ namespace dxvk {
     }
   }
 
+  RtxParticleSystemManager::ParticleSystem::ParticleSystem(const RtxParticleSystemDesc& desc, const MaterialData& matData, const CategoryFlags& cats, const uint32_t seed) : context(desc)
+    , materialData(matData)
+    , categories(cats) {
+    // Seed the RNG with a parameter from the manager, so we get unique random values for each particle system
+    generator = std::default_random_engine(seed);
+    // Store this hash since it cannot change now.
+    // NOTE: This material data hash is stable within a run, but since hash depends on VK handles, it is not reliable across runs.
+    m_cachedHash = materialData.getHash() ^ context.desc.calcHash();
+    context.numVerticesPerParticle = getVerticesPerParticle();
+
+    // classic square billboard
+    static const float2 offsets[4] = {
+        float2(-0.5f,  0.5f),
+        float2(0.5f,  0.5f),
+        float2(-0.5f, -0.5f),
+        float2(0.5f, -0.5f)
+    };
+
+    // motion trail - first 4 are "head", last 4 are "tail"
+    static const float2 offsetsMotionTrail[8] = {
+      // TAIL quad (fixed)
+      float2(-0.5f, -0.5f),
+      float2(-0.5f,  0.0f),
+      float2( 0.5f, -0.5f),
+      float2( 0.5f,  0.0f),
+
+      // HEAD quad (stretched)
+      float2(-0.5f, 0.0f),
+      float2(-0.5f, 0.5f),
+      float2( 0.5f, 0.0f),
+      float2( 0.5f, 0.5f)
+    };
+
+    if (desc.enableMotionTrail) {
+      memcpy(&context.particleVertexOffsets[0], &offsetsMotionTrail[0], sizeof(offsetsMotionTrail));
+    } else {
+      memcpy(&context.particleVertexOffsets[0], &offsets[0], sizeof(offsets));
+    }
+  }
+
   void RtxParticleSystemManager::ParticleSystem::allocStaticBuffers(DxvkContext* ctx) {
     ScopedCpuProfileZone();
 
@@ -446,11 +493,11 @@ namespace dxvk {
       ctx->clearBuffer(m_particles, 0, info.size, 0);
     }
 
-    if (m_vb == nullptr || m_vb->info().size != sizeof(ParticleVertex) * context.desc.maxNumParticles * 4) {
+    if (m_vb == nullptr || m_vb->info().size != sizeof(ParticleVertex) * getVertexCount()) {
       const Rc<DxvkDevice>& device = ctx->getDevice();
 
       DxvkBufferCreateInfo info;
-      info.size = sizeof(ParticleVertex) * context.desc.maxNumParticles * 4;
+      info.size = sizeof(ParticleVertex) * getVertexCount();
       info.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
         | VK_BUFFER_USAGE_TRANSFER_DST_BIT
         | VK_BUFFER_USAGE_TRANSFER_SRC_BIT
@@ -465,27 +512,48 @@ namespace dxvk {
       ctx->clearBuffer(m_vb, 0, info.size, 0);
     }
 
-    if (m_ib == nullptr || m_ib->info().size != sizeof(uint32_t) * context.desc.maxNumParticles * 6) {
+    if (m_ib == nullptr || m_ib->info().size != sizeof(uint32_t) * getIndexCount()) {
       const Rc<DxvkDevice>& device = ctx->getDevice();
 
       DxvkBufferCreateInfo info;
-      info.size = sizeof(uint32_t) * context.desc.maxNumParticles * 6;
+      info.size = sizeof(uint32_t) * getIndexCount();
       info.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
-        | VK_BUFFER_USAGE_TRANSFER_DST_BIT
-        | VK_BUFFER_USAGE_TRANSFER_SRC_BIT
-        | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR;
+                 | VK_BUFFER_USAGE_TRANSFER_DST_BIT
+                 | VK_BUFFER_USAGE_TRANSFER_SRC_BIT
+                 | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR;
       info.stages = VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
       info.access = VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_TRANSFER_READ_BIT;
       m_ib = device->createBuffer(info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, DxvkMemoryStats::Category::RTXBuffer, "RTX Particles - Index Buffer");
 
-      std::vector<uint32_t> indices(context.desc.maxNumParticles * 6);
+      std::vector<uint32_t> indices(getIndexCount());
       for (int i = 0; i < context.desc.maxNumParticles; i++) {
-        indices[i * 6 + 0] = i * 4 + 0;
-        indices[i * 6 + 1] = i * 4 + 1;
-        indices[i * 6 + 2] = i * 4 + 2;
-        indices[i * 6 + 3] = i * 4 + 2;
-        indices[i * 6 + 4] = i * 4 + 1;
-        indices[i * 6 + 5] = i * 4 + 3;
+        indices[i * getIndicesPerParticle() + 0] = i * getVerticesPerParticle() + 0;
+        indices[i * getIndicesPerParticle() + 1] = i * getVerticesPerParticle() + 1;
+        indices[i * getIndicesPerParticle() + 2] = i * getVerticesPerParticle() + 2;
+
+        indices[i * getIndicesPerParticle() + 3] = i * getVerticesPerParticle() + 2;
+        indices[i * getIndicesPerParticle() + 4] = i * getVerticesPerParticle() + 1;
+        indices[i * getIndicesPerParticle() + 5] = i * getVerticesPerParticle() + 3;
+      }
+
+      if (context.desc.enableMotionTrail) {
+        for (int i = 0; i < context.desc.maxNumParticles; i++) {
+          indices[i * getIndicesPerParticle() + 6]  = i * getVerticesPerParticle() + 1;
+          indices[i * getIndicesPerParticle() + 7]  = i * getVerticesPerParticle() + 4;
+          indices[i * getIndicesPerParticle() + 8]  = i * getVerticesPerParticle() + 3;
+
+          indices[i * getIndicesPerParticle() + 9]  = i * getVerticesPerParticle() + 3;
+          indices[i * getIndicesPerParticle() + 10] = i * getVerticesPerParticle() + 4;
+          indices[i * getIndicesPerParticle() + 11] = i * getVerticesPerParticle() + 6;
+
+          indices[i * getIndicesPerParticle() + 12] = i * getVerticesPerParticle() + 4;
+          indices[i * getIndicesPerParticle() + 13] = i * getVerticesPerParticle() + 5;
+          indices[i * getIndicesPerParticle() + 14] = i * getVerticesPerParticle() + 6;
+
+          indices[i * getIndicesPerParticle() + 15] = i * getVerticesPerParticle() + 6;
+          indices[i * getIndicesPerParticle() + 16] = i * getVerticesPerParticle() + 5;
+          indices[i * getIndicesPerParticle() + 17] = i * getVerticesPerParticle() + 7;
+        }
       }
 
       ctx->updateBuffer(m_ib, 0, info.size, indices.data());

src/dxvk/rtx_render/rtx_particle_system.h

@@ -75,16 +75,7 @@ namespace dxvk {
       uint32_t generationIdx = 0;
 
       ParticleSystem() = delete;
-      ParticleSystem(const RtxParticleSystemDesc& desc, const MaterialData& matData, const CategoryFlags& cats, const uint32_t seed)
-        : context(desc)
-        , materialData(matData)
-        , categories(cats) {
-        // Seed the RNG with a parameter from the manager, so we get unique random values for each particle system
-        generator = std::default_random_engine(seed);
-        // Store this hash since it cannot change now.
-        // NOTE: This material data hash is stable within a run, but since hash depends on VK handles, it is not reliable across runs.
-        m_cachedHash = materialData.getHash() ^ context.desc.calcHash();
-      }
+      ParticleSystem(const RtxParticleSystemDesc& desc, const MaterialData& matData, const CategoryFlags& cats, const uint32_t seed);
 
       XXH64_hash_t getHash() const {
         return m_cachedHash;
@@ -110,12 +101,20 @@ namespace dxvk {
         return generationIdx;
       }
 
+      uint32_t getVerticesPerParticle() const {
+        return context.desc.enableMotionTrail ? 8 : 4;
+      }
+
+      uint32_t getIndicesPerParticle() const {
+        return context.desc.enableMotionTrail ? 18 : 6;
+      }
+
       uint32_t getVertexCount() const {
-        return context.desc.maxNumParticles * 4;
+        return context.desc.maxNumParticles * getVerticesPerParticle();
       }
 
       uint32_t getIndexCount() const {
-        return context.desc.maxNumParticles * 6;
+        return context.desc.maxNumParticles * getIndicesPerParticle();
       }
 
       void allocStaticBuffers(DxvkContext* pCtx);
@@ -157,6 +156,8 @@ namespace dxvk {
     RTX_OPTION("rtx.particles.globalPreset", bool, useTurbulence, true, "Enable turbulence simulation.");
     RTX_OPTION("rtx.particles.globalPreset", float, turbulenceAmplitude, 5.f, "How much turbulence influences the force of a particle.");
     RTX_OPTION("rtx.particles.globalPreset", float, turbulenceFrequency, .05f, "The rate of change of turbulence forces.");
+    RTX_OPTION("rtx.particles.globalPreset", bool, enableMotionTrail, false, "Elongates the particle with respect to velocity, texture edges are preserved, with only the center being stretched which provides a motion blur like effect on the particles themselves.  This will automatically align particles rotation with their individual velocitys (similar to rtx.particles.globalPreset.alignParticlesToVelocity) and so rotation parameters are no longer taken into account when this setting is enabled.");
+    RTX_OPTION("rtx.particles.globalPreset", float, motionTrailMultiplier, 1.f, "When enableMotionTrail is set to enabled, this value can be used to increase (or decrease) the length of the tail artificially, which is determined by the velocity.  A value of 1 (the default) will ensure each particle is the exact size of the motion over the previous frame.  Values geater than 1 will increase that size linearly.  Likewise for smaller than 1.  0 and below is an invalid value.");
 
 
     void setupConstants(RtxContext* ctx, ParticleSystemConstants& constants);

src/dxvk/shaders/rtx/pass/particles/particle_system_common.h

@@ -72,8 +72,8 @@ struct RtxParticleSystemDesc {
   uint8_t enableCollisionDetection;
 
   float collisionRestitution;
-  uint pad0;
-  uint pad1;
+  uint enableMotionTrail;
+  float motionTrailMultiplier;
   uint pad2;
 
 #ifdef __cplusplus
@@ -91,10 +91,12 @@ struct RtxParticleSystemDesc {
 struct GpuParticleSystem { 
   RtxParticleSystemDesc desc; // TODO: Can compress this further.
 
-  // These members arent hashed
+  // These members aren't hashed
+  float2 particleVertexOffsets[8];
+
   uint spawnParticleOffset = 0;
   uint spawnParticleCount = 0;
-  uint pad0;
+  uint numVerticesPerParticle = 4;
   uint pad1;
 
 #ifndef __cplusplus
@@ -138,6 +140,7 @@ struct ParticleSystemConstants {
   float deltaTimeSecs;
 
   float absoluteTimeSecs;
+  float invDeltaTimeSecs;
   uint frameIdx;
   uint16_t renderingWidth;
   uint16_t renderingHeight;