FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

2.8 branch: Bump version# to 2.8.5 and SO# to 74. Backport the Notify macro modifications and CMake variable to compile out notification.

Browse Source
This commit is contained in:
Paul MARTZ
2011-05-02 17:59:02 +00:00
parent 18d9206a5e 7269f71c47 b8b536257c
commit 288fb20eb6
5 changed files with 254 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@@ -30,7 +30,7 @@ PROJECT(OpenSceneGraph)
SET(OPENSCENEGRAPH_MAJOR_VERSION 2)
SET(OPENSCENEGRAPH_MINOR_VERSION 8)
SET(OPENSCENEGRAPH_PATCH_VERSION 4)
SET(OPENSCENEGRAPH_PATCH_VERSION 5)
SET(OPENSCENEGRAPH_SOVERSION 65)
# set to 0 when not a release candidate, non zero means that any generated
@@ -245,6 +245,8 @@ ENDIF(WIN32)
#luigi#ENDIF(UNIX)
########################################################################################################
OPTION(OSG_NOTIFY_DISABLED "Set to ON to build OpenSceneGraph with the noitfy() disabled." OFF)
OPTION(OSG_USE_FLOAT_MATRIX "Set to ON to build OpenSceneGraph with float Matrix instead of double." OFF)
MARK_AS_ADVANCED(OSG_USE_FLOAT_MATRIX)

103
include/osg/Notify
View File

@@ -11,10 +11,11 @@
* OpenSceneGraph Public License for more details.
*/
#ifndef OSG_NOTIFY
#define OSG_NOTIFY 1
#ifndef OSG_NOTIFY_H
#define OSG_NOTIFY_H 1
#include <osg/Export>
#include <osg/Referenced> // for NotifyHandler
#include <ostream>
@@ -23,8 +24,8 @@ namespace osg {
/** Range of notify levels from DEBUG_FP through to FATAL, ALWAYS
* is reserved for forcing the absorption of all messages. The
* keywords are also used verbatim when specified by the environmental
* variable OSGNOTIFYLEVEL. See documentation on osg::notify() for
* further details.
* variable OSGNOTIFYLEVEL or OSG_NOTIFY_LEVEL.
* See documentation on osg::notify() for further details.
*/
enum NotifySeverity {
ALWAYS=0,
@@ -37,38 +38,108 @@ enum NotifySeverity {
};
/** set the notify level, overriding the default or the value set by
* the environmental variable OSGNOTIFYLEVEL.
* the environmental variable OSGNOTIFYLEVEL or OSG_NOTIFY_LEVEL.
*/
extern OSG_EXPORT void setNotifyLevel(NotifySeverity severity);
/** get the notify level. */
extern OSG_EXPORT NotifySeverity getNotifyLevel();
/** is notification enabled, given the current setNotifyLevel() setting? */
extern OSG_EXPORT bool isNotifyEnabled(NotifySeverity severity);
/** initialize notify level. */
extern OSG_EXPORT bool initNotifyLevel();
#ifdef OSG_NOTIFY_DISABLED
inline bool isNotifyEnabled(NotifySeverity) { return false; }
#else
/** is notification enabled, given the current setNotifyLevel() setting? */
extern OSG_EXPORT bool isNotifyEnabled(NotifySeverity severity);
#endif
/** notify messaging function for providing fatal through to verbose
* debugging messages. Level of messages sent to the console can
* be controlled by setting the NotifyLevel either within your
* application or via the an environmental variable. For instance
* setenv OSGNOTIFYLEVEL DEBUG (for tsh), export OSGNOTIFYLEVEL=DEBUG
* (for bourne shell) or set OSGNOTIFYLEVEL=DEBUG (for Windows) all
* tell the osg to redirect all debugging and more important messages
* to the console (useful for debugging :-) setting ALWAYS will force
* application or via the an environmental variable i.e.
* - setenv OSGNOTIFYLEVEL DEBUG (for tsh)
* - export OSGNOTIFYLEVEL=DEBUG (for bourne shell)
* - set OSGNOTIFYLEVEL=DEBUG (for Windows)
*
* All tell the osg to redirect all debugging and more important messages
* to the notification stream (useful for debugging) setting ALWAYS will force
* all messages to be absorbed, which might be appropriate for final
* applications. Default NotifyLevel is NOTICE. Check the enum
* NotifySeverity for full range of possibilities. To use the notify
* #NotifySeverity for full range of possibilities. To use the notify
* with your code simply use the notify function as a normal file
* stream (like cout) i.e osg::notify(osg::DEBUG) << "Hello Bugs!"<<endl;
* stream (like std::cout) i.e
* @code
* osg::notify(osg::DEBUG) << "Hello Bugs!" << std::endl;
* @endcode
* @see setNotifyLevel, setNotifyHandler
*/
extern OSG_EXPORT std::ostream& notify(const NotifySeverity severity);
inline std::ostream& notify(void) { return notify(osg::INFO); }
#define OSG_NOTIFY(level) if (osg::isNotifyEnabled(level)) osg::notify(level)
#define OSG_ALWAYS OSG_NOTIFY(osg::ALWAYS)
#define OSG_FATAL OSG_NOTIFY(osg::FATAL)
#define OSG_WARN OSG_NOTIFY(osg::WARN)
#define OSG_NOTICE OSG_NOTIFY(osg::NOTICE)
#define OSG_INFO OSG_NOTIFY(osg::INFO)
#define OSG_DEBUG OSG_NOTIFY(osg::DEBUG_INFO)
#define OSG_DEBUG_FP OSG_NOTIFY(osg::DEBUG_FP)
/** Handler processing output of notification stream. It acts as a sink to
* notification messages. It is called when notification stream needs to be
* synchronized (i.e. after osg::notify() << std::endl).
* StandardNotifyHandler is used by default, it writes notifications to stderr
* (severity <= WARN) or stdout (severity > WARN).
* Notifications can be redirected to other sinks such as GUI widgets or
* windows debugger (WinDebugNotifyHandler) with custom handlers.
* Use setNotifyHandler to set custom handler.
* Note that osg notification API is not thread safe although notification
* handler is called from many threads. When incorporating handlers into GUI
* widgets you must take care of thread safety on your own.
* @see setNotifyHandler
*/
class OSG_EXPORT NotifyHandler : public osg::Referenced
{
public:
virtual void notify(osg::NotifySeverity severity, const char *message) = 0;
};
/** Set notification handler, by default StandardNotifyHandler is used.
* @see NotifyHandler
*/
extern OSG_EXPORT void setNotifyHandler(NotifyHandler *handler);
/** Get currrent notification handler. */
extern OSG_EXPORT NotifyHandler *getNotifyHandler();
/** Redirects notification stream to stderr (severity <= WARN) or stdout (severity > WARN).
* The fputs() function is used to write messages to standard files. Note that
* std::out and std::cerr streams are not used.
* @see setNotifyHandler
*/
class OSG_EXPORT StandardNotifyHandler : public NotifyHandler
{
public:
void notify(osg::NotifySeverity severity, const char *message);
};
#if defined(WIN32) && !defined(__CYGWIN__)
/** Redirects notification stream to windows debugger with use of
* OuputDebugString functions.
* @see setNotifyHandler
*/
class OSG_EXPORT WinDebugNotifyHandler : public NotifyHandler
{
public:
void notify(osg::NotifySeverity severity, const char *message);
};
#endif
}
#endif

4
include/osg/Version
View File

@@ -21,8 +21,8 @@ extern "C" {
#define OPENSCENEGRAPH_MAJOR_VERSION 2
#define OPENSCENEGRAPH_MINOR_VERSION 8
#define OPENSCENEGRAPH_PATCH_VERSION 4
#define OPENSCENEGRAPH_SOVERSION 65
#define OPENSCENEGRAPH_PATCH_VERSION 5
#define OPENSCENEGRAPH_SOVERSION 74
/** convinience macro that can be used to decide whether a feature is present or not i.e.
* #if OSG_MIN_VERSION_REQUIRED(2,9,5)

1
src/osg/Config.in
View File

@@ -23,6 +23,7 @@
#ifndef OSG_CONFIG
#define OSG_CONFIG 1
#cmakedefine OSG_NOTIFY_DISABLED
#cmakedefine OSG_USE_FLOAT_MATRIX
#cmakedefine OSG_USE_FLOAT_PLANE
#cmakedefine OSG_USE_FLOAT_BOUNDINGSPHERE

205
src/osg/Notify.cpp
View File

@@ -11,34 +11,148 @@
* OpenSceneGraph Public License for more details.
*/
#include <osg/Notify>
#include <osg/ApplicationUsage>
#include <osg/ref_ptr>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <sstream>
#include <iostream>
#include <fstream>
using namespace std;
#include <ctype.h>
osg::NotifySeverity g_NotifyLevel = osg::NOTICE;
namespace osg
{
class NullStreamBuffer : public std::streambuf
{
private:
std::streamsize xsputn(const std::streambuf::char_type *str, std::streamsize n)
{
return n;
}
};
struct NullStream : public std::ostream
{
public:
NullStream():
std::ostream(new NullStreamBuffer)
{ _buffer = dynamic_cast<NullStreamBuffer *>(rdbuf()); }
~NullStream()
{
rdbuf(0);
delete _buffer;
}
protected:
NullStreamBuffer* _buffer;
};
/** Stream buffer calling notify handler when buffer is synchronized (usually on std::endl).
* Stream stores last notification severity to pass it to handler call.
*/
struct NotifyStreamBuffer : public std::stringbuf
{
NotifyStreamBuffer() : _severity(osg::NOTICE)
{
}
void setNotifyHandler(osg::NotifyHandler *handler) { _handler = handler; }
osg::NotifyHandler *getNotifyHandler() const { return _handler.get(); }
/** Sets severity for next call of notify handler */
void setCurrentSeverity(osg::NotifySeverity severity) { _severity = severity; }
osg::NotifySeverity getCurrentSeverity() const { return _severity; }
private:
int sync()
{
sputc(0); // string termination
if (_handler.valid())
_handler->notify(_severity, pbase());
pubseekpos(0, std::ios_base::out); // or str(std::string())
return 0;
}
osg::ref_ptr<osg::NotifyHandler> _handler;
osg::NotifySeverity _severity;
};
struct NotifyStream : public std::ostream
{
public:
NotifyStream():
std::ostream(new NotifyStreamBuffer)
{ _buffer = dynamic_cast<NotifyStreamBuffer *>(rdbuf()); }
void setCurrentSeverity(osg::NotifySeverity severity)
{
_buffer->setCurrentSeverity(severity);
}
osg::NotifySeverity getCurrentSeverity() const
{
return _buffer->getCurrentSeverity();
}
~NotifyStream()
{
rdbuf(0);
delete _buffer;
}
protected:
NotifyStreamBuffer* _buffer;
};
}
using namespace osg;
static osg::ApplicationUsageProxy Notify_e0(osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE, "OSG_NOTIFY_LEVEL <mode>", "FATAL | WARN | NOTICE | DEBUG_INFO | DEBUG_FP | DEBUG | INFO | ALWAYS");
static bool s_NeedNotifyInit = true;
static osg::NotifySeverity g_NotifyLevel = osg::NOTICE;
static osg::NullStream *g_NullStream;
static osg::NotifyStream *g_NotifyStream;
void osg::setNotifyLevel(osg::NotifySeverity severity)
{
osg::initNotifyLevel();
if (s_NeedNotifyInit) osg::initNotifyLevel();
g_NotifyLevel = severity;
}
osg::NotifySeverity osg::getNotifyLevel()
{
osg::initNotifyLevel();
if (s_NeedNotifyInit) osg::initNotifyLevel();
return g_NotifyLevel;
}
void osg::setNotifyHandler(osg::NotifyHandler *handler)
{
osg::NotifyStreamBuffer *buffer = static_cast<osg::NotifyStreamBuffer *>(g_NotifyStream->rdbuf());
if (buffer)
buffer->setNotifyHandler(handler);
}
osg::NotifyHandler* osg::getNotifyHandler()
{
if (s_NeedNotifyInit) osg::initNotifyLevel();
osg::NotifyStreamBuffer *buffer = static_cast<osg::NotifyStreamBuffer *>(g_NotifyStream->rdbuf());
return buffer ? buffer->getNotifyHandler() : 0;
}
bool osg::initNotifyLevel()
{
static bool s_NotifyInit = false;
static osg::NullStream s_NullStream;
static osg::NotifyStream s_NotifyStream;
if (s_NotifyInit) return true;
g_NullStream = &s_NullStream;
g_NotifyStream = &s_NotifyStream;
// g_NotifyLevel
// =============
@@ -72,56 +186,59 @@ bool osg::initNotifyLevel()
}
s_NotifyInit = true;
// Setup standard notify handler
osg::NotifyStreamBuffer *buffer = dynamic_cast<osg::NotifyStreamBuffer *>(g_NotifyStream->rdbuf());
if (buffer && !buffer->getNotifyHandler())
buffer->setNotifyHandler(new StandardNotifyHandler);
s_NeedNotifyInit = false;
return true;
}
#ifndef OSG_NOTIFY_DISABLED
bool osg::isNotifyEnabled( osg::NotifySeverity severity )
{
if (s_NeedNotifyInit) osg::initNotifyLevel();
return severity<=g_NotifyLevel;
}
class NullStreamBuffer : public std::streambuf
{
private:
virtual streamsize xsputn (const char_type*, streamsize n)
{
return n;
}
};
struct NullStream : public std::ostream
{
NullStream():
std::ostream(new NullStreamBuffer) {}
virtual ~NullStream()
{
delete rdbuf();
rdbuf(0);
}
};
#endif
std::ostream& osg::notify(const osg::NotifySeverity severity)
{
// set up global notify null stream for inline notify
static NullStream s_NotifyNulStream;
if (s_NeedNotifyInit) osg::initNotifyLevel();
static bool initialized = false;
if (!initialized)
if (osg::isNotifyEnabled(severity))
{
std::cerr<<""; // dummy op to force construction of cerr, before a reference is passed back to calling code.
std::cout<<""; // dummy op to force construction of cout, before a reference is passed back to calling code.
initialized = osg::initNotifyLevel();
g_NotifyStream->setCurrentSeverity(severity);
return *g_NotifyStream;
}
if (severity<=g_NotifyLevel)
{
if (severity<=osg::WARN) return std::cerr;
else return std::cout;
}
return s_NotifyNulStream;
return *g_NullStream;
}
void osg::StandardNotifyHandler::notify(osg::NotifySeverity severity, const char *message)
{
#if 1
if (severity <= osg::WARN)
fputs(message, stderr);
else
fputs(message, stdout);
#else
fputs(message, stdout);
#endif
}
#if defined(WIN32) && !defined(__CYGWIN__)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
void osg::WinDebugNotifyHandler::notify(osg::NotifySeverity severity, const char *message)
{
OutputDebugStringA(message);
}
#endif