MeshParticleEmitter.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "graphics/Color.h"
 
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
 
#include <cstdint>
#include <span>
#include <vector>
 
namespace eve::stylize {
 
enum class MeshParticleShape : std::uint8_t { Point, Sphere, Box, Cone };
 
struct MeshParticleBurst {
    float timeSeconds = 0.f;
    std::uint32_t count = 0;
};
 
struct MeshParticleScalarKey {
    float time = 0.f;
    float value = 1.f;
};
 
struct MeshParticleColorKey {
    float time = 0.f;
    graphics::Color value{1.f};
};
 
struct MeshParticleEmitterConfig {
    std::uint32_t capacity = 1024;
    float emissionRate = 0.f;
    float lifetimeMin = 1.f;
    float lifetimeMax = 1.f;
    float speedMin = 0.f;
    float speedMax = 0.f;
    glm::vec3 direction{0.f, 1.f, 0.f};
    MeshParticleShape shape = MeshParticleShape::Point;
    glm::vec3 boxExtents{0.5f};
    float sphereRadius = 0.5f;
    float coneAngleRadians = 0.5f;
    glm::vec3 gravity{0.f};
    float damping = 0.f;
    float rotationMinRadians = 0.f;
    float rotationMaxRadians = 0.f;
    float angularVelocityMin = 0.f;
    float angularVelocityMax = 0.f;
    float scaleStart = 1.f;
    float scaleEnd = 0.f;
    graphics::Color colorStart{1.f};
    graphics::Color colorEnd{1.f, 1.f, 1.f, 0.f};
    std::vector<MeshParticleScalarKey> scaleCurve;
    std::vector<MeshParticleScalarKey> velocityCurve;
    std::vector<MeshParticleColorKey> colorGradient;
    float fixedStepSeconds = 1.f / 60.f;
    std::uint32_t maximumSubsteps = 8;
    std::uint32_t randomSeed = 1;
    float loopDurationSeconds = 0.f;
    bool looping = false;
    std::vector<MeshParticleBurst> bursts;
};
 
struct MeshParticleInstance {
    std::uint64_t stableId = 0;
    glm::mat4 model{1.f};
    graphics::Color color{1.f};
    float normalizedAge = 0.f;
};
 
struct MeshParticleAdvanceReport {
    std::uint32_t simulatedSteps = 0;
    std::uint32_t spawned = 0;
    std::uint32_t expired = 0;
    std::uint32_t dropped = 0;
    std::uint32_t alive = 0;
    float discardedTimeSeconds = 0.f;
};
 
class EVENGINE_API_WORLD MeshParticleEmitter {
public:
    explicit MeshParticleEmitter(MeshParticleEmitterConfig config = {});
 
    ~MeshParticleEmitter();
 
    // Class-level dllexport instantiates every member, and the implicitly declared
    // copy assignment would instantiate `std::vector<Particle>::operator=`, which
    // needs a complete `Particle` -- but `Particle` is only forward declared here
    // (defined in the .cpp), so that is `error C2036: unknown size` in every TU that
    // includes this header.  A user-declared destructor does *not* suppress the
    // implicit copy assignment.  The emitter owns live particle state and was never
    // copied anywhere in the tree, so deleting the copy operations preserves the
    // existing semantics without requiring the private type to be complete.
    MeshParticleEmitter(const MeshParticleEmitter&)            = delete;
    MeshParticleEmitter& operator=(const MeshParticleEmitter&) = delete;
 
    void start();
 
    void stop() noexcept { emitting_ = false; }
 
    void reset();
 
    void setOrigin(const glm::vec3& origin) noexcept { origin_ = origin; }
 
    [[nodiscard]] std::uint32_t emit(std::uint32_t count);
 
    [[nodiscard]] MeshParticleAdvanceReport advance(float deltaSeconds);
 
    [[nodiscard]] std::vector<MeshParticleInstance> snapshot() const;
 
    [[nodiscard]] const MeshParticleEmitterConfig& config() const noexcept { return config_; }
 
    [[nodiscard]] std::size_t size() const noexcept;
 
private:
    struct Particle;
 
    void simulateStep(float dt, MeshParticleAdvanceReport& report);
    [[nodiscard]] std::uint32_t spawn(std::uint32_t count, MeshParticleAdvanceReport* report);
    [[nodiscard]] float randomUnit();
    [[nodiscard]] glm::vec3 randomDirection();
    [[nodiscard]] glm::vec3 spawnOffset();
 
    MeshParticleEmitterConfig config_;
    std::vector<Particle> particles_;
    glm::vec3 origin_{0.f};
    std::uint32_t randomState_ = 1;
    std::uint64_t nextStableId_ = 1;
    float accumulator_ = 0.f;
    float timeline_ = 0.f;
    float emissionAccumulator_ = 0.f;
    std::size_t nextBurst_ = 0;
    bool emitting_ = false;
};
 
}  // namespace eve::stylize