VolumeFluidEmitter.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <cstdint>
#include "common/Result.h"
#include "fluids/VolumeFluid.h"
 
namespace eve::fluids {
 
enum class VolumeFluidEmissionShape { Edge, Square, Disk, Sphere, Cube, Distribution };
 
struct VolumeFluidEmitterBlueprintMetrics {
    float particleSize = 0.1f;
    float particleMass = 1.f;
    float smoothingRadius = 0.2f;
};
 
struct VolumeFluidEmitterBlueprint3D {
    unsigned  capacity   = 1000;
    float     resolution = 1.f, restDensity = 1000.f, smoothing = 2.f;
    float     viscosity = .05f, surfaceTension = 1.f;
    float     buoyancy = -1.f, atmosphericDrag = 0.f, atmosphericPressure = 0.f, vorticity = 0.f;
    float     diffusion = 0.f;
    glm::vec4 diffusionData{0.f};
};
 
struct VolumeGranularEmitterBlueprint3D {
    unsigned capacity   = 1000;
    float    resolution = 1.f, restDensity = 1000.f;
    float randomness = 0.f;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<VolumeFluidEmitterBlueprintMetrics> evaluateVolumeFluidEmitterBlueprint3D(
    float resolution, float restDensity, float smoothing);
 
struct VolumeFluidDistributionPoint {
    glm::vec3 position{0.f};
    glm::vec4 color{1.f};
    glm::vec3 direction{0.f, 0.f, 1.f};
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::vector<VolumeFluidDistributionPoint>> buildVolumeFluidImageDistribution(
    std::span<const glm::vec4> pixels, unsigned width, unsigned height, float pixelScale, float maximumSize,
    float spacing, float alphaThreshold);
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::vector<VolumeFluidDistributionPoint>> buildVolumeFluidMeshDistribution(
    std::span<const glm::vec3> vertices, std::span<const uint32_t> indices, glm::vec3 scale, float spacing);
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::vector<VolumeFluidDistributionPoint>> buildVolumeFluidSphereDistribution(
    float radius, float spacing, bool surface);
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::vector<VolumeFluidDistributionPoint>> buildVolumeFluidCubeDistribution(
    glm::vec3 size, float spacing, bool surface);
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::vector<VolumeFluidDistributionPoint>> buildVolumeFluidEdgeDistribution(
    float length, float spacing, float radialVelocityDegrees);
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::vector<VolumeFluidDistributionPoint>> buildVolumeFluidDiskDistribution(
    float radius, float spacing, bool edgeEmission);
 
struct VolumeFluidEmission {
    VolumeFluidEmissionShape shape = VolumeFluidEmissionShape::Disk;
    glm::vec3                origin{0.f, 1.f, 0.f};
    glm::vec3                direction{0.f, -1.f, 0.f};
    glm::vec3 extent{0.1f};
    float speed = 1.f, jitter = 0.f;
    float randomVelocity = 0.f;
    bool useShapeColor = true;
    unsigned actorCapacity = 1000;
    float granularRadiusRandomness = 0.f;
    VolumeFluidParticle prototype;
    uint32_t seed = 1;
    std::vector<VolumeFluidDistributionPoint> distribution;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<VolumeFluidEmission> composeVolumeFluidEmitterShapes(
    const VolumeFluidEmission& base, std::span<const VolumeFluidEmission> shapes);
 
struct VolumeFluidEmitterBlueprintApplication3D {
    VolumeFluidSettings                settings;
    VolumeFluidEmission                emission;
    VolumeFluidEmitterBlueprintMetrics metrics;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<VolumeFluidEmitterBlueprintApplication3D>
                                   prepareVolumeFluidEmitterBlueprint3D(const VolumeFluidEmitterBlueprint3D& blueprint);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<VolumeFluidEmitterBlueprintApplication3D>
prepareVolumeGranularEmitterBlueprint3D(const VolumeGranularEmitterBlueprint3D& blueprint);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<unsigned> emitVolumeFluidBurst(VolumeFluid&               solver,
                                                                         const VolumeFluidEmission& emission,
                                                                         unsigned                   count);
 
struct VolumeFluidEmitterSnapshot {
    std::string schema  = "eve.volume-fluid-emitter-state";
    unsigned    version = 1;
    unsigned    kind    = 0;
    std::string phase    = "0";
    uint32_t    sequence = 0;
    bool        emitting = false;
};
 
struct VolumeFluidEmitterCheckpoint {
    std::string                schema  = "eve.volume-fluid-emitter-checkpoint";
    unsigned                   version = 1;
    VolumeFluidSnapshot        solver;
    VolumeFluidEmission        emission;
    VolumeFluidEmitterSnapshot controller;
};
 
struct VolumeFluidNozzlePose {
    glm::vec3 position{0.f};
    glm::vec4 rotation{0.f, 0.f, 0.f, 1.f};
};
 
class EVENGINE_API_DOMAINS VolumeFluidEmitter final {
public:
    [[nodiscard]] Result<unsigned> emitParticle(VolumeFluid& solver, const VolumeFluidEmission& emission, float offset,
                                                float dt);
    [[nodiscard]] Result<unsigned> advance(VolumeFluid& solver, const VolumeFluidEmission& emission, float dt,
                                           float rate, unsigned maxPerStep = 256, float minimumPoolFraction = 0.5f);
    [[nodiscard]] Result<unsigned> advanceBurst(VolumeFluid& solver, const VolumeFluidEmission& emission,
                                                unsigned count, float minimumPoolFraction = 0.5f);
    [[nodiscard]] bool isEmitting() const noexcept { return emitting_; }
    [[nodiscard]] VolumeFluidEmitterSnapshot snapshot() const;
    [[nodiscard]] Result<void> restore(const VolumeFluidEmitterSnapshot& state);
 
private:
    double   credit_   = 0.0;
    uint32_t sequence_ = 0;
    bool     emitting_ = false;
};
 
class EVENGINE_API_DOMAINS VolumeFluidJetEmitter final {
public:
    [[nodiscard]] Result<unsigned> advanceMoving(VolumeFluid& solver, const VolumeFluidEmission& emission,
                                                 const VolumeFluidNozzlePose& begin, const VolumeFluidNozzlePose& end,
                                                 float dt, unsigned maxPerStep = 256, float minimumPoolFraction = 0.5f,
                                                 float inheritVelocity = 0.f);
    [[nodiscard]] Result<unsigned> advance(VolumeFluid& solver, const VolumeFluidEmission& emission, float dt,
                                           unsigned maxPerStep = 256, float minimumPoolFraction = 0.5f);
    [[nodiscard]] bool isEmitting() const noexcept { return emitting_; }
    [[nodiscard]] VolumeFluidEmitterSnapshot snapshot() const;
    [[nodiscard]] Result<void> restore(const VolumeFluidEmitterSnapshot& state);
 
private:
    std::vector<VolumeFluidDistributionPoint> layerPoints_;
    double                                    distance_ = 0.0;
    uint32_t                                  sequence_ = 0;
    bool                                      emitting_ = false;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS VolumeFluidEmitterCheckpoint captureVolumeFluidEmitterCheckpoint(
    const VolumeFluid& solver, const VolumeFluidEmission& emission, const VolumeFluidEmitter& controller);
[[nodiscard]] EVENGINE_API_DOMAINS VolumeFluidEmitterCheckpoint captureVolumeFluidEmitterCheckpoint(
    const VolumeFluid& solver, const VolumeFluidEmission& emission, const VolumeFluidJetEmitter& controller);
[[nodiscard]] EVENGINE_API_DOMAINS Result<void> restoreVolumeFluidEmitterCheckpoint(
    VolumeFluid& solver, VolumeFluidEmitter& controller, const VolumeFluidEmitterCheckpoint& checkpoint);
[[nodiscard]] EVENGINE_API_DOMAINS Result<void> restoreVolumeFluidEmitterCheckpoint(
    VolumeFluid& solver, VolumeFluidJetEmitter& controller, const VolumeFluidEmitterCheckpoint& checkpoint);
 
}  // namespace eve::fluids