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 DllExport MeshManager
  {
  public:
    struct VERTEX
    {
            // Position
      float x, y, z,
            // Normalized position
            nx, ny, nz,
          // Texture coords
            u, v,
          // Opacity
          o;
    };

    MeshManager(SkyX *s);

    ~MeshManager();

        void create();

    void remove();

    void updateGeometry(Ogre::Camera* cam);

        inline Ogre::MeshPtr getMesh()
        {
            return mMesh;
        }

        inline Ogre::SubMesh* getSubMesh()
        {
            return mSubMesh;
        }

        inline Ogre::Entity* getEntity()
        {
            return mEntity;
        }

        inline const Ogre::String& getMaterialName() const
        {
            return mMaterialName;
        }

        void setMaterialName(const Ogre::String &MaterialName);

        inline Ogre::HardwareVertexBufferSharedPtr &getHardwareVertexBuffer()
        {
            return mVertexBuffer;
        }

    inline Ogre::HardwareIndexBufferSharedPtr &getHardwareIndexBuffer()
    {
      return mIndexBuffer;
    }

    inline Ogre::SceneNode* getSceneNode()
    {
      return mSceneNode;
    }

    inline const bool& isCreated() const
    {
      return mCreated;
    }

    void setGeometryParameters(const int& Steps, const int& Circles);

    inline const int& getSteps() const
    {
      return mSteps;
    }

    inline const int& getCircles() const
    {
      return mCircles;
    }

    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 bool& getUnderHorizonFading() const
    {
      return mUnderHorizonFading;
    }

    inline const Ogre::Real& getUnderHorizonFadingExponent() const
    {
      return mUnderHorizonFadingExponent;
    }

    inline const Ogre::Real& getUnderHorizonFadingMultiplier() const
    {
      return mUnderHorizonFadingMultiplier;
    }

    inline void setRadiusMultiplier(const Ogre::Real& RadiusMultiplier)
    {
      mRadiusMultiplier = RadiusMultiplier;
    }

    float getSkydomeRadius(Ogre::Camera* c) const;

  private:
    void _createGeometry();

    SkyX* mSkyX;

    bool mCreated;

    Ogre::MeshPtr mMesh;

    Ogre::SubMesh *mSubMesh;
    Ogre::Entity *mEntity;

    Ogre::HardwareVertexBufferSharedPtr mVertexBuffer;

    VERTEX* mVertices;

    Ogre::HardwareIndexBufferSharedPtr  mIndexBuffer;

    Ogre::SceneNode* mSceneNode;

    int mSteps;

    int mCircles;
    int mUnderHorizonCircles;
    bool mUnderHorizonFading;
    Ogre::Real mUnderHorizonFadingExponent;
    Ogre::Real mUnderHorizonFadingMultiplier;

    Ogre::Real mRadiusMultiplier;

    Ogre::String mMaterialName;
  };
}

#endif