FluidTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditableTarget.h"
#include "editing/EditingAuthority.h"
#include "editing/EditingProperty.h"
 
#include <string>
#include <vector>
 
namespace eve::fluids {
class FluidSimulation;
}
 
namespace eve::fluids_editing {
 
using CapabilityId       = editing::CapabilityId;
using DiagnosticSeverity = editing::DiagnosticSeverity;
using DomainOperation    = editing::DomainOperation;
using EditRegion         = editing::EditRegion;
using EditorDiagnostic   = editing::Diagnostic;
 
using editing::Result;
using EditorStatus           = editing::Status;
using EditorValue            = editing::Value;
using IDomainOperationTarget = editing::IDomainOperationTarget;
using IEditableTarget        = editing::IEditableTarget;
using IPropertyProvider      = editing::IPropertyProvider;
using PropertyDescriptor     = editing::PropertyDescriptor;
using PropertyFlag           = editing::PropertyFlag;
using PropertyPath           = editing::PropertyPath;
using PropertyReadResult     = editing::PropertyReadResult;
using PropertyReadState      = editing::PropertyReadState;
using PropertySchema         = editing::PropertySchema;
using PropertySetMode        = editing::PropertySetMode;
using PropertyType           = editing::PropertyType;
using Revision               = editing::Revision;
using RuleId                 = editing::RuleId;
using SelectionSnapshot      = editing::SelectionSnapshot;
using TargetDescriptor       = editing::TargetDescriptor;
using TargetId               = editing::TargetId;
 
using editing::validatePropertyValue;
 
struct FluidSimulationSettings {
    int    maxParticles     = 10000;
    int    previewParticles = 1000;
    double particleRadius   = 0.05;
    double supportRadius    = 0.20;
    double restDensity      = 1.0;
    double gravityX = 0.0, gravityY = -9.8, gravityZ = 0.0;
    double viscosity       = 0.02;
    double yieldStress     = 0.0;
    double cohesion        = 0.0;
    double adhesion        = 0.0;
    double damping         = 0.0;
    double maximumVelocity = 20.0;
    int    iterations      = 1;
    int    pbfIterations   = 2;
};
 
struct FluidSimulationPreview {
    EditorStatus                  status                  = EditorStatus::Failed;
    Revision                      documentRevision        = 0;
    std::uint64_t                 estimatedBytes          = 0;
    std::uint64_t                 estimatedNeighborChecks = 0;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class EVENGINE_API_ORCHESTRATION FluidSimulationTarget final : public ::eve::editing::EditableTargetState,
                                                               public virtual IEditableTarget,
                                                               public IDomainOperationTarget,
                                                               public IPropertyProvider {
public:
    explicit FluidSimulationTarget(std::string id);
    TargetId         targetId() const override { return TargetId(id_); }
    TargetDescriptor describe() const override;
    void*                         queryCapability(const CapabilityId& capability) override;
    Result<void>            applyDomainOperation(const DomainOperation& operation) override;
    eve::Result<eve::Revision>    currentRevision(const SelectionSnapshot& selection) const override;
    PropertySchema                schema(const SelectionSnapshot& selection) const override;
    PropertyReadResult            read(const SelectionSnapshot& selection, const PropertyPath& path) const override;
    Result<DomainOperation> makeSet(const SelectionSnapshot& selection, const PropertyPath& path,
                                          const EditorValue& value, PropertySetMode mode) const override;
    Result<DomainOperation> makeReset(const SelectionSnapshot& selection,
                                            const PropertyPath&      path) const override;
    FluidSimulationSettings settings() const { return settings_; }
    std::vector<EditorDiagnostic> validate() const;
    FluidSimulationPreview previewBudget(std::uint64_t byteBudget     = 256ULL * 1024ULL * 1024ULL,
                                         std::uint64_t neighborBudget = 100000000ULL) const;
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    bool                    matches(const SelectionSnapshot& selection) const;
    std::string             id_;
    FluidSimulationSettings settings_;
};
 
class FluidSimulationRuntimeApplier {
public:
    Result<void> apply(const FluidSimulationTarget& target, fluids::FluidSimulation* simulation) const;
};
 
}  // namespace eve::fluids_editing