OgreVisibleObject.h

Go to the documentation of this file.

//    Copyright (C) 2004-2014 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef OGRE_VISIBLE_OBJECT_H
#define OGRE_VISIBLE_OBJECT_H

#include "OgreCoreDLL.h"

#include "../Core_LIB/CVisibleObject.h"
#include "../Graphics_LIB/GUtils.h"
#include "../Graphics_LIB/GObjectTextDisplay.h"

namespace OpenSkyNet {
    namespace OgreCore {
        class OGRECORE_DLL OgreVisibleObject : public OpenSkyNet::Core::VisibleObject {
        private:
            static Ogre::Vector3 _camSpaceOffset;
            static Ogre::Vector3 _worldSpaceOffset;
        protected:
            Ogre::SceneNode* _renderNode;
            Graphics::ObjectTextDisplay* _renderName;
            std::vector<std::string> _materialNames;
        public:
            static inline void setCamSpaceOffset(const Ogre::Vector3 &camSpaceOffset_) {
                _camSpaceOffset = camSpaceOffset_;
                _worldSpaceOffset = _camSpaceOffset*-1.0;
            }

            static inline const Ogre::Vector3& getCamSpaceOffset() { return _camSpaceOffset; }

            static inline const Ogre::Vector3& getWorldSpaceOffset() { return _worldSpaceOffset; }

            OgreVisibleObject(Ogre::SceneNode* renderNode_);

            OgreVisibleObject(Ogre::SceneNode* renderNode_, const Math::Point<>& pos_, const Math::Matrix3x3& rot_);

            OgreVisibleObject(Ogre::SceneNode* renderNode_, const Ogre::Vector3& pos_, const Ogre::Quaternion& rot_);

            virtual ~OgreVisibleObject();

            inline const Ogre::SceneNode* getRenderNode() const { return _renderNode; }
            inline Ogre::SceneNode* getRenderNode() { return _renderNode; }

            virtual Math::Point<> getPos() const;
            virtual void getPos(Math::Point<>& pos_) const;
            virtual void setPos(const Math::Point<>& pos_);

            virtual Ogre::Vector3 getVec3() const;
            virtual void getVec3(Ogre::Vector3& vec3_) const;
            virtual void setVec3(const Ogre::Vector3& vec3_);

            virtual Math::Matrix3x3 getRot() const;
            virtual void getRot(Math::Matrix3x3& rot_) const;
            virtual void setRot(const Math::Matrix3x3& rot_);

            virtual Ogre::Quaternion getQuat() const;
            virtual void getQuat(Ogre::Quaternion& quat_) const;
            virtual void setQuat(const Ogre::Quaternion& quat_);

            virtual void setVisible(bool val_) { _renderNode->setVisible(val_); }

            void setRenderNameEnabled(const std::string& name_, const Ogre::Camera* cam_, const Ogre::ColourValue& color_);
            inline void setRenderNameText(const std::string& name_) { if (_renderName) _renderName->setText(name_); }
            inline void updateRenderNameTransform() { if (_renderName) _renderName->update(); }

            virtual void saveMaterials();
            virtual void loadMaterials();
        };
    }
}

#endif //OGRE_VISIBLE_OBJECT_H