include/Environment.h

Go to the documentation of this file.

#ifndef ENVIRONMENT_H
#define ENVIRONMENT_H

#include <vector>

#include "ngl/Transformation.h"
#include "ngl/TransformStack.h"
#include "ngl/Obj.h"
#include "ngl/Vector.h"

#include "ShaderLibrary.h"
#include "Particle.h"
#include "Capsule.h"
#include "Integration.h"


class Environment
{
public:
    Environment();

    ~Environment();

    void loadGeometry();

    void draw
            (
                ngl::TransformStack _txStack,
                ShaderLibrary* io_sman,
                const std::string _boundaryShader,
                const std::string _obstacleShader
            );

    void checkAndResolveCollision
            (
                Particle& io_currentParticle,
                bool& o_hitBoundary,
                bool& o_hitRBD,
                const bool _fromRBD
            );

    void updateObstacles(Integration* _integration);

    std::vector<std::vector<ngl::Vector> > getBoundaryPositionList();

    std::vector<std::string> getBoundaryNameList();

    std::vector<std::vector<ngl::Vector> > getSpherePositionList();

    std::vector<std::string> getSphereNameList();

    std::vector<std::vector<ngl::Vector> > getCapsulePositionList();

    std::vector<std::string> getCapsuleNameList();

    inline std::vector<Particle>& getSphereObstacleList() { return m_sphereObstacleList; }

    inline std::vector<Capsule>& getCapsuleObstacleList() { return m_capsuleObstacleList; }


    inline bool getObstacleEnabled() const { return m_obstacleEnabled; }

    inline ngl::Vector getBoundaryDimension() const { return m_boundaryDimension; }

    inline ngl::Vector getBoundaryPosition() const { return m_boundaryPosition; }

    inline bool getBoundaryBoundTop() const { return m_boundaryBoundTop; }

    inline ngl::Real getBoundaryRestitutionCoefficientForFluid() const { return m_boundaryRestitutionCoefficientForFluid; }

    inline ngl::Real getBoundaryRestitutionCoefficientForRBD() const { return m_boundaryRestitutionCoefficientForRBD; }

    inline ngl::Real getObstacleRestitutionCoefficient() const { return m_obstacleRestitutionCoefficient; }

    inline int getCapsuleResolution() const { return m_capsuleResolution; }

    inline bool getPeriodicWallEnabled() const { return m_periodicWallEnabled; }

    inline ngl::Real getPeriodicWallMaxAmplitude() const { return m_periodicWallMaxAmplitude; }

    inline ngl::Real getPeriodicWallSpeed() const { return m_periodicWallSpeed; }

    inline ngl::Real getAngleOfPeriodicWall() const { return m_angleOfPeriodicWall; }

    inline ngl::Real getPeriodicWallAngleIncrement() const { return m_periodicWallAngleIncrement; }



    inline void setObstacleEnabled(const bool _v) { m_obstacleEnabled = _v; }

    inline void setBoundaryDimension(const ngl::Vector _v)
    {
        m_boundaryDimension = _v;
        delete m_boundaryBBox;
        m_boundaryBBox = new ngl::BBox(m_boundaryPosition, m_boundaryDimension.m_x, m_boundaryDimension.m_y, m_boundaryDimension.m_z);
    }

    inline void setBoundaryPosition(ngl::Vector _v) { m_boundaryPosition = _v; m_boundaryBBox->setCenter(_v); }

    inline void setBoundaryBoundTop(const bool _v) { m_boundaryBoundTop = _v; }

    inline void setBoundaryRestitutionCoefficientForFluid(const ngl::Real _v) { m_boundaryRestitutionCoefficientForFluid = _v; }

    inline void setBoundaryRestitutionCoefficientForRBD(const ngl::Real _v) { m_boundaryRestitutionCoefficientForRBD = _v; }

    inline void setObstacleRestitutionCoefficient(const ngl::Real _v) { m_obstacleRestitutionCoefficient = _v; }

    inline void setCapsuleResolution(const int _v) { m_capsuleResolution = _v; }

    inline void setPeriodicWallEnabled(const bool _v) { m_periodicWallEnabled = _v; }

    inline void setPeriodicWallMaxAmplitude(const ngl::Real _v) { m_periodicWallMaxAmplitude = _v; }

    inline void setPeriodicWallSpeed(const ngl::Real _v) { m_periodicWallSpeed = _v; }

    inline void setAngleOfPeriodicWall(const ngl::Real _v) { m_angleOfPeriodicWall = _v; }

    inline void setPeriodicWallAngleIncrement(const ngl::Real _v) { m_periodicWallAngleIncrement = _v; }


private:
    bool m_obstacleEnabled;

    ngl::Vector m_boundaryDimension;

    ngl::Vector m_boundaryPosition;

    ngl::BBox* m_boundaryBBox;

    bool m_boundaryBoundTop;

    ngl::Real m_boundaryRestitutionCoefficientForFluid;

    ngl::Real m_boundaryRestitutionCoefficientForRBD;

    ngl::Real m_obstacleRestitutionCoefficient;

    std::vector<Particle> m_sphereObstacleList;

    std::vector<Capsule> m_capsuleObstacleList;

    int m_capsuleResolution;

    bool m_periodicWallEnabled;

    ngl::Real m_periodicWallMaxAmplitude;

    ngl::Real m_periodicWallSpeed;

    ngl::Real m_angleOfPeriodicWall;

    ngl::Real m_periodicWallAngleIncrement;



private:
    bool checkAndResolveCollisionWithObstacle
                    (
                        Particle& io_currentParticle,
                        Particle& _obstacle
                    );

    bool checkAndResolveCollisionWithObstacle
                    (
                        Particle& io_currentParticle,
                        Capsule& _obstacle
                    );

    bool checkAndResolveCollisionWithBoundary
                    (
                        Particle& io_currentParticle,
                        const bool _fromRBD
                    );

    void resolveCollision
                    (
                        Particle& io_currentParticle,
                        const ngl::Vector _contactPoint,
                        const ngl::Vector _normal,
                        const ngl::Real _penetrationDepth,
                        const ngl::Real _restitutionCoefficient
                    );

    void updatePeriodicBoundingBox();
};

#endif // ENVIRONMENT_H