PhysicsManager.h

Go to the documentation of this file.

/*
 * i6engine
 * Copyright (2016) Daniel Bonrath, Michael Baer, All rights reserved.
 *
 * This file is part of i6engine; i6engine is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __I6ENGINE_MODULES_PHYSICSMANAGER_H__
#define __I6ENGINE_MODULES_PHYSICSMANAGER_H__

#include "i6engine/math/i6eVector.h"

#include "i6engine/api/GameMessage.h"

#include "i6engine/modules/physics/PhysicsNode.h"

#include "LinearMath/btAlignedObjectArray.h"

class btBroadphaseInterface;
class btCollisionDispatcher;
class btCollisionShape;
class btCompoundShape;
class btDefaultCollisionConfiguration;
class btDiscreteDynamicsWorld;
class btDynamicsWorld;
class btMotionState;
class btRigidBody;
class btSequentialImpulseConstraintSolver;
class btTypedConstraint;
struct btOverlapFilterCallback;

namespace i6e {
namespace modules {

        class DebugDrawer;
        class PhysicsController;

        class PhysicsManager {
        public:
                static std::map<std::pair<PhysicsNode *, PhysicsNode *>, uint64_t> _collisionPairs;

                static uint64_t _tickCount;

                explicit PhysicsManager(PhysicsController * pc);

                ~PhysicsManager();

                void NewsCreate(const api::GameMessage::Ptr & msg);

                void NewsUpdate(const api::GameMessage::Ptr & msg);

                void NewsDelete(const api::GameMessage::Ptr & msg);

                void Tick();

                btCompoundShape * createCompound();

                btCollisionShape * createSphere(const api::attributeMap & params);

                btCollisionShape * createFromFile(const api::attributeMap & params);

                btCollisionShape * createBox(const api::attributeMap & params);

                btCollisionShape * createPlane(const api::attributeMap & params);

                btCollisionShape * createEmptyShape();

                void remove(btRigidBody * body);
                void removeShape(btCollisionShape * shape);

                btDynamicsWorld * getPhysicsWorld() const;

                void setGravity(const Vec3 & gravity);

                void setGravity(const double gravityDown);

                void addRigidBody(btRigidBody * rigidBody);

                void removeRigidBody(btRigidBody * rigidBody);

                PhysicsNode * getPhysicsNode(const int64_t id);

                void addTicker(PhysicsNode * pn);

                void removeTicker(PhysicsNode * pn);

        private:
                PhysicsController * _ctrl;

                btAlignedObjectArray<btCollisionShape *> _collisionShapes;

                btDiscreteDynamicsWorld * _dynamicsWorld;
                btBroadphaseInterface * _broadphase;
                btCollisionDispatcher * _dispatcher;
                btDefaultCollisionConfiguration * _collisionConfiguration;
                btSequentialImpulseConstraintSolver * _solver;

                std::map<int64_t, PhysicsNode *> _nodes;

                // http://www.bulletphysics.org/mediawiki-1.5.8/index.php/Collision_Things
                uint64_t _lngTime;

                std::vector<PhysicsNode *> _tickList;

                std::map<int64_t, std::vector<std::pair<int64_t, btTypedConstraint *>>> _constraints;

                bool _paused;

                DebugDrawer * _debugDrawer;

                btOverlapFilterCallback * _filterCallback;

                PhysicsManager(const PhysicsManager &) = delete;

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

                ASSERT_THREAD_SAFETY_HEADER
        };

} /* namespace modules */
} /* namespace i6e */

#endif /* __I6ENGINE_MODULES_PHYSICSMANAGER_H__ */