Caelum: main/src/PointStarfield.cpp Source File

00001 /*
00002 This file is part of Caelum.
00003 See http://www.ogre3d.org/wiki/index.php/Caelum 
00004 
00005 Copyright (c) 2008 Caelum team. See Contributors.txt for details.
00006 
00007 Caelum is free software: you can redistribute it and/or modify
00008 it under the terms of the GNU Lesser General Public License as published
00009 by the Free Software Foundation, either version 3 of the License, or
00010 (at your option) any later version.
00011 
00012 Caelum is distributed in the hope that it will be useful,
00013 but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 GNU Lesser General Public License for more details.
00016 
00017 You should have received a copy of the GNU Lesser General Public License
00018 along with Caelum. If not, see <http://www.gnu.org/licenses/>.
00019 */
00020 
00021 #include "CaelumPrecompiled.h"
00022 #include "PointStarfield.h"
00023 #include "GeometryFactory.h"
00024 #include "CaelumExceptions.h"
00025 #include "Astronomy.h"
00026 
00027 using namespace Ogre;
00028 
00029 namespace caelum
00030 {
00031     const Ogre::String PointStarfield::BILLBOARD_MATERIAL_NAME = "Caelum/StarPoint";
00032 
00033     PointStarfield::PointStarfield (
00034             Ogre::SceneManager *sceneMgr,
00035             Ogre::SceneNode *caelumRootNode,
00036             bool initWithCatalogue)
00037     {
00038         mMag0PixelSize = 16;
00039         mMinPixelSize = 4;
00040         mMaxPixelSize = 6;
00041         mMagnitudeScale = Math::Pow(100, 0.2);
00042         mObserverLatitude = 45;
00043         mObserverLongitude = 0;
00044 
00045         mMaterial = Ogre::MaterialManager::getSingleton ().getByName (BILLBOARD_MATERIAL_NAME);
00046         if (mMaterial.isNull ()) {
00047             CAELUM_THROW_UNSUPPORED_EXCEPTION ("Can't load point starfield material", "PointStarfield");
00048         }
00049         mMaterial->load ();
00050         if (mMaterial->getBestTechnique () == 0) {
00051             CAELUM_THROW_UNSUPPORED_EXCEPTION ("Can't load point starfield material", "PointStarfield");
00052         }
00053 
00054         sceneMgr->getRenderQueue()->getQueueGroup(CAELUM_RENDER_QUEUE_STARFIELD)->setShadowsEnabled (false);
00055 
00056         // We use a separate data source.
00057         Ogre::String objName = "Caelum/PointStarfield/" + Ogre::StringConverter::toString ((size_t)this);
00058         mManualObj = sceneMgr->createManualObject (objName);
00059         mManualObj->setDynamic(false);
00060         mManualObj->setRenderQueueGroup (CAELUM_RENDER_QUEUE_STARFIELD);
00061         mManualObj->setCastShadows(false);
00062 
00063         mNode = caelumRootNode->createChildSceneNode ();
00064         mNode->attachObject (mManualObj);
00065 
00066         if (initWithCatalogue) {
00067             addBrightStarCatalogue ();
00068         }
00069     }
00070 
00071     PointStarfield::~PointStarfield () {
00072         if (mNode) {
00073             mNode->getCreator()->destroySceneNode(mNode->getName());
00074             mNode = 0;
00075         }
00076 
00077         if (mManualObj) {
00078             mManualObj->_getManager()->destroyMovableObject(mManualObj);
00079             mManualObj = 0;
00080         }
00081             
00082         Ogre::MaterialManager::getSingletonPtr()->remove(mMaterial->getHandle());
00083     }
00084 
00085     void PointStarfield::notifyStarVectorChanged () {
00086         invalidateGeometry ();
00087     }
00088 
00089     void PointStarfield::clearAllStars () {
00090         mStars.clear();
00091         notifyStarVectorChanged ();
00092     }
00093 
00094     Real randReal () {
00095         return rand() / static_cast<float>(RAND_MAX);
00096     }
00097 
00098     Real randReal (Real min, Real max) {
00099         Real f = randReal ();
00100         return min * (1 - f) + max * f;
00101     }
00102 
00103     void PointStarfield::addRandomStars (int count)
00104     {
00105         for (int i = 0; i < count; ++i) {
00106             // Generate a vector inside a sphere
00107             Ogre::Vector3 pos;
00108             do {
00109                 pos.x = randReal(-1, 1);
00110                 pos.y = randReal(-1, 1);
00111                 pos.z = randReal(-1, 1);
00112             } while (pos.squaredLength () >= 1);
00113 
00114             // Convert to rasc/decl angles.
00115             LongReal rasc, decl, dist;
00116             Astronomy::convertRectangularToSpherical(
00117                     pos.x, pos.y, pos.z,
00118                     rasc, decl, dist);
00119 
00120             Star s;
00121             s.RightAscension = Ogre::Degree (rasc);
00122             s.Declination = Ogre::Degree (decl);
00123             // This distribution is wrong.
00124             s.Magnitude = 6 * pos.squaredLength () + 1.5;
00125             mStars.push_back(s);
00126         }
00127         notifyStarVectorChanged ();
00128     }
00129 
00130     void PointStarfield::addStar (const BrightStarCatalogueEntry &entry) {
00131         Star s;
00132         s.RightAscension = Ogre::Degree(360 / 24.0f * (
00133                 Math::Abs(entry.rasc_hour) +
00134                 entry.rasc_min / 60.0f +
00135                 entry.rasc_sec / 3600.0f));
00136         s.Declination = Ogre::Degree(Math::Sign(entry.decl_deg) * (
00137                 Math::Abs(entry.decl_deg) +
00138                 entry.decl_min / 60.0f +
00139                 entry.decl_sec / 3600.0f));
00140         s.Magnitude = entry.magn;
00141         mStars.push_back(s);
00142 
00143         notifyStarVectorChanged ();
00144     }
00145 
00146     void PointStarfield::addBrightStarCatalogue (int count) {
00147         assert(count >= 0);
00148         if (count < BrightStarCatalogueSize) {
00149             // Only sort if we don't add everything.
00150             // It would be lovely if the catalogue was already sorted.
00151             std::vector<std::pair<Real, int> > vec;
00152             vec.reserve(BrightStarCatalogueSize);
00153             for (int i = 0; i < BrightStarCatalogueSize; ++i) {
00154                 vec.push_back(std::make_pair(BrightStarCatalogue[i].magn, i));
00155             }
00156             sort(vec.begin(), vec.end());
00157             for (int i = 0; i < count; ++i) {
00158                 addStar(BrightStarCatalogue[vec[i].second]);
00159             }
00160         } else {
00161             assert(count == BrightStarCatalogueSize);
00162             for (int i = 0; i < BrightStarCatalogueSize; ++i) {
00163                 addStar(BrightStarCatalogue[i]);
00164             }
00165         }
00166         notifyStarVectorChanged ();
00167     }
00168 
00169     void PointStarfield::invalidateGeometry () {
00170         mValidGeometry = false;
00171     }
00172 
00173     void PointStarfield::ensureGeometry ()
00174     {
00175         if (mValidGeometry) {
00176             return;
00177         }
00178 
00179         Ogre::LogManager::getSingleton ().logMessage ("Caelum: Recomputing starfield geometry.");
00180 
00181         mManualObj->clear();
00182         mManualObj->estimateVertexCount(6 * mStars.size());
00183         mManualObj->begin(mMaterial->getName (), Ogre::RenderOperation::OT_TRIANGLE_LIST);
00184         for (uint i = 0; i < mStars.size(); ++i) {
00185             // Determine position at J2000
00186             LongReal azm, alt;
00187             Astronomy::convertEquatorialToHorizontal(
00188                     Astronomy::J2000,
00189                     mObserverLatitude.valueDegrees(),
00190                     mObserverLongitude.valueDegrees(),
00191                     mStars[i].RightAscension.valueDegrees(), mStars[i].Declination.valueDegrees(),
00192                     azm, alt);
00193 
00194             Ogre::Vector3 pos;
00195             pos.z = -Math::Cos (Ogre::Degree(azm)) * Math::Cos (Ogre::Degree(alt));
00196             pos.x =  Math::Sin (Ogre::Degree(azm)) * Math::Cos (Ogre::Degree(alt));
00197             pos.y = -Math::Sin (Ogre::Degree(alt));
00198 
00199             mManualObj->colour (Ogre::ColourValue::White);
00200             mManualObj->position (pos);
00201             mManualObj->textureCoord (+1, -1, mStars[i].Magnitude);
00202             mManualObj->position (pos);
00203             mManualObj->textureCoord (+1, +1, mStars[i].Magnitude);
00204             mManualObj->position (pos);
00205             mManualObj->textureCoord (-1, -1, mStars[i].Magnitude);
00206 
00207             mManualObj->position (pos);
00208             mManualObj->textureCoord (-1, -1, mStars[i].Magnitude);
00209             mManualObj->position (pos);
00210             mManualObj->textureCoord (+1, +1, mStars[i].Magnitude);
00211             mManualObj->position (pos);
00212             mManualObj->textureCoord (-1, +1, mStars[i].Magnitude);
00213         }
00214         mManualObj->end();
00215 
00216         // Set infinite bounds on the starfield.
00217         AxisAlignedBox box;
00218         box.setInfinite ();
00219         mManualObj->setBoundingBox (box);
00220 
00221         mValidGeometry = true;
00222     }
00223 
00224     void PointStarfield::notifyCameraChanged (Ogre::Camera *cam) {
00225         CameraBoundElement::notifyCameraChanged (cam);
00226 
00227         // Shader params are changed for every camera.
00228         Pass* pass = mMaterial->getBestTechnique ()->getPass (0);
00229         GpuProgramParametersSharedPtr fpParams = pass->getFragmentProgramParameters ();
00230         GpuProgramParametersSharedPtr vpParams = pass->getVertexProgramParameters ();
00231 
00232         int height = cam->getViewport ()-> getActualHeight ();
00233         int width = cam->getViewport ()-> getActualWidth ();
00234         Real pixFactor = 1.0f / width;
00235         Real magScale = -Math::Log (mMagnitudeScale) / 2;
00236         Real mag0Size = mMag0PixelSize * pixFactor;
00237         Real minSize = mMinPixelSize * pixFactor;
00238         Real maxSize = mMaxPixelSize * pixFactor;
00239         Real aspectRatio = static_cast<Real>(width) / height;
00240 
00241         // These params are relative to the size of the screen.
00242         vpParams->setIgnoreMissingParams (true);
00243         vpParams->setNamedConstant ("mag_scale", magScale);
00244         vpParams->setNamedConstant ("mag0_size", mag0Size);
00245         vpParams->setNamedConstant ("min_size", minSize);
00246         vpParams->setNamedConstant ("max_size", maxSize);
00247         vpParams->setNamedConstant ("aspect_ratio", aspectRatio);
00248     }
00249 
00250     void PointStarfield::setFarRadius (Ogre::Real radius) {
00251         CameraBoundElement::setFarRadius(radius);
00252         mNode->setScale (Ogre::Vector3::UNIT_SCALE * radius);
00253     }
00254 
00255     void PointStarfield::_update (const float time) {
00256         // This is probably wrong.
00257         Ogre::Quaternion orientation = Ogre::Quaternion::IDENTITY;
00258         orientation = orientation * Ogre::Quaternion (Ogre::Radian (-mObserverLatitude + Ogre::Degree (90)), Ogre::Vector3::UNIT_X);
00259         orientation = orientation * Ogre::Quaternion (Ogre::Radian (-time * 2 * Ogre::Math::PI), Ogre::Vector3::UNIT_Y);
00260         mNode->setOrientation (orientation);
00261         ensureGeometry ();
00262     }
00263 
00264     void PointStarfield::setObserverLatitude (Ogre::Degree value) {
00265         if (!Math::RealEqual (mObserverLatitude.valueDegrees (), value.valueDegrees (), 0.001)) {
00266             mObserverLatitude = value;
00267             invalidateGeometry ();
00268         }
00269     }
00270 
00271     void PointStarfield::setObserverLongitude (Ogre::Degree value) {
00272         if (!Math::RealEqual (mObserverLongitude.valueDegrees (), value.valueDegrees (), 0.001)) {
00273             mObserverLongitude = value;
00274             invalidateGeometry ();
00275         }
00276     }
00277 }