Merge with default

--HG--
branch : gsoc2012-fabien

code/nel/include/nel/misc/time_nl.h

@@ -48,6 +48,19 @@ typedef sint64 TTicks;
 class CTime
 {
 public:
+	struct CTimerInfo
+	{
+		/// Returns if there is a high precision timer that can be used.
+		bool IsHighPrecisionAvailable;
+		/// If a CPU specific timer is used and the values are not consistent accross threads.
+		bool RequiresSingleCore;
+		/// The resolution of the high resolution timer.
+		TTicks HighPrecisionResolution;
+	};
+
+	/** Get advanced information on the used timers.
+	 */
+	static void probeTimerInfo(CTimerInfo &result);
 
 	/** Return the number of second since midnight (00:00:00), January 1, 1970,
 	 * coordinated universal time, according to the system clock.
@@ -71,7 +84,7 @@ public:
 	 * the value can jump backwards if the system time is changed by a user or a NTP time sync process.
 	 * The value is different on 2 different computers; use the CUniTime class to get a universal
 	 * time that is the same on all computers.
-	 * \warning On Win32, the value is on 32 bits only. It wraps around to 0 every about 49.71 days.
+	 * \warning On Win32, the value is on 32 bits only, and uses the low-res timer unless probeTimerInfo was called and a high resolution timer can be used. It wraps around to 0 every about 49.71 days.
 	 */
 	static TTime	getLocalTime();
 

code/nel/src/3d/driver/direct3d/driver_direct3d_texture.cpp

@@ -868,6 +868,13 @@ bool CDriverD3D::uploadTextureInternal (ITexture& tex, CRect& rect, uint8 destMi
 										D3DFORMAT destFormat, D3DFORMAT srcFormat)
 {
 	H_AUTO_D3D(CDriverD3D_uploadTextureInternal)
+
+	if (rect.Width == 0 || rect.Height == 0)
+	{
+		nlwarning("Rectangle width or height cannot be 0");
+		return false;
+	}
+
 	// The D3D texture
 	CTextureDrvInfosD3D*	d3dtext = getTextureD3D(tex);
 

code/nel/src/misc/p_thread.cpp

@@ -221,6 +221,9 @@ void CPThread::wait ()
 bool CPThread::setCPUMask(uint64 cpuMask)
 {
 #ifdef __USE_GNU
+
+	nlwarning("This code does not work. May cause a segmentation fault...");
+
 	sint res = pthread_setaffinity_np(_ThreadHandle, sizeof(uint64), (const cpu_set_t*)&cpuMask);
 
 	if (res)
@@ -228,9 +231,14 @@ bool CPThread::setCPUMask(uint64 cpuMask)
 		nlwarning("pthread_setaffinity_np() returned %d", res);
 		return false;
 	}
-#endif // __USE_GNU
 
 	return true;
+
+#else // __USE_GNU
+
+	return false;
+
+#endif // __USE_GNU
 }
 
 /*
@@ -238,9 +246,12 @@ bool CPThread::setCPUMask(uint64 cpuMask)
  */
 uint64 CPThread::getCPUMask()
 {
-	uint64 cpuMask = 1;
-
 #ifdef __USE_GNU
+
+	nlwarning("This code does not work. May cause a segmentation fault...");
+
+	uint64 cpuMask = 0;
+
 	sint res = pthread_getaffinity_np(_ThreadHandle, sizeof(uint64), (cpu_set_t*)&cpuMask);
 
 	if (res)
@@ -248,9 +259,14 @@ uint64 CPThread::getCPUMask()
 		nlwarning("pthread_getaffinity_np() returned %d", res);
 		return 0;
 	}
-#endif // __USE_GNU
 
 	return cpuMask;
+
+#else // __USE_GNU
+
+	return 0;
+
+#endif // __USE_GNU
 }
 
 void CPThread::setPriority(TThreadPriority priority)
@@ -311,9 +327,9 @@ IProcess *IProcess::getCurrentProcess ()
  */
 uint64 CPProcess::getCPUMask()
 {
-	uint64 cpuMask = 1;
-
 #ifdef __USE_GNU
+
+	uint64 cpuMask = 0;
 	sint res = sched_getaffinity(getpid(), sizeof(uint64), (cpu_set_t*)&cpuMask);
 
 	if (res)
@@ -321,15 +337,21 @@ uint64 CPProcess::getCPUMask()
 		nlwarning("sched_getaffinity() returned %d, errno = %d: %s", res, errno, strerror(errno));
 		return 0;
 	}
-#endif // __USE_GNU
 
 	return cpuMask;
+
+#else // __USE_GNU
+
+	return 0;
+
+#endif // __USE_GNU
 }
 
 /// set the CPU mask
 bool CPProcess::setCPUMask(uint64 cpuMask)
 {
 #ifdef __USE_GNU
+
 	sint res = sched_setaffinity(getpid(), sizeof(uint64), (const cpu_set_t*)&cpuMask);
 
 	if (res)
@@ -337,9 +359,14 @@ bool CPProcess::setCPUMask(uint64 cpuMask)
 		nlwarning("sched_setaffinity() returned %d, errno = %d: %s", res, errno, strerror(errno));
 		return false;
 	}
-#endif // __USE_GNU
 
 	return true;
+
+#else // __USE_GNU
+
+	return false;
+
+#endif // __USE_GNU
 }
 
 

code/nel/src/misc/time_nl.cpp

@@ -32,9 +32,262 @@
 #include "nel/misc/time_nl.h"
 #include "nel/misc/sstring.h"
 
+#include <nel/misc/thread.h>
+
 namespace NLMISC
 {
 
+namespace {
+#ifdef NL_OS_WINDOWS
+bool a_HaveQueryPerformance = false;
+LARGE_INTEGER a_QueryPerformanceFrequency;
+#endif
+#ifdef NL_OS_UNIX
+#	if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0)
+#	if defined(_POSIX_MONOTONIC_CLOCK) && (_POSIX_MONOTONIC_CLOCK >= 0)
+#		define NL_MONOTONIC_CLOCK
+#	endif
+#	endif
+#	ifdef NL_MONOTONIC_CLOCK
+bool a_CheckedMonotonicClock = false;
+bool a_HasMonotonicClock = false;
+uint64 a_MonotonicClockFrequency = 0;
+uint64 a_MonotonicClockResolutionNs = 0;
+bool hasMonotonicClock()
+{
+	if (!a_CheckedMonotonicClock)
+	{
+		/* Initialize the local time engine.
+		* On Unix, this method will find out if the Monotonic Clock is supported
+		* (seems supported by kernel 2.6, not by kernel 2.4). See getLocalTime().
+		*/
+		struct timespec tv;
+		if ((clock_gettime( CLOCK_MONOTONIC, &tv ) == 0) &&
+			 (clock_getres( CLOCK_MONOTONIC, &tv ) == 0))
+		{
+//			nldebug( "Monotonic local time supported (resolution %.6f ms)", ((float)tv.tv_sec)*1000.0f + ((float)tv.tv_nsec)/1000000.0f );
+
+			if (tv.tv_sec > 0)
+			{
+				nlwarning("Monotonic clock not ok, resolution > 1s");
+				a_HasMonotonicClock = false;
+			}
+			else
+			{
+				uint64 nsPerTick = tv.tv_nsec;
+				uint64 nsPerSec = 1000000000L;
+				uint64 tickPerSec = nsPerSec / nsPerTick;
+				a_MonotonicClockFrequency = tickPerSec;
+				a_MonotonicClockResolutionNs = nsPerTick;
+				a_HasMonotonicClock = true;
+			}
+		}
+		else
+		{
+			a_HasMonotonicClock = false;
+		}
+		a_CheckedMonotonicClock = true;
+	}
+	return a_HasMonotonicClock;
+}
+#	endif
+#endif
+}
+
+void CTime::probeTimerInfo(CTime::CTimerInfo &result)
+{
+	breakable
+	{
+#ifdef NL_OS_WINDOWS
+		LARGE_INTEGER winPerfFreq;
+		LARGE_INTEGER winPerfCount;
+		DWORD lowResTime;
+		if (!QueryPerformanceFrequency(&winPerfFreq))
+		{
+			nldebug("Cannot query performance frequency");
+			result.IsHighPrecisionAvailable = false;
+		}
+		else
+		{
+			result.HighPrecisionResolution = winPerfFreq.QuadPart;
+		}
+		if (winPerfFreq.QuadPart == 1000)
+		{
+			nldebug("Higher precision timer not available, OS defaulted to GetTickCount");
+			result.IsHighPrecisionAvailable = false;
+		}
+		if (!QueryPerformanceCounter(&winPerfCount))
+		{
+			nldebug("Cannot query performance counter");
+			result.IsHighPrecisionAvailable = false;
+			result.HighPrecisionResolution = 1000;
+		}
+		a_HaveQueryPerformance = result.IsHighPrecisionAvailable;
+		a_QueryPerformanceFrequency.QuadPart = winPerfFreq.QuadPart;
+		if (!result.IsHighPrecisionAvailable)
+		{
+			lowResTime = timeGetTime();
+		}
+#else
+
+		// Other platforms are awesome. Generic implementation for now.
+		TTime localTime = getLocalTime();
+		result.IsHighPrecisionAvailable = true;
+		result.HighPrecisionResolution = 0;
+
+#	ifdef NL_MONOTONIC_CLOCK
+		timespec monoClock;
+		if (hasMonotonicClock())
+		{
+			clock_gettime(CLOCK_MONOTONIC, &monoClock);
+			result.HighPrecisionResolution = a_MonotonicClockFrequency;
+		}
+		else
+		{
+			nldebug("Monotonic clock not available");
+		}
+#	endif
+
+#endif
+
+		uint64 cpuMask = IProcess::getCurrentProcess()->getCPUMask();
+#ifdef NL_OS_WINDOWS
+		uint64 threadMask = IThread::getCurrentThread()->getCPUMask(); // broken on linux, don't expect it to work anywhere
+#else
+		uint64 threadMask = cpuMask;
+#endif
+
+		uint identical = 0; // Identical stamps may indicate the os handling backwards glitches.
+		uint backwards = 0; // Happens when the timers are not always in sync and the implementation is faulty.
+		uint regular = 0; // How many times the number advanced normally.
+		uint skipping = 0; // Does not really mean anything necessarily.
+		uint frequencybug = 0; // Should never happen.
+		// uint badcore = 0; // Affinity does not work.
+
+		// Cycle 32 times trough all cores, and verify if the timing remains consistent.
+		for (uint i = 32; i; --i)
+		{
+			uint64 currentBit = 1;
+			for (uint j = 64; j; --j)
+			{
+				if (cpuMask & currentBit)
+				{
+#ifdef NL_OS_WINDOWS
+					if (!IThread::getCurrentThread()->setCPUMask(currentBit))
+#else
+					if (!IProcess::getCurrentProcess()->setCPUMask(currentBit))
+#endif
+						break; // Thread was set to last cpu.
+#ifdef NL_OS_WINDOWS
+					// Make sure the thread is rescheduled.
+					SwitchToThread();
+					Sleep(0);
+					// Verify the core
+					/* Can only verify on 2003, Vista and higher.
+					if (1 << GetCurrentProcessorNumber() != currentBit)
+						++badcore;
+					*/
+					// Check if the timer is still sane.
+					if (result.IsHighPrecisionAvailable)
+					{
+						LARGE_INTEGER winPerfFreqN;
+						LARGE_INTEGER winPerfCountN;
+						QueryPerformanceFrequency(&winPerfFreqN);
+						if (winPerfFreqN.QuadPart != winPerfFreq.QuadPart)
+							++frequencybug;
+						QueryPerformanceCounter(&winPerfCountN);
+						if (winPerfCountN.QuadPart == winPerfCount.QuadPart)
+							++identical;
+						if (winPerfCountN.QuadPart < winPerfCount.QuadPart || winPerfCountN.QuadPart - winPerfCount.QuadPart < 0)
+							++backwards;
+						if (winPerfCountN.QuadPart - winPerfCount.QuadPart > winPerfFreq.QuadPart / 20) // 50ms skipping check
+							++skipping;
+						else if (winPerfCountN.QuadPart > winPerfCount.QuadPart)
+							++regular;
+						winPerfCount.QuadPart = winPerfCountN.QuadPart;
+					}
+					else
+					{
+						DWORD lowResTimeN;
+						lowResTimeN = timeGetTime();
+						if (lowResTimeN == lowResTime)
+							++identical;
+						if (lowResTimeN < lowResTime || lowResTimeN - lowResTime < 0)
+							++backwards;
+						if (lowResTimeN - lowResTime > 50)
+							++skipping;
+						else if (lowResTimeN > lowResTime)
+							++regular;
+						lowResTime = lowResTimeN;
+					}
+#else
+#ifdef NL_OS_UNIX
+					sched_yield();
+#else
+					nlSleep(0);
+#endif
+#	ifdef NL_MONOTONIC_CLOCK
+					if (hasMonotonicClock())
+					{
+						timespec monoClockN;
+						clock_gettime(CLOCK_MONOTONIC, &monoClockN);
+						if (monoClock.tv_sec == monoClockN.tv_sec && monoClock.tv_nsec == monoClockN.tv_nsec)
+							++identical;
+						if (monoClockN.tv_sec < monoClock.tv_sec || (monoClock.tv_sec == monoClockN.tv_sec && monoClockN.tv_nsec < monoClock.tv_nsec))
+							++backwards;
+						if (monoClock.tv_sec == monoClockN.tv_sec && (monoClockN.tv_nsec - monoClock.tv_nsec > 50000000L))
+							++skipping;
+						else if ((monoClock.tv_sec == monoClockN.tv_sec && monoClock.tv_nsec < monoClockN.tv_nsec) || monoClock.tv_sec < monoClockN.tv_sec)
+							++regular;
+						monoClock.tv_sec = monoClockN.tv_sec;
+						monoClock.tv_nsec = monoClockN.tv_nsec;
+					}
+					else
+#	endif
+					{
+						TTime localTimeN = getLocalTime();
+						if (localTimeN == localTime)
+							++identical;
+						if (localTimeN < localTime || localTimeN - localTime < 0)
+							++backwards;
+						if (localTimeN - localTime > 50)
+							++skipping;
+						else if (localTimeN > localTime)
+							++regular;
+						localTime = localTimeN;
+					}
+#endif
+				}
+				currentBit <<= 1;
+			}
+		}
+
+#ifdef NL_OS_WINDOWS
+		IThread::getCurrentThread()->setCPUMask(threadMask);
+#else
+		IProcess::getCurrentProcess()->setCPUMask(threadMask);
+#endif
+
+		nldebug("Timer resolution: %i Hz", (int)(result.HighPrecisionResolution));
+		nldebug("Time identical: %i, backwards: %i, regular: %i, skipping: %i, frequency bug: %i", identical, backwards, regular, skipping, frequencybug);
+		if (identical > regular)
+			nlwarning("The system timer is of relatively low resolution, you may experience issues");
+		if (backwards > 0 || frequencybug > 0)
+		{
+			nlwarning("The current system timer is not reliable across multiple cpu cores");
+			result.RequiresSingleCore = true;
+		}
+		else result.RequiresSingleCore = false;
+
+		if (result.HighPrecisionResolution == 14318180)
+			nldebug("Detected known HPET era timer frequency");
+		if (result.HighPrecisionResolution == 3579545)
+			nldebug("Detected known AHCI era timer frequency");
+		if (result.HighPrecisionResolution == 1193182)
+			nldebug("Detected known i8253/i8254 era timer frequency");
+	}
+}
+
 /* Return the number of second since midnight (00:00:00), January 1, 1970,
  * coordinated universal time, according to the system clock.
  * This values is the same on all computer if computers are synchronized (with NTP for example).
@@ -97,54 +350,42 @@ TTime CTime::getLocalTime ()
 	//else
 	//{
 		// This is not affected by system time changes. But it cycles every 49 days.
-		return timeGetTime();
+		// return timeGetTime(); // Only this was left active before it was commented.
 	//}
 
-#elif defined (NL_OS_UNIX)
+	/*
-
+	 * The above is no longer relevant.
-	static bool initdone = false;
-	static bool isMonotonicClockSupported = false;
-	if ( ! initdone )
-	{
-
-#if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0)
-#if defined(_POSIX_MONOTONIC_CLOCK) && (_POSIX_MONOTONIC_CLOCK >= 0)
-
-		/* Initialize the local time engine.
-		* On Unix, this method will find out if the Monotonic Clock is supported
-		* (seems supported by kernel 2.6, not by kernel 2.4). See getLocalTime().
 	 */
-		struct timespec tv;
+
-		if ( (clock_gettime( CLOCK_MONOTONIC, &tv ) == 0) &&
+	if (a_HaveQueryPerformance)
-			 (clock_getres( CLOCK_MONOTONIC, &tv ) == 0) )
 	{
-//			nldebug( "Monotonic local time supported (resolution %.6f ms)", ((float)tv.tv_sec)*1000.0f + ((float)tv.tv_nsec)/1000000.0f );
+		// On a (fast) 15MHz timer this rolls over after 7000 days.
-			isMonotonicClockSupported = true;
+		// If my calculations are right.
+		LARGE_INTEGER counter;
+		QueryPerformanceCounter(&counter);
+		counter.QuadPart *= (LONGLONG)1000L;
+		counter.QuadPart /= a_QueryPerformanceFrequency.QuadPart;
+		return counter.QuadPart;
 	}
 	else
-
-#endif
-#endif
 	{
-//			nlwarning( "Monotonic local time not supported, caution with time sync" );
+		// Use default reliable low resolution timer.
+		return timeGetTime();
 	}
 
-		initdone = true;
+#elif defined (NL_OS_UNIX)
-	}
 
-#if defined(_POSIX_TIMERS) && (_POSIX_TIMERS > 0)
+#ifdef NL_MONOTONIC_CLOCK
-#if defined(_POSIX_MONOTONIC_CLOCK) && (_POSIX_MONOTONIC_CLOCK >= 0)
 
-	if ( isMonotonicClockSupported )
+	if (hasMonotonicClock())
 	{
-		struct timespec tv;
+		timespec tv;
 		// This is not affected by system time changes.
 		if ( clock_gettime( CLOCK_MONOTONIC, &tv ) != 0 )
 			nlerror ("Can't get clock time again");
 	    return (TTime)tv.tv_sec * (TTime)1000 + (TTime)((tv.tv_nsec/*+500*/) / 1000000);
 	}
 
-#endif
 #endif
 
 	// This is affected by system time changes.
@@ -156,7 +397,6 @@ TTime CTime::getLocalTime ()
 #endif
 }
 
-
 /* Return the time in processor ticks. Use it for profile purpose.
  * If the performance time is not supported on this hardware, it returns 0.
  * \warning On a multiprocessor system, the value returned by each processor may

code/nel/tools/misc/CMakeLists.txt

@@ -18,3 +18,5 @@ IF(WIN32)
     ADD_SUBDIRECTORY(words_dic)
   ENDIF(MFC_FOUND)
 ENDIF(WIN32)
+
+ADD_SUBDIRECTORY(probe_timers)

code/nel/tools/misc/probe_timers/CMakeLists.txt

@@ -0,0 +1,9 @@
+FILE(GLOB SRC *.cpp)
+
+ADD_EXECUTABLE(nl_probe_timers ${SRC})
+
+TARGET_LINK_LIBRARIES(nl_probe_timers nelmisc)
+NL_DEFAULT_PROPS(nl_probe_timers "NeL, Tools, Misc: Probe Timers")
+NL_ADD_RUNTIME_FLAGS(nl_probe_timers)
+
+INSTALL(TARGETS nl_probe_timers RUNTIME DESTINATION bin COMPONENT toolsmisc)

code/nel/tools/misc/probe_timers/main.cpp

@@ -0,0 +1,38 @@
+// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
+// Copyright (C) 2012  by authors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "nel/misc/types_nl.h"
+#include "nel/misc/time_nl.h"
+
+using namespace NLMISC;
+
+int main (int argc, char **argv)
+{
+	for (uint i = 0; i < 8; ++i)
+	{
+		CTime::CTimerInfo timerInfo;
+		CTime::probeTimerInfo(timerInfo);
+	}
+
+	printf ("\nPress <return> to exit\n");
+	getchar ();
+
+	return EXIT_SUCCESS;
+}

code/ryzom/client/src/init.cpp

@@ -687,6 +687,9 @@ void prelogInit()
 		_control87 (_EM_INVALID|_EM_DENORMAL/*|_EM_ZERODIVIDE|_EM_OVERFLOW*/|_EM_UNDERFLOW|_EM_INEXACT, _MCW_EM);
 #endif // NL_OS_WINDOWS
 		
+		CTime::CTimerInfo timerInfo;
+		NLMISC::CTime::probeTimerInfo(timerInfo);
+		if (timerInfo.RequiresSingleCore) // TODO: Also have a FV configuration value to force single core.
 			setCPUMask();
 
 		FPU_CHECKER_ONCE

code/ryzom/client/src/time_client.h

@@ -134,24 +134,9 @@ void updateClientTime();
 // update smoothed time (useful for sky animation)
 void updateSmoothedTime();
 
-inline TTime ryzomGetLocalTime ()
+inline NLMISC::TTime ryzomGetLocalTime()
 {
-#ifdef NL_OS_WINDOWS
+	return NLMISC::CTime::getLocalTime();
-	if (ClientCfg.TimerMode == 0)
-	{
-		return (TTime)(NLMISC::CTime::ticksToSecond (NLMISC::CTime::getPerformanceTime()) * 1000.0);
-	}
-	else // if (ClientCfg.TimerMode == 1)
-	{
-		// Use 1 ms timer precision
-		timeBeginPeriod(1);
- 		DWORD start = timeGetTime();
-		timeEndPeriod(1);
-		return (TTime)start;
-	}
-#else // NL_OS_WINDOWS
-	return (TTime)(NLMISC::CTime::ticksToSecond (NLMISC::CTime::getPerformanceTime()) * 1000.0);
-#endif // NL_OS_WINDOWS
 }
 
 inline NLMISC::TTicks ryzomGetPerformanceTime()

code/ryzom/tools/leveldesign/CMakeLists.txt

@@ -12,6 +12,9 @@ IF(WIN32)
   ADD_SUBDIRECTORY(world_editor)
   IF(WITH_MFC)
     ADD_SUBDIRECTORY(mission_compiler_fe)
+	ADD_SUBDIRECTORY(georges_dll)
+	ADD_SUBDIRECTORY(georges_exe)
+	ADD_SUBDIRECTORY(georges_plugin_sound)
   ENDIF(WITH_MFC)
 ENDIF(WIN32)
 

code/ryzom/tools/leveldesign/georges_dll/CMakeLists.txt

@@ -0,0 +1,19 @@
+
+FILE(GLOB SRC *.cpp *.h)
+
+ADD_LIBRARY(georges_dll SHARED ${SRC} georges_edit.rc)
+
+INCLUDE_DIRECTORIES(${NEL_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
+
+TARGET_LINK_LIBRARIES(georges_dll nelmisc nelgeorges)
+NL_DEFAULT_PROPS(georges_dll "Ryzom, Tools, Georges: Georges Dll")
+NL_ADD_RUNTIME_FLAGS(georges_dll)
+NL_ADD_LIB_SUFFIX(georges_dll)
+
+ADD_DEFINITIONS(${MFC_DEFINITIONS} -DGEORGES_EXPORT)
+
+IF(WITH_PCH)
+  ADD_NATIVE_PRECOMPILED_HEADER(georges_dll ${CMAKE_CURRENT_SOURCE_DIR}/stdafx.h ${CMAKE_CURRENT_SOURCE_DIR}/stdafx.cpp)
+ENDIF(WITH_PCH)
+
+INSTALL(TARGETS georges_dll LIBRARY DESTINATION lib RUNTIME DESTINATION bin ARCHIVE DESTINATION lib COMPONENT libraries)

code/ryzom/tools/leveldesign/georges_dll/output_console_dlg.h

@@ -37,7 +37,7 @@ public:
 
 	// From CDialog
 	void	OnOK () {}
-	void	OnCancel ()
+	void	OnCancel ();
 
 // Dialog Data
 	//{{AFX_DATA(COutputConsoleDlg)

code/ryzom/tools/leveldesign/georges_exe/CMakeLists.txt

@@ -0,0 +1,12 @@
+FILE(GLOB SRC *.cpp *.h)
+
+ADD_DEFINITIONS(${MFC_DEFINITIONS})
+SET(CMAKE_MFC_FLAG 2)
+ADD_EXECUTABLE(georges_exe WIN32 ${SRC} georges_exe.rc)
+
+TARGET_LINK_LIBRARIES(georges_exe nelmisc nelgeorges georges_dll)
+
+NL_DEFAULT_PROPS(georges_exe "Ryzom, Tools, Georges: Georges Exe")
+NL_ADD_RUNTIME_FLAGS(georges_exe)
+
+INSTALL(TARGETS georges_exe RUNTIME DESTINATION bin COMPONENT tools)

code/ryzom/tools/leveldesign/georges_plugin_sound/CMakeLists.txt

@@ -0,0 +1,26 @@
+
+FILE(GLOB SRC *.cpp *.h)
+
+# Bugfix...
+IF (NOT DXSDK_INCLUDE_DIR)
+	IF (DXSDK_DIR)
+		SET(DXSDK_INCLUDE_DIR "${DXSDK_DIR}/Include")
+	ENDIF (DXSDK_DIR)
+ENDIF (NOT DXSDK_INCLUDE_DIR)
+
+IF (NOT DXSDK_INCLUDE_DIR)
+	message(FATAL_ERROR "Configuration bad, cannot find DirectX include.")
+ENDIF (NOT DXSDK_INCLUDE_DIR)
+
+ADD_LIBRARY(georges_plugin_sound SHARED ${SRC})
+
+INCLUDE_DIRECTORIES(georges_plugin_sound ${NEL_INCLUDE_DIR} ${DXSDK_INCLUDE_DIR})
+
+TARGET_LINK_LIBRARIES(georges_plugin_sound nelmisc nelgeorges nelsound nelligo nelsnd_lowlevel georges_dll ${DXSDK_DSOUND_LIBRARY} ${DXSDK_GUID_LIBRARY})
+NL_DEFAULT_PROPS(georges_plugin_sound "Ryzom, Tools, Georges: Georges Plugin Sound")
+NL_ADD_RUNTIME_FLAGS(georges_plugin_sound)
+NL_ADD_LIB_SUFFIX(georges_plugin_sound)
+
+ADD_DEFINITIONS(${MFC_DEFINITIONS})
+
+INSTALL(TARGETS georges_plugin_sound LIBRARY DESTINATION lib RUNTIME DESTINATION bin ARCHIVE DESTINATION lib COMPONENT libraries)

code/ryzom/tools/leveldesign/georges_plugin_sound/sound_plugin.cpp

@@ -68,6 +68,9 @@ CSoundPlugin::CSoundPlugin(IEdit *globalInterface)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 
+	// Initialize without sheet id bin
+	NLMISC::CSheetId::initWithoutSheet();
+
 	CVector dir;
 
 	_GlobalInterface = globalInterface;
@@ -337,7 +340,7 @@ void CSoundPlugin::setActiveDocument(IEditDocument *pdoc)
 		_Dialog.setName(_Filename);
 
 		// 1st, try to found the sound in the preloaded sound bank.
-		_Sound = _Mixer->getSoundId(CStringMapper::map(_Filename));
+		_Sound = _Mixer->getSoundId(CSheetId(_Filename, "sound"));
 		if (_Sound == NULL)
 		{
 			// not found, create a new one.
@@ -537,7 +540,7 @@ void CSoundPlugin::play(std::string &filename)
 //				point.Name = string("simulation-")+_Sound->getName()+"-000";
 
 				region.VPoints.push_back(point);
-				string name = string("simulation-")+CStringMapper::unmap(_Sound->getName())+"-000";
+				string name = string("simulation-")+NLMISC::CFile::getFilenameWithoutExtension(_Sound->getName().toString())+"-000";
 				if (region.VPoints.back().checkProperty("name"))
 					region.VPoints.back().removePropertyByName("name");
 

code/ryzom/tools/leveldesign/georges_plugin_sound/sound_plugin.h

@@ -40,7 +40,7 @@
 #include "nel/sound/driver/sound_driver.h"
 #include "nel/sound/driver/source.h"
 #include "nel/sound/driver/listener.h"
-#include "sound/driver/dsound/source_dsound.h"
+// #include "sound/driver/dsound/source_dsound.h"
 
 #include "nel/sound/u_audio_mixer.h"
 #include "nel/sound/u_listener.h"
@@ -49,7 +49,7 @@
 class NLSOUND::IBuffer;
 class NLSOUND::IListener;
 class NLSOUND::USource;
-class NLSOUND::CSourceDSound;
+// class NLSOUND::CSourceDSound;
 class NLSOUND::CSound;
 
 

code/ryzom/tools/leveldesign/world_editor/CMakeLists.txt

@@ -3,7 +3,11 @@ ADD_SUBDIRECTORY(land_export_lib)
 
 IF(WITH_MFC)
   ADD_SUBDIRECTORY(world_editor)
+  ADD_SUBDIRECTORY(world_editor_fauna_graph_plugin)
+  ADD_SUBDIRECTORY(world_editor_graph_plugin)
   ADD_SUBDIRECTORY(world_editor_primitive_plugin)
+  ADD_SUBDIRECTORY(world_editor_shard_monitor_plugin)
+  ADD_SUBDIRECTORY(world_editor_sound_plugin)
 ENDIF(WITH_MFC)
 
 # This is an old plugin and is deprecated. It doesn't even compile anymore.

code/ryzom/tools/leveldesign/world_editor/world_editor_fauna_graph_plugin/CMakeLists.txt

@@ -0,0 +1,21 @@
+FILE(GLOB SRC *.cpp *.h)
+
+ADD_LIBRARY(world_editor_fauna_graph_plugin SHARED ${SRC})
+
+INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR})
+
+TARGET_LINK_LIBRARIES(world_editor_fauna_graph_plugin 
+							nelmisc
+							nel3d
+							nelsound
+							nelsnd_lowlevel)
+							
+NL_DEFAULT_PROPS(world_editor_fauna_graph_plugin "Ryzom, Tools, World: World Editor Fauna Graph Plugin")
+NL_ADD_RUNTIME_FLAGS(world_editor_fauna_graph_plugin)
+NL_ADD_LIB_SUFFIX(world_editor_fauna_graph_plugin)
+
+ADD_DEFINITIONS(${LIBXML2_DEFINITIONS} ${MFC_DEFINITIONS} -DWIN32_DLL_EXPORTS)
+
+
+INSTALL(TARGETS world_editor_fauna_graph_plugin LIBRARY DESTINATION lib RUNTIME DESTINATION bin ARCHIVE DESTINATION lib COMPONENT tools3d)
+

code/ryzom/tools/leveldesign/world_editor/world_editor_graph_plugin/CMakeLists.txt

@@ -0,0 +1,22 @@
+FILE(GLOB SRC *.cpp *.h)
+
+ADD_LIBRARY(world_editor_graph_plugin SHARED ${SRC})
+
+INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR})
+
+TARGET_LINK_LIBRARIES(world_editor_graph_plugin 
+							nelmisc
+							nel3d
+							nelsound
+							nelsnd_lowlevel
+							ryzom_mission_compiler_lib)
+							
+NL_DEFAULT_PROPS(world_editor_graph_plugin "Ryzom, Tools, World: World Editor Graph Plugin")
+NL_ADD_RUNTIME_FLAGS(world_editor_graph_plugin)
+NL_ADD_LIB_SUFFIX(world_editor_graph_plugin)
+
+ADD_DEFINITIONS(${LIBXML2_DEFINITIONS} ${MFC_DEFINITIONS} -DWIN32_DLL_EXPORTS)
+
+
+INSTALL(TARGETS world_editor_graph_plugin LIBRARY DESTINATION lib RUNTIME DESTINATION bin ARCHIVE DESTINATION lib COMPONENT tools3d)
+

code/ryzom/tools/leveldesign/world_editor/world_editor_shard_monitor_plugin/CMakeLists.txt

@@ -0,0 +1,22 @@
+FILE(GLOB SRC *.cpp *.h)
+
+ADD_LIBRARY(world_editor_shard_monitor_plugin SHARED ${SRC})
+
+INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR})
+
+TARGET_LINK_LIBRARIES(world_editor_shard_monitor_plugin 
+							nelmisc
+							nel3d
+							nelsound
+							nelsnd_lowlevel
+							ryzom_gameshare)
+							
+NL_DEFAULT_PROPS(world_editor_shard_monitor_plugin "Ryzom, Tools, World: World Editor Shard Monitor Plugin")
+NL_ADD_RUNTIME_FLAGS(world_editor_shard_monitor_plugin)
+NL_ADD_LIB_SUFFIX(world_editor_shard_monitor_plugin)
+
+ADD_DEFINITIONS(${LIBXML2_DEFINITIONS} ${MFC_DEFINITIONS} -DWIN32_DLL_EXPORTS)
+
+
+INSTALL(TARGETS world_editor_shard_monitor_plugin LIBRARY DESTINATION lib RUNTIME DESTINATION bin ARCHIVE DESTINATION lib COMPONENT tools3d)
+

code/ryzom/tools/leveldesign/world_editor/world_editor_sound_plugin/CMakeLists.txt

@@ -0,0 +1,21 @@
+FILE(GLOB SRC *.cpp *.h)
+
+ADD_LIBRARY(world_editor_sound_plugin SHARED ${SRC})
+
+INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR})
+
+TARGET_LINK_LIBRARIES(world_editor_sound_plugin 
+							nelmisc
+							nel3d
+							nelsound
+							nelsnd_lowlevel)
+							
+NL_DEFAULT_PROPS(world_editor_sound_plugin "Ryzom, Tools, World: World Editor Sound Plugin")
+NL_ADD_RUNTIME_FLAGS(world_editor_sound_plugin)
+NL_ADD_LIB_SUFFIX(world_editor_sound_plugin)
+
+ADD_DEFINITIONS(${LIBXML2_DEFINITIONS} ${MFC_DEFINITIONS} -DWIN32_DLL_EXPORTS)
+
+
+INSTALL(TARGETS world_editor_sound_plugin LIBRARY DESTINATION lib RUNTIME DESTINATION bin ARCHIVE DESTINATION lib COMPONENT tools3d)
+