PhysicalStateComponent.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_API_PHYSICALSTATECOMPONENT_H__
#define __I6ENGINE_API_PHYSICALSTATECOMPONENT_H__

#include "i6engine/math/i6eQuaternion.h"
#include "i6engine/math/i6eVector.h"

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

#include "boost/thread/mutex.hpp"

namespace i6e {
namespace api {

        namespace ResponseType {
                enum ResponseType {
                        NONE = 0,               // !< Simple objects being pushable
                        STATIC = 1<<0,  // !< Static object (don't move, can't be pushed away, ...)
                        GHOST = 1<<1,   // !< Objects that don't interact physically with other objects (it's more like an area)
                        TRIGGER = 1<<2  // !< collision with this object will trigger the internal callbacks (use this if you need shatter info)
                };
        }

        struct CollisionGroup {
                uint32_t responseType;

                uint32_t crashType;

                uint32_t crashMask;

                CollisionGroup() : responseType(0), crashType(0), crashMask(0) {
                }

                CollisionGroup(uint32_t response, uint32_t type, uint32_t mask) : responseType(response), crashType(type), crashMask(mask) {
                }

                explicit CollisionGroup(const std::string & str) : responseType(), crashType(), crashMask() {
                        std::stringstream ss(str);
                        ss >> responseType;
                        ss >> crashType;
                        ss >> crashMask;
                }

                CollisionGroup & operator=(const CollisionGroup & cg) {
                        responseType = cg.responseType;
                        crashType = cg.crashType;
                        crashMask = cg.crashMask;
                        return *this;
                }

                void insertInMap(const std::string & entry, attributeMap & params) const {
                        std::stringstream ss;
                        ss << responseType << " " << crashType << " " << crashMask;
                        params.insert(std::make_pair(entry, ss.str()));
                }

                template<class Archive>
                void serialize(Archive & ar, const unsigned int /*version*/) {
                        ar & responseType;
                        ar & crashType;
                        ar & crashMask;
                }
        };

        typedef struct RayTestResult {
                int64_t objID;
                int64_t sourceID;
                Vec3 collisionPoint;

                RayTestResult() : objID(-1), sourceID(-1), collisionPoint() {}
        } RayTestResult;

        enum ShatterInterest : uint16_t {
                NONE = 0,               // !< shouldn't be used with responseType TRIGGER
                START = 1 << 0, // !< start of a collision
                END = 1 << 1,           // !< end of a collision
                ALWAYS = 1 << 2 // !< every collision
        };

        class ISIXE_MODULES_API PhysicalStateComponent : public Component {
        public:
                enum class ShapeType : uint16_t {
                        PLANE,  // !< an infinite large plane
                        BOX,    // !< a cuboid
                        SPHERE, // !< a sphere
                        FILE    // !< load from file
                };

                enum class RayTestRepetition : uint16_t {
                        STOP = 0,       // !< stops raytest, if started with periodic
                        ONCE,           // !< sends one ray
                        PERIODIC        // !< sends a ray every tick
                };

                enum class RayTestNotify : uint16_t {
                        ALWAYS,                 // !< notifies always
                        CHANGE,                 // !< notifies only on change whether something was hit or not
                        FOUND,                  // !< notifies only if raytest was successful
                        NOTFOUND,               // !< notifies only if raytest was unsuccessful
                        OBJECTCHANGE    // !< notifies only if found object is changed
                };

                PhysicalStateComponent(const int64_t id, const attributeMap & params);

                ~PhysicalStateComponent();

                Vec3 getPosition() const;

                void setPosition(const Vec3 & position, uint32_t prio);

                inline Quaternion getRotation() const { return _rotation; }

                void setRotation(const Quaternion & rotation, uint32_t prio);

                inline Vec3 getScale() const {
                        return _scale;
                }

                void setScale(const Vec3 & scale, uint32_t prio);

                void setCollisionFlags(const CollisionGroup & col);

                CollisionGroup getCollisionFlags() const { return _collisionGroup; }

                void reset();

                void setCollisionShape(ShapeType st, const attributeMap & params);

                void applyRotation(const Quaternion & rotation);

                Vec3 getLinearVelocity() const {
                        if (_speedDirty > 0) {
                                return _speedNew;
                        } else {
                                return _linearVelocity;
                        }
                }

                void setLinearVelocity(const Vec3 & linVel, uint32_t prio);

                void applyCentralForce(const Vec3 & cForce, bool forceIsLocalSpace);
                void applyForce(const Vec3 & force, const Vec3 & offset, bool forceIsLocalSpace);

                void setShatterInterest(ShatterInterest si);

                void setGravity(const Vec3 & gravity);

                attributeMap synchronize() const override;

                void rayTest(const Vec3 & from, const Vec3 & to, RayTestRepetition rtr, RayTestNotify rtn, const GameMessage::Ptr & msg);

                std::string getTemplateName() const override {
                        return "PhysicalState";
                }

                void addPosition(const Vec3 & pos);

                std::vector<componentOptions> getComponentOptions() override;

        private:
                Vec3 _position;
                Vec3 _positionNew;
                uint32_t _posDirty;
                uint32_t _rotDirty;
                uint32_t _speedDirty;

                Quaternion _rotation;
                Quaternion _rotationNew;

                Vec3 _scale;
                Vec3 _scaleNew;
                uint32_t _scaleDirty;

                Vec3 _linearVelocity;
                Vec3 _speedNew;

                std::vector<std::tuple<Vec3, Vec3, bool>> _forces;

                Vec3 _gravity;

                CollisionGroup _collisionGroup;

                ShapeType _shapeType;

                attributeMap _shapeParams;

                // TODO (Michael) maybe move this to Component base class?
                bool _initialized;

                ShatterInterest _shatterInterest;

                mutable boost::mutex _lock;

                uint32_t _syncPrio;

                void Init() override;

                void Finalize() override;

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

                void Tick() override;

                virtual std::pair<AddStrategy, int64_t> howToAdd(const ComPtr & comp) const override;
        };

} /* namespace api */
} /* namespace i6e */

#endif /* __I6ENGINE_API_PHYSICALSTATECOMPONENT_H__ */