main/include/PointStarfield.h

/*
This file is part of Caelum.
See http://www.ogre3d.org/wiki/index.php/Caelum 

Copyright (c) 2008 Caelum team. See Contributors.txt for details.

Caelum 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 3 of the License, or
(at your option) any later version.

Caelum 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 Caelum. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef CAELUM__POINT_STARFIELD_H
#define CAELUM__POINT_STARFIELD_H

#include "CaelumPrerequisites.h"
#include "CameraBoundElement.h"
#include <vector>

namespace caelum
{
    struct BrightStarCatalogueEntry {
        signed char rasc_hour;
        signed char rasc_min;
        float rasc_sec;
        signed char decl_deg;
        signed char decl_min;
        float decl_sec;
        float magn;
    };

    const int BrightStarCatalogueSize = 9110;

    extern const BrightStarCatalogueEntry BrightStarCatalogue[BrightStarCatalogueSize];

    class CAELUM_EXPORT PointStarfield : public CameraBoundElement
    {
        public:
            PointStarfield (
                    Ogre::SceneManager *sceneMgr,
                    Ogre::SceneNode *caelumRootNode,
                    bool initWithCatalogue = true);

            virtual ~PointStarfield ();

            struct Star {
                Ogre::Degree RightAscension;
                Ogre::Degree Declination;
                Ogre::Real Magnitude;
            };

            typedef std::vector<Star> StarVector;

            inline StarVector& getStarVector () { return mStars; }

            void notifyStarVectorChanged ();

            void clearAllStars ();

            void addRandomStars (int count);

            void addStar (const BrightStarCatalogueEntry &entry);

            void addBrightStarCatalogue (int count = BrightStarCatalogueSize);


        private:
            Ogre::SceneNode *mNode;

            Ogre::ManualObject *mManualObj;

            Ogre::MaterialPtr mMaterial;

            std::vector<Star> mStars;

            Ogre::Real mMinPixelSize, mMaxPixelSize, mMag0PixelSize;
            Ogre::Real mMagnitudeScale;

            Ogre::Degree mObserverLatitude, mObserverLongitude;

            bool mValidGeometry;
            void invalidateGeometry();
            void ensureGeometry();

        public:
            void _update (float time);

            inline void setMagnitudeScale (Ogre::Real value) { mMagnitudeScale = value; }
            inline Ogre::Real getMagnitudeScale () { return mMagnitudeScale; }

            inline void setMag0PixelSize (Ogre::Real value) { mMag0PixelSize = value; }
            inline Ogre::Real getMag0PixelSize () { return mMag0PixelSize; }

            inline void setMinPixelSize (Ogre::Real value) { mMinPixelSize = value; }
            inline Ogre::Real getMinPixelSize () { return mMinPixelSize; }

            inline void setMaxPixelSize (Ogre::Real value) { mMaxPixelSize = value; }
            inline Ogre::Real getMaxPixelSize () { return mMaxPixelSize; }

            void setObserverLatitude (Ogre::Degree value);
            inline Ogre::Degree getObserverLatitude () { return mObserverLatitude; }

            void setObserverLongitude (Ogre::Degree value);
            inline Ogre::Degree getObserverLongitude () { return mObserverLongitude; }

            static const Ogre::String BILLBOARD_MATERIAL_NAME;

            virtual void notifyCameraChanged (Ogre::Camera *cam);

        protected:
            virtual void setFarRadius (Ogre::Real radius);
    };
}

#endif // CAELUM__POINT_STARFIELD_H

---