CUDAParticleSystemSolverBase3.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.

#ifndef CUBBYFLOW_CUDA_PARTICLE_SYSTEM_SOLVER_BASE3_HPP
#define CUBBYFLOW_CUDA_PARTICLE_SYSTEM_SOLVER_BASE3_HPP

#ifdef CUBBYFLOW_USE_CUDA

#include <Core/Animation/PhysicsAnimation.hpp>
#include <Core/CUDA/CUDAParticleSystemData3.hpp>
#include <Core/Matrix/Matrix.hpp>
#include <Core/Utils/Constants.hpp>

namespace CubbyFlow
{
class CUDAParticleSystemSolverBase3 : public PhysicsAnimation
{
 public:
    CUDAParticleSystemSolverBase3();

    CUDAParticleSystemSolverBase3(const CUDAParticleSystemSolverBase3&) =
        delete;

    CUDAParticleSystemSolverBase3(CUDAParticleSystemSolverBase3&&) noexcept =
        delete;

    ~CUDAParticleSystemSolverBase3() override = default;

    CUDAParticleSystemSolverBase3& operator=(
        const CUDAParticleSystemSolverBase3&) = delete;

    CUDAParticleSystemSolverBase3& operator=(
        CUDAParticleSystemSolverBase3&&) noexcept = delete;

    float DragCoefficient() const;

    void SetDragCoefficient(float newDragCoefficient);

    float RestitutionCoefficient() const;

    void SetRestitutionCoefficient(float newRestitutionCoefficient);

    const Vector3F& Gravity() const;

    void SetGravity(const Vector3F& newGravity);

    virtual CUDAParticleSystemData3* ParticleSystemData();

    virtual const CUDAParticleSystemData3* ParticleSystemData() const;

 protected:
    void OnInitialize() override;

    void UpdateCollider(double timeStepInSeconds);

    void UpdateEmitter(double timeStepInSeconds);

 private:
    float m_dragCoefficient = 1e-4f;
    float m_restitutionCoefficient = 0.0f;
    Vector3F m_gravity{ 0.0f, GRAVITY_FLOAT, 0.0f };
    CUDAParticleSystemData3Ptr m_particleSystemData;
};

using CUDAParticleSystemSolverBase3Ptr =
    std::shared_ptr<CUDAParticleSystemSolverBase3>;

template <typename DerivedBuilder>
class CUDAParticleSystemSolverBuilderBase3
{
 public:
    DerivedBuilder& WithDragCoefficient(float coeff);

    DerivedBuilder& WithRestitutionCoefficient(float coeff);

    DerivedBuilder& WithGravity(const Vector3F& gravity);

 protected:
    float m_dragCoefficient = 1e-4f;
    float m_restitutionCoefficient = 0.0f;
    Vector3F m_gravity{ 0.0f, GRAVITY_FLOAT, 0.0f };
};

template <typename T>
T& CUDAParticleSystemSolverBuilderBase3<T>::WithDragCoefficient(float coeff)
{
    m_dragCoefficient = coeff;
    return static_cast<T&>(*this);
}

template <typename T>
T& CUDAParticleSystemSolverBuilderBase3<T>::WithRestitutionCoefficient(
    float coeff)
{
    m_restitutionCoefficient = coeff;
    return static_cast<T&>(*this);
}

template <typename T>
T& CUDAParticleSystemSolverBuilderBase3<T>::WithGravity(const Vector3F& gravity)
{
    m_gravity = gravity;
    return static_cast<T&>(*this);
}
}  // namespace CubbyFlow

#endif

#endif