Changeset 197 for osgVisual/trunk

Timestamp:

Jan 12, 2011, 10:20:19 PM (14 years ago)

Author:

Torben Dannhauer

Message:

working commit for backup purposes, not compiling at this stage.. sorry, will be corrected tomorrow

Location:

osgVisual/trunk

Files:

• bin/osgVisualConfig.xml (modified) (2 diffs)
• include/sky_Silverlining/visual_skySilverLining.h (modified) (3 diffs)
• src/sky_Silverlining/visual_skySilverLining.cpp (modified) (1 diff)

osgVisual/trunk/bin/osgVisualConfig.xml

@@ -38 +38 @@
   
   <scenery>
-    <terrain filename="D:/OpenSceneGraph/VPB-Testdatensatz/DB_Small/database.ive"></terrain>
+    <terrain filename="D:/OpenSceneGraph/VPB-Testdatensatz/DB_Small/database.ive" filename2="J:\BRD1m_MUC0.25m_srtmEU_BM\terrain.ive"></terrain>
     <animationpath filename="salzburg.path"></animationpath>
     <models>
@@ -50 +50 @@
       </model>
     </models>
-    <datetime day="0" month="0" year="0" hour="15" minute="30"></datetime>
+    <datetime day="0" month="0" year="0" hour="12" minute="30"></datetime>
     <visibility range="50000" turbidity="2.2" ></visibility>
     <cloudlayer slot="1" type="cumulusCongestus" enabled="true" fadetime="15">

osgVisual/trunk/include/sky_Silverlining/visual_skySilverLining.h

@@ -34 +34 @@
 
 #include <visual_util.h>
+
+// XML Parser
+#include <stdio.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+
+#include <string.h>
+#include <iostream>
 
 namespace osgVisual
@@ -252 +260 @@
          *
          * \li CloudTypes::CIRROCUMULUS - High planar cloud puffs.
-         * \li CloudTypes::CIRRUS_FIBRATUS - High, wispy cirrus clouds.
-     * \li CloudTypes::NIMBOSTRATUS - Low stratus decks.
-     * \li CloudTypes::CUMULONIMBUS_CAPPILATUS - A large thunderhead with lightning and rain.
-     * \li CloudTypes::CUMULUS_MEDIOCRIS - Small, puffy clouds.
-     * \li CloudTypes::CUMULUS_CONGESTUS - Larger cumulus clouds with flattened bottoms.
-     * \li CloudTypes::CUMULUS_MEDIOCRIS_INFINITE - A cumulus mediocris layer where the clouds wrap around
-     *  the camera location at all times, to create the illusion of an infinitely large cloud layer.
-     * \li CloudTypes::CUMULUS_CONGESTUS_INFINITE - A cumulus congestus layer where the clouds wrap around
+         * \li CloudTypes::CIRRUS_FIBRATUS - High, thicker and fibrous clouds that signal changing weather.
+     * \li CloudTypes::STRATUS - Low clouds represented as a slab.
+     * \li CloudTypes::CUMULUS_MEDIOCRIS - Low, puffy clouds on fair days.
+     * \li CloudTypes::CUMULUS_CONGESTUS - Large cumulus clouds that could turn into a thunderhead.
+         * \li CloudTypes::CUMULONIMBUS_CAPPILATUS - A large thunderhead with lightning and rain.
+     * \li CloudTypes::STRATOCUMULUS - Low, dense, puffy clouds with some sun breaks between them.
      *  the camera location at all times, to create the illusion of an infinitely large cloud layer.
          * 
@@ -466 +472 @@
 
 
-
-
+/** @name XML configuration
+ *  The following functions provide the XML functionality to configure sky via XML
+ */
+//@{
+        void configureCloudlayerbyXML( xmlNode* cloudlayerNode_ );
+//@}
 
 private:

osgVisual/trunk/src/sky_Silverlining/visual_skySilverLining.cpp

@@ -742 +742 @@
         }
 }
+
+void visual_skySilverLining::configureCloudlayerbyXML( xmlNode* cloudlayerNode_ )
+{
+        std::string 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" )
+                        {
+                                std::stringstream sstr(attr_value);
+                                sstr >> slot;
+                        }
+                        if( attr_name == "enabled" )
+                        {
+                                if(attr_value=="yes")
+                                        enabled = true;
+                                else
+                                        enabled = false;
+                        }
+                        if( attr_name == "fadetime" )
+                        {
+                                std::stringstream sstr(attr_value);
+                                sstr >> fadetime;
+                        }
+                        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; 
+                }
+
+                cloudlayerNode_ = cloudlayerNode_->children;
+                if(!cloudlayerNode_)
+                {
+                        OSG_NOTIFY( osg::ALWAYS ) << "ERROR - visual_skySilverLining::configureCloudlayerbyXML: Missing geometry specification for a cloudlayer." << std::endl;
+                        return;
+                }
+
+                for (xmlNode *cur_node = cloudlayerNode_; cur_node; cur_node = cur_node->next)
+                {
+                        if(cur_node->type == XML_ELEMENT_NODE && node_name == "geometry")
+                        {
+                                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 == "baselength" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> baselength;
+                                        }
+                                        if( attr_name == "basewidth" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> basewidth;
+                                        }
+                                        if( attr_name == "thickness" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> thickness;
+                                        }
+                                        if( attr_name == "baseHeight" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> baseHeight;
+                                        }
+                                        if( attr_name == "density" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> density;
+                                        }
+                                        attr = attr->next; 
+                                }
+                        }
+
+                        if(cur_node->type == XML_ELEMENT_NODE && node_name == "precipitation")
+                        {
+                                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 == "rate_mmPerHour_rain" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> rate_mmPerHour_rain;
+                                        }
+                                        if( attr_name == "rate_mmPerHour_drySnow" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> rate_mmPerHour_drySnow;
+                                        }
+                                        if( attr_name == "rate_mmPerHour_wetSnow" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> rate_mmPerHour_wetSnow;
+                                        }
+                                        if( attr_name == "rate_mmPerHour_sleet" )
+                                        {
+                                                std::stringstream sstr(attr_value);
+                                                sstr >> rate_mmPerHour_sleet;
+                                        }
+                                        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 );
+        }
+        else
+                OSG_NOTIFY( osg::ALWAYS ) << "ERROR - visual_skySilverLining::configureCloudlayerbyXML: Node is not a cloudlayer node." << std::endl;
+}