IMaterial.h

Go to the documentation of this file.

#pragma once
 
 
#include "math/rng/Rng.h"
#include "objects/containers/FlatMap.h"
#include "objects/utility/IteratorAdapters.h"
#include "objects/wrappers/SharedPtr.h"
#include "quantities/QuantityIds.h"
#include "sph/initial/UvMapping.h"
#include "system/Settings.h"
 
NAMESPACE_SPH_BEGIN
 
class Storage;
class IMaterial;
class IScheduler;
 
class MaterialView {
private:
    RawPtr<IMaterial> mat;
    IndexSequence seq;
 
public:
    INLINE MaterialView(RawPtr<IMaterial>&& material, IndexSequence seq)
        : mat(std::move(material))
        , seq(seq) {
        SPH_ASSERT(material != nullptr);
    }
 
    INLINE IMaterial& material() {
        SPH_ASSERT(mat != nullptr);
        return *mat;
    }
 
    INLINE IMaterial& material() const {
        SPH_ASSERT(mat != nullptr);
        return *mat;
    }
 
    INLINE operator IMaterial&() {
        return this->material();
    }
 
    INLINE operator const IMaterial&() const {
        return this->material();
    }
 
    INLINE RawPtr<IMaterial> operator->() {
        return &this->material();
    }
 
    INLINE RawPtr<const IMaterial> operator->() const {
        return &this->material();
    }
 
    INLINE IndexSequence sequence() {
        return seq;
    }
 
    INLINE const IndexSequence sequence() const {
        return seq;
    }
};
 
 
struct MaterialInitialContext {
    AutoPtr<IRng> rng;
 
    SharedPtr<IScheduler> scheduler;
 
    Float kernelRadius = 2._f;
 
    AutoPtr<IUvMapping> uvMap = nullptr;
 
    MaterialInitialContext() = default;
 
    explicit MaterialInitialContext(const RunSettings& settings);
};
 
class IMaterial : public Polymorphic {
protected:
    BodySettings params;
 
    FlatMap<QuantityId, Float> minimals;
 
    FlatMap<QuantityId, Interval> ranges;
 
    const static Interval DEFAULT_RANGE;
    const static Float DEFAULT_MINIMAL;
 
public:
    explicit IMaterial(const BodySettings& settings)
        : params(settings) {}
 
    template <typename TValue>
    INLINE IMaterial& setParam(const BodySettingsId paramIdx, TValue&& value) {
        params.set(paramIdx, std::forward<TValue>(value));
        return *this;
    }
 
    template <typename TValue>
    INLINE TValue getParam(const BodySettingsId paramIdx) const {
        return params.get<TValue>(paramIdx);
    }
 
    INLINE const BodySettings& getParams() const {
        return params;
    }
 
    void setRange(const QuantityId id, const Interval& range, const Float minimal);
 
    INLINE void setRange(const QuantityId id, const BodySettingsId rangeId, const BodySettingsId minimalId) {
        this->setRange(id, params.get<Interval>(rangeId), params.get<Float>(minimalId));
    }
 
    INLINE Float minimal(const QuantityId id) const {
        return minimals.tryGet(id).valueOr(DEFAULT_MINIMAL);
    }
 
    INLINE const Interval range(const QuantityId id) const {
        return ranges.tryGet(id).valueOr(DEFAULT_RANGE);
    }
 
    virtual void create(Storage& storage, const MaterialInitialContext& context) = 0;
 
    virtual void initialize(IScheduler& scheduler, Storage& storage, const IndexSequence sequence) = 0;
 
    virtual void finalize(IScheduler& scheduler, Storage& storage, const IndexSequence sequence) = 0;
};
 
 
class NullMaterial : public IMaterial {
public:
    explicit NullMaterial(const BodySettings& body)
        : IMaterial(body) {}
 
    virtual void create(Storage& UNUSED(storage), const MaterialInitialContext& UNUSED(context)) override {}
 
    virtual void initialize(IScheduler& UNUSED(scheduler),
        Storage& UNUSED(storage),
        const IndexSequence UNUSED(sequence)) override {}
 
    virtual void finalize(IScheduler& UNUSED(scheduler),
        Storage& UNUSED(storage),
        const IndexSequence UNUSED(sequence)) override {}
};
 
NAMESPACE_SPH_END