PhysicsManagerState.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_PHYSICS_PHYSICSMANAGERSTATE_H
#define SURGSIM_PHYSICS_PHYSICSMANAGERSTATE_H

#include <memory>
#include <vector>
#include <unordered_map>

#include "SurgSim/Collision/CollisionPair.h"
#include "SurgSim/Collision/ContactFilter.h"
#include "SurgSim/Collision/Representation.h"
#include "SurgSim/Particles/Representation.h"
#include "SurgSim/Physics/Constraint.h"
#include "SurgSim/Physics/MlcpMapping.h"
#include "SurgSim/Physics/MlcpPhysicsProblem.h"
#include "SurgSim/Physics/MlcpPhysicsSolution.h"
#include "SurgSim/Physics/Representation.h"


namespace SurgSim
{
namespace Physics
{

class ConstraintComponent;

enum ConstraintGroupType
{
    CONSTRAINT_GROUP_TYPE_CONTACT = 0,
    CONSTRAINT_GROUP_TYPE_SCENE,
    CONSTRAINT_GROUP_TYPE_COUNT
};

class PhysicsManagerState
{
public:
    PhysicsManagerState();

    ~PhysicsManagerState();

    void setRepresentations(const std::vector<std::shared_ptr<Representation>>& val);

    const std::vector<std::shared_ptr<Representation>>& getRepresentations();

    void setActiveRepresentations(const std::vector<std::shared_ptr<Representation>>& activeRepresentations);

    const std::vector<std::shared_ptr<Representation>>& getActiveRepresentations() const;

    void setCollisionRepresentations(const std::vector<std::shared_ptr<SurgSim::Collision::Representation>>& val);

    const std::vector<std::shared_ptr<SurgSim::Collision::Representation>>& getCollisionRepresentations();

    void setActiveCollisionRepresentations(const std::vector<std::shared_ptr<SurgSim::Collision::Representation>>& val);

    const std::vector<std::shared_ptr<SurgSim::Collision::Representation>>& getActiveCollisionRepresentations();

    void setParticleRepresentations(const std::vector<std::shared_ptr<SurgSim::Particles::Representation>>& val);

    const std::vector<std::shared_ptr<SurgSim::Particles::Representation>>& getParticleRepresentations();

    void setActiveParticleRepresentations(const std::vector<std::shared_ptr<SurgSim::Particles::Representation>>& val);

    const std::vector<std::shared_ptr<SurgSim::Particles::Representation>>& getActiveParticleRepresentations();

    void setConstraintComponents(const std::vector<std::shared_ptr<ConstraintComponent>>& val);

    const std::vector<std::shared_ptr<ConstraintComponent>>& getConstraintComponents();

    const std::unordered_map<std::shared_ptr<SurgSim::Collision::Representation>,
          std::shared_ptr<SurgSim::Physics::Representation>>& getCollisionToPhysicsMap() const;

    void setCollisionPairs(const std::vector<std::shared_ptr<SurgSim::Collision::CollisionPair>>& val);

    const std::vector<std::shared_ptr<SurgSim::Collision::CollisionPair>>& getCollisionPairs();

    void setContactFilters(const std::vector<std::shared_ptr<SurgSim::Collision::ContactFilter>>& val);

    std::vector<std::shared_ptr<SurgSim::Collision::ContactFilter>> getContactFilters() const;


    void setConstraintGroup(ConstraintGroupType type, const std::vector<std::shared_ptr<Constraint>>& constraints);

    const std::vector<std::shared_ptr<Constraint>>& getConstraintGroup(int type) const;

    void setActiveConstraints(const std::vector<std::shared_ptr<Constraint>>& activeConstraints);

    const std::vector<std::shared_ptr<Constraint>>& getActiveConstraints() const;

    MlcpPhysicsProblem& getMlcpProblem();

    const MlcpPhysicsProblem& getMlcpProblem() const;

    MlcpPhysicsSolution& getMlcpSolution();

    const MlcpPhysicsSolution& getMlcpSolution() const;

    const MlcpMapping<Representation>& getRepresentationsMapping() const;

    void setRepresentationsMapping(const MlcpMapping<Representation>& representationsMapping);

    const MlcpMapping<Constraint>& getConstraintsMapping() const;

    void setConstraintsMapping(const MlcpMapping<Constraint>& constraintsMapping);

    void setTimeOfImpact(double timeOfImpact);

    double getTimeOfImpact();

    bool shouldAbortGroup() const;

    void setAbortGroup(bool val);

private:

    std::vector<std::shared_ptr<Representation>> m_representations;

    std::vector<std::shared_ptr<Representation>> m_activeRepresentations;

    std::vector<std::shared_ptr<SurgSim::Collision::Representation>> m_collisionRepresentations;

    std::vector<std::shared_ptr<SurgSim::Collision::Representation>> m_activeCollisionRepresentations;

    std::vector <std::shared_ptr<Collision::ContactFilter>> m_contactFilters;

    std::vector<std::shared_ptr<SurgSim::Particles::Representation>> m_particleRepresentations;

    std::vector<std::shared_ptr<SurgSim::Particles::Representation>> m_activeParticleRepresentations;

    std::vector<std::shared_ptr<ConstraintComponent>> m_constraintComponents;

    std::unordered_map<std::shared_ptr<SurgSim::Collision::Representation>,
        std::shared_ptr<SurgSim::Physics::Representation>> m_collisionsToPhysicsMap;

    std::vector<std::shared_ptr<SurgSim::Collision::CollisionPair>> m_collisionPairs;

    std::unordered_map<int, std::vector<std::shared_ptr<Constraint>>> m_constraints;

    std::vector<std::shared_ptr<Constraint>> m_activeConstraints;

    MlcpMapping<Representation> m_representationsIndexMapping;

    MlcpMapping<Constraint> m_constraintsIndexMapping;

    MlcpPhysicsProblem m_mlcpPhysicsProblem;

    MlcpPhysicsSolution m_mlcpPhysicsSolution;

    bool m_abortGroup;

    double m_timeOfImpact;
};

}; // Physics
}; // SurgSim

#endif