PhysicsNode.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_PHYSICSNODE_H__
#define __I6ENGINE_MODULES_PHYSICSNODE_H__

#include <vector>

#include "i6engine/api/components/PhysicalStateComponent.h"

#include "LinearMath/btMotionState.h"

class btCollisionShape;
class btCompoundShape;
class btRigidBody;

namespace i6e {
namespace api {
        struct CollisionGroup;
} /* namespace api */
namespace modules {

        class PhysicsMailbox;
        class PhysicsManager;
        class PhysicsVelocityComponent;

        typedef struct PeriodicRaytest {
                Vec3 from;
                Vec3 to;
                api::PhysicalStateComponent::RayTestNotify raytestNotify;
                api::GameMessage::Ptr message;

                api::RayTestResult lastResult;

                PeriodicRaytest() : from(), to(), raytestNotify(), message(), lastResult() {
                }

                PeriodicRaytest(const Vec3 & f, const Vec3 & t, api::PhysicalStateComponent::RayTestNotify rtn, api::GameMessage::Ptr msg) : from(f), to(t), raytestNotify(rtn), message(msg), lastResult() {
                }
        } PeriodicRaytest;

        class PhysicsNode : public btMotionState {
                friend class PhysicsMailbox;
                friend class PhysicsManager;
                friend class PhysicsVelocityComponent;

        public:
                PhysicsNode(const int64_t id, const int64_t compId, const Vec3 & position, const Quaternion & rotation, const Vec3 & scale, const api::CollisionGroup & cg, const api::attributeMap & params, api::ShatterInterest shatterInterest, PhysicsManager * pm);

                ~PhysicsNode();

                bool addChild(const int64_t compId, const Vec3 & position, const Quaternion & rotation, const Vec3 & scale, const api::CollisionGroup & cg, const api::PhysicalStateComponent::ShapeType shapeType, const api::attributeMap & shapeParams);

                void removeChild(int64_t compId);

                bool empty() const;

                void reset();

                void setPosition(const Vec3 & position, int64_t id);

                void setRotation(const Quaternion & rotation, int64_t id);

                void setScale(const Vec3 & scale, int64_t id);

                inline void getWorldTransform(btTransform & worldTrans) const { worldTrans = _transform; }

                void setWorldTransform(const btTransform & worldTrans);

                inline btRigidBody * getRigidBody() const { return _rigidBody; }

                api::RayTestResult HitTest(const Vec3 & from, const Vec3 & to);

                int64_t getID() const {
                        return _id;
                }

                int64_t getCompID() const {
                        return _compId;
                }

                uint32_t getCrashType() { return _collisionGroup.crashType; }

                void setCollisionFlags(const api::CollisionGroup & cg);

                void setCrashType(uint32_t ct) {
                        _collisionGroup.crashType = ct;
                }

                void setCrashMask(uint32_t cm) {
                        _collisionGroup.crashMask = cm;
                }

                uint32_t getCrashMask() { return _collisionGroup.crashMask; }

                Vec3 getPosition() const { return _position; }

                Quaternion getRotation() const { return _rotation; }

                Vec3 getScale() const { return _scale; }

                void applyRotation(const Quaternion & rotation, int64_t id);

                api::ShatterInterest getShatterInterest() const { return _shatterInterest; }

                void Tick();

                void createVelocityComponent(double maxSpeed, double resistanceCoefficient, double windage);

                void deleteVelocityComponent();

        private:
                PhysicsManager * _manager;

                int64_t _id;
                int64_t _compId;
                api::CollisionGroup _collisionGroup;

                Vec3 _position;
                Quaternion _rotation;
                Vec3 _scale;

                btTransform _transform;
                btRigidBody * _rigidBody;

                Vec3 _linearVelocity;
                Vec3 _centralForce;

                api::ShatterInterest _shatterInterest;

                std::vector<PeriodicRaytest *> _rayTests;

                btCompoundShape * _parentShape;

                std::map<int64_t, std::pair<int64_t, btCollisionShape *>> _childShapes;

                PhysicsVelocityComponent * _velocityComponent;

                uint16_t _tickCount;

                double _mass;

                utils::weakPtr<api::PhysicalStateComponent, api::Component> _weakPSCPtr;

                void startSimulatingBody();

                void stopSimulatingBody();

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

                void addTicker();

                void removeTicker();

                Vec3 getVelocity() const;

                void applyForce(const Vec3 & force, const Vec3 & offset, bool local);

                ASSERT_THREAD_SAFETY_HEADER
        };

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

#endif /* __I6ENGINE_MODULES_PHYSICSNODE_H__ */