source: osgVisual/include/util/visual_util.h @ 104

#pragma once
/* -*-c++-*- osgVisual - Copyright (C) 2009-2010 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 <string.h>
#include <iostream>


#include <osg/Node>
#include <osg/Group>
#include <osg/Geode>
#include <osg/CoordinateSystemNode>
#include <osg/ShapeDrawable>

#include <osgViewer/Viewer>

#ifdef FUNFUNCTIONS_ENABLED
#ifdef WIN32
#include <osgViewer/api/Win32/GraphicsHandleWin32>
#include "C:\\Program Files/Microsoft SDKs/Windows/v6.1/Include/dwmapi.h"
#pragma comment ( lib, "C:\\Program Files/Microsoft SDKs/Windows/v6.1/Lib/dwmapi.lib" )
#endif
#endif

#include <OpenThreads/ReentrantMutex>

#include <osgUtil/LineSegmentIntersector>

namespace osgVisual
{ 

/**
 * \brief This class provides utility functions. 
 * 
 * The utility functions are implemented as static functions if possible for easy use in other classes.
 * 
 * \todo check why lineIntersector is unstable, check if newer and better system is available.
 * 
 * @author Torben Dannhauer
 * @date  Jul 2009
 */ 
class util
{
        #include <leakDetection.h>
public:
        /**
         * \brief Construtor
         * 
         */ 
        util();

        /**
         * \brief Destructor
         * 
         */ 
        ~util();

        /**
         * \brief This functions searches in the scene graph for a node with a name
         * 
         * This function searches in the scene graph unter the node "currNode" for a node named like the given search name.
         * The functions returns the first node with that name.
         * 
         * @param searchName_ : Nodename to search for
         * @param currNode_ : Scene graph to search in.
         * @return : if Node found: Pointer to the node. If not found: NULL
         */ 
        static osg::Node* findNamedNode(const std::string& searchName_, osg::Node* currNode_);

        /**
         * \brief This function creates a red cylinder of the specified size tor testing purposes.
         * 
         * @param length_ : Length of the cylinder in meter.
         * @param width_ : Diameter of the cylinder in meter.
         * @param offset_ : Offset of the cylinder's origin in meter.
         * @return : Referenced Pointer off the Geode with the created cylinder.
         */ 
        static osg::ref_ptr<osg::Geode> getDemoCylinder(double length_, double width_, osg::Vec3 offset_ = osg::Vec3(0.0, 0.0, 0.0) );
        
        /**
         * \brief This function creates a red sphere of the specified size tor testing purposes.
         * 
         * @param radius_ : Radius of the sphere in meter.
         * @param offset_ : Offset of the sphere's origin in meter.
         * @return : Referenced Pointer off the Geode with the created cylinder.
         */ 
        static osg::ref_ptr<osg::Geode> getDemoSphere(double radius_, osg::Vec3 offset_ = osg::Vec3(0.0, 0.0, 0.0) );

        /**
         * \brief This functions searches the scene graph for intersections of a line between two points and the model.
         * 
         * @param start_ : Point 1 for the intersection line
         * @param end_ : Point 2 for the intersection line
         * @param intersection_ : vektor to the intersection point if any is found.
         * @param node_ : Node which is the root of the scene graph to check for intersections
         * @param intersectTraversalMask_ : Bitwise mask wich controls which nodes should be checked for intersections (e.g. to check only terrain but not clouds or sky)
         * @return returns : True if an intersection is found. 
         */ 
        static bool intersect(const osg::Vec3d& start_, const osg::Vec3d& end_, osg::Vec3d& intersection_, osg::Node* node_, osg::Node::NodeMask intersectTraversalMask_=0xffffffff );

        /**
         * \brief This function queries the height of terrain (hot) at a specified location.
         * 
         * @param hot_ : Reference to write the calculated hot into.
         * @param rootNode_ : Node which is the root of the scene graph to calculate the hot.
         * @param lat_ : Latitude of the position to calculate the hot.
         * @param lon_ : Longitude of the position to calculate the hot.
         * @param traversalMask_ : Bitwise mask wich controls which nodes should be checked for hot (e.g. to check only terrain but not clouds or sky)
         * @return : True if hot calculation successful.
         */ 
        static bool queryHeightOfTerrain(double& hot_, osg::Node* rootNode_, double lat_, double lon_, osg::Node::NodeMask traversalMask_=0xffffffff);

        /**
         * \brief This function queries the height above terrain (hat) at a specified location in WGS84 coordinates.
         * 
         * @param hat_ : Reference to write the calculated hat into.
         * @param rootNode_ : Node which is the root of the scene graph to calculate the hat.
         * @param lat_ : Latitude of the position to calculate the hat. (e.g. lat of camera)
         * @param lon_ : Longitude of the position to calculate the hat.(e.g. lon of camera)
         * @param height_ : Height of the position to calculate the hat.(e.g. height of camera).
         * @param traversalMask_ : Bitwise mask wich controls which nodes should be checked for hat (e.g. to check only terrain but not clouds or sky)
         * @return :  True if hat calculation successful.
         */ 
        static bool queryHeightAboveTerrainInWGS84(double& hat_, osg::Node* rootNode_, double lat_, double lon_, double height_, osg::Node::NodeMask traversalMask_=0xffffffff);

        /**
         * \brief This function queries the height above terrain (hat) at a specified location in world coordinates.
         * 
         * @param hat_ : Reference to write the calculated hat into.
         * @param rootNode_ : Node which is the root of the scene graph to calculate the hat.
         * @param x_ : First value of the pointer which points to the position to calculate hat for.
         * @param y_ : Second value of the pointer which points to the position to calculate hat for. 
         * @param z_ : Third value of the pointer which points to the position to calculate hat for.
         * @param traversalMask_ : Bitwise mask wich controls which nodes should be checked for hat (e.g. to check only terrain but not clouds or sky)
         * @return :  True if hat calculation successful. 
         */ 
        static bool queryHeightAboveTerrainInWorld(double& hat_, osg::Node* rootNode_, double x_, double y_, double z_, osg::Node::NodeMask traversalMask_=0xffffffff);

        /**
         * \brief This function calculates the earth readius (vector length in world coordiantes from origin to location) at the specified location.
         * 
         * @param lat_ : Latitude in radians.
         * @param lon_ : Longitude in radians.
         * @param rootNode_ : Root node of the scene which coordinate system node should be used.
         * @param radius_ : Calculated earth readius in meter.
         * @return : True if calculation successful.
         */ 
        static bool calculateEarthRadiusAtWGS84Coordinate(double lat_, double lon_, osg::Node* rootNode_, double& radius_);

        /**
         * \brief This function converts a WGS84 position into global OpenGL XYZ coordinates.
         * 
         * @param lat_ : Latitude of the position to calculate XYZ.
         * @param lon_ : Longitude of the position to calculate XYZ.
         * @param height_ : Height of the position to calculate XYZ.
         * @param rootNode_ : Node which is the root of the scene graph to calculate XYZ.
         * @param x_ : X Coordinate in global OpenGL coordinates.
         * @param y_ : Y Coordinate in global OpenGL coordinates.
         * @param z_ : Z Coordinate in global OpenGL coordinates.
         * @return : True if calculation successful.
         */ 
        static bool calculateXYZAtWGS84Coordinate(double lat_, double lon_, double height_, osg::Node* rootNode_, double& x_, double& y_, double& z_);

        /**
         * \brief This function calculates lat, lon and height of a specified camera by a specified coordinate system node. 
         * 
         * @param camera_ : Camera node which position should be calculated.
         * @param rootNode_ : rootNode of the scene.
         * @param lat_ : Latitude variable to save value in.
         * @param lon_ : Longitude variable to save value in.
         * @param height_ : Height: variable to save value in.
         * @return : True if calculation was successful.
         */ 
        static bool getWGS84ofCamera( osg::Camera* camera_, osg::Node* rootNode_, double& lat_, double& lon_, double& height_ ); 

        /**
         * \brief This function returns the global XYZ coordinates of the specified camera.
         * 
         * @param camera_ : Camera to return the position.
         * @param x_ : X coordinate.
         * @param y_ : Y coordinate.
         * @param z_ : Z coordinate.
         */ 
        static void getXYZofCamera( osg::Camera* camera_, double& x_, double& y_, double& z_ ); 

        /**
         * \brief This function disables the close button on the openGL's windowdecoration
         * 
         * To be honest, this function is only to play, I have found it on http://forum.openscenegraph.org and found it interesting enought to play along ;)
         * 
         * @param viewer_ : Pointer to the applications viewer
         * @return : true if successful
         */ 
        static bool removeClosebuttonOnGLWindow(osgViewer::Viewer* viewer_);

        /**
         * \brief This function make the backgroud of the GL window blurred transparent, if an backgroud with alpha is set.
         * 
         * To be honest, this function is only to play, I have found it on http://forum.openscenegraph.org and found it interesting enought to play along ;)
         * 
         * @param viewer_ : Pointer to the applications viewer
         * @return : true if successful
         */ 
        static bool setTransparentWindowBackground(osgViewer::Viewer* viewer_);
};

} //END NAMESPACE