Representation.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013-2015, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SURGSIM_COLLISION_REPRESENTATION_H
#define SURGSIM_COLLISION_REPRESENTATION_H

#include <boost/thread/mutex.hpp>
#include <list>
#include <memory>
#include <unordered_map>
#include <unordered_set>

#include "SurgSim/DataStructures/BufferedValue.h"
#include "SurgSim/Framework/Log.h"
#include "SurgSim/Framework/Representation.h"
#include "SurgSim/Math/Aabb.h"
#include "SurgSim/Math/Shape.h"

namespace SurgSim
{

namespace Math
{
class Shape;
};

namespace Physics
{
class Representation;
};

namespace Collision
{
struct Contact;
class Representation;

typedef std::unordered_map<std::shared_ptr<SurgSim::Collision::Representation>,
        std::list<std::shared_ptr<SurgSim::Collision::Contact>>> ContactMapType;

enum CollisionDetectionType : SURGSIM_ENUM_TYPE;

class Representation : public SurgSim::Framework::Representation
{
public:
    explicit Representation(const std::string& name);

    virtual ~Representation();

    virtual int getShapeType() const = 0;

    virtual void setCollisionDetectionType(CollisionDetectionType type);

    CollisionDetectionType getCollisionDetectionType() const;

    virtual void setSelfCollisionDetectionType(CollisionDetectionType type);

    CollisionDetectionType getSelfCollisionDetectionType() const;

    virtual std::shared_ptr<SurgSim::Math::Shape> getShape() const = 0;

    virtual const Math::PosedShape<std::shared_ptr<Math::Shape>>& getPosedShape();

    const Math::PosedShapeMotion<std::shared_ptr<Math::Shape>>& getPosedShapeMotion() const;

    SurgSim::DataStructures::BufferedValue<ContactMapType>& getCollisions();

    void addContact(const std::shared_ptr<Representation>& other,
                    const std::shared_ptr<SurgSim::Collision::Contact>& contact);

    bool collidedWith(const std::shared_ptr<Representation>& other);

    virtual void update(const double& dt);

    virtual void updateShapeData();

    virtual void updateDcdData();

    virtual void updateCcdData(double timeOfImpact);

    bool ignore(const std::string& fullName);

    bool ignore(const std::shared_ptr<Representation>& representation);

    void setIgnoring(const std::vector<std::string>& fullNames);

    bool isIgnoring(const std::string& fullName) const;

    bool isIgnoring(const std::shared_ptr<Representation>& representation) const;

    bool allow(const std::string& fullName);

    bool allow(const std::shared_ptr<Representation>& representation);

    void setAllowing(const std::vector<std::string>& fullNames);

    bool isAllowing(const std::string& fullName) const;

    bool isAllowing(const std::shared_ptr<Representation>& representation) const;

    virtual Math::Aabbd getBoundingBox() const;

protected:
    void invalidatePosedShapeMotion();

    std::vector<std::string> getIgnoring() const;

    std::vector<std::string> getAllowing() const;

    void doRetire() override;

    void setPosedShapeMotion(const Math::PosedShapeMotion<std::shared_ptr<Math::Shape>>& posedShape);

    std::shared_ptr<Framework::Logger> m_logger;

    double m_oldVolume;
    double m_aabbThreshold;
    Math::RigidTransform3d m_previousDcdPose;
    Math::RigidTransform3d m_previousCcdCurrentPose;

private:
    CollisionDetectionType m_collisionDetectionType;

    CollisionDetectionType m_selfCollisionDetectionType;

    SurgSim::DataStructures::BufferedValue<ContactMapType> m_collisions;

    boost::mutex m_collisionsMutex;

    Math::PosedShapeMotion<std::shared_ptr<Math::Shape>> m_posedShapeMotion;

    mutable boost::shared_mutex m_posedShapeMotionMutex;

    std::unordered_set<std::string> m_ignoring;

    std::unordered_set<std::string> m_allowing;
};

}; // namespace Collision
}; // namespace SurgSim

SURGSIM_SERIALIZABLE_ENUM(SurgSim::Collision::CollisionDetectionType,
                          (COLLISION_DETECTION_TYPE_NONE)
                          (COLLISION_DETECTION_TYPE_DISCRETE)
                          (COLLISION_DETECTION_TYPE_CONTINUOUS)
                          (MAX_COLLISION_DETECTION_TYPES))

#endif