Changeset 365

Timestamp:

05/16/15 17:40:16 (10 years ago)

Author:

epyon

Message:

• overhaul of logging: no longer stream operated no longer using STL no memory allocation shorthand macros fast file and console I/O

Location:

trunk

Files:

• . (modified) (1 prop)
• nv/core/array2d.hh (modified) (1 diff)
• nv/core/common.hh (modified) (2 diffs)
• nv/core/logger.hh (modified) (8 diffs)
• nv/core/logging.hh (modified) (3 diffs)
• nv/core/string.hh (modified) (8 diffs)
• nv/lib/assimp.hh (modified) (1 diff)
• src/core/io_event.cc (modified) (1 diff)
• src/core/library.cc (modified) (3 diffs)
• src/core/logger.cc (modified) (6 diffs)
• src/core/profiler.cc (modified) (4 diffs)
• src/core/string.cc (added)
• src/engine/particle_engine.cc (modified) (7 diffs)
• src/engine/program_manager.cc (modified) (2 diffs)
• src/fmod/fmod_audio.cc (modified) (5 diffs)
• src/formats/assimp_loader.cc (modified) (7 diffs)
• src/formats/md2_loader.cc (modified) (3 diffs)
• src/gfx/texture_font.cc (modified) (1 diff)
• src/gl/gl_context.cc (modified) (2 diffs)
• src/gl/gl_device.cc (modified) (7 diffs)
• src/gui/gui_ascii_renderer.cc (modified) (3 diffs)
• src/gui/gui_gfx_renderer.cc (modified) (5 diffs)
• src/lib/gl.cc (modified) (6 diffs)
• src/lua/lua_handle.cc (modified) (2 diffs)
• src/lua/lua_state.cc (modified) (13 diffs)
• src/sdl/sdl_audio.cc (modified) (5 diffs)
• src/sdl/sdl_window.cc (modified) (2 diffs)
• src/sdl/sdl_window_manager.cc (modified) (1 diff)

trunk/nv/core/array2d.hh

@@ -320 +320 @@
                         if ( dest_start_x + min(size_x, source.m_size.x - source_start_x) > m_size.x || dest_start_y + min(size_y, source.m_size.y - source_start_y) > m_size.y )
                         {
-                                NV_LOG( LOG_WARNING, "set_sub_array: Source area does not fit in the destination area.  Data will be truncated." );
+                                NV_LOG_WARNING( "set_sub_array: Source area does not fit in the destination area.  Data will be truncated." );
                         }
                 

trunk/nv/core/common.hh

@@ -130 +130 @@
 #include <cstdint>
 #include <cassert>
-#include <nv/core/logging.hh>
+//#include <nv/core/logging.hh>
 
 #define NV_STRINGIZE_DETAIL(x) #x
@@ -146 +146 @@
 #define NV_ASSERT(cond, msg) assert( (cond) && msg )
 #define NV_THROW(eobj, ...) { \
-        NV_LOG( nv::LOG_ERROR, __FILE__ " line " NV_STRINGIZE(__LINE__) " - exception thrown - " #eobj ); \
+        NV_LOG_ERROR( __FILE__ " line " NV_STRINGIZE(__LINE__) " - exception thrown - " #eobj ); \
         throw eobj( __VA_ARGS__ ); \
 } 

trunk/nv/core/logger.hh

@@ -16 +16 @@
 #include <nv/core/string.hh>
 #include <nv/core/logging.hh>
-#include <iosfwd>
-#include <list>
 
 namespace nv
@@ -35 +33 @@
                  * @param message message to be logged.
                  */
-                virtual void log( log_level level, const std::string& message ) = 0;
+                virtual void log( log_level level, const string_ref& message ) = 0;
                 /**
          * Optional timestamp string
                  */
-                const char* timestamp() const;
+                string_ref timestamp() const;
                 /**
          * Log level name (unpadded)
                  */
-                const char* level_name( log_level level ) const;
+                string_ref level_name( log_level level ) const;
                 /**
          * Log level name (padded)
                  */
-                const char* padded_level_name( log_level level ) const;
+                string_ref padded_level_name( log_level level ) const;
                 /**
                  * Enforcement of virtual destructor.
@@ -86 +84 @@
                  * @param message message to be logged.
                  */
-                virtual void log( log_level level, const std::string& message );
+                virtual void log( log_level level, const string_ref& message );
 
                 /** 
@@ -118 +116 @@
 
         protected:
-                /** Type for the log sink list. */
-                typedef std::list< std::pair< log_level, log_sink* > > log_sink_list;
+                struct log_sink_info
+                {
+                        log_sink* sink;
+                        uint32    level;
+                        log_sink_info() : sink( nullptr ), level(0) {}
+                };
 
                 /** Log sink list. */
-                log_sink_list m_log_sinks;
+                log_sink_info m_log_sinks[16];
         };
 
@@ -140 +142 @@
                  * Logging function.
                  */
-                virtual void log( log_level level, const std::string& message );
+                virtual void log( log_level level, const string_ref& message );
 
         private:
@@ -148 +150 @@
 
         /**
-         * General stream sink.
-         *
-         * Logs to passed stream.
-         */
-        class log_stream_sink : public log_sink
+        * General handle sink.
+        *
+        * Logs to passed handle.
+        */
+        class log_handle_sink : public log_sink
         {
         public:
@@ -161 +163 @@
                  * Flushing can be controlled by optional flush parameter.
                  *
-                 * @param stream stream to be logged to.
+                 * @param sys_handle system dependent handle to be logged to.
                  * @param flush_always if set to false, wont flush after each line.
                  */
-                log_stream_sink( std::ostream* stream, bool flush_always ) 
-                        : m_stream(stream), m_flush(flush_always) {}
-
-                /**
-                 * Logging function.
-                 */
-                virtual void log( log_level level, const std::string& message );
+                log_handle_sink( void* sys_handle, bool flush_always )
+                        : m_handle( sys_handle ), m_flush( flush_always )
+                {
+                }
+
+                /**
+                 * Logging function.
+                 */
+                virtual void log( log_level level, const string_ref& message );
 
         protected:
-                /** Stored stream. */
-                std::ostream* m_stream;
+                /** Stored handle. */
+                void* m_handle;
                 /** Controls flushing. */
                 bool m_flush;
@@ -181 +185 @@
         /**
          * File logger sink.
-         *
-         * Logs to std::out -- be sure a console window is open, or std::out redirected!
-         */
-        class log_file_sink : public log_stream_sink
-        {
-        public:
-                /**
-                 * Constructor.
-                 *
-                 * Logs to the file passed. File is closed and disposed of after ending.
-                 * File is not appended, it's overwritten. If file is not creatable,
-                 * the constructor will throw!
-                 *
-                 * @param file_name file to be logged to.
-                 * @param flush_always if set to false, wont flush after each line.
-                 * @throws runtime_error if file_name cannot be opened.
-                 */
-                log_file_sink( const std::string file_name, bool flush_always = true );
-
-                /**
-                 * Destructor.
-                 *
-                 * Flushes, closes file and disposes of the stream.
-                 */
+         */
+        class log_file_sink : public log_handle_sink
+        {
+        public:
+                /**
+                * Constructor.
+                *
+                * Logs to the file passed. File is closed and disposed of after ending.
+                * File is not appended, it's overwritten. If file is not createable,
+                * the constructor will throw!
+                *
+                * @param file_name file to be logged to.
+                * @param flush_always if set to false, wont flush after each line.
+                */
+                log_file_sink( const string_ref& file_name, bool flush_always = true );
+
+                /**
+                * Destructor.
+                *
+                * Flushes, closes file and disposes of the stream.
+                */
                 virtual ~log_file_sink();
         };

trunk/nv/core/logging.hh

@@ -15 +15 @@
 
 #include <nv/core/common.hh>
+#include <nv/core/string.hh>
 #include <nv/core/singleton.hh>
-#include <string>
 #include <sstream>
+
+#include <nv/core/profiler.hh>
+
+
 
 namespace nv
@@ -38 +42 @@
         {
         public:
+                logger_base()
+                {
+                        m_pos = m_message;
+                }
                 unsigned int get_level()
                 {
@@ -46 +54 @@
                         m_level = level;
                 }
-                virtual void log( log_level level, const std::string& message ) = 0;
+                virtual void log( log_level level, const string_ref& message ) = 0;
+                void log_append( string_ref ref )
+                {
+                        memcpy( m_pos, ref.data(), ref.size() );
+                        m_pos += ref.size();
+                }
+                void log_append( uint32 u )
+                {
+                        m_pos += uint32_to_buffer( u, m_pos );
+                }
+                void log_append( sint32 s )
+                {
+                        m_pos += sint32_to_buffer( s, m_pos );
+                }
+                void log_append( f32 f )
+                {
+                        m_pos += f32_to_buffer( f, m_pos );
+                }
+                void log( log_level level )
+                {
+                        *m_pos = '\0';
+                        log( level, string_ref( m_message, (size_t) ( m_pos - m_message ) ) );
+                        m_pos = m_message;
+                }
+                static bool can_log( log_level level )
+                {
+                        return logger_base::is_valid() && (unsigned int)reference().get_level() >= (unsigned int)level;
+                }
                 virtual ~logger_base() {}
         protected:
+                char m_message[256];
+                char* m_pos;
                 unsigned int m_level;
         };
 
+        namespace detail
+        {
+                inline void streamer( std::stringstream& )
+                {
+                        // noop;
+                }
+
+                template < typename T, typename... Args >
+                inline void streamer( std::stringstream& ss, T&& t, Args&&... args )
+                {
+                        ss << t;
+                        streamer( ss, std::forward<Args>(args)... );
+                }
+                inline void logger( log_level level, logger_base& base )
+                {
+                        base.log( level );
+                }
+
+                template < typename T, typename... Args >
+                inline void logger( log_level level, logger_base& base, T&& t, Args&&... args )
+                {
+                        base.log_append( t );
+                        logger( level, base, std::forward<Args>( args )... );
+                }
+        }
+
 } // namespace nv
 
-#define NV_LOG(level, message_stream) \
-        if ( nv::logger_base::is_valid() && \
-                (unsigned int)nv::logger_base::reference().get_level() >= (unsigned int)level ) \
+#define NV_LOG_STREAM(level, message_stream) \
+        if ( nv::logger_base::can_log(level) ) \
         {       \
                 std::stringstream ss; \
-                ss << message_stream; \
-                nv::logger_base::reference().log( level, ss.str() ); \
+                ss << message_stream;\
+                nv::logger_base::reference().log( level, string_ref( ss.str() ) ); \
         }
 
+#define NV_LOG(level, ...) \
+        if ( nv::logger_base::can_log(level) ) \
+                                                                                {       \
+                NV_PROFILE( "logging" );\
+                nv::detail::logger( level, nv::logger_base::reference(), __VA_ARGS__ ); \
+                                }
+
 #if NV_DEBUG == 1
-#define NV_DEBUG_LOG(level, message_stream) \
-        if ( nv::logger_base::is_valid() && \
-                (unsigned int)nv::logger_base::reference().get_level() >= (unsigned int)level ) \
+#define NV_DEBUG_LOG(level, ...) \
+        if ( nv::logger_base::can_log(level) ) \
         {       \
-                std::stringstream ss; \
-                ss << message_stream; \
-                nv::logger_base::reference().log( level, ss.str() ); \
+                nv::detail::logger( level, nv::logger_base::reference(), __VA_ARGS__ ); \
         }
 #else
-#define NV_DEBUG_LOG(level, message_stream)
+#define NV_DEBUG_LOG(level, ...)
 #endif
 
+#define NV_LOG_FATAL(...)    NV_LOG( nv::LOG_FATAL, __VA_ARGS__ )
+#define NV_LOG_CRITICAL(...) NV_LOG( nv::LOG_CRITICAL, __VA_ARGS__ )
+#define NV_LOG_ERROR(...)    NV_LOG( nv::LOG_ERROR, __VA_ARGS__ )
+#define NV_LOG_WARNING(...)  NV_LOG( nv::LOG_WARNING, __VA_ARGS__ )
+#define NV_LOG_NOTICE(...)   NV_LOG( nv::LOG_NOTICE, __VA_ARGS__ )
+#define NV_LOG_INFO(...)     NV_LOG( nv::LOG_INFO, __VA_ARGS__ )
+#define NV_LOG_DEBUG(...)    NV_LOG( nv::LOG_DEBUG, __VA_ARGS__ )
+#define NV_LOG_TRACE(...)    NV_LOG( nv::LOG_TRACE, __VA_ARGS__ )
+
 #endif // NV_CORE_LOGGING_HH

trunk/nv/core/string.hh

@@ -33 +33 @@
         using std::string;
 
+
+
         /**
         * Utility function for converting any value to string.
@@ -49 +51 @@
                 if ( stream.fail() )
                 {
-                        NV_THROW( runtime_error, "bad cast" );
+//                      NV_THROW( runtime_error, "bad cast" );
                 }
 
@@ -79 +81 @@
                 if ( value.fail() )
                 {
-                        NV_THROW( runtime_error, "bad cast" );
+//                      NV_THROW( runtime_error, "bad cast" );
                 }
         }
@@ -98 +100 @@
                 if ( value.fail() )
                 {
-                        NV_THROW( runtime_error, "bad cast" );
+//                      NV_THROW( runtime_error, "bad cast" );
                 }
                 return vout;
@@ -130 +132 @@
         {
                 std::ifstream input(filename);
-                if ( !input.is_open() ) NV_THROW( std::runtime_error, "File "+filename+" not found!");
+//              if ( !input.is_open() ) NV_THROW( std::runtime_error, "File "+filename+" not found!");
                 std::stringstream sstr;
                 while(input >> sstr.rdbuf());
@@ -328 +330 @@
                 }
 
-                inline NV_CONSTEXPR char front()  const { return m_data[0]; }
-                inline NV_CONSTEXPR char back()   const { return m_data[m_size - 1]; }
+                inline NV_CONSTEXPR char front()        const { return m_data[0]; }
+                inline NV_CONSTEXPR char back()         const { return m_data[m_size - 1]; }
                 inline NV_CONSTEXPR const char* data()  const { return m_data; }
 
@@ -472 +474 @@
                 // Non-literal constructors
                 template< typename U, typename std::enable_if<std::is_same<U, const char*>::value>::type* = nullptr >
+                inline string_ref( U str ) : string_base( str, std::strlen( str ) ) {}
+
+                // Non-literal constructors
+                template< typename U, typename std::enable_if<std::is_same<U, char*>::value>::type* = nullptr >
                 inline string_ref( U str ) : string_base( str, std::strlen( str ) ) {}
 
@@ -625 +631 @@
 #undef NV_STRING_REF_CAST_OPERATORS
 
+size_t sint32_to_buffer( sint32 n, char* str );
+size_t sint64_to_buffer( sint64 n, char* str );
+size_t uint32_to_buffer( uint32 n, char* str );
+size_t uint64_to_buffer( uint64 n, char* str );
+size_t f32_to_buffer( f32 n, char* str );
+size_t f64_to_buffer( f64 n, char* str );
+
 
 }

trunk/nv/lib/assimp.hh

@@ -78 +78 @@
         inline void assimp_log_callback( const char* message, char* )
         {
-                NV_LOG( LOG_DEBUG, rtrimmed( message ) );
+                NV_LOG_DEBUG( rtrimmed( message ) );
         }
 

trunk/src/core/io_event.cc

@@ -46 +46 @@
 void nv::log_event( const io_event& e )
 {
-        NV_LOG( LOG_INFO, "Event: " << get_io_event_name( e.type ) );
+        NV_LOG_INFO( "Event: ", get_io_event_name( e.type ) );
 }
 

trunk/src/core/library.cc

@@ -71 +71 @@
         return true;
     }
-    NV_LOG( LOG_NOTICE, "library : loading '" + m_name + "'..." );
+    NV_LOG_NOTICE( "library : loading '", m_name, "'..." );
 
     string name = m_name;
@@ -86 +86 @@
     if ( m_handle == NULL )
     {
-                NV_LOG( LOG_NOTICE, "library : '" + name + "' failed to open." );
+                NV_LOG_NOTICE( "library : '", name, "' failed to open." );
                 return false;
     }
-    NV_LOG( LOG_NOTICE, "library : '" + name + "' loaded." );
+    NV_LOG_NOTICE( "library : '", name, "' loaded." );
         return true;
 }
@@ -117 +117 @@
     if ( NV_LIB_CLOSE( (NV_LIB_HANDLE)m_handle ) )
     {
-        NV_LOG( LOG_ERROR, "library : can't close library '" + m_name + "'!" );
+        NV_LOG_ERROR( "library : can't close library '", m_name, "'!" );
     }
     m_handle = NULL;

trunk/src/core/logger.cc

@@ -6 +6 @@
 
 #include "nv/core/common.hh"
-#include <iostream>
-#include <utility>
-#include <algorithm>
-#include <fstream>
-#include <ctime>
+#include "nv/core/time.hh"
 #include <cstdio>
-#include "nv/core/exception.hh"
 #if NV_PLATFORM == NV_WINDOWS
 #define WIN32_LEAN_AND_MEAN
@@ -89 +84 @@
 
 // log function
-void logger::log( log_level level, const std::string& message )
-{
-        // get the iterator to the beginning of the log_sink list
-        log_sink_list::reverse_iterator it = m_log_sinks.rbegin();
-
-        // iterate
-        while ( it != m_log_sinks.rend() )
-        {
-                // if we have a log sink with high enough level...
-                if ( it->first >= level )
+void logger::log( log_level level, const string_ref& message )
+{
+        for ( auto& sink_info : m_log_sinks )
+        {
+                if ( sink_info.sink && (sink_info.level >= (uint32)level) )
                 {
                         // log and iterate
-                        it->second->log( level, message );
+                        sink_info.sink->log( level, message );
                 }
-                else 
+        }
+}
+
+// add a new sink
+void logger::add_sink( log_sink* sink, int level )
+{
+        // add a sink
+        for ( auto& sink_info : m_log_sinks )
+        {
+                if ( sink_info.sink == nullptr )
                 {
-                        // otherwise return, the list is sorted by log level
+                        sink_info.sink  = sink;
+                        sink_info.level = (uint32)level;
                         return;
                 }
-                ++it;
-        }
-}
-
-// add a new sink
-void logger::add_sink( log_sink* sink, int level )
-{
-        // add a sink
-        m_log_sinks.push_back( std::make_pair( log_level(level), sink ) );
-        // and sort the list (default sort of pairs is by first element)
-        m_log_sinks.sort();
+        }
+        NV_ASSERT( false, "ran out of log sink space!" );
 }
 
@@ -124 +115 @@
 bool logger::remove_sink( log_sink* sink )
 {
-        // get the iterator to the beginning of the log_sink list
-        log_sink_list::iterator it = m_log_sinks.begin();
-
-        // iterate
-        while ( it != m_log_sinks.end() )
-        {
-                // found?
-                if ( it->second == sink ) 
+        for ( auto& sink_info : m_log_sinks )
+        {
+                if ( sink_info.sink == sink )
                 {
-                        // erase and return true to report success
-                        m_log_sinks.erase(it);
+                        delete sink_info.sink;
+                        sink_info.sink = nullptr;
                         return true;
                 }
-                ++it;
-        }
-
+        }
         // not found, return false
         return false;
@@ -147 +131 @@
 logger::~logger()
 {
-        // while we have sinks
-        while ( !m_log_sinks.empty() )
-        {
-                // delete the last one
-                delete m_log_sinks.back().second;
-                // and pop it
-                m_log_sinks.pop_back();
+        // delete all sinks
+        for ( auto& sink_info : m_log_sinks )
+        {
+                delete sink_info.sink;
         }
 }
@@ -159 +140 @@
 
 // console logging
-void log_console_sink::log( log_level level, const std::string& message )
-{
-        if (m_color) 
-        {
-#if NV_PLATFORM == NV_WINDOWS 
-                SetConsoleTextAttribute( m_handle, FOREGROUND_INTENSITY );
-                std::cout << timestamp() << " [";
-                SetConsoleTextAttribute( m_handle, log_color[ (level) / 10 ] );
-                std::cout << NV_LOG_LEVEL_NAME_PAD(level);
-                SetConsoleTextAttribute( m_handle, FOREGROUND_INTENSITY );
-                std::cout << "] ";
-                SetConsoleTextAttribute( m_handle, FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE );
-                std::cout << message << std::endl;
-#else
-                std::cout << "\33[30;1m" << timestamp() << " [" << log_color[ (level) / 10 ] << NV_LOG_LEVEL_NAME_PAD(level) << "\33[30;1m] \33[37;1m" << message << std::endl;
-#endif
-        }
+void log_console_sink::log( log_level level, const string_ref& message )
+{
+#if NV_PLATFORM == NV_WINDOWS 
+        if ( m_color ) SetConsoleTextAttribute( m_handle, FOREGROUND_INTENSITY );
+        string_ref stamp( timestamp() );
+        WriteConsole( m_handle, stamp.data(), stamp.size(), nullptr, nullptr );
+        WriteConsole( m_handle, " [", 2, nullptr, nullptr );
+        if (m_color) SetConsoleTextAttribute( m_handle, log_color[( level ) / 10] );
+        WriteConsole( m_handle, NV_LOG_LEVEL_NAME_PAD( level ), 8, nullptr, nullptr );
+        if ( m_color ) SetConsoleTextAttribute( m_handle, FOREGROUND_INTENSITY );
+        WriteConsole( m_handle, "] ", 2, nullptr, nullptr );
+        if ( m_color ) SetConsoleTextAttribute( m_handle, FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE );
+        WriteConsole( m_handle, message.data(), message.size(), nullptr, nullptr );
+        WriteConsole( m_handle, "\n", 1, nullptr, nullptr );
+#else
+        if ( m_color ) fwrite( "\33[30;1m", 7, 1, stdout );
+        fwrite( stamp.data(), stamp.size(), 1, stdout );
+        fwrite( " [", 2, 1, stdout );
+        if ( m_color )
+        {
+                const char* lcolor = log_color[( level ) / 10];
+                fwrite( lcolor, strlen(lcolor), 1, stdout );
+        }
+        fwrite( NV_LOG_LEVEL_NAME_PAD( level ), 8, 1, stdout );
+        if ( m_color )
+                fwrite( "\33[30;1m] \33[37;1m", 16, 1, stdout );
         else
-        {
-        std::cout << timestamp() << " [" << NV_LOG_LEVEL_NAME_PAD(level) << "] " << message << std::endl;
-        }
-}
-
-// stream logging
-void log_stream_sink::log( log_level level, const std::string& message )
-{
-        // if flushing is enabled
-        if ( m_flush )
-        {
-                // write and flush using std::endl
-                *m_stream << timestamp() << " [" << NV_LOG_LEVEL_NAME(level) << "] " << message << std::endl;
-        }
-        else
-        {
-                // write and end with "\n" (no flush)
-                *m_stream << timestamp() << " [" << NV_LOG_LEVEL_NAME(level) << "] " << message << "\n";
-        }
-}
-
-// file logging
-log_file_sink::log_file_sink( const std::string file_name, bool flush_always /*= true */ )
-        : log_stream_sink( nullptr, flush_always )
-{
-        // create the stream manually
-        std::ofstream* fstream = new std::ofstream( file_name );
-
-        // check if it's open
-        if ( !fstream->is_open() )
-        {
-                // throw if not open
-                NV_THROW( runtime_error, "Could not open file \""+file_name+"\" for logging!" );
-        }
-
-        m_stream = fstream;
-}
-
-// file logger destructor
-log_file_sink::~log_file_sink()
-{
-        // close the file
-        dynamic_cast< std::ofstream* >(m_stream)->close();
-        // dispose of the stream
-        delete m_stream;
-}
+                fwrite( "] ", 2, 1, stdout );
+        fwrite( stamp.data(), stamp.size(), 1, stdout );
+        fwrite( "\n", 1, 1, stdout );
+#endif
+}
+
+// handle logging
+void log_handle_sink::log( log_level level, const string_ref& message )
+{
+        string_ref stamp( timestamp() );
+#if 0 // NV_PLATFORM == NV_WINDOWS
+        // Turns out WriteFile on Windows is unbuffered and quite slower than fwrite 
+        // due to this fact -- especially UNUSABLE with manual FlushFileBuffers
+        // If we want to get rid of C runtime, this would need a buffered I/O layer.
+        DWORD unused = 0;
+        WriteFile( m_handle, stamp.data(), stamp.size(), &unused, nullptr );
+        WriteFile( m_handle, " [", 2, &unused, nullptr );
+        WriteFile( m_handle, NV_LOG_LEVEL_NAME_PAD( level ), 8, &unused, nullptr );
+        WriteFile( m_handle, "] ", 2, &unused, nullptr );
+        WriteFile( m_handle, message.data(), message.size(), &unused, nullptr );
+        WriteFile( m_handle, "\n", 1, &unused, nullptr );
+        //if ( m_flush ) FlushFileBuffers( m_handle );
+#else
+        fwrite( stamp.data(), stamp.size(), 1, (FILE*)m_handle );
+        fwrite( " [", 2, 1, (FILE*)m_handle );
+        fwrite( NV_LOG_LEVEL_NAME_PAD( level ), 8, 1, (FILE*)m_handle );
+        fwrite( "] ", 2, 1, (FILE*)m_handle );
+        fwrite( message.data(), message.size(), 1, (FILE*)m_handle );
+        fwrite( "\n", 1, 1, (FILE*)m_handle );
+        if ( m_flush ) fflush( (FILE*)m_handle );
+#endif
+}
+
+nv::log_file_sink::log_file_sink( const string_ref& file_name, bool flush_always /*= true */ )
+        : log_handle_sink( nullptr, flush_always )
+{
+#if 0 // NV_PLATFORM == NV_WINDOWS
+        // See comments in log_handle_sink
+        HANDLE handle = CreateFile( file_name.data(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr );
+        if ( INVALID_HANDLE_VALUE == handle )
+        {
+                NV_ASSERT( false, "invalid log handle" );
+        }
+        m_handle = handle;
+#else
+        m_handle = fopen( file_name.data(), "w" );
+#endif
+}
+
+nv::log_file_sink::~log_file_sink()
+{
+#if 0 // NV_PLATFORM == NV_WINDOWS
+        // See comments in log_handle_sink
+        CloseHandle( m_handle );
+#else
+        fclose( (FILE*) m_handle );
+#endif
+}
+
 
 nv::log_console_sink::log_console_sink( bool coloring )
@@ -234 +237 @@
 }
 
-const char* nv::log_sink::timestamp() const
-{
-        std::clock_t time = std::clock();
-        unsigned int secs = (unsigned int)(time / CLOCKS_PER_SEC);
-        unsigned int mm   = (unsigned int)(time*100 / CLOCKS_PER_SEC) % 100;
+string_ref nv::log_sink::timestamp() const
+{
+        uint32 ms = get_system_ms();
+        unsigned int secs = (unsigned int)(ms / 1000);
+        unsigned int mm   = (unsigned int)( ms * 100 / 1000 ) % 100;
         unsigned int h    = (unsigned int)(secs / (60*60));
         unsigned int m    = (unsigned int)(secs / 60) % 60;
         unsigned int s    = secs % 60;
-        static char buffer[128];
-#if NV_PLATFORM == NV_WINDOWS 
-        sprintf_s( buffer, 128, "%02d:%02d:%02d.%02d", h, m, s, mm );
-#else
-        sprintf( buffer, "%02d:%02d:%02d.%02d", h, m, s, mm );
+        static char buffer[16];
+#if NV_PLATFORM == NV_WINDOWS 
+        sprintf_s( buffer, 16, "%02d:%02d:%02d.%02d", h, m, s, mm );
+#else
+        snprintf( buffer, 16, "%02d:%02d:%02d.%02d", h, m, s, mm );
 #endif
         buffer[11] = '\0';
-        return buffer;
-}
-
-const char* nv::log_sink::level_name( log_level level ) const
+        return string_ref( buffer, 10 );
+}
+
+string_ref nv::log_sink::level_name( log_level level ) const
 {
         return NV_LOG_LEVEL_NAME( level );
 }
 
-const char* nv::log_sink::padded_level_name( log_level level ) const
-{
-        return NV_LOG_LEVEL_NAME_PAD( level );
-}
+string_ref nv::log_sink::padded_level_name( log_level level ) const
+{
+        return string_ref( NV_LOG_LEVEL_NAME_PAD( level ), 8 );
+}
+

trunk/src/core/profiler.cc

@@ -8 +8 @@
 #include <ios>
 #include "nv/core/time.hh"
+#include "nv/core/logging.hh"
 
 using namespace nv;
@@ -97 +98 @@
 }
 
-
 void profiler::log_report()
 {
         m_root->stop();
-        NV_LOG( LOG_INFO, "-- PROFILER REPORT -----------------------------------------" );
-        NV_LOG( LOG_INFO, std::left << std::setw(24) << "TAG" 
+        NV_LOG_INFO( "-- PROFILER REPORT -----------------------------------------" );
+        NV_LOG_STREAM( LOG_INFO, std::left << std::setw(24) << "TAG" 
                 << std::setw(7) << "%PARNT" 
                 << std::setw(7) << "CALLS" 
@@ -108 +108 @@
                 << std::setw(10) << "AVG(ms)" );
         log_node_children( "", m_root );
-        NV_LOG( LOG_INFO, "-- PROFILER REPORT END -------------------------------------" );
+        NV_LOG_INFO( "-- PROFILER REPORT END -------------------------------------" );
         m_root->start();
 }
@@ -119 +119 @@
                 if ( c->m_calls > 0 )
                 {
-                        NV_LOG( LOG_INFO, std::left << std::setw(24) << ind + c->m_tag 
+                        NV_LOG_STREAM( LOG_INFO, std::left << std::setw(24) << ind + c->m_tag 
                                 << std::setw(7) << std::setprecision(2) << std::fixed << ( (double)c->m_total_time_us / (double)c->m_parent->m_total_time_us ) * 100.0
                                 << std::setw(7) << c->m_calls 

trunk/src/engine/particle_engine.cc

@@ -303 +303 @@
         if ( id == "" )
         {
-                NV_LOG( LOG_ERROR, "Bad table passed to particle_engine!" )
+                NV_LOG_ERROR( "Bad table passed to particle_engine!" )
         }
         // TODO : overwrite check
@@ -325 +325 @@
         else 
         {
-                NV_LOG( LOG_ERROR, "Unknown orientation type! (" << orientation << ")!" );
+                NV_LOG_ERROR( "Unknown orientation type! (", orientation, ")!" );
                 data.orientation = particle_orientation::POINT;
         }
@@ -341 +341 @@
         else 
         {
-                NV_LOG( LOG_ERROR, "Unknown particle origin! (" << origin << ")!" );
+                NV_LOG_ERROR( "Unknown particle origin! (", origin, ")!" );
                 data.origin = particle_origin::CENTER;
         }
@@ -368 +368 @@
                                 {
                                         edata.emmiter_func = nv_particle_emmiter_point;
-                                        NV_LOG( LOG_WARNING, "Unknown emmiter type in particle system! (" << sub_type << ")" );
+                                        NV_LOG_WARNING( "Unknown emmiter type in particle system! (", sub_type, ")" );
                                 }
 
@@ -417 +417 @@
                         else
                         {
-                                NV_LOG( LOG_ERROR, "Too many emmiters (" << MAX_PARTICLE_EMMITERS << " is MAX)!" );
+                                NV_LOG_ERROR( "Too many emmiters (", MAX_PARTICLE_EMMITERS, " is MAX)!" );
                         }
                 }
@@ -433 +433 @@
                                         {
                                                 data.affector_count--;
-                                                NV_LOG( LOG_WARNING, "Bad data passed to " << sub_type << " affector in particle system!" );
+                                                NV_LOG_WARNING( "Bad data passed to ", sub_type, " affector in particle system!" );
                                         }
                                 }
@@ -439 +439 @@
                                 {
                                         data.affector_count--;
-                                        NV_LOG( LOG_WARNING, "Unknown affector type in particle system! (" << sub_type << ")" );
+                                        NV_LOG_WARNING( "Unknown affector type in particle system! (", sub_type, ")" );
                                 }
                         }
                         else
                         {
-                                NV_LOG( LOG_ERROR, "Too many affectors (" << MAX_PARTICLE_AFFECTORS << " is MAX)!" );
+                                NV_LOG_ERROR( "Too many affectors (", MAX_PARTICLE_AFFECTORS, " is MAX)!" );
                         }
                 }
                 else 
                 {
-                        NV_LOG( LOG_WARNING, "Unknown element in particle system! (" << type << ")" );
+                        NV_LOG_WARNING( "Unknown element in particle system! (", type, ")" );
                 }
         }

trunk/src/engine/program_manager.cc

@@ -7 +7 @@
 #include "nv/engine/program_manager.hh"
 #include "nv/core/range.hh"
+#include "nv/core/logging.hh"
 #include "nv/lua/lua_nova.hh"
+
 
 nv::program_manager::program_manager( context* a_context ) : m_context( a_context )
@@ -17 +19 @@
 nv::resource_id nv::program_manager::load_resource( lua::table_guard& table )
 {
-        NV_LOG( LOG_DEBUG, table.get_string("id") );
+        NV_LOG_DEBUG( table.get_string("id") );
         std::string vsource;
         std::string fsource;

trunk/src/fmod/fmod_audio.cc

@@ -24 +24 @@
         if ( result != FMOD_OK )
         {
-                NV_LOG( LOG_CRITICAL, "Failed to create FMOD System -- " << FMOD_ErrorString( result ) );
+                NV_LOG_CRITICAL( "Failed to create FMOD System -- ", FMOD_ErrorString( result ) );
                 return;
         }
@@ -30 +30 @@
         if ( result != FMOD_OK )
         {
-                NV_LOG( LOG_ERROR, "Failed to initialize FMOD System -- " << FMOD_ErrorString( result ) );
+                NV_LOG_ERROR( "Failed to initialize FMOD System -- ", FMOD_ErrorString( result ) );
                 return;
         }
@@ -47 +47 @@
                 if ( result != FMOD_OK )
                 {
-                        NV_LOG( LOG_WARNING, "FMOD failed to play sound -- " << FMOD_ErrorString( result ) );
+                        NV_LOG_WARNING( "FMOD failed to play sound -- ", FMOD_ErrorString( result ) );
                 }
                 else
@@ -70 +70 @@
                 if ( result != FMOD_OK )
                 {
-                        NV_LOG( LOG_WARNING, "FMOD failed to play sound -- " << FMOD_ErrorString( result ) );
+                        NV_LOG_WARNING( "FMOD failed to play sound -- ", FMOD_ErrorString( result ) );
                 }
                 else
@@ -95 +95 @@
         if ( fm_result != FMOD_OK )
         {
-                NV_LOG( LOG_ERROR, "FMOD failed to load sample '" << a_path << "' -- " << FMOD_ErrorString( fm_result ) );
+                NV_LOG_ERROR( "FMOD failed to load sample '", a_path, "' -- ", FMOD_ErrorString( fm_result ) );
                 return sound();
         }

trunk/src/formats/assimp_loader.cc

@@ -89 +89 @@
         m_scene = nullptr;
         m_mesh_count = 0;
-        NV_LOG( nv::LOG_NOTICE, "AssImp loading file..." );
+        NV_LOG_NOTICE( "AssImp loading file..." );
         size_t size = source.size();
         char* data  = new char[ size ];
@@ -97 +97 @@
         if( !scene)
         {
-                NV_LOG( nv::LOG_ERROR, aiGetErrorString() );
+                NV_LOG_ERROR( aiGetErrorString() );
                 return false;
         }
         m_scene      = scene;
         m_mesh_count = scene->mNumMeshes;
-        NV_LOG( nv::LOG_NOTICE, "Loading successfull" );
+        NV_LOG_NOTICE( "Loading successfull" );
         return true;
 }
@@ -213 +213 @@
         if ( scene == nullptr ) return;
 
-        NV_LOG( nv::LOG_NOTICE, "------------------------" );
-        NV_LOG( nv::LOG_NOTICE, "Texture   count - " << scene->mNumTextures );
-        NV_LOG( nv::LOG_NOTICE, "Animation count - " << scene->mNumAnimations );
-        NV_LOG( nv::LOG_NOTICE, "Material  count - " << scene->mNumMaterials );
-        NV_LOG( nv::LOG_NOTICE, "Meshes    count - " << scene->mNumMeshes );
-        NV_LOG( nv::LOG_NOTICE, "------------------------" );
+        NV_LOG_NOTICE( "------------------------" );
+        NV_LOG_NOTICE( "Texture   count - ", scene->mNumTextures );
+        NV_LOG_NOTICE( "Animation count - ", scene->mNumAnimations );
+        NV_LOG_NOTICE( "Material  count - ", scene->mNumMaterials );
+        NV_LOG_NOTICE( "Meshes    count - ", scene->mNumMeshes );
+        NV_LOG_NOTICE( "------------------------" );
 
         aiNode* root = scene->mRootNode;
         if (root)
         {
-                NV_LOG( nv::LOG_NOTICE, "Root node  - " << root->mName.data );
-                NV_LOG( nv::LOG_NOTICE, "  meshes   - " << root->mNumMeshes );
-                NV_LOG( nv::LOG_NOTICE, "  children - " << root->mNumChildren );
+                NV_LOG_NOTICE( "Root node  - ", root->mName.data );
+                NV_LOG_NOTICE( "  meshes   - ", root->mNumMeshes );
+                NV_LOG_NOTICE( "  children - ", root->mNumChildren );
         }
         else
         {
-                NV_LOG( nv::LOG_NOTICE, "No root node!" );
-        }
-        NV_LOG( nv::LOG_NOTICE, "------------------------" );
+                NV_LOG_NOTICE( "No root node!" );
+        }
+        NV_LOG_NOTICE( "------------------------" );
 
         if ( scene->mNumMeshes > 0 )
@@ -239 +239 @@
                         aiMesh* mesh = scene->mMeshes[mc];
 
-                        NV_LOG( nv::LOG_NOTICE, "Mesh #"<<mc<<"   - " << std::string( mesh->mName.data ) );
-                        NV_LOG( nv::LOG_NOTICE, "  bones   - " << mesh->mNumBones );
-                        NV_LOG( nv::LOG_NOTICE, "  uvs     - " << mesh->mNumUVComponents[0] );
-                        NV_LOG( nv::LOG_NOTICE, "  verts   - " << mesh->mNumVertices );
-                        NV_LOG( nv::LOG_NOTICE, "  faces   - " << mesh->mNumFaces );
-
-                        //                      NV_LOG( nv::LOG_NOTICE, "Bones:" );
+                        NV_LOG_NOTICE( "Mesh #", mc, "   - ", std::string( mesh->mName.data ) );
+                        NV_LOG_NOTICE( "  bones   - ", mesh->mNumBones );
+                        NV_LOG_NOTICE( "  uvs     - ", mesh->mNumUVComponents[0] );
+                        NV_LOG_NOTICE( "  verts   - ", mesh->mNumVertices );
+                        NV_LOG_NOTICE( "  faces   - ", mesh->mNumFaces );
+
+                        //                      NV_LOG_NOTICE(  "Bones:" );
                         //                      for (unsigned int m=0; m<mesh->mNumBones; m++)
                         //                      {
                         //                              aiBone* bone  = mesh->mBones[m];
-                        //                              NV_LOG( nv::LOG_DEBUG, bone->mName.C_Str() );
+                        //                              NV_LOG_NOTICE( bone->mName.C_Str() );
                         //                      }
                 }
@@ -255 +255 @@
         else
         {
-                NV_LOG( nv::LOG_NOTICE, "No meshes!" );
-        }
-        NV_LOG( nv::LOG_NOTICE, "------------------------" );
+                NV_LOG_NOTICE( "No meshes!" );
+        }
+        NV_LOG_NOTICE( "------------------------" );
 
 
@@ -270 +270 @@
         //                      {
         //                              texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path);
-        //                              NV_LOG( nv::LOG_NOTICE, "  material - " << path.data );
+        //                              NV_LOG_NOTICE( "  material - ", path.data );
         //                              texIndex++;
         //                      }
@@ -277 +277 @@
         //      else
         //      {
-        //              NV_LOG( nv::LOG_NOTICE, "No materials" );
+        //              NV_LOG_NOTICE( "No materials" );
         //      }
-        //      NV_LOG( nv::LOG_NOTICE, "------------------------" );
+        //      NV_LOG_NOTICE( "------------------------" );
 
 }

trunk/src/formats/md2_loader.cc

@@ -155 +155 @@
         }
 
-        NV_LOG( LOG_INFO, "num_skins    = " << md2->header.num_skins );
-        NV_LOG( LOG_INFO, "num_vertices = " << md2->header.num_vertices );
-        NV_LOG( LOG_INFO, "num_st       = " << md2->header.num_st );
-        NV_LOG( LOG_INFO, "num_tris     = " << md2->header.num_tris );
-        NV_LOG( LOG_INFO, "num_frames   = " << md2->header.num_frames );
+        NV_LOG_INFO( "num_skins    = ", md2->header.num_skins );
+        NV_LOG_INFO( "num_vertices = ", md2->header.num_vertices );
+        NV_LOG_INFO( "num_st       = ", md2->header.num_st );
+        NV_LOG_INFO( "num_tris     = ", md2->header.num_tris );
+        NV_LOG_INFO( "num_frames   = ", md2->header.num_frames );
 
 
@@ -295 +295 @@
         }
 
-        NV_LOG( LOG_INFO, "New vertex count = " << m_new_vindexes.size() );
-        NV_LOG( LOG_INFO, "Collisions       = " << stats_collision );
-        NV_LOG( LOG_INFO, "Reuse count      = " << stats_reuse );
+        NV_LOG_INFO( "New vertex count = ", m_new_vindexes.size() );
+        NV_LOG_INFO( "Collisions       = ", stats_collision );
+        NV_LOG_INFO( "Reuse count      = ", stats_reuse );
 }
 
@@ -335 +335 @@
         {
                 const md2_frame_t& cframe = md2->frames[current_frame];
-                NV_LOG( LOG_INFO, "FrameID = " << cframe.name );
+                NV_LOG_INFO( "FrameID = ", cframe.name );
 
                 vec3 scale     = md2_vec3( cframe.scale );

trunk/src/gfx/texture_font.cc

@@ -9 +9 @@
 #include <stdexcept>
 #include "nv/lib/freetype2.hh"
+#include "nv/core/logging.hh"
 
 using namespace nv;

trunk/src/gl/gl_context.cc

@@ -8 +8 @@
 #include "nv/lib/gl.hh"
 #include "nv/gl/gl_device.hh"
+#include "nv/core/logger.hh"
 
 using namespace nv;
@@ -168 +169 @@
                 switch ( result )
                 {
-                case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT         : NV_LOG( LOG_ERROR, "gl_context::check : Framebuffer incomplete attachment!" ); break;
-                case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT : NV_LOG( LOG_ERROR, "gl_context::check : Framebuffer missing attachment!" ); break;
-                case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS         : NV_LOG( LOG_ERROR, "gl_context::check : Framebuffer incomplete dimensions!" ); break;
-                case GL_FRAMEBUFFER_INCOMPLETE_FORMATS            : NV_LOG( LOG_ERROR, "gl_context::check : Framebuffer incomplete formats!" ); break;
-                case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER        : NV_LOG( LOG_ERROR, "gl_context::check : Framebuffer incomplete draw buffer!" ); break;
-                case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER        : NV_LOG( LOG_ERROR, "gl_context::check : Framebuffer incomplete read buffer!" ); break;
-                case GL_FRAMEBUFFER_UNSUPPORTED                   : NV_LOG( LOG_ERROR, "gl_context::check : Framebuffer format combination unsupported!" ); break;
-                default : NV_LOG( LOG_ERROR, "gl_context::check : Unknown Framebuffer error! (" << result << ")" ); break;
+                case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT         : NV_LOG_ERROR( "gl_context::check : Framebuffer incomplete attachment!" ); break;
+                case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT : NV_LOG_ERROR( "gl_context::check : Framebuffer missing attachment!" ); break;
+                case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS         : NV_LOG_ERROR( "gl_context::check : Framebuffer incomplete dimensions!" ); break;
+                case GL_FRAMEBUFFER_INCOMPLETE_FORMATS            : NV_LOG_ERROR( "gl_context::check : Framebuffer incomplete formats!" ); break;
+                case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER        : NV_LOG_ERROR( "gl_context::check : Framebuffer incomplete draw buffer!" ); break;
+                case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER        : NV_LOG_ERROR( "gl_context::check : Framebuffer incomplete read buffer!" ); break;
+                case GL_FRAMEBUFFER_UNSUPPORTED                   : NV_LOG_ERROR( "gl_context::check : Framebuffer format combination unsupported!" ); break;
+                default: NV_LOG_ERROR( "gl_context::check : Unknown Framebuffer error! (", result, ")" ); break;
                 }
         }
         else
         {
-                NV_LOG( LOG_ERROR, "gl_context::check : Framebuffer extensions not loaded!" );
+                NV_LOG_ERROR( "gl_context::check : Framebuffer extensions not loaded!" );
         }
         return false;

trunk/src/gl/gl_device.cc

@@ -41 +41 @@
         if (!image)
         {
-                NV_LOG( LOG_ERROR, "Image file " << filename << " not found!" );
+                NV_LOG_ERROR( "Image file ", filename, " not found!" );
                 return nullptr;
         }
@@ -59 +59 @@
         if ( !image )
         {
-                NV_LOG( LOG_ERROR, "Image binary data cannot be loaded found!" );
+                NV_LOG_ERROR( "Image binary data cannot be loaded found!" );
                 return nullptr;
         }
@@ -228 +228 @@
                 if ( fatal )
                 {
-                        NV_LOG( LOG_ERROR, "Uniform '" << name << "' not found in program!" );
+                        NV_LOG_ERROR( "Uniform '", name, "' not found in program!" );
                         NV_THROW( runtime_error, ( "Uniform '"+name+"' not found!" ) );
                 }
@@ -247 +247 @@
                 if ( fatal )
                 {
-                        NV_LOG( LOG_ERROR, "Attribute '" << name << "' not found in program!" );
-                        NV_THROW( runtime_error, ( "Attribute '"+name+"' not found!" ) );
+                        NV_LOG_ERROR( "Attribute '", name, "' not found in program!" );
+                        NV_THROW( runtime_error, ( "Attribute '"+ name + "' not found!" ) );
                 }
         }
@@ -279 +279 @@
         glGetProgramInfoLog( p->glid, buffer_size, &length, buffer );
 
-        NV_LOG( LOG_INFO, "Program #" << p->glid << (status == GL_FALSE ? " failed to compile!" : " compiled successfully.") );
+        NV_LOG_INFO( "Program #", p->glid, (status == GL_FALSE ? " failed to compile!" : " compiled successfully.") );
 
         if ( length > 0 )
         {
-                NV_LOG( LOG_INFO, "Program #" << p->glid << " log: " << buffer );
+                NV_LOG_INFO( "Program #", p->glid, " log: ", buffer );
         }
 
@@ -297 +297 @@
         {
                 glGetProgramInfoLog( p->glid, buffer_size, &length, buffer );
-                NV_LOG( LOG_ERROR, "Program #" << p->glid << " validation error : " << buffer );
+                NV_LOG_ERROR( "Program #", p->glid, " validation error : ", buffer );
                 return false;
         }
@@ -418 +418 @@
                 if ( compile_ok == 0 )
                 {
-                        NV_LOG( LOG_ERROR, "Shader #" << glid << " error: " << buffer );
+                        NV_LOG_ERROR( "Shader #", glid, " error: ", buffer );
                 }
                 else
                 {
-                        NV_LOG( LOG_INFO, "Shader #" << glid << " compiled successfully: " << buffer );
+                        NV_LOG_INFO( "Shader #", glid, " compiled successfully: ", buffer );
                 }
         }
         else
         {
-                NV_LOG( LOG_INFO, "Shader #" << glid << " compiled successfully." );
+                NV_LOG_INFO( "Shader #", glid, " compiled successfully." );
         }
         return compile_ok != 0;

trunk/src/gui/gui_ascii_renderer.cc

@@ -6 +6 @@
 
 #include "nv/gui/gui_ascii_renderer.hh"
+
+#include "nv/core/logging.hh"
 
 using namespace nv;
@@ -115 +117 @@
         // TODO: FIX
         int fix_me;
-        NV_LOG( nv::LOG_DEBUG, "on_hover_change" );
+        NV_LOG_DEBUG( "on_hover_change" );
         e->m_flags[DIRTY] = true;
 }
@@ -123 +125 @@
         // TODO: FIX
         int fix_me;
-        NV_LOG( nv::LOG_DEBUG, "on_select_change" );
+        NV_LOG_DEBUG( "on_select_change" );
         e->m_flags[DIRTY] = true;
 }

trunk/src/gui/gui_gfx_renderer.cc

@@ -143 +143 @@
         , m_reupload( true )
 {
-        NV_LOG( LOG_TRACE, "Creating GUI renderer..." );
+        NV_LOG_TRACE( "Creating GUI renderer..." );
         m_context = w->get_context();
         m_area.dim( dimension( w->get_width(), w->get_height() ) );
@@ -154 +154 @@
         delete[] wfill;
 
-        NV_LOG( LOG_TRACE, "Creating render data..." );
+        NV_LOG_TRACE( "Creating render data..." );
         screen_render_data* sr = new screen_render_data( w->get_context(), 1024 );
         m_render_data = sr;
@@ -174 +174 @@
         m_render_state.blending.src_alpha_factor = blending::SRC_ALPHA;
         m_render_state.blending.dst_alpha_factor = blending::ONE_MINUS_SRC_ALPHA;
-        NV_LOG( LOG_TRACE, "GUI Renderer created" );
+        NV_LOG_TRACE( "GUI Renderer created" );
 }
 
@@ -347 +347 @@
         // TODO: FIX
         int fix_me;
-        NV_LOG( nv::LOG_DEBUG, "on_hover_change" );
+        NV_LOG_DEBUG( "on_hover_change" );
         e->m_flags[DIRTY] = true;
 }
@@ -355 +355 @@
         // TODO: FIX
         int fix_me;
-        NV_LOG( nv::LOG_DEBUG, "on_select_change" );
+        NV_LOG_DEBUG( "on_select_change" );
         e->m_flags[DIRTY] = true;
 }

trunk/src/lib/gl.cc

@@ -7 +7 @@
 #include "nv/core/common.hh"
 #include "nv/core/range.hh"
+#include "nv/core/logging.hh"
 #include "nv/lib/gl.hh"
 
@@ -58 +59 @@
 {
         void* result = gl_ext_loader( name );
-        NV_LOG( ( result ? nv::LOG_DEBUG : fail_level ), "load_gl_ext_symbol : " << name << ( result ? " succeded." : "failed." ) );
+        NV_LOG( ( result ? nv::LOG_DEBUG : fail_level ), "load_gl_ext_symbol : ", name, ( result ? " succeded." : "failed." ) );
         return result;
 }
@@ -237 +238 @@
         if ( !gl_library.is_open() ) 
         {
-                NV_LOG( nv::LOG_ERROR, "load_gl_extension used, while gl_library was closed!" );
+                NV_LOG_ERROR( "load_gl_extension used, while gl_library was closed!" );
                 return false;
         }
@@ -243 +244 @@
         if ( gl_ext_loader == nullptr )
         {
-                NV_LOG( nv::LOG_ERROR, "load_gl_extension used, while gl_ext_loader was undefined!" );
+                NV_LOG_ERROR( "load_gl_extension used, while gl_ext_loader was undefined!" );
                 return false;
         }
-        NV_LOG( nv::LOG_DEBUG, "load_gl_extension - loading extension - \"" << name << "\"..." );
+        NV_LOG_DEBUG( "load_gl_extension - loading extension - \"", name, "\"..." );
 
         uint32 count      = 0; 
@@ -264 +265 @@
         } break;
         default : {
-                NV_LOG( nv::LOG_ERROR, "load_gl_extension - unknown extension \"" << name << "\"!" );
+                NV_LOG_ERROR( "load_gl_extension - unknown extension \"", name, "\"!" );
                 return nullptr;
         }
@@ -272 +273 @@
         if ( fail_count == 0 )
         {
-                NV_LOG( nv::LOG_NOTICE, "load_gl_extension - extension \"" << name << "\" loaded (" << count << " symbols)" );
+                NV_LOG_NOTICE( "load_gl_extension - extension \"", name, "\" loaded (", count, " symbols)" );
                 gl_loaded_extensions = (gl_extensions)( gl_loaded_extensions | (unsigned)extension );
                 return false;
         }
-        NV_LOG( nv::LOG_NOTICE, "load_gl_extension - failed to load extension \"" << name << "\" (" << count << "/" << fail_count << " symbols loaded)" );
+        NV_LOG_NOTICE( "load_gl_extension - failed to load extension \"", name, "\" (", count, "/", fail_count, " symbols loaded)" );
         return true;
 }

trunk/src/lua/lua_handle.cc

@@ -7 +7 @@
 #include "nv/lua/lua_handle.hh"
 
+#include "nv/core/logging.hh"
 #include "nv/lua/lua_state.hh"
 #include "nv/lua/lua_raw.hh"
@@ -18 +19 @@
         if ( !lua_istable( L, -1 ) )
         {
-                NV_LOG( nv::LOG_ERROR, "NIL" );
+                NV_LOG_ERROR( "NIL" );
                 lua_pop( L, 2 );
                 lua_pushnil( L );

trunk/src/lua/lua_state.cc

@@ -111 +111 @@
         if ( !p.resolve( m_state, global ) )
         {
-                NV_LOG( LOG_ERROR, "Lua error : not a valid path - " + p.to_string() );
+                NV_LOG_ERROR( "Lua error : not a valid path - ", p.to_string() );
                 return false;
         }
@@ -118 +118 @@
         {
                 lua_pop( m_state, 1 );
-                NV_LOG( LOG_ERROR, "Lua error : not a valid function - " + p.to_string() );
+                NV_LOG_ERROR( "Lua error : not a valid function - ", p.to_string() );
                 return false;
         }
@@ -129 +129 @@
         if ( status != 0 )
         {
-                NV_LOG( LOG_ERROR, "Lua error : " << lua_tostring( m_state, -1 ) );
+                NV_LOG_ERROR( "Lua error : ", lua_tostring( m_state, -1 ) );
                 lua_pop( m_state, 1 );
         }
@@ -144 +144 @@
         if ( !p.resolve( m_state, global ) || lua_type(m_state, -1) != LUA_TTABLE )
         {
-                NV_LOG( LOG_ERROR, "Could not resolve table!" );
+                NV_LOG_ERROR( "Could not resolve table!" );
                 // TODO : error handling
         }
@@ -156 +156 @@
         if ( !p.resolve( m_state, false ) || lua_type(m_state, -1) != LUA_TTABLE )
         {
-                NV_LOG( LOG_ERROR, "Could not resolve table!" );
+                NV_LOG_ERROR( "Could not resolve table!" );
                 // TODO : error handling
         }
@@ -347 +347 @@
         }
 
-        NV_LOG( nv::LOG_TRACE, "Lua state created" );
+        NV_LOG_TRACE( "Lua state created" );
 }
 
 int lua::state::load_string( string_ref code, string_ref name )
 {
-        NV_LOG( nv::LOG_TRACE, "Loading Lua string '" << name << "'");
+        NV_LOG_TRACE( "Loading Lua string '", name, "'");
         return luaL_loadbuffer( m_state, code.data(), code.length(), name.data() );
 }
@@ -358 +358 @@
 int lua::state::load_stream( std::istream& stream, string_ref name )
 {
-        NV_LOG( nv::LOG_NOTICE, "Loading Lua stream '" << name << "'");
+        NV_LOG_NOTICE( "Loading Lua stream '", name, "'");
         return load_string( std::string(
                 (std::istreambuf_iterator<char>(stream)),
@@ -366 +366 @@
 int lua::state::load_file( string_ref filename )
 {
-        NV_LOG( nv::LOG_NOTICE, "Loading Lua file '" << filename << "'");
+        NV_LOG_NOTICE( "Loading Lua file '", filename, "'");
         return luaL_loadfile( m_state, filename.data() );
 }
@@ -376 +376 @@
         if (result)
         {
-                NV_LOG( nv::LOG_WARNING, "Failed to load string " << name << ": " << lua_tostring(m_state, -1));
+                NV_LOG_WARNING( "Failed to load string ", name, ": ", lua_tostring(m_state, -1));
                 return false;
         }
@@ -388 +388 @@
         if (result)
         {
-                NV_LOG( nv::LOG_WARNING, "Failed to open stream " << name << ": " << lua_tostring(m_state, -1));
+                NV_LOG_WARNING( "Failed to open stream ", name, ": ", lua_tostring( m_state, -1 ) );
                 return false;
         }
@@ -400 +400 @@
         if (result) 
         {
-                NV_LOG( nv::LOG_WARNING, "Failed to open file " << filename << ": " << lua_tostring(m_state, -1));
+                NV_LOG_WARNING( "Failed to open file ", filename, ": ", lua_tostring( m_state, -1 ) );
                 return false;
         }
@@ -411 +411 @@
         if (result) 
         {
-                NV_LOG( nv::LOG_WARNING, "Failed to run script " << name << ": " << lua_tostring(m_state, -1));
+                NV_LOG_WARNING( "Failed to run script ", name, ": ", lua_tostring( m_state, -1 ) );
                 lua_pop( m_state, 1 );
         }
@@ -425 +425 @@
 {
         int top = lua_gettop(m_state);
-        NV_LOG( LOG_DEBUG, "Stack dump (" << top << ")");
+        NV_LOG_DEBUG( "Stack dump (", top, ")");
         for ( int i = 0; i < top; ++i )
         {
-                NV_LOG( LOG_DEBUG, "#" << i+1 << " - " << lua_typename(m_state, lua_type(m_state, i+1) ) << " = " << nlua_typecontent(m_state, i+1) );
+                NV_LOG_DEBUG( "#", i+1, " - ", lua_typename(m_state, lua_type(m_state, i+1) ), " = ", nlua_typecontent(m_state, i+1) );
         }
 }

trunk/src/sdl/sdl_audio.cc

@@ -21 +21 @@
         if ( SDL_Init( SDL_INIT_AUDIO ) == -1 ) 
         {
-                NV_LOG( LOG_CRITICAL, "SDL_AUDIO failed to load -- " << SDL_GetError() );
+                NV_LOG_CRITICAL( "SDL_AUDIO failed to load -- ", SDL_GetError() );
                 return;
         }
@@ -27 +27 @@
         if( Mix_OpenAudio( 44100, MIX_DEFAULT_FORMAT, 2, 1024 ) == -1 )
         {
-                NV_LOG( LOG_CRITICAL, "SDL_mixer failed to load -- " << Mix_GetError() );
+                NV_LOG_CRITICAL( "SDL_mixer failed to load -- ", Mix_GetError() );
                 return;
         }
@@ -40 +40 @@
                 if ( channel == -1 )
                 {
-                        NV_LOG( LOG_WARNING, "SDL_mixer failed to play -- " << Mix_GetError() );
+                        NV_LOG_WARNING( "SDL_mixer failed to play -- ", Mix_GetError() );
                 }
                 else
@@ -67 +67 @@
                 if ( channel == -1 )
                 {
-                        NV_LOG( LOG_WARNING, "SDL_mixer failed to play -- " << Mix_GetError() );
+                        NV_LOG_WARNING( "SDL_mixer failed to play -- ", Mix_GetError() );
                 }
                 else
@@ -91 +91 @@
         if ( Mix_LoadWAV_RW == nullptr || SDL_RWFromFile == nullptr ) 
         {
-                NV_LOG( LOG_ERROR, "SDL_mixer not loaded!" );
+                NV_LOG_ERROR( "SDL_mixer not loaded!" );
         }
         Mix_Chunk *sample = Mix_LoadWAV_RW(SDL_RWFromFile(a_path.c_str(), "rb"), 1);
         if ( sample == nullptr )
         {
-                NV_LOG( LOG_ERROR, "SDL_mixer failed to load sample '" << a_path << "' -- " << Mix_GetError() );
+                NV_LOG_ERROR( "SDL_mixer failed to load sample '", a_path, "' -- ", Mix_GetError() );
                 return sound();
         }

trunk/src/sdl/sdl_window.cc

@@ -38 +38 @@
         if ( m_handle == 0 )
         {
-                NV_LOG( LOG_CRITICAL, "Video mode set failed: " << SDL_GetError( ) );
+                NV_LOG_CRITICAL( "Video mode set failed: ", SDL_GetError( ) );
                 return; // TODO: Error report
         }
@@ -56 +56 @@
         if ( ctx_handle == 0 )
         {
-                NV_LOG( LOG_CRITICAL, "GL Context creation failed: " << SDL_GetError( ) );
+                NV_LOG_CRITICAL( "GL Context creation failed: ", SDL_GetError( ) );
                 return; // TODO: Error report
         }
 
         nv::load_gl_library();
-        NV_LOG( LOG_INFO, "OpenGL Vendor       : " << glGetString(GL_VENDOR) );
-        NV_LOG( LOG_INFO, "OpenGL Renderer     : " << glGetString(GL_RENDERER) );
-        NV_LOG( LOG_INFO, "OpenGL Version      : " << glGetString(GL_VERSION) );
-        NV_LOG( LOG_INFO, "OpenGL GLSL Version : " << glGetString(GL_SHADING_LANGUAGE_VERSION) );
+        NV_LOG_INFO( "OpenGL Vendor       : ", (const char*)glGetString(GL_VENDOR) );
+        NV_LOG_INFO( "OpenGL Renderer     : ", (const char*)glGetString( GL_RENDERER ) );
+        NV_LOG_INFO( "OpenGL Version      : ", (const char*)glGetString( GL_VERSION ) );
+        NV_LOG_INFO( "OpenGL GLSL Version : ", (const char*)glGetString( GL_SHADING_LANGUAGE_VERSION ) );
         SDL_GL_SetSwapInterval(1);
 

trunk/src/sdl/sdl_window_manager.cc

@@ -19 +19 @@
         if ( SDL_Init(0) < 0 )
         {
-                NV_LOG( LOG_CRITICAL, "SDL initialization failed: " << SDL_GetError( ) );
+                NV_LOG_CRITICAL( "SDL initialization failed: ", SDL_GetError( ) );
                 return; // TODO: Error report
         }