source: osgVisual/trunk/src/sky_Silverlining/visual_skySilverLining.cpp @ 432

/* -*-c++-*- osgVisual - Copyright (C) 2009-2011 Torben Dannhauer
 *
 * This library is based on OpenSceneGraph, open source and may be redistributed and/or modified under 
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * osgVisual requires for some proprietary modules a license from the correspondig manufacturer.
 * You have to aquire licenses for all used proprietary modules.
 * 
 * This library 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
 * OpenSceneGraph Public License for more details.
*/

#include <visual_skySilverLining.h>

using namespace osgVisual;

visual_skySilverLining::visual_skySilverLining(osgViewer::Viewer* viewer_, std::string configFileName, bool& disabled)
{
        OSG_NOTIFY( osg::ALWAYS ) << "Initialize visual_skySilverlining..." << std::endl;

        atmosphereInitialized = false;
        postInitialized = false;
        atmosphere = NULL;
        viewer = viewer_;
        lat = 0;
        lon = 0;

        for( int i=0; i<MAX_CLOUDLAYER_SLOTS; i++ )
        {
                cloudLayerSlots.push_back( cloudLayerSlot() );
                cloudLayerSlots.back().slot_id = i;
        }

        // Check if the module is en- or diabled by XML configuration.
        xmlDoc* tmpDoc;
        xmlNode* config = util::getModuleXMLConfig( configFileName, "sky_silverlining", tmpDoc, disabled );
        if( disabled)
                OSG_NOTIFY( osg::ALWAYS ) << "..disabled by XML configuration file." << std::endl;
 
        if(config)
                xmlFreeDoc(tmpDoc); xmlCleanupParser();

}

visual_skySilverLining::~visual_skySilverLining(void)
{
        this->removeUpdateCallback( updateCallback );
        if ( atmosphere != NULL )
                delete atmosphere;
}

void visual_skySilverLining::skyUpdateCallback::operator()(osg::Node* node, osg::NodeVisitor* nv)
{
        //std::cout << "Sky silverlining update callback" << std::endl;
        // Check if atmosphere is initialized.
        if (!sky->isInitialized())
                return;

        // on first time: perform Post-Init.
        sky->postInit();

        // Update sky
        double lat, lon, height;
        util::getWGS84ofCamera( sceneCamera, csn, lat, lon, height );
        //std::cout << "lat: " << osg::RadiansToDegrees(lat) << ", lon: " << osg::RadiansToDegrees(lon) << ", height: " << height << std::endl;
        sky->setLocation( lat, lon, height );
}

void visual_skySilverLining::setDateTime( int year_, int month_, int day_, int hour_, int minute_, int second_, bool daylightSaving_, double timezoneOffset_ )
{
        // Check if atmosphere is initialized.
        if (!isInitialized())
                return;

        SilverLining::LocalTime t = atmosphere->GetConditions()->GetTime();
        t.SetYear( year_ );
        t.SetMonth( month_ );
        t.SetDay( day_ );
        t.SetHour( hour_ );
        t.SetMinutes( minute_ );
        t.SetSeconds( second_ );
        t.SetObservingDaylightSavingsTime( daylightSaving_ );
        t.SetTimeZone( timezoneOffset_ );
}

void visual_skySilverLining::setTime( int hour_, int minute_, int second_ )
{
        // Check if atmosphere is initialized.
        if (!isInitialized())
                return;
        
        SilverLining::LocalTime t = atmosphere->GetConditions()->GetTime();
        if(hour_) t.SetHour( hour_ );
        if(minute_) t.SetMinutes( minute_ );
        if(second_) t.SetSeconds( second_ );
        atmosphere->GetConditions()->SetTime( t );
}

void visual_skySilverLining::setDate( int year_, int month_, int day_ )
{
        // Check if atmosphere is initialized.
        if (!isInitialized())
                return;

        SilverLining::LocalTime t = atmosphere->GetConditions()->GetTime();
        if(year_) t.SetYear( year_ );
        if(month_) t.SetMonth( month_ );
        if(day_) t.SetDay( day_ );
}

void visual_skySilverLining::setDateByEpoch( int secondsSince1970_ )
{
        // Check if atmosphere is initialized.
        if (!isInitialized())
                return;
        
        SilverLining::LocalTime t = atmosphere->GetConditions()->GetTime();
        t.SetFromEpochSeconds( secondsSince1970_ );
}

void visual_skySilverLining::setLocation(double lat_, double lon_, double alt_)
{
        // Check if atmosphere is initialized.
        if (!isInitialized())
                return;

        lat = lat_;
        lon = lon_;
        height = alt_;
        
        SilverLining::Location loc = atmosphere->GetConditions()->GetLocation();
        loc.SetAltitude(alt_);
        loc.SetLatitude(lat_);
        loc.SetLongitude(lon_);         
        atmosphere->GetConditions()->SetLocation( loc );

        updateUpVector();
}


bool visual_skySilverLining::isInitialized()
{
        // Check if atmosphere is initialized. If not: make a deep lookup. If initialized, perform. Otherwise return
        if (!atmosphereInitialized)
        {
                skySilverLining_atmosphereReference *ar = dynamic_cast<skySilverLining_atmosphereReference *>(viewer->getCamera()->getUserData());
                if (ar != NULL )
                {
                        if (ar->atmosphereInitialized)
                                atmosphereInitialized = true;
                }
        }
        return(atmosphereInitialized);
}

void visual_skySilverLining::init(osg::Group *distortedRoot, osg::CoordinateSystemNode *sceneGraphRoot)
{
        sceneRoot = sceneGraphRoot;

        // Use projection matrix callback oder fixed Cullsettings?
        bool useProjMatrixCallback = true;

        // add Sky to SceneGraphRoot
        sceneGraphRoot->addChild( this );

        // Deactivate culling for the sky node (required by the silverlining sky framework)
        this->setCullingActive(false);

        // Instantiate an Atmosphere and associate it with this camera. If you have multiple cameras
        // in multiple contexts, be sure to instantiate seperate Atmosphere objects for each.
    // ***IMPORTANT!**** Check that the path to the resources folder for SilverLining in SkyDrawable.cpp
    // SkyDrawable::initializeSilverLining matches with where you installed SilverLining.
        atmosphere = new SilverLining::Atmosphere(SILVERLINING_LICENSEE, SILVERLINING_LICENSE);

    // Add the sky (calls Atmosphere::BeginFrame and handles initialization once you're in
    // the rendering thread)
        skyDrawable = new skySilverLining_skyDrawable(viewer, sceneRoot);

        if(distortedRoot)       // if distortion used:
        {
                int rootKids = distortedRoot->getNumChildren();
                for (int i = 0; i < rootKids; i++)
                {
                        osg::Node *n = distortedRoot->getChild(i);
                        osg::Camera *cam = dynamic_cast<osg::Camera*>(n);
                        if (cam && cam->getRenderOrder() == osg::Camera::PRE_RENDER)
                                sceneCamera = cam;
                }
        }
        else    // if no distortion used:
                sceneCamera = viewer->getCamera();

        osg::Camera *mainCamera = viewer->getCamera();
        if (!useProjMatrixCallback)
        {
                mainCamera->setClearMask(0);
                mainCamera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
                double fovy, aspect, zNear, zFar;
                mainCamera->getProjectionMatrixAsPerspective(fovy, aspect, zNear, zFar);
                mainCamera->setProjectionMatrixAsPerspective(fovy, aspect, 2, 125000);
        }
        else
        {
                cb = new skySilverLining_projectionMatrixCallback( atmosphere, viewer->getCamera(), sceneRoot);
                sceneCamera->setClampProjectionMatrixCallback(cb);
                cb->setSkyDrawable(skyDrawable);
        }

        // append atmosphere pointer to the cameras.
        sceneCamera->setClearMask(0);
        osg::ref_ptr<skySilverLining_atmosphereReference> ar = new skySilverLining_atmosphereReference;
        ar->atmosphere = atmosphere;
        sceneCamera->setUserData(ar);
        mainCamera->setUserData(ar);

        // Create and install updateCallback (for position etc.)
        updateCallback = new skyUpdateCallback( sceneGraphRoot, sceneCamera, this );
        this->setUpdateCallback( updateCallback );

    // Use a RenderBin to enforce that the sky gets drawn first, then the scene, then the clouds
        skyDrawable->getOrCreateStateSet()->setRenderBinDetails(-1, "RenderBin");

    // Add the models
    sceneGraphRoot->getOrCreateStateSet()->setRenderBinDetails(1, "RenderBin");

    // Add the clouds (note, you need this even if you don't want clouds - it calls
    // Atmosphere::EndFrame() )
        cloudsDrawable = new skySilverLining_cloudsDrawable(viewer);
        cloudsDrawable->getOrCreateStateSet()->setRenderBinDetails(99, "RenderBin");

        // Add drawable to this geode to get rendered
        this->addDrawable(skyDrawable);
        this->addDrawable(cloudsDrawable);

        //SilverLining::Atmosphere::EnableHDR( true );
}

void visual_skySilverLining::postInit()
{
        // Only allow one execution
        //if(postInitialized)
        //      return;
        //else postInitialized = true;

        // Execute Updatecallback once before adding Clouds.
        //updateCallback->operator ()(this, NULL);

        //atmosphere->GetConditions()->SetFog( 0.8, 1, 1, 1);   // use this for simulation real fog.

        //Todo: secure memory-manager of timer*. oder remove paragraph
        //MyMillisecondTimer *timer = new MyMillisecondTimer();
 //   atmosphere->GetConditions()->SetMillisecondTimer(timer);
        //atmosphere->GetConditions()->EnableTimePassage(true, -1);
}

void visual_skySilverLining::updateUpVector()
{
        double x,y,z;
    util::getXYZofCamera(sceneCamera, x, y, z);
    osg::Vec3d up(x, y, z);
    up.normalize();

    osg::Vec3d north(0, 0, 1);  // Z is north
    osg::Vec3d east = north ^ up;       // Cross product
    east.normalize();

    atmosphere->SetUpVector(up.x(), up.y(), up.z());
    atmosphere->SetRightVector(east.x(), east.y(), east.z());

    osg::Matrixd proj = sceneCamera->getProjectionMatrix();
    double dProj[16];

    int i = 0;
    for (int row = 0; row < 4; row++)
    {
        for (int col = 0; col < 4; col++)
        {
            dProj[i] = proj(row, col);
            i++;
        }
    }
    //atmosphere->SetProjectionMatrix(dProj);
}

void visual_skySilverLining::shutdown()
{
        if (isInitialized())
        {
                // Remove this Node from scenegraph
                sceneRoot->removeChild( this );
                
                // Remove updatecallback
                this->removeUpdateCallback( updateCallback );
                updateCallback = NULL;

                // delete drawables
                skyDrawable->shutdown();
                this->removeDrawable(skyDrawable);
                this->removeDrawable(cloudsDrawable);
        }
}

void visual_skySilverLining::setVisibility(double visibility_)
{
        if (isInitialized())
        {
                atmosphere->GetConditions()->SetVisibility( visibility_ );
        }

}

double visual_skySilverLining::getVisibility()
{
        if (isInitialized())
        {
                return atmosphere->GetConditions()->GetVisibility();
        }
        else
                return -1;
}

void visual_skySilverLining::setTurbidity(double turbidity_)
{
        if (isInitialized())
        {
                atmosphere->GetConditions()->SetTurbidity( turbidity_ );
        }
}

double visual_skySilverLining::getTurbidity()
{
        if (isInitialized())
        {
                return atmosphere->GetConditions()->GetTurbidity();
        }
        else
                return -1;
}

void visual_skySilverLining::clearAllWindVolumes()
{
        if (isInitialized())
        {
                atmosphere->GetConditions()->ClearWindVolumes();
        }
}

bool visual_skySilverLining::insideWind(double height_, double& bottom_, double& top_, double& speed_, double& direction_)
{
        if (isInitialized())
        {
                // Calculation earth radius on the wind positionl approximated through the now used position.
                double radius;
                if ( util::calculateEarthRadiusAtWGS84Coordinate(lat, lon, sceneRoot, radius) )
                {
                        // go through all wind volumes an check them for inside()
                        //std::map<int, SilverLining::WindVolume> windvolumes = atmosphere->GetConditions()->GetWindVolumes();
                        SL_MAP(int, SilverLining::WindVolume) windvolumes = atmosphere->GetConditions()->GetWindVolumes();
                        for(unsigned int i=0; i<windvolumes.size(); i++)
                        {
                                if( windvolumes[i].Inside(radius + height_) )
                                {
                                        // save wind data
                                        bottom_ = windvolumes[i].GetMinAltitude();
                                        top_ = windvolumes[i].GetMaxAltitude() - radius;
                                        speed_ = windvolumes[i].GetWindSpeed() - radius;
                                        direction_ = windvolumes[i].GetDirection();
                                        // return that wind was found
                                        return true;
                                }
                        }       // For END
                }       // If valid radius END
        }       // If initialized() END
        bottom_ = -1;
        top_ = -1;
        speed_ = -1;
        direction_ = -1;
        return false;
}

void visual_skySilverLining::addWindVolume(double bottom_, double top_, double speed_, int direction_)
{
        if (isInitialized())            
        {
                // Calculation earth radius on current lat lon position
                double radius;
                if ( util::calculateEarthRadiusAtWGS84Coordinate(lat, lon, sceneRoot, radius) )
                {
                        // correct wind value:
                        if ( direction_ < 180 )
                                direction_ += 180;
                        else direction_ -= 180;

                        // Setting up Wind
                        SilverLining::WindVolume wv;
                        wv.SetDirection( direction_ );
                        wv.SetMinAltitude( radius + bottom_ );
                        wv.SetMaxAltitude( radius + top_ );
                        wv.SetWindSpeed( speed_ );
                        atmosphere->GetConditions()->SetWind(wv);
                }
        }
}

void visual_skySilverLining::setLightPollution(double lightPollution_)
{
        if (isInitialized())
        {
                return atmosphere->GetConditions()->SetLightPollution( lightPollution_ );
        }
}

double visual_skySilverLining::getLightPollution()
{
        if (isInitialized())
        {
                return atmosphere->GetConditions()->GetLightPollution();
        }
        else
                return -1;

}

void visual_skySilverLining::addCloudLayer(int slot_, double baseLength_, double baseWidth_, double thickness_, double baseHeight_, double density_, CloudTypes cloudtype_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                // create cloudlayer order and pass to skyDrawable to instantiate.
                cloudlayerOrder newCL;
                newCL.slot = slot_;
                newCL.lat = lat;
                newCL.lon = lon;
                newCL.baseLength = baseLength_;
                newCL.baseWidth = baseWidth_;
                newCL.thickness = thickness_;
                newCL.baseHeight = baseHeight_;
                newCL.density = density_;
                newCL.cloudtype = cloudtype_;
                newCL.assocCloudLayerSlot = &cloudLayerSlots[slot_];
                
                skyDrawable->addCloudLayerOrder( newCL );

        }        // If isInitialized() END
}

void visual_skySilverLining::removeCloudLayer( int slot_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                atmosphere->GetConditions()->RemoveCloudLayer( cloudLayerSlots[slot_].cloudLayerHandle );
                cloudLayerSlots[slot_].used = false;
                cloudLayerSlots[slot_].cloudLayerHandle = -1;
                cloudLayerSlots[slot_].cloudLayerPointer = NULL;
                cloudLayerSlots[slot_].enabled = false;
        }
}

void visual_skySilverLining::clearAllSlots()
{
        if (isInitialized())
        {
                atmosphere->GetConditions()->RemoveAllCloudLayers();
                for( int i=0; i<MAX_CLOUDLAYER_SLOTS; i++ )
                {
                        cloudLayerSlots[i].used = false;
                        cloudLayerSlots[i].cloudLayerHandle = -1;
                        cloudLayerSlots[i].cloudLayerPointer = NULL;
                        cloudLayerSlots[i].enabled = false;
                }
        }
}

SilverLining::CloudLayer* visual_skySilverLining::getCloudLayer( int slot_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                if ( cloudLayerSlots[slot_].used )
                        return cloudLayerSlots[slot_].cloudLayerPointer; 
        }

        return NULL;
}

void visual_skySilverLining::setEnabled(int slot_, bool enabled_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                cloudLayerSlots[slot_].enabled = enabled_;
        }
}

bool visual_skySilverLining::isEnabled( int slot_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                return cloudLayerSlots[slot_].enabled;
        }
        return false;
}

void visual_skySilverLining::fadeVisibility( int slot_, int fadetimeMS_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                if (cloudLayerSlots[slot_].enabled)
                {
                        cloudLayerSlots[slot_].enabled = false;
                        cloudLayerSlots[slot_].cloudLayerPointer->SetEnabled( false, fadetimeMS_ );
                }
                else
                {
                        cloudLayerSlots[slot_].enabled = true;
                        cloudLayerSlots[slot_].cloudLayerPointer->SetEnabled( true, fadetimeMS_ );
                }
        }
}

std::string visual_skySilverLining::getCloudLayerTypeName( int slot_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                return cloudLayerSlots[slot_].typeName;
        }
        return "";
}

void visual_skySilverLining::clearGlobalPrecipitation()
{
        if (isInitialized())
        {
                atmosphere->GetConditions()->SetPrecipitation( SilverLining::CloudLayer::NONE, 0.0 );
        }
}

void visual_skySilverLining::setGlobalPrecipitation( double rate_mmPerHour_rain_, double rate_mmPerHour_drySnow_, double rate_mmPerHour_wetSnow_, double rate_mmPerHour_sleet_ )
{
        if ( isInitialized() )
        {
                // Delete old Precipitation
                atmosphere->GetConditions()->SetPrecipitation( SilverLining::CloudLayer::NONE, 0.0 );
                
                // Set new Precipitation
                atmosphere->GetConditions()->SetPrecipitation( SilverLining::CloudLayer::RAIN, rate_mmPerHour_rain_ );
                atmosphere->GetConditions()->SetPrecipitation( SilverLining::CloudLayer::WET_SNOW, rate_mmPerHour_drySnow_ );
                atmosphere->GetConditions()->SetPrecipitation( SilverLining::CloudLayer::DRY_SNOW, rate_mmPerHour_wetSnow_ );
                atmosphere->GetConditions()->SetPrecipitation( SilverLining::CloudLayer::SLEET, rate_mmPerHour_sleet_ );
        }
}
        
bool visual_skySilverLining::getOverallPrecipitationAtLocation( double& rate_mmPerHour_rain, double& rate_mmPerHour_drySnow, double& rate_mmPerHour_wetSnow, double& rate_mmPerHour_sleet, double lat_, double lon_, double height_ )
{
        if (isInitialized())
        {
                // Init
                bool hasPrecipitation = false;
                double x = 0;
                double y = 0;
                double z = 0;
                //// If -1 : Use sky internal values
                if ( lat_ == -1 )
                        lat_ = lat;
                if ( lon_ == -1 )
                        lon_ = lon;
                if ( height_ == -1 )
                        height_ = height;

                // Set precipitation to zero;
                rate_mmPerHour_rain = 0;
                rate_mmPerHour_drySnow = 0;
                rate_mmPerHour_wetSnow = 0;
                rate_mmPerHour_sleet = 0;

                // Get global position
                util::calculateXYZAtWGS84Coordinate(lat_, lon_, height_, sceneRoot, x, y, z);

                // Look up every cloud layer for it's precipitation.
                for( int i=0; i<MAX_CLOUDLAYER_SLOTS; i++ )
                {
                        if ( cloudLayerSlots[i].used )  // IF used, Pointer should be valid
                        {
                                if( cloudLayerSlots[i].cloudLayerPointer->HasPrecipitationAtPosition(x, y, z) )
                                {
                                        hasPrecipitation = true;
                                        SL_MAP (int, double) precipitationMap = cloudLayerSlots[i].cloudLayerPointer->GetPrecipitation();
                                        for( SL_MAP (int, double)::iterator it = precipitationMap.begin(); it != precipitationMap.end(); it++ )
                                        {
                                                switch(it->first)
                                                {
                                                        case SilverLining::CloudLayer::RAIN : rate_mmPerHour_rain += it->second;
                                                                break;
                                                        case SilverLining::CloudLayer::DRY_SNOW : rate_mmPerHour_drySnow += it->second;
                                                                break;
                                                        case SilverLining::CloudLayer::WET_SNOW : rate_mmPerHour_wetSnow += it->second;
                                                                break;
                                                        case SilverLining::CloudLayer::SLEET : rate_mmPerHour_sleet += it->second;
                                                                break;
                                                        default: OSG_NOTIFY( osg::FATAL ) << "ERROR: visual_skySilverLining::getOverallPrecipitationAtLocation() : Wrong precipitation type in map!" << std::endl;
                                                                break;
                                                };
                                        }
                                }       // If slot has Precipitation END
                        }       // If used END
                }       // For all slots END

                OSG_NOTIFY( osg::ALWAYS ) << "Rain: " << rate_mmPerHour_rain << ", dry snow: " << rate_mmPerHour_drySnow << ", wet snow: " << rate_mmPerHour_wetSnow << ", sleet: " << rate_mmPerHour_sleet << std::endl;
                return hasPrecipitation;

        }       // If initialized END
        return false;
}


bool visual_skySilverLining::getSlotPrecipitationAtLocation( int slot_, double& rate_mmPerHour_rain, double& rate_mmPerHour_drySnow, double& rate_mmPerHour_wetSnow, double& rate_mmPerHour_sleet, double lat_, double lon_, double height_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                if( cloudLayerSlots[slot_].used )       // IF used, Pointer should be valid
                {
                        double x = 0;
                        double y = 0;
                        double z = 0;
                        rate_mmPerHour_rain = 0;
                        rate_mmPerHour_drySnow = 0;
                        rate_mmPerHour_wetSnow = 0;
                        rate_mmPerHour_sleet = 0;
                        //// If -1 : Use sky internal values
                        if ( lat_ == -1 )
                                lat_ = lat;
                        if ( lon_ == -1 )
                                lon_ = lon;
                        if ( height_ == -1 )
                                height_ = height;

                        // Get global position
                        util::calculateXYZAtWGS84Coordinate(lat_, lon_, height_, sceneRoot, x, y, z);

                        // Check for precipitation
                        if( cloudLayerSlots[slot_].cloudLayerPointer->HasPrecipitationAtPosition(x, y, z) )
                        {
                                SL_MAP (int, double) precipitationMap = cloudLayerSlots[slot_].cloudLayerPointer->GetPrecipitation();
                                for( SL_MAP (int, double)::iterator it = precipitationMap.begin(); it != precipitationMap.end(); it++ )
                                {
                                        switch(it->first)
                                        {
                                                case SilverLining::CloudLayer::RAIN : rate_mmPerHour_rain = it->second;
                                                        break;
                                                case SilverLining::CloudLayer::DRY_SNOW : rate_mmPerHour_drySnow = it->second;
                                                        break;
                                                case SilverLining::CloudLayer::WET_SNOW : rate_mmPerHour_wetSnow = it->second;
                                                        break;
                                                case SilverLining::CloudLayer::SLEET : rate_mmPerHour_sleet = it->second;
                                                        break;
                                                default: OSG_NOTIFY( osg::FATAL ) << "ERROR: visual_skySilverLining::getSlotPrecipitationAtLocation() : Wrong precipitation type in map!" << std::endl;
                                                        break;
                                        };
                                }       // FOR END
                                OSG_NOTIFY( osg::ALWAYS ) << "Rain: " << rate_mmPerHour_rain << ", dry snow: " << rate_mmPerHour_drySnow << ", wet snow: " << rate_mmPerHour_wetSnow << ", sleet: " << rate_mmPerHour_sleet << std::endl;
                                return true;
                        }       // If slot has Precipitation END
                        else 
                                return false;
                }       // If used END
                else
                        return false;
        }       // If initialized END
        return false;
}

bool visual_skySilverLining::getSlotPrecipitation( int slot_, double& rate_mmPerHour_rain, double& rate_mmPerHour_drySnow, double& rate_mmPerHour_wetSnow, double& rate_mmPerHour_sleet )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                if( cloudLayerSlots[slot_].used )       // IF used, Pointer should be valid
                {
                        rate_mmPerHour_rain = 0;
                        rate_mmPerHour_drySnow = 0;
                        rate_mmPerHour_wetSnow = 0;
                        rate_mmPerHour_sleet = 0;

                        // Check for precipitation

                                SL_MAP (int, double) precipitationMap = cloudLayerSlots[slot_].cloudLayerPointer->GetPrecipitation();
                                for( SL_MAP (int, double)::iterator it = precipitationMap.begin(); it != precipitationMap.end(); it++ )
                                {
                                        switch(it->first)
                                        {
                                                case SilverLining::CloudLayer::RAIN : rate_mmPerHour_rain = it->second;
                                                        break;
                                                case SilverLining::CloudLayer::DRY_SNOW : rate_mmPerHour_drySnow = it->second;
                                                        break;
                                                case SilverLining::CloudLayer::WET_SNOW : rate_mmPerHour_wetSnow = it->second;
                                                        break;
                                                case SilverLining::CloudLayer::SLEET : rate_mmPerHour_sleet = it->second;
                                                        break;
                                                default: OSG_NOTIFY( osg::FATAL ) << "ERROR: visual_skySilverLining::getSlotPrecipitation() : Wrong precipitation type in map!" << std::endl;
                                                        break;
                                        };
                                }       // FOR END
                                
                                if ( rate_mmPerHour_rain>0 || rate_mmPerHour_drySnow>0 || rate_mmPerHour_wetSnow>0 || rate_mmPerHour_sleet>0)
                                {
                                        OSG_NOTIFY( osg::ALWAYS ) << "Rain: " << rate_mmPerHour_rain << ", dry snow: " << rate_mmPerHour_drySnow << ", wet snow: " << rate_mmPerHour_wetSnow << ", sleet: " << rate_mmPerHour_sleet << std::endl;
                                        return true;
                                }
                                else
                                        return false;
                }       // If used END
                else
                        return false;
        }       // If initialized END
        return false;
}

void visual_skySilverLining::clearAllPrecipitation( int slot_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                if( cloudLayerSlots[slot_].used )       // IF used, Pointer should be valid
                {
                        cloudLayerSlots[slot_].cloudLayerPointer->SetPrecipitation( SilverLining::CloudLayer::NONE, 0.0 );
                        cloudLayerSlots[slot_].cloudLayerPointer->SetPrecipitation( SilverLining::CloudLayer::NONE, 0.0 ); // Second Call to clear precipitation rate.
                }
        }
}

void visual_skySilverLining::setSlotPrecipitation( int slot_, double rate_mmPerHour_rain_, double rate_mmPerHour_drySnow_, double rate_mmPerHour_wetSnow_, double rate_mmPerHour_sleet_ )
{
        if (isInitialized() && slot_ >= 0 && slot_ < MAX_CLOUDLAYER_SLOTS)
        {
                if( cloudLayerSlots[slot_].used )       // IF used, Pointer should be valid
                {
                        cloudLayerSlots[slot_].cloudLayerPointer->SetPrecipitation( SilverLining::CloudLayer::RAIN, rate_mmPerHour_rain_ );
                        cloudLayerSlots[slot_].cloudLayerPointer->SetPrecipitation( SilverLining::CloudLayer::DRY_SNOW, rate_mmPerHour_drySnow_ );
                        cloudLayerSlots[slot_].cloudLayerPointer->SetPrecipitation( SilverLining::CloudLayer::WET_SNOW, rate_mmPerHour_wetSnow_ );
                        cloudLayerSlots[slot_].cloudLayerPointer->SetPrecipitation( SilverLining::CloudLayer::SLEET, rate_mmPerHour_sleet_ );
                }
        }
}

void visual_skySilverLining::configureCloudlayerbyXML( xmlNode* cloudlayerNode_ )
{
        std::string node_name=reinterpret_cast<const char*>(cloudlayerNode_->name);
        if(cloudlayerNode_->type == XML_ELEMENT_NODE && node_name == "clouds")
        {
                for (cloudlayerNode_= cloudlayerNode_->children; cloudlayerNode_; cloudlayerNode_ = cloudlayerNode_->next)
                {
                        node_name=reinterpret_cast<const char*>(cloudlayerNode_->name);
                        if(cloudlayerNode_->type == XML_ELEMENT_NODE && node_name == "cloudlayer")
                        {
                                int slot = -1;
                                bool enabled;
                                int fadetime = -1, baselength = -1, basewidth = -1, thickness = -1, baseHeight = -1 ;
                                float density = -1.0, rate_mmPerHour_rain = -1.0, rate_mmPerHour_drySnow = -1.0, rate_mmPerHour_wetSnow = -1.0, rate_mmPerHour_sleet = -1.0;
                                CloudTypes ctype = CUMULUS_CONGESTUS; 

                                xmlAttr  *attr = cloudlayerNode_->properties;
                                while ( attr ) 
                                { 
                                        std::string attr_name=reinterpret_cast<const char*>(attr->name);
                                        std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
                                        if( attr_name == "slot" ) slot = util::strToInt(attr_value);
                                        if( attr_name == "enabled" ) enabled = util::strToBool(attr_value);
                                        if( attr_name == "fadetime" ) fadetime = util::strToInt(attr_value);
                                        if( attr_name == "type" )
                                        {
                                                if(attr_value=="CIRROCUMULUS")
                                                        ctype = CIRROCUMULUS;
                                                if(attr_value=="CIRRUS_FIBRATUS")
                                                        ctype = CIRRUS_FIBRATUS;
                                                if(attr_value=="STRATUS")
                                                        ctype = STRATUS;
                                                if(attr_value=="CUMULUS_MEDIOCRIS")
                                                        ctype = CUMULUS_MEDIOCRIS;
                                                if(attr_value=="CUMULUS_CONGESTUS")
                                                        ctype = CUMULUS_CONGESTUS;
                                                if(attr_value=="CUMULONIMBUS_CAPPILATUS")
                                                        ctype = CUMULONIMBUS_CAPPILATUS;
                                                if(attr_value=="STRATOCUMULUS")
                                                        ctype = STRATOCUMULUS;
                                        }
                                        attr = attr->next; 
                                }

                                if(!cloudlayerNode_->children)
                                {
                                        OSG_NOTIFY( osg::ALWAYS ) << "ERROR - visual_skySilverLining::configureCloudlayerbyXML: Missing geometry specification for a cloudlayer." << std::endl;
                                        return;
                                }

                                for (xmlNode *cur_node = cloudlayerNode_->children; cur_node; cur_node = cur_node->next)
                                {
                                        node_name=reinterpret_cast<const char*>(cur_node->name);
                                        if(cur_node->type == XML_ELEMENT_NODE && node_name == "geometry")
                                        {
                                                xmlAttr  *attr = cur_node->properties;
                                                while ( attr ) 
                                                { 
                                                        std::string attr_name=reinterpret_cast<const char*>(attr->name);
                                                        std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
                                                        if( attr_name == "baselength" ) baselength = util::strToInt(attr_value);
                                                        if( attr_name == "basewidth" )  basewidth = util::strToInt(attr_value);
                                                        if( attr_name == "thickness" )  thickness = util::strToInt(attr_value);
                                                        if( attr_name == "baseHeight" ) baseHeight = util::strToInt(attr_value);
                                                        if( attr_name == "density" ) density = util::strToDouble(attr_value);

                                                        attr = attr->next; 
                                                }
                                        }

                                        if(cur_node->type == XML_ELEMENT_NODE && node_name == "precipitation")
                                        {
                                                xmlAttr  *attr = cur_node->properties;
                                                while ( attr ) 
                                                { 
                                                        std::string attr_name=reinterpret_cast<const char*>(attr->name);
                                                        std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
                                                        if( attr_name == "rate_mmPerHour_rain" ) rate_mmPerHour_rain = util::strToDouble(attr_value);
                                                        if( attr_name == "rate_mmPerHour_drySnow" ) rate_mmPerHour_drySnow = util::strToDouble(attr_value);
                                                        if( attr_name == "rate_mmPerHour_wetSnow" ) rate_mmPerHour_wetSnow = util::strToDouble(attr_value);
                                                        if( attr_name == "rate_mmPerHour_sleet" ) rate_mmPerHour_sleet = util::strToDouble(attr_value);

                                                        attr = attr->next; 
                                                }
                                        }
                                }

                                if(slot!=-1 && baselength!=-1 && basewidth!=-1 && thickness!=-1 && baseHeight!=-1 && density!=-1 )
                                        addCloudLayer( slot, baselength, basewidth, thickness, baseHeight, density, ctype );

                                if(slot!=-1 && rate_mmPerHour_rain!=-1 && rate_mmPerHour_drySnow!=-1 && thickness!=-1 && baseHeight!=-1 && density!=-1 )
                                        setSlotPrecipitation( slot, rate_mmPerHour_rain, rate_mmPerHour_drySnow, rate_mmPerHour_wetSnow, rate_mmPerHour_sleet );
                        }       // If Node = cloudlayer END
                }       // FOR-loop end
        }       // If Clouds END
                else
        OSG_NOTIFY( osg::ALWAYS ) << "ERROR - visual_skySilverLining::configureCloudlayerbyXML: Node is not a <clouds> node." << std::endl;
}