Component.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_COMPONENT_H__
#define __I6ENGINE_API_COMPONENT_H__

#include <map>
#include <vector>

#include "i6engine/utils/Exceptions.h"
#include "i6engine/utils/i6eThreadSafety.h"
#include "i6engine/utils/Singleton.h"
#include "i6engine/utils/weakPtr.h"
#include "i6engine/utils/EnumClassStream.h"

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

#include "i6engine/api/GameMessage.h"
#include "i6engine/api/configs/attributeMap.h"

#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/lexical_cast.hpp"

namespace i6e {
namespace api {

        class Component;
        class GameObject;

        typedef utils::sharedPtr<Component, Component> ComPtr;
        typedef utils::sharedPtr<GameObject, GameObject> GOPtr;
        typedef utils::weakPtr<Component> WeakComPtr;
        typedef utils::weakPtr<GameObject> WeakGOPtr;
        typedef boost::function<ComPtr(const int64_t, const attributeMap &)> createGOCCallback;

        enum class AddStrategy {
                ADD,                    // !< simply add this component
                REPLACE,                // !< replace the component with the specified one (-1 is the dispatcher, 0 is the first additional comp, etc.)
                REPLACE_DIS,    // !< replaces the Dispachter component
                REJECT                  // !< don't add this component at all
        };

        enum class AccessState {
                READONLY,       // !< option is only for information of the user
                READWRITE       // !< option can be changed in editor
        };

        enum ComponentOptionsParameter {
                ACCESSSTATE = 0,
                NAME,
                READFUNC,
                WRITEFUNC,
                WIDGETTYPE
        };

        typedef std::tuple<AccessState, std::string, boost::function<std::string(void)>, boost::function<bool(std::string)>, std::string> componentOptions;

        class ISIXE_MODULES_API Component {
                friend class GameObject;

        public:
                Component();

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

                virtual ~Component();

                template<typename T>
                static ComPtr createC(const int64_t id, const attributeMap & params) {
                        return utils::make_shared<T, Component>(id, params);
                }

                void setOwnerGO(const WeakGOPtr & objGo);

                GOPtr getOwnerGO();

                uint32_t getComponentID() const {
                        return _objComponentID;
                }

                uint32_t getFamilyID() const {
                        return _objFamilyID;
                }

                std::string getIdentifier() const { return _identifier; }

                virtual void Tick() {}

                void setDie() const;

                inline int64_t getID() const {
                        return _id;
                }

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

                virtual void Init() = 0;

                virtual void Finalize() {}

                virtual attributeMap synchronize() const = 0;

                void setSync(bool b) { _sync = b; }
                bool getSync() const { return _sync; }

                void enableTicking(bool allowTicking) const;

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

                void setSelf(const WeakComPtr & self);

                virtual std::string getTemplateName() const = 0;

                virtual std::vector<componentOptions> getComponentOptions() = 0;

                std::vector<ComPtr> getSubComponents() const {
                        return _subComps;
                }

        protected:
                int64_t _objOwnerID;

                WeakGOPtr _objOwnerGO;

                uint32_t _objComponentID;

                uint32_t _objFamilyID;

                std::vector<ComPtr> _subComps;

                std::string _identifier;

                int64_t _id;

                bool _sync;

                WeakComPtr _self;

                bool _tickingAllowed;

                bool _wantsToTick;

                bool _isTicking;

                void addTicker();

                void removeTicker();
                
                void doEnableTicking(bool allowTicking);

                ASSERT_THREAD_SAFETY_HEADER
        };

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

#endif /* __I6ENGINE_API_COMPONENT_H__ */