Merge with default

--HG--
branch : sdl2

code/CMakeLists.txt

@@ -132,6 +132,13 @@ IF(FINAL_VERSION)
   ADD_DEFINITIONS(-DFINAL_VERSION=1)
 ENDIF(FINAL_VERSION)
 
+IF(WITH_SSE2)
+  ADD_DEFINITIONS(-DNL_HAS_SSE2)
+  IF(WITH_SSE3)
+    ADD_DEFINITIONS(-DNL_HAS_SSE3)
+  ENDIF(WITH_SSE3)
+ENDIF(WITH_SSE2)
+
 IF(WITH_QT)
   FIND_PACKAGE(Qt4 COMPONENTS QtCore QtGui QtXml QtOpenGL REQUIRED)
 ENDIF(WITH_QT)

code/CMakeModules/nel.cmake

@@ -118,13 +118,13 @@ MACRO(NL_DEFAULT_PROPS name label)
     ENDIF(NL_LIB_PREFIX)
   ENDIF(${type} STREQUAL SHARED_LIBRARY)
 
-  IF(${type} STREQUAL EXECUTABLE AND WIN32)
+  IF(${type} STREQUAL EXECUTABLE AND WIN32 AND NOT MINGW)
     SET_TARGET_PROPERTIES(${name} PROPERTIES
       VERSION ${NL_VERSION}
       SOVERSION ${NL_VERSION_MAJOR}
       COMPILE_FLAGS "/GA"
       LINK_FLAGS "/VERSION:${NL_VERSION_MAJOR}.${NL_VERSION_MINOR}")
-  ENDIF(${type} STREQUAL EXECUTABLE AND WIN32)
+  ENDIF(${type} STREQUAL EXECUTABLE AND WIN32 AND NOT MINGW)
 ENDMACRO(NL_DEFAULT_PROPS)
 
 ###
@@ -324,6 +324,13 @@ MACRO(NL_SETUP_NEL_DEFAULT_OPTIONS)
   OPTION(WITH_LIBOVR              "With LibOVR support"                           OFF)
   OPTION(WITH_LIBVR               "With LibVR support"                            OFF)
   OPTION(WITH_PERFHUD             "With NVIDIA PerfHUD support"                   OFF)
+  
+  OPTION(WITH_SSE2                "With SSE2"                                     ON )
+  OPTION(WITH_SSE3                "With SSE3"                                     ON )
+  
+  IF(NOT MSVC)
+    OPTION(WITH_GCC_FPMATH_BOTH   "With GCC -mfpmath=both"                        OFF)
+  ENDIF(NOT MSVC)
 ENDMACRO(NL_SETUP_NEL_DEFAULT_OPTIONS)
 
 MACRO(NL_SETUP_NELNS_DEFAULT_OPTIONS)
@@ -614,6 +621,14 @@ MACRO(NL_SETUP_BUILD)
       ENDIF(CLANG)
     ENDIF(WIN32)
 
+    IF(WITH_SSE3)
+      ADD_PLATFORM_FLAGS("-msse3")
+    ENDIF(WITH_SSE3)
+
+    IF(WITH_GCC_FPMATH_BOTH)
+      ADD_PLATFORM_FLAGS("-mfpmath=both")
+    ENDIF(WITH_GCC_FPMATH_BOTH)
+
     IF(APPLE)
       IF(NOT XCODE)
         IF(CMAKE_OSX_ARCHITECTURES)
@@ -875,9 +890,9 @@ MACRO(NL_SETUP_BUILD)
     ENDIF(APPLE)
 
     # Fix "relocation R_X86_64_32 against.." error on x64 platforms
-    IF(TARGET_X64 AND WITH_STATIC AND NOT WITH_STATIC_DRIVERS)
+    IF(TARGET_X64 AND WITH_STATIC AND NOT WITH_STATIC_DRIVERS AND NOT MINGW)
       ADD_PLATFORM_FLAGS("-fPIC")
-    ENDIF(TARGET_X64 AND WITH_STATIC AND NOT WITH_STATIC_DRIVERS)
+    ENDIF(TARGET_X64 AND WITH_STATIC AND NOT WITH_STATIC_DRIVERS AND NOT MINGW)
 
     SET(PLATFORM_CXXFLAGS "${PLATFORM_CXXFLAGS} -ftemplate-depth-48")
 

code/nel/include/nel/3d/computed_string.h

@@ -290,7 +290,7 @@ public:
 	 * \param matrix transformation matrix
 	 * \param hotspot position of string origine
 	 */
-	void render3D (IDriver& driver,CMatrix matrix,THotSpot hotspot = MiddleMiddle);
+	void render3D (IDriver& driver, const CMatrix &matrix, THotSpot hotspot = MiddleMiddle);
 
 };
 

code/nel/include/nel/3d/driver.h

@@ -182,7 +182,7 @@ public:
 							IDriver();
 	virtual					~IDriver();
 
-	virtual bool			init(uint windowIcon = 0, emptyProc exitFunc = 0) = 0;
+	virtual bool			init(uintptr_t windowIcon = 0, emptyProc exitFunc = 0) = 0;
 
 	/// Deriver should calls IDriver::release() first, to destroy all driver components (textures, shaders, VBuffers).
 	virtual bool			release();
@@ -1341,7 +1341,7 @@ public:
 	 *	NB: if implementation does not support it, 0 may be returned. OpenGL ones return the Texture ID.
 	 *	NB: unlike isTextureExist(), this method is not thread safe.
 	 */
-	virtual	uint			getTextureHandle(const ITexture&tex) = 0;
+	virtual	uintptr_t		getTextureHandle(const ITexture&tex) = 0;
 
 	// see if the Multiply-Add Tex Env operator is supported (see CMaterial::Mad)
 	virtual	bool			supportMADOperator() const = 0;

code/nel/include/nel/3d/driver_user.h

@@ -123,7 +123,7 @@ public:
 
 	/// \name Object
 	// @{
-	CDriverUser (uint windowIcon, UDriver::TDriver driver, emptyProc exitFunc = 0);
+	CDriverUser (uintptr_t windowIcon, UDriver::TDriver driver, emptyProc exitFunc = 0);
 	virtual	~CDriverUser();
 	// @}
 

code/nel/include/nel/3d/dru.h

@@ -24,8 +24,11 @@
 #include "nel/misc/geom_ext.h"
 #include "nel/misc/line.h"
 
-
+#if defined (NL_COMP_MINGW)
-#ifdef NL_OS_WINDOWS
+# define NL3D_GL_DLL_NAME "libnel_drv_opengl_win"
+# define NL3D_GLES_DLL_NAME "libnel_drv_opengles_win"
+# define NL3D_D3D_DLL_NAME "libnel_drv_direct3d_win"
+#elif defined (NL_OS_WINDOWS)
 # define NL3D_GL_DLL_NAME "nel_drv_opengl_win"
 # define NL3D_GLES_DLL_NAME "nel_drv_opengles_win"
 # define NL3D_D3D_DLL_NAME "nel_drv_direct3d_win"

code/nel/include/nel/3d/matrix_3x4.h

@@ -108,281 +108,6 @@ public:
 };
 
 
-// ***************************************************************************
-// ***************************************************************************
-// SSE Matrix
-// ***************************************************************************
-// ***************************************************************************
-
-
-// ***************************************************************************
-#if defined(NL_OS_WINDOWS) && !defined(NL_NO_ASM)
-
-
-/** For fast vector/point multiplication. Special usage for Skinning.
- *	NB: SSE is no more used (no speed gain, some memory problem), but keep it for possible future usage.
- */
-class	CMatrix3x4SSE
-{
-public:
-	// Order them in memory column first, for SSE column multiplication.
-	float	a11, a21, a31, a41;
-	float	a12, a22, a32, a42;
-	float	a13, a23, a33, a43;
-	float	a14, a24, a34, a44;
-
-	// Copy from a matrix.
-	void	set(const CMatrix &mat)
-	{
-		const float	*m =mat.get();
-		a11= m[0]; a12= m[4]; a13= m[8] ; a14= m[12];
-		a21= m[1]; a22= m[5]; a23= m[9] ; a24= m[13];
-		a31= m[2]; a32= m[6]; a33= m[10]; a34= m[14];
-		// not used.
-		a41= 0   ; a42= 0   ; a43= 0    ; a44= 1;
-	}
-
-
-	// mulSetvector. NB: in should be different as v!! (else don't work).
-	void	mulSetVector(const CVector &vin, CVector &vout)
-	{
-		__asm
-		{
-			mov		eax, vin
-			mov		ebx, this
-			mov		edi, vout
-			// Load in vector in op[0]
-			movss	xmm0, [eax]vin.x
-			movss	xmm1, [eax]vin.y
-			movss	xmm2, [eax]vin.z
-			// Expand op[0] to op[1], op[2], op[3]
-			shufps	xmm0, xmm0, 0
-			shufps	xmm1, xmm1, 0
-			shufps	xmm2, xmm2, 0
-			// Mul each vector with 3 Matrix column
-			mulps	xmm0, [ebx]this.a11
-			mulps	xmm1, [ebx]this.a12
-			mulps	xmm2, [ebx]this.a13
-			// Add each column vector.
-			addps	xmm0, xmm1
-			addps	xmm0, xmm2
-
-			// write the result.
-			movss	[edi]vout.x, xmm0
-			shufps	xmm0, xmm0, 33
-			movss	[edi]vout.y, xmm0
-			movhlps	xmm0, xmm0
-			movss	[edi]vout.z, xmm0
-		}
-	}
-	// mulSetpoint. NB: in should be different as v!! (else don't work).
-	void	mulSetPoint(const CVector &vin, CVector &vout)
-	{
-		__asm
-		{
-			mov		eax, vin
-			mov		ebx, this
-			mov		edi, vout
-			// Load in vector in op[0]
-			movss	xmm0, [eax]vin.x
-			movss	xmm1, [eax]vin.y
-			movss	xmm2, [eax]vin.z
-			// Expand op[0] to op[1], op[2], op[3]
-			shufps	xmm0, xmm0, 0
-			shufps	xmm1, xmm1, 0
-			shufps	xmm2, xmm2, 0
-			// Mul each vector with 3 Matrix column
-			mulps	xmm0, [ebx]this.a11
-			mulps	xmm1, [ebx]this.a12
-			mulps	xmm2, [ebx]this.a13
-			// Add each column vector.
-			addps	xmm0, xmm1
-			addps	xmm0, xmm2
-			// Add Matrix translate column vector
-			addps	xmm0, [ebx]this.a14
-
-			// write the result.
-			movss	[edi]vout.x, xmm0
-			shufps	xmm0, xmm0, 33
-			movss	[edi]vout.y, xmm0
-			movhlps	xmm0, xmm0
-			movss	[edi]vout.z, xmm0
-		}
-	}
-
-
-	// mulSetvector. NB: vin should be different as v!! (else don't work).
-	void	mulSetVector(const CVector &vin, float scale, CVector &vout)
-	{
-		__asm
-		{
-			mov		eax, vin
-			mov		ebx, this
-			mov		edi, vout
-			// Load in vector in op[0]
-			movss	xmm0, [eax]vin.x
-			movss	xmm1, [eax]vin.y
-			movss	xmm2, [eax]vin.z
-			// Load scale in op[0]
-			movss	xmm3, scale
-			// Expand op[0] to op[1], op[2], op[3]
-			shufps	xmm0, xmm0, 0
-			shufps	xmm1, xmm1, 0
-			shufps	xmm2, xmm2, 0
-			shufps	xmm3, xmm3, 0
-			// Store vertex column in other regs.
-			movaps	xmm5, xmm0
-			movaps	xmm6, xmm1
-			movaps	xmm7, xmm2
-			// Mul each vector with 3 Matrix column
-			mulps	xmm0, [ebx]this.a11
-			mulps	xmm1, [ebx]this.a12
-			mulps	xmm2, [ebx]this.a13
-			// Add each column vector.
-			addps	xmm0, xmm1
-			addps	xmm0, xmm2
-
-			// mul final result with scale
-			mulps	xmm0, xmm3
-
-			// store it in xmm4 for future use.
-			movaps	xmm4, xmm0
-		}
-	}
-	// mulSetpoint. NB: vin should be different as v!! (else don't work).
-	void	mulSetPoint(const CVector &vin, float scale, CVector &vout)
-	{
-		__asm
-		{
-			mov		eax, vin
-			mov		ebx, this
-			mov		edi, vout
-			// Load in vector in op[0]
-			movss	xmm0, [eax]vin.x
-			movss	xmm1, [eax]vin.y
-			movss	xmm2, [eax]vin.z
-			// Load scale in op[0]
-			movss	xmm3, scale
-			// Expand op[0] to op[1], op[2], op[3]
-			shufps	xmm0, xmm0, 0
-			shufps	xmm1, xmm1, 0
-			shufps	xmm2, xmm2, 0
-			shufps	xmm3, xmm3, 0
-			// Store vertex column in other regs.
-			movaps	xmm5, xmm0
-			movaps	xmm6, xmm1
-			movaps	xmm7, xmm2
-			// Mul each vector with 3 Matrix column
-			mulps	xmm0, [ebx]this.a11
-			mulps	xmm1, [ebx]this.a12
-			mulps	xmm2, [ebx]this.a13
-			// Add each column vector.
-			addps	xmm0, xmm1
-			addps	xmm0, xmm2
-			// Add Matrix translate column vector
-			addps	xmm0, [ebx]this.a14
-
-			// mul final result with scale
-			mulps	xmm0, xmm3
-
-			// store it in xmm4 for future use.
-			movaps	xmm4, xmm0
-		}
-	}
-
-
-	// mulAddvector. NB: vin should be different as v!! (else don't work).
-	void	mulAddVector(const CVector &/* vin */, float scale, CVector &vout)
-	{
-		__asm
-		{
-			mov		ebx, this
-			mov		edi, vout
-			// Load vin vector loaded in mulSetVector
-			movaps	xmm0, xmm5
-			movaps	xmm1, xmm6
-			movaps	xmm2, xmm7
-			// Load scale in op[0]
-			movss	xmm3, scale
-			// Expand op[0] to op[1], op[2], op[3]
-			shufps	xmm3, xmm3, 0
-			// Mul each vector with 3 Matrix column
-			mulps	xmm0, [ebx]this.a11
-			mulps	xmm1, [ebx]this.a12
-			mulps	xmm2, [ebx]this.a13
-			// Add each column vector.
-			addps	xmm0, xmm1
-			addps	xmm0, xmm2
-
-			// mul final result with scale
-			mulps	xmm0, xmm3
-
-			// Add result, with prec sum.
-			addps	xmm0, xmm4
-
-			// store it in xmm4 for future use.
-			movaps	xmm4, xmm0
-
-			// write the result.
-			movss	[edi]vout.x, xmm0
-			shufps	xmm0, xmm0, 33
-			movss	[edi]vout.y, xmm0
-			movhlps	xmm0, xmm0
-			movss	[edi]vout.z, xmm0
-		}
-	}
-	// mulAddpoint. NB: vin should be different as v!! (else don't work).
-	void	mulAddPoint(const CVector &/* vin */, float scale, CVector &vout)
-	{
-		__asm
-		{
-			mov		ebx, this
-			mov		edi, vout
-			// Load vin vector loaded in mulSetPoint
-			movaps	xmm0, xmm5
-			movaps	xmm1, xmm6
-			movaps	xmm2, xmm7
-			// Load scale in op[0]
-			movss	xmm3, scale
-			// Expand op[0] to op[1], op[2], op[3]
-			shufps	xmm3, xmm3, 0
-			// Mul each vector with 3 Matrix column
-			mulps	xmm0, [ebx]this.a11
-			mulps	xmm1, [ebx]this.a12
-			mulps	xmm2, [ebx]this.a13
-			// Add each column vector.
-			addps	xmm0, xmm1
-			addps	xmm0, xmm2
-			// Add Matrix translate column vector
-			addps	xmm0, [ebx]this.a14
-
-			// mul final result with scale
-			mulps	xmm0, xmm3
-
-			// Add result, with prec sum.
-			addps	xmm0, xmm4
-
-			// store it in xmm4 for future use.
-			movaps	xmm4, xmm0
-
-			// write the result.
-			movss	[edi]vout.x, xmm0
-			shufps	xmm0, xmm0, 33
-			movss	[edi]vout.y, xmm0
-			movhlps	xmm0, xmm0
-			movss	[edi]vout.z, xmm0
-		}
-	}
-
-};
-
-#else // NL_OS_WINDOWS
-/// dummy CMatrix3x4SSE for non windows platform
-class CMatrix3x4SSE : public  CMatrix3x4 { };
-#endif
-
-
-
 } // NL3D
 
 

code/nel/include/nel/3d/skeleton_model.h

@@ -54,7 +54,7 @@ public:
 	// The index of the skin rdrPass
 	uint16		RdrPassIndex;
 	// The texture id of the specular texture. This is the sort Key.
-	uint32		SpecId;
+	uintptr_t	SpecId;
 
 	bool	operator<(const CSkinSpecularRdrPass &o) const
 	{

code/nel/include/nel/3d/u_driver.h

@@ -845,8 +845,8 @@ public:
 	/**
 	 *	This is the static function which build a UDriver, the root for all 3D functions.
 	 */
-	static	UDriver			*createDriver(uint windowIcon = 0, bool direct3d = false, emptyProc exitFunc = 0);
+	static	UDriver			*createDriver(uintptr_t windowIcon = 0, bool direct3d = false, emptyProc exitFunc = 0);
-	static	UDriver			*createDriver(uint windowIcon, TDriver driver, emptyProc exitFunc = 0);
+	static	UDriver			*createDriver(uintptr_t windowIcon, TDriver driver, emptyProc exitFunc = 0);
 
 	/**
 	 *	Purge static memory

code/nel/include/nel/misc/di_event_emitter.h

@@ -34,7 +34,9 @@
 #include "events.h"
 #include "rect.h"
 #include "game_device.h"
-#define NOMINMAX
+#ifndef NL_COMP_MINGW
+#	define NOMINMAX
+#endif
 #include <windows.h>
 #include <dinput.h>
 
@@ -101,7 +103,7 @@ public:
 	  * \param we A windows eventsemitter. Can be NULL. Needed if you want to mix WIN32 events and Direct Input events
 	  *			  (for example, a Direct Input Mouse and a Win32 Keyboard)
 	  */
-	static CDIEventEmitter *create(HINSTANCE hinst, HWND hwnd, CWinEventEmitter *we);
+	static CDIEventEmitter *create(HINSTANCE hinst, HWND hwnd, CWinEventEmitter *we) throw(EDirectInput);
 	~CDIEventEmitter();
 public:
 

code/nel/include/nel/misc/fixed_size_allocator.h

@@ -53,7 +53,8 @@ public:
 	uint getNumAllocatedBlocks() const { return _NumAlloc; }
 private:
 	class CChunk;
-	class CNode
+	
+	class NL_ALIGN(NL_DEFAULT_MEMORY_ALIGNMENT) CNode
 	{
 	public:
 		CChunk *Chunk; // the Chunk this node belongs to.

code/nel/include/nel/misc/hierarchical_timer.h

@@ -74,7 +74,7 @@
 namespace NLMISC
 {
 
-#ifdef NL_OS_WINDOWS
+#ifdef NL_COMP_VC
 // Visual C++ warning : ebp maybe modified
 #	pragma warning(disable:4731)
 #endif

code/nel/include/nel/misc/inter_window_msg_queue.h

@@ -220,7 +220,7 @@ private:
 
 	static TOldWinProcMap _OldWinProcMap;
 
-	bool initInternal(HINSTANCE hInstance, HWND ownerWindow, uint32 localId, uint32 foreignId = NULL);
+	bool initInternal(HINSTANCE hInstance, HWND ownerWindow, uint32 localId, uint32 foreignId = 0);
 
 private:
 	static	LRESULT CALLBACK listenerProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

code/nel/include/nel/misc/matrix.h

@@ -53,7 +53,8 @@ class	CPlane;
  * \author Nevrax France
  * \date 2000
  */
-class CMatrix
+
+class NL_ALIGN_SSE2 CMatrix
 {
 public:
 	/// Rotation Order.

code/nel/include/nel/misc/object_vector.h

@@ -29,6 +29,12 @@
 # endif // NLMISC_HEAP_ALLOCATION_NDEBUG
 #endif // NL_USE_DEFAULT_MEMORY_MANAGER
 
+#ifndef NL_OV_USE_NEW_ALLOCATOR
+# ifdef NL_HAS_SSE2
+#  define NL_OV_USE_NEW_ALLOCATOR
+# endif // NL_HAS_SSE2
+#endif // NL_OV_USE_NEW_ALLOCATOR
+
 namespace NLMISC {
 
 

code/nel/include/nel/misc/types_nl.h

@@ -86,6 +86,10 @@
 #			define NL_COMP_VC_VERSION 60
 #			define NL_COMP_NEED_PARAM_ON_METHOD
 #		endif
+#	elif defined(__MINGW32__)
+#		define NL_COMP_MINGW
+#		define NL_COMP_GCC
+#		define NL_NO_ASM
 #	endif
 #	if defined(_HAS_TR1) && (_HAS_TR1 + 0) // VC9 TR1 feature pack or later
 #		define NL_ISO_STDTR1_AVAILABLE
@@ -93,9 +97,13 @@
 #		define NL_ISO_STDTR1_NAMESPACE std::tr1
 #	endif
 #	ifdef _DEBUG
-#		define NL_DEBUG
+#		ifndef NL_DEBUG
+#			define NL_DEBUG
+#		endif
 #	elif defined (NDEBUG)
-#		define NL_RELEASE
+#		ifndef NL_RELEASE
+#			define NL_RELEASE
+#		endif
 #	else
 #		error "Don't know the compilation mode"
 #	endif
@@ -109,7 +117,9 @@
 #		define _WIN32_WINNT 0x0600 // force VISTA minimal version in 64 bits
 #	endif
 	// define NOMINMAX to be sure that windows includes will not define min max macros, but instead, use the stl template
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #else
 #	ifdef __APPLE__
 #		define NL_OS_MAC
@@ -142,7 +152,7 @@
 //
 // NL_ISO_TEMPLATE_SPEC can be used in front of an instanciated class-template member data definition,
 // because sometimes MSVC++ 6 produces an error C2908 with a definition with template <>.
-#if defined(NL_OS_WINDOWS) || (defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ <= 3)))
+#if defined(NL_COMP_VC) || (defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ <= 3)))
 #	define NL_ISO_SYNTAX 0
 #	define NL_ISO_TEMPLATE_SPEC
 #else
@@ -328,6 +338,57 @@ typedef	unsigned	int			uint;			// at least 32bits (depend of processor)
 
 #endif // NL_OS_UNIX
 
+
+// #ifdef NL_ENABLE_FORCE_INLINE
+#	ifdef NL_COMP_VC
+#		define NL_FORCE_INLINE __forceinline
+#	elif defined(NL_COMP_GCC)
+#		define NL_FORCE_INLINE inline __attribute__((always_inline))
+#	else
+#		define NL_FORCE_INLINE inline
+#	endif
+// #else
+// #	define NL_FORCE_INLINE inline
+// #endif
+
+
+#ifdef NL_COMP_VC
+#define NL_ALIGN(nb) __declspec(align(nb))
+#else
+#define NL_ALIGN(nb) __attribute__((aligned(nb)))
+#endif
+
+#ifdef NL_OS_WINDOWS
+#include <stdlib.h>
+#include <intrin.h>
+#include <malloc.h>
+inline void *aligned_malloc(size_t size, size_t alignment) { return _aligned_malloc(size, alignment); }
+inline void aligned_free(void *ptr) { _aligned_free(ptr); }
+#else
+#include <malloc.h>
+inline void *aligned_malloc(size_t size, size_t alignment) { return memalign(alignment, size); }
+inline void aligned_free(void *ptr) { free(ptr); }
+#endif /* NL_COMP_ */
+
+
+#ifdef NL_HAS_SSE2
+
+#define NL_DEFAULT_MEMORY_ALIGNMENT 16
+#define NL_ALIGN_SSE2 NL_ALIGN(NL_DEFAULT_MEMORY_ALIGNMENT)
+
+extern void *operator new(size_t size) throw(std::bad_alloc);
+extern void *operator new[](size_t size) throw(std::bad_alloc);
+extern void operator delete(void *p) throw();
+extern void operator delete[](void *p) throw();
+
+#else /* NL_HAS_SSE2 */
+
+#define NL_DEFAULT_MEMORY_ALIGNMENT 4
+#define NL_ALIGN_SSE2
+
+#endif /* NL_HAS_SSE2 */
+
+
 // CHashMap, CHashSet and CHashMultiMap definitions
 #if defined(_STLPORT_VERSION) // STLport detected
 #	include <hash_map>
@@ -388,8 +449,8 @@ typedef	uint16	ucchar;
 
 
 // To define a 64bits constant; ie: UINT64_CONSTANT(0x123456781234)
-#ifdef NL_OS_WINDOWS
+#ifdef NL_COMP_VC
-#	if defined(NL_COMP_VC) && (NL_COMP_VC_VERSION >= 80)
+#	if (NL_COMP_VC_VERSION >= 80)
 #		define INT64_CONSTANT(c)	(c##LL)
 #		define SINT64_CONSTANT(c)	(c##LL)
 #		define UINT64_CONSTANT(c)	(c##LL)

code/nel/include/nel/misc/win_displayer.h

@@ -22,7 +22,9 @@
 #ifdef NL_OS_WINDOWS
 
 #define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
-#define NOMINMAX
+#ifndef NL_COMP_MINGW
+#	define NOMINMAX
+#endif
 #include <windows.h>
 
 #include "displayer.h"

code/nel/include/nel/net/buf_sock.h

@@ -50,10 +50,10 @@ public:
 	virtual ~CBufSock();
 
 	/// Sets the application identifier
-	void					setAppId( uint64 id ) { _AppId = id; }
+	void					setAppId( uintptr_t id ) { _AppId = id; }
 
 	/// Returns the application identifier
-	uint64					appId() const { return _AppId; }
+	uintptr_t				appId() const { return _AppId; }
 
 	/// Returns a string with the characteristics of the object
 	std::string				asString() const;
@@ -256,7 +256,7 @@ private:
 	NLMISC::CObjectVector<uint8> _ReadyToSendBuffer;
 	TBlockSize			_RTSBIndex;
 
-	uint64				_AppId;
+	uintptr_t			_AppId;
 
 	// Connected state (from the user's point of view, i.e. changed when the connection/disconnection event is at the front of the receive queue)
 	bool				_ConnectedState;

code/nel/samples/3d/cluster_viewer/main.cpp

@@ -38,7 +38,9 @@
 #include "nel/3d/event_mouse_listener.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/samples/3d/font/main.cpp

@@ -30,7 +30,9 @@
 #include "nel/3d/driver_user.h"
 
 #ifdef NL_OS_WINDOWS
-	#define NOMINMAX
+	#ifndef NL_COMP_MINGW
+		#define NOMINMAX
+	#endif
 	#include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/samples/3d/shape_viewer/main.cpp

@@ -29,7 +29,9 @@
 #include <nel/3d/u_instance.h>
 
 #ifdef NL_OS_WINDOWS
-	#define NOMINMAX
+	#ifndef NL_COMP_MINGW
+		#define NOMINMAX
+	#endif
 	#include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/samples/net/chat/kbhit.cpp

@@ -14,7 +14,9 @@
 // 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/>.
 
-#ifdef __GNUC__
+#include "nel/misc/types_nl.h"
+
+#ifndef NL_OS_WINDOWS
 #include "kbhit.h"
 #include <termios.h>
 #include <unistd.h>   // for read()

code/nel/samples/net/chat/server.cpp

@@ -24,7 +24,9 @@
 #include "nel/net/callback_server.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/samples/net/class_transport/ai_service.cpp

@@ -37,7 +37,9 @@
 #include "nel/net/transport_class.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/samples/net/class_transport/gd_service.cpp

@@ -37,7 +37,9 @@
 #include "nel/net/transport_class.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/samples/net/login_system/frontend_service.cpp

@@ -34,7 +34,9 @@
 #include "nel/net/login_server.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/samples/net/udp/bench_service.cpp

@@ -43,7 +43,9 @@
 #include "receive_task.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/samples/net/udp/receive_task.cpp

@@ -18,7 +18,9 @@
 
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #elif defined NL_OS_UNIX
 

code/nel/src/3d/computed_string.cpp

@@ -143,11 +143,13 @@ void CComputedString::render2D (IDriver& driver,
 /*------------------------------------------------------------------*\
 							render3D()
 \*------------------------------------------------------------------*/
-void CComputedString::render3D (IDriver& driver,CMatrix matrix,THotSpot hotspot)
+void CComputedString::render3D (IDriver& driver, const CMatrix &matrixp, THotSpot hotspot)
 {
 	if (Vertices.getNumVertices() == 0)
 		return;
 
+	CMatrix matrix = matrixp;
+
 	// get window size
 	uint32	wndWidth, wndHeight;
 	driver.getWindowSize(wndWidth, wndHeight);

code/nel/src/3d/deform_2d.cpp

@@ -103,7 +103,6 @@ void CDeform2d::doDeform(const TPoint2DVect &surf, IDriver *drv, IPerturbUV *uvp
 	static CVertexBuffer  vb;
 	vb.setName("CDeform2d");
 	vb.setVertexFormat(CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag);
-	vb.setPreferredMemory(CVertexBuffer::RAMVolatile, false);
 
 
 

code/nel/src/3d/driver/direct3d/CMakeLists.txt

@@ -10,7 +10,7 @@ NL_DEFAULT_PROPS(nel_drv_direct3d_win "NeL, Driver, Video: Direct3D")
 NL_ADD_RUNTIME_FLAGS(nel_drv_direct3d_win)
 NL_ADD_LIB_SUFFIX(nel_drv_direct3d_win)
 
-ADD_DEFINITIONS(/Ddriver_direct3d_EXPORTS)
+ADD_DEFINITIONS(-DRIVER_DIRECT3D_EXPORTS)
 
 IF(WITH_PCH)
   ADD_NATIVE_PRECOMPILED_HEADER(nel_drv_direct3d_win ${CMAKE_CURRENT_SOURCE_DIR}/stddirect3d.h ${CMAKE_CURRENT_SOURCE_DIR}/stddirect3d.cpp)

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

@@ -110,6 +110,10 @@ IDriver* createD3DDriverInstance ()
 
 #else
 
+#ifdef NL_COMP_MINGW
+extern "C"
+{
+#endif
 __declspec(dllexport) IDriver* NL3D_createIDriverInstance ()
 {
 	return new CDriverD3D;
@@ -119,7 +123,9 @@ __declspec(dllexport) uint32 NL3D_interfaceVersion ()
 {
 	return IDriver::InterfaceVersion;
 }
-
+#ifdef NL_COMP_MINGW
+}
+#endif
 #endif
 
 /*static*/ bool CDriverD3D::_CacheTest[CacheTest_Count] =
@@ -379,7 +385,7 @@ void CDriverD3D::resetRenderVariables()
 	}
 	for (i=0; i<MaxTexture; i++)
 	{
-		if ((uint32)(_TexturePtrStateCache[i].Texture) != 0xcccccccc)
+		if ((uintptr_t)(_TexturePtrStateCache[i].Texture) != 0xcccccccc)
 		{
 			touchRenderVariable (&(_TexturePtrStateCache[i]));
 			// reset texture because it may reference an old render target
@@ -419,7 +425,7 @@ void CDriverD3D::resetRenderVariables()
 
 	for (i=0; i<MaxLight; i++)
 	{
-		if (*(uint32*)(&(_LightCache[i].Light)) != 0xcccccccc)
+		if (*(uintptr_t*)(&(_LightCache[i].Light)) != 0xcccccccc)
 		{
 			_LightCache[i].EnabledTouched = true;
 			touchRenderVariable (&(_LightCache[i]));
@@ -514,7 +520,7 @@ void CDriverD3D::initRenderVariables()
 	for (i=0; i<MaxTexture; i++)
 	{
 		_TexturePtrStateCache[i].StageID = i;
-		*(uint32*)&(_TexturePtrStateCache[i].Texture) = 0xcccccccc;
+		*(uintptr_t*)&(_TexturePtrStateCache[i].Texture) = 0xcccccccc;
 		_TexturePtrStateCache[i].Modified = false;
 	}
 	for (i=0; i<MaxSampler; i++)
@@ -543,7 +549,7 @@ void CDriverD3D::initRenderVariables()
 	for (i=0; i<MaxLight; ++i)
 	{
 		_LightCache[i].LightIndex = uint8(i);
-		*(uint32*)&(_LightCache[i].Light) = 0xcccccccc;
+		*(uintptr_t*)&(_LightCache[i].Light) = 0xcccccccc;
 		_LightCache[i].Modified = false;
 	}
 	_VertexProgramCache.Modified = false;
@@ -1063,7 +1069,7 @@ void CDriverD3D::updateRenderVariablesInternal()
 
 // ***************************************************************************
 
-static void D3DWndProc(CDriverD3D *driver, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+void D3DWndProc(CDriverD3D *driver, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
 	H_AUTO_D3D(D3DWndProc);
 
@@ -1231,7 +1237,7 @@ static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM l
 
 // ***************************************************************************
 
-bool CDriverD3D::init (uint windowIcon, emptyProc exitFunc)
+bool CDriverD3D::init (uintptr_t windowIcon, emptyProc exitFunc)
 {
 	H_AUTO_D3D(CDriver3D_init );
 
@@ -1481,7 +1487,7 @@ bool CDriverD3D::setDisplay(nlWindow wnd, const GfxMode& mode, bool show, bool r
 				break;
 			}
 		}
-	#endif WITH_PERFHUD
+	#endif /* WITH_PERFHUD */
 	// Create the D3D device
 	HRESULT result = _D3D->CreateDevice (adapter, _Rasterizer, _HWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_PUREDEVICE, &parameters, &_DeviceInterface);
 	if (result != D3D_OK)

code/nel/src/3d/driver/direct3d/driver_direct3d.def

@@ -1,2 +1,4 @@
-EXPORTS NL3D_createIDriverInstance
+LIBRARY nel_drv_direct3d_win_r
-EXPORTS NL3D_interfaceVersion
+EXPORTS
+	NL3D_createIDriverInstance
+	NL3D_interfaceVersion

code/nel/src/3d/driver/direct3d/driver_direct3d.h

@@ -839,7 +839,7 @@ public:
 	// ***************************************************************************
 
 	// Mode initialisation, requests
-	virtual bool			init (uint windowIcon = 0, emptyProc exitFunc = 0);
+	virtual bool			init (uintptr_t windowIcon = 0, emptyProc exitFunc = 0);
 	virtual bool			setDisplay(nlWindow wnd, const GfxMode& mode, bool show, bool resizeable) throw(EBadDisplay);
 	virtual bool			release();
 	virtual bool			setMode(const GfxMode& mode);
@@ -953,7 +953,7 @@ public:
 	virtual void			setSwapVBLInterval(uint interval);
 	virtual uint			getSwapVBLInterval();
 	virtual void			swapTextureHandle(ITexture &tex0, ITexture &tex1);
-	virtual	uint			getTextureHandle(const ITexture&tex);
+	virtual	uintptr_t		getTextureHandle(const ITexture&tex);
 
 	// Matrix, viewport and frustum
 	virtual void			setFrustum(float left, float right, float bottom, float top, float znear, float zfar, bool perspective = true);
@@ -1893,7 +1893,7 @@ public:
 		H_AUTO_D3D(CDriverD3D_setSamplerState);
 		nlassert (_DeviceInterface);
 		nlassert (sampler<MaxSampler);
-		nlassert (samplerState<MaxSamplerState);
+		nlassert ((int)samplerState<(int)MaxSamplerState);
 
 		// Ref on the state
 		CSamplerState &_samplerState = _SamplerStateCache[sampler][samplerState];
@@ -2025,7 +2025,7 @@ public:
 
 		// Remap high matrices indexes
 		type = (D3DTRANSFORMSTATETYPE)remapMatrixIndex (type);
-		nlassert (type<MaxMatrixState);
+		nlassert ((int)type<(int)MaxMatrixState);
 
 		CMatrixState &theMatrix = _MatrixCache[type];
 #ifdef NL_D3D_USE_RENDER_STATE_CACHE

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

@@ -46,7 +46,7 @@ CIBDrvInfosD3D::CIBDrvInfosD3D(CDriverD3D *drv, ItIBDrvInfoPtrList it, CIndexBuf
 
 // ***************************************************************************
 
-extern uint indexCount=0;
+uint indexCount=0;
 
 CIBDrvInfosD3D::~CIBDrvInfosD3D()
 {

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

@@ -1091,7 +1091,7 @@ void CDriverD3D::swapTextureHandle(ITexture &tex0, ITexture &tex1)
 
 // ***************************************************************************
 
-uint CDriverD3D::getTextureHandle(const ITexture &tex)
+uintptr_t CDriverD3D::getTextureHandle(const ITexture &tex)
 {
 	H_AUTO_D3D(CDriverD3D_getTextureHandle)
 	// If DrvShare not setuped
@@ -1104,7 +1104,7 @@ uint CDriverD3D::getTextureHandle(const ITexture &tex)
 	if(!d3dtext)
 		return 0;
 
-	return (uint)(d3dtext->Texture);
+	return (uintptr_t)(d3dtext->Texture);
 }
 
 // ***************************************************************************

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

@@ -59,7 +59,7 @@ CVBDrvInfosD3D::CVBDrvInfosD3D(CDriverD3D *drv, ItVBDrvInfoPtrList it, CVertexBu
 
 // ***************************************************************************
 
-extern uint vertexCount=0;
+uint vertexCount=0;
 
 CVBDrvInfosD3D::~CVBDrvInfosD3D()
 {
@@ -173,7 +173,7 @@ uint8	*CVBDrvInfosD3D::lock (uint begin, uint end, bool readOnly)
 
 		void *pbData;
 		if (VertexBuffer->Lock ( begin, end-begin, &pbData, readOnly?D3DLOCK_READONLY:0) != D3D_OK)
-			return false;
+			return NULL;
 
 		// Lock Profile?
 		if(driver->_VBHardProfiling /*&& Hardware*/)

code/nel/src/3d/driver/direct3d/stddirect3d.h

@@ -19,7 +19,9 @@
 
 #ifdef NL_OS_WINDOWS
 #	define WIN32_LEAN_AND_MEAN
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #endif
 

code/nel/src/3d/driver/opengl/CMakeLists.txt

@@ -37,7 +37,7 @@ NL_ADD_RUNTIME_FLAGS(${NLDRV_OGL_LIB})
 IF(WIN32)
   INCLUDE_DIRECTORIES(${DXSDK_INCLUDE_DIR})
   TARGET_LINK_LIBRARIES(${NLDRV_OGL_LIB} ${DXSDK_DINPUT_LIBRARY} ${DXSDK_GUID_LIBRARY})
-  ADD_DEFINITIONS(/DDRIVER_OPENGL_EXPORTS)
+  ADD_DEFINITIONS(-DDRIVER_OPENGL_EXPORTS)
 ENDIF(WIN32)
 
 IF(APPLE)

code/nel/src/3d/driver/opengl/driver_opengl.cpp

@@ -108,7 +108,10 @@ IDriver* createGlDriverInstance ()
 #else
 
 #ifdef NL_OS_WINDOWS
-
+#ifdef NL_COMP_MINGW
+extern "C"
+{
+#endif
 __declspec(dllexport) IDriver* NL3D_createIDriverInstance ()
 {
 	return new CDriverGL;
@@ -118,7 +121,9 @@ __declspec(dllexport) uint32 NL3D_interfaceVersion ()
 {
 	return IDriver::InterfaceVersion;
 }
-
+#ifdef NL_COMP_MINGW
+}
+#endif
 #elif defined (NL_OS_UNIX)
 
 extern "C"
@@ -479,6 +484,11 @@ bool CDriverGL::setupDisplay()
 #endif
 	}
 	
+	if (_Extensions.ARBFragmentShader)
+	{
+		_ForceNativeFragmentPrograms = false;
+	}
+
 	_VertexProgramEnabled= false;
 	_PixelProgramEnabled= false;
 	_LastSetupGLArrayVertexProgram= false;
@@ -2652,7 +2662,7 @@ void CDriverGL::checkTextureOn() const
 bool CDriverGL::supportOcclusionQuery() const
 {
 	H_AUTO_OGL(CDriverGL_supportOcclusionQuery)
-	return _Extensions.NVOcclusionQuery;
+	return _Extensions.NVOcclusionQuery || _Extensions.ARBOcclusionQuery;
 }
 
 // ***************************************************************************
@@ -2683,11 +2693,14 @@ bool CDriverGL::supportFrameBufferObject() const
 IOcclusionQuery *CDriverGL::createOcclusionQuery()
 {
 	H_AUTO_OGL(CDriverGL_createOcclusionQuery)
-	nlassert(_Extensions.NVOcclusionQuery);
+	nlassert(_Extensions.NVOcclusionQuery || _Extensions.ARBOcclusionQuery);
 
 #ifndef USE_OPENGLES
 	GLuint id;
-	nglGenOcclusionQueriesNV(1, &id);
+	if (_Extensions.NVOcclusionQuery)
+		nglGenOcclusionQueriesNV(1, &id);
+	else
+		nglGenQueriesARB(1, &id);
 	if (id == 0) return NULL;
 	COcclusionQueryGL *oqgl = new COcclusionQueryGL;
 	oqgl->Driver = this;
@@ -2714,7 +2727,10 @@ void CDriverGL::deleteOcclusionQuery(IOcclusionQuery *oq)
 	oqgl->Driver = NULL;
 	nlassert(oqgl->ID != 0);
 	GLuint id = oqgl->ID;
-	nglDeleteOcclusionQueriesNV(1, &id);
+	if (_Extensions.NVOcclusionQuery)
+		nglDeleteOcclusionQueriesNV(1, &id);
+	else
+		nglDeleteQueriesARB(1, &id);
 	_OcclusionQueryList.erase(oqgl->Iterator);
 	if (oqgl == _CurrentOcclusionQuery)
 	{
@@ -2733,7 +2749,10 @@ void COcclusionQueryGL::begin()
 	nlassert(Driver);
 	nlassert(Driver->_CurrentOcclusionQuery == NULL); // only one query at a time
 	nlassert(ID);
-	nglBeginOcclusionQueryNV(ID);
+	if (Driver->_Extensions.NVOcclusionQuery)
+		nglBeginOcclusionQueryNV(ID);
+	else
+		nglBeginQueryARB(GL_SAMPLES_PASSED, ID);
 	Driver->_CurrentOcclusionQuery = this;
 	OcclusionType = NotAvailable;
 	VisibleCount = 0;
@@ -2749,7 +2768,10 @@ void COcclusionQueryGL::end()
 	nlassert(Driver);
 	nlassert(Driver->_CurrentOcclusionQuery == this); // only one query at a time
 	nlassert(ID);
-	nglEndOcclusionQueryNV();
+	if (Driver->_Extensions.NVOcclusionQuery)
+		nglEndOcclusionQueryNV();
+	else
+		nglEndQueryARB(GL_SAMPLES_PASSED);
 	Driver->_CurrentOcclusionQuery = NULL;
 #endif
 }
@@ -2765,15 +2787,25 @@ IOcclusionQuery::TOcclusionType COcclusionQueryGL::getOcclusionType()
 	nlassert(Driver->_CurrentOcclusionQuery != this); // can't query result between a begin/end pair!
 	if (OcclusionType == NotAvailable)
 	{
-		GLuint result;
+		if (Driver->_Extensions.NVOcclusionQuery)
-		// retrieve result
+		{
-		nglGetOcclusionQueryuivNV(ID, GL_PIXEL_COUNT_AVAILABLE_NV, &result);
+			GLuint result;
-		if (result != GL_FALSE)
+			// retrieve result
+			nglGetOcclusionQueryuivNV(ID, GL_PIXEL_COUNT_AVAILABLE_NV, &result);
+			if (result != GL_FALSE)
+			{
+				nglGetOcclusionQueryuivNV(ID, GL_PIXEL_COUNT_NV, &result);
+				OcclusionType = result != 0 ? NotOccluded : Occluded;
+				VisibleCount = (uint) result;
+				// Note : we could return the exact number of pixels that passed the z-test, but this value is not supported by all implementation (Direct3D ...)
+			}
+		}
+		else
 		{
-			nglGetOcclusionQueryuivNV(ID, GL_PIXEL_COUNT_NV, &result);
+			GLuint result;
+			nglGetQueryObjectuivARB(ID, GL_QUERY_RESULT, &result);
 			OcclusionType = result != 0 ? NotOccluded : Occluded;
 			VisibleCount = (uint) result;
-			// Note : we could return the exact number of pixels that passed the z-test, but this value is not supported by all implementation (Direct3D ...)
 		}
 	}
 #endif

code/nel/src/3d/driver/opengl/driver_opengl.def

@@ -1,2 +1,4 @@
-EXPORTS NL3D_createIDriverInstance
+LIBRARY nel_drv_opengl_win_r
-EXPORTS NL3D_interfaceVersion
+EXPORTS
+	NL3D_createIDriverInstance
+	NL3D_interfaceVersion

code/nel/src/3d/driver/opengl/driver_opengl.h

@@ -304,7 +304,7 @@ public:
 
 	virtual	bool			isLost() const { return false; } // there's no notion of 'lost device" in OpenGL
 
-	virtual bool			init (uint windowIcon = 0, emptyProc exitFunc = 0);
+	virtual bool			init (uintptr_t windowIcon = 0, emptyProc exitFunc = 0);
 
 	virtual void			disableHardwareVertexProgram();
 	virtual void			disableHardwarePixelProgram();
@@ -632,7 +632,7 @@ public:
 
 	virtual void			swapTextureHandle(ITexture &tex0, ITexture &tex1);
 
-	virtual	uint			getTextureHandle(const ITexture&tex);
+	virtual	uintptr_t		getTextureHandle(const ITexture&tex);
 
 	/// \name Material multipass.
 	/**	NB: setupMaterial() must be called before thoses methods.
@@ -1591,6 +1591,7 @@ private:
 	// @}
 	// misc
 public:
+	friend class COcclusionQueryGL;
 	static GLenum NLCubeFaceToGLCubeFace[6];
 	static CMaterial::CTexEnv	_TexEnvReplace;
 	// occlusion query

code/nel/src/3d/driver/opengl/driver_opengl_extension.cpp

@@ -449,6 +449,16 @@ PFNGLENDOCCLUSIONQUERYNVPROC				nglEndOcclusionQueryNV;
 PFNGLGETOCCLUSIONQUERYIVNVPROC				nglGetOcclusionQueryivNV;
 PFNGLGETOCCLUSIONQUERYUIVNVPROC				nglGetOcclusionQueryuivNV;
 
+// ARB_occlusion_query
+PFNGLGENQUERIESPROC							nglGenQueriesARB;
+PFNGLDELETEQUERIESPROC						nglDeleteQueriesARB;
+PFNGLISQUERYPROC							nglIsQueryARB;
+PFNGLBEGINQUERYPROC							nglBeginQueryARB;
+PFNGLENDQUERYPROC							nglEndQueryARB;
+PFNGLGETQUERYIVPROC							nglGetQueryivARB;
+PFNGLGETQUERYOBJECTIVPROC					nglGetQueryObjectivARB;
+PFNGLGETQUERYOBJECTUIVPROC					nglGetQueryObjectuivARB;
+
 // GL_EXT_framebuffer_object
 PFNGLISRENDERBUFFEREXTPROC					nglIsRenderbufferEXT;
 PFNGLISFRAMEBUFFEREXTPROC					nglIsFramebufferEXT;
@@ -1239,6 +1249,15 @@ static bool	setupNVFragmentProgram2(const char *glext)
 	return true;
 }
 
+// *********************************
+static bool	setupARBFragmentShader(const char *glext)
+{
+	H_AUTO_OGL(setupNVFragmentProgram2);
+	CHECK_EXT("GL_ARB_fragment_shader");
+	
+	return true;
+}
+
 // ***************************************************************************
 static bool	setupARBVertexBufferObject(const char	*glext)
 {
@@ -1371,6 +1390,26 @@ static bool	setupNVOcclusionQuery(const char	*glext)
 	return true;
 }
 
+// ***************************************************************************
+static bool	setupARBOcclusionQuery(const char	*glext)
+{
+	H_AUTO_OGL(setupARBOcclusionQuery);
+	CHECK_EXT("ARB_occlusion_query");
+
+#ifndef USE_OPENGLES
+	CHECK_ADDRESS(PFNGLGENQUERIESPROC, glGenQueriesARB);
+	CHECK_ADDRESS(PFNGLDELETEQUERIESPROC, glDeleteQueriesARB);
+	CHECK_ADDRESS(PFNGLISQUERYPROC, glIsQueryARB);
+	CHECK_ADDRESS(PFNGLBEGINQUERYPROC, glBeginQueryARB);
+	CHECK_ADDRESS(PFNGLENDQUERYPROC, glEndQueryARB);
+	CHECK_ADDRESS(PFNGLGETQUERYIVPROC, glGetQueryivARB);
+	CHECK_ADDRESS(PFNGLGETQUERYOBJECTIVPROC, glGetQueryObjectivARB);
+	CHECK_ADDRESS(PFNGLGETQUERYOBJECTUIVPROC, glGetQueryObjectuivARB);
+#endif
+
+	return true;
+}
+
 
 // ***************************************************************************
 static bool	setupNVTextureRectangle(const char	*glext)
@@ -1597,7 +1636,7 @@ void	registerGlExtensions(CGlExtensions &ext)
 	{
 		ext.NVVertexProgram = setupNVVertexProgram(glext);
 		ext.EXTVertexShader = setupEXTVertexShader(glext);
-		ext.ARBVertexProgram= setupARBVertexProgram(glext);
+		ext.ARBVertexProgram = setupARBVertexProgram(glext);
 	}
 	else
 	{
@@ -1612,6 +1651,7 @@ void	registerGlExtensions(CGlExtensions &ext)
 	{		
 		ext.ARBFragmentProgram = setupARBFragmentProgram(glext);	
 		ext.NVFragmentProgram2 = setupNVFragmentProgram2(glext);
+		ext.ARBFragmentShader = setupARBFragmentShader(glext);
 	}
 	else
 	{
@@ -1663,6 +1703,9 @@ void	registerGlExtensions(CGlExtensions &ext)
 	// Check NV_occlusion_query
 	ext.NVOcclusionQuery = setupNVOcclusionQuery(glext);
 
+	// Check ARB_occlusion_query
+	ext.ARBOcclusionQuery = setupARBOcclusionQuery(glext);
+
 	// Check GL_NV_texture_rectangle
 	ext.NVTextureRectangle = setupNVTextureRectangle(glext);
 

code/nel/src/3d/driver/opengl/driver_opengl_extension.h

@@ -58,6 +58,7 @@ struct	CGlExtensions
 	bool	EXTVertexShader;
 	bool	NVTextureShader;
 	bool	NVOcclusionQuery;
+	bool	ARBOcclusionQuery;
 	bool	NVTextureRectangle;
 	bool	EXTTextureRectangle;
 	bool	ARBTextureRectangle;
@@ -103,6 +104,7 @@ struct	CGlExtensions
 	bool	ARBVertexProgram;
 	bool	ARBTextureNonPowerOfTwo;
 	bool	ARBMultisample;
+	bool	ARBFragmentShader;
 
 	// NV Pixel Programs
 	bool	NVFragmentProgram2;
@@ -177,7 +179,9 @@ public:
 		ARBTextureRectangle = false;
 		ARBTextureNonPowerOfTwo = false;
 		ARBMultisample = false;
+		ARBFragmentShader = false;
 		NVOcclusionQuery = false;
+		ARBOcclusionQuery = false;
 		FrameBufferObject = false;
 		FrameBufferBlit = false;
 		FrameBufferMultisample = false;
@@ -239,6 +243,7 @@ public:
 		result += EXTSecondaryColor ? "EXTSecondaryColor " : "";
 		result += EXTBlendColor ? "EXTBlendColor " : "";
 		result += NVOcclusionQuery ? "NVOcclusionQuery " : "";
+		result += ARBOcclusionQuery ? "ARBOcclusionQuery " : "";
 		result += NVStateVARWithoutFlush ? "NVStateVARWithoutFlush " : "";
 		result += ARBMultisample ? "ARBMultisample " : "";
 		result += NVXGPUMemoryInfo ? "NVXGPUMemoryInfo " : "";
@@ -737,7 +742,16 @@ extern PFNGLENDOCCLUSIONQUERYNVPROC nglEndOcclusionQueryNV;
 extern PFNGLGETOCCLUSIONQUERYIVNVPROC nglGetOcclusionQueryivNV;
 extern PFNGLGETOCCLUSIONQUERYUIVNVPROC nglGetOcclusionQueryuivNV;
 
-
+// ARB_occlusion_query
+//==================================
+extern PFNGLGENQUERIESPROC nglGenQueriesARB;
+extern PFNGLDELETEQUERIESPROC nglDeleteQueriesARB;
+extern PFNGLISQUERYPROC nglIsQueryARB;
+extern PFNGLBEGINQUERYPROC nglBeginQueryARB;
+extern PFNGLENDQUERYPROC nglEndQueryARB;
+extern PFNGLGETQUERYIVPROC nglGetQueryivARB;
+extern PFNGLGETQUERYOBJECTIVPROC nglGetQueryObjectivARB;
+extern PFNGLGETQUERYOBJECTUIVPROC nglGetQueryObjectuivARB;
 
 #ifdef NL_OS_WINDOWS
 

code/nel/src/3d/driver/opengl/driver_opengl_texture.cpp

@@ -2269,7 +2269,7 @@ void		CDriverGL::swapTextureHandle(ITexture &tex0, ITexture &tex1)
 
 
 // ***************************************************************************
-uint CDriverGL::getTextureHandle(const ITexture &tex)
+uintptr_t CDriverGL::getTextureHandle(const ITexture &tex)
 {
 	H_AUTO_OGL(CDriverGL_getTextureHandle)
 	// If DrvShare not setuped

code/nel/src/3d/driver/opengl/driver_opengl_window.cpp

@@ -296,7 +296,7 @@ bool GlWndProc(CDriverGL *driver, XEvent &e)
 #endif // NL_OS_UNIX
 
 // ***************************************************************************
-bool CDriverGL::init (uint windowIcon, emptyProc exitFunc)
+bool CDriverGL::init (uintptr_t windowIcon, emptyProc exitFunc)
 {
 	H_AUTO_OGL(CDriverGL_init)
 

code/nel/src/3d/driver/opengl/stdopengl.h

@@ -37,7 +37,9 @@
 
 #ifdef NL_OS_WINDOWS
 #	define WIN32_LEAN_AND_MEAN
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <windowsx.h>
 #endif

code/nel/src/3d/driver_user.cpp

@@ -82,13 +82,13 @@ void					UDriver::setMatrixMode2D43()
 }
 
 // ***************************************************************************
-UDriver					*UDriver::createDriver(uint windowIcon, bool direct3d, emptyProc exitFunc)
+UDriver					*UDriver::createDriver(uintptr_t windowIcon, bool direct3d, emptyProc exitFunc)
 {
 	return new CDriverUser (windowIcon, direct3d ? CDriverUser::Direct3d:CDriverUser::OpenGl, exitFunc);
 }
 
 // ***************************************************************************
-UDriver					*UDriver::createDriver(uint windowIcon, TDriver driver, emptyProc exitFunc)
+UDriver					*UDriver::createDriver(uintptr_t windowIcon, TDriver driver, emptyProc exitFunc)
 {
 	return new CDriverUser (windowIcon, (CDriverUser::TDriver)driver, exitFunc);
 }
@@ -114,7 +114,7 @@ bool	CDriverUser::_StaticInit= false;
 
 
 // ***************************************************************************
-CDriverUser::CDriverUser (uint windowIcon, TDriver driver, emptyProc exitFunc)
+CDriverUser::CDriverUser (uintptr_t windowIcon, TDriver driver, emptyProc exitFunc)
 {
 	// The enum of IDriver and UDriver MUST be the same!!!
 	nlassert((uint)IDriver::idCount == (uint)UDriver::idCount);

code/nel/src/3d/dru.cpp

@@ -35,7 +35,9 @@
 #endif // HAVE_CONFIG_H
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #else // NL_OS_WINDOWS
 #	include <dlfcn.h>

code/nel/src/3d/mesh_mrm_skin.cpp

@@ -16,6 +16,10 @@
 
 #include "std3d.h"
 
+#ifdef NL_HAS_SSE2
+#	include <xmmintrin.h>
+#endif
+
 #include "nel/misc/bsphere.h"
 #include "nel/misc/fast_mem.h"
 #include "nel/misc/system_info.h"
@@ -39,124 +43,6 @@ namespace NL3D
 {
 
 
-// ***************************************************************************
-// ***************************************************************************
-// CMatrix3x4SSE array correctly aligned
-// ***************************************************************************
-// ***************************************************************************
-
-
-
-// ***************************************************************************
-#define	NL3D_SSE_ALIGNEMENT		16
-/**
- *	A CMatrix3x4SSE array correctly aligned
- *	NB: SSE is no more used (no speed gain, some memory problem), but keep it for possible future usage.
- */
-class	CMatrix3x4SSEArray
-{
-private:
-	void	*_AllocData;
-	void	*_Data;
-	uint	_Size;
-	uint	_Capacity;
-
-public:
-	CMatrix3x4SSEArray()
-	{
-		_AllocData= NULL;
-		_Data= NULL;
-		_Size= 0;
-		_Capacity= 0;
-	}
-	~CMatrix3x4SSEArray()
-	{
-		clear();
-	}
-	CMatrix3x4SSEArray(const CMatrix3x4SSEArray &other)
-	{
-		_AllocData= NULL;
-		_Data= NULL;
-		_Size= 0;
-		_Capacity= 0;
-		*this= other;
-	}
-	CMatrix3x4SSEArray &operator=(const CMatrix3x4SSEArray &other)
-	{
-		if( this == &other)
-			return *this;
-		resize(other.size());
-		// copy data from aligned pointers to aligned pointers.
-		memcpy(_Data, other._Data, size() * sizeof(CMatrix3x4SSE) );
-
-		return *this;
-	}
-
-
-	CMatrix3x4SSE	*getPtr()
-	{
-		return (CMatrix3x4SSE*)_Data;
-	}
-
-	void	clear()
-	{
-		delete [] ((uint8 *)_AllocData);
-		_AllocData= NULL;
-		_Data= NULL;
-		_Size= 0;
-		_Capacity= 0;
-	}
-
-	void	resize(uint n)
-	{
-		// reserve ??
-		if(n>_Capacity)
-			reserve( max(2*_Capacity, n));
-		_Size= n;
-	}
-
-	void	reserve(uint n)
-	{
-		if(n==0)
-			clear();
-		else if(n>_Capacity)
-		{
-			// Alloc new data.
-			void	*newAllocData;
-			void	*newData;
-
-			// Alloc for alignement.
-			newAllocData= new uint8 [n * sizeof(CMatrix3x4SSE) + NL3D_SSE_ALIGNEMENT-1];
-			if(newAllocData==NULL)
-				throw Exception("SSE Allocation Failed");
-
-			// Align ptr
-			newData= (void*) ( ((ptrdiff_t)newAllocData+NL3D_SSE_ALIGNEMENT-1) & (~(NL3D_SSE_ALIGNEMENT-1)) );
-
-			// copy valid data from old to new.
-			memcpy(newData, _Data, size() * sizeof(CMatrix3x4SSE) );
-
-			// release old.
-			if(_AllocData)
-				delete [] ((uint8*)_AllocData);
-
-			// change ptrs and capacity.
-			_Data= newData;
-			_AllocData= newAllocData;
-			_Capacity= n;
-
-			// TestYoyo
-			//nlwarning("YOYO Tst SSE P4: %X, %d", _Data, n);
-		}
-	}
-
-	uint	size() const {return _Size;}
-
-
-	CMatrix3x4SSE	&operator[](uint i) {return ((CMatrix3x4SSE*)_Data)[i];}
-};
-
-
 
 // ***************************************************************************
 // ***************************************************************************

code/nel/src/3d/mesh_mrm_skin_template.cpp

@@ -39,7 +39,23 @@ static void	applyArraySkinNormalT(uint numMatrixes, uint32 *infPtr, CMesh::CSkin
 {
 	/* Prefetch all vertex/normal before, it is to be faster.
 	*/
-#if defined(NL_OS_WINDOWS) && !defined(NL_NO_ASM)
+#ifdef NL_HAS_SSE2
+	{
+		uint	nInfTmp= nInf;
+		uint32	*infTmpPtr= infPtr;
+		for(;nInfTmp>0;nInfTmp--, infTmpPtr++)
+		{
+			uint	index= *infTmpPtr;
+			CMesh::CSkinWeight	*srcSkin= srcSkinPtr + index;
+			CVector				*srcVertex= srcVertexPtr + index;
+			CVector				*srcNormal= srcNormalPtr + index;
+
+			_mm_prefetch((const char *)(void *)srcSkin, _MM_HINT_T1);
+			_mm_prefetch((const char *)(void *)srcVertex, _MM_HINT_T1);
+			_mm_prefetch((const char *)(void *)srcNormal, _MM_HINT_T1);
+		}
+	}
+#elif defined(NL_OS_WINDOWS) && !defined(NL_NO_ASM)
 	{
 		uint	nInfTmp= nInf;
 		uint32	*infTmpPtr= infPtr;
@@ -176,7 +192,25 @@ static void	applyArraySkinTangentSpaceT(uint numMatrixes, uint32 *infPtr, CMesh:
 {
 	/* Prefetch all vertex/normal/tgSpace before, it is faster.
 	*/
-#if defined(NL_OS_WINDOWS) && !defined(NL_NO_ASM)
+#ifdef NL_HAS_SSE2
+	{
+		uint	nInfTmp= nInf;
+		uint32	*infTmpPtr= infPtr;
+		for(;nInfTmp>0;nInfTmp--, infTmpPtr++)
+		{
+			uint	index= *infTmpPtr;
+			CMesh::CSkinWeight	*srcSkin= srcSkinPtr + index;
+			CVector				*srcVertex= srcVertexPtr + index;
+			CVector				*srcNormal= srcNormalPtr + index;
+			CVector				*srcTgSpace= tgSpacePtr + index;
+
+			_mm_prefetch((const char *)(void *)srcSkin, _MM_HINT_T1);
+			_mm_prefetch((const char *)(void *)srcVertex, _MM_HINT_T1);
+			_mm_prefetch((const char *)(void *)srcNormal, _MM_HINT_T1);
+			_mm_prefetch((const char *)(void *)srcTgSpace, _MM_HINT_T1);
+		}
+	}
+#elif defined(NL_OS_WINDOWS) && !defined(NL_NO_ASM)
 	{
 		uint	nInfTmp= nInf;
 		uint32	*infTmpPtr= infPtr;

code/nel/src/3d/mesh_mrm_skinned.cpp

@@ -2247,123 +2247,6 @@ void CMeshMRMSkinnedGeom::getSkinWeights (std::vector<CMesh::CSkinWeight> &skinW
 	}
 }
 
-// ***************************************************************************
-// ***************************************************************************
-// CMatrix3x4SSE array correctly aligned
-// ***************************************************************************
-// ***************************************************************************
-
-
-
-// ***************************************************************************
-#define	NL3D_SSE_ALIGNEMENT		16
-/**
- *	A CMatrix3x4SSEArray array correctly aligned
- *	NB: SSE is no more used (no speed gain, some memory problem), but keep it for possible future usage.
- */
-class	CMatrix3x4SSEArray
-{
-private:
-	void	*_AllocData;
-	void	*_Data;
-	uint	_Size;
-	uint	_Capacity;
-
-public:
-	CMatrix3x4SSEArray()
-	{
-		_AllocData= NULL;
-		_Data= NULL;
-		_Size= 0;
-		_Capacity= 0;
-	}
-	~CMatrix3x4SSEArray()
-	{
-		clear();
-	}
-	CMatrix3x4SSEArray(const CMatrix3x4SSEArray &other)
-	{
-		_AllocData= NULL;
-		_Data= NULL;
-		_Size= 0;
-		_Capacity= 0;
-		*this= other;
-	}
-	CMatrix3x4SSEArray &operator=(const CMatrix3x4SSEArray &other)
-	{
-		if( this == &other)
-			return *this;
-		resize(other.size());
-		// copy data from aligned pointers to aligned pointers.
-		memcpy(_Data, other._Data, size() * sizeof(CMatrix3x4SSE) );
-
-		return *this;
-	}
-
-
-	CMatrix3x4SSE	*getPtr()
-	{
-		return (CMatrix3x4SSE*)_Data;
-	}
-
-	void	clear()
-	{
-		delete [] ((uint8 *) _AllocData);
-		_AllocData= NULL;
-		_Data= NULL;
-		_Size= 0;
-		_Capacity= 0;
-	}
-
-	void	resize(uint n)
-	{
-		// reserve ??
-		if(n>_Capacity)
-			reserve( max(2*_Capacity, n));
-		_Size= n;
-	}
-
-	void	reserve(uint n)
-	{
-		if(n==0)
-			clear();
-		else if(n>_Capacity)
-		{
-			// Alloc new data.
-			void	*newAllocData;
-			void	*newData;
-
-			// Alloc for alignement.
-			newAllocData= new uint8 [n * sizeof(CMatrix3x4SSE) + NL3D_SSE_ALIGNEMENT-1];
-			if(newAllocData==NULL)
-				throw Exception("SSE Allocation Failed");
-
-			// Align ptr
-			newData= (void*) ( ((ptrdiff_t)newAllocData+NL3D_SSE_ALIGNEMENT-1) & (~(NL3D_SSE_ALIGNEMENT-1)) );
-
-			// copy valid data from old to new.
-			memcpy(newData, _Data, size() * sizeof(CMatrix3x4SSE) );
-
-			// release old.
-			if(_AllocData)
-				delete [] ((uint8*)_AllocData);
-
-			// change ptrs and capacity.
-			_Data= newData;
-			_AllocData= newAllocData;
-			_Capacity= n;
-
-			// TestYoyo
-			//nlwarning("YOYO Tst SSE P4: %X, %d", _Data, n);
-		}
-	}
-
-	uint	size() const {return _Size;}
-
-
-	CMatrix3x4SSE	&operator[](uint i) {return ((CMatrix3x4SSE*)_Data)[i];}
-};
-
 
 // ***************************************************************************
 // ***************************************************************************

code/nel/src/3d/motion_blur.cpp

@@ -59,7 +59,6 @@ void CMotionBlur::performMotionBlur(IDriver *driver, float motionBlurAmount)
 	static CVertexBuffer  vb ;
 	vb.setVertexFormat(CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag ) ;
 	vb.setNumVertices(4) ;
-	vb.setPreferredMemory(CVertexBuffer::RAMVolatile, false);
 
 	uint32 width, height ;
 	driver->getWindowSize(width, height) ;

code/nel/src/3d/ps_fan_light.cpp

@@ -519,7 +519,6 @@ void CPSFanLight::getVBnIB(CVertexBuffer *&retVb, CIndexBuffer *&retIb)
 		vb.setName("CPSFanLight");
 		ib.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
 		ib.setNumIndexes(size * _NbFans * 3);
-		ib.setPreferredMemory(CIndexBuffer::AGPVolatile, false);
 		// pointer on the current index to fill
 		CIndexBufferReadWrite iba;
 		ib.lock (iba);

code/nel/src/3d/ps_force.cpp

@@ -421,7 +421,6 @@ void CPSGravity::show()
 
 	vb.setVertexFormat(CVertexBuffer::PositionFlag);
 	vb.setNumVertices(6);
-	vb.setPreferredMemory(CVertexBuffer::RAMVolatile, false);
 	{
 		CVertexBufferReadWrite vba;
 		vb.lock (vba);
@@ -434,7 +433,6 @@ void CPSGravity::show()
 	}
 	pb.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
 	pb.setNumIndexes(2*4);
-	pb.setPreferredMemory(CIndexBuffer::RAMVolatile, false);
 	{
 		CIndexBufferReadWrite ibaWrite;
 		pb.lock (ibaWrite);

code/nel/src/3d/ps_ribbon.cpp

@@ -971,7 +971,6 @@ CPSRibbon::CVBnPB &CPSRibbon::getVBnPB()
 						  );
 		vb.setNumVertices((_UsedNbSegs + 1) * numRibbonInVB * numVerticesInSlice); // 1 seg = 1 line + terminal vertices
 		pb.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
-		pb.setPreferredMemory(CIndexBuffer::AGPVolatile, false);
 		// set the primitive block size
 		if (_BraceMode)
 		{

code/nel/src/3d/ps_ribbon_look_at.cpp

@@ -582,7 +582,6 @@ CPSRibbonLookAt::CVBnPB &CPSRibbonLookAt::getVBnPB()
 		CIndexBuffer &pb = VBnPB.PB;
 		pb.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
 		pb.setNumIndexes((_UsedNbSegs << 1) * numRibbonInVB * 3);
-		pb.setPreferredMemory(CIndexBuffer::AGPVolatile, false);
 		CIndexBufferReadWrite iba;
 		pb.lock (iba);
 		/// Setup the pb and vb parts. Not very fast but executed only once

code/nel/src/3d/ps_shockwave.cpp

@@ -530,7 +530,6 @@ void CPSShockWave::getVBnPB(CVertexBuffer *&retVb, CIndexBuffer *&retPb)
 		vb.lock (vba);
 		pb.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
 		pb.setNumIndexes(2 * 3 * size * _NbSeg);
-		pb.setPreferredMemory(CIndexBuffer::AGPVolatile, false);
 		CIndexBufferReadWrite ibaWrite;
 		pb.lock (ibaWrite);
 		uint finalIndex = 0;

code/nel/src/3d/ps_tail_dot.cpp

@@ -422,7 +422,6 @@ CPSTailDot::CVBnPB &CPSTailDot::getVBnPB()
 		CIndexBuffer &pb = VBnPB.PB;
 		pb.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
 		pb.setNumIndexes(2 * _UsedNbSegs * numRibbonInVB);
-		pb.setPreferredMemory(CIndexBuffer::AGPVolatile, false);
 		/// Setup the pb and vb parts. Not very fast but executed only once
 		uint vbIndex = 0;
 		uint pbIndex = 0;

code/nel/src/3d/ps_util.cpp

@@ -117,7 +117,6 @@ void CPSUtil::displayBBox(NL3D::IDriver *driver, const NLMISC::CAABBox &box, NLM
 	CVertexBuffer vb;
 	vb.setVertexFormat(CVertexBuffer::PositionFlag);
 	vb.setNumVertices(8);
-	vb.setPreferredMemory(CVertexBuffer::AGPVolatile, false);
 
 	{
 		CVertexBufferReadWrite vba;
@@ -146,7 +145,6 @@ void CPSUtil::displayBBox(NL3D::IDriver *driver, const NLMISC::CAABBox &box, NLM
 	CIndexBuffer pb;
 	pb.setFormat(NL_DEFAULT_INDEX_BUFFER_FORMAT);
 	pb.setNumIndexes(2*12);
-	pb.setPreferredMemory(CIndexBuffer::RAMVolatile, false);
 	{
 		CIndexBufferReadWrite ibaWrite;
 		pb.lock (ibaWrite);
@@ -208,7 +206,6 @@ void CPSUtil::displayArrow(IDriver *driver, const CVector &start, const CVector
 	CVertexBuffer vb;
 	vb.setVertexFormat(CVertexBuffer::PositionFlag);
 	vb.setNumVertices(5);
-	vb.setPreferredMemory(CVertexBuffer::AGPVolatile, false);
 
 
 	{

code/nel/src/3d/scene_group.cpp

@@ -1307,7 +1307,6 @@ void			CInstanceGroup::displayDebugClusters(IDriver *drv, class CTextContext *tx
 	const uint	maxVertices= 10000;
 	vb.setVertexFormat(CVertexBuffer::PositionFlag);
 	vb.setNumVertices(maxVertices);
-	vb.setPreferredMemory(CVertexBuffer::RAMVolatile, false);
 	CIndexBuffer		clusterTriangles;
 	CIndexBuffer		clusterLines;
 	CIndexBuffer		portalTriangles;

code/nel/src/3d/zone_lighter.cpp

@@ -38,7 +38,9 @@
 
 #ifdef NL_OS_WINDOWS
 #	define WIN32_LEAN_AND_MEAN
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <winbase.h>
 #endif // NL_OS_WINDOWS

code/nel/src/gui/interface_parser.cpp

@@ -647,8 +647,7 @@ namespace NLGUI
 			{
 				if(!parseLUAScript(root))
 				{
-					nlwarning ("could not parse 'lua'");
+					nlerror ("could not parse 'lua'");
-					exit( EXIT_FAILURE );
 				}
 			}
 			else

code/nel/src/gui/lua_object.cpp

@@ -362,7 +362,7 @@ namespace NLGUI
 	{
 		nlassert(key);
 		nlassert(isValid());
-		if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to set a function value '%p' at key %s on object '%s' of type %s (not a table).", value, key, getId().c_str(), getTypename()));
+		if (!isTable()) throw ELuaNotATable(NLMISC::toString("Trying to set a function value '%p' at key %s on object '%s' of type %s (not a table).", (void *)value, key, getId().c_str(), getTypename()));
 		CLuaStackChecker lsc(_LuaState);
 		push();
 		_LuaState->push(key);

code/nel/src/gui/stdpch.h

@@ -30,7 +30,9 @@
 #include "nel/misc/hierarchical_timer.h"
 
 #ifdef NL_OS_WINDOWS
-	#define NOMINMAX
+	#ifndef NL_COMP_MINGW
+	#	define NOMINMAX
+	#endif
 	#include <WinSock2.h>
 	#include <windows.h>
 #endif

code/nel/src/ligo/stdligo.h

@@ -63,6 +63,8 @@
 #include "nel/misc/file.h"
 
 #ifdef NL_OS_WINDOWS
-	#define NOMINMAX
+	#ifndef NL_COMP_MINGW
+		#define NOMINMAX
+	#endif
 	#include <windows.h>
 #endif

code/nel/src/ligo/zone_bank.cpp

@@ -25,7 +25,9 @@
 #include "nel/misc/o_xml.h"
 
 #ifdef NL_OS_WINDOWS
+#ifndef NL_COMP_MINGW
 #define NOMINMAX
+#endif
 #include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/src/misc/CMakeLists.txt

@@ -27,7 +27,7 @@ ENDIF(WITH_STATIC OR WIN32)
 # For DirectInput (di_event_emitter)
 IF(WIN32)
   INCLUDE_DIRECTORIES(${DXSDK_INCLUDE_DIR})
-  TARGET_LINK_LIBRARIES(nelmisc ${DXSDK_DINPUT_LIBRARY} ${DXSDK_GUID_LIBRARY})
+  TARGET_LINK_LIBRARIES(nelmisc ${DXSDK_DINPUT_LIBRARY} ${DXSDK_GUID_LIBRARY} winmm dbghelp)
 ENDIF(WIN32)
 
 IF(UNIX)
@@ -39,7 +39,7 @@ ENDIF(UNIX)
 
 INCLUDE_DIRECTORIES(${SDL2_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR} ${PNG_INCLUDE_DIR} config_file)
 
-TARGET_LINK_LIBRARIES(nelmisc ${SDL2_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} ${LIBXML2_LIBRARIES})
+TARGET_LINK_LIBRARIES(nelmisc ${SDL2_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} ${LIBXML2_LIBRARIES} ${ZLIB_LIBRARY})
 SET_TARGET_PROPERTIES(nelmisc PROPERTIES LINK_INTERFACE_LIBRARIES "")
 NL_DEFAULT_PROPS(nelmisc "NeL, Library: NeL Misc")
 NL_ADD_RUNTIME_FLAGS(nelmisc)

code/nel/src/misc/bitmap_jpeg.cpp

@@ -26,6 +26,9 @@
 #include <csetjmp>
 extern "C"
 {
+	#ifdef NL_COMP_MINGW
+	#	define HAVE_BOOLEAN
+	#endif
 	#include <jpeglib.h>
 }
 #endif

code/nel/src/misc/co_task.cpp

@@ -53,7 +53,9 @@
 #  define _WIN32_WINNT 0x0400
 # endif
 
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #elif defined (NL_OS_UNIX)
 #	define NL_WIN_CALLBACK

code/nel/src/misc/common.cpp

@@ -20,7 +20,9 @@
 #include "nel/misc/common.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <io.h>
 #	include <tchar.h>
@@ -37,6 +39,7 @@
 
 using namespace std;
 
+#ifndef NL_COMP_MINGW
 #ifdef NL_OS_WINDOWS
 #	pragma message( " " )
 
@@ -69,6 +72,36 @@ extern "C" long _ftol2( double dblSource ) { return _ftol( dblSource ); }
 
 
 #endif // NL_OS_WINDOWS
+#endif // !NL_COMP_MINGW
+
+
+#ifdef NL_HAS_SSE2
+
+void *operator new(size_t size) throw(std::bad_alloc)
+{
+	void *p = aligned_malloc(size, NL_DEFAULT_MEMORY_ALIGNMENT);
+	if (p == NULL) throw std::bad_alloc();
+	return p;
+}
+
+void *operator new[](size_t size) throw(std::bad_alloc)
+{
+	void *p = aligned_malloc(size, NL_DEFAULT_MEMORY_ALIGNMENT);
+	if (p == NULL) throw std::bad_alloc();
+	return p;
+}
+
+void operator delete(void *p) throw()
+{
+	aligned_free(p);
+}
+
+void operator delete[](void *p) throw()
+{
+	aligned_free(p);
+}
+
+#endif /* NL_HAS_SSE2 */
 
 
 #ifdef DEBUG_NEW
@@ -1040,7 +1073,7 @@ bool openDoc (const char *document)
     HINSTANCE result = ShellExecuteA(NULL, "open", document, NULL,NULL, SW_SHOWDEFAULT);
 
     // If it failed, get the .htm regkey and lookup the program
-    if ((UINT)result <= HINSTANCE_ERROR)
+    if ((uintptr_t)result <= HINSTANCE_ERROR)
 	{
         if (GetRegKey(HKEY_CLASSES_ROOT, ext.c_str(), key) == ERROR_SUCCESS)
 		{

code/nel/src/misc/debug.cpp

@@ -34,8 +34,10 @@
 
 #ifdef NL_OS_WINDOWS
 #	define _WIN32_WINDOWS	0x0410
+#	ifndef NL_COMP_MINGW
 #	define WINVER			0x0400
-#	define NOMINMAX
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <direct.h>
 #	include <tchar.h>
@@ -445,7 +447,7 @@ public:
 
 	EDebug() { _Reason = "Nothing about EDebug"; }
 
-	~EDebug () { }
+	virtual ~EDebug() throw() {}
 
 	EDebug(EXCEPTION_POINTERS * pexp) : m_pexp(pexp) { nlassert(pexp != 0); createWhat(); }
 	EDebug(const EDebug& se) : m_pexp(se.m_pexp) { createWhat(); }
@@ -755,7 +757,7 @@ public:
 
 	HANDLE getProcessHandle()
 	{
-		return CSystemInfo::isNT()?GetCurrentProcess():(HANDLE)GetCurrentProcessId();
+		return CSystemInfo::isNT()?GetCurrentProcess():(HANDLE)(uintptr_t)GetCurrentProcessId();
 	}
 
 	// return true if found
@@ -797,7 +799,7 @@ public:
 		while (findAndErase(rawType, "classvector<char,class char_traits<char>,class allocator<char> >", "string")) ;
 	}
 
-	string getFuncInfo (DWORD funcAddr, DWORD stackAddr)
+	string getFuncInfo (uintptr_t funcAddr, uintptr_t stackAddr)
 	{
 		string str ("NoSymbol");
 
@@ -853,7 +855,7 @@ public:
 
 				if (stop==0 && (parse[i] == ',' || parse[i] == ')'))
 				{
-					ULONG *addr = (ULONG*)(stackAddr) + 2 + pos2++;
+					uintptr_t *addr = (uintptr_t*)(stackAddr) + 2 + pos2++;
 
 					string displayType = type;
 					cleanType (type, displayType);
@@ -882,7 +884,7 @@ public:
 					}
 					else if (type == "char*")
 					{
-						if (!IsBadReadPtr(addr,sizeof(char*)) && *addr != NULL)
+						if (!IsBadReadPtr(addr,sizeof(char*)) && *addr != 0)
 						{
 							if (!IsBadStringPtrA((char*)*addr,32))
 							{
@@ -920,7 +922,7 @@ public:
 					{
 						if (!IsBadReadPtr(addr,sizeof(string*)))
 						{
-							if (*addr != NULL)
+							if (*addr != 0)
 							{
 								if (!IsBadReadPtr((void*)*addr,sizeof(string)))
 									sprintf (tmp, "\"%s\"", ((string*)*addr)->c_str());
@@ -929,9 +931,9 @@ public:
 					}
 					else
 					{
-						if (!IsBadReadPtr(addr,sizeof(ULONG*)))
+						if (!IsBadReadPtr(addr,sizeof(uintptr_t*)))
 						{
-							if(*addr == NULL)
+							if(*addr == 0)
 								sprintf (tmp, "<NULL>");
 							else
 								sprintf (tmp, "0x%p", *addr);
@@ -956,7 +958,7 @@ public:
 			if (disp != 0)
 			{
 				str += " + ";
-				str += toString ((uint32)disp);
+				str += toString ((uintptr_t)disp);
 				str += " bytes";
 			}
 		}
@@ -1166,7 +1168,8 @@ void createDebug (const char *logPath, bool logInFile, bool eraseLastLog)
 		initAcquireTimeMap();
 #endif
 
-#ifdef NL_OS_WINDOWS
+#ifndef NL_COMP_MINGW
+#	ifdef NL_OS_WINDOWS
 //		if (!IsDebuggerPresent ())
 		{
 			// Use an environment variable to share the value among the EXE and its child DLLs
@@ -1180,7 +1183,8 @@ void createDebug (const char *logPath, bool logInFile, bool eraseLastLog)
 				SetEnvironmentVariable( SE_TRANSLATOR_IN_MAIN_MODULE, _T("1") );
 			}
 		}
-#endif // NL_OS_WINDOWS
+#	endif // NL_OS_WINDOWS
+#endif //!NL_COMP_MINGW
 
 		INelContext::getInstance().setErrorLog(new CLog (CLog::LOG_ERROR));
 		INelContext::getInstance().setWarningLog(new CLog (CLog::LOG_WARNING));

code/nel/src/misc/di_game_device.cpp

@@ -217,7 +217,7 @@ static void BuildCtrlName(LPCDIDEVICEOBJECTINSTANCE lpddoi,
 
 //============================================================================
 // A callback to enumerate the controls of a device
-static BOOL CALLBACK DIEnumDeviceObjectsCallback
+BOOL CALLBACK DIEnumDeviceObjectsCallback
 (
   LPCDIDEVICEOBJECTINSTANCE lpddoi,
   LPVOID pvRef

code/nel/src/misc/di_keyboard_device.cpp

@@ -113,8 +113,8 @@ static const CKeyConv DIToNel[] =
 	{DIK_CONVERT, KeyCONVERT, "CONVERT", false},
 	{DIK_NOCONVERT, KeyNONCONVERT, "NOCONVERT", true},
 	//
-	{DIK_KANA, KeyKANA, false},
+	{DIK_KANA, KeyKANA, "KANA", false},
-	{DIK_KANJI, KeyKANJI, false},
+	{DIK_KANJI, KeyKANJI, "KANJI", false},
 };
 
 
@@ -164,7 +164,7 @@ CDIKeyboard::CDIKeyboard(CWinEventEmitter *we, HWND hwnd)
 		_RepeatPeriod = (uint) (1000.f / (keybSpeed * (27.5f / 31.f) + 2.5f));
 	}
 	// get keyboard layout
-	_KBLayout = ::GetKeyboardLayout(NULL);
+	_KBLayout = ::GetKeyboardLayout(0);
 
 	_RepetitionDisabled.resize(NumKeys);
 	_RepetitionDisabled.clearAll();

code/nel/src/misc/di_mouse_device.cpp

@@ -27,6 +27,12 @@
 	#define new DEBUG_NEW
 #endif
 
+#ifdef NL_COMP_MINGW
+#	undef FIELD_OFFSET
+#	define FIELD_OFFSET(t,f) offsetof(t,f)
+#endif
+
+
 namespace NLMISC
 {
 
@@ -78,7 +84,7 @@ void	    CDIMouse::setMouseMode(TAxis axis, TAxisMode axisMode)
 //======================================================
 CDIMouse::TAxisMode	CDIMouse::getMouseMode(TAxis axis) const
 {
-	nlassert(axis < NumMouseAxis);
+	nlassert((int)axis < (int)NumMouseAxis);
 	return _MouseAxisMode[axis];
 }
 

code/nel/src/misc/displayer.cpp

@@ -39,8 +39,10 @@
 // these defines is for IsDebuggerPresent(). it'll not compile on windows 95
 // just comment this and the IsDebuggerPresent to compile on windows 95
 #	define _WIN32_WINDOWS	0x0410
-#	define WINVER			0x0400
+#	ifndef NL_COMP_MINGW
-#	define NOMINMAX
+#		define WINVER			0x0400
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #else
 #	define IsDebuggerPresent() false

code/nel/src/misc/dynloadlib.cpp

@@ -57,7 +57,7 @@ void *nlGetSymbolAddress(NL_LIB_HANDLE libHandle, const std::string &procName)
 {
 	void *res = 0;
 #ifdef NL_OS_WINDOWS
-	res = GetProcAddress(libHandle, procName.c_str());
+	res = (void *)GetProcAddress(libHandle, procName.c_str());
 #elif defined(NL_OS_UNIX)
 	res = dlsym(libHandle, procName.c_str());
 #else

code/nel/src/misc/fixed_size_allocator.cpp

@@ -33,6 +33,9 @@ CFixedSizeAllocator::CFixedSizeAllocator(uint numBytesPerBlock, uint numBlockPer
 	_NumChunks = 0;
 	nlassert(numBytesPerBlock > 1);
 	_NumBytesPerBlock = numBytesPerBlock;
+	const uint mask = NL_DEFAULT_MEMORY_ALIGNMENT - 1;
+	_NumBytesPerBlock = (_NumBytesPerBlock + mask) & ~mask;
+	nlassert(_NumBytesPerBlock >= numBytesPerBlock);
 	_NumBlockPerChunk = std::max(numBlockPerChunk, (uint) 3);
 	_NumAlloc = 0;
 }
@@ -67,12 +70,14 @@ void *CFixedSizeAllocator::alloc()
 	return _FreeSpace->unlink();
 }
 
+#define aligned_offsetof(s, m) ((offsetof(s, m) + (NL_DEFAULT_MEMORY_ALIGNMENT - 1)) & ~(NL_DEFAULT_MEMORY_ALIGNMENT - 1))
+
 // *****************************************************************************************************************
 void CFixedSizeAllocator::free(void *block)
 {
 	if (!block) return;
 	/// get the node from the object
-	CNode *node = (CNode *) ((uint8 *) block - offsetof(CNode, Next));
+	CNode *node = (CNode *) ((uint8 *) block - aligned_offsetof(CNode, Next));
 	//
 	nlassert(node->Chunk != NULL);
 	nlassert(node->Chunk->Allocator == this);
@@ -84,7 +89,9 @@ void CFixedSizeAllocator::free(void *block)
 // *****************************************************************************************************************
 uint CFixedSizeAllocator::CChunk::getBlockSizeWithOverhead() const
 {
-	return std::max((uint)(sizeof(CNode) - offsetof(CNode, Next)),(uint)(Allocator->getNumBytesPerBlock())) + offsetof(CNode, Next);
+	nlctassert((sizeof(CNode) % NL_DEFAULT_MEMORY_ALIGNMENT) == 0);
+	return std::max((uint)(sizeof(CNode) - aligned_offsetof(CNode, Next)),
+		(uint)(Allocator->getNumBytesPerBlock())) + aligned_offsetof(CNode, Next);
 }
 
 // *****************************************************************************************************************
@@ -105,7 +112,7 @@ CFixedSizeAllocator::CChunk::~CChunk()
 	nlassert(NumFreeObjs == 0);
 	nlassert(Allocator->_NumChunks > 0);
 	-- (Allocator->_NumChunks);
-	delete[] Mem;
+	aligned_free(Mem); //delete[] Mem;
 }
 
 // *****************************************************************************************************************
@@ -115,7 +122,7 @@ void CFixedSizeAllocator::CChunk::init(CFixedSizeAllocator *alloc)
 	nlassert(alloc != NULL);
 	Allocator = alloc;
 	//
-	Mem = new uint8[getBlockSizeWithOverhead() * alloc->getNumBlockPerChunk()];
+	Mem = (uint8 *)aligned_malloc(getBlockSizeWithOverhead() * alloc->getNumBlockPerChunk(), NL_DEFAULT_MEMORY_ALIGNMENT); // new uint8[getBlockSizeWithOverhead() * alloc->getNumBlockPerChunk()];
 	//
 	getNode(0).Chunk = this;
 	getNode(0).Next = &getNode(1);
@@ -179,7 +186,7 @@ void *CFixedSizeAllocator::CNode::unlink()
 	*Prev = Next;
 	nlassert(Chunk->NumFreeObjs > 0);
 	Chunk->grab(); // tells the containing chunk that a node has been allocated
-	return (void *) &Next;
+	return (void *)((uintptr_t)(this) + aligned_offsetof(CNode, Next)); //(void *) &Next;
 }
 
 // *****************************************************************************************************************

code/nel/src/misc/log.cpp

@@ -19,7 +19,9 @@
 #include "nel/misc/log.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <process.h>
 #	include <windows.h>
 #else

code/nel/src/misc/matrix.cpp

@@ -140,6 +140,7 @@ inline void CMatrix::testExpandRot() const
 		self->Scale33= 1;
 	}
 }
+
 inline void CMatrix::testExpandProj() const
 {
 	if(hasProj())

code/nel/src/misc/mem_displayer.cpp

@@ -24,7 +24,9 @@
 #include "nel/misc/debug.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <imagehlp.h>
 #	pragma comment(lib, "imagehlp.lib")
@@ -148,7 +150,11 @@ static string getSourceInfo (DWORD_TYPE addr)
 	return str;
 }
 
-static DWORD_TYPE __stdcall GetModuleBase(HANDLE hProcess, DWORD_TYPE dwReturnAddress)
+#ifdef NL_OS_WIN64
+static DWORD64 __stdcall GetModuleBase(HANDLE hProcess, DWORD64 dwReturnAddress)
+#else
+static DWORD __stdcall GetModuleBase(HANDLE hProcess, DWORD dwReturnAddress)
+#endif
 {
 	IMAGEHLP_MODULE moduleInfo;
 
@@ -169,9 +175,15 @@ static DWORD_TYPE __stdcall GetModuleBase(HANDLE hProcess, DWORD_TYPE dwReturnAd
 
 		if (cch && (lstrcmp(szFile, "DBFN")== 0))
 		{
-			 if (!SymLoadModule(hProcess,
+			char mn[] = { 'M', 'N', 0x00 };
-				   NULL, "MN",
+#ifdef NL_OS_WIN64
-				   NULL, (DWORD) memoryBasicInfo.AllocationBase, 0))
+			if (!SymLoadModule64(
+#else
+			if (!SymLoadModule(
+#endif
+					hProcess,
+					NULL, mn,
+					NULL, (uintptr_t)memoryBasicInfo.AllocationBase, 0))
 				{
 //					DWORD dwError = GetLastError();
 //					nlinfo("Error: %d", dwError);
@@ -179,17 +191,23 @@ static DWORD_TYPE __stdcall GetModuleBase(HANDLE hProcess, DWORD_TYPE dwReturnAd
 		}
 		else
 		{
-		 if (!SymLoadModule(hProcess,
+#ifdef NL_OS_WIN64
-			   NULL, ((cch) ? szFile : NULL),
+			if (!SymLoadModule64(
-			   NULL, (DWORD) memoryBasicInfo.AllocationBase, 0))
+#else
+			if (!SymLoadModule(
+#endif
+				hProcess,
+				NULL, ((cch) ? szFile : NULL),
+				NULL, (uintptr_t)memoryBasicInfo.AllocationBase, 0))
 			{
 //				DWORD dwError = GetLastError();
 //				nlinfo("Error: %d", dwError);
 			 }
 
+
 		}
 
-		 return (DWORD) memoryBasicInfo.AllocationBase;
+		 return (uintptr_t)memoryBasicInfo.AllocationBase;
 	  }
 //		else
 //			nlinfo("Error is %d", GetLastError());
@@ -250,19 +268,13 @@ static void displayCallStack (CLog *log)
 		return;
 	}
 
-#ifdef NL_OS_WIN64
+	// FIXME: Implement this for MinGW
-	WOW64_CONTEXT context;
+#ifndef NL_COMP_MINGW
-#else
 	CONTEXT context;
-#endif
 	::ZeroMemory (&context, sizeof(context));
 	context.ContextFlags = CONTEXT_FULL;
 
-#ifdef NL_OS_WIN64
-	if (Wow64GetThreadContext (GetCurrentThread(), &context) == FALSE)
-#else
 	if (GetThreadContext (GetCurrentThread(), &context) == FALSE)
-#endif
 	{
 		nlwarning ("DISP: GetThreadContext(%p) failed", GetCurrentThread());
 		return;
@@ -283,12 +295,13 @@ static void displayCallStack (CLog *log)
 
 #ifdef NL_OS_WIN64
 		MachineType = IMAGE_FILE_MACHINE_AMD64;
+		BOOL res = StackWalk64(MachineType, GetCurrentProcess(), GetCurrentThread(), &callStack,
+			NULL, NULL, SymFunctionTableAccess, GetModuleBase, NULL);
 #else
 		MachineType = IMAGE_FILE_MACHINE_I386;
-#endif
+		BOOL res = StackWalk(MachineType, GetCurrentProcess(), GetCurrentThread(), &callStack,
-
-		BOOL res = StackWalk (MachineType, GetCurrentProcess(), GetCurrentThread(), &callStack,
 			NULL, NULL, SymFunctionTableAccess, GetModuleBase, NULL);
+#endif
 
 /*		if (res == FALSE)
 		{
@@ -309,6 +322,7 @@ static void displayCallStack (CLog *log)
 
 		log->displayNL ("   %s : %s", srcInfo.c_str(), symInfo.c_str());
 	}
+#endif
 }
 
 #else // NL_OS_WINDOWS

code/nel/src/misc/object_arena_allocator.cpp

@@ -68,21 +68,23 @@ void *CObjectArenaAllocator::alloc(uint size)
 	if (size >= _MaxAllocSize)
 	{
 		// use standard allocator
-		uint8 *block = new uint8[size + sizeof(uint)]; // an additionnal uint is needed to store size of block
+		nlctassert(NL_DEFAULT_MEMORY_ALIGNMENT >= sizeof(uint));
+		uint8 *block = (uint8 *)aligned_malloc(NL_DEFAULT_MEMORY_ALIGNMENT + size, NL_DEFAULT_MEMORY_ALIGNMENT); //new uint8[size + sizeof(uint)]; // an additionnal uint is needed to store size of block
 		if (!block) return NULL;
 		#ifdef NL_DEBUG
 			_MemBlockToAllocID[block] = _AllocID;
 		#endif
 		*(uint *) block = size;
-		return block + sizeof(uint);
+		return block + NL_DEFAULT_MEMORY_ALIGNMENT;
 	}
 	uint entry = ((size + (_Granularity - 1)) / _Granularity) ;
 	nlassert(entry < _ObjectSizeToAllocator.size());
 	if (!_ObjectSizeToAllocator[entry])
 	{
-		_ObjectSizeToAllocator[entry] = new CFixedSizeAllocator(entry * _Granularity + sizeof(uint), _MaxAllocSize / size); // an additionnal uint is needed to store size of block
+		_ObjectSizeToAllocator[entry] = new CFixedSizeAllocator(entry * _Granularity + NL_DEFAULT_MEMORY_ALIGNMENT, _MaxAllocSize / size); // an additionnal uint is needed to store size of block
 	}
 	void *block = _ObjectSizeToAllocator[entry]->alloc();
+	nlassert(((uintptr_t)block % NL_DEFAULT_MEMORY_ALIGNMENT) == 0);
 	#ifdef NL_DEBUG
 		if (block)
 		{
@@ -91,14 +93,14 @@ void *CObjectArenaAllocator::alloc(uint size)
 		++_AllocID;
 	#endif
 	*(uint *) block = size;
-	return (void *) ((uint8 *) block + sizeof(uint));
+	return (void *) ((uint8 *) block + NL_DEFAULT_MEMORY_ALIGNMENT);
 }
 
 // *****************************************************************************************************************
 void CObjectArenaAllocator::free(void *block)
 {
 	if (!block) return;
-	uint8 *realBlock = (uint8 *) block - sizeof(uint); // a uint is used at start of block to give its size
+	uint8 *realBlock = (uint8 *) block - NL_DEFAULT_MEMORY_ALIGNMENT; // sizeof(uint); // a uint is used at start of block to give its size
 	uint size = *(uint *) realBlock;
 	if (size >= _MaxAllocSize)
 	{
@@ -107,7 +109,7 @@ void CObjectArenaAllocator::free(void *block)
 				nlassert(it != _MemBlockToAllocID.end());
 				_MemBlockToAllocID.erase(it);
 		#endif
-		delete realBlock;
+		aligned_free(realBlock);
 		return;
 	}
 	uint entry = ((size + (_Granularity - 1)) / _Granularity);

code/nel/src/misc/path.cpp

@@ -25,7 +25,9 @@
 #include "nel/misc/xml_pack.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <sys/types.h>
 #	include <sys/stat.h>

code/nel/src/misc/report.cpp

@@ -23,7 +23,9 @@
 #include "nel/misc/path.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <windowsx.h>
 #	include <winuser.h>
@@ -157,8 +159,10 @@ static LRESULT CALLBACK WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM
 				// if the dtor call order is not good.
 				//exit(EXIT_SUCCESS);
 #ifdef NL_OS_WINDOWS
+#ifndef NL_COMP_MINGW
 				// disable the Windows popup telling that the application aborted and disable the dr watson report.
 				_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+#endif
 #endif
 				// quit without calling atexit or static object dtors.
 				abort();
@@ -232,7 +236,7 @@ TReportResult report (const std::string &title, const std::string &header, const
 
 	// create the edit control
 	HWND edit = CreateWindowW (L"EDIT", NULL, WS_BORDER | WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL | ES_READONLY | ES_LEFT | ES_MULTILINE, 7, 70, 429, 212, dialog, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(dialog, GWLP_HINSTANCE), NULL);
-	SendMessage (edit, WM_SETFONT, (LONG) font, TRUE);
+	SendMessage (edit, WM_SETFONT, (WPARAM) font, TRUE);
 
 	// set the edit text limit to lot of :)
 	SendMessage (edit, EM_LIMITTEXT, ~0U, 0);
@@ -246,7 +250,7 @@ TReportResult report (const std::string &title, const std::string &header, const
 	{
 		// create the combo box control
 		checkIgnore = CreateWindowW (L"BUTTON", L"Don't display this report again", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | BS_CHECKBOX, 7, 290, 429, 18, dialog, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(dialog, GWLP_HINSTANCE), NULL);
-		SendMessage (checkIgnore, WM_SETFONT, (LONG) font, TRUE);
+		SendMessage (checkIgnore, WM_SETFONT, (WPARAM) font, TRUE);
 
 		if(ignoreNextTime)
 		{
@@ -256,28 +260,28 @@ TReportResult report (const std::string &title, const std::string &header, const
 
 	// create the debug button control
 	debug = CreateWindowW (L"BUTTON", L"Debug", WS_CHILD | WS_VISIBLE, 7, 315, 75, 25, dialog, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(dialog, GWLP_HINSTANCE), NULL);
-	SendMessage (debug, WM_SETFONT, (LONG) font, TRUE);
+	SendMessage (debug, WM_SETFONT, (WPARAM) font, TRUE);
 
 	if (debugButton == 0)
 		EnableWindow(debug, FALSE);
 
 	// create the ignore button control
 	ignore = CreateWindowW (L"BUTTON", L"Ignore", WS_CHILD | WS_VISIBLE, 75+7+7, 315, 75, 25, dialog, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(dialog, GWLP_HINSTANCE), NULL);
-	SendMessage (ignore, WM_SETFONT, (LONG) font, TRUE);
+	SendMessage (ignore, WM_SETFONT, (WPARAM) font, TRUE);
 
 	if (ignoreButton == 0)
 		EnableWindow(ignore, FALSE);
 
 	// create the quit button control
 	quit = CreateWindowW (L"BUTTON", L"Quit", WS_CHILD | WS_VISIBLE, 75+75+7+7+7, 315, 75, 25, dialog, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(dialog, GWLP_HINSTANCE), NULL);
-	SendMessage (quit, WM_SETFONT, (LONG) font, TRUE);
+	SendMessage (quit, WM_SETFONT, (WPARAM) font, TRUE);
 
 	if (quitButton == 0)
 		EnableWindow(quit, FALSE);
 
 	// create the debug button control
 	sendReport = CreateWindowW (L"BUTTON", L"Don't send the report", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 7, 315+32, 429, 18, dialog, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(dialog, GWLP_HINSTANCE), NULL);
-	SendMessage (sendReport, WM_SETFONT, (LONG) font, TRUE);
+	SendMessage (sendReport, WM_SETFONT, (WPARAM) font, TRUE);
 
 	string formatedHeader;
 	if (header.empty())
@@ -302,7 +306,7 @@ TReportResult report (const std::string &title, const std::string &header, const
 
 	// create the label control
 	HWND label = CreateWindowW (L"STATIC", (LPCWSTR)uc.c_str(), WS_CHILD | WS_VISIBLE /*| SS_WHITERECT*/, 7, 7, 429, 51, dialog, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(dialog, GWLP_HINSTANCE), NULL);
-	SendMessage (label, WM_SETFONT, (LONG) font, TRUE);
+	SendMessage (label, WM_SETFONT, (WPARAM) font, TRUE);
 
 
 	DebugDefaultBehavior = debugButton==1;

code/nel/src/misc/shared_memory.cpp

@@ -20,7 +20,9 @@
 #include "nel/misc/debug.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #else
 #	include <sys/types.h>

code/nel/src/misc/stdmisc.h

@@ -43,9 +43,11 @@
 #include <vector>
 
 #ifdef _WIN32
-	#define NOMINMAX
+#	ifndef __MINGW32__
-	#include <WinSock2.h>
+		#define NOMINMAX
-	#include <windows.h>
+#	endif
+#	include <WinSock2.h>
+#	include <windows.h>
 #endif
 
 #endif // NL_STDMISC_H

code/nel/src/misc/system_info.cpp

@@ -19,7 +19,9 @@
 #include "nel/misc/system_info.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <WinNT.h>
 #	include <tchar.h>
@@ -1322,7 +1324,8 @@ bool CSystemInfo::getVideoInfo (std::string &deviceName, uint64 &driverVersion)
 											{
 												VS_FIXEDFILEINFO *info;
 												UINT len;
-												if (_VerQueryValue(&buffer[0], "\\", (VOID**)&info, &len))
+												char bslash[] = { '\\', 0x00 };
+												if (_VerQueryValue(&buffer[0], bslash, (VOID**)&info, &len))
 												{
 													driverVersion = (((uint64)info->dwFileVersionMS)<<32)|info->dwFileVersionLS;
 													return true;

code/nel/src/misc/system_utils.cpp

@@ -18,7 +18,9 @@
 #include "nel/misc/system_utils.h"
 
 #ifdef NL_OS_WINDOWS
-	#define NOMINMAX
+	#ifndef NL_COMP_MINGW
+		#define NOMINMAX
+	#endif
 	#include <windows.h>
 
 	#ifdef _WIN32_WINNT_WIN7
@@ -222,7 +224,7 @@ bool CSystemUtils::supportUnicode()
 bool CSystemUtils::isAzertyKeyboard()
 {
 #ifdef NL_OS_WINDOWS
-	uint16 klId = uint16((uint32)GetKeyboardLayout(0) & 0xFFFF);
+	uint16 klId = uint16((uintptr_t)GetKeyboardLayout(0) & 0xFFFF);
 	// 0x040c is French, 0x080c is Belgian
 	if (klId == 0x040c || klId == 0x080c)
 		return true;
@@ -312,7 +314,8 @@ bool CSystemUtils::setRegKey(const string &ValueName, const string &Value)
 	HKEY hkey;
 	DWORD dwDisp;
 
-	if (RegCreateKeyExA(HKEY_CURRENT_USER, RootKey.c_str(), 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDisp) == ERROR_SUCCESS)
+	char nstr[] = { 0x00 };
+	if (RegCreateKeyExA(HKEY_CURRENT_USER, RootKey.c_str(), 0, nstr, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDisp) == ERROR_SUCCESS)
 	{
 		if (RegSetValueExA(hkey, ValueName.c_str(), 0L, REG_SZ, (const BYTE *)Value.c_str(), (DWORD)(Value.size())+1) == ERROR_SUCCESS)
 			res = true;

code/nel/src/misc/tds.cpp

@@ -20,7 +20,9 @@
 #include "nel/misc/debug.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #endif // NL_OS_WINDOWS
 

code/nel/src/misc/time_nl.cpp

@@ -21,7 +21,9 @@
 #include "nel/misc/thread.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #elif defined (NL_OS_UNIX)
 #	include <sys/time.h>

code/nel/src/misc/win_displayer.cpp

@@ -18,8 +18,9 @@
 #include "nel/misc/win_displayer.h"
 
 #ifdef NL_OS_WINDOWS
-
+#ifndef NL_COMP_MINGW
-#define NOMINMAX
+#	define NOMINMAX
+#endif
 #include <windows.h>
 #include <windowsx.h>
 #include <winuser.h>
@@ -263,7 +264,7 @@ void CWinDisplayer::updateLabels ()
 					{
 						access.value()[i].Hwnd = CreateWindowW (L"STATIC", L"", WS_CHILD | WS_VISIBLE | SS_SIMPLE, 0, 0, 0, 0, _HWnd, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(_HWnd, GWLP_HINSTANCE), NULL);
 					}
-					SendMessage ((HWND)access.value()[i].Hwnd, WM_SETFONT, (LONG) _HFont, TRUE);
+					SendMessage ((HWND)access.value()[i].Hwnd, WM_SETFONT, (WPARAM)_HFont, TRUE);
 					needResize = true;
 				}
 
@@ -285,7 +286,7 @@ void CWinDisplayer::updateLabels ()
 					}
 				}
 
-				SendMessage ((HWND)access.value()[i].Hwnd, WM_SETTEXT, 0, (LONG) n.c_str());
+				SendMessage ((HWND)access.value()[i].Hwnd, WM_SETTEXT, 0, (LPARAM) n.c_str());
 				access.value()[i].NeedUpdate = false;
 			}
 		}
@@ -422,7 +423,7 @@ void CWinDisplayer::open (string titleBar, bool iconified, sint x, sint y, sint
 		dwStyle |= WS_HSCROLL;
 
 	_HEdit = CreateWindowExW(WS_EX_OVERLAPPEDWINDOW, RICHEDIT_CLASSW, L"", dwStyle, 0, _ToolBarHeight, w, h-_ToolBarHeight-_InputEditHeight, _HWnd, (HMENU) NULL, (HINSTANCE) GetWindowLongPtr(_HWnd, GWLP_HINSTANCE), NULL);
-	SendMessage (_HEdit, WM_SETFONT, (LONG) _HFont, TRUE);
+	SendMessage (_HEdit, WM_SETFONT, (WPARAM)_HFont, TRUE);
 
 	// set the edit text limit to lot of :)
 	SendMessage (_HEdit, EM_LIMITTEXT, -1, 0);
@@ -436,7 +437,7 @@ void CWinDisplayer::open (string titleBar, bool iconified, sint x, sint y, sint
 	_HInputEdit = CreateWindowExW(WS_EX_OVERLAPPEDWINDOW, RICHEDIT_CLASSW, L"", WS_CHILD | WS_VISIBLE
 		/*| ES_MULTILINE*/ | ES_WANTRETURN | ES_NOHIDESEL | ES_AUTOHSCROLL, 0, h-_InputEditHeight, w, _InputEditHeight,
 		_HWnd, NULL, (HINSTANCE) GetWindowLongPtr(_HWnd, GWLP_HINSTANCE), NULL);
-	SendMessageW (_HInputEdit, WM_SETFONT, (LONG) _HFont, TRUE);
+	SendMessageW (_HInputEdit, WM_SETFONT, (WPARAM)_HFont, TRUE);
 
 	LRESULT dwEvent = SendMessageW(_HInputEdit, EM_GETEVENTMASK, (WPARAM)0, (LPARAM)0);
 	dwEvent |= ENM_MOUSEEVENTS | ENM_KEYEVENTS | ENM_CHANGE;
@@ -486,7 +487,7 @@ void CWinDisplayer::clear ()
 	SendMessageW (_HEdit, EM_SETSEL, 0, nIndex);
 
 	// clear all the text
-	SendMessageW (_HEdit, EM_REPLACESEL, FALSE, (LONG) "");
+	SendMessageW (_HEdit, EM_REPLACESEL, FALSE, (LPARAM) "");
 
 	SendMessageW(_HEdit,EM_SETMODIFY,(WPARAM)TRUE,(LPARAM)0);
 
@@ -535,7 +536,7 @@ void CWinDisplayer::display_main ()
 
 				// store old selection
 				DWORD startSel, endSel;
-				SendMessage (_HEdit, EM_GETSEL, (LONG)&startSel, (LONG)&endSel);
+				SendMessage (_HEdit, EM_GETSEL, (WPARAM)&startSel, (LPARAM)&endSel);
 
 				// find how many lines we have to remove in the current output to add new lines
 
@@ -549,7 +550,7 @@ void CWinDisplayer::display_main ()
 
 					if (nblineremove == _HistorySize)
 					{
-						SendMessage (_HEdit, WM_SETTEXT, 0, (LONG) "");
+						SendMessage (_HEdit, WM_SETTEXT, 0, (LPARAM) "");
 						startSel = endSel = -1;
 					}
 					else
@@ -559,7 +560,7 @@ void CWinDisplayer::display_main ()
 						LRESULT oldIndex2 = SendMessageW (_HEdit, EM_LINEINDEX, nblineremove, 0);
 						//nlassert (oldIndex2 != -1);
 						SendMessageW (_HEdit, EM_SETSEL, oldIndex1, oldIndex2);
-						SendMessageW (_HEdit, EM_REPLACESEL, FALSE, (LONG) "");
+						SendMessageW (_HEdit, EM_REPLACESEL, FALSE, (LPARAM) "");
 
 						// update the selection due to the erasing
 						sint dt = (sint)(oldIndex2 - oldIndex1);
@@ -599,7 +600,7 @@ void CWinDisplayer::display_main ()
 					}
 
 					// add the string to the edit control
-					SendMessageW (_HEdit, EM_REPLACESEL, FALSE, (LONG) str.c_str());
+					SendMessageW (_HEdit, EM_REPLACESEL, FALSE, (LPARAM) str.c_str());
 				}
 
 				// restore old selection

code/nel/src/misc/win_event_emitter.cpp

@@ -22,7 +22,9 @@
 #include "nel/misc/event_server.h"
 
 #ifdef NL_OS_WINDOWS
+#ifndef NL_COMP_MINGW
 #define NOMINMAX
+#endif
 #include <windows.h>
 #include <windowsx.h>
 

code/nel/src/net/buf_client.cpp

@@ -24,7 +24,9 @@
 #include "nel/net/net_log.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #elif defined NL_OS_UNIX
 #	include <netinet/in.h>

code/nel/src/net/buf_server.cpp

@@ -22,7 +22,9 @@
 #include "nel/net/net_log.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #elif defined NL_OS_UNIX
 #	include <unistd.h>

code/nel/src/net/buf_sock.cpp

@@ -25,7 +25,9 @@
 
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #elif defined NL_OS_UNIX
 #	include <netinet/in.h>

code/nel/src/net/listen_sock.cpp

@@ -22,7 +22,9 @@
 
 #ifdef NL_OS_WINDOWS
 
-#define NOMINMAX
+#ifndef NL_COMP_MINGW
+#	define NOMINMAX
+#endif
 #include <windows.h>
 typedef sint socklen_t;
 

code/nel/src/net/service.cpp

@@ -24,8 +24,10 @@
 // these defines is for IsDebuggerPresent(). it'll not compile on windows 95
 // just comment this and the IsDebuggerPresent to compile on windows 95
 #	define _WIN32_WINDOWS	0x0410
-#	define WINVER			0x0400
+#	ifndef NL_COMP_MINGW
-#	define NOMINMAX
+#		define WINVER			0x0400
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	include <direct.h>
 #elif defined NL_OS_UNIX

code/nel/src/net/sock.cpp

@@ -22,7 +22,9 @@
 #include "nel/misc/hierarchical_timer.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <winsock2.h>
 #	include <windows.h>
 #	define socklen_t int

code/nel/src/net/stdnet.h

@@ -17,7 +17,9 @@
 #include "nel/misc/types_nl.h"
 
 #ifdef NL_OS_WINDOWS
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <winsock2.h>
 #	include <windows.h>
 #endif // NL_OS_WINDOWS

code/nel/src/net/tcp_sock.cpp

@@ -21,7 +21,9 @@
 
 #ifdef NL_OS_WINDOWS
 #	include <winsock2.h>
-#	define NOMINMAX
+#	ifndef NL_COMP_MINGW
+#		define NOMINMAX
+#	endif
 #	include <windows.h>
 #	define socklen_t int
 #	define ERROR_NUM WSAGetLastError()