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 "PrivatePtr.h"
#include "FastGpuParamRef.h"

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:
        PrivateMaterialPtr mMaterial;

        PrivateSceneNodePtr mNode;
        
        PrivateManualObjectPtr mManualObj;

        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 () const { return mMagnitudeScale; }

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

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

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

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

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

    private:
        Ogre::Degree mObserverPositionRebuildDelta;

    public:
        inline Ogre::Degree getObserverPositionRebuildDelta () const {
            return mObserverPositionRebuildDelta;
        }
        inline void setObserverPositionRebuildDelta (Ogre::Degree value) {
            mObserverPositionRebuildDelta = value;
        }

        static const Ogre::Degree DEFAULT_OBSERVER_POSITION_REBUILD_DELTA;

        static const Ogre::String STARFIELD_MATERIAL_NAME;

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

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

    public:
        void setQueryFlags (uint flags) { mManualObj->setQueryFlags (flags); }
        uint getQueryFlags () const { return mManualObj->getQueryFlags (); }
        void setVisibilityFlags (uint flags) { mManualObj->setVisibilityFlags (flags); }
        uint getVisibilityFlags () const { return mManualObj->getVisibilityFlags (); }

    private:
        struct Params {
            void setup(Ogre::GpuProgramParametersSharedPtr vpParams);
        
            Ogre::GpuProgramParametersSharedPtr vpParams;
            FastGpuParamRef mag_scale;
            FastGpuParamRef mag0_size;
            FastGpuParamRef min_size;
            FastGpuParamRef max_size;
            FastGpuParamRef aspect_ratio;
        } mParams;
    };
}

#endif // CAELUM__POINT_STARFIELD_H

---