MeshManager.h

Go to the documentation of this file.

/*
--------------------------------------------------------------------------------
This source file is part of SkyX.
Visit http://www.paradise-studios.net/products/skyx/
 
Copyright (C) 2009-2012 Xavier Vergu�n Gonz�lez <xavyiy@gmail.com>
 
This program 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 of the License, or (at your option) any later
version.
 
This program 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 program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
--------------------------------------------------------------------------------
*/
 
#ifndef _SkyX_MeshManager_H_
#define _SkyX_MeshManager_H_
 
#include "Prerequisites.h"
 
namespace SkyX
{
    class SkyX;
 
    class MeshManager 
    {
    public:
        struct VERTEX
        {
                  // Position
            float x, y, z,
                  // Normalized position
                  nx, ny, nz,
                  // Texture coords
                  u, v,
                  // Opacity
                  o;
        };
        struct VERTEX {…};
 
        MeshManager(SkyX *s);
 
        ~MeshManager();
 
        void create();
 
        void remove();
 
        void updateGeometry(Ogre::Camera* cam);
 
        inline Ogre::MeshPtr getMesh()
        {
            return mMesh;
        }
        inline Ogre::MeshPtr getMesh() {…}
 
        inline Ogre::SubMesh* getSubMesh()
        {
            return mSubMesh;
        }
        inline Ogre::SubMesh* getSubMesh() {…}
 
        inline Ogre::Entity* getEntity()
        {
            return mEntity;
        }
        inline Ogre::Entity* getEntity() {…}
 
        inline const Ogre::String& getMaterialName() const
        {
            return mMaterialName;
        }
        inline const Ogre::String& getMaterialName() const {…}
 
        void setMaterialName(const Ogre::String &MaterialName);
 
        inline Ogre::HardwareVertexBufferSharedPtr &getHardwareVertexBuffer()
        {
            return mVertexBuffer;
        }
        inline Ogre::HardwareVertexBufferSharedPtr &getHardwareVertexBuffer() {…}
 
        inline Ogre::HardwareIndexBufferSharedPtr &getHardwareIndexBuffer()
        {
            return mIndexBuffer;
        }
        inline Ogre::HardwareIndexBufferSharedPtr &getHardwareIndexBuffer() {…}
 
        inline Ogre::SceneNode* getSceneNode()
        {
            return mSceneNode;
        }
        inline Ogre::SceneNode* getSceneNode() {…}
 
        inline const bool& isCreated() const
        {
            return mCreated;
        }
        inline const bool& isCreated() const {…}
 
        void setGeometryParameters(const int& Steps, const int& Circles);
 
        inline const int& getSteps() const
        {
            return mSteps;
        }
        inline const int& getSteps() const {…}
 
        inline const int& getCircles() const
        {
            return mCircles;
        }
        inline const int& getCircles() const {…}
 
        void setUnderHorizonParams(const int& UnderHorizonCircles = 15, const bool& UnderHorizonFading = true, const Ogre::Real& UnderHorizonFadingExponent = 1, const Ogre::Real& UnderHorizonFadingMultiplier = 2);
 
        inline const int& getUnderHorizonCircles() const
        {
            return mUnderHorizonCircles;
        }
        inline const int& getUnderHorizonCircles() const {…}
 
        inline const bool& getUnderHorizonFading() const
        {
            return mUnderHorizonFading;
        }
        inline const bool& getUnderHorizonFading() const {…}
 
        inline const Ogre::Real& getUnderHorizonFadingExponent() const
        {
            return mUnderHorizonFadingExponent;
        }
        inline const Ogre::Real& getUnderHorizonFadingExponent() const {…}
 
        inline const Ogre::Real& getUnderHorizonFadingMultiplier() const
        {
            return mUnderHorizonFadingMultiplier;
        }
        inline const Ogre::Real& getUnderHorizonFadingMultiplier() const {…}
 
        inline void setRadiusMultiplier(const Ogre::Real& RadiusMultiplier)
        {
            mRadiusMultiplier = RadiusMultiplier;
        }
        inline void setRadiusMultiplier(const Ogre::Real& RadiusMultiplier) {…}
 
        const float getSkydomeRadius(Ogre::Camera* c) const;
 
    private:
        void _createGeometry();
 
        bool mCreated;
 
        Ogre::MeshPtr mMesh;
        Ogre::SubMesh *mSubMesh;
        Ogre::Entity *mEntity;
 
        Ogre::HardwareVertexBufferSharedPtr mVertexBuffer;
        Ogre::HardwareIndexBufferSharedPtr  mIndexBuffer;
 
        VERTEX* mVertices;
 
        int mCircles;
        int mSteps;
 
        int mUnderHorizonCircles;
        bool mUnderHorizonFading;
        Ogre::Real mUnderHorizonFadingExponent;
        Ogre::Real mUnderHorizonFadingMultiplier;
 
        Ogre::Real mRadiusMultiplier;
 
        Ogre::SceneNode* mSceneNode;
 
        Ogre::String mMaterialName;
 
        SkyX* mSkyX;
    };
    class MeshManager  {…};
}
 
#endif