Fix windows build: warnings management

Also removes the use of 'this' to initialize base classes, which led to
a compiler warning on vs2010.

indra/CMakeLists.txt

@@ -30,7 +30,7 @@ include(BuildVersion)
 
 include(UnixInstall)
 
-set (DISABLE_FATAL_WARNINGS TRUE)
+set (DISABLE_FATAL_WARNINGS CACHE BOOL TRUE)
 
 if (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release CACHE STRING
@@ -53,6 +53,9 @@ add_subdirectory(${LIBS_OPEN_PREFIX}llcharacter)
 add_subdirectory(${LIBS_OPEN_PREFIX}llcommon)
 add_subdirectory(${LIBS_OPEN_PREFIX}llimage)
 add_subdirectory(${LIBS_OPEN_PREFIX}libopenjpeg)
+add_subdirectory(${LIBS_OPEN_PREFIX}libhacd)
+add_subdirectory(${LIBS_OPEN_PREFIX}libndhacd)
+add_subdirectory(${LIBS_OPEN_PREFIX}libpathing)
 add_subdirectory(${LIBS_OPEN_PREFIX}llimagej2coj)
 add_subdirectory(${LIBS_OPEN_PREFIX}llinventory)
 add_subdirectory(${LIBS_OPEN_PREFIX}llmath)

indra/aistatemachine/CMakeLists.txt

@@ -19,6 +19,7 @@ include_directories(
 
 set(aistatemachine_SOURCE_FILES
     aistatemachine.cpp
+    aistatemachinethread.cpp
     aitimer.cpp
     )
 
@@ -26,6 +27,7 @@ set(aistatemachine_HEADER_FILES
     CMakeLists.txt
 
     aistatemachine.h
+    aistatemachinethread.h
     aitimer.h
     )
 

indra/aistatemachine/aistatemachine.cpp

@@ -176,7 +176,7 @@ void AIStateMachine::idle(state_type current_run_state)
 // About thread safeness:
 //
 // The main thread initializes a statemachine and calls run, so a statemachine
-// runs in the main thread. However, it is allowed that a state calls idle()
+// runs in the main thread. However, it is allowed that a state calls idle(current_state)
 // and then allows one or more other threads to call cont() upon some
 // event (only once, of course, as idle() has to be called before cont()
 // can be called again-- and a non-main thread is not allowed to call idle()).

indra/aistatemachine/aistatemachine.h

@@ -264,7 +264,7 @@ class AIStateMachine {
 	//! Halt the state machine until cont() is called (not thread-safe).
 	void idle(void);
 
-	//! Halt the state machine until cont() is called, provided it is still in 'cur_run_state'.
+	//! Halt the state machine until cont() is called, provided it is still in 'current_run_state'.
 	void idle(state_type current_run_state);
 
 	//! Temporarily halt the state machine.

indra/aistatemachine/aistatemachinethread.cpp

@@ -0,0 +1,197 @@
+/**
+ * @file aistatemachinethread.cpp
+ * @brief Implementation of AIStateMachineThread
+ *
+ * Copyright (c) 2013, Aleric Inglewood.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution.
+ *
+ * CHANGELOG
+ *   and additional copyright holders.
+ *
+ *   23/01/2013
+ *   Initial version, written by Aleric Inglewood @ SL
+ */
+
+#include "linden_common.h"
+#include "aistatemachinethread.h"
+
+class AIStateMachineThreadBase::Thread : public LLThread {
+  private:
+	LLPointer<AIThreadImpl> mImpl;
+	bool mNeedCleanup;
+  public:
+	Thread(AIThreadImpl* impl) :
+#ifdef LL_DEBUG
+	  LLThread(impl->getName()),
+#else
+	  LLThread("AIStateMachineThreadBase::Thread"),
+#endif
+	  mImpl(impl) { }
+  protected:
+	/*virtual*/ void run(void)
+	{
+	  mNeedCleanup = mImpl->thread_done(mImpl->run());
+	}
+	/*virtual*/ void terminated(void)
+	{
+	  mStatus = STOPPED;
+	  if (mNeedCleanup)
+	  {
+		// The state machine that started us has disappeared! Clean up ourselves.
+
+		// This is OK now because in our case nobody is watching us and having set
+		// the status to STOPPED didn't change anything really, although it will
+		// prevent LLThread::shutdown from blocking a whole minute and then calling
+		// apr_thread_exit to never return! Normally, the LLThread might be deleted
+		// immediately (by the main thread) after setting mStatus to STOPPED.
+		Thread::completed(this);
+	  }
+	}
+  public:
+	// TODO: Implement a thread pool. For now, just create a new one every time.
+	static Thread* allocate(AIThreadImpl* impl) { return new Thread(impl); }
+	static void completed(Thread* threadp) { delete threadp; }
+};
+
+// MAIN THREAD
+
+char const* AIStateMachineThreadBase::state_str_impl(state_type run_state) const
+{
+  switch(run_state)
+  {
+	AI_CASE_RETURN(start_thread);
+	AI_CASE_RETURN(wait_stopped);
+  }
+  return "UNKNOWN STATE";
+}
+
+void AIStateMachineThreadBase::initialize_impl(void)
+{
+  mThread = NULL;
+  mAbort = false;
+  set_state(start_thread);
+}
+
+void AIStateMachineThreadBase::multiplex_impl(void)
+{
+  switch(mRunState)
+  {
+	case start_thread:
+	  mThread = Thread::allocate(mImpl);
+	  // Set next state.
+	  set_state(wait_stopped);
+	  idle(wait_stopped);		// Wait till the thread returns.
+	  mThread->start();
+	  break;
+	case wait_stopped:
+	  if (!mThread->isStopped())
+		break;
+	  // We're done!
+	  //
+	  // We can only get here when AIThreadImpl::done called cont(), (very
+	  // shortly after which it will be STOPPED), which means we need to do
+	  // the clean up of the thread.
+	  // Also, the thread has really stopped now, so it's safe to delete it.
+	  //
+	  // Clean up the thread.
+	  Thread::completed(mThread);
+	  mThread = NULL;			// Stop abort_impl() from doing anything.
+	  if (mAbort)
+		abort();
+	  else
+		finish();
+	  break;
+  }
+}
+
+void AIStateMachineThreadBase::abort_impl(void)
+{
+  if (mThread)
+  {
+	// If this AIStateMachineThreadBase still exists then the first base class of
+	// AIStateMachineThread<THREAD_IMPL>, LLPointer<THREAD_IMPL>, also still exists
+	// and therefore mImpl is valid.
+	bool need_cleanup = mImpl->state_machine_done(mThread);		// Signal the fact that we aborted.
+	if (need_cleanup)
+	{
+	  // This is an unlikely race condition. We have been aborted by our parent,
+	  // but at the same time the thread finished!
+	  // We can only get here when AIThreadImpl::thread_done already returned
+	  // (VERY shortly after the thread will stop (if not already)).
+	  // Just go into a tight loop while waiting for that, when it is safe
+	  // to clean up the thread.
+	  while (!mThread->isStopped())
+	  {
+		mThread->yield();
+	  }
+	  Thread::completed(mThread);
+	}
+	else
+	{
+	  // The thread is still happily running (and will clean up itself).
+	  // Lets make sure we're not flooded with this situation.
+	  llwarns << "Thread state machine aborted while the thread is still running. That is a waste of CPU and should be avoided." << llendl;
+	}
+  }
+}
+
+bool AIThreadImpl::state_machine_done(LLThread* threadp)
+{
+  StateMachineThread_wat state_machine_thread_w(mStateMachineThread);
+  AIStateMachineThreadBase* state_machine_thread = *state_machine_thread_w;
+  bool need_cleanup = !state_machine_thread;
+  if (!need_cleanup)
+  {
+	// If state_machine_thread is non-NULL, then AIThreadImpl::thread_done wasnt called yet
+	// (or at least didn't return yet) which means the thread is still running.
+	// Try telling the thread that it can stop.
+	threadp->setQuitting();
+	// Finally, mark that we are NOT going to do the cleanup by setting mStateMachineThread to NULL.
+	*state_machine_thread_w = NULL;
+  }
+  return need_cleanup;
+}
+
+// AIStateMachineThread THREAD
+
+bool AIThreadImpl::thread_done(bool result)
+{
+  StateMachineThread_wat state_machine_thread_w(mStateMachineThread);
+  AIStateMachineThreadBase* state_machine_thread = *state_machine_thread_w;
+  bool need_cleanup = !state_machine_thread;
+  if (!need_cleanup)
+  {
+	// If state_machine_thread is non-NULL then AIThreadImpl::abort_impl wasn't called,
+	// which means the state machine still exists. In fact, it should be in the waiting() state.
+	// It can also happen that the state machine is being aborted right now (but it will still exist).
+	// (Note that waiting() and running() aren't strictly thread-safe (we should really lock
+	// mSetStateLock here) but by first calling waiting() and then running(), and assuming that
+	// changing an int from the value 1 to the value 2 is atomic, this will work since the
+	// only possible transition is from waiting to not running).
+	llassert(state_machine_thread->waiting() || !state_machine_thread->running());
+	state_machine_thread->schedule_abort(!result);
+	// Note that if the state machine is not running (being aborted, ie - hanging in abort_impl
+	// waiting for the lock on mStateMachineThread) then this is simply ignored.
+	state_machine_thread->cont();
+	// Finally, mark that we are NOT going to do the cleanup by setting mStateMachineThread to NULL.
+	*state_machine_thread_w = NULL;
+  }
+  return need_cleanup;
+}
+

indra/aistatemachine/aistatemachinethread.h

@@ -0,0 +1,229 @@
+/**
+ * @file aistatemachinethread.h
+ * @brief Run code in a thread.
+ *
+ * Copyright (c) 2013, Aleric Inglewood.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution.
+ *
+ * CHANGELOG
+ *   and additional copyright holders.
+ *
+ *   23/01/2013
+ *   Initial version, written by Aleric Inglewood @ SL
+ */
+
+#ifndef AISTATEMACHINETHREAD_H
+#define AISTATEMACHINETHREAD_H
+
+#include "aistatemachine.h"
+#include "llthread.h"
+#include "aithreadsafe.h"
+
+#ifdef EXAMPLE_CODE	// undefined
+
+class HelloWorldThread : public AIThreadImpl {
+  private:
+	bool mStdErr;		// input
+	bool mSuccess;		// output
+
+  public:
+	// Constructor.
+	HelloWorldThread(void) : AIThreadImpl("HelloWorldThread"),						// MAIN THREAD
+		mStdErr(false), mSuccess(false) { }
+
+	// Some initialization function (if needed).
+	void init(bool err)	{ mStdErr = err; }											// MAIN THREAD
+	// Read back output.
+	bool successful(void) const { return mSuccess; }
+
+	// Mandatory signature.
+	/*virtual*/ bool run(void)														// NEW THREAD
+	{
+	  if (mStdErr)
+		std::cerr << "Hello world" << std::endl;
+	  else
+		std::cout << "Hello world" << std::endl;
+	  mSuccess = true;
+	  return true;			// true = finish, false = abort.
+	}
+};
+
+// The states of this state machine.
+enum hello_world_state_type {
+  HelloWorld_start = AIStateMachine::max_state,
+  HelloWorld_done
+};
+
+// The statemachine class (this is almost a template).
+class HelloWorld : public AIStateMachine {
+  private:
+	AIStateMachineThread<HelloWorldThread> mHelloWorld;
+	bool mErr;
+
+  public:
+	HelloWorld() : mErr(false) { }
+
+	// Print to stderr or stdout?
+	void init(bool err) { mErr = err; }
+
+  protected:
+	// Call finish() (or abort()), not delete.
+	/*virtual*/ ~HelloWorld() { }
+
+	// Handle initializing the object.
+	/*virtual*/ void initialize_impl(void);
+
+	// Handle mRunState.
+	/*virtual*/ void multiplex_impl(void);
+
+	// Handle aborting from current bs_run state.
+	/*virtual*/ void abort_impl(void) { }
+
+	// Handle cleaning up from initialization (or post abort) state.
+	/*virtual*/ void finish_impl(void)
+	{
+	  // Kill object by default.
+	  // This can be overridden by calling run() from the callback function.
+	  kill();
+	}
+
+	// Implemenation of state_str for run states.
+	/*virtual*/ char const* state_str_impl(state_type run_state) const
+	{
+	  switch(run_state)
+	  {
+		AI_CASE_RETURN(HelloWorld_start);
+		AI_CASE_RETURN(HelloWorld_done);
+	  }
+	  return "UNKNOWN STATE";
+	}
+};
+
+// The actual implementation of this statemachine starts here!
+
+void HelloWorld::initialize_impl(void)
+{
+  mHelloWorld->init(mErr);							// Initialize the thread object.
+  set_state(HelloWorld_start);
+}
+
+void HelloWorld::multiplex_impl(void)
+{
+  switch (mRunState)
+  {
+	case HelloWorld_start:
+	{
+	  mHelloWorld.run(this, HelloWorld_done);		// Run HelloWorldThread and set the state of 'this' to HelloWorld_done when finished.
+	  idle(HelloWorld_start);						// Always go idle after starting a thread!
+	  break;
+	}
+	case HelloWorld_done:
+	{
+	  // We're done. Lets also abort when the thread reported no success.
+	  if (mHelloWorld->successful())				// Read output/result of thread object.
+		finish();
+	  else
+		abort();
+	  break;
+	}
+  }
+}
+
+#endif	// EXAMPLE CODE
+
+class AIStateMachineThreadBase;
+
+// Derive from this to implement the code that must run in another thread.
+class AIThreadImpl : public LLThreadSafeRefCount {
+  private:
+    template<typename THREAD_IMPL> friend struct AIStateMachineThread;
+	typedef AIAccess<AIStateMachineThreadBase*> StateMachineThread_wat;
+	AIThreadSafeSimpleDC<AIStateMachineThreadBase*> mStateMachineThread;
+
+  public:
+	virtual bool run(void) = 0;
+	bool thread_done(bool result);
+	bool state_machine_done(LLThread* threadp);
+
+#ifdef LL_DEBUG
+  private:
+	char const* mName;
+  protected:
+	AIThreadImpl(char const* name = "AIStateMachineThreadBase::Thread") : mName(name) { }
+  public:
+	char const* getName(void) const { return mName; }
+#endif
+};
+
+// The base class for statemachine threads.
+class AIStateMachineThreadBase : public AIStateMachine {
+  private:
+	// The actual thread (derived from LLThread).
+	class Thread;
+
+	// The states of this state machine.
+	enum thread_state_type {
+	  start_thread = AIStateMachine::max_state,		// Start the thread (if necessary create it first).
+	  wait_stopped									// Wait till the thread is stopped.
+	};
+
+  protected:
+	AIStateMachineThreadBase(AIThreadImpl* impl) : mImpl(impl) { }
+
+  private:
+	// Handle initializing the object.
+	/*virtual*/ void initialize_impl(void);
+
+	// Handle mRunState.
+	/*virtual*/ void multiplex_impl(void);
+
+	// Handle aborting from current bs_run state.
+	/*virtual*/ void abort_impl(void);
+
+	// Handle cleaning up from initialization (or post abort) state.
+	/*virtual*/ void finish_impl(void) { }
+
+	// Implemenation of state_str for run states.
+	/*virtual*/ char const* state_str_impl(state_type run_state) const;
+
+  private:
+	Thread* mThread;		// The thread that the code is run in.
+	AIThreadImpl* mImpl;	// Pointer to the implementation code that needs to be run in the thread.
+	bool mAbort;			// (Inverse of) return value of AIThreadImpl::run(). Only valid in state wait_stopped.
+
+  public:
+	void schedule_abort(bool do_abort) { mAbort = do_abort; }
+
+};
+
+// The state machine that runs T::run() in a thread.
+// THREAD_IMPL Must be derived from AIThreadImpl.
+template<typename THREAD_IMPL>
+struct AIStateMachineThread : public LLPointer<THREAD_IMPL>, public AIStateMachineThreadBase {
+  // Constructor.
+  AIStateMachineThread(void) :
+	  LLPointer<THREAD_IMPL>(new THREAD_IMPL),
+	  AIStateMachineThreadBase(LLPointer<THREAD_IMPL>::get())
+  {
+	*AIThreadImpl::StateMachineThread_wat(static_cast<AIThreadImpl*>(LLPointer<THREAD_IMPL>::get())->mStateMachineThread) = this;
+  }
+};
+
+#endif
+

indra/cmake/00-Common.cmake

@@ -23,28 +23,32 @@ set(CMAKE_CONFIGURATION_TYPES "RelWithDebInfo;Release;Debug" CACHE STRING
 # Platform-specific compilation flags.
 
 if (WINDOWS)
+  # Various libs are compiler specific, generate some variables here we can just use
+  # when we require them instead of reimplementing the test each time.
+  if (MSVC10)
+    set(MSVC_DIR 10.0)
+    set(MSVC_SUFFIX 100)
+  endif (MSVC10)
+
   # Remove default /Zm1000 flag that cmake inserts
   string (REPLACE "/Zm1000" " " CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
 
   # Don't build DLLs.
   set(BUILD_SHARED_LIBS OFF)
 
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /MDd /MP /arch:SSE2"
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /MDd /MP"
       CACHE STRING "C++ compiler debug options" FORCE)
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO 
-      "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Od /Zi /MD /MP /arch:SSE2"
+      "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Od /Zi /MD /MP"
       CACHE STRING "C++ compiler release-with-debug options" FORCE)
   set(CMAKE_CXX_FLAGS_RELEASE
-      "${CMAKE_CXX_FLAGS_RELEASE} ${LL_CXX_FLAGS} /O2 /Zi /MD /MP /arch:SSE2 /fp:fast"
+      "${CMAKE_CXX_FLAGS_RELEASE} ${LL_CXX_FLAGS} /O2 /Zi /MD /MP /fp:fast -D_SECURE_STL=0 -D_HAS_ITERATOR_DEBUGGING=0"
       CACHE STRING "C++ compiler release options" FORCE)
   set(CMAKE_C_FLAGS_RELEASE
-      "${CMAKE_C_FLAGS_RELEASE} ${LL_C_FLAGS} /O2 /Zi /MD /MP /arch:SSE2 /fp:fast"
+      "${CMAKE_C_FLAGS_RELEASE} ${LL_C_FLAGS} /O2 /Zi /MD /MP /fp:fast"
       CACHE STRING "C compiler release options" FORCE)
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE")
 
-  if(NOT CMAKE_EXE_LINKER_FLAGS_RELEASE MATCHES LARGEADDRESSAWARE)   
-    set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LARGEADDRESSAWARE")
-  endif()
-           
   set(CMAKE_CXX_STANDARD_LIBRARIES "")
   set(CMAKE_C_STANDARD_LIBRARIES "")
 
@@ -57,54 +61,25 @@ if (WINDOWS)
       /W3
       /c
       /Zc:forScope
+	  /Zc:wchar_t-
       /nologo
       /Oy-
+	  /arch:SSE2
       )
-     
+
   # configure win32 API for windows XP+ compatibility
   set(WINVER "0x0501" CACHE STRING "Win32 API Target version (see http://msdn.microsoft.com/en-us/library/aa383745%28v=VS.85%29.aspx)")
   add_definitions("/DWINVER=${WINVER}" "/D_WIN32_WINNT=${WINVER}")
 
-  if(MSVC80 OR MSVC90 OR MSVC10)
-    set(CMAKE_CXX_FLAGS_RELEASE
-      "${CMAKE_CXX_FLAGS_RELEASE} -D_SECURE_STL=0 -D_HAS_ITERATOR_DEBUGGING=0"
-      CACHE STRING "C++ compiler release options" FORCE)
-    set(CMAKE_C_FLAGS_RELEASE
-      "${CMAKE_C_FLAGS_RELEASE}" CACHE STRING "C compiler release options" FORCE)
-    add_definitions(
-      /Zc:wchar_t-
-      )
-  endif (MSVC80 OR MSVC90 OR MSVC10)
-  
   # Are we using the crummy Visual Studio KDU build workaround?
   if (NOT DISABLE_FATAL_WARNINGS)
     add_definitions(/WX)
   endif (NOT DISABLE_FATAL_WARNINGS)
-  
-  # Various libs are compiler specific, generate some variables here we can just use
-  # when we require them instead of reimplementing the test each time.
-  
-  if (MSVC71)
-    set(MSVC_DIR 7.1)
-    set(MSVC_SUFFIX 71)
-  elseif (MSVC80)
-    set(MSVC_DIR 8.0)
-    set(MSVC_SUFFIX 80)
-  elseif (MSVC90)
-    set(MSVC_DIR 9.0)
-    set(MSVC_SUFFIX 90)
-  elseif (MSVC10)
-    set(MSVC_DIR 10.0)
-    set(MSVC_SUFFIX 100)
-  endif (MSVC71)
 
-  if (MSVC10)
-    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
-    SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /MANIFEST:NO")
-    SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /MANIFEST:NO")
-  endif(MSVC10)
+  SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
+  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /MANIFEST:NO")
+  SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /MANIFEST:NO")
 
-    
 endif (WINDOWS)
 
 set (GCC_EXTRA_OPTIMIZATIONS "-ffast-math")

indra/cmake/CMakeLists.txt

@@ -36,6 +36,7 @@ set(cmake_SOURCE_FILES
     FMOD.cmake
     FMODEX.cmake
     FreeType.cmake
+    GLOD.cmake
     GStreamer010Plugin.cmake
     GooglePerfTools.cmake
     Hunspell.cmake
@@ -55,6 +56,7 @@ set(cmake_SOURCE_FILES
     LLMessage.cmake
     LLPlugin.cmake
     LLPrimitive.cmake
+    LLPhysicsExtensions.cmake
     LLQtWebkit.cmake
     LLRender.cmake
     LLScene.cmake

indra/cmake/Colladadom.cmake

@@ -0,0 +1,46 @@
+# -*- cmake -*-
+
+include(Prebuilt)
+
+set(COLLADADOM_FIND_QUIETLY OFF)
+set(COLLADADOM_FIND_REQUIRED ON)
+
+if (STANDALONE)
+  include (FindColladadom)
+else (STANDALONE)
+  use_prebuilt_binary(colladadom)
+
+  if (NOT WINDOWS)
+	use_prebuilt_binary(pcre)
+  endif (NOT WINDOWS)
+
+  if (NOT DARWIN AND NOT WINDOWS)
+	use_prebuilt_binary(libxml)
+  endif (NOT DARWIN AND NOT WINDOWS)
+
+  set(COLLADADOM_INCLUDE_DIRS
+	  ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/collada
+	  ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/collada/1.4
+	  )
+
+  if (WINDOWS)
+	  add_definitions(-DDOM_DYNAMIC)
+	  set(COLLADADOM_LIBRARIES 
+		  debug libcollada14dom22-d
+		  optimized libcollada14dom22
+		  debug libboost_filesystem-vc100-mt-gd-1_45.lib
+		  optimized libboost_filesystem-vc100-mt-1_45.lib
+		  debug libboost_system-vc100-mt-gd-1_45.lib
+		  optimized libboost_system-vc100-mt-1_45.lib
+		  )
+  else (WINDOWS)
+	  set(COLLADADOM_LIBRARIES 
+		  collada14dom
+		  minizip
+		  xml2
+		  pcrecpp
+		  pcre
+		  )
+  endif (WINDOWS)
+endif (STANDALONE)
+

indra/cmake/CopyWinLibs.cmake

@@ -31,6 +31,8 @@ set(debug_files
     libapriconv-1.dll
     libeay32.dll
     ssleay32.dll
+    libcollada14dom22-d.dll
+    glod.dll
     )
 
 copy_if_different(
@@ -210,6 +212,8 @@ set(release_files
     libapriconv-1.dll
     libeay32.dll
     ssleay32.dll
+    libcollada14dom22.dll
+    glod.dll
     )
 
 if(FMODEX)

indra/cmake/FindColladadom.cmake

@@ -0,0 +1,31 @@
+# -*- cmake -*-
+
+# - Find collada14dom
+# Find the colladadom version 1.4 includes and library
+# This module defines
+#  COLLADADOM_FOUND, System has libcollada14dom.so.
+#  COLLADADOM_INCLUDE_DIRS - The collada include directories.
+#  COLLADADOM_LIBRARIES - The libraries needed to use libcollada14dom.
+#  COLLADADOM_DEFINITIONS - Compiler switches required for using libcollada14dom.
+
+FIND_PACKAGE(PkgConfig)
+PKG_CHECK_MODULES(PC_COLLADADOM collada)
+SET(COLLADADOM_DEFINITIONS ${PC_COLLADADOM_CFLAGS_OTHER})
+
+FIND_PATH(COLLADADOM_INCLUDE_DIR dae.h
+  HINTS ${PC_COLLADADOM_INCLUDE_DIR} ${PC_COLLADADOM_INCLUDE_DIRS}
+  PATH_SUFFIXES collada)
+
+FIND_LIBRARY(COLLADADOM_LIBRARY
+  NAMES libcollada14dom.so
+  HINTS ${PC_COLLADADOM_LIBDIR} ${PC_COLLADADOM_LIBRARY_DIRS}
+  PATHS /usr/lib /usr/local/lib)
+
+SET(COLLADADOM_LIBRARIES ${COLLADADOM_LIBRARY})
+SET(COLLADADOM_INCLUDE_DIRS ${COLLADADOM_INCLUDE_DIR} ${COLLADADOM_INCLUDE_DIR}/1.4)
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(COLLADADOM DEFAULT_MSG
+  COLLADADOM_LIBRARY COLLADADOM_INCLUDE_DIR)
+
+MARK_AS_ADVANCED(COLLADADOM_LIBRARY COLLADADOM_INCLUDE_DIR)

indra/cmake/FindGLOD.cmake

@@ -0,0 +1,32 @@
+# -*- cmake -*-
+
+# - Find GLOD
+# Find the GLOD includes and library
+# This module defines
+#  GLOD_FOUND, System has libglod.so.
+#  GLOD_INCLUDE_DIRS - The GLOD include directories.
+#  GLOD_LIBRARIES - The libraries needed to use libglod.
+#  GLOD_DEFINITIONS - Compiler switches required for using libglod.
+
+FIND_PACKAGE(PkgConfig)
+PKG_CHECK_MODULES(PC_GLOD glod)
+SET(GLOD_DEFINITIONS ${PC_GLOD_CFLAGS_OTHER})
+
+FIND_PATH(GLOD_INCLUDE_DIR glod/glod.h
+  HINTS ${PC_GLOD_INCLUDE_DIR} ${PC_GLOD_INCLUDE_DIRS}
+  )
+
+FIND_LIBRARY(GLOD_LIBRARY
+  NAMES libGLOD.so
+  HINTS ${PC_GLOD_LIBDIR} ${PC_GLOD_LIBRARY_DIRS}
+  PATHS /usr/lib /usr/local/lib)
+
+SET(GLOD_LIBRARIES ${GLOD_LIBRARY})
+SET(GLOD_INCLUDE_DIRS ${GLOD_INCLUDE_DIR})
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLOD DEFAULT_MSG
+  GLOD_LIBRARY GLOD_INCLUDE_DIR)
+
+MARK_AS_ADVANCED(GLOD_LIBRARY GLOD_INCLUDE_DIR)
+

indra/cmake/GLOD.cmake

@@ -0,0 +1,13 @@
+# -*- cmake -*-
+include(Prebuilt)
+
+set(GLOD_FIND_QUIETLY OFF)
+set(GLOD_FIND_REQUIRED ON)
+
+if (STANDALONE)
+  include(FindGLOD)
+else (STANDALONE)
+  use_prebuilt_binary(GLOD)
+  set(GLOD_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include)
+  set(GLOD_LIBRARIES glod)
+endif (STANDALONE)

indra/cmake/LLPhysicsExtensions.cmake

@@ -0,0 +1,7 @@
+# -*- cmake -*-
+
+set(LLPHYSICSEXTENSIONS_LIBRARIES nd_hacdConvexDecomposition hacd nd_Pathing )
+set(LLPHYSICSEXTENSIONS_INCLUDE_DIRS ${LIBS_OPEN_DIR}/libndhacd )
+
+
+

indra/cmake/LLPrimitive.cmake

@@ -1,7 +1,22 @@
 # -*- cmake -*-
 
-set(LLPRIMITIVE_INCLUDE_DIRS
-    ${LIBS_OPEN_DIR}/llprimitive
-    )
+include(Colladadom)
+
+set(LLPRIMITIVE_INCLUDE_DIRS
+  ${LIBS_OPEN_DIR}/llprimitive
+  ${COLLADADOM_INCLUDE_DIRS}
+  )
+
+if (WINDOWS)
+  set(LLPRIMITIVE_LIBRARIES 
+	  debug llprimitive
+	  optimized llprimitive
+	  ${COLLADADOM_LIBRARIES}
+	  )
+else (WINDOWS)
+  set(LLPRIMITIVE_LIBRARIES 
+	  llprimitive
+	  ${COLLADADOM_LIBRARIES}
+	  )
+endif (WINDOWS)
 
-set(LLPRIMITIVE_LIBRARIES llprimitive)

indra/develop.py

@@ -473,26 +473,11 @@ class DarwinSetup(UnixSetup):
 
 class WindowsSetup(PlatformSetup):
     gens = {
-        'vc71' : {
-            'gen' : r'Visual Studio 7 .NET 2003',
-            'ver' : r'7.1'
-            },
-        'vc80' : {
-            'gen' : r'Visual Studio 8 2005',
-            'ver' : r'8.0'
-            },
-        'vc90' : {
-            'gen' : r'Visual Studio 9 2008',
-            'ver' : r'9.0'
-            },
         'vc100' : {
             'gen' : r'Visual Studio 10',
             'ver' : r'10.0'
             }
         }
-    gens['vs2003'] = gens['vc71']
-    gens['vs2005'] = gens['vc80']
-    gens['vs2008'] = gens['vc90']
     gens['vs2010'] = gens['vc100']
 
     search_path = r'C:\windows'
@@ -505,21 +490,21 @@ class WindowsSetup(PlatformSetup):
 
     def _get_generator(self):
         if self._generator is None:
-            for version in 'vc80 vc90 vc100 vc71'.split():
+            for version in 'vc100'.split():
                 if self.find_visual_studio(version):
                     self._generator = version
                     print 'Building with ', self.gens[version]['gen']
                     break
             else:
                 print >> sys.stderr, 'Cannot find a Visual Studio installation, testing for express editions'
-                for version in 'vc80 vc90 vc100 vc71'.split():
+                for version in 'vc100'.split():
                     if self.find_visual_studio_express(version):
                         self._generator = version
                         self.using_express = True
                         print 'Building with ', self.gens[version]['gen'] , "Express edition"
                         break
                 else:
-					for version in 'vc80 vc90 vc100 vc71'.split():
+					for version in 'vc100'.split():
 						if self.find_visual_studio_express_single(version):
 							self._generator = version
 							self.using_express = True
@@ -768,8 +753,7 @@ Options:
   -m32 | -m64           build architecture (32-bit or 64-bit)
   -N | --no-distcc      disable use of distcc
   -G | --generator=NAME generator name
-                        Windows: VC71 or VS2003 (default), VC80 (VS2005) 
-                          VC90 (VS2008), or VC100 (VS2010)
+                        Windows: VC100 (VS2010) (default)
                         Mac OS X: Xcode (default), Unix Makefiles
                         Linux: Unix Makefiles (default), KDevelop3
   -p | --project=NAME   set the root project name. (Doesn't effect makefiles)

indra/libhacd/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 2.6.4)
+
+project(libhacd CXX C)
+include(00-Common)
+
+file (GLOB SOURCE_FILES *.cpp )
+file (GLOB INCLUDE_FILES *.h )
+
+IF(WINDOWS)
+   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+ENDIF(WINDOWS)
+
+add_library(hacd ${SOURCE_FILES} ${INCLUDE_FILES})

indra/libhacd/hacdCircularList.h

@@ -0,0 +1,85 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_CIRCULAR_LIST_H
+#define HACD_CIRCULAR_LIST_H
+#include <stdlib.h>
+#include "hacdVersion.h"
+#include "hacdMicroAllocator.h"
+namespace HACD
+{
+	//!	CircularListElement class.
+	template < typename T > class CircularListElement
+	{
+    public:
+        T &                                     GetData() { return m_data; }
+        const T &                               GetData() const { return m_data; }
+        CircularListElement<T> * &				GetNext() { return m_next; }
+        CircularListElement<T> * &				GetPrev() { return m_prev; }
+        const CircularListElement<T> * &		GetNext() const { return m_next; }
+        const CircularListElement<T> * &		GetPrev() const { return m_prev; }        
+        //!	Constructor
+												CircularListElement(const T & data) {m_data = data;}
+												CircularListElement(void){}
+        //! Destructor
+												~CircularListElement(void){}
+    private:
+        T										m_data;
+        CircularListElement<T> *				m_next; 
+        CircularListElement<T> *				m_prev;
+
+												CircularListElement(const CircularListElement & rhs);
+	};
+    
+    
+	//!	CircularList class.
+	template < typename T > class CircularList
+	{
+	public:
+        HeapManager * const     				GetHeapManager() const { return m_heapManager;}
+		void									SetHeapManager(HeapManager * const heapManager) { m_heapManager = heapManager;}
+        CircularListElement<T> *  &             GetHead() { return m_head;}        
+		const CircularListElement<T> *          GetHead() const { return m_head;}
+		bool                                    IsEmpty() const { return (m_size == 0);}
+		size_t                                  GetSize() const { return m_size; }
+		const T &                               GetData() const { return m_head->GetData(); }        
+		T &                                     GetData() { return m_head->GetData();}
+		bool                                    Delete() ;
+        bool                                    Delete(CircularListElement<T> * element);
+		CircularListElement<T> *                Add(const T * data = 0);
+		CircularListElement<T> *                Add(const T & data);
+		bool                                    Next();
+		bool                                    Prev();
+		void									Clear() { while(Delete());};
+        const CircularList&						operator=(const CircularList& rhs);
+		//!	Constructor											
+												CircularList(HeapManager * heapManager)
+												{ 
+													m_head = 0; 
+													m_size = 0;
+                                                    m_heapManager = heapManager;
+												}
+												CircularList(const CircularList& rhs);
+		//! Destructor
+		virtual								    ~CircularList(void) {Clear();};
+	private:
+		CircularListElement<T> *				m_head;		//!< a pointer to the head of the circular list
+		size_t									m_size;		//!< number of element in the circular list
+        HeapManager *                           m_heapManager;
+        
+	};
+}
+#include "hacdCircularList.inl"
+#endif

indra/libhacd/hacdCircularList.inl

@@ -0,0 +1,230 @@
+#pragma once
+#ifndef HACD_CIRCULAR_LIST_INL
+#define HACD_CIRCULAR_LIST_INL
+#include <stdlib.h>
+#include "hacdVersion.h"
+namespace HACD
+{
+	template < typename T > 
+	inline bool CircularList<T>::Delete(CircularListElement<T> * element)
+	{
+        if (!element)
+        {
+            return false;
+        }
+		if (m_size > 1)
+		{
+			CircularListElement<T> * next = element->GetNext();
+			CircularListElement<T> * prev = element->GetPrev();
+            if (m_heapManager)
+            {
+				element->~CircularListElement<T>();
+                heap_free(m_heapManager, element);
+            }
+            else
+            {
+			    delete element;
+            }
+			m_size--;
+            if (element == m_head)
+            {
+                m_head = next;
+            }
+			next->GetPrev() = prev;
+			prev->GetNext() = next;
+			return true;
+		}
+		else if (m_size == 1)
+		{
+            if (m_heapManager)
+            {
+				element->~CircularListElement<T>();
+                heap_free(m_heapManager, m_head);
+            }
+            else
+            {
+			    delete m_head;
+            }
+			m_size--;
+			m_head = 0;
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+    
+	template < typename T > 
+	inline bool CircularList<T>::Delete()
+	{
+		if (m_size > 1)
+		{
+			CircularListElement<T> * next = m_head->GetNext();
+			CircularListElement<T> * prev = m_head->GetPrev();
+            if (m_heapManager)
+            {
+				m_head->~CircularListElement<T>();
+                heap_free(m_heapManager, m_head);
+            }
+            else
+            {
+			    delete m_head;
+            }
+			m_size--;
+			m_head = next;
+			next->GetPrev() = prev;
+			prev->GetNext() = next;
+			return true;
+		}
+		else if (m_size == 1)
+		{
+            if (m_heapManager)
+            {
+				m_head->~CircularListElement<T>();
+                heap_free(m_heapManager, m_head);
+            }
+            else
+            {
+			    delete m_head;
+            }
+            m_size--;
+			m_head = 0;
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+	template < typename T > 
+	inline CircularListElement<T> * CircularList<T>::Add(const T * data)
+	{
+		if (m_size == 0)
+		{
+			if (data)
+			{
+                if (m_heapManager)
+                {
+                    m_head = static_cast< CircularListElement<T> * > (heap_malloc(m_heapManager, sizeof(CircularListElement<T>)));
+                    m_head->GetData().Initialize();
+                    m_head->GetData() = (*data);
+                }
+                else
+                {
+				    m_head = new CircularListElement<T>(*data);
+                }
+			}
+			else
+			{
+                if (m_heapManager)
+                {
+                    m_head = static_cast< CircularListElement<T> * > (heap_malloc(m_heapManager, sizeof(CircularListElement<T>)));
+                    m_head->GetData().Initialize();
+                }
+                else
+                {
+    				m_head = new CircularListElement<T>();
+                }
+			}
+			m_head->GetNext() = m_head->GetPrev() = m_head;
+		}
+		else
+		{
+			CircularListElement<T> * next = m_head->GetNext();
+			CircularListElement<T> * element = m_head;
+			if (data)
+			{
+                if (m_heapManager)
+                {
+                    m_head = static_cast< CircularListElement<T> * > (heap_malloc(m_heapManager, sizeof(CircularListElement<T>)));
+                    m_head->GetData().Initialize();
+                    m_head->GetData() = (*data);
+                }
+                else
+                {
+				    m_head = new CircularListElement<T>(*data);
+                }
+			}
+			else
+			{
+                if (m_heapManager)
+                {
+                    m_head = static_cast< CircularListElement<T> * > (heap_malloc(m_heapManager, sizeof(CircularListElement<T>)));
+                    m_head->GetData().Initialize();
+                }
+                else
+                {
+    				m_head = new CircularListElement<T>();
+                }
+			}
+			m_head->GetNext() = next;
+			m_head->GetPrev() = element;
+			element->GetNext() = m_head;
+			next->GetPrev() = m_head;
+		}
+		m_size++;
+		return m_head;
+	}
+	template < typename T > 
+	inline CircularListElement<T> * CircularList<T>::Add(const T & data)
+	{
+		const T * pData = &data;
+		return Add(pData);
+	}
+	template < typename T > 
+	inline bool CircularList<T>::Next()
+	{
+		if (m_size == 0)
+		{
+			return false;
+		}
+		m_head = m_head->GetNext();
+		return true;
+	}
+	template < typename T > 
+	inline bool CircularList<T>::Prev()
+	{
+		if (m_size == 0)
+		{
+			return false;
+		}
+		m_head = m_head->GetPrev();
+		return true;
+	}
+	template < typename T > 
+	inline CircularList<T>::CircularList(const CircularList& rhs)
+	{
+		if (rhs.m_size > 0)
+		{
+			CircularListElement<T> * current = rhs.m_head;
+			do
+			{
+				current = current->GetNext();
+				Add(current->GetData());
+			}
+			while ( current != rhs.m_head );
+		}
+	}
+    template < typename T > 
+	inline const CircularList<T>& CircularList<T>::operator=(const CircularList& rhs)
+	{
+        if (&rhs != this)
+        {
+            Clear();
+            m_heapManager = rhs.m_heapManager;
+            if (rhs.m_size > 0)
+            {
+                CircularListElement<T> * current = rhs.m_head;
+                do
+                {
+                    current = current->GetNext();
+                    Add(current->GetData());
+                }
+                while ( current != rhs.m_head );
+            }
+        }
+        return (*this);
+	}
+}
+#endif

indra/libhacd/hacdGraph.cpp

@@ -0,0 +1,278 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "hacdGraph.h"
+namespace HACD
+{    
+    
+    GraphEdge::GraphEdge()
+    {
+        m_v1 = -1;
+        m_v2 = -1;
+		m_name = -1;
+        m_error = 0;
+        m_concavity = 0;
+        m_deleted = false;
+#ifdef HACD_PRECOMPUTE_CHULLS
+        m_convexHull = 0;
+#endif
+	}
+   
+    GraphVertex::GraphVertex()
+    {
+        m_convexHull = 0;
+		m_name = -1;
+        m_cc = -1;
+        m_concavity = 0;
+        m_surf = 0;
+        m_deleted = false;
+    }
+    
+    bool GraphVertex::DeleteEdge(long name)
+    {
+        return m_edges.Erase(name);
+    }
+
+    Graph::Graph()
+    {
+        m_nV = 0;
+        m_nE = 0;
+        m_nCCs = 0;
+    }
+    
+    Graph::~Graph()
+    {
+    }
+    
+	void Graph::Allocate(size_t nV, size_t nE)
+	{ 
+		m_nV = nV;
+		m_edges.reserve(nE);
+		m_vertices.resize(nV);
+		for(size_t i = 0; i < nV; i++)
+		{
+			m_vertices[i].m_name = static_cast<long>(i);
+		}
+	}
+
+    long Graph::AddVertex()
+    {
+		size_t name = m_vertices.size();
+		m_vertices.resize(name+1);
+        m_vertices[name].m_name = static_cast<long>(name);
+        m_nV++;
+        return static_cast<long>(name);
+    }
+    
+    long Graph::AddEdge(long v1, long v2)
+    {
+		size_t name = m_edges.size();
+		m_edges.push_back(GraphEdge());
+        m_edges[name].m_name = static_cast<long>(name);
+        m_edges[name].m_v1 = v1;
+        m_edges[name].m_v2 = v2;
+        m_vertices[v1].AddEdge(static_cast<long>(name));
+        m_vertices[v2].AddEdge(static_cast<long>(name));
+        m_nE++;
+		return static_cast<long>(name);
+    }
+
+    bool Graph::DeleteEdge(long name)
+    {
+		if (name < static_cast<long>(m_edges.size()))
+		{
+            long v1 = m_edges[name].m_v1;
+            long v2 = m_edges[name].m_v2;
+			m_edges[name].m_deleted = true;
+            m_vertices[v1].DeleteEdge(name);
+            m_vertices[v2].DeleteEdge(name);
+			m_nE--;
+			return true;
+		}
+		return false;
+    }
+    bool Graph::DeleteVertex(long name)
+    {
+		if (name < static_cast<long>(m_vertices.size()))
+		{
+			m_vertices[name].m_deleted = true;
+            m_vertices[name].m_edges.Clear();
+            m_vertices[name].m_ancestors = std::vector<long>();
+            delete m_vertices[name].m_convexHull;
+			m_vertices[name].m_distPoints.Clear();
+			m_vertices[name].m_boudaryEdges.Clear();
+            m_vertices[name].m_convexHull = 0;
+			m_nV--;
+			return true;
+		}
+		return false;
+    }    
+    bool Graph::EdgeCollapse(long v1, long v2)
+	{
+		long edgeToDelete = GetEdgeID(v1, v2);
+        if (edgeToDelete >= 0) 
+		{
+			// delete the edge (v1, v2)
+			DeleteEdge(edgeToDelete);
+			// add v2 to v1 ancestors
+            m_vertices[v1].m_ancestors.push_back(v2);
+			// add v2's ancestors to v1's ancestors
+			m_vertices[v1].m_ancestors.insert(m_vertices[v1].m_ancestors.begin(),
+											  m_vertices[v2].m_ancestors.begin(), 
+											  m_vertices[v2].m_ancestors.end());
+			// update adjacency information
+			SArray<long, SARRAY_DEFAULT_MIN_SIZE> & v1Edges =  m_vertices[v1].m_edges;
+			long b = -1;
+            long idEdge;
+			for(size_t ed = 0; ed < m_vertices[v2].m_edges.Size(); ++ed) 
+			{
+                idEdge = m_vertices[v2].m_edges[ed];
+				if (m_edges[idEdge].m_v1 == v2)
+				{
+					b = m_edges[idEdge].m_v2;
+				}
+				else
+				{
+					b = m_edges[idEdge].m_v1;
+				}
+				if (GetEdgeID(v1, b) >= 0)
+				{
+					m_edges[idEdge].m_deleted = true;
+					m_vertices[b].DeleteEdge(idEdge);
+					m_nE--;
+				}
+				else
+				{
+					m_edges[idEdge].m_v1 = v1;
+					m_edges[idEdge].m_v2 = b;
+					v1Edges.Insert(idEdge);
+				}
+			}
+			// delete the vertex v2
+            DeleteVertex(v2);			
+            return true;
+        }
+		return false;
+    }
+    
+    long Graph::GetEdgeID(long v1, long v2) const
+    {
+		if (v1 < static_cast<long>(m_vertices.size()) && !m_vertices[v1].m_deleted)
+		{
+            long idEdge;
+			for(size_t ed = 0; ed < m_vertices[v1].m_edges.Size(); ++ed) 
+			{
+                idEdge =  m_vertices[v1].m_edges[ed];
+				if ( (m_edges[idEdge].m_v1 == v2) || 
+					 (m_edges[idEdge].m_v2 == v2)   ) 
+				{
+					return m_edges[idEdge].m_name;
+				}
+			}
+		}
+        return -1;
+    }
+    
+	void Graph::Print() const
+	{
+		std::cout << "-----------------------------" << std::endl;
+        std::cout << "vertices (" << m_nV << ")" << std::endl;
+        for (size_t v = 0; v < m_vertices.size(); ++v) 
+		{
+			const GraphVertex & currentVertex = m_vertices[v];
+			if (!m_vertices[v].m_deleted)
+			{
+
+				std::cout  << currentVertex.m_name	  << "\t";
+				long idEdge;
+				for(size_t ed = 0; ed < currentVertex.m_edges.Size(); ++ed) 
+				{
+                    idEdge = currentVertex.m_edges[ed];
+					std::cout  << "(" << m_edges[idEdge].m_v1 << "," << m_edges[idEdge].m_v2 << ") "; 	  
+				}
+				std::cout << std::endl;
+			}			
+		}
+
+		std::cout << "vertices (" << m_nE << ")" << std::endl;
+		for (size_t e = 0; e < m_edges.size(); ++e) 
+		{
+			const GraphEdge & currentEdge = m_edges[e];
+			if (!m_edges[e].m_deleted)
+			{
+				std::cout  << currentEdge.m_name	  << "\t(" 
+						   << m_edges[e].m_v1		  << "," 
+						   << m_edges[e].m_v2		  << ") "<< std::endl;
+			}			
+		}
+	}
+	void Graph::Clear()
+	{
+		m_vertices.clear();
+		m_edges.clear();
+		m_nV = 0;
+        m_nE = 0;
+	}
+    
+    long Graph::ExtractCCs()
+	{
+        // all CCs to -1
+        for (size_t v = 0; v < m_vertices.size(); ++v) 
+		{
+			if (!m_vertices[v].m_deleted)
+			{
+				m_vertices[v].m_cc = -1;
+			}
+        }
+        
+        // we get the CCs
+        m_nCCs = 0;
+		long v2 = -1;
+        long idEdge;
+		std::vector<long> temp;
+        for (size_t v = 0; v < m_vertices.size(); ++v) 
+		{
+			if (!m_vertices[v].m_deleted && m_vertices[v].m_cc == -1) 
+			{
+                m_vertices[v].m_cc = static_cast<long>(m_nCCs);
+                temp.clear();
+                temp.push_back(m_vertices[v].m_name);
+                while (temp.size()) 
+				{
+                    long vertex = temp[temp.size()-1];
+                    temp.pop_back();                                        
+					for(size_t ed = 0; ed < m_vertices[vertex].m_edges.Size(); ++ed) 
+					{
+                        idEdge =  m_vertices[vertex].m_edges[ed];
+                        if (m_edges[idEdge].m_v1 == vertex) 
+						{
+                            v2 = m_edges[idEdge].m_v2;
+                        }
+                        else 
+						{
+                            v2 = m_edges[idEdge].m_v1;
+                        }
+                        if ( !m_vertices[v2].m_deleted && m_vertices[v2].m_cc == -1) 
+						{
+                            m_vertices[v2].m_cc = static_cast<long>(m_nCCs);
+                            temp.push_back(v2);
+                        }
+                    }
+                }
+                m_nCCs++;
+            }
+        }        
+        return static_cast<long>(m_nCCs);
+    }
+}

indra/libhacd/hacdGraph.h

@@ -0,0 +1,118 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_GRAPH_H
+#define HACD_GRAPH_H
+#include "hacdVersion.h"
+#include "hacdVector.h"
+#include "hacdICHull.h"
+#include <map>
+#include <vector>
+#include "hacdSArray.h"
+//#define HACD_PRECOMPUTE_CHULLS
+
+namespace HACD
+{
+    class GraphVertex;
+    class GraphEdge;
+    class Graph;
+	class HACD;
+       
+    class GraphVertex  
+    {
+    public:
+        bool                                                      AddEdge(long name) 
+                                                                  { 
+                                                                    m_edges.Insert(name); 
+                                                                    return true; 
+                                                                  }
+        bool                                                      DeleteEdge(long name);        
+                                                                  GraphVertex();
+                                                                  ~GraphVertex(){ delete m_convexHull;};      
+    private:
+        long                                                      m_name;
+        long                                                      m_cc;
+        SArray<long, SARRAY_DEFAULT_MIN_SIZE>                     m_edges;
+        bool                                                      m_deleted;
+        std::vector<long>	                                      m_ancestors;
+		SArray<DPoint, SARRAY_DEFAULT_MIN_SIZE>					  m_distPoints;
+
+        Real                                                      m_concavity;
+        double                                                    m_surf;
+        ICHull *                                                  m_convexHull;
+		SArray<unsigned long long, SARRAY_DEFAULT_MIN_SIZE>       m_boudaryEdges;
+        
+
+        friend class GraphEdge;
+        friend class Graph;
+		friend class HACD;
+    };
+    
+	class GraphEdge 
+    {
+    public:
+                                                                 GraphEdge();
+                                                                 ~GraphEdge()
+                                                                 {
+#ifdef HACD_PRECOMPUTE_CHULLS
+                                                                    delete m_convexHull;
+#endif
+                                                                 };
+    private:
+        long                                                     m_name;
+        long                                                     m_v1;
+        long                                                     m_v2;
+        double                                                   m_concavity;
+        Real                                                     m_error;
+#ifdef HACD_PRECOMPUTE_CHULLS
+        ICHull *                                                 m_convexHull;
+#endif
+        bool                                                     m_deleted;
+        
+        friend class GraphVertex;
+        friend class Graph;
+		friend class HACD;
+    };
+    
+    class Graph  
+    {
+    public:
+		size_t									                 GetNEdges() const { return m_nE;}
+		size_t									                 GetNVertices() const { return m_nV;}
+        bool                                                     EdgeCollapse(long v1, long v2);
+        long                                                     AddVertex();
+        long                                                     AddEdge(long v1, long v2);
+        bool                                                     DeleteEdge(long name);	
+        bool                                                     DeleteVertex(long name);
+        long                                                     GetEdgeID(long v1, long v2) const;
+		void									                 Clear();
+        void                                                     Print() const;
+        long                                                     ExtractCCs();
+        
+                                                                 Graph();
+        virtual                                                  ~Graph();      
+		void									                 Allocate(size_t nV, size_t nE);
+
+    private:
+        size_t                                                   m_nCCs;
+        size_t                                                   m_nV;
+        size_t                                                   m_nE;
+        std::vector<GraphEdge>                                   m_edges;
+        std::vector<GraphVertex>                                 m_vertices;
+
+		friend class HACD;
+    };
+}
+#endif

indra/libhacd/hacdHACD.h

@@ -0,0 +1,330 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_HACD_H
+#define HACD_HACD_H
+#include "hacdVersion.h"
+#include "hacdVector.h"
+#include "hacdGraph.h"
+#include "hacdICHull.h"
+#include <set>
+#include <vector>
+#include <queue>
+
+namespace HACD
+{
+    const double                                    sc_pi = 3.14159265;
+	class HACD;
+
+	// just to be able to set the capcity of the container
+	
+	template<class _Ty, class _Container = std::vector<_Ty>, class _Pr = std::less<typename _Container::value_type> >
+	class reservable_priority_queue: public std::priority_queue<_Ty, _Container, _Pr> 
+	{
+        typedef typename std::priority_queue<_Ty, _Container, _Pr>::size_type size_type;
+	public:
+                                                    reservable_priority_queue(size_type capacity = 0) { reserve(capacity); };
+		void										reserve(size_type capacity) { this->c.reserve(capacity); } 
+        size_type									capacity() const { return this->c.capacity(); } 
+	};
+	
+	//! priority queque element
+	class HACD;
+    class GraphEdgePriorityQueue
+    {
+		public:
+			//! Constructor
+			//! @param name edge's id
+			//! @param priority edge's priority
+													GraphEdgePriorityQueue(long name, Real priority)
+													{
+														m_name = name;
+														m_priority = priority;
+													}
+			//! Destructor
+													~GraphEdgePriorityQueue(void){}
+		private:
+			long									m_name;						//!< edge name
+			Real                                    m_priority;					//!< priority
+		//! Operator < for GraphEdgePQ
+        friend bool                                 operator<(const GraphEdgePriorityQueue & lhs, const GraphEdgePriorityQueue & rhs);
+		//! Operator > for GraphEdgePQ
+        friend bool                                 operator>(const GraphEdgePriorityQueue & lhs, const GraphEdgePriorityQueue & rhs);
+		friend class HACD;
+    };
+    inline bool										operator<(const GraphEdgePriorityQueue & lhs, const GraphEdgePriorityQueue & rhs)
+													{
+														return (lhs.m_priority<rhs.m_priority);
+													}
+    inline bool										operator>(const GraphEdgePriorityQueue & lhs, const GraphEdgePriorityQueue & rhs)
+													{
+														return lhs.m_priority>rhs.m_priority;
+													}
+    class ICallback
+    {
+    public:
+		virtual void operator()( char const *aMsg, double aProgress, double aConcavity, size_t aVertices) = 0;
+    };
+	
+	typedef ICallback* CallBackFunction;
+
+	//! Provides an implementation of the Hierarchical Approximate Convex Decomposition (HACD) technique described in "A Simple and Efficient Approach for 3D Mesh Approximate Convex Decomposition" Game Programming Gems 8 - Chapter 2.8, p.202. A short version of the chapter was published in ICIP09 and is available at ftp://ftp.elet.polimi.it/users/Stefano.Tubaro/ICIP_USB_Proceedings_v2/pdfs/0003501.pdf
+    class HACD
+	{            
+    public:
+		//! Gives the targeted number of triangles of the decimated mesh
+		//! @return targeted number of triangles of the decimated mesh
+		size_t										GetTargetNTrianglesDecimatedMesh() const { return m_targetNTrianglesDecimatedMesh;}
+        //! Sets the targeted number of triangles of the decimated mesh
+		//! @param targeted number of triangles of the decimated mesh
+		void										SetNTargetTrianglesDecimatedMesh(size_t  targetNTrianglesDecimatedMesh) { m_targetNTrianglesDecimatedMesh = targetNTrianglesDecimatedMesh;}
+		//! Gives the triangles partitionas an array of size m_nTriangles where the i-th element specifies the cluster to which belong the i-th triangle
+		//! @return triangles partition
+		const long * const							GetPartition() const { return m_partition;}
+        //! Sets the scale factor
+		//! @param scale scale factor
+		void										SetScaleFactor(double  scale) { m_scale = scale;}
+		//! Gives the scale factor
+		//! @return scale factor
+		const double								GetScaleFactor() const { return m_scale;}
+        //! Sets the threshold to detect small clusters. The threshold is expressed as a percentage of the total mesh surface (default 0.25%)
+		//! @param smallClusterThreshold threshold to detect small clusters
+		void										SetSmallClusterThreshold(double  smallClusterThreshold) { m_smallClusterThreshold = smallClusterThreshold;}
+		//! Gives the threshold to detect small clusters. The threshold is expressed as a percentage of the total mesh surface (default 0.25%)
+		//! @return threshold to detect small clusters
+		const double								GetSmallClusterThreshold() const { return m_smallClusterThreshold;}
+		//! Sets the call-back function
+		//! @param callBack pointer to the call-back function
+		void										SetCallBack(CallBackFunction  callBack) { m_callBack = callBack;}
+		//! Gives the call-back function
+		//! @return pointer to the call-back function
+		const CallBackFunction                      GetCallBack() const { return m_callBack;}
+        
+        //! Specifies whether faces points should be added when computing the concavity
+		//! @param addFacesPoints true = faces points should be added
+		void										SetAddFacesPoints(bool  addFacesPoints) { m_addFacesPoints = addFacesPoints;}
+		//! Specifies wheter faces points should be added when computing the concavity
+		//! @return true = faces points should be added
+		const bool									GetAddFacesPoints() const { return m_addFacesPoints;}
+        //! Specifies whether extra points should be added when computing the concavity
+		//! @param addExteraDistPoints true = extra points should be added
+		void										SetAddExtraDistPoints(bool  addExtraDistPoints) { m_addExtraDistPoints = addExtraDistPoints;}
+		//! Specifies wheter extra points should be added when computing the concavity
+		//! @return true = extra points should be added
+		const bool									GetAddExtraDistPoints() const { return m_addExtraDistPoints;}
+        //! Sets the points of the input mesh (Remark: the input points will be scaled and shifted. Use DenormalizeData() to invert those operations)
+		//! @param points pointer to the input points
+		void										SetPoints(Vec3<Real>  * points) { m_points = points;}
+		//! Gives the points of the input mesh (Remark: the input points will be scaled and shifted. Use DenormalizeData() to invert those operations)
+		//! @return pointer to the input points 
+		const Vec3<Real> *                          GetPoints() const { return m_points;}
+		//! Gives the points of the decimated mesh
+		//! @return pointer to the decimated mesh points 
+		const Vec3<Real> *                          GetDecimatedPoints() const { return m_pointsDecimated;}
+		//! Gives the triangles in the decimated mesh 
+		//! @return pointer to the decimated mesh triangles 
+		const Vec3<long>   *			            GetDecimatedTriangles() const { return m_trianglesDecimated;}        
+		//! Gives the number of points in the decimated mesh.
+		//! @return number of points the decimated mesh mesh
+		const size_t								GetNDecimatedPoints() const { return m_nPointsDecimated;}
+		//! Gives the number of triangles in the decimated mesh.
+		//! @return number of triangles the decimated mesh
+		const size_t								GetNDecimatedTriangles() const { return m_nTrianglesDecimated;}
+		//! Sets the triangles of the input mesh.
+		//! @param triangles points pointer to the input points
+		void										SetTriangles(Vec3<long>  * triangles) { m_triangles = triangles;}
+		//! Gives the triangles in the input mesh 
+		//! @return pointer to the input triangles 
+		const Vec3<long>   *			            GetTriangles() const { return m_triangles;}
+		//! Sets the number of points in the input mesh.
+		//! @param nPoints number of points the input mesh
+		void										SetNPoints(size_t nPoints) { m_nPoints = nPoints;}
+		//! Gives the number of points in the input mesh.
+		//! @return number of points the input mesh
+		const size_t								GetNPoints() const { return m_nPoints;}
+		//! Sets the number of triangles in the input mesh.
+		//! @param nTriangles number of triangles in the input mesh
+		void										SetNTriangles(size_t nTriangles) { m_nTriangles = nTriangles;}
+		//! Gives the number of triangles in the input mesh.
+		//! @return number of triangles the input mesh
+		const size_t								GetNTriangles() const { return m_nTriangles;}
+		//! Sets the minimum number of clusters to be generated.
+		//! @param nClusters minimum number of clusters
+		void										SetNClusters(size_t nClusters) { m_nMinClusters = nClusters;}
+		//! Gives the number of generated clusters.
+		//! @return number of generated clusters
+		const size_t								GetNClusters() const { return m_nClusters;}
+		//! Sets the maximum allowed concavity.
+		//! @param concavity maximum concavity
+		void										SetConcavity(double concavity) { m_concavity = concavity;}
+		//! Gives the maximum allowed concavity.
+		//! @return maximum concavity
+		double                                      GetConcavity() const { return m_concavity;}
+		//! Sets the maximum allowed distance to get CCs connected.
+		//! @param concavity maximum distance to get CCs connected
+		void										SetConnectDist(double ccConnectDist) { m_ccConnectDist = ccConnectDist;}
+		//! Gives the maximum allowed distance to get CCs connected.
+		//! @return maximum distance to get CCs connected
+		double                                      GetConnectDist() const { return m_ccConnectDist;}        
+        //! Sets the volume weight.
+		//! @param beta volume weight
+        void										SetVolumeWeight(double beta) { m_beta = beta;}
+		//! Gives the volume weight.
+		//! @return volume weight
+        double                                      GetVolumeWeight() const { return m_beta;}	
+		//! Sets the compacity weight (i.e. parameter alpha in ftp://ftp.elet.polimi.it/users/Stefano.Tubaro/ICIP_USB_Proceedings_v2/pdfs/0003501.pdf).
+		//! @param alpha compacity weight
+        void										SetCompacityWeight(double alpha) { m_alpha = alpha;}
+		//! Gives the compacity weight (i.e. parameter alpha in ftp://ftp.elet.polimi.it/users/Stefano.Tubaro/ICIP_USB_Proceedings_v2/pdfs/0003501.pdf).
+		//! @return compacity weight
+        double                                      GetCompacityWeight() const { return m_alpha;}	
+		//! Sets the maximum number of vertices for each generated convex-hull.
+		//! @param nVerticesPerCH maximum # vertices per CH
+        void										SetNVerticesPerCH(size_t nVerticesPerCH) { m_nVerticesPerCH = nVerticesPerCH;}
+		//! Gives the maximum number of vertices for each generated convex-hull.
+		//! @return maximum # vertices per CH
+		const size_t								GetNVerticesPerCH() const { return m_nVerticesPerCH;}
+		//! Gives the number of vertices for the cluster number numCH.
+		//! @return number of vertices
+		size_t                                      GetNPointsCH(size_t numCH) const;
+		//! Gives the number of triangles for the cluster number numCH.
+		//! @param numCH cluster's number
+		//! @return number of triangles
+        size_t                                      GetNTrianglesCH(size_t numCH) const;
+		//! Gives the vertices and the triangles of the cluster number numCH.
+		//! @param numCH cluster's number
+		//! @param points pointer to the vector of points to be filled
+		//! @param triangles pointer to the vector of triangles to be filled
+		//! @return true if sucess
+        bool                                        GetCH(size_t numCH, Vec3<Real> * const points, Vec3<long> * const triangles);     
+		//! Computes the HACD decomposition.
+		//! @param fullCH specifies whether to generate convex-hulls with a full or limited (i.e. < m_nVerticesPerCH) number of vertices
+        //! @param exportDistPoints specifies wheter distance points should ne exported or not (used only for debugging).
+		//! @return true if sucess
+        bool										Compute(bool fullCH=false, bool exportDistPoints=false);
+#if 0
+		//! Saves the generated convex-hulls in a VRML 2.0 file.
+		//! @param fileName the output file name
+		//! @param uniColor specifies whether the different convex-hulls should have the same color or not
+        //! @param numCluster specifies the cluster to be saved, if numCluster < 0 export all clusters
+        //! @return true if sucess
+		bool										Save(const char * fileName, bool uniColor, long numCluster=-1) const;
+#endif
+		//! Shifts and scales to the data to have all the coordinates between 0.0 and 1000.0.
+		void										NormalizeData();
+		//! Inverse the operations applied by NormalizeData().
+		void										DenormalizeData();
+		//! Destructor.
+													~HACD(void);
+
+	private:
+        //! Constructor.
+													HACD(HeapManager * heapManager = 0);
+
+		//! Gives the edge index.
+		//! @param a first vertex id
+		//! @param b second vertex id
+		//! @return edge's index
+		static unsigned long long					GetEdgeIndex(unsigned long long a, unsigned long long b) 
+													{ 
+														if (a > b) return (a << 32) + b;
+														else	   return (b << 32) + a;
+													}
+		//! Computes the concavity of a cluster.
+		//! @param ch the cluster's convex-hull
+		//! @param distPoints the cluster's points 
+		//! @return cluster's concavity
+		double										Concavity(ICHull & ch, std::map<long, DPoint> & distPoints);
+		//! Computes the perimeter of a cluster.
+		//! @param triIndices the cluster's triangles
+		//! @param distPoints the cluster's points 
+		//! @return cluster's perimeter
+        double										ComputePerimeter(const std::vector<long> & triIndices) const;
+		//! Creates the Graph by associating to each mesh triangle a vertex in the graph and to each couple of adjacent triangles an edge in the graph.
+        void										CreateGraph();	
+		//! Initializes the graph costs and computes the vertices normals
+        void										InitializeDualGraph();
+		//! Computes the cost of an edge
+		//! @param e edge's id
+        void                                        ComputeEdgeCost(size_t e);
+		//! Initializes the priority queue
+		//! @param fast specifies whether fast mode is used
+		//! @return true if success
+        bool                                        InitializePriorityQueue();
+        //! Cleans the intersection between convex-hulls
+        void                                        CleanClusters();
+        //! Computes convex-hulls from partition information
+        //! @param fullCH specifies whether to generate convex-hulls with a full or limited (i.e. < m_nVerticesPerCH) number of vertices
+		void										ComputeConvexHulls(bool fullCH);
+		//! Simplifies the graph
+		//! @param fast specifies whether fast mode is used
+		void										Simplify();
+
+	private:
+        Vec3<long> *								m_trianglesDecimated;		//>! pointer the triangles array
+        Vec3<Real> *                                m_pointsDecimated;			//>! pointer the points array
+        Vec3<long> *								m_triangles;				//>! pointer the triangles array
+        Vec3<Real> *                                m_points;					//>! pointer the points array
+        Vec3<Real> *                                m_facePoints;               //>! pointer to the faces points array
+        Vec3<Real> *                                m_faceNormals;              //>! pointer to the faces normals array
+        Vec3<Real> *                                m_normals;					//>! pointer the normals array
+        Vec3<Real> *                                m_extraDistPoints;          //>! pointer to the faces points array
+        Vec3<Real> *                                m_extraDistNormals;         //>! pointer to the faces normals array
+        size_t										m_nTrianglesDecimated;		//>! number of triangles in the original mesh
+        size_t										m_nPointsDecimated;			//>! number of vertices in the original mesh
+        size_t										m_nTriangles;				//>! number of triangles in the original mesh
+        size_t										m_nPoints;					//>! number of vertices in the original mesh
+        size_t										m_nClusters;				//>! number of clusters
+        size_t										m_nMinClusters;				//>! minimum number of clusters
+        double										m_ccConnectDist;			//>! maximum allowed distance to connect CCs
+        double										m_concavity;				//>! maximum concavity
+		double										m_alpha;					//>! compacity weigth
+        double                                      m_beta;                     //>! volume weigth
+		double										m_gamma;					//>! computation cost
+        double										m_diag;						//>! length of the BB diagonal
+		double										m_scale;					//>! scale factor used for NormalizeData() and DenormalizeData()
+		double										m_flatRegionThreshold;		//>! threshhold to control the contirbution of flat regions concavity (default 1% of m_scale)
+		double										m_smallClusterThreshold;	//>! threshhold to detect small clusters (default 0.25% of the total mesh surface)
+		double										m_area;						//>! surface area
+		Vec3<Real>                                  m_barycenter;				//>! barycenter of the mesh
+        std::vector< long >                         m_cVertices;				//>! array of vertices each belonging to a different cluster
+        ICHull *                                    m_convexHulls;				//>! convex-hulls associated with the final HACD clusters
+		Graph										m_graph;					//>! simplification graph
+        size_t                                      m_nVerticesPerCH;			//>! maximum number of vertices per convex-hull
+		reservable_priority_queue<GraphEdgePriorityQueue, 
+            std::vector<GraphEdgePriorityQueue>,
+			std::greater<std::vector<GraphEdgePriorityQueue>::value_type> > m_pqueue;		//!> priority queue
+													HACD(const HACD & rhs);
+		CallBackFunction							m_callBack;					//>! call-back function
+		long *										m_partition;				//>! array of size m_nTriangles where the i-th element specifies the cluster to which belong the i-th triangle
+		size_t										m_targetNTrianglesDecimatedMesh; //>! specifies the target number of triangles in the decimated mesh. If set to 0 no decimation is applied.
+        HeapManager *                               m_heapManager;              //>! Heap Manager
+        bool                                        m_addFacesPoints;           //>! specifies whether to add faces points or not
+        bool                                        m_addExtraDistPoints;       //>! specifies whether to add extra points for concave shapes or not
+
+        friend HACD * const                         CreateHACD(HeapManager * heapManager = 0);
+        friend void                                 DestroyHACD(HACD * const hacd);
+	};
+    inline HACD * const CreateHACD(HeapManager * heapManager) 
+    { 
+        return new HACD(heapManager);
+    }
+    inline void DestroyHACD(HACD * const hacd) 
+    { 
+        delete hacd;
+    }
+}
+#endif
+

indra/libhacd/hacdICHull.h

@@ -0,0 +1,133 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_ICHULL_H
+#define HACD_ICHULL_H
+#include "hacdVersion.h"
+#include "hacdManifoldMesh.h"
+#include "hacdVector.h"
+#include <vector>
+#include <map>
+#include "hacdMicroAllocator.h"
+
+namespace HACD
+{
+	class DPoint;
+	class HACD;
+	//!	Incremental Convex Hull algorithm (cf. http://maven.smith.edu/~orourke/books/ftp.html ).
+	enum ICHullError
+	{
+		ICHullErrorOK = 0,
+		ICHullErrorCoplanarPoints,
+		ICHullErrorNoVolume,
+		ICHullErrorInconsistent,
+		ICHullErrorNotEnoughPoints
+	};
+	class ICHull
+	{
+		public:
+			static const double									sc_eps;
+			//! 
+            HeapManager * const     							GetHeapManager() const { return m_heapManager;}
+			//!
+			void												SetHeapManager(HeapManager * const heapManager)
+                                                                { 
+                                                                    m_heapManager = heapManager;
+                                                                    m_mesh.SetHeapManager(m_heapManager);
+                                                                }
+			//!
+			bool												IsFlat() { return m_isFlat;}
+			//! 
+            std::map<long, DPoint> *							GetDistPoints() const { return m_distPoints;}
+			//!
+			void												SetDistPoints(std::map<long, DPoint> * distPoints) { m_distPoints = distPoints;}
+			//! Returns the computed mesh
+            TMMesh &                                            GetMesh() { return m_mesh;}
+			//!	Add one point to the convex-hull    
+            bool                                                AddPoint(const Vec3<Real> & point) {return AddPoints(&point, 1);}
+			//!	Add one point to the convex-hull    
+            bool                                                AddPoint(const Vec3<Real> & point, long id);
+			//!	Add points to the convex-hull
+			bool                                                AddPoints(const Vec3<Real> * points, size_t nPoints);	
+			bool												AddPoints(std::vector< Vec3<Real> > points);
+			//!	
+			ICHullError                                         Process();
+            //! 
+            ICHullError                                         Process(unsigned long nPointsCH);
+            //!
+            double                                              ComputeVolume();
+			//!
+			double												ComputeArea();
+            //!
+            bool                                                IsInside(const Vec3<Real> & pt0, const double eps = 0.0);
+			//!
+			double												ComputeDistance(long name, const Vec3<Real> & pt, const Vec3<Real> & normal, bool & insideHull, bool updateIncidentPoints);
+            //!
+            const ICHull &                                      operator=(ICHull & rhs);        
+
+			//!	Constructor
+																ICHull(HeapManager * const heapManager=0);
+			//! Destructor
+			virtual                                             ~ICHull(void) {};
+
+		private:
+            //!	DoubleTriangle builds the initial double triangle.  It first finds 3 noncollinear points and makes two faces out of them, in opposite order. It then finds a fourth point that is not coplanar with that face.  The vertices are stored in the face structure in counterclockwise order so that the volume between the face and the point is negative. Lastly, the 3 newfaces to the fourth point are constructed and the data structures are cleaned up. 
+			ICHullError                                         DoubleTriangle();
+            //!	MakeFace creates a new face structure from three vertices (in ccw order).  It returns a pointer to the face.
+            CircularListElement<TMMTriangle> *                  MakeFace(CircularListElement<TMMVertex> * v0,  
+                                                                         CircularListElement<TMMVertex> * v1,
+                                                                         CircularListElement<TMMVertex> * v2,
+                                                                         CircularListElement<TMMTriangle> * fold);			
+            //!	
+            CircularListElement<TMMTriangle> *                  MakeConeFace(CircularListElement<TMMEdge> * e, CircularListElement<TMMVertex> * v);
+			//!	
+			bool                                                ProcessPoint();
+            //!
+            bool                                                ComputePointVolume(double &totalVolume, bool markVisibleFaces);
+            //!
+            bool                                                FindMaxVolumePoint();
+            //!	
+            bool                                                CleanEdges();
+            //!	
+            bool                                                CleanVertices(unsigned long & addedPoints);
+            //!	
+            bool                                                CleanTriangles();
+            //!	
+            bool                                                CleanUp(unsigned long & addedPoints);
+            //!
+            bool                                                MakeCCW(CircularListElement<TMMTriangle> * f,
+                                                                        CircularListElement<TMMEdge> * e, 
+                                                                        CircularListElement<TMMVertex> * v);
+			void												Clear(); 
+		private:
+            static const long                                   sc_dummyIndex;
+            static const double                                 sc_distMin;
+			TMMesh                                              m_mesh;
+            std::vector<CircularListElement<TMMEdge> *>         m_edgesToDelete;
+            std::vector<CircularListElement<TMMEdge> *>         m_edgesToUpdate;
+            std::vector<CircularListElement<TMMTriangle> *>     m_trianglesToDelete; 
+			std::map<long, DPoint> *							m_distPoints;            
+//			CircularListElement<TMMVertex> *					m_dummyVertex;
+			Vec3<Real>                                          m_normal;
+			bool												m_isFlat;
+            HeapManager *                                       m_heapManager;
+					                                           
+																ICHull(const ICHull & rhs);
+        
+			friend class HACD;
+	};
+
+}
+#endif

indra/libhacd/hacdManifoldMesh.cpp

@@ -0,0 +1,604 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "hacdManifoldMesh.h"
+using namespace std;
+
+
+namespace HACD
+{    
+    Material::Material(void)
+    {
+        m_diffuseColor.X()  = 0.5;
+        m_diffuseColor.Y()  = 0.5;
+        m_diffuseColor.Z()  = 0.5;
+        m_specularColor.X() = 0.5;
+        m_specularColor.Y() = 0.5;
+        m_specularColor.Z() = 0.5;
+        m_ambientIntensity  = 0.4;
+        m_emissiveColor.X() = 0.0;
+        m_emissiveColor.Y() = 0.0;
+        m_emissiveColor.Z() = 0.0;
+        m_shininess         = 0.4;
+        m_transparency      = 0.0;
+    }
+    
+	TMMVertex::TMMVertex(void)
+	{
+        Initialize();
+	}
+    void TMMVertex::Initialize()
+	{
+		m_name = 0;
+        m_id = 0;
+		m_duplicate = 0;
+		m_onHull = false;
+		m_tag = false;
+	}
+
+	TMMVertex::~TMMVertex(void)
+	{
+	}
+	TMMEdge::TMMEdge(void)
+	{
+        Initialize();
+	}
+    void TMMEdge::Initialize()
+	{
+        m_id = 0;
+		m_triangles[0] = m_triangles[1] = m_newFace = 0;
+		m_vertices[0] = m_vertices[1] = 0;
+    }
+	TMMEdge::~TMMEdge(void)
+	{
+	}
+    void TMMTriangle::Initialize()
+	{
+        m_id = 0;
+		for(int i = 0; i < 3; i++)
+		{
+			m_edges[i] = 0;
+			m_vertices[0] = 0;
+		}
+		m_visible = false;
+        m_incidentPoints.Initialize();
+    }
+	TMMTriangle::TMMTriangle(void)
+	{
+        Initialize();
+	}
+	TMMTriangle::~TMMTriangle(void)
+	{
+	}
+	TMMesh::TMMesh(HeapManager * const heapManager):
+        m_vertices(heapManager), 
+        m_edges(heapManager),
+        m_triangles(heapManager)
+	{
+		m_barycenter = Vec3<Real>(0,0,0);
+		m_diag = 1;
+        m_heapManager = heapManager;   
+	}
+	TMMesh::~TMMesh(void)
+	{
+	}
+
+	void TMMesh::Print() 
+	{
+		size_t nV = m_vertices.GetSize();
+		std::cout << "-----------------------------" << std::endl;
+        std::cout << "vertices (" << nV << ")" << std::endl;
+        for(size_t v = 0; v < nV; v++)
+		{
+			const TMMVertex & currentVertex = m_vertices.GetData();
+			std::cout  << currentVertex.m_id	  << ", " 
+		 			   << currentVertex.m_pos.X() << ", " 
+					   << currentVertex.m_pos.Y() << ", "
+					   << currentVertex.m_pos.Z() << std::endl;
+			m_vertices.Next();
+		}
+    
+
+		size_t nE = m_edges.GetSize();
+		std::cout << "edges (" << nE << ")" << std::endl;
+		for(size_t e = 0; e < nE; e++)
+		{
+			const TMMEdge & currentEdge = m_edges.GetData();
+            const CircularListElement<TMMVertex> * v0 = currentEdge.m_vertices[0];
+            const CircularListElement<TMMVertex> * v1 = currentEdge.m_vertices[1];
+            const CircularListElement<TMMTriangle> * f0 = currentEdge.m_triangles[0];
+            const CircularListElement<TMMTriangle> * f1 = currentEdge.m_triangles[1];
+
+			std::cout << "-> (" << v0->GetData().m_name << ", " << v1->GetData().m_name << ")" << std::endl; 
+            std::cout << "-> F0 (" << f0->GetData().m_vertices[0]->GetData().m_name << ", " 
+                                   << f0->GetData().m_vertices[1]->GetData().m_name << ", "
+                                   << f0->GetData().m_vertices[2]->GetData().m_name <<")" << std::endl; 
+            std::cout << "-> F1 (" << f1->GetData().m_vertices[0]->GetData().m_name << ", " 
+                                   << f1->GetData().m_vertices[1]->GetData().m_name << ", "
+                                   << f1->GetData().m_vertices[2]->GetData().m_name << ")" << std::endl;                         
+			m_edges.Next();
+		}
+		size_t nT = m_triangles.GetSize();
+		std::cout << "triangles (" << nT << ")" << std::endl;
+		for(size_t t = 0; t < nT; t++)
+		{
+			const TMMTriangle & currentTriangle = m_triangles.GetData();
+            const CircularListElement<TMMVertex> * v0 = currentTriangle.m_vertices[0];
+            const CircularListElement<TMMVertex> * v1 = currentTriangle.m_vertices[1];
+            const CircularListElement<TMMVertex> * v2 = currentTriangle.m_vertices[2];
+            const CircularListElement<TMMEdge> * e0 = currentTriangle.m_edges[0];
+            const CircularListElement<TMMEdge> * e1 = currentTriangle.m_edges[1];
+            const CircularListElement<TMMEdge> * e2 = currentTriangle.m_edges[2];
+            
+			std::cout << "-> (" << v0->GetData().m_name << ", " << v1->GetData().m_name << ", "<< v2->GetData().m_name << ")" << std::endl; 
+         
+            std::cout << "-> E0 (" << e0->GetData().m_vertices[0]->GetData().m_name << ", " 
+                                   << e0->GetData().m_vertices[1]->GetData().m_name << ")" << std::endl; 
+            std::cout << "-> E1 (" << e1->GetData().m_vertices[0]->GetData().m_name << ", " 
+                                   << e1->GetData().m_vertices[1]->GetData().m_name << ")" << std::endl;
+            std::cout << "-> E2 (" << e2->GetData().m_vertices[0]->GetData().m_name << ", " 
+                                   << e2->GetData().m_vertices[1]->GetData().m_name << ")" << std::endl;   
+			m_triangles.Next();
+		}   
+	}
+#if 0
+    bool TMMesh::Save(const char *fileName)
+    {
+        std::ofstream fout(fileName);
+        std::cout << "Saving " <<  fileName << std::endl;
+		if (SaveVRML2(fout))
+		{
+           fout.close();
+		   return true;
+		}
+        return false;
+    }
+    bool TMMesh::SaveVRML2(std::ofstream &fout)
+    {
+        return SaveVRML2(fout, Material());
+    }
+    bool TMMesh::SaveVRML2(std::ofstream &fout, const Material & material)
+    {
+        if (fout.is_open()) 
+        {
+            size_t nV = m_vertices.GetSize();
+            size_t nT = m_triangles.GetSize();            
+            fout <<"#VRML V2.0 utf8" << std::endl;	    	
+            fout <<"" << std::endl;
+            fout <<"# Vertices: " << nV << std::endl;		
+            fout <<"# Triangles: " << nT << std::endl;		
+            fout <<"" << std::endl;
+            fout <<"Group {" << std::endl;
+            fout <<"	children [" << std::endl;
+            fout <<"		Shape {" << std::endl;
+            fout <<"			appearance Appearance {" << std::endl;
+            fout <<"				material Material {" << std::endl;
+            fout <<"					diffuseColor "      << material.m_diffuseColor.X()      << " " 
+                                                            << material.m_diffuseColor.Y()      << " "
+                                                            << material.m_diffuseColor.Z()      << std::endl;  
+            fout <<"					ambientIntensity "  << material.m_ambientIntensity      << std::endl;
+            fout <<"					specularColor "     << material.m_specularColor.X()     << " " 
+                                                            << material.m_specularColor.Y()     << " "
+                                                            << material.m_specularColor.Z()     << std::endl; 
+            fout <<"					emissiveColor "     << material.m_emissiveColor.X()     << " " 
+                                                            << material.m_emissiveColor.Y()     << " "
+                                                            << material.m_emissiveColor.Z()     << std::endl; 
+            fout <<"					shininess "         << material.m_shininess             << std::endl;
+            fout <<"					transparency "      << material.m_transparency          << std::endl;
+            fout <<"				}" << std::endl;
+            fout <<"			}" << std::endl;
+            fout <<"			geometry IndexedFaceSet {" << std::endl;
+            fout <<"				ccw TRUE" << std::endl;
+            fout <<"				solid TRUE" << std::endl;
+            fout <<"				convex TRUE" << std::endl;
+            if (GetNVertices() > 0) {
+                fout <<"				coord DEF co Coordinate {" << std::endl;
+                fout <<"					point [" << std::endl;
+                for(size_t v = 0; v < nV; v++)
+                {
+                    TMMVertex & currentVertex = m_vertices.GetData();
+                    fout <<"						" << currentVertex.m_pos.X() << " " 
+                                                      << currentVertex.m_pos.Y() << " " 
+                                                      << currentVertex.m_pos.Z() << "," << std::endl;
+                    currentVertex.m_id = v;
+                    m_vertices.Next();
+                }
+                fout <<"					]" << std::endl;
+                fout <<"				}" << std::endl;
+            }
+            if (GetNTriangles() > 0) {
+                fout <<"				coordIndex [ " << std::endl;
+                for(size_t f = 0; f < nT; f++)
+                {
+                    TMMTriangle & currentTriangle = m_triangles.GetData();
+                    fout <<"						" << currentTriangle.m_vertices[0]->GetData().m_id << ", " 
+                                                      << currentTriangle.m_vertices[1]->GetData().m_id << ", "                                                  
+                                                      << currentTriangle.m_vertices[2]->GetData().m_id << ", -1," << std::endl;
+                    m_triangles.Next();
+                }
+                fout <<"				]" << std::endl;
+            }
+            fout <<"			}" << std::endl;
+            fout <<"		}" << std::endl;
+            fout <<"	]" << std::endl;
+            fout <<"}" << std::endl;	
+        }
+        return true;
+    }
+#endif
+    void TMMesh::GetIFS(Vec3<Real> * const points, Vec3<long> * const triangles)
+    {
+        size_t nV = m_vertices.GetSize();
+        size_t nT = m_triangles.GetSize(); 
+
+        for(size_t v = 0; v < nV; v++)
+        {
+            points[v] = m_vertices.GetData().m_pos;
+            m_vertices.GetData().m_id = v;
+            m_vertices.Next();
+        }
+        for(size_t f = 0; f < nT; f++)
+        {
+            TMMTriangle & currentTriangle = m_triangles.GetData();
+            triangles[f].X() = static_cast<long>(currentTriangle.m_vertices[0]->GetData().m_id);
+            triangles[f].Y() = static_cast<long>(currentTriangle.m_vertices[1]->GetData().m_id);
+            triangles[f].Z() = static_cast<long>(currentTriangle.m_vertices[2]->GetData().m_id);
+            m_triangles.Next();
+        }
+    }
+	void TMMesh::Clear()
+    {
+		m_vertices.Clear();
+		m_edges.Clear();
+		m_triangles.Clear();
+	}
+    void TMMesh::Copy(TMMesh & mesh)
+    {
+        Clear();
+        // updating the id's
+        size_t nV = mesh.m_vertices.GetSize();
+        size_t nE = mesh. m_edges.GetSize();
+        size_t nT = mesh.m_triangles.GetSize();
+        for(size_t v = 0; v < nV; v++)
+        {
+            mesh.m_vertices.GetData().m_id = v;
+            mesh.m_vertices.Next();            
+        }
+        for(size_t e = 0; e < nE; e++)
+        {
+            mesh.m_edges.GetData().m_id = e;
+            mesh.m_edges.Next();
+            
+        }        
+        for(size_t f = 0; f < nT; f++)
+        {
+            mesh.m_triangles.GetData().m_id = f;
+            mesh.m_triangles.Next();
+        }
+        // copying data
+        m_vertices  = mesh.m_vertices;
+        m_edges     = mesh.m_edges;
+        m_triangles = mesh.m_triangles;
+        m_heapManager = mesh.m_heapManager;
+ 
+        // generating mapping
+        CircularListElement<TMMVertex> ** vertexMap     = new CircularListElement<TMMVertex> * [nV];
+        CircularListElement<TMMEdge> ** edgeMap         = new CircularListElement<TMMEdge> * [nE];
+        CircularListElement<TMMTriangle> ** triangleMap = new CircularListElement<TMMTriangle> * [nT];
+        for(size_t v = 0; v < nV; v++)
+        {
+            vertexMap[v] = m_vertices.GetHead();
+            m_vertices.Next();            
+        }
+        for(size_t e = 0; e < nE; e++)
+        {
+            edgeMap[e] = m_edges.GetHead();
+            m_edges.Next();            
+        }        
+        for(size_t f = 0; f < nT; f++)
+        {
+            triangleMap[f] = m_triangles.GetHead();
+            m_triangles.Next();
+        }
+        
+        // updating pointers
+        for(size_t v = 0; v < nV; v++)
+        {
+            if (vertexMap[v]->GetData().m_duplicate)
+            {
+                vertexMap[v]->GetData().m_duplicate = edgeMap[vertexMap[v]->GetData().m_duplicate->GetData().m_id];
+            }
+        }
+        for(size_t e = 0; e < nE; e++)
+        {
+            if (edgeMap[e]->GetData().m_newFace)
+            {
+                edgeMap[e]->GetData().m_newFace = triangleMap[edgeMap[e]->GetData().m_newFace->GetData().m_id];
+            }
+			if (nT > 0)
+			{
+				for(int f = 0; f < 2; f++)
+				{
+					if (edgeMap[e]->GetData().m_triangles[f])
+					{
+						edgeMap[e]->GetData().m_triangles[f] = triangleMap[edgeMap[e]->GetData().m_triangles[f]->GetData().m_id];
+					}
+				}            
+			}
+            for(int v = 0; v < 2; v++)
+            {
+                if (edgeMap[e]->GetData().m_vertices[v])
+                {
+                    edgeMap[e]->GetData().m_vertices[v] = vertexMap[edgeMap[e]->GetData().m_vertices[v]->GetData().m_id];
+                }
+            }
+        }        
+        for(size_t f = 0; f < nT; f++)
+        {
+			if (nE > 0)
+			{
+				for(int e = 0; e < 3; e++)
+				{
+					if (triangleMap[f]->GetData().m_edges[e])
+					{
+						triangleMap[f]->GetData().m_edges[e] = edgeMap[triangleMap[f]->GetData().m_edges[e]->GetData().m_id];
+					}
+				}            
+			}
+            for(int v = 0; v < 3; v++)
+            {
+                if (triangleMap[f]->GetData().m_vertices[v])
+                {
+                    triangleMap[f]->GetData().m_vertices[v] = vertexMap[triangleMap[f]->GetData().m_vertices[v]->GetData().m_id];
+                }
+            }
+        }
+        delete [] vertexMap;
+        delete [] edgeMap;
+        delete [] triangleMap;
+        
+    }
+	long  IntersectRayTriangle(const Vec3<double> & P0, const Vec3<double> & dir, 
+							   const Vec3<double> & V0, const Vec3<double> & V1, 
+							   const Vec3<double> & V2, double &t)
+	{
+        const double EPS = 1e-9;
+        const double EPS1 = 1e-6;
+		t = 0.0;
+		Vec3<double> edge1, edge2, edge3;
+		double det;
+		edge1 = V1 - V2;
+		edge2 = V2 - V0;
+		Vec3<double> pvec = dir ^ edge2;
+		det = edge1 * pvec;
+		if (det < EPS && det > -EPS)
+			return 0;
+		Vec3<double> tvec = P0 - V0;
+		Vec3<double> qvec = tvec ^ edge1;
+		t = (edge2 * qvec) / det;
+        if (t < 0.0)
+        {
+            return 0;
+        }
+		edge3 = V0 - V1;
+		Vec3<double> I(P0 + t * dir);
+		Vec3<double> s0 = (I-V0) ^ edge3;
+		Vec3<double> s1 = (I-V1) ^ edge1;
+		Vec3<double> s2 = (I-V2) ^ edge2;
+
+        Vec3<double> normal = edge1 ^ edge2;
+        double diff = normal.GetNorm() - s0.GetNorm() - s1.GetNorm() - s2.GetNorm();            
+
+        if (diff < EPS1 && diff > -EPS1)
+        {
+            return 1;			
+        }
+		return 0;
+	}
+
+    bool IntersectLineLine(const Vec3<double> & p1, const Vec3<double> & p2, 
+                          const Vec3<double> & p3, const Vec3<double> & p4,
+                          Vec3<double> & pa, Vec3<double> & pb, 
+                          double & mua, double & mub)
+    {
+        Vec3<double> p13,p43,p21;
+        double d1343,d4321,d1321,d4343,d2121;
+        double numer,denom;
+        
+        p13.X() = p1.X() - p3.X();
+        p13.Y() = p1.Y() - p3.Y();
+        p13.Z() = p1.Z() - p3.Z();
+        p43.X() = p4.X() - p3.X();
+        p43.Y() = p4.Y() - p3.Y();
+        p43.Z() = p4.Z() - p3.Z();
+        if (p43.X()==0.0 && p43.Y()==0.0 && p43.Z()==0.0)
+            return false;
+        p21.X() = p2.X() - p1.X();
+        p21.Y() = p2.Y() - p1.Y();
+        p21.Z() = p2.Z() - p1.Z();
+        if (p21.X()==0.0 && p21.Y()==0.0 && p21.Z()==0.0)
+            return false;
+        
+        d1343 = p13.X() * p43.X() + p13.Y() * p43.Y() + p13.Z() * p43.Z();
+        d4321 = p43.X() * p21.X() + p43.Y() * p21.Y() + p43.Z() * p21.Z();
+        d1321 = p13.X() * p21.X() + p13.Y() * p21.Y() + p13.Z() * p21.Z();
+        d4343 = p43.X() * p43.X() + p43.Y() * p43.Y() + p43.Z() * p43.Z();
+        d2121 = p21.X() * p21.X() + p21.Y() * p21.Y() + p21.Z() * p21.Z();
+        
+        denom = d2121 * d4343 - d4321 * d4321;
+        if (denom==0.0)
+            return false;
+        numer = d1343 * d4321 - d1321 * d4343;
+        
+        mua = numer / denom;
+        mub = (d1343 + d4321 * (mua)) / d4343;
+        
+        pa.X() = p1.X() + mua * p21.X();
+        pa.Y() = p1.Y() + mua * p21.Y();
+        pa.Z() = p1.Z() + mua * p21.Z();
+        pb.X() = p3.X() + mub * p43.X();
+        pb.Y() = p3.Y() + mub * p43.Y();
+        pb.Z() = p3.Z() + mub * p43.Z();
+        
+        return true;
+    }
+
+	long  IntersectRayTriangle2(const Vec3<double> & P0, const Vec3<double> & dir, 
+							   const Vec3<double> & V0, const Vec3<double> & V1, 
+							   const Vec3<double> & V2, double &r)
+	{
+		Vec3<double> u, v, n;          // triangle vectors
+		Vec3<double> w0, w;          // ray vectors
+		double     a, b;             // params to calc ray-plane intersect
+
+		// get triangle edge vectors and plane normal
+		u = V1 - V0;
+		v = V2 - V0;
+		n = u ^ v;             // cross product
+		if (n.GetNorm() == 0.0)            // triangle is degenerate
+			return -1;                 // do not deal with this case
+
+		w0 = P0 - V0;
+		a = - n * w0;
+		b =   n * dir;
+		if (fabs(b) <= 0.0) {     // ray is parallel to triangle plane
+			if (a == 0.0)                // ray lies in triangle plane
+				return 2;
+			else return 0;             // ray disjoint from plane
+		}
+
+		// get intersect point of ray with triangle plane
+		r = a / b;
+		if (r < 0.0)                   // ray goes away from triangle
+			return 0;                  // => no intersect
+		// for a segment, also test if (r > 1.0) => no intersect
+
+		Vec3<double> I = P0 + r * dir;           // intersect point of ray and plane
+
+		// is I inside T?
+		double uu, uv, vv, wu, wv, D;
+		uu = u * u;
+		uv = u * v;
+		vv = v * v;
+		w  = I - V0;
+		wu = w * u;
+		wv = w * v;
+		D = uv * uv - uu * vv;
+
+		// get and test parametric coords
+		double s, t;
+		s = (uv * wv - vv * wu) / D;
+		if (s < 0.0 || s > 1.0)        // I is outside T
+			return 0;
+		t = (uv * wu - uu * wv) / D;
+		if (t < 0.0 || (s + t) > 1.0)  // I is outside T
+			return 0;
+		return 1;                      // I is in T
+	}
+    
+    
+	bool TMMesh::CheckConsistancy()
+    {
+        size_t nE = m_edges.GetSize();
+        size_t nT = m_triangles.GetSize();
+        for(size_t e = 0; e < nE; e++)
+        {
+            for(int f = 0; f < 2; f++)
+            {
+                if (!m_edges.GetHead()->GetData().m_triangles[f])
+                {
+                    return false;
+                }
+            }            
+			m_edges.Next();
+        }        
+
+        for(size_t f = 0; f < nT; f++)
+        {
+            for(int e = 0; e < 3; e++)
+            {
+                int found = 0;
+                for(int k = 0; k < 2; k++)
+                {
+                    if (m_triangles.GetHead()->GetData().m_edges[e]->GetData().m_triangles[k] == m_triangles.GetHead())
+                    {
+                        found++;
+                    }
+                }
+                if (found != 1)
+                {
+                    return false;
+                }
+            }            
+			m_triangles.Next();
+        }
+
+		return true;
+    }
+	bool TMMesh::Normalize()
+    {
+        size_t nV = m_vertices.GetSize();
+		if (nV == 0)
+		{
+			return false;
+		}
+        m_barycenter = m_vertices.GetHead()->GetData().m_pos;
+		Vec3<Real> min = m_barycenter;
+		Vec3<Real> max = m_barycenter;
+		Real x, y, z;
+        for(size_t v = 1; v < nV; v++)
+        {
+			m_barycenter +=  m_vertices.GetHead()->GetData().m_pos;
+            x = m_vertices.GetHead()->GetData().m_pos.X();
+            y = m_vertices.GetHead()->GetData().m_pos.Y();
+            z = m_vertices.GetHead()->GetData().m_pos.Z();
+            if ( x < min.X()) min.X() = x;
+			else if ( x > max.X()) max.X() = x;
+            if ( y < min.Y()) min.Y() = y;
+			else if ( y > max.Y()) max.Y() = y;
+            if ( z < min.Z()) min.Z() = z;
+			else if ( z > max.Z()) max.Z() = z;
+			m_vertices.Next();
+        }
+		m_barycenter /= static_cast<Real>(nV);
+        m_diag = static_cast<Real>(0.001 * (max-min).GetNorm());
+        const Real invDiag = static_cast<Real>(1.0 / m_diag);
+		if (m_diag != 0.0)
+		{
+	        for(size_t v = 0; v < nV; v++)
+		    {
+				m_vertices.GetHead()->GetData().m_pos = (m_vertices.GetHead()->GetData().m_pos - m_barycenter) * invDiag;
+				m_vertices.Next();
+		    }
+		}
+		return true;
+	}
+	bool TMMesh::Denormalize()
+	{
+        size_t nV = m_vertices.GetSize();
+		if (nV == 0)
+		{
+			return false;
+		}
+		if (m_diag != 0.0)
+		{
+	        for(size_t v = 0; v < nV; v++)
+		    {
+				m_vertices.GetHead()->GetData().m_pos = m_vertices.GetHead()->GetData().m_pos * m_diag + m_barycenter;
+				m_vertices.Next();
+			}
+		}
+		return false;
+    }
+}

indra/libhacd/hacdManifoldMesh.h

@@ -0,0 +1,269 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+All rights reserved.
+
+
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_MANIFOLD_MESH_H
+#define HACD_MANIFOLD_MESH_H
+#include <iostream>
+#include <fstream>
+#include "hacdVersion.h"
+#include "hacdCircularList.h"
+#include "hacdVector.h"
+#include "hacdSArray.h"
+#include <set>
+#include "hacdMicroAllocator.h"
+namespace HACD
+{
+	class TMMTriangle;
+	class TMMEdge;
+    class TMMesh;
+    class ICHull;
+	class HACD;
+
+    class DPoint  
+    {
+    public:       
+																DPoint(long name=0, Real dist=0, bool computed=false, bool distOnly=false)
+																	:m_name(name),
+																	 m_dist(dist),
+																	 m_computed(computed),
+                                                                     m_distOnly(distOnly){};
+                                                				~DPoint(){};      
+    private:
+		long													m_name;
+		Real                                                    m_dist;
+		bool													m_computed;
+        bool                                                    m_distOnly;
+		friend class TMMTriangle;
+	    friend class TMMesh;
+		friend class GraphVertex;
+        friend class GraphEdge;
+        friend class Graph;
+		friend class ICHull;
+		friend class HACD;
+    };
+
+	//!	Vertex data structure used in a triangular manifold mesh (TMM).
+	class TMMVertex
+	{
+		public:
+            void                                                Initialize();                                                    
+																TMMVertex(void);
+                                                                ~TMMVertex(void);
+        
+        private:
+			Vec3<Real>											m_pos;
+			long												m_name;
+            size_t												m_id;
+			CircularListElement<TMMEdge> *						m_duplicate;		// pointer to incident cone edge (or NULL)
+			bool												m_onHull;
+			bool												m_tag;
+																TMMVertex(const TMMVertex & rhs);
+            
+			friend class HACD;            
+			friend class ICHull;
+            friend class TMMesh;
+            friend class TMMTriangle;
+            friend class TMMEdge;
+	};
+
+	//!	Edge data structure used in a triangular manifold mesh (TMM).
+	class TMMEdge
+	{		
+		public:
+            void                                                Initialize(); 
+																TMMEdge(void);
+																~TMMEdge(void);
+        private:
+            size_t												m_id;
+			CircularListElement<TMMTriangle> *					m_triangles[2];
+			CircularListElement<TMMVertex> *					m_vertices[2];
+			CircularListElement<TMMTriangle> *					m_newFace;
+
+
+																TMMEdge(const TMMEdge & rhs);
+                
+		friend class HACD;
+		friend class ICHull;
+        friend class TMMTriangle;
+        friend class TMMVertex;
+        friend class TMMesh;
+	};
+
+	//!	Triangle data structure used in a triangular manifold mesh (TMM).
+	class TMMTriangle
+	{
+		public:
+            void                                                Initialize(); 
+																TMMTriangle(void);
+																~TMMTriangle(void);
+        private:
+            size_t												m_id;
+			CircularListElement<TMMEdge> *						m_edges[3];
+			CircularListElement<TMMVertex> *					m_vertices[3];
+			SArray<long, SARRAY_DEFAULT_MIN_SIZE>				m_incidentPoints;
+			bool												m_visible;
+																
+																TMMTriangle(const TMMTriangle & rhs);
+        
+		friend class HACD;
+        friend class ICHull;
+        friend class TMMesh;
+        friend class TMMVertex;
+        friend class TMMEdge;
+	};
+    
+    class Material
+    {
+    public:    
+                                                                Material(void);
+                                                                ~Material(void){}        
+//    private:
+        Vec3<double>                                            m_diffuseColor;
+        double                                                  m_ambientIntensity;
+        Vec3<double>                                            m_specularColor;
+        Vec3<double>                                            m_emissiveColor;
+        double                                                  m_shininess;
+        double                                                  m_transparency;
+        
+        friend class TMMesh;
+		friend class HACD;
+    };
+
+	//!	triangular manifold mesh data structure.
+	class TMMesh
+	{
+		public:
+			//! 
+            HeapManager * const     							GetHeapManager() const { return m_heapManager;}
+			//!
+			void												SetHeapManager(HeapManager * const heapManager)
+                                                                { 
+                                                                    m_heapManager = heapManager;
+                                                                    m_vertices.SetHeapManager(m_heapManager);
+                                                                    m_edges.SetHeapManager(m_heapManager);
+                                                                    m_triangles.SetHeapManager(m_heapManager);
+                                                                }
+			//! Returns the number of vertices>
+			inline size_t										GetNVertices() const { return m_vertices.GetSize();}
+			//! Returns the number of edges
+			inline size_t										GetNEdges() const { return m_edges.GetSize();}
+			//! Returns the number of triangles
+			inline size_t										GetNTriangles() const { return m_triangles.GetSize();}
+            //! Returns the vertices circular list
+            inline const CircularList<TMMVertex> &              GetVertices() const { return m_vertices;}
+            //! Returns the edges circular list
+            inline const CircularList<TMMEdge> &				GetEdges() const { return m_edges;}
+            //! Returns the triangles circular list
+            inline const CircularList<TMMTriangle> &			GetTriangles() const { return m_triangles;}
+            //! Returns the vertices circular list
+            inline CircularList<TMMVertex> &                    GetVertices() { return m_vertices;}
+            //! Returns the edges circular list
+            inline CircularList<TMMEdge> &                      GetEdges() { return m_edges;}
+            //! Returns the triangles circular list
+            inline CircularList<TMMTriangle> &                  GetTriangles() { return m_triangles;}               
+			//! Add vertex to the mesh
+			CircularListElement<TMMVertex> *					AddVertex() {return m_vertices.Add();}
+			//! Add vertex to the mesh
+			CircularListElement<TMMEdge> *						AddEdge() {return m_edges.Add();}
+			//! Add vertex to the mesh
+			CircularListElement<TMMTriangle> *					AddTriangle() {return m_triangles.Add();}
+			//! Print mesh information 
+			void												Print();
+            //!
+            void                                                GetIFS(Vec3<Real> * const points, Vec3<long> * const triangles);
+#if 0
+            //! Save mesh 
+            bool												Save(const char *fileName);        
+            //! Save mesh to VRML 2.0 format 
+            bool												SaveVRML2(std::ofstream &fout);             
+            //! Save mesh to VRML 2.0 format 
+            bool												SaveVRML2(std::ofstream &fout, const Material & material);  			
+#endif
+            //!  
+            void												Clear();
+            //!
+            void                                                Copy(TMMesh & mesh);
+			//!
+			bool												CheckConsistancy();
+			//!
+			bool												Normalize();
+			//!
+			bool												Denormalize();
+            //!	Constructor
+																TMMesh(HeapManager * const heapManager);
+			//! Destructor
+			virtual												~TMMesh(void);
+
+		private:
+			CircularList<TMMVertex>								m_vertices;
+			CircularList<TMMEdge>								m_edges;
+			CircularList<TMMTriangle>							m_triangles;
+			Real                                                m_diag;						//>! length of the BB diagonal
+			Vec3<Real>                                          m_barycenter;				//>! barycenter of the mesh
+            HeapManager *                                       m_heapManager;
+
+			// not defined
+																TMMesh(const TMMesh & rhs);
+			friend class ICHull;
+			friend class HACD;
+	};
+	//! IntersectRayTriangle(): intersect a ray with a 3D triangle
+	//!    Input:  a ray R, and a triangle T
+	//!    Output: *I = intersection point (when it exists)
+	//!             0 = disjoint (no intersect)
+	//!             1 = intersect in unique point I1
+	long														IntersectRayTriangle( const Vec3<double> & P0, const Vec3<double> & dir, 
+																					  const Vec3<double> & V0, const Vec3<double> & V1, 
+																					  const Vec3<double> & V2, double &t);
+
+	// intersect_RayTriangle(): intersect a ray with a 3D triangle
+	//    Input:  a ray R, and a triangle T
+	//    Output: *I = intersection point (when it exists)
+	//    Return: -1 = triangle is degenerate (a segment or point)
+	//             0 = disjoint (no intersect)
+	//             1 = intersect in unique point I1
+	//             2 = are in the same plane
+	long														IntersectRayTriangle2(const Vec3<double> & P0, const Vec3<double> & dir, 
+																					   const Vec3<double> & V0, const Vec3<double> & V1, 
+																					   const Vec3<double> & V2, double &r);
+
+    /*
+     Calculate the line segment PaPb that is the shortest route between
+     two lines P1P2 and P3P4. Calculate also the values of mua and mub where
+     Pa = P1 + mua (P2 - P1)
+     Pb = P3 + mub (P4 - P3)
+     Return FALSE if no solution exists.
+     */
+    bool                                                        IntersectLineLine(const Vec3<double> & p1, const Vec3<double> & p2, 
+                                                                                  const Vec3<double> & p3, const Vec3<double> & p4,
+                                                                                  Vec3<double> & pa, Vec3<double> & pb, 
+                                                                                  double & mua, double &mub);
+}
+#endif

indra/libhacd/hacdMeshDecimator.cpp

@@ -0,0 +1,684 @@
+#include <sstream>
+#include <iostream>
+#include <stdlib.h>
+#include <algorithm>
+#include <vector>
+#include "hacdMeshDecimator.h"
+
+namespace HACD
+{
+	MeshDecimator::MeshDecimator(void)
+	{
+		m_triangles					= 0;
+		m_points   					= 0;
+		m_nPoints					= 0;
+		m_nInitialTriangles 		= 0;
+		m_nVertices					= 0;
+		m_nTriangles				= 0;
+		m_nEdges					= 0;
+		m_trianglesTags				= 0;
+		m_ecolManifoldConstraint	= true;
+		m_callBack					= 0;
+	}
+
+	MeshDecimator::~MeshDecimator(void)
+	{
+		ReleaseMemory();
+	}
+	void MeshDecimator::ReleaseMemory()
+	{
+		delete [] m_trianglesTags;
+        std::vector< MDVertex > emptyVertices(0);
+		m_vertices.swap(emptyVertices);
+        std::vector<MDEdge> emptyEdges(0);
+		m_edges.swap(emptyEdges);
+		m_pqueue = 		std::priority_queue<
+				 MDEdgePriorityQueue, 
+				 std::vector<MDEdgePriorityQueue>, 
+				 std::less<MDEdgePriorityQueue> >();
+		m_triangles					= 0;
+		m_points   					= 0;
+		m_nPoints					= 0;
+		m_nInitialTriangles 		= 0;
+		m_nVertices					= 0;
+		m_nTriangles				= 0;
+		m_nEdges					= 0;
+		m_trianglesTags				= 0;
+	}
+	void MeshDecimator::Initialize(size_t nVertices, size_t nTriangles,   Vec3<Float> * points,  Vec3<long> * triangles)
+	{
+		m_nVertices			= nVertices;
+		m_nTriangles		= nTriangles;
+		m_nInitialTriangles = nTriangles;
+		m_points			= points;
+		m_nPoints			= nVertices;
+		m_triangles			= triangles;
+		m_trianglesTags		= new bool[m_nTriangles];
+		m_edges.reserve(3*m_nTriangles);
+		m_vertices.resize(m_nVertices);
+		for(size_t v = 0; v < m_nVertices; ++v)
+		{
+			m_vertices[v].m_tag = true;
+		}
+		long tri[3];
+		MDEdge edge;
+		edge.m_tag = true;
+		edge.m_onBoundary = true;
+        long nEdges = 0;
+		long idEdge;
+		long nTris = static_cast<long>(m_nTriangles);
+		for(long t = 0; t < nTris; ++t)
+		{
+			tri[0] = m_triangles[t].X();
+			tri[1] = m_triangles[t].Y();
+			tri[2] = m_triangles[t].Z();
+			m_trianglesTags[t] = true;
+			for(int k = 0; k < 3; ++k)
+			{
+				edge.m_v1 = tri[k];
+				edge.m_v2 = tri[(k+1)%3];
+				m_vertices[edge.m_v1].m_triangles.Insert(t);
+				idEdge = GetEdge(edge.m_v1, edge.m_v2);
+				if (idEdge == -1)
+				{
+					m_edges.push_back(edge);
+					m_vertices[edge.m_v1].m_edges.Insert(nEdges);
+					m_vertices[edge.m_v2].m_edges.Insert(nEdges);
+					++nEdges;
+				}
+				else
+				{
+					m_edges[idEdge].m_onBoundary = false;
+				}
+			}
+		}
+        m_nEdges = static_cast<size_t>(nEdges);
+		for(size_t v = 0; v < m_nVertices; ++v)
+		{
+			m_vertices[v].m_onBoundary = false;
+			for(size_t itE = 0; itE < m_vertices[v].m_edges.Size(); ++itE)
+			{
+				idEdge = m_vertices[v].m_edges[itE];
+				if (m_edges[idEdge].m_onBoundary)
+				{
+					m_vertices[v].m_onBoundary = true;
+					break;
+				}
+			}
+		}
+	}
+	long MeshDecimator::GetTriangle(long v1, long v2, long v3) const
+	{
+		long i, j, k;
+        long idTriangle;
+		for(size_t it = 0; it < m_vertices[v1].m_triangles.Size(); ++it)
+		{
+            idTriangle = m_vertices[v1].m_triangles[it];
+			i = m_triangles[idTriangle].X();
+			j = m_triangles[idTriangle].Y();
+			k = m_triangles[idTriangle].Z();
+			if ( (i==v1 && j==v2 && k==v3) || (i==v1 && j==v3 && k==v2) ||
+				 (i==v2 && j==v1 && k==v3) || (i==v2 && j==v3 && k==v1) ||
+				 (i==v3 && j==v2 && k==v1) || (i==v3 && j==v1 && k==v2)  )
+			{
+				return idTriangle;
+			}
+		}
+		return -1;
+	}
+	long MeshDecimator::GetEdge(long v1, long v2) const
+	{
+		long idEdge;
+        for(size_t it = 0; it < m_vertices[v1].m_edges.Size(); ++it)
+		{
+            idEdge = m_vertices[v1].m_edges[it];
+			if ( (m_edges[idEdge].m_v1==v1 && m_edges[idEdge].m_v2==v2) || 
+				 (m_edges[idEdge].m_v1==v2 && m_edges[idEdge].m_v2==v1) )
+			{
+				return idEdge;
+			}
+		}
+		return -1;
+	}
+	void MeshDecimator::EdgeCollapse(long v1, long v2)
+	{
+		long u, w;
+		int shift;
+		long idTriangle;
+		for(size_t itT = 0; itT < m_vertices[v2].m_triangles.Size(); ++itT)
+		{
+            idTriangle =  m_vertices[v2].m_triangles[itT];
+			if (m_triangles[idTriangle].X() == v2)
+			{
+				shift = 0;
+				u = m_triangles[idTriangle].Y();
+				w = m_triangles[idTriangle].Z();
+			}
+			else if (m_triangles[idTriangle].Y() == v2)
+			{
+				shift = 1;
+				u = m_triangles[idTriangle].X();
+				w = m_triangles[idTriangle].Z();
+			}
+			else
+			{
+				shift = 2;
+				u = m_triangles[idTriangle].X();
+				w = m_triangles[idTriangle].Y();
+			}
+
+			if ((u == v1) || (w == v1))
+			{
+				m_trianglesTags[idTriangle] = false;
+				m_vertices[u].m_triangles.Erase(idTriangle);						
+				m_vertices[w].m_triangles.Erase(idTriangle);
+				m_nTriangles--;
+			}
+			else if (GetTriangle(v1, u, w) == -1)
+			{
+				m_vertices[v1].m_triangles.Insert(idTriangle);
+				m_triangles[idTriangle][shift] = v1;
+			}
+			else
+			{
+				m_trianglesTags[idTriangle] = false;
+				m_vertices[u].m_triangles.Erase(idTriangle);						
+				m_vertices[w].m_triangles.Erase(idTriangle);
+				m_nTriangles--;
+			}
+		}
+        long idEdge;
+		for(size_t itE = 0; itE < m_vertices[v2].m_edges.Size(); ++itE)
+		{
+            idEdge = m_vertices[v2].m_edges[itE];
+			w = (m_edges[idEdge].m_v1 == v2)? m_edges[idEdge].m_v2 : m_edges[idEdge].m_v1;
+			if (w==v1)
+			{
+				m_edges[idEdge].m_tag = false;
+				m_vertices[w].m_edges.Erase(idEdge);
+				m_nEdges--;
+			}
+			else if ( GetEdge(v1, w) == -1)
+			{
+				if (m_edges[idEdge].m_v1 == v2)	m_edges[idEdge].m_v1 = v1;
+				else							m_edges[idEdge].m_v2 = v1;
+				m_vertices[v1].m_edges.Insert(idEdge);			
+			}
+			else
+			{
+				m_edges[idEdge].m_tag = false;
+				m_vertices[w].m_edges.Erase(idEdge);
+				m_nEdges--;
+			}
+		}
+		m_vertices[v2].m_tag = false;
+		m_nVertices--;
+		// update boundary edges
+		SArray<long, 64> incidentVertices;
+		incidentVertices.PushBack(v1);
+		for(size_t itE = 0; itE < m_vertices[v1].m_edges.Size(); ++itE)
+		{
+			incidentVertices.PushBack((m_edges[idEdge].m_v1!= v1)?m_edges[idEdge].m_v1:m_edges[idEdge].m_v2);
+            idEdge = m_vertices[v1].m_edges[itE];
+			m_edges[idEdge].m_onBoundary = (IsBoundaryEdge(m_edges[idEdge].m_v1, m_edges[idEdge].m_v2) != -1);
+		}		
+		// update boundary vertices
+		long idVertex;
+		for(size_t itV = 0; itV < incidentVertices.Size(); ++itV)
+		{
+			idVertex = incidentVertices[itV];
+			m_vertices[idVertex].m_onBoundary = false;
+			for(size_t itE = 0; itE < m_vertices[idVertex].m_edges.Size(); ++itE)
+			{
+				idEdge = m_vertices[idVertex].m_edges[itE];
+				if (m_edges[idEdge].m_onBoundary)
+				{
+					m_vertices[idVertex].m_onBoundary = true;
+					break;
+				}
+			}
+		}		
+	}
+	long MeshDecimator::IsBoundaryEdge(long v1, long v2) const
+	{
+		long commonTri = -1;
+		long itTriangle1, itTriangle2;
+		for(size_t itT1 = 0; itT1 < m_vertices[v1].m_triangles.Size(); ++itT1)
+		{
+            itTriangle1 = m_vertices[v1].m_triangles[itT1];
+			for(size_t itT2 = 0; itT2 < m_vertices[v2].m_triangles.Size(); ++itT2)
+			{
+                itTriangle2 = m_vertices[v2].m_triangles[itT2];
+				if (itTriangle1 == itTriangle2)
+				{
+					if (commonTri == -1)
+					{
+						commonTri = itTriangle1;
+					}
+					else
+					{
+						return -1;
+					}
+				}
+			}
+		}
+		return commonTri;
+	}
+	bool MeshDecimator::IsBoundaryVertex(long v) const
+	{
+		long idEdge;
+		for(size_t itE = 0; itE < m_vertices[v].m_edges.Size(); ++itE)
+		{
+            idEdge =  m_vertices[v].m_edges[itE];
+			if ( IsBoundaryEdge(m_edges[idEdge].m_v1, m_edges[idEdge].m_v2) != -1) return true;
+		}
+		return false;
+	}
+
+	void MeshDecimator::GetMeshData(Vec3<Float> * points, Vec3<long> * triangles) const
+	{
+		long * map = new long [m_nPoints];
+		long counter = 0;
+		for (size_t v = 0; v < m_nPoints; ++v)
+		{
+			if ( m_vertices[v].m_tag )
+			{
+				points[counter] = m_points[v];
+				map[v] = counter++;
+			}
+		}
+		counter = 0;
+		for (size_t t = 0; t < m_nInitialTriangles; ++t)
+		{
+			if ( m_trianglesTags[t] )
+			{
+				triangles[counter].X() = map[m_triangles[t].X()];
+				triangles[counter].Y() = map[m_triangles[t].Y()];
+				triangles[counter].Z() = map[m_triangles[t].Z()];
+				counter++;
+			}
+		}
+		delete [] map;
+	}
+
+	void MeshDecimator::InitializeQEM()
+	{
+		Vec3<Float> coordMin = m_points[0];
+		Vec3<Float> coordMax = m_points[0];
+		Vec3<Float> coord;
+		for (size_t p = 1; p < m_nPoints ; ++p) 
+		{
+			coord = m_points[p];
+			if (coordMin.X() > coord.X()) coordMin.X() = coord.X();
+			if (coordMin.Y() > coord.Y()) coordMin.Y() = coord.Y();
+			if (coordMin.Z() > coord.Z()) coordMin.Z() = coord.Z();
+			if (coordMax.X() < coord.X()) coordMax.X() = coord.X();
+			if (coordMax.Y() < coord.Y()) coordMax.Y() = coord.Y();
+			if (coordMax.Z() < coord.Z()) coordMax.Z() = coord.Z();
+		}
+		coordMax -= coordMin;
+		m_diagBB = coordMax.GetNorm();
+
+		long i, j, k;
+		Vec3<Float> n;	
+		Float d = 0;
+		Float area = 0;
+		for(size_t v = 0; v < m_nPoints; ++v)
+		{
+			memset(m_vertices[v].m_Q, 0, 10 * sizeof(Float));
+            long idTriangle;
+			for(size_t itT = 0; itT < m_vertices[v].m_triangles.Size(); ++itT)
+			{
+                idTriangle = m_vertices[v].m_triangles[itT];
+				i = m_triangles[idTriangle].X();
+				j = m_triangles[idTriangle].Y();
+				k = m_triangles[idTriangle].Z();
+				n = (m_points[j] - m_points[i])^(m_points[k] - m_points[i]);
+				area = n.GetNorm();
+				n.Normalize();
+				d = - (m_points[v] * n);
+				m_vertices[v].m_Q[0] += area * (n.X() * n.X());
+				m_vertices[v].m_Q[1] += area * (n.X() * n.Y());
+				m_vertices[v].m_Q[2] += area * (n.X() * n.Z());
+				m_vertices[v].m_Q[3] += area * (n.X() * d);
+				m_vertices[v].m_Q[4] += area * (n.Y() * n.Y());
+				m_vertices[v].m_Q[5] += area * (n.Y() * n.Z());
+				m_vertices[v].m_Q[6] += area * (n.Y() * d);
+				m_vertices[v].m_Q[7] += area * (n.Z() * n.Z());
+				m_vertices[v].m_Q[8] += area * (n.Z() * d);
+				m_vertices[v].m_Q[9] += area * (d     * d);
+			}
+		}
+		Vec3<Float> u1, u2;
+		const Float w = static_cast<Float>(1000);
+		long t, v1, v2, v3;
+		for(size_t e = 0; e < m_edges.size(); ++e)
+		{
+			v1 = m_edges[e].m_v1;
+			v2 = m_edges[e].m_v2;
+			t = IsBoundaryEdge(v1, v2);
+			if (t != -1)
+			{
+				if      (m_triangles[t].X() != v1 && m_triangles[t].X() != v2) v3 = m_triangles[t].X();
+				else if (m_triangles[t].Y() != v1 && m_triangles[t].Y() != v2) v3 = m_triangles[t].Y();
+				else														   v3 = m_triangles[t].Z();
+				u1 = m_points[v2] - m_points[v1];
+				u2 = m_points[v3] - m_points[v1];
+				area = w * (u1^u2).GetNorm();
+				u1.Normalize();
+				n =  u2 - (u2 * u1) * u1;
+				n.Normalize();
+
+				d = - (m_points[v1] * n);
+				m_vertices[v1].m_Q[0] += area * (n.X() * n.X());
+				m_vertices[v1].m_Q[1] += area * (n.X() * n.Y());
+				m_vertices[v1].m_Q[2] += area * (n.X() * n.Z());
+				m_vertices[v1].m_Q[3] += area * (n.X() * d);
+				m_vertices[v1].m_Q[4] += area * (n.Y() * n.Y());
+				m_vertices[v1].m_Q[5] += area * (n.Y() * n.Z());
+				m_vertices[v1].m_Q[6] += area * (n.Y() * d);
+				m_vertices[v1].m_Q[7] += area * (n.Z() * n.Z());
+				m_vertices[v1].m_Q[8] += area * (n.Z() * d);
+				m_vertices[v1].m_Q[9] += area * (d * d);
+
+				d = - (m_points[v2] * n);
+				m_vertices[v2].m_Q[0] += area * (n.X() * n.X());
+				m_vertices[v2].m_Q[1] += area * (n.X() * n.Y());
+				m_vertices[v2].m_Q[2] += area * (n.X() * n.Z());
+				m_vertices[v2].m_Q[3] += area * (n.X() * d);
+				m_vertices[v2].m_Q[4] += area * (n.Y() * n.Y());
+				m_vertices[v2].m_Q[5] += area * (n.Y() * n.Z());
+				m_vertices[v2].m_Q[6] += area * (n.Y() * d);
+				m_vertices[v2].m_Q[7] += area * (n.Z() * n.Z());
+				m_vertices[v2].m_Q[8] += area * (n.Z() * d);
+				m_vertices[v2].m_Q[9] += area * (d * d);
+			}
+		}
+	}
+	void MeshDecimator::InitializePriorityQueue()
+	{	
+		double progressOld = -1.0;
+		double progress = 0.0;    
+		char msg[1024];
+		double ptgStep = 1.0;
+		long v1, v2;
+		MDEdgePriorityQueue pqEdge;
+		size_t nE = m_edges.size();
+		for(size_t e = 0; e < nE; ++e)
+		{
+			progress = e * 100.0 / nE;
+			if (fabs(progress-progressOld) > ptgStep && m_callBack)
+			{
+				sprintf(msg, "%3.2f %% \t \t \r", progress);
+				(*m_callBack)(msg, progress, 0.0, m_nVertices);
+				progressOld = progress;
+			}
+
+			if (m_edges[e].m_tag)
+			{
+				v1 = m_edges[e].m_v1;
+				v2 = m_edges[e].m_v2;
+				if ( (!m_ecolManifoldConstraint) || (ManifoldConstraint(v1, v2)))
+				{
+					pqEdge.m_qem = m_edges[e].m_qem = ComputeEdgeCost(v1, v2, m_edges[e].m_pos);
+					pqEdge.m_name = static_cast<long>(e);
+					m_pqueue.push(pqEdge);
+				}
+			}
+		}
+	}
+	double MeshDecimator::ComputeEdgeCost(long v1, long v2, Vec3<Float> & newPos) const
+	{
+		double Q[10];
+		double M[12];
+		Vec3<double> pos;
+		for(int i = 0; i < 10; ++i) Q[i] = m_vertices[v1].m_Q[i] + m_vertices[v2].m_Q[i];
+		M[0] = Q[0]; // (0, 0)
+		M[1] = Q[1]; // (0, 1) 
+		M[2] = Q[2]; // (0, 2)
+		M[3] = Q[3]; // (0, 3)
+		M[4] = Q[1]; // (1, 0)
+		M[5] = Q[4]; // (1, 1)
+		M[6] = Q[5]; // (1, 2)
+		M[7] = Q[6]; // (1, 3)
+		M[8] = Q[2]; // (2, 0)
+		M[9] = Q[5]; // (2, 1)
+		M[10] = Q[7]; // (2, 2);
+		M[11] = Q[8]; // (2, 3);
+		double det =   M[0] * M[5] * M[10] + M[1] * M[6] * M[8] + M[2] * M[4] * M[9]   
+					 - M[0] * M[6] * M[9]  - M[1] * M[4] * M[10]- M[2] * M[5] * M[8]; 
+		if (det != 0.0)
+		{
+			double d = 1.0 / det;
+			pos.X() = d * (M[1]*M[7]*M[10] + M[2]*M[5]*M[11] + M[3]*M[6]*M[9]
+						  -M[1]*M[6]*M[11] - M[2]*M[7]*M[9]  - M[3]*M[5]*M[10]);
+			pos.Y() = d * (M[0]*M[6]*M[11] + M[2]*M[7]*M[8]  + M[3]*M[4]*M[10]
+						  -M[0]*M[7]*M[10] - M[2]*M[4]*M[11] - M[3]*M[6]*M[8]);
+			pos.Z() = d * (M[0]*M[7]*M[9]  + M[1]*M[4]*M[11] + M[3]*M[5]*M[8]
+						  -M[0]*M[5]*M[11] - M[1]*M[7]*M[8]  - M[3]*M[4]*M[9]);
+	  		newPos.X() = static_cast<Float>(pos.X());
+			newPos.Y() = static_cast<Float>(pos.Y());
+			newPos.Z() = static_cast<Float>(pos.Z());
+		}
+		else
+		{
+			const Float w = static_cast<Float>(0.5f);
+			newPos = w * m_points[v1] + w * m_points[v2];
+	  		pos.X() = static_cast<double>(newPos.X());
+			pos.Y() = static_cast<double>(newPos.Y());
+			pos.Z() = static_cast<double>(newPos.Z());
+		}
+
+		double qem = pos.X()  * (Q[0] * pos.X() + Q[1] * pos.Y() + Q[2] * pos.Z() + Q[3]) +  
+					 pos.Y()  * (Q[1] * pos.X() + Q[4] * pos.Y() + Q[5] * pos.Z() + Q[6]) +
+					 pos.Z()  * (Q[2] * pos.X() + Q[5] * pos.Y() + Q[7] * pos.Z() + Q[8]) +
+								(Q[3] * pos.X() + Q[6] * pos.Y() + Q[8] * pos.Z() + Q[9]) ;
+
+		Vec3<Float> d1;
+		Vec3<Float> d2;
+		Vec3<Float> n1;
+		Vec3<Float> n2;
+        Vec3<Float> oldPosV1 =  m_points[v1];
+        Vec3<Float> oldPosV2 =  m_points[v2];
+
+		SArray<long, SARRAY_DEFAULT_MIN_SIZE> triangles = m_vertices[v1].m_triangles;
+		long idTriangle;
+		for(size_t itT = 0; itT < m_vertices[v2].m_triangles.Size(); ++itT)
+		{
+            idTriangle = m_vertices[v2].m_triangles[itT];
+			triangles.Insert(idTriangle);
+		}
+		long a[3];
+        for(size_t itT = 0; itT != triangles.Size(); ++itT)
+		{
+            idTriangle = triangles[itT];
+			a[0] = m_triangles[idTriangle].X();
+			a[1] = m_triangles[idTriangle].Y();
+			a[2] = m_triangles[idTriangle].Z();
+
+			d1 = m_points[a[1]] - m_points[a[0]];
+			d2 = m_points[a[2]] - m_points[a[0]];
+			n1 = d1^d2;
+
+            m_points[v1] = newPos;
+            m_points[v2] = newPos;
+
+			d1 = m_points[a[1]] - m_points[a[0]];
+			d2 = m_points[a[2]] - m_points[a[0]];
+            n2 = d1^d2;
+
+            m_points[v1] = oldPosV1;
+            m_points[v2] = oldPosV2;
+
+            n1.Normalize();
+            n2.Normalize();
+			if (n1*n2 < 0.0) 
+            {
+                return std::numeric_limits<double>::max();
+            }
+		}
+		if ( m_ecolManifoldConstraint && !ManifoldConstraint(v1, v2))
+		{
+			return std::numeric_limits<double>::max();
+		}
+		return qem;
+	}
+	bool MeshDecimator::ManifoldConstraint(long v1, long v2) const
+	{
+		std::set<long> vertices;
+		long a, b;
+        long idEdge1;
+        long idEdge2;
+		long idEdgeV1V2;
+		for(size_t itE1 = 0; itE1 < m_vertices[v1].m_edges.Size(); ++itE1)
+		{
+            idEdge1 = m_vertices[v1].m_edges[itE1];
+			a = (m_edges[idEdge1].m_v1 == v1) ? m_edges[idEdge1].m_v2 : m_edges[idEdge1].m_v1;
+			vertices.insert(a);
+			if (a != v2)
+			{
+				for(size_t itE2 = 0; itE2 < m_vertices[v2].m_edges.Size(); ++itE2)
+				{
+                    idEdge2 = m_vertices[v2].m_edges[itE2];
+					b = (m_edges[idEdge2].m_v1 == v2) ? m_edges[idEdge2].m_v2 : m_edges[idEdge2].m_v1;
+					vertices.insert(b);
+					if ( a==b )
+					{
+						if (GetTriangle(v1, v2, a) == -1)
+						{
+							return false;
+						}
+					}
+				}
+			}
+			else
+			{
+				idEdgeV1V2 = idEdge1;
+			}
+		}
+		if (vertices.size() <= 4 || ( m_vertices[v1].m_onBoundary && m_vertices[v2].m_onBoundary && !m_edges[idEdgeV1V2].m_onBoundary))
+		{
+			return false;
+		}
+		return true;
+	}
+	bool MeshDecimator::EdgeCollapse(double & qem)
+	{
+		MDEdgePriorityQueue currentEdge;
+		long v1, v2;
+		bool done = false;
+		do
+		{
+			done = false;
+			if (m_pqueue.size() == 0)
+			{
+				done = true;
+				break;
+			}
+			else
+			{
+				currentEdge = m_pqueue.top();
+				m_pqueue.pop();
+			}
+		}
+		while ( (!m_edges[currentEdge.m_name].m_tag) || (m_edges[currentEdge.m_name].m_qem != currentEdge.m_qem));
+		
+		if (done) return false;
+		v1 = m_edges[currentEdge.m_name].m_v1;
+		v2 = m_edges[currentEdge.m_name].m_v2;
+
+		qem = currentEdge.m_qem;
+		EdgeCollapse(v1, v2);
+		m_points[v1] = m_edges[currentEdge.m_name].m_pos ;
+		for(int k = 0; k < 10; k++) m_vertices[v1].m_Q[k] += m_vertices[v2].m_Q[k];
+
+		// Update priority queue
+		long idEdge;
+        long a, b;
+        SArray<long, SARRAY_DEFAULT_MIN_SIZE> incidentVertices;
+		for(size_t itE = 0; itE < m_vertices[v1].m_edges.Size(); ++itE)
+		{
+            idEdge = m_vertices[v1].m_edges[itE];
+			a = m_edges[idEdge].m_v1;
+			b = m_edges[idEdge].m_v2;
+            incidentVertices.PushBack((a != v1)?a:b);
+			MDEdgePriorityQueue pqEdge;
+			pqEdge.m_qem = m_edges[idEdge].m_qem = ComputeEdgeCost(a, b, m_edges[idEdge].m_pos);
+			pqEdge.m_name = idEdge;
+			m_pqueue.push(pqEdge);
+		}
+        long idVertex;
+		for(size_t itV = 0; itV< incidentVertices.Size(); ++itV)
+		{
+            idVertex = incidentVertices[itV];
+		    for(size_t itE = 0; itE < m_vertices[idVertex].m_edges.Size(); ++itE)
+		    {
+                idEdge = m_vertices[idVertex].m_edges[itE];
+			    a = m_edges[idEdge].m_v1;
+			    b = m_edges[idEdge].m_v2;
+			    if ( a!=v1 && b!=v1)
+			    {
+				    MDEdgePriorityQueue pqEdge;
+				    pqEdge.m_qem = m_edges[idEdge].m_qem = ComputeEdgeCost(a, b, m_edges[idEdge].m_pos);
+				    pqEdge.m_name = idEdge;
+				    m_pqueue.push(pqEdge);
+			    }
+		    }
+        }
+		return true;	
+	}
+	bool MeshDecimator::Decimate(size_t targetNVertices, size_t targetNTriangles, double targetError)
+	{
+		double qem = 0.0;
+		double progressOld = -1.0;
+		double progress = 0.0;    
+		char msg[1024];
+		double ptgStep = 1.0;
+
+		if (m_callBack)
+		{
+			std::ostringstream msg;
+			msg << "+ Mesh" << std::endl;
+			msg << "\t # vertices                     \t" << m_nPoints << std::endl;
+			msg << "\t # triangles                    \t" << m_nTriangles << std::endl;
+			msg << "+ Parameters" << std::endl;
+			msg << "\t target # of vertices           \t" << targetNVertices << std::endl;
+			msg << "\t target # of triangles          \t" << targetNTriangles << std::endl;
+			msg << "\t QEM			                  \t" << targetError << std::endl;
+			(*m_callBack)(msg.str().c_str(), 0.0, 0.0, m_nPoints);
+		}
+		
+		if (m_callBack) (*m_callBack)("+ Initialize QEM \n", 0.0, 0.0, m_nPoints);
+		InitializeQEM();
+		if (m_callBack) (*m_callBack)("+ Initialize priority queue \n", 0.0, 0.0, m_nPoints);
+		InitializePriorityQueue();
+		if (m_callBack) (*m_callBack)("+ Simplification \n", 0.0, 0.0, m_nPoints);
+		double invDiag2 = 1.0 / (m_diagBB * m_diagBB);
+		while((m_pqueue.size() > 0) && 
+			  (m_nEdges > 0) && 
+			  (m_nVertices > targetNVertices) &&
+			  (m_nTriangles > targetNTriangles) &&
+			  (qem < targetError))
+		{
+			progress = 100.0 - m_nVertices * 100.0 / m_nPoints;
+			if (fabs(progress-progressOld) > ptgStep && m_callBack)
+			{
+				sprintf(msg, "%3.2f %% V = %lu \t QEM = %f \t \t \r", progress, static_cast<unsigned long>(m_nVertices), sqrt(qem));
+				(*m_callBack)(msg, progress, qem, m_nVertices);
+				progressOld = progress;
+			}
+			if (!EdgeCollapse(qem)) break;
+			qem *= invDiag2;
+		}
+		if (m_callBack)
+		{
+			std::ostringstream msg;
+			msg << "+ Simplification output" << std::endl;
+			msg << "\t # vertices                     \t" << m_nVertices << std::endl;
+			msg << "\t # triangles                    \t" << m_nTriangles << std::endl;
+			msg << "\t QEM					          \t" << qem << std::endl;
+			(*m_callBack)(msg.str().c_str(), 100.0, qem, m_nVertices);
+		}
+		return true;
+	}
+}

indra/libhacd/hacdMeshDecimator.h

@@ -0,0 +1,116 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+All rights reserved.
+
+
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#pragma once
+#ifndef HACD_MESH_DECEMATOR_H
+#define HACD_MESH_DECEMATOR_H
+#include <queue>
+#include <set>
+#include <vector>
+#include <limits>
+#include "hacdVersion.h"
+#include "hacdVector.h"
+#include "hacdSArray.h"
+#include "hacdHACD.h"
+
+namespace HACD
+{
+	typedef double Float;
+	struct MDVertex
+	{
+		SArray<long, SARRAY_DEFAULT_MIN_SIZE>   m_edges;	
+		SArray<long, SARRAY_DEFAULT_MIN_SIZE>	m_triangles;	
+		Float									m_Q[10];
+												// 0 1 2 3
+	  											//   4 5 6
+	   											//     7 8
+		  										//       9
+		bool									m_tag;
+		bool									m_onBoundary;
+	};
+	
+	struct MDEdge
+	{
+		long									m_v1;		
+		long									m_v2;		
+		double									m_qem;	
+		Vec3<Float>								m_pos;
+		bool									m_onBoundary;
+		bool									m_tag;
+	};
+	struct MDEdgePriorityQueue
+	{
+		long									m_name;		
+		double									m_qem;	
+		inline	friend bool						operator<(const MDEdgePriorityQueue & lhs, const MDEdgePriorityQueue & rhs) { return (lhs.m_qem > rhs.m_qem);}
+		inline	friend bool						operator>(const MDEdgePriorityQueue & lhs, const MDEdgePriorityQueue & rhs) { return (lhs.m_qem < rhs.m_qem);}
+	};
+
+	class MeshDecimator
+	{
+	public:
+		//! Sets the call-back function
+		//! @param callBack pointer to the call-back function
+		void									SetCallBack(CallBackFunction  callBack) { m_callBack = callBack;}
+		//! Gives the call-back function
+		//! @return pointer to the call-back function
+		const CallBackFunction                  GetCallBack() const { return m_callBack;}
+
+		inline void								SetEColManifoldConstraint(bool ecolManifoldConstraint) { m_ecolManifoldConstraint = ecolManifoldConstraint; }
+		inline size_t							GetNVertices()const {return m_nVertices;};
+		inline size_t							GetNTriangles() const {return m_nTriangles;};
+		inline size_t							GetNEdges() const {return m_nEdges;};
+		void									GetMeshData(Vec3<Float> * points, Vec3<long> * triangles) const;
+		void									ReleaseMemory();
+		void									Initialize(size_t nVertices, size_t nTriangles, 
+														   Vec3<Float> *  points, 
+														   Vec3<long> * triangles);		
+		bool 									Decimate(size_t targetNVertices = 100, 
+														 size_t targetNTriangles = 0, 
+														 double targetError = std::numeric_limits<double>::max());
+
+												MeshDecimator(void);
+												~MeshDecimator(void);
+	private : 
+		void									EdgeCollapse(long v1, long v2);
+		long									GetTriangle(long v1, long v2, long v3) const;
+		long									GetEdge(long v1, long v2) const;
+		long									IsBoundaryEdge(long v1, long v2) const;
+		bool									IsBoundaryVertex(long v) const;
+		void									InitializePriorityQueue();
+		void									InitializeQEM();
+		bool									ManifoldConstraint(long v1, long v2) const;
+		double									ComputeEdgeCost(long v1, long v2, Vec3<Float> & pos) const;
+		bool									EdgeCollapse(double & error);
+	private:
+		Vec3<long> *							m_triangles;			
+		Vec3<Float> *							m_points;		
+		size_t									m_nPoints;
+		size_t									m_nInitialTriangles;
+		size_t									m_nVertices;
+		size_t									m_nTriangles;
+		size_t									m_nEdges;
+		double									m_diagBB;
+		std::vector<MDVertex>					m_vertices;
+		std::vector<MDEdge>						m_edges;
+		std::priority_queue<
+			 MDEdgePriorityQueue, 
+			 std::vector<MDEdgePriorityQueue>, 
+			 std::less<MDEdgePriorityQueue> >	m_pqueue;
+		CallBackFunction						m_callBack;					//>! call-back function
+		bool *									m_trianglesTags;
+		bool									m_ecolManifoldConstraint;
+	};
+}
+#endif

indra/libhacd/hacdMicroAllocator.cpp

@@ -0,0 +1,993 @@
+#include "hacdMicroAllocator.h"
+
+/*!
+**
+** Copyright (c) 2009 by John W. Ratcliff mailto:jratcliffscarab@gmail.com
+**
+** If you find this code useful or you are feeling particularily generous I would
+** ask that you please go to http://www.amillionpixels.us and make a donation
+** to Troy DeMolay.
+**
+**
+** If you wish to contact me you can use the following methods:
+**
+** Skype ID: jratcliff63367
+** email: jratcliffscarab@gmail.com
+**
+**
+** The MIT license:
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is furnished
+** to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in all
+** copies or substantial portions of the Software.
+
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+** WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+
+
+#include <new>
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#if defined(__APPLE__) || defined(LINUX)
+#include <pthread.h>
+#endif
+
+
+#pragma warning(disable:4100)
+
+namespace HACD
+{
+
+//==================================================================================
+class MemMutex
+{
+	public:
+		MemMutex(void);
+		~MemMutex(void);
+
+	public:
+		// Blocking Lock.
+		void Lock(void);
+
+		// Unlock.
+		void Unlock(void);
+
+private:
+		#if defined(_WIN32) || defined(_XBOX)
+		CRITICAL_SECTION m_Mutex;
+		#elif defined(__APPLE__) || defined(LINUX)
+		pthread_mutex_t  m_Mutex;
+		#endif
+};
+
+//==================================================================================
+MemMutex::MemMutex(void)
+{
+#if defined(_WIN32) || defined(_XBOX)
+	InitializeCriticalSection(&m_Mutex);
+#elif defined(__APPLE__) || defined(LINUX)
+	pthread_mutexattr_t mta;
+	pthread_mutexattr_init(&mta);
+	pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init(&m_Mutex, &mta);
+	pthread_mutexattr_destroy(&mta);
+#endif
+}
+
+//==================================================================================
+MemMutex::~MemMutex(void)
+{
+#if defined(_WIN32) || defined(_XBOX)
+	DeleteCriticalSection(&m_Mutex);
+#elif defined(__APPLE__) || defined(LINUX)
+	pthread_mutex_destroy(&m_Mutex);
+#endif
+}
+
+//==================================================================================
+// Blocking Lock.
+//==================================================================================
+void MemMutex::Lock(void)
+{
+#if defined(_WIN32) || defined(_XBOX)
+	EnterCriticalSection(&m_Mutex);
+#elif defined(__APPLE__) || defined(LINUX)
+	pthread_mutex_lock(&m_Mutex);
+#endif
+}
+
+//==================================================================================
+// Unlock.
+//==================================================================================
+void MemMutex::Unlock(void)
+{
+#if defined(_WIN32) || defined(_XBOX)
+	LeaveCriticalSection(&m_Mutex);
+#elif defined(__APPLE__) || defined(LINUX)
+	pthread_mutex_unlock(&m_Mutex);
+#endif
+}
+
+
+
+struct ChunkHeader
+{
+  ChunkHeader   *mNextChunk;
+};
+
+// interface to add and remove new chunks to the master list.
+class MicroChunkUpdate
+{
+public:
+  virtual void addMicroChunk(NxU8 *memStart,NxU8 *memEnd,MemoryChunk *chunk) = 0;
+  virtual void removeMicroChunk(MemoryChunk *chunk) = 0;
+};
+
+class MemoryHeader
+{
+public:
+  MemoryHeader *mNext;
+};
+
+// a single fixed size chunk for micro-allocations.
+class MemoryChunk
+{
+public:
+  MemoryChunk(void)
+  {
+    mData       = 0;
+    mDataEnd    = 0;
+    mUsedCount  = 0;
+    mFreeList   = 0;
+    mMyHeap     = false;
+    mChunkSize  = 0;
+  }
+
+  NxU8 * init(NxU8 *chunkBase,NxU32 chunkSize,NxU32 maxChunks)
+  {
+    mChunkSize  = chunkSize;
+    mData     =  chunkBase;
+    mDataEnd  = mData+(chunkSize*maxChunks);
+    mFreeList = (MemoryHeader *) mData;
+    MemoryHeader *scan = mFreeList;
+    NxU8 *data = mData;
+    data+=chunkSize;
+    for (NxU32 i=0; i<(maxChunks-1); i++)
+    {
+        MemoryHeader *next = (MemoryHeader *)data;
+        scan->mNext = next;
+        data+=chunkSize;
+        scan = next;
+    }
+    scan->mNext = 0;
+    return mDataEnd;
+  }
+
+  inline void * allocate(MicroHeap *heap,NxU32 chunkSize,NxU32 maxChunks,MicroChunkUpdate *update)
+  {
+    void *ret = 0;
+
+    if ( mData == 0 )
+    {
+        mMyHeap = true;
+        mData = (NxU8 *)heap->micro_malloc( chunkSize * maxChunks );
+        init(mData,chunkSize,maxChunks);
+        update->addMicroChunk(mData,mDataEnd,this);
+    }
+    if ( mFreeList )
+    {
+        mUsedCount++;
+        ret = mFreeList;
+        mFreeList = mFreeList->mNext;
+    }
+    return ret;
+  }
+
+  inline void deallocate(void *p,MicroHeap *heap,MicroChunkUpdate *update)
+  {
+#ifdef _DEBUG
+    assert(mUsedCount);
+    NxU8 *s = (NxU8 *)p;
+    assert( s >= mData && s < mDataEnd );
+#endif
+    MemoryHeader *mh = mFreeList;
+    mFreeList = (MemoryHeader *)p;
+    mFreeList->mNext = mh;
+    mUsedCount--;
+    if ( mUsedCount == 0 && mMyHeap  ) // free the heap back to the application if we are done with this.
+    {
+        update->removeMicroChunk(this);
+        heap->micro_free(mData);
+        mMyHeap = false;
+        mData   = 0;
+        mDataEnd = 0;
+        mFreeList = 0;
+    }
+  }
+
+  NxU32 getChunkSize(void) const { return mChunkSize; };
+
+  bool isInside(const NxU8 *p) const
+  {
+	  return p>=mData && p < mDataEnd; 
+  }
+
+private:
+  bool          mMyHeap;
+  NxU8         *mData;
+  NxU8         *mDataEnd;
+  NxU32         mUsedCount;
+  MemoryHeader *mFreeList;
+  NxU32         mChunkSize;
+};
+
+#define DEFAULT_CHUNKS 32
+
+class MemoryChunkChunk
+{
+public:
+  MemoryChunkChunk(void)
+  {
+    mNext = 0;
+    mChunkSize = 0;
+	mMaxChunks = 0;
+  }
+
+  ~MemoryChunkChunk(void)
+  {
+  }
+
+  inline void * allocate(MemoryChunk *&current,MicroChunkUpdate *update)
+  {
+    void *ret = 0;
+
+    MemoryChunkChunk *scan = this;
+    while ( scan && ret == 0 )
+    {
+      for (NxU32 i=0; i<DEFAULT_CHUNKS; i++)
+      {
+          ret = scan->mChunks[i].allocate(mHeap,mChunkSize,mMaxChunks,update);
+          if ( ret )
+          {
+            current = &scan->mChunks[i];
+            scan = 0;
+            break;
+          }
+      }
+      if ( scan )
+        scan = scan->mNext;
+    }
+
+    if ( !ret )
+    {
+        MemoryChunkChunk *mcc = (MemoryChunkChunk *)mHeap->micro_malloc( sizeof(MemoryChunkChunk) );
+        new ( mcc ) MemoryChunkChunk;
+        MemoryChunkChunk *onext = mNext;
+        mNext = mcc;
+        mcc->mNext = onext;
+        ret = mcc->mChunks[0].allocate(mHeap,mChunkSize,mMaxChunks,update);
+        current = &mcc->mChunks[0];
+    }
+
+    return ret;
+  }
+
+  NxU8 * init(NxU8 *chunkBase,NxU32 fixedSize,NxU32 chunkSize,MemoryChunk *&current,MicroHeap *heap)
+  {
+    mHeap = heap;
+    mChunkSize = chunkSize;
+	mMaxChunks = fixedSize/chunkSize;
+    current = &mChunks[0];
+    chunkBase = mChunks[0].init(chunkBase,chunkSize,mMaxChunks);
+    return chunkBase;
+  }
+
+  MicroHeap        *mHeap;
+  NxU32             mChunkSize;
+  NxU32             mMaxChunks;
+  MemoryChunkChunk *mNext;
+  MemoryChunk       mChunks[DEFAULT_CHUNKS];
+};
+
+class FixedMemory
+{
+public:
+  FixedMemory(void)
+  {
+    mCurrent = 0;
+  }
+
+  void * allocate(MicroChunkUpdate *update)
+  {
+    void *ret = mCurrent->allocate(mChunks.mHeap,mChunks.mChunkSize,mChunks.mMaxChunks,update);
+    if ( ret == 0 )
+    {
+        ret = mChunks.allocate(mCurrent,update);
+    }
+	return ret;
+  }
+
+  NxU8 * init(NxU8 *chunkBase,NxU32 chunkSize,NxU32 fixedSize,MicroHeap *heap)
+  {
+	mMemBegin = chunkBase;
+	mMemEnd   = chunkBase+fixedSize;
+    mChunks.init(chunkBase,fixedSize,chunkSize,mCurrent,heap);
+	return mMemEnd;
+  }
+
+  NxU8            *mMemBegin;
+  NxU8            *mMemEnd;
+  MemoryChunk     *mCurrent; // the current memory chunk we are operating in.
+  MemoryChunkChunk mChunks;  // the collection of all memory chunks used.
+};
+
+class MicroChunk
+{
+public:
+
+  void set(NxU8 *memStart,NxU8 *memEnd,MemoryChunk *mc)
+  {
+    mMemStart = memStart;
+    mMemEnd   = memEnd;
+    mChunk    = mc;
+    mPad      = 0;
+  }
+
+  inline bool inside(const NxU8 *p) const
+  {
+    return p >= mMemStart && p < mMemEnd;
+  }
+
+  NxU8        *mMemStart;
+  NxU8        *mMemEnd;
+  MemoryChunk *mChunk;
+  NxU8        *mPad; // padding to make it 16 byte aligned.
+};
+
+class MyMicroAllocator : public MicroAllocator, public MicroChunkUpdate, public MemMutex
+{
+public:
+  MyMicroAllocator(MicroHeap *heap,void *baseMem,NxU32 initialSize,NxU32 chunkSize)
+  {
+    mLastMicroChunk     = 0;
+    mMicroChunks        = 0;
+    mMicroChunkCount    = 0;
+    mMaxMicroChunks		= 0;
+	mHeap               = heap;
+	mChunkSize          = chunkSize;
+
+    // 0 through 8 bytes
+    for (NxU32 i=0; i<=8; i++)
+    {
+        mFixedAllocators[i] = &mAlloc[0];
+    }
+
+    // 9 through 16 bytes
+    for (NxU32 i=9; i<=16; i++)
+    {
+        mFixedAllocators[i] = &mAlloc[1];
+    }
+
+    // 17 through 32 bytes
+    for (NxU32 i=17; i<=32; i++)
+    {
+        mFixedAllocators[i] = &mAlloc[2];
+    }
+
+    // 33 through 64
+    for (NxU32 i=33; i<=64; i++)
+    {
+        mFixedAllocators[i] = &mAlloc[3];
+    }
+
+    // 65 through 128
+    for (NxU32 i=65; i<=128; i++)
+    {
+        mFixedAllocators[i] = &mAlloc[4];
+    }
+
+    // 129 through 255
+    for (NxU32 i=129; i<257; i++)
+    {
+        mFixedAllocators[i] = &mAlloc[5];
+    }
+
+    mBaseMem = (NxU8 *)baseMem;
+    mBaseMemEnd = mBaseMem+initialSize;
+
+    NxU8 *chunkBase = (NxU8 *)baseMem+sizeof(MyMicroAllocator);
+
+
+    chunkBase+=32;
+	NxU64 ptr = (NxU64)chunkBase;
+	ptr = ptr>>4;
+	ptr = ptr<<4; // make sure it is 16 byte aligned.
+	chunkBase = (NxU8 *)ptr;
+
+    mChunkStart = chunkBase;
+    chunkBase = mAlloc[0].init(chunkBase,8,chunkSize,heap);
+    chunkBase = mAlloc[1].init(chunkBase,16,chunkSize,heap);
+    chunkBase = mAlloc[2].init(chunkBase,32,chunkSize,heap);
+    chunkBase = mAlloc[3].init(chunkBase,64,chunkSize,heap);
+    chunkBase = mAlloc[4].init(chunkBase,128,chunkSize,heap);
+    chunkBase = mAlloc[5].init(chunkBase,256,chunkSize,heap);
+	mChunkEnd = chunkBase;
+
+    assert(chunkBase <= mBaseMemEnd );
+
+  }
+
+  ~MyMicroAllocator(void)
+  {
+    if ( mMicroChunks )
+    {
+        mHeap->micro_free(mMicroChunks);
+    }
+  }
+
+  virtual NxU32           getChunkSize(MemoryChunk *chunk) 
+  {
+	  return chunk ? chunk->getChunkSize() : 0;
+  }
+
+  // we have to steal one byte out of every allocation to record the size, so we can efficiently de-allocate it later.
+  virtual void * malloc(size_t size)
+  {
+    void *ret = 0;
+	Lock();
+   assert( size <= 256 );
+   if ( size <= 256 )
+   {
+     ret = mFixedAllocators[size]->allocate(this);
+   }
+   Unlock();
+    return ret;
+  }
+
+  virtual void   free(void *p,MemoryChunk *chunk)
+  {
+    Lock();
+    chunk->deallocate(p,mHeap,this);
+	Unlock();
+  }
+
+  // perform a binary search on the sorted list of chunks.
+  MemoryChunk * binarySearchMicroChunks(const NxU8 *p)
+  {
+	  MemoryChunk *ret = 0;
+
+	  NxU32 low = 0;
+	  NxU32 high = mMicroChunkCount;
+
+	  while ( low != high )
+	  {
+		  NxU32 mid = (high-low)/2+low;
+		  MicroChunk &chunk = mMicroChunks[mid];
+		  if ( chunk.inside(p))
+		  {
+			  mLastMicroChunk = &chunk;
+			  ret = chunk.mChunk;
+			  break;
+		  }
+		  else
+		  {
+			  if ( p > chunk.mMemEnd )
+			  {
+				  low = mid+1;
+			  }
+			  else
+			  {
+				  high = mid;
+			  }
+		  }
+	  }
+
+	  return ret;
+  }
+
+  virtual MemoryChunk *   isMicroAlloc(const void *p)  // returns true if this pointer is handled by the micro-allocator.
+  {
+    MemoryChunk *ret = 0;
+
+	Lock();
+
+    const NxU8 *s = (const NxU8 *)p;
+
+    if ( s >= mChunkStart && s < mChunkEnd )
+    {
+        NxU32 index = (NxU32)(s-mChunkStart)/mChunkSize;
+        assert(index>=0 && index < 6 );
+        ret = &mAlloc[index].mChunks.mChunks[0];
+		assert( ret->isInside(s) );
+    }
+	else if ( mMicroChunkCount )
+	{
+        if ( mLastMicroChunk && mLastMicroChunk->inside(s) )
+        {
+            ret = mLastMicroChunk->mChunk;
+        }
+        else
+        {
+			if ( mMicroChunkCount >= 4 )
+			{
+				ret = binarySearchMicroChunks(s);
+#ifdef _DEBUG
+				if (ret )
+				{
+					assert( ret->isInside(s) );
+				}
+				else 
+				{
+					for (NxU32 i=0; i<mMicroChunkCount; i++)
+					{
+						assert( !mMicroChunks[i].inside(s) );
+					}
+				}
+#endif
+			}
+			else
+			{
+				for (NxU32 i=0; i<mMicroChunkCount; i++)
+				{
+					if ( mMicroChunks[i].inside(s) )
+					{
+						ret = mMicroChunks[i].mChunk;
+						assert( ret->isInside(s) );
+						mLastMicroChunk = &mMicroChunks[i];
+						break;
+					}
+				}
+			}
+        }
+	}
+#ifdef _DEBUG
+	if ( ret )
+		assert( ret->isInside(s) );
+#endif
+	Unlock();
+    return ret;
+  }
+
+  MicroHeap * getMicroHeap(void) const { return mHeap; };
+
+  void allocateMicroChunks(void)
+  {
+    if ( mMaxMicroChunks == 0 )
+    {
+        mMaxMicroChunks = 64; // initial reserve.
+        mMicroChunks = (MicroChunk *)mHeap->micro_malloc( sizeof(MicroChunk)*mMaxMicroChunks );
+    }
+    else
+    {
+        mMaxMicroChunks*=2;
+        mMicroChunks = (MicroChunk *)mHeap->micro_realloc( mMicroChunks, sizeof(MicroChunk)*mMaxMicroChunks);
+    }
+  }
+
+  // perform an insertion sort of the new chunk.
+  virtual void addMicroChunk(NxU8 *memStart,NxU8 *memEnd,MemoryChunk *chunk)
+  {
+    if ( mMicroChunkCount >= mMaxMicroChunks )
+    {
+        allocateMicroChunks();
+    }
+
+    bool inserted = false;
+    for (NxU32 i=0; i<mMicroChunkCount; i++)
+    {
+        if ( memEnd < mMicroChunks[i].mMemStart )
+        {
+            for (NxU32 j=mMicroChunkCount; j>i; j--)
+            {
+                mMicroChunks[j] = mMicroChunks[j-1];
+            }
+            mMicroChunks[i].set( memStart, memEnd, chunk );
+			mLastMicroChunk = &mMicroChunks[i];
+            mMicroChunkCount++;
+            inserted = true;
+            break;
+        }
+    }
+    if ( !inserted )
+    {
+        mMicroChunks[mMicroChunkCount].set(memStart,memEnd,chunk);
+		mLastMicroChunk = &mMicroChunks[mMicroChunkCount];
+        mMicroChunkCount++;
+    }
+  }
+
+  virtual void removeMicroChunk(MemoryChunk *chunk)
+  {
+    mLastMicroChunk = 0;
+    #ifdef _DEBUG
+    bool removed = false;
+    #endif
+    for (NxU32 i=0; i<mMicroChunkCount; i++)
+    {
+        if ( mMicroChunks[i].mChunk == chunk )
+        {
+            mMicroChunkCount--;
+            for (NxU32 j=i; j<mMicroChunkCount; j++)
+            {
+                mMicroChunks[j] = mMicroChunks[j+1];
+            }
+            #ifdef _DEBUG
+            removed = true;
+            #endif
+            break;
+        }
+    }
+#ifdef _DEBUG
+    assert(removed);
+#endif
+  }
+
+  inline void * inline_malloc(size_t size)
+  {
+     Lock();
+     void *ret = mFixedAllocators[size]->allocate(this);
+	 Unlock();
+	 return ret;
+  }
+
+  inline void            inline_free(void *p,MemoryChunk *chunk) // free relative to previously located MemoryChunk
+  {
+	Lock();
+    chunk->deallocate(p,mHeap,this);
+	Unlock();
+  }
+
+  inline MemoryChunk *   inline_isMicroAlloc(const void *p) // returns pointer to the chunk this memory belongs to, or null if not a micro-allocated block.
+  {
+    MemoryChunk *ret = 0;
+
+	Lock();
+
+    const NxU8 *s = (const NxU8 *)p;
+
+    if ( s >= mChunkStart && s < mChunkEnd )
+    {
+        NxU32 index = (NxU32)(s-mChunkStart)/mChunkSize;
+        assert(index>=0 && index < 6 );
+        ret = &mAlloc[index].mChunks.mChunks[0];
+    }
+	else if ( mMicroChunkCount )
+	{
+        if ( mLastMicroChunk && mLastMicroChunk->inside(s) )
+        {
+            ret = mLastMicroChunk->mChunk;
+        }
+        else
+        {
+			if ( mMicroChunkCount >= 4 )
+			{
+				ret = binarySearchMicroChunks(s);
+			}
+			else
+			{
+				for (NxU32 i=0; i<mMicroChunkCount; i++)
+				{
+					if ( mMicroChunks[i].inside(s) )
+					{
+						ret = mMicroChunks[i].mChunk;
+						mLastMicroChunk = &mMicroChunks[i];
+						break;
+					}
+				}
+			}
+        }
+	}
+
+	Unlock();
+
+    return ret;
+  }
+
+
+private:
+  MicroHeap   *mHeap;
+  NxU8        *mBaseMem;
+  NxU8        *mBaseMemEnd;
+  FixedMemory *mFixedAllocators[257];
+  NxU32        mChunkSize;
+  NxU8        *mChunkStart;
+  NxU8        *mChunkEnd;
+
+  NxU32        mMaxMicroChunks;
+  NxU32        mMicroChunkCount;
+  MicroChunk  *mLastMicroChunk;
+  MicroChunk  *mMicroChunks;
+
+  FixedMemory  mAlloc[6];
+};
+
+
+MicroAllocator *createMicroAllocator(MicroHeap *heap,NxU32 chunkSize)
+{
+    NxU32 initialSize = chunkSize*6+sizeof(MyMicroAllocator)+32;
+    void *baseMem = heap->micro_malloc(initialSize);
+    MyMicroAllocator *mc = (MyMicroAllocator *)baseMem;
+    new ( mc ) MyMicroAllocator(heap,baseMem,initialSize,chunkSize);
+    return static_cast< MicroAllocator *>(mc);
+}
+
+void releaseMicroAllocator(MicroAllocator *m)
+{
+    MyMicroAllocator *mc = static_cast< MyMicroAllocator *>(m);
+	MicroHeap *mh = mc->getMicroHeap();
+    mc->~MyMicroAllocator();
+	mh->micro_free(mc);
+}
+
+class MyHeapManager : public MicroHeap, public HeapManager
+{
+public:
+  MyHeapManager(NxU32 defaultChunkSize)
+  {
+    mMicro = createMicroAllocator(this,defaultChunkSize);
+  }
+
+  ~MyHeapManager(void)
+  {
+    releaseMicroAllocator(mMicro);
+  }
+
+  // heap allocations used by the micro allocator.
+  virtual void * micro_malloc(size_t size)
+  {
+    return ::malloc(size);
+  }
+
+  virtual void   micro_free(void *p)
+  {
+    return ::free(p);
+  }
+
+  virtual void * micro_realloc(void *oldMem,size_t newSize)
+  {
+    return ::realloc(oldMem,newSize);
+  }
+
+  virtual void * heap_malloc(size_t size)
+  {
+    void *ret;
+
+    if ( size <= 256 ) // micro allocator only handles allocations between 0 and 256 bytes in length.
+    {
+        ret = mMicro->malloc(size);
+    }
+    else
+    {
+        ret = ::malloc(size);
+    }
+    return ret;
+  }
+
+  virtual void   heap_free(void *p)
+  {
+    MemoryChunk *chunk = mMicro->isMicroAlloc(p);
+    if ( chunk )
+    {
+        mMicro->free(p,chunk);
+    }
+    else
+    {
+        ::free(p);
+    }
+  }
+
+  virtual void * heap_realloc(void *oldMem,size_t newSize)
+  {
+    void *ret = 0;
+
+    MemoryChunk *chunk = mMicro->isMicroAlloc(oldMem);
+    if ( chunk )
+    {
+        ret = heap_malloc(newSize);
+        NxU32 oldSize = chunk->getChunkSize();
+        if ( oldSize < newSize )
+        {
+            memcpy(ret,oldMem,oldSize);
+        }
+        else
+        {
+            memcpy(ret,oldMem,newSize);
+        }
+        mMicro->free(oldMem,chunk);
+    }
+    else
+    {
+        ret = ::realloc(oldMem,newSize);
+    }
+
+    return ret;
+  }
+
+  inline void * inline_heap_malloc(size_t size)
+  {
+    return size<=256 ? ((MyMicroAllocator *)mMicro)->inline_malloc(size) : ::malloc(size);
+  }
+
+  inline void   inline_heap_free(void *p)
+  {
+	  MemoryChunk *chunk = ((MyMicroAllocator *)mMicro)->inline_isMicroAlloc(p);
+	  if ( chunk )
+	  {
+		  ((MyMicroAllocator *)mMicro)->inline_free(p,chunk);
+	  }
+	  else
+	  {
+		  ::free(p);
+	  }
+
+  }
+
+private:
+  MicroAllocator *mMicro;
+};
+
+
+HeapManager * createHeapManager(NxU32 defaultChunkSize)
+{
+    MyHeapManager *m = (MyHeapManager *)::malloc(sizeof(MyHeapManager));
+    new ( m ) MyHeapManager(defaultChunkSize);
+    return static_cast< HeapManager *>(m);
+}
+
+void          releaseHeapManager(HeapManager *heap)
+{
+    MyHeapManager *m = static_cast< MyHeapManager *>(heap);
+    m->~MyHeapManager();
+	free(m);
+}
+
+
+#define TEST_SIZE 63
+#define TEST_ALLOC_COUNT 8192
+#define TEST_RUN 40000000
+#define TEST_INLINE 1
+
+#ifdef WIN32
+#include <windows.h>
+#pragma comment(lib,"winmm.lib")
+#else
+static NxU32 timeGetTime(void)
+{
+	return 0;
+}
+#endif
+#include <stdio.h>
+
+void performUnitTests(void)
+{
+    void *allocs[TEST_ALLOC_COUNT];
+    for (NxU32 i=0; i<TEST_ALLOC_COUNT; i++)
+    {
+        allocs[i] = 0;
+    }
+
+
+    HeapManager *hm = createHeapManager(65536*32);
+
+
+    {
+
+      NxU32 stime = timeGetTime();
+      srand(0);
+
+
+      for (NxU32 i=0; i<TEST_RUN; i++)
+      {
+          NxU32 index = rand()&(TEST_ALLOC_COUNT-1);
+          if ( allocs[index] )
+          {
+#if TEST_INLINE
+              heap_free(hm, allocs[index] );
+#else
+              hm->heap_free( allocs[index] );
+#endif
+              allocs[index] = 0;
+          }
+          else
+          {
+              NxU32 asize = (rand()&TEST_SIZE);
+			  if ( (rand()&127)==0) asize+=256; // one out of every 15 allocs is larger than 256 bytes.
+#if TEST_INLINE
+              allocs[index] = heap_malloc(hm,asize);
+#else
+              allocs[index] = hm->heap_malloc(asize);
+#endif
+          }
+      }
+
+      for (NxU32 i=0; i<TEST_ALLOC_COUNT; i++)
+      {
+          if ( allocs[i] )
+          {
+#if TEST_INLINE
+              heap_free(hm,allocs[i] );
+#else
+              hm->heap_free(allocs[i] );
+#endif
+			  allocs[i] = 0;
+          }
+      }
+
+      NxU32 etime = timeGetTime();
+      printf("Micro allocation test took %d milliseconds.\r\n", etime - stime );
+
+    }
+
+    {
+
+      NxU32 stime = timeGetTime();
+      srand(0);
+
+
+      for (NxU32 i=0; i<TEST_RUN; i++)
+      {
+          NxU32 index = rand()&(TEST_ALLOC_COUNT-1);
+          if ( allocs[index] )
+          {
+              ::free( allocs[index] );
+              allocs[index] = 0;
+          }
+          else
+          {
+              NxU32 asize = (rand()&TEST_SIZE);
+			  if ( (rand()&127)==0) asize+=256; // one out of every 15 allocs is larger than 256 bytes.
+              allocs[index] = ::malloc(asize);
+          }
+      }
+
+      for (NxU32 i=0; i<TEST_ALLOC_COUNT; i++)
+      {
+          if ( allocs[i] )
+          {
+              ::free(allocs[i] );
+			  allocs[i] = 0;
+          }
+      }
+
+      NxU32 etime = timeGetTime();
+      printf("Standard malloc/free test took %d milliseconds.\r\n", etime - stime );
+
+    }
+
+    releaseHeapManager(hm);
+}
+
+void * heap_malloc(HeapManager *hm,size_t size)
+{
+    return ((MyHeapManager *)hm)->inline_heap_malloc(size);
+}
+
+void   heap_free(HeapManager *hm,void *p)
+{
+    ((MyHeapManager *)hm)->inline_heap_free(p);
+}
+
+void * heap_realloc(HeapManager *hm,void *oldMem,size_t newSize)
+{
+    return hm->heap_realloc(oldMem,newSize);
+}
+
+}; // end of namespace

indra/libhacd/hacdMicroAllocator.h

@@ -0,0 +1,204 @@
+#ifndef MICRO_ALLOCATOR_H
+
+#define MICRO_ALLOCATOR_H
+
+/*!
+**
+** Copyright (c) 2009 by John W. Ratcliff mailto:jratcliffscarab@gmail.com
+**
+** If you find this code useful or you are feeling particularily generous I would
+** ask that you please go to http://www.amillionpixels.us and make a donation
+** to Troy DeMolay.
+**
+** If you wish to contact me you can use the following methods:
+**
+** Skype ID: jratcliff63367
+** email: jratcliffscarab@gmail.com
+**
+**
+** The MIT license:
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is furnished
+** to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in all
+** copies or substantial portions of the Software.
+
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+** WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+
+
+// This code snippet provides a high speed micro-allocator.
+//
+// The concept is that you reserve an initial bank of memory for small allocations.  Ideally a megabyte or two.
+// The amount of memory reserved is equal to chunkSize*6
+//
+// All micro-allocations are split into 6 seperate pools.
+//    They are: 0-8 bytes
+//              9-32 bytes
+//              33-64 bytes
+//              65-128 bytes
+//              129-256 bytes
+//
+// On creation of the micro-allocation system you preserve a certiain amount of memory for each of these banks.
+//
+// The user provides a heap interface to callback for additional memory as needed.
+//
+// In most cases allocations are order-N and frees are order-N as well.
+//
+// The larger a buffer you provide, the closer to 'order-N' the allocator behaves.
+//
+// This kind of a micro-allocator is ideal for use with STL as it does many tiny allocations.
+// All allocations are 16 byte aligned (with the exception of the 8 byte allocations, which are 8 byte aligned every other one).
+//
+#include <stdio.h>
+
+#ifdef WIN32
+	typedef __int64				NxI64;
+	typedef signed int			NxI32;
+	typedef signed short		NxI16;
+	typedef signed char			NxI8;
+
+	typedef unsigned __int64	NxU64;
+	typedef unsigned int		NxU32;
+	typedef unsigned short		NxU16;
+	typedef unsigned char		NxU8;
+
+	typedef float				NxF32;
+	typedef double				NxF64;
+
+#elif __gnu_linux__
+	typedef long long			NxI64;
+	typedef signed int			NxI32;
+	typedef signed short		NxI16;
+	typedef signed char			NxI8;
+
+	typedef unsigned long long	NxU64;
+    typedef unsigned int		NxU32;
+	typedef unsigned short		NxU16;
+	typedef unsigned char		NxU8;
+
+	typedef float				NxF32;
+	typedef double				NxF64;
+
+#elif __APPLE__
+	typedef long long			NxI64;
+	typedef signed int			NxI32;
+	typedef signed short		NxI16;
+	typedef signed char			NxI8;
+
+	typedef unsigned long long	NxU64;
+	typedef unsigned int		NxU32;
+	typedef unsigned short		NxU16;
+	typedef unsigned char		NxU8;
+
+	typedef float				NxF32;
+	typedef double				NxF64;
+
+#elif __CELLOS_LV2__
+	typedef long long			NxI64;
+	typedef signed int			NxI32;
+	typedef signed short		NxI16;
+	typedef signed char			NxI8;
+
+	typedef unsigned long long	NxU64;
+	typedef unsigned int		NxU32;
+	typedef unsigned short		NxU16;
+	typedef unsigned char		NxU8;
+
+	typedef float				NxF32;
+	typedef double				NxF64;
+
+#elif _XBOX
+	typedef __int64				NxI64;
+	typedef signed int			NxI32;
+	typedef signed short		NxI16;
+	typedef signed char			NxI8;
+
+	typedef unsigned __int64	NxU64;
+	typedef unsigned int		NxU32;
+	typedef unsigned short		NxU16;
+	typedef unsigned char		NxU8;
+
+	typedef float				NxF32;
+	typedef double				NxF64;
+
+#elif defined(__PPCGEKKO__)
+	typedef long long			NxI64;
+	typedef signed int			NxI32;
+	typedef signed short		NxI16;
+	typedef signed char			NxI8;
+
+	typedef unsigned long long	NxU64;
+	typedef unsigned int		NxU32;
+	typedef unsigned short		NxU16;
+
+	typedef float				NxF32;
+	typedef double				NxF64;
+
+#else
+	#error Unknown platform!
+#endif
+
+
+namespace HACD
+{
+
+// user provided heap allocator
+class MicroHeap
+{
+public:
+  virtual void * micro_malloc(size_t size) = 0;
+  virtual void   micro_free(void *p) = 0;
+  virtual void * micro_realloc(void *oldMen,size_t newSize) = 0;
+};
+
+class MemoryChunk;
+
+class MicroAllocator
+{
+public:
+  virtual void *          malloc(size_t size) = 0;
+  virtual void            free(void *p,MemoryChunk *chunk) = 0; // free relative to previously located MemoryChunk
+  virtual MemoryChunk *   isMicroAlloc(const void *p) = 0; // returns pointer to the chunk this memory belongs to, or null if not a micro-allocated block.
+  virtual NxU32           getChunkSize(MemoryChunk *chunk) = 0;
+};
+
+MicroAllocator *createMicroAllocator(MicroHeap *heap,NxU32 chunkSize=32768); // initial chunk size 32k per block.
+void            releaseMicroAllocator(MicroAllocator *m);
+
+class HeapManager
+{
+public:
+  virtual void * heap_malloc(size_t size) = 0;
+  virtual void   heap_free(void *p) = 0;
+  virtual void * heap_realloc(void *oldMem,size_t newSize) = 0;
+};
+
+
+// creates a heap manager that uses micro-allocations for all allocations < 256 bytes and standard malloc/free for anything larger.
+HeapManager * createHeapManager(NxU32 defaultChunkSize=32768);
+void          releaseHeapManager(HeapManager *heap);
+
+// about 10% faster than using the virtual interface, inlines the functions as much as possible.
+void * heap_malloc(HeapManager *hm,size_t size);
+void   heap_free(HeapManager *hm,void *p);
+void * heap_realloc(HeapManager *hm,void *oldMem,size_t newSize);
+
+void performUnitTests(void);
+
+//
+
+}; // end of namespace
+
+#endif

indra/libhacd/hacdRaycastMesh.cpp

@@ -0,0 +1,280 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "hacdRaycastMesh.h"
+#include <math.h>
+#include <assert.h>
+#include <limits>
+#include "hacdManifoldMesh.h"
+namespace HACD
+{
+	bool BBox::Raycast(const Vec3<Float> & origin, const Vec3<Float> & dir, Float & distMin) const
+	{
+		Vec3<Float> d = m_max - m_min;
+		Float r2 = 0.25 * (d.X()*d.X()+d.Y()*d.Y()+d.Z()*d.Z());
+		Vec3<Float> c = 0.5 * m_max + 0.5 * m_min;
+		Vec3<Float> u = (c-origin);
+		Vec3<Float> a = u - (u * dir) * dir;
+		Float dist2 = (a.X()*a.X()+a.Y()*a.Y()+a.Z()*a.Z());
+		distMin = (u.X()*u.X()+u.Y()*u.Y()+u.Z()*u.Z());
+		if ( distMin > r2 ) // origin outside the sphere of center c and radius r 
+		{
+			distMin = sqrt(distMin) - sqrt(r2); // the distance to any point inside the sphere is higher than |origin - c| - r
+		}
+		else
+		{
+			distMin = 0.0;
+		}
+		if (dist2 > r2) return false;
+		return true;
+	}	
+	void RMNode::ComputeBB()
+	{
+		if (m_triIDs.Size() == 0)
+		{
+			return;
+		}
+		Vec3<long> * const triangles = m_rm->m_triangles;			
+		Vec3<Float> * const vertices = m_rm->m_vertices;
+		const Float minFloat = std::numeric_limits<Float>::min();
+		const Float maxFloat = std::numeric_limits<Float>::max();
+		m_bBox.m_max = Vec3<Float>(minFloat, minFloat, minFloat);
+		m_bBox.m_min = Vec3<Float>(maxFloat, maxFloat, maxFloat);
+		Float x, y, z;
+		long v, f;
+		for(size_t id = 0; id < m_triIDs.Size(); ++id)
+		{
+			f = m_triIDs[id];
+			for(size_t k = 0; k < 3; ++k)
+			{
+				v = triangles[f][k];
+				x = vertices[v].X();
+				y = vertices[v].Y();
+				z = vertices[v].Z();
+				if ( x < m_bBox.m_min.X()) m_bBox.m_min.X() = x;
+				if ( x > m_bBox.m_max.X()) m_bBox.m_max.X() = x;
+				if ( y < m_bBox.m_min.Y()) m_bBox.m_min.Y() = y;
+				if ( y > m_bBox.m_max.Y()) m_bBox.m_max.Y() = y;
+				if ( z < m_bBox.m_min.Z()) m_bBox.m_min.Z() = z;
+				if ( z > m_bBox.m_max.Z()) m_bBox.m_max.Z() = z;
+			}
+        }
+	}
+	void RaycastMesh::ComputeBB()
+	{
+		if (m_nVertices == 0)
+		{
+			return;
+		}
+		m_bBox.m_min = m_vertices[0];
+		m_bBox.m_max = m_vertices[0];
+		Float x, y, z;
+        for (size_t v = 1; v < m_nVertices ; v++) 
+        {
+            x = m_vertices[v].X();
+            y = m_vertices[v].Y();
+            z = m_vertices[v].Z();
+            if ( x < m_bBox.m_min.X()) m_bBox.m_min.X() = x;
+			else if ( x > m_bBox.m_max.X()) m_bBox.m_max.X() = x;
+            if ( y < m_bBox.m_min.Y()) m_bBox.m_min.Y() = y;
+			else if ( y > m_bBox.m_max.Y()) m_bBox.m_max.Y() = y;
+            if ( z < m_bBox.m_min.Z()) m_bBox.m_min.Z() = z;
+			else if ( z > m_bBox.m_max.Z()) m_bBox.m_max.Z() = z;
+        }
+	}
+	void RaycastMesh::Initialize(size_t nVertices, size_t nTriangles, 
+								Vec3<Float> *  vertices,  Vec3<long> * triangles, 
+								size_t maxDepth, size_t minLeafSize, Float minAxisSize)
+	{
+		m_triangles  = triangles;			
+		m_vertices   = vertices;		
+		m_nVertices  = nVertices;
+		m_nTriangles = nTriangles;
+		delete [] m_nodes;
+		m_nNodes = 0;
+		m_nMaxNodes = 0;
+		for(size_t k = 0; k < maxDepth; k++)
+		{
+			m_nMaxNodes += (1 << maxDepth);
+		}
+		m_nodes = new RMNode[m_nMaxNodes];
+		RMNode & root = m_nodes[AddNode()];
+		root.m_triIDs.Resize(nTriangles);
+		for(size_t t = 0; t < m_nTriangles; ++t) root.m_triIDs.PushBack(t);
+		root.m_rm = this;
+		root.m_id = 0;
+		root.Create(0, maxDepth, minLeafSize, minAxisSize);
+	}
+	RaycastMesh::RaycastMesh(void)
+	{
+		m_triangles  = 0;			
+		m_vertices   = 0;		
+		m_nVertices  = 0;
+		m_nTriangles = 0;
+		m_nodes		 = 0;
+		m_nNodes	 = 0;
+		m_nMaxNodes  = 0;
+	}
+	RaycastMesh::~RaycastMesh(void)
+	{
+		delete [] m_nodes;
+	}
+	void RMNode::Create(size_t depth, size_t maxDepth, size_t minLeafSize, Float minAxisSize)
+	{
+		ComputeBB();
+		Vec3<Float> d = m_bBox.m_max - m_bBox.m_min;
+		Float maxDiff = std::max<Float>(d.X(), std::max<Float>(d.Y(), d.Z()));
+		RMSplitAxis split;
+		if		(d.X() == maxDiff) split = RMSplitAxis_X;
+		else if (d.Y() == maxDiff) split = RMSplitAxis_Y;
+		else					   split = RMSplitAxis_Z;
+	
+		if (depth == maxDepth || minLeafSize >= m_triIDs.Size() || maxDiff < minAxisSize)
+		{
+			m_leaf = true;
+			return;
+		}
+		m_idLeft  = m_rm->AddNode();
+		m_idRight = m_rm->AddNode();
+		RMNode & leftNode  = m_rm->m_nodes[m_idLeft];	
+		RMNode & rightNode = m_rm->m_nodes[m_idRight];
+		leftNode.m_id      = m_idLeft;
+		rightNode.m_id     = m_idRight;
+		leftNode.m_bBox    = m_bBox;
+		rightNode.m_bBox   = m_bBox;
+		leftNode.m_rm	   = m_rm;
+		rightNode.m_rm	   = m_rm;
+
+		if ( split == RMSplitAxis_X)
+		{
+			leftNode.m_bBox.m_max.X() = leftNode.m_bBox.m_max.X() - d.X() * 0.5;
+			rightNode.m_bBox.m_min.X() = leftNode.m_bBox.m_max.X();
+		}
+		else if ( split == RMSplitAxis_Y)
+		{
+			leftNode.m_bBox.m_max.Y() = leftNode.m_bBox.m_max.Y() - d.Y() * 0.5;
+			rightNode.m_bBox.m_min.Y() = leftNode.m_bBox.m_max.Y();
+		}
+		else
+		{
+			leftNode.m_bBox.m_max.Z() = leftNode.m_bBox.m_max.Z() - d.Z() * 0.5;
+			rightNode.m_bBox.m_min.Z() = leftNode.m_bBox.m_max.Z();
+		}
+		long f;
+		long pts[3];
+		long v;
+		Vec3<long> * const triangles = m_rm->m_triangles;			
+		Vec3<Float> * const vertices = m_rm->m_vertices;
+		leftNode.m_triIDs.Resize(m_triIDs.Size());
+		rightNode.m_triIDs.Resize(m_triIDs.Size());
+		bool found;
+		for(size_t id = 0; id < m_triIDs.Size(); ++id)
+		{
+			f = m_triIDs[id];
+			pts[0] = triangles[f].X();
+            pts[1] = triangles[f].Y();
+            pts[2] = triangles[f].Z();
+
+			found = false;
+			for (int k = 0; k < 3; ++k)
+			{
+				v = pts[k];
+				if ( vertices[v].X() <= leftNode.m_bBox.m_max.X() && 
+					 vertices[v].X() >= leftNode.m_bBox.m_min.X() &&
+					 vertices[v].Y() <= leftNode.m_bBox.m_max.Y() && 
+					 vertices[v].Y() >= leftNode.m_bBox.m_min.Y() &&
+					 vertices[v].Z() <= leftNode.m_bBox.m_max.Z() && 
+					 vertices[v].Z() >= leftNode.m_bBox.m_min.Z() )
+				{
+					leftNode.m_triIDs.PushBack(f);
+					found = true;
+					break;
+				}
+			}
+			if (!found)
+			{
+				for (int k = 0; k < 3; ++k)
+				{
+					v = pts[k];
+					if ( vertices[v].X() <= rightNode.m_bBox.m_max.X() && 
+						 vertices[v].X() >= rightNode.m_bBox.m_min.X() &&
+						 vertices[v].Y() <= rightNode.m_bBox.m_max.Y() && 
+						 vertices[v].Y() >= rightNode.m_bBox.m_min.Y() &&
+						 vertices[v].Z() <= rightNode.m_bBox.m_max.Z() && 
+						 vertices[v].Z() >= rightNode.m_bBox.m_min.Z() )
+					{
+						rightNode.m_triIDs.PushBack(f);
+						break;
+					}
+				}		
+			}
+		}
+		rightNode.Create(depth+1, maxDepth, minLeafSize, minAxisSize);
+		leftNode.Create(depth+1, maxDepth, minLeafSize, minAxisSize);
+		m_triIDs.Clear();
+	}
+	bool RaycastMesh::Raycast(const Vec3<Float> & from, const Vec3<Float> & dir, long & triID, Float & distance, Vec3<Real> & hitPoint, Vec3<Real> & hitNormal) const
+	{
+		distance = std::numeric_limits<Float>::max();
+		if (m_nNodes == 0) return false;
+		return m_nodes[0].Raycast(from, dir, triID, distance, hitPoint, hitNormal);
+	}
+	bool RMNode::Raycast(const Vec3<Float> & from, const Vec3<Float> & dir, long & triID, Float & distance, Vec3<Real> & hitPoint, Vec3<Real> & hitNormal) const 
+	{
+		Float distToSphere;
+		if (m_bBox.Raycast(from, dir, distToSphere) && (distToSphere < distance))
+		{
+			if (m_leaf)
+			{
+				long f, i1, j1, k1;
+				Vec3<long> * const triangles = m_rm->m_triangles;			
+				Vec3<Float> * const vertices = m_rm->m_vertices;
+				Vec3<Real> u1, v1, normal1;
+				double dist = 0.0;
+				long nhit = 0;
+				bool ret = false;
+				for(size_t id = 0; id < m_triIDs.Size(); ++id)
+				{
+					f = m_triIDs[id];
+					i1 = triangles[f].X();
+					j1 = triangles[f].Y();
+					k1 = triangles[f].Z();
+					u1 = vertices[j1] - vertices[i1];
+					v1 = vertices[k1] - vertices[i1];
+					normal1 = (u1 ^ v1);
+					if (dir * normal1 > 0.0)
+					{
+						nhit = IntersectRayTriangle(from, dir, vertices[i1], vertices[j1], vertices[k1], dist);
+						if (nhit==1 && distance>dist)
+						{
+							normal1.Normalize();
+							hitNormal = normal1;
+							hitPoint = from + dist * dir;
+							distance = dist;
+							triID = f;
+							ret = true;
+						}						
+					}
+				}
+				return ret;
+			}
+			bool ret1 = false;
+			bool ret2 = false;
+			if (m_idRight >= 0) ret1 = m_rm->m_nodes[m_idRight].Raycast(from, dir, triID, distance, hitPoint, hitNormal);
+			if (m_idLeft >= 0)  ret2 = m_rm->m_nodes[m_idLeft].Raycast(from, dir, triID, distance, hitPoint, hitNormal);
+			return ret1 || ret2;
+		}
+		return false;
+	}
+}

indra/libhacd/hacdRaycastMesh.h

@@ -0,0 +1,97 @@
+
+
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef RAYCAST_MESH_H
+#define RAYCAST_MESH_H
+#include "hacdSArray.h"
+#include <vector>
+#include "hacdVersion.h"
+#include "hacdVector.h"
+#include "hacdSArray.h"
+
+namespace HACD
+{
+	typedef double Float;
+	class RaycastMesh;
+	class RMNode;
+	class BBox
+	{
+	public:
+		bool									Raycast(const Vec3<Float> & origin, const Vec3<Float> & dir, Float & distance) const;
+												BBox(void){}
+												~BBox(void){}
+	private:
+		Vec3<Float>								m_min;	
+		Vec3<Float>								m_max;
+		friend class RMNode;
+		friend class RaycastMesh;
+	};
+
+	enum RMSplitAxis
+	{
+		RMSplitAxis_X,
+		RMSplitAxis_Y,
+		RMSplitAxis_Z
+	};
+	class RMNode
+	{
+	public:
+		void									ComputeBB();
+		bool									Raycast(const Vec3<Float> & from, const Vec3<Float> & dir, long & triID, Float & distance, Vec3<Real> & hitPoint, Vec3<Real> & hitNormal) const;
+		void									Create(size_t depth, size_t maxDepth, size_t minLeafSize, Float minAxisSize);
+												~RMNode(void){}
+												RMNode(void)
+												{
+													m_idRight = m_idLeft = m_id = -1;
+													m_rm = 0;
+													m_leaf = false;
+												}
+		long									m_id;
+		long									m_idLeft;
+		long									m_idRight;
+		BBox									m_bBox;		
+		SArray<long, SARRAY_DEFAULT_MIN_SIZE>	m_triIDs;
+		RaycastMesh *							m_rm;
+		bool									m_leaf;
+	};
+
+	class RaycastMesh
+	{
+	public:
+	size_t										GetNNodes() const { return m_nNodes;}
+	size_t										AddNode() { m_nNodes++; return m_nNodes-1; }
+	void										ComputeBB();
+	bool										Raycast(const Vec3<Float> & from, const Vec3<Float> & dir, long & triID, Float & distance, Vec3<Real> & hitPoint, Vec3<Real> & hitNormal) const;
+	void										Initialize(size_t nVertices, size_t nTriangles, 
+														   Vec3<Float> *  vertices,  Vec3<long> * triangles, 
+														   size_t maxDepth=15, size_t minLeafSize = 4, Float minAxisSize = 2.0);	
+												RaycastMesh(void);
+												~RaycastMesh(void);
+	private : 
+
+	private:
+		Vec3<long> *							m_triangles;			
+		Vec3<Float> *							m_vertices;		
+		size_t									m_nVertices;
+		size_t									m_nTriangles;
+		RMNode *								m_nodes;
+		BBox									m_bBox;
+		size_t									m_nNodes;
+		size_t									m_nMaxNodes;
+		friend class RMNode;
+	};
+}
+#endif

indra/libhacd/hacdSArray.h

@@ -0,0 +1,154 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_SARRAY_H
+#define HACD_SARRAY_H
+#include "hacdVersion.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#define SARRAY_DEFAULT_MIN_SIZE 16
+
+namespace HACD
+{
+	//!	SArray.
+    template < typename T, size_t N > class SArray
+    {
+        public:
+            T &                     operator[](size_t i)       
+                                    {
+                                        T * const data = Data();
+                                        return data[i];
+                                    }
+            const T &               operator[](size_t i) const 
+                                    {
+                                        const T * const data = Data();
+                                        return data[i];
+                                    }
+            size_t                  Size() const               
+                                    { 
+                                        return m_size;
+                                    }
+            T * const               Data()
+                                    { 
+                                        return (m_maxSize == N)? m_data0 : m_data;
+                                    }
+            const T * const         Data() const
+                                    { 
+                                        return (m_maxSize == N)? m_data0 : m_data;
+                                    }
+            void                    Clear()
+                                    {
+                                        m_size = 0;
+                                        delete [] m_data;
+                                        m_data    = 0;
+                                        m_maxSize = N;
+                                    }
+            void                    PopBack()
+                                    {
+                                        --m_size;
+                                    }
+			void                    Resize(size_t size)
+									{
+										if (size > m_maxSize)
+										{
+                                            T * temp = new T[size];
+											memcpy(temp, Data(), m_size*sizeof(T));
+                                            delete [] m_data;
+                                            m_data = temp;
+                                            m_maxSize = size;
+										}
+									}
+            void                    PushBack(const T &  value)
+                                    {
+                                        if (m_size==m_maxSize)
+                                        {
+                                            size_t maxSize = (m_maxSize << 1);                                            
+                                            T * temp = new T[maxSize];
+                                            memcpy(temp, Data(), m_maxSize*sizeof(T));
+                                            delete [] m_data;
+                                            m_data = temp;
+                                            m_maxSize = maxSize;
+                                        }
+                                        T * const data = Data();
+                                        data[m_size++] = value;
+                                    }
+            bool                    Find(const T & value, size_t & pos)
+                                    {
+                                        T * const data = Data();
+                                        for(pos = 0; pos < m_size; ++pos)
+                                            if (value == data[pos]) return true;
+                                        return false;
+                                    }
+            bool                    Insert(const T & value)
+                                    {
+                                        size_t pos;
+                                        if (Find(value, pos)) return false;
+                                        PushBack(value);
+                                        return true;
+                                    }
+            bool                    Erase(const T & value)
+                                    {
+                                        size_t pos;
+                                        T * const data = Data();
+                                        if (Find(value, pos))
+                                        {
+                                            for(size_t j = pos+1;  j < m_size; ++j)
+                                                data[j-1] = data[j];
+                                            --m_size;
+                                            return true;
+                                        }
+                                        return false;
+                                    }
+            void                    operator=(const SArray & rhs)       
+                                    {
+                                        if (m_maxSize < rhs.m_size)
+                                        {
+                                            delete [] m_data;
+                                            m_maxSize = rhs.m_maxSize;
+                                            m_data = new T[m_maxSize];
+                                        }
+                                        m_size = rhs.m_size;
+                                        memcpy(Data(), rhs.Data(), m_size*sizeof(T));
+                                    }
+            void                    Initialize()
+                                    {
+                                        m_data    = 0;
+                                        m_size    = 0;
+                                        m_maxSize = N;
+                                    }
+                                    SArray(const SArray & rhs)
+                                    {
+                                        m_data    = 0;
+                                        m_size    = 0;
+                                        m_maxSize = N;
+                                        *this    = rhs;
+                                    }
+                                    SArray()
+                                    {
+                                        Initialize();
+                                    }
+                                    ~SArray()
+                                    {
+                                        delete [] m_data;
+                                    }
+        private:
+            T                       m_data0[N];
+            T *                     m_data;
+            size_t                  m_size;
+            size_t                  m_maxSize;
+       };    
+}
+#endif

indra/libhacd/hacdVector.h

@@ -0,0 +1,69 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_VECTOR_H
+#define HACD_VECTOR_H
+#include <math.h>
+#include <iostream>
+#include "hacdVersion.h"
+
+namespace HACD
+{
+    typedef double Real;
+	//!	Vector dim 3.
+	template < typename T > class Vec3
+	{
+	public:
+		T &					operator[](size_t i) { return m_data[i];}
+		const T	&			operator[](size_t i) const { return m_data[i];}
+		T &					X();
+		T &					Y();
+		T &					Z();
+		const T	&			X() const;
+		const T	&			Y() const;
+		const T	&			Z() const;
+		void				Normalize();
+		T					GetNorm() const;
+		void				operator= (const Vec3 & rhs);
+		void				operator+=(const Vec3 & rhs);
+		void				operator-=(const Vec3 & rhs);
+		void				operator-=(T a);
+		void				operator+=(T a);
+		void				operator/=(T a);
+		void				operator*=(T a);
+		Vec3				operator^ (const Vec3 & rhs) const;
+		T			    	operator* (const Vec3 & rhs) const;
+		Vec3				operator+ (const Vec3 & rhs) const;
+		Vec3				operator- (const Vec3 & rhs) const;
+		Vec3				operator- () const;
+		Vec3				operator* (T rhs) const;
+		Vec3				operator/ (T rhs) const;
+							Vec3();
+							Vec3(T a);
+							Vec3(T x, T y, T z);
+							Vec3(const Vec3 & rhs);
+		/*virtual*/			~Vec3(void);
+
+	private:
+		T					m_data[3];
+	};
+    template<typename T>
+    const bool Colinear(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c);
+    template<typename T>
+    const T Volume(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c, const Vec3<T> & d);
+    
+}
+#include "hacdVector.inl"	// template implementation
+#endif

indra/libhacd/hacdVector.inl

@@ -0,0 +1,178 @@
+#pragma once
+#ifndef HACD_VECTOR_INL
+#define HACD_VECTOR_INL
+namespace HACD
+{
+	template <typename T> 
+	inline Vec3<T> operator*(T lhs, const Vec3<T> & rhs)
+	{
+		return Vec3<T>(lhs * rhs.X(), lhs * rhs.Y(), lhs * rhs.Z());
+	}
+	template <typename T> 
+	inline T & Vec3<T>::X() 
+	{
+		return m_data[0];
+	}
+	template <typename T>	
+	inline  T &	Vec3<T>::Y() 
+	{
+		return m_data[1];
+	}
+	template <typename T>	
+	inline  T &	Vec3<T>::Z() 
+	{
+		return m_data[2];
+	}
+	template <typename T>	
+	inline  const T & Vec3<T>::X() const 
+	{
+		return m_data[0];
+	}
+	template <typename T>	
+	inline  const T & Vec3<T>::Y() const 
+	{
+		return m_data[1];
+	}
+	template <typename T>	
+	inline  const T & Vec3<T>::Z() const 
+	{
+		return m_data[2];
+	}
+	template <typename T>	
+	inline  void Vec3<T>::Normalize()
+	{
+		T n = sqrt(m_data[0]*m_data[0]+m_data[1]*m_data[1]+m_data[2]*m_data[2]);
+		if (n != 0.0) (*this) /= n;
+	}
+	template <typename T>	
+	inline  T Vec3<T>::GetNorm() const 
+	{ 
+		return sqrt(m_data[0]*m_data[0]+m_data[1]*m_data[1]+m_data[2]*m_data[2]);
+	}
+	template <typename T>	
+	inline  void Vec3<T>::operator= (const Vec3 & rhs)
+	{ 
+		this->m_data[0] = rhs.m_data[0]; 
+		this->m_data[1] = rhs.m_data[1]; 
+		this->m_data[2] = rhs.m_data[2]; 
+	}
+	template <typename T>	
+	inline  void Vec3<T>::operator+=(const Vec3 & rhs)
+	{ 
+		this->m_data[0] += rhs.m_data[0]; 
+		this->m_data[1] += rhs.m_data[1]; 
+		this->m_data[2] += rhs.m_data[2]; 
+	}     
+	template <typename T>  
+	inline void Vec3<T>::operator-=(const Vec3 & rhs)
+	{ 
+		this->m_data[0] -= rhs.m_data[0]; 
+		this->m_data[1] -= rhs.m_data[1]; 
+		this->m_data[2] -= rhs.m_data[2]; 
+	}
+	template <typename T>  
+	inline void Vec3<T>::operator-=(T a)
+	{ 
+		this->m_data[0] -= a; 
+		this->m_data[1] -= a; 
+		this->m_data[2] -= a; 
+	}
+	template <typename T>  
+	inline void Vec3<T>::operator+=(T a)
+	{ 
+		this->m_data[0] += a; 
+		this->m_data[1] += a; 
+		this->m_data[2] += a; 
+	}
+	template <typename T>  
+	inline void Vec3<T>::operator/=(T a)
+	{ 
+		this->m_data[0] /= a; 
+		this->m_data[1] /= a; 
+		this->m_data[2] /= a; 
+	}
+	template <typename T>  
+	inline void Vec3<T>::operator*=(T a)
+	{ 
+		this->m_data[0] *= a; 
+		this->m_data[1] *= a; 
+		this->m_data[2] *= a; 
+	}  
+	template <typename T>	
+	inline Vec3<T> Vec3<T>::operator^ (const Vec3<T> & rhs) const
+	{
+		return Vec3<T>(m_data[1] * rhs.m_data[2] - m_data[2] * rhs.m_data[1],
+					   m_data[2] * rhs.m_data[0] - m_data[0] * rhs.m_data[2],
+					   m_data[0] * rhs.m_data[1] - m_data[1] * rhs.m_data[0]);
+	}
+	template <typename T>
+	inline T Vec3<T>::operator*(const Vec3<T> & rhs) const
+	{
+		return (m_data[0] * rhs.m_data[0] + m_data[1] * rhs.m_data[1] + m_data[2] * rhs.m_data[2]);
+	}        
+	template <typename T>
+	inline Vec3<T> Vec3<T>::operator+(const Vec3<T> & rhs) const
+	{
+		return Vec3<T>(m_data[0] + rhs.m_data[0],m_data[1] + rhs.m_data[1],m_data[2] + rhs.m_data[2]);
+	}
+	template <typename T> 
+	inline  Vec3<T> Vec3<T>::operator-(const Vec3<T> & rhs) const
+	{
+		return Vec3<T>(m_data[0] - rhs.m_data[0],m_data[1] - rhs.m_data[1],m_data[2] - rhs.m_data[2]) ;
+	}     
+	template <typename T> 
+	inline  Vec3<T> Vec3<T>::operator-() const
+	{
+		return Vec3<T>(-m_data[0],-m_data[1],-m_data[2]) ;
+	}     
+
+	template <typename T> 
+	inline Vec3<T> Vec3<T>::operator*(T rhs) const
+	{
+		return Vec3<T>(rhs * this->m_data[0], rhs * this->m_data[1], rhs * this->m_data[2]);
+	}
+	template <typename T>
+	inline Vec3<T> Vec3<T>::operator/ (T rhs) const
+	{
+		return Vec3<T>(m_data[0] / rhs, m_data[1] / rhs, m_data[2] / rhs);
+	}
+	template <typename T>
+	inline Vec3<T>::Vec3(T a) 
+	{ 
+		m_data[0] = m_data[1] = m_data[2] = a; 
+	}
+	template <typename T>
+	inline Vec3<T>::Vec3(T x, T y, T z)
+	{
+		m_data[0] = x;
+		m_data[1] = y;
+		m_data[2] = z;
+	}
+	template <typename T>
+	inline Vec3<T>::Vec3(const Vec3 & rhs)
+	{		
+		m_data[0] = rhs.m_data[0];
+		m_data[1] = rhs.m_data[1];
+		m_data[2] = rhs.m_data[2];
+	}
+	template <typename T>
+	inline Vec3<T>::~Vec3(void){};
+
+	template <typename T>
+	inline Vec3<T>::Vec3() {}
+    
+    template<typename T>
+    inline const bool Colinear(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c)
+    {
+        return  ((c.Z() - a.Z()) * (b.Y() - a.Y()) - (b.Z() - a.Z()) * (c.Y() - a.Y()) == 0.0 /*EPS*/) &&
+                ((b.Z() - a.Z()) * (c.X() - a.X()) - (b.X() - a.X()) * (c.Z() - a.Z()) == 0.0 /*EPS*/) &&
+                ((b.X() - a.X()) * (c.Y() - a.Y()) - (b.Y() - a.Y()) * (c.X() - a.X()) == 0.0 /*EPS*/);
+    }
+    
+    template<typename T>
+    inline const T Volume(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c, const Vec3<T> & d)
+    {
+        return (a-d) * ((b-d) ^ (c-d));
+    }
+}
+#endif //HACD_VECTOR_INL

indra/libhacd/hacdVersion.h

@@ -0,0 +1,20 @@
+/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com)
+ All rights reserved.
+ 
+ 
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ 
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ 
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ 
+ 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#ifndef HACD_VERSION_H
+#define HACD_VERSION_H
+#define HACD_VERSION_MAJOR 0
+#define HACD_VERSION_MINOR 0
+#endif

indra/libndhacd/CMakeLists.txt

@@ -0,0 +1,9 @@
+project(libndhacd)
+
+include_directories(${LIBS_OPEN_DIR}/libhacd)
+
+set (SOURCE_FILES LLConvexDecomposition.cpp nd_hacdConvexDecomposition.cpp nd_hacdStructs.cpp nd_hacdUtils.cpp nd_EnterExitTracer.cpp nd_StructTracer.cpp )
+file(GLOB HEADER_FILES *.h)
+
+add_library( nd_hacdConvexDecomposition STATIC ${SOURCE_FILES} ${HEADER_FILES})
+

indra/libndhacd/LLConvexDecomposition.cpp

@@ -0,0 +1,80 @@
+/** 
+ * @file   LLConvexDecomposition.cpp
+ * @author falcon@lindenlab.com
+ * @brief  A stub implementation of LLConvexDecomposition interface
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#if defined(_WINDOWS)
+#	include "windowsincludes.h"
+#endif
+
+#ifndef NULL
+#define NULL 0 
+#endif
+
+#include "nd_hacdConvexDecomposition.h"
+
+#include "LLConvexDecomposition.h"
+
+
+/*static */bool LLConvexDecomposition::s_isInitialized = false;
+
+/*static*/LLConvexDecomposition* LLConvexDecomposition::getInstance()
+{
+	if ( !s_isInitialized )
+	{
+		return NULL;
+	}
+	else
+	{
+		return nd_hacdConvexDecomposition::getInstance();
+	}
+}
+
+/*static */LLCDResult LLConvexDecomposition::initSystem()
+{
+	LLCDResult result = nd_hacdConvexDecomposition::initSystem();
+	if ( result == LLCD_OK )
+	{
+		s_isInitialized = true;
+	}
+	return result;
+}
+
+/*static */LLCDResult LLConvexDecomposition::initThread()
+{
+	return nd_hacdConvexDecomposition::initThread();
+}
+
+/*static */LLCDResult LLConvexDecomposition::quitThread()
+{
+	return nd_hacdConvexDecomposition::quitThread();
+}
+
+/*static */LLCDResult LLConvexDecomposition::quitSystem()
+{
+	return nd_hacdConvexDecomposition::quitSystem();
+}
+
+

indra/libndhacd/LLConvexDecomposition.h

@@ -0,0 +1,231 @@
+/** 
+ * @file LLConvexDecomposition.cpp
+ * @brief LLConvexDecomposition interface definition
+ *
+ * $LicenseInfo:firstyear=2011&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2011, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_CONVEX_DECOMPOSITION
+#define LL_CONVEX_DECOMPOSITION
+
+typedef int bool32;
+
+#if defined(_WIN32) || defined(_WIN64)
+#define LLCD_CALL __cdecl
+#else
+#define LLCD_CALL
+#endif
+
+struct LLCDParam
+{
+	enum LLCDParamType
+	{
+		LLCD_INVALID = 0,
+		LLCD_INTEGER,
+		LLCD_FLOAT,
+		LLCD_BOOLEAN,
+		LLCD_ENUM
+	};
+
+	struct LLCDEnumItem
+	{
+		const char*	mName;
+		int			mValue;
+	};
+
+	union LLCDValue
+	{
+		float	mFloat;
+		int		mIntOrEnumValue;
+		bool32	mBool;
+	};
+
+	union LLCDParamDetails
+	{
+		struct {
+			LLCDValue mLow;
+			LLCDValue mHigh;
+			LLCDValue mDelta;
+		} mRange;
+
+		struct {
+			int				mNumEnums;
+			LLCDEnumItem*	mEnumsArray;
+		} mEnumValues;
+	};
+
+	const char*					mName;
+	const char*					mDescription;
+	LLCDParamType				mType;
+	LLCDParamDetails			mDetails;
+	LLCDValue					mDefault;
+	int							mStage;
+
+	// WARNING: Only the LLConvexDecomposition implementation
+	// should change this value
+	int							mReserved;
+};
+
+struct LLCDStageData 
+{
+	const char*	mName;
+	const char* mDescription;
+	bool32 mSupportsCallback;
+};
+
+struct LLCDMeshData
+{
+	enum IndexType 
+	{
+		INT_16,
+		INT_32
+	};
+
+	const float*	mVertexBase;
+	int				mVertexStrideBytes;
+	int				mNumVertices;
+	const void*		mIndexBase;
+	IndexType		mIndexType;
+	int				mIndexStrideBytes;
+	int				mNumTriangles;
+};
+
+struct LLCDHull
+{
+	const float*	mVertexBase;
+	int				mVertexStrideBytes;
+	int				mNumVertices;
+};
+
+enum LLCDResult
+{
+	LLCD_OK = 0,
+	LLCD_UNKOWN_ERROR,
+	LLCD_NULL_PTR,
+	LLCD_INVALID_STAGE,
+	LLCD_UNKNOWN_PARAM,
+	LLCD_BAD_VALUE,
+	LLCD_REQUEST_OUT_OF_RANGE,
+	LLCD_INVALID_MESH_DATA,
+	LLCD_INVALID_HULL_DATA,
+	LLCD_STAGE_NOT_READY,
+	LLCD_INVALID_THREAD,
+	LLCD_NOT_IMPLEMENTED
+};
+
+// This callback will receive a string describing the current subtask being performed 
+// as well as a pair of numbers indicating progress. (The values should not be interpreted
+// as a completion percentage as 'current' may be greater than 'final'.)
+// If the callback returns zero, the decomposition will be terminated
+typedef int				(LLCD_CALL *llcdCallbackFunc)(const char* description, int current, int final);
+
+class LLConvexDecomposition
+{
+public:
+	// Obtain a pointer to the actual implementation
+	static LLConvexDecomposition* getInstance();
+
+	static LLCDResult initSystem();
+	static LLCDResult initThread();
+	static LLCDResult quitThread();
+	static LLCDResult quitSystem();
+
+	// Generate a decomposition object handle
+	virtual void genDecomposition(int& decomp) = 0;
+	// Delete decomposition object handle
+	virtual void deleteDecomposition(int decomp) = 0;
+	// Bind given decomposition handle
+	// Commands operate on currently bound decomposition
+	virtual void bindDecomposition(int decomp) = 0;
+
+	// Sets *paramsOut to the address of the LLCDParam array and returns
+	// the number of parameters
+	virtual int getParameters(const LLCDParam** paramsOut) = 0;
+
+
+	// Sets *stagesOut to the address of the LLCDStageData array and returns
+	// the number of stages
+	virtual int getStages(const LLCDStageData** stagesOut) = 0;
+
+
+	// Set a parameter by name. Pass enum values as integers.
+	virtual LLCDResult	setParam(const char* name, float val)	= 0;
+	virtual LLCDResult	setParam(const char* name, int val)		= 0; 
+	virtual LLCDResult	setParam(const char* name, bool val)	= 0;
+
+
+	// Set incoming mesh data. Data is copied to local buffers and will
+	// persist until the next setMeshData call
+	virtual LLCDResult	setMeshData( const LLCDMeshData* data, bool vertex_based ) = 0;
+
+
+	// Register a callback to be called periodically during the specified stage
+	// See the typedef above for more information
+	virtual LLCDResult	registerCallback( int stage, llcdCallbackFunc callback ) = 0;
+
+
+	// Execute the specified decomposition stage
+	virtual LLCDResult	executeStage(int stage) = 0;
+	virtual LLCDResult	buildSingleHull() = 0 ;
+
+
+	// Gets the number of hulls generated by the specified decompositions stage
+	virtual int getNumHullsFromStage(int stage) = 0;
+
+
+	// Populates hullOut to reference the internal copy of the requested hull
+	// The data will persist only until the next executeStage call for that stage.
+	virtual LLCDResult	getHullFromStage( int stage, int hull, LLCDHull* hullOut ) = 0;
+	virtual LLCDResult  getSingleHull( LLCDHull* hullOut ) = 0 ;
+
+	// TODO: Implement lock of some kind to disallow this call if data not yet ready
+	// Populates the meshDataOut to reference the utility's copy of the mesh geometry
+	// for the hull and stage specified. 
+	// You must copy this data if you want to continue using it after the next executeStage
+	// call
+	virtual LLCDResult	getMeshFromStage( int stage, int hull, LLCDMeshData* meshDataOut) = 0;
+
+
+	// Creates a mesh from hullIn and temporarily stores it internally in the utility.
+	// The mesh data persists only until the next call to getMeshFromHull
+	virtual LLCDResult	getMeshFromHull( LLCDHull* hullIn, LLCDMeshData* meshOut ) = 0;
+
+	// Takes meshIn, generates a single convex hull from it, converts that to a mesh
+	// stored internally, and populates meshOut to reference the internally stored data.
+	// The data is persistent only until the next call to generateSingleHullMeshFromMesh
+	virtual LLCDResult generateSingleHullMeshFromMesh( LLCDMeshData* meshIn, LLCDMeshData* meshOut) = 0;
+
+	//
+	/// Debug
+	virtual void loadMeshData(const char* fileIn, LLCDMeshData** meshDataOut) = 0;
+
+	virtual bool isFunctional()=0;
+
+private:
+	static bool s_isInitialized;
+};
+
+// Pull in our trace interface
+#include "ndConvexDecomposition.h"
+
+#endif //LL_CONVEX_DECOMPOSITION
+

indra/libndhacd/LLConvexDecompositionStubImpl.cpp

@@ -0,0 +1,148 @@
+/** 
+ * @file   LLConvexDecompositionStubImpl.cpp
+ * @author falcon@lindenlab.com
+ * @brief  A stub implementation of LLConvexDecomposition
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+
+#include <string.h>
+#include <memory>
+#include "LLConvexDecompositionStubImpl.h"
+
+LLConvexDecomposition* LLConvexDecompositionImpl::getInstance()
+{
+	return NULL;
+}
+
+LLCDResult LLConvexDecompositionImpl::initSystem()
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::initThread()
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::quitThread()
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::quitSystem()
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+void LLConvexDecompositionImpl::genDecomposition(int& decomp)
+{
+
+}
+
+void LLConvexDecompositionImpl::deleteDecomposition(int decomp)
+{
+
+}
+
+void LLConvexDecompositionImpl::bindDecomposition(int decomp)
+{
+
+}
+
+LLCDResult LLConvexDecompositionImpl::setParam(const char* name, float val)
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::setParam(const char* name, bool val)
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::setParam(const char* name, int val)
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::setMeshData( const LLCDMeshData* data, bool vertex_based )
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::registerCallback(int stage, llcdCallbackFunc callback )
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::buildSingleHull()
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::executeStage(int stage)
+{
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+int LLConvexDecompositionImpl::getNumHullsFromStage(int stage)
+{
+	return 0;
+}
+
+LLCDResult LLConvexDecompositionImpl::getSingleHull( LLCDHull* hullOut ) 
+{
+	memset( hullOut, 0, sizeof(LLCDHull) );
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::getHullFromStage( int stage, int hull, LLCDHull* hullOut )
+{
+	memset( hullOut, 0, sizeof(LLCDHull) );
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::getMeshFromStage( int stage, int hull, LLCDMeshData* meshDataOut )
+{
+	memset( meshDataOut, 0, sizeof(LLCDMeshData) );
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult	LLConvexDecompositionImpl::getMeshFromHull( LLCDHull* hullIn, LLCDMeshData* meshOut )
+{
+	memset( meshOut, 0, sizeof(LLCDMeshData) );
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+LLCDResult LLConvexDecompositionImpl::generateSingleHullMeshFromMesh(LLCDMeshData* meshIn, LLCDMeshData* meshOut)
+{
+	memset( meshOut, 0, sizeof(LLCDMeshData) );
+	return LLCD_NOT_IMPLEMENTED;
+}
+
+void LLConvexDecompositionImpl::loadMeshData(const char* fileIn, LLCDMeshData** meshDataOut)
+{
+	static LLCDMeshData meshData;
+	memset( &meshData, 0, sizeof(LLCDMeshData) );
+	*meshDataOut = &meshData;
+}

indra/libndhacd/LLConvexDecompositionStubImpl.h

@@ -0,0 +1,97 @@
+/** 
+ * @file   LLConvexDecompositionStubImpl.h
+ * @author falcon@lindenlab.com
+ * @brief  A stub implementation of LLConvexDecomposition
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+
+#ifndef LL_CONVEX_DECOMP_UTIL_H
+#define LL_CONVEX_DECOMP_UTIL_H
+
+#include "LLConvexDecomposition.h"
+
+class LLConvexDecompositionImpl : public LLConvexDecomposition
+{
+	public:
+
+		virtual ~LLConvexDecompositionImpl() {}
+
+		static LLConvexDecomposition* getInstance();
+		static LLCDResult initSystem();
+		static LLCDResult initThread();
+		static LLCDResult quitThread();
+		static LLCDResult quitSystem();
+
+		// Generate a decomposition object handle
+		void genDecomposition(int& decomp);
+		// Delete decomposition object handle
+		void deleteDecomposition(int decomp);
+		// Bind given decomposition handle
+		// Commands operate on currently bound decomposition
+		void bindDecomposition(int decomp);
+
+		// Sets *paramsOut to the address of the LLCDParam array and returns
+		// the length of the array
+		int getParameters(const LLCDParam** paramsOut) 
+		{ 
+			*paramsOut = NULL; 
+			return 0; 
+		}
+
+		int getStages(const LLCDStageData** stagesOut) 
+		{ 
+			*stagesOut = NULL; 
+			return 0; 
+		}
+
+		// Set a parameter by name. Returns false if out of bounds or unsupported parameter
+		LLCDResult	setParam(const char* name, float val);
+		LLCDResult	setParam(const char* name, int val);
+		LLCDResult	setParam(const char* name, bool val);
+		LLCDResult	setMeshData( const LLCDMeshData* data, bool vertex_based );
+		LLCDResult	registerCallback(int stage, llcdCallbackFunc callback );
+
+		LLCDResult	executeStage(int stage);
+		LLCDResult	buildSingleHull() ;
+
+		int getNumHullsFromStage(int stage);
+
+		LLCDResult	getHullFromStage( int stage, int hull, LLCDHull* hullOut );
+		LLCDResult  getSingleHull( LLCDHull* hullOut ) ;
+		
+		// TODO: Implement lock of some kind to disallow this call if data not yet ready
+		LLCDResult	getMeshFromStage( int stage, int hull, LLCDMeshData* meshDataOut);
+		LLCDResult	getMeshFromHull( LLCDHull* hullIn, LLCDMeshData* meshOut );
+
+		// For visualizing convex hull shapes in the viewer physics shape display
+		LLCDResult generateSingleHullMeshFromMesh( LLCDMeshData* meshIn, LLCDMeshData* meshOut);
+
+		/// Debug
+		void loadMeshData(const char* fileIn, LLCDMeshData** meshDataOut);
+
+	private:
+		LLConvexDecompositionImpl() {}
+};
+
+#endif //LL_CONVEX_DECOMP_UTIL_H

indra/libndhacd/ndConvexDecomposition.h

@@ -0,0 +1,58 @@
+#ifndef ND_CONVEXDECOMPOSITION_H
+#define ND_CONVEXDECOMPOSITION_H
+
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef ND_HASCONVEXDECOMP_TRACER
+ #define ND_HASCONVEXDECOMP_TRACER
+#endif
+
+class ndConvexDecompositionTracer
+{
+public:
+	enum ETraceLevel
+	{
+		eNone = 0,
+		eTraceFunctions = 0x1,
+		eTraceData = 0x2,
+	};
+	
+	virtual ~ndConvexDecompositionTracer()
+	{ }
+
+	virtual void trace( char const *a_strMsg ) = 0;
+
+	virtual void startTraceData( char const *a_strWhat) = 0;
+	virtual void traceData( char const *a_strData ) = 0;
+	virtual void endTraceData() = 0;
+
+	virtual int getLevel() = 0;
+
+	virtual void addref() = 0;
+	virtual void release() = 0;
+};
+
+class ndConvexDecompositionTracable
+{
+public:
+	virtual void setTracer( ndConvexDecompositionTracer *) = 0;
+};
+
+
+#endif

indra/libndhacd/nd_EnterExitTracer.cpp

@@ -0,0 +1,51 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "nd_EnterExitTracer.h"
+
+#include <vector>
+#include <sstream>
+
+void EnterExitTracer::doTrace( char const *aPrefix )
+{
+	if( !mFunc || !mTracer )
+		return;
+
+	if( ndConvexDecompositionTracer::eTraceFunctions == (mTracer->getLevel() & ndConvexDecompositionTracer::eTraceFunctions ) )
+		return;
+
+	std::stringstream str;
+	if( aPrefix )
+		str << aPrefix;
+
+	str << mFunc;	
+	mTracer->trace( str.str().c_str() );
+}
+
+EnterExitTracer::EnterExitTracer( char const *aFunc, ndConvexDecompositionTracer *aTracer )
+	: mFunc( aFunc )
+	, mTracer( aTracer )
+{
+	doTrace( "enter: " );
+}
+
+EnterExitTracer::~EnterExitTracer( )
+{
+	doTrace( "exit: " );
+}
+

indra/libndhacd/nd_EnterExitTracer.h

@@ -0,0 +1,43 @@
+#ifndef ND_ENTEREXITTRACER_H
+#define ND_ENTEREXITTRACER_H
+
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "ndConvexDecomposition.h"
+
+class EnterExitTracer
+{
+	char const *mFunc;
+	ndConvexDecompositionTracer *mTracer;
+
+	void doTrace( char const *aPrefix );
+
+public:
+	EnterExitTracer( char const *aFunc, ndConvexDecompositionTracer *aTracer );
+	~EnterExitTracer( );
+	
+};
+
+#ifdef __GNUC__
+   #define TRACE_FUNC(ATRACER) EnterExitTracer oETTrace( __PRETTY_FUNCTION__, ATRACER );
+#else
+   #define TRACE_FUNC(ATRACER) EnterExitTracer oETTrace( __FUNCTION__, ATRACER );
+#endif
+
+#endif

indra/libndhacd/nd_StructTracer.cpp

@@ -0,0 +1,188 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "nd_StructTracer.h"
+#include <sstream>
+#include <iomanip>
+
+using namespace std;
+
+namespace ndStructTracer
+{
+	bool doTrace( ndConvexDecompositionTracer *aTracer )
+	{
+		if( !aTracer )
+			return false;
+
+		return ndConvexDecompositionTracer::eTraceData == (aTracer->getLevel() & ndConvexDecompositionTracer::eTraceData) ;
+	}
+
+
+	template<typename T> void traceVecDbl( T const &aValue, ndConvexDecompositionTracer *aTracer )
+	{
+		stringstream str;
+		str << fixed
+			<< "\tX: " << aValue.X()
+			<< " Y: " << aValue.Y()
+			<< " Z: " << aValue.Z();
+
+		aTracer->traceData( str.str().c_str() );
+	}
+
+	template< typename T> void traceVecDoubles( vector< T > const &aVertices, ndConvexDecompositionTracer *aTracer )
+	{
+		for( size_t i = 0; i < aVertices.size(); ++i )
+			traceVecDbl( aVertices[i], aTracer ); 
+	}
+
+	void traceVertices( vector< tVecDbl > const &aVertices, ndConvexDecompositionTracer *aTracer )
+	{
+		aTracer->traceData( "Triangles\n" );
+		traceVecDoubles( aVertices, aTracer );
+	}
+
+	void traceTriangles( vector< tVecLong > const &aTriangles, ndConvexDecompositionTracer *aTracer )
+	{
+		aTracer->traceData( "Vertices\n" );
+		traceVecDoubles( aTriangles, aTracer );
+	}
+
+	void trace( DecompData const &aData, ndConvexDecompositionTracer *aTracer )
+	{
+		if( !doTrace( aTracer ) )
+			return;
+
+		aTracer->startTraceData("Hulls");
+
+		stringstream str;
+		str << "Hulls: " << aData.mHulls.size();
+		aTracer->traceData( str.str().c_str() );
+		str.seekp(0);
+
+		for( size_t i = 0; i < aData.mHulls.size(); ++i )
+		{
+			str << "Hull #" << i;
+			aTracer->traceData( str.str().c_str() );
+			str.seekp(0);
+
+			DecompHull const &oHull( aData.mHulls[i] );
+			traceVertices( oHull.mVertices, aTracer );
+			traceTriangles( oHull.mTriangles, aTracer );
+		}
+
+		aTracer->endTraceData();
+	}
+
+	template< typename T> void traceVertex( T aX, T aY, T aZ, ndConvexDecompositionTracer *aTracer )
+	{
+		stringstream str;
+		str << fixed
+			<< "X: " << aX
+			<< "Y: " << aY
+			<< "Z: " << aZ;
+
+		aTracer->traceData( str.str().c_str() );
+	}
+
+	template< typename T> void traceTriangle( void *& aPtr, int aStride, ndConvexDecompositionTracer *aTracer )
+	{
+		T *pData = reinterpret_cast< T* >(aPtr);
+		long X( pData[0] ),	Y( pData[1] ),	Z( pData[2] );
+
+		traceVertex( X, Y, Z, aTracer );
+
+		pData += aStride;
+		aPtr = pData;
+	}
+
+	void traceVertices( int aNumVertices, float const *aVertices, int aStride, ndConvexDecompositionTracer *aTracer )
+	{
+		for( int i = 0; i < aNumVertices; ++i )
+		{
+			float X( aVertices[0] ), Y( aVertices[1] ), Z( aVertices[2] );
+			traceVertex( X, Y, Z, aTracer );
+			aVertices += aStride;
+		}
+	}
+
+	void traceTriangles( LLCDMeshData const *aData, ndConvexDecompositionTracer *aTracer )
+	{
+		int nCount = aData->mNumTriangles;
+		int nStride = aData->mIndexStrideBytes;
+		void *pData = const_cast<void*>( aData->mIndexBase );
+		int nIndexType = aData->mIndexType;
+
+		if ( LLCDMeshData::INT_16 == nIndexType )
+			nStride /= 2;
+		else
+			nStride /= 4;
+			
+		for ( int i = 0; i < nCount; ++i )
+		{
+			if( LLCDMeshData::INT_16  == nIndexType )
+				traceTriangle< hacdUINT16 >( pData, nStride, aTracer );
+			else
+				traceTriangle< hacdUINT32 >( pData, nStride, aTracer );
+		}
+	}
+
+	void trace( LLCDMeshData const *aData, bool aVertexBased, ndConvexDecompositionTracer *aTracer )
+	{
+		if( !doTrace( aTracer ) )
+			return;
+
+		aTracer->startTraceData("LLCDMeshData");
+
+		string strVBased("true");
+		if( !aVertexBased )
+			strVBased = "false";
+
+		stringstream str;
+		str << "LLCDMeshData vertex based: " << strVBased
+			<< "# vertices " << aData->mNumVertices
+			<< "# triangles " << aData->mNumTriangles;
+
+		aTracer->traceData( str.str().c_str() );
+
+		traceVertices( aData->mNumVertices, aData->mVertexBase, aData->mVertexStrideBytes/sizeof(float), aTracer );
+
+		if( !aVertexBased )
+			traceTriangles( aData, aTracer );
+			
+		aTracer->endTraceData();
+	}
+
+	void trace( LLCDHull const *aData, ndConvexDecompositionTracer *aTracer )
+	{
+		if( !doTrace( aTracer ) )
+			return;
+
+		aTracer->startTraceData("LLCDHull");
+
+		stringstream str;
+		str << "LLCDHull # vertices " << aData->mNumVertices;
+
+		aTracer->traceData( str.str().c_str() );
+
+		traceVertices( aData->mNumVertices, aData->mVertexBase, aData->mVertexStrideBytes/sizeof(float), aTracer );
+
+
+		aTracer->endTraceData();
+	}
+};
+

indra/libndhacd/nd_StructTracer.h

@@ -0,0 +1,34 @@
+#ifndef ND_STRUCTTRACER_H
+#define ND_STRUCTTRACER_H
+
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+
+#include "ndConvexDecomposition.h"
+#include "LLConvexDecomposition.h"
+#include "nd_hacdStructs.h"
+
+namespace ndStructTracer
+{
+	void trace( DecompData const &aData, ndConvexDecompositionTracer *aTracer );
+	void trace( LLCDMeshData const *aData, bool aVertexBased, ndConvexDecompositionTracer *aTracer );
+	void trace( LLCDHull const *aData, ndConvexDecompositionTracer *aTracer );
+};
+
+#endif

indra/libndhacd/nd_hacdConvexDecomposition.cpp

@@ -0,0 +1,393 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <string.h>
+#include <memory>
+#include "nd_hacdConvexDecomposition.h"
+
+#include "nd_hacdDefines.h"
+#include "nd_hacdStructs.h"
+#include "nd_hacdUtils.h"
+#include "ndConvexDecomposition.h"
+#include "nd_EnterExitTracer.h"
+#include "nd_StructTracer.h"
+
+LLCDStageData nd_hacdConvexDecomposition::mStages[1];
+
+LLCDParam nd_hacdConvexDecomposition::mParams[4];
+LLCDParam::LLCDEnumItem nd_hacdConvexDecomposition::mMethods[1];
+LLCDParam::LLCDEnumItem nd_hacdConvexDecomposition::mQuality[1];
+LLCDParam::LLCDEnumItem nd_hacdConvexDecomposition::mSimplify[1];
+
+LLConvexDecomposition* nd_hacdConvexDecomposition::getInstance()
+{
+	static nd_hacdConvexDecomposition sImpl;
+	return &sImpl;
+}
+
+nd_hacdConvexDecomposition::nd_hacdConvexDecomposition()
+{
+	mNextId = 0;
+	mCurrentDecoder = 0;
+	mSingleHullMeshFromMesh = new HACDDecoder();
+	mTracer = 0;
+}
+
+nd_hacdConvexDecomposition::~nd_hacdConvexDecomposition()
+{
+	if( mTracer )
+		mTracer->release();
+}
+
+LLCDResult nd_hacdConvexDecomposition::initSystem()
+{
+	memset( &mStages[0], 0, sizeof( mStages ) );
+	memset( &mParams[0], 0, sizeof( mParams ) );
+	memset( &mMethods[0], 0, sizeof( mMethods ) );
+	memset( &mQuality[0], 0, sizeof( mQuality ) );
+	memset( &mSimplify[0], 0, sizeof( mSimplify ) );
+
+	mStages[0].mName = "Decompose";
+	mStages[0].mDescription = NULL;
+
+	mMethods[0].mName = "Default";
+	mMethods[0].mValue = 0;
+
+	mQuality[0].mName = "Default";
+	mQuality[0].mValue = 0;
+
+	mSimplify[0].mName = "None";
+	mSimplify[0].mValue = 0;
+
+	mParams[0].mName = "nd_AlwaysNeedTriangles";
+	mParams[0].mDescription = 0;
+	mParams[0].mType = LLCDParam::LLCD_BOOLEAN;
+	mParams[0].mDefault.mBool = true;
+
+	mParams[1].mName = "Method";
+	mParams[1].mType = LLCDParam::LLCD_ENUM;
+	mParams[1].mDetails.mEnumValues.mNumEnums = sizeof(mMethods)/sizeof(LLCDParam::LLCDEnumItem);
+	mParams[1].mDetails.mEnumValues.mEnumsArray = mMethods;
+	mParams[1].mDefault.mIntOrEnumValue = 0;
+
+	mParams[2].mName = "Decompose Quality";
+	mParams[2].mType = LLCDParam::LLCD_ENUM;
+	mParams[2].mDetails.mEnumValues.mNumEnums = sizeof(mQuality)/sizeof(LLCDParam::LLCDEnumItem);
+	mParams[2].mDetails.mEnumValues.mEnumsArray = mQuality;
+	mParams[2].mDefault.mIntOrEnumValue = 0;
+
+	mParams[3].mName = "Simplify Method";
+	mParams[3].mType = LLCDParam::LLCD_ENUM;
+	mParams[3].mDetails.mEnumValues.mNumEnums = sizeof(mSimplify)/sizeof(LLCDParam::LLCDEnumItem);
+	mParams[3].mDetails.mEnumValues.mEnumsArray = mSimplify;
+	mParams[3].mDefault.mIntOrEnumValue = 0;
+
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::initThread()
+{
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::quitThread()
+{
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::quitSystem()
+{
+	return LLCD_OK;
+}
+
+void nd_hacdConvexDecomposition::genDecomposition( int& decomp )
+{
+	HACDDecoder *pGen = new HACDDecoder();
+	decomp = mNextId;
+	++mNextId;
+
+	mDecoders[ decomp ] = pGen;
+}
+
+void nd_hacdConvexDecomposition::deleteDecomposition( int decomp )
+{
+	delete mDecoders[ decomp ];
+	mDecoders.erase( decomp );
+}
+
+void nd_hacdConvexDecomposition::bindDecomposition( int decomp )
+{
+	TRACE_FUNC( mTracer );
+	mCurrentDecoder = decomp;
+}
+
+LLCDResult nd_hacdConvexDecomposition::setParam( const char* name, float val )
+{
+	TRACE_FUNC( mTracer );
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::setParam( const char* name, bool val )
+{
+	TRACE_FUNC( mTracer );
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::setParam( const char* name, int val )
+{
+	TRACE_FUNC( mTracer );
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::setMeshData( const LLCDMeshData* data, bool vertex_based )
+{
+	TRACE_FUNC( mTracer );
+	ndStructTracer::trace( data, vertex_based, mTracer );
+
+	HACDDecoder *pC = mDecoders[ mCurrentDecoder ];
+	return ::setMeshData( data, vertex_based, pC );
+}
+
+LLCDResult nd_hacdConvexDecomposition::registerCallback( int stage, llcdCallbackFunc callback )
+{
+	TRACE_FUNC( mTracer );
+	if( mDecoders.end() == mDecoders.find( mCurrentDecoder ) )
+		return LLCD_STAGE_NOT_READY;
+
+	HACDDecoder *pC = mDecoders[ mCurrentDecoder ];
+	pC->mCallback = callback;
+
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::buildSingleHull()
+{
+	TRACE_FUNC( mTracer );
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::executeStage( int stage )
+{
+	TRACE_FUNC( mTracer );
+	if ( stage < 0 || stage >= NUM_STAGES )
+		return LLCD_INVALID_STAGE;
+
+	HACDDecoder *pC = mDecoders[ mCurrentDecoder ];
+	tHACD *pHACD = init( 1, MIN_NUMBER_OF_CLUSTERS, MAX_VERTICES_PER_HULL, CONNECT_DISTS[0], pC );
+
+	DecompData oRes = decompose( pHACD );
+	ndStructTracer::trace( oRes, mTracer );
+
+	delete pHACD;
+
+	pC->mStages[ stage ] = oRes;
+
+	return LLCD_OK;
+}
+
+int nd_hacdConvexDecomposition::getNumHullsFromStage( int stage )
+{
+	TRACE_FUNC( mTracer );
+	HACDDecoder *pC = mDecoders[ mCurrentDecoder ];
+
+	if ( !pC )
+		return 0;
+
+	if ( stage < 0 || static_cast<size_t>(stage) >= pC->mStages.size() )
+		return 0;
+
+	return pC->mStages[stage].mHulls.size();
+}
+
+DecompData toSingleHull( HACDDecoder *aDecoder, LLCDResult &aRes, ndConvexDecompositionTracer *aTracer )
+{
+	TRACE_FUNC( aTracer );
+	aRes = LLCD_REQUEST_OUT_OF_RANGE;
+
+	for ( int i = 0; i < TO_SINGLE_HULL_TRIES; ++i )
+	{
+		tHACD *pHACD = init( CONCAVITY_FOR_SINGLE_HULL[i], 1, MAX_VERTICES_PER_HULL, CONNECT_DISTS[i], aDecoder );
+
+		DecompData oRes = decompose( pHACD );
+		delete pHACD;
+
+		ndStructTracer::trace( oRes, aTracer );
+
+		if ( oRes.mHulls.size() == 1 )
+		{
+			aRes = LLCD_OK;
+			return oRes;
+		}
+	}
+
+	return DecompData();
+}
+
+LLCDResult nd_hacdConvexDecomposition::getSingleHull( LLCDHull* hullOut )
+{
+	TRACE_FUNC( mTracer );
+	HACDDecoder *pC = mDecoders[ mCurrentDecoder ];
+
+	memset( hullOut, 0, sizeof( LLCDHull ) );
+
+	LLCDResult res;
+
+	// Will already trace oRes
+	DecompData oRes = ::toSingleHull( pC, res, mTracer );
+
+	if ( LLCD_OK != res || oRes.mHulls.size() != 1 )
+		return res;
+
+	pC->mSingleHull = oRes.mHulls[0];
+	pC->mSingleHull.toLLHull( hullOut );
+
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::getHullFromStage( int stage, int hull, LLCDHull* hullOut )
+{
+	TRACE_FUNC( mTracer );
+	HACDDecoder *pC = mDecoders[ mCurrentDecoder ];
+
+	memset( hullOut, 0, sizeof( LLCDHull ) );
+
+	if ( stage < 0 || static_cast<size_t>(stage) >= pC->mStages.size() )
+		return LLCD_INVALID_STAGE;
+
+	DecompData &oData = pC->mStages[ stage ];
+
+	if ( hull < 0 ||static_cast<size_t>(hull) >= oData.mHulls.size() )
+		return LLCD_REQUEST_OUT_OF_RANGE;
+
+	oData.mHulls[ hull ].toLLHull( hullOut );
+	ndStructTracer::trace( hullOut, mTracer );
+
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::getMeshFromStage( int stage, int hull, LLCDMeshData* meshDataOut )
+{
+	TRACE_FUNC( mTracer );
+	HACDDecoder *pC = mDecoders[ mCurrentDecoder ];
+
+	memset( meshDataOut, 0, sizeof( LLCDHull ) );
+
+	if ( stage < 0 || static_cast<size_t>(stage) >= pC->mStages.size() )
+		return LLCD_INVALID_STAGE;
+
+	DecompData &oData = pC->mStages[ stage ];
+
+	if ( hull < 0 || static_cast<size_t>(hull) >= oData.mHulls.size() )
+		return LLCD_REQUEST_OUT_OF_RANGE;
+
+	oData.mHulls[ hull ].toLLMesh( meshDataOut );
+	ndStructTracer::trace( meshDataOut, true, mTracer );
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::getMeshFromHull( LLCDHull* hullIn, LLCDMeshData* meshOut )
+{
+	TRACE_FUNC( mTracer );
+	memset( meshOut, 0, sizeof( LLCDMeshData ) );
+
+	mMeshToHullVertices.clear();
+	mMeshToHullTriangles.clear();
+
+	if( !hullIn || !hullIn->mVertexBase || !meshOut )
+		return LLCD_NULL_PTR;
+	if( hullIn->mVertexStrideBytes < 3*sizeof(float) || hullIn->mNumVertices < 3 )
+		return LLCD_INVALID_HULL_DATA;
+
+	LLCDResult oRet = convertHullToMesh( hullIn, mMeshToHullVertices, mMeshToHullTriangles );
+
+	if( LLCD_OK != oRet )
+		return oRet;
+
+	meshOut->mVertexStrideBytes = sizeof( float )*3;
+	meshOut->mNumVertices = mMeshToHullVertices.size()/3;
+	meshOut->mVertexBase = &mMeshToHullVertices[0];
+
+	meshOut->mIndexType = LLCDMeshData::INT_32;
+	meshOut->mIndexStrideBytes = sizeof( hacdUINT32 ) * 3;
+	meshOut->mNumTriangles = mMeshToHullTriangles.size()/3;
+	meshOut->mIndexBase = &mMeshToHullTriangles[0];
+
+	return LLCD_OK;
+}
+
+LLCDResult nd_hacdConvexDecomposition::generateSingleHullMeshFromMesh( LLCDMeshData* meshIn, LLCDMeshData* meshOut )
+{
+	TRACE_FUNC( mTracer );
+	memset( meshOut, 0, sizeof( LLCDMeshData ) );
+	mSingleHullMeshFromMesh->clear();
+	LLCDResult res = ::setMeshData( meshIn, meshIn->mNumVertices > 3, mSingleHullMeshFromMesh );
+
+	if ( LLCD_OK != res )
+		return res;
+
+	// Will already trace oRes
+	DecompData oRes = ::toSingleHull( mSingleHullMeshFromMesh, res, mTracer );
+
+	if ( LLCD_OK != res || oRes.mHulls.size() != 1 )
+		return res;
+
+	mSingleHullMeshFromMesh->mSingleHull = oRes.mHulls[0];
+	mSingleHullMeshFromMesh->mSingleHull.toLLMesh( meshOut );
+
+	return LLCD_OK;
+}
+
+void nd_hacdConvexDecomposition::loadMeshData( const char* fileIn, LLCDMeshData** meshDataOut )
+{
+	TRACE_FUNC( mTracer );
+	static LLCDMeshData meshData;
+	memset( &meshData, 0, sizeof( LLCDMeshData ) );
+	*meshDataOut = &meshData;
+}
+
+int nd_hacdConvexDecomposition::getParameters( const LLCDParam** paramsOut )
+{
+	TRACE_FUNC( mTracer );
+	*paramsOut = mParams;
+	return sizeof(mParams)/sizeof(LLCDParam);
+}
+
+int nd_hacdConvexDecomposition::getStages( const LLCDStageData** stagesOut )
+{
+	TRACE_FUNC( mTracer );
+
+	*stagesOut = mStages;
+	return sizeof(mStages)/sizeof(LLCDStageData);
+}
+
+void nd_hacdConvexDecomposition::setTracer( ndConvexDecompositionTracer * aTracer)
+{
+	if( mTracer )
+		mTracer->release();
+
+	mTracer = aTracer;
+
+	if( mTracer )
+		mTracer->addref();
+}
+
+
+bool nd_hacdConvexDecomposition::isFunctional()
+{
+	return true;
+}

indra/libndhacd/nd_hacdConvexDecomposition.h

@@ -0,0 +1,103 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef ND_HACD_CONVEXDECOMP_H
+#define ND_HACD_CONVEXDECOMP_H
+
+#include "LLConvexDecomposition.h"
+
+#include <map>
+#include <vector>
+
+struct HACDDecoder;
+
+class nd_hacdConvexDecomposition : public LLConvexDecomposition, public ndConvexDecompositionTracable
+{
+	int mNextId;
+	int mCurrentDecoder;
+	std::map< int, HACDDecoder * > mDecoders;
+	HACDDecoder *mSingleHullMeshFromMesh;
+
+	std::vector< float > mMeshToHullVertices;
+	std::vector< int > mMeshToHullTriangles;
+
+	ndConvexDecompositionTracer *mTracer;
+
+	static LLCDStageData mStages[1];
+
+	static LLCDParam mParams[4];
+	static LLCDParam::LLCDEnumItem mMethods[1];
+	static LLCDParam::LLCDEnumItem mQuality[1];
+	static LLCDParam::LLCDEnumItem mSimplify[1];
+
+public:
+	virtual ~nd_hacdConvexDecomposition();
+
+	static LLConvexDecomposition* getInstance();
+	static LLCDResult initSystem();
+	static LLCDResult initThread();
+	static LLCDResult quitThread();
+	static LLCDResult quitSystem();
+
+	// Generate a decomposition object handle
+	void genDecomposition( int& decomp );
+	// Delete decomposition object handle
+	void deleteDecomposition( int decomp );
+	// Bind given decomposition handle
+	// Commands operate on currently bound decomposition
+	void bindDecomposition( int decomp );
+
+	// Sets *paramsOut to the address of the LLCDParam array and returns
+	// the length of the array
+	int getParameters( const LLCDParam** paramsOut );
+	int getStages( const LLCDStageData** stagesOut ) ;
+
+	// Set a parameter by name. Returns false if out of bounds or unsupported parameter
+	LLCDResult	setParam( const char* name, float val );
+	LLCDResult	setParam( const char* name, int val );
+	LLCDResult	setParam( const char* name, bool val );
+	LLCDResult	setMeshData( const LLCDMeshData* data, bool vertex_based );
+	LLCDResult	registerCallback( int stage, llcdCallbackFunc callback );
+
+	LLCDResult	executeStage( int stage );
+	LLCDResult	buildSingleHull() ;
+
+	int getNumHullsFromStage( int stage );
+
+	LLCDResult	getHullFromStage( int stage, int hull, LLCDHull* hullOut );
+	LLCDResult  getSingleHull( LLCDHull* hullOut ) ;
+
+	// TODO: Implement lock of some kind to disallow this call if data not yet ready
+	LLCDResult	getMeshFromStage( int stage, int hull, LLCDMeshData* meshDataOut );
+	LLCDResult	getMeshFromHull( LLCDHull* hullIn, LLCDMeshData* meshOut );
+
+	// For visualizing convex hull shapes in the viewer physics shape display
+	LLCDResult generateSingleHullMeshFromMesh( LLCDMeshData* meshIn, LLCDMeshData* meshOut );
+
+	/// Debug
+	void loadMeshData( const char* fileIn, LLCDMeshData** meshDataOut );
+
+	virtual void setTracer( ndConvexDecompositionTracer *);
+
+	virtual bool isFunctional();
+
+private:
+	nd_hacdConvexDecomposition();
+};
+
+#endif

indra/libndhacd/nd_hacdDefines.h

@@ -0,0 +1,46 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef ND_HACD_DEFINES_H
+#define ND_HACD_DEFINES_H
+
+#include "hacdHACD.h"
+
+#define NUM_STAGES 1
+
+typedef unsigned short hacdUINT16;
+typedef unsigned int hacdUINT32;
+
+typedef HACD::HACD tHACD;
+typedef HACD::Vec3< double > tVecDbl;
+typedef HACD::Vec3< long > tVecLong;
+
+typedef tVecLong ( *fFromIXX )( void const *&, int );
+
+const int MAX_VERTICES_PER_HULL     = 256;    // see http://wiki.secondlife.com/wiki/Mesh/Mesh_physics
+const int MIN_NUMBER_OF_CLUSTERS    = 1;
+
+int const TO_SINGLE_HULL_TRIES = 10;
+
+// Use a high value so HACD will generate just one hull. For now we use the same concavity for each run.
+int const CONCAVITY_FOR_SINGLE_HULL[  TO_SINGLE_HULL_TRIES ] = { 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000 };
+
+// Max distance to connect CC. Increase this each run.
+double const CONNECT_DISTS[ TO_SINGLE_HULL_TRIES ] = { 30, 60, 120, 240, 480, 960, 1920, 3840, 7680, 10000 };
+
+#endif

indra/libndhacd/nd_hacdStructs.cpp

@@ -0,0 +1,107 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "nd_hacdStructs.h"
+#include "LLConvexDecomposition.h"
+
+void DecompHull::clear()
+{
+	mVertices.clear();
+	mTriangles.clear();
+	mLLVertices.clear();
+	mLLTriangles.clear();
+}
+
+void DecompHull::computeLLVertices()
+{
+	if ( mLLVertices.size()*3 != mVertices.size() )
+	{
+		for ( size_t i = 0; i < mVertices.size(); ++i )
+		{
+			mLLVertices.push_back( static_cast<float>( mVertices[i].X() ) );
+			mLLVertices.push_back( static_cast<float>( mVertices[i].Y() ) );
+			mLLVertices.push_back( static_cast<float>( mVertices[i].Z() ) );
+		}
+	}
+}
+
+void DecompHull::computeLLTriangles()
+{
+	if ( mLLTriangles.size()*3 != mTriangles.size() )
+	{
+		for ( size_t i = 0; i < mTriangles.size(); ++i )
+		{
+			mLLTriangles.push_back( mTriangles[i].X() );
+			mLLTriangles.push_back( mTriangles[i].Y() );
+			mLLTriangles.push_back( mTriangles[i].Z() );
+		}
+	}
+
+}
+
+void DecompHull::toLLHull( LLCDHull *aHull )
+{
+	computeLLVertices();
+
+	aHull->mVertexBase = &mLLVertices[0];
+	aHull->mVertexStrideBytes = sizeof( float ) * 3;
+	aHull->mNumVertices = mVertices.size();
+}
+
+void DecompHull::toLLMesh( LLCDMeshData *aMesh )
+{
+	computeLLVertices();
+	computeLLTriangles();
+
+	aMesh->mIndexType = LLCDMeshData::INT_32;
+	aMesh->mVertexBase = &mLLVertices[0];
+	aMesh->mNumVertices = mVertices.size();
+	aMesh->mVertexStrideBytes = sizeof( float ) * 3;
+
+	aMesh->mIndexBase = &mLLTriangles[0];
+	aMesh->mIndexStrideBytes = sizeof( hacdUINT32 ) * 3;
+	aMesh->mNumTriangles = mTriangles.size();
+}
+
+void DecompData::clear()
+{
+	mHulls.clear();
+}
+
+HACDDecoder::HACDDecoder()
+{
+	mStages.resize( NUM_STAGES );
+	mCallback = 0;
+}
+
+void HACDDecoder::clear()
+{
+	mVertices.clear();
+	mTriangles.clear();
+
+	for ( size_t i = 0;  i < mStages.size(); ++i )
+		mStages[i].clear();
+
+	mSingleHull.clear();
+
+	mCallback = 0;
+}
+
+
+
+

indra/libndhacd/nd_hacdStructs.h

@@ -0,0 +1,77 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef ND_HACD_DECOMPSTRUCTS_H
+#define ND_HACD_DECOMPSTRUCTS_H
+
+#include "nd_hacdDefines.h"
+#include "hacdHACD.h"
+#include "LLConvexDecomposition.h"
+#include <vector>
+
+struct LLCDHull;
+struct LLCDMeshData;
+
+struct DecompHull
+{
+	std::vector< tVecDbl > mVertices;
+	std::vector< tVecLong > mTriangles;
+
+	std::vector< float > mLLVertices;
+	std::vector< hacdUINT32 > mLLTriangles;
+
+	void clear();
+
+	void computeLLVertices();
+
+	void computeLLTriangles();
+
+	void toLLHull( LLCDHull *aHull );
+	void toLLMesh( LLCDMeshData *aMesh );
+};
+
+struct DecompData
+{
+	std::vector< DecompHull > mHulls;
+
+	void clear();
+};
+
+struct HACDDecoder: public HACD::ICallback
+{
+	std::vector< tVecDbl > mVertices;
+	std::vector< tVecLong > mTriangles;
+
+	std::vector< DecompData > mStages;
+	DecompHull mSingleHull;
+
+	llcdCallbackFunc mCallback;
+
+	HACDDecoder();
+	void clear();
+
+	virtual void operator()( char const *aMsg, double aProgress, double aConcavity, size_t aVertices)
+	{
+		if( mCallback )
+			(*mCallback)(aMsg, static_cast<int>(aProgress), aVertices );
+	}
+
+};
+
+
+#endif

indra/libndhacd/nd_hacdUtils.cpp

@@ -0,0 +1,183 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "nd_hacdUtils.h"
+
+tHACD* init( int nConcavity, int nClusters, int nMaxVerticesPerHull, double dMaxConnectDist, HACDDecoder *aData )
+{
+	tHACD *pDec = HACD::CreateHACD(0);
+	pDec->SetPoints( &aData->mVertices[0] );
+	pDec->SetNPoints( aData->mVertices.size() );
+
+	if ( aData->mTriangles.size() )
+	{
+		pDec->SetTriangles( &aData->mTriangles[0] );
+		pDec->SetNTriangles( aData->mTriangles.size() );
+	}
+
+	pDec->SetCompacityWeight( 0.1f );
+	pDec->SetVolumeWeight( 0 );
+	pDec->SetNClusters( nClusters );
+	pDec->SetAddExtraDistPoints( true );
+	pDec->SetAddFacesPoints( true );
+	pDec->SetNVerticesPerCH( nMaxVerticesPerHull );
+	pDec->SetConcavity( nConcavity );
+	pDec->SetConnectDist( dMaxConnectDist );
+
+	pDec->SetCallBack( aData );
+
+	return pDec;
+}
+
+DecompData decompose( tHACD *aHACD )
+{
+	aHACD->Compute();
+
+	DecompData oRet;
+
+	int nClusters = aHACD->GetNClusters();
+
+	for ( int i = 0; i < nClusters; ++i )
+	{
+		int nVertices = aHACD->GetNPointsCH( i );
+		int nTriangles = aHACD->GetNTrianglesCH( i );
+		DecompHull oHull;
+
+		oHull.mVertices.resize( nVertices );
+		oHull.mTriangles.resize( nTriangles );
+		aHACD->GetCH( i, &oHull.mVertices[0], &oHull.mTriangles[0] );
+
+		oRet.mHulls.push_back( oHull );
+	}
+
+	return oRet;
+}
+
+tVecLong fromI16( void const *& pPtr, int aStride )
+{
+	hacdUINT16 const *pVal = reinterpret_cast< hacdUINT16 const * >( pPtr );
+	tVecLong oRet( pVal[0], pVal[1], pVal[2] );
+	pVal += aStride / 2;
+	pPtr = pVal;
+	return oRet;
+}
+
+tVecLong fromI32( void const *& pPtr, int aStride )
+{
+	hacdUINT32 const *pVal = reinterpret_cast< hacdUINT32 const * >( pPtr );
+	tVecLong oRet( pVal[0], pVal[1], pVal[2] );
+	pVal += aStride / 4;
+	pPtr = pVal;
+	return oRet;
+}
+
+LLCDResult setMeshData( const LLCDMeshData* data, bool vertex_based, HACDDecoder *aDec )
+{
+	if ( !data || !data->mVertexBase || ( data->mNumVertices < 3 ) || ( data->mVertexStrideBytes != 12 && data->mVertexStrideBytes != 16 ) )
+		return LLCD_INVALID_MESH_DATA;
+
+	if ( !vertex_based && ( ( data->mNumTriangles < 1 ) || ! data->mIndexBase ) )
+		return LLCD_INVALID_MESH_DATA;
+
+	aDec->clear();
+	int nCount = data->mNumVertices;
+	float const* pVertex = data->mVertexBase;
+	int nStride = data->mVertexStrideBytes / sizeof( float );
+
+	for ( int i = 0; i < nCount; ++i )
+	{
+		tVecDbl oPt( pVertex[0], pVertex[1], pVertex[2] );
+		aDec->mVertices.push_back( oPt );
+		pVertex += nStride;
+	}
+
+	if ( !vertex_based )
+	{
+		fFromIXX pFunc = 0;
+		nCount = data->mNumTriangles;
+		nStride = data->mIndexStrideBytes;
+		void const *pData = data->mIndexBase;
+
+		if ( data->mIndexType == LLCDMeshData::INT_16 )
+			pFunc = fromI16;
+		else
+			pFunc = fromI32;
+
+		for ( int i = 0; i < nCount; ++i )
+		{
+			tVecLong oVal( ( *pFunc )( pData, nStride ) );
+			aDec->mTriangles.push_back( oVal );
+		}
+	}
+
+	return LLCD_OK;
+}
+
+LLCDResult convertHullToMesh( const LLCDHull* aHull, std::vector< float > &aVerticesOut, std::vector< int > &aTrianglesOut )
+{
+	if( !aHull || !aHull->mVertexBase )
+		return LLCD_NULL_PTR;
+	if( aHull->mVertexStrideBytes < 3*sizeof(float) || aHull->mNumVertices < 3 )
+		return LLCD_INVALID_HULL_DATA;
+
+	HACD::ICHull oHull;
+
+	int nCount = aHull->mNumVertices;
+	float const *pVertex = aHull->mVertexBase;
+	int nStride = aHull->mVertexStrideBytes / sizeof( float );
+
+	std::vector< tVecDbl > vcPoints;
+
+	for ( int i = 0; i < nCount; ++i )
+	{
+		vcPoints.push_back( tVecDbl( pVertex[0], pVertex[1], pVertex[2] ) ); 
+		pVertex += nStride;
+	}
+
+	oHull.AddPoints( &vcPoints[0], vcPoints.size() );
+
+	HACD::ICHullError eErr = oHull.Process( MAX_VERTICES_PER_HULL );
+	if( HACD::ICHullErrorOK != eErr )
+		return LLCD_INVALID_HULL_DATA;
+
+	HACD::TMMesh &oMesh = oHull.GetMesh();
+
+	std::vector< tVecDbl > vPoints;
+	std::vector< tVecLong > vTriangles;
+
+	vPoints.resize( oMesh.GetNVertices() );
+	vTriangles.resize( oMesh.GetNTriangles() );
+
+	oMesh.GetIFS( &vPoints[0], &vTriangles[0] );
+
+	for( size_t i = 0; i < vPoints.size(); ++i )
+	{
+		aVerticesOut.push_back( static_cast<float>( vPoints[i].X() ) );
+		aVerticesOut.push_back( static_cast<float>( vPoints[i].Y() ) );
+		aVerticesOut.push_back( static_cast<float>( vPoints[i].Z() ) );
+	}
+
+	for( size_t i = 0; i < vTriangles.size(); ++i )
+	{
+		aTrianglesOut.push_back( vTriangles[i].X() );
+		aTrianglesOut.push_back( vTriangles[i].Y() );
+		aTrianglesOut.push_back( vTriangles[i].Z() );
+	}
+
+	return LLCD_OK;
+}

indra/libndhacd/nd_hacdUtils.h

@@ -0,0 +1,34 @@
+/**
+ * copyright 2011 sl.nicky.ml@googlemail.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef ND_HACD_UTILS_H
+#define ND_HACD_UTILS_H
+
+#include "nd_hacdStructs.h"
+#include "LLConvexDecomposition.h"
+
+tHACD* init( int nConcavity, int nClusters, int nMaxVerticesPerHull, double dMaxConnectDist, HACDDecoder *aData );
+DecompData decompose( tHACD *aHACD );
+
+tVecLong fromI16( void *& pPtr, int aStride );
+tVecLong fromI32( void *& pPtr, int aStride );
+
+LLCDResult setMeshData( const LLCDMeshData* data, bool vertex_based, HACDDecoder *aDec );
+LLCDResult convertHullToMesh( const LLCDHull* aHull, std::vector< float > &aVerticesOut, std::vector< int > &aTrianglesOut );
+
+#endif

indra/libndhacd/windowsincludes.h

@@ -0,0 +1,59 @@
+/** 
+ * @file windowsincludes.h
+ * @brief includes that need to be involved in the windows version of llconvexdecompositionstub
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+// Modify the following defines if you have to target a platform prior to the ones specified below.
+// Refer to MSDN for the latest info on corresponding values for different platforms.
+#ifndef WINVER				// Allow use of features specific to Windows XP or later.
+#define WINVER 0x0501		// Change this to the appropriate value to target other versions of Windows.
+#endif
+
+#ifndef _WIN32_WINNT		// Allow use of features specific to Windows XP or later.                   
+#define _WIN32_WINNT 0x0501	// Change this to the appropriate value to target other versions of Windows.
+#endif						
+
+#ifndef _WIN32_WINDOWS		// Allow use of features specific to Windows 98 or later.
+#define _WIN32_WINDOWS 0x0410 // Change this to the appropriate value to target Windows Me or later.
+#endif
+
+#ifndef _WIN32_IE			// Allow use of features specific to IE 6.0 or later.
+#define _WIN32_IE 0x0600	// Change this to the appropriate value to target other versions of IE.
+#endif
+
+#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
+// Windows Header Files:
+#include <windows.h>
+
+
+
+// TODO: reference additional headers your program requires here

indra/libpathing/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 2.6.4)
+
+project(ndPathingLib CXX C)
+
+if( MSVC )
+   add_definitions(-D_HAS_ITERATOR_DEBUGGING=0 -D_SECURE_SCL=0 -D_CRT_SECURE_NO_WARNINGS=1)
+endif( MSVC )
+
+file (GLOB SOURCE_FILES *.cpp )
+file (GLOB INCLUDE_FILES *.h )
+
+add_library(nd_Pathing STATIC ${SOURCE_FILES} ${INCLUDE_FILES} )
+

indra/libpathing/llpathinglib.cpp

@@ -0,0 +1,89 @@
+#include "llpathinglib.h"
+
+void LLPathingLib::initSystem()
+{
+}
+
+void LLPathingLib::quitSystem()
+{
+}
+
+LLPathingLib* LLPathingLib::getInstance()
+{
+	static LLPathingLib sObj;
+	return &sObj;
+}
+
+bool LLPathingLib::isFunctional()
+{
+	return false;
+}
+
+void LLPathingLib::extractNavMeshSrcFromLLSD( std::vector< unsigned char > const &aMeshData, int aNavigation )
+{
+}
+
+LLPathingLib::LLPLResult LLPathingLib::generatePath( PathingPacket const& )
+{
+	return LLPL_NO_PATH;
+}
+
+void LLPathingLib::cleanupResidual()
+{
+}
+
+void LLPathingLib::stitchNavMeshes( )
+{
+}
+
+void LLPathingLib::renderNavMesh( void )
+{
+}
+
+void LLPathingLib::renderNavMeshShapesVBO( unsigned int aShapeTypeBitmask )
+{
+}
+
+void LLPathingLib::renderPath()
+{
+}
+
+void LLPathingLib::cleanupVBOManager()
+{
+}
+
+void LLPathingLib::setNavMeshColors( NavMeshColors const &aColors )
+{
+}
+
+void LLPathingLib::setNavMeshMaterialType( LLPLCharacterType aType )
+{
+}
+
+void LLPathingLib::renderNavMeshEdges()
+{
+}
+
+void LLPathingLib::renderPathBookend( LLRender&, LLPLRenderType )
+{
+}
+
+void LLPathingLib::renderSimpleShapes( LLRender&, float )
+{
+}
+
+void LLPathingLib::createPhysicsCapsuleRep( float, float, bool, LLUUID const& )
+{
+}
+
+void LLPathingLib::cleanupPhysicsCapsuleRepResiduals()
+{
+}
+
+void LLPathingLib::processNavMeshData()
+{
+}
+
+void LLPathingLib::renderSimpleShapeCapsuleID( LLRender&, LLUUID const&, LLVector3 const&, LLQuaternion const& )
+{
+}

indra/libpathing/llpathinglib.h

@@ -0,0 +1,181 @@
+#ifndef LL_PATHINGLIB_H
+#define LL_PATHINGLIB_H
+
+#include <vector>
+
+#ifndef LL_V3MATH_H
+class LLVector3
+{
+public:
+	float mV[3];
+};
+#endif
+
+#ifndef LL_V4COLORU_H
+class LLColor4U
+{
+public:
+	unsigned char mV[4];
+};
+#endif
+
+#ifndef LL_LLUUID_H
+class LLUUID
+{
+public:
+	unsigned char mData[16];
+};
+#endif
+
+#ifndef LLQUATERNION_H
+class LLQuaternion
+{
+public:
+	double mQ[4];
+};
+#endif
+
+class LLRender;
+
+class LLPathingLib
+{
+public:
+	enum LLPLResult
+	{
+		LLPL_NO_PATH,
+		LLPL_PATH_GENERATED_OK,
+	};
+
+	enum LLPLCharacterType
+	{
+		LLPL_CHARACTER_TYPE_NONE,
+		LLPL_CHARACTER_TYPE_A,
+		LLPL_CHARACTER_TYPE_B,
+		LLPL_CHARACTER_TYPE_C,
+		LLPL_CHARACTER_TYPE_D,
+	};
+
+	enum LLShapeType
+	{
+		LLST_WalkableObjects = 1,
+		LLST_ObstacleObjects = 2,
+		LLST_MaterialPhantoms = 3,
+		LLST_ExclusionPhantoms = 4,
+	};
+
+	enum LLPLRenderType
+	{
+		LLPL_START,
+		LLPL_END,
+	};
+
+	struct Vector
+	{
+		double mX;
+		double mY;
+		double mZ;
+		
+		Vector& operator=( LLVector3 const &aRHS )
+		{
+			mX = aRHS.mV[0];
+			mY = aRHS.mV[1];
+			mZ = aRHS.mV[2];
+
+			return *this;
+		}
+		
+		operator LLVector3() const
+		{
+			LLVector3 ret;
+			ret.mV[0] = mX;
+			ret.mV[1] = mY;
+			ret.mV[2] = mZ;
+			return ret;
+		}
+	};
+
+	struct PathingPacket
+	{
+		Vector mStartPointA;
+		Vector mEndPointA;
+
+		Vector mStartPointB;
+		Vector mEndPointB;
+
+		bool mHasPointA;
+		bool mHasPointB;
+
+		double mCharacterWidth;
+		LLPLCharacterType mCharacterType;
+	};
+
+	struct NavMeshColor
+	{
+		unsigned char mR;
+		unsigned char mG;
+		unsigned char mB;
+		unsigned char mAlpha;
+
+		NavMeshColor& operator=( LLColor4U const &aRHS )
+		{
+			mR = aRHS.mV[0];
+			mG = aRHS.mV[1];
+			mB = aRHS.mV[2];
+			mAlpha = aRHS.mV[3];
+
+			return *this;
+		}
+		
+	};
+
+	struct NavMeshColors
+	{
+		NavMeshColor mWalkable;
+		NavMeshColor mObstacle;
+		NavMeshColor mMaterial;
+		NavMeshColor mExclusion;
+		NavMeshColor mConnectedEdge;
+		NavMeshColor mBoundaryEdge;
+		NavMeshColor mHeatColorBase;
+		NavMeshColor mHeatColorMax;
+		NavMeshColor mFaceColor;
+		NavMeshColor mStarValid;
+		NavMeshColor mStarInvalid;
+		NavMeshColor mTestPath;
+		NavMeshColor mWaterColor;
+	};
+
+	static void initSystem();
+	static void quitSystem();
+	static LLPathingLib* getInstance();
+
+	bool isFunctional();
+
+	void extractNavMeshSrcFromLLSD( std::vector< unsigned char> const &aMeshData, int aNavigation );
+
+	LLPLResult generatePath( PathingPacket const& );
+	void cleanupResidual();
+
+	void stitchNavMeshes( );
+
+	void renderNavMesh( void );
+	void renderNavMeshShapesVBO( unsigned int aShapeTypeBitmask );
+	void renderPath();
+	void cleanupVBOManager();
+
+	void renderNavMeshEdges();
+	void renderPathBookend( LLRender&, LLPLRenderType );
+
+	void setNavMeshColors( NavMeshColors const& );
+	void setNavMeshMaterialType( LLPLCharacterType );
+
+	void renderSimpleShapes( LLRender&, float );
+
+	void createPhysicsCapsuleRep( float, float, bool, LLUUID const& );
+	void cleanupPhysicsCapsuleRepResiduals();
+
+	void processNavMeshData();
+	void renderSimpleShapeCapsuleID( LLRender&, LLUUID const&, LLVector3 const&, LLQuaternion const& );
+};
+
+#endif

indra/libpathing/llphysicsextensions.cpp

@@ -0,0 +1,10 @@
+#include "llphysicsextensions.h"
+
+void LLPhysicsExtensions::quitSystem()
+{
+}
+
+bool LLPhysicsExtensions::isFunctional()
+{
+	return false;
+}

indra/libpathing/llphysicsextensions.h

@@ -0,0 +1,12 @@
+#ifndef LLPYHSICS_EXTENSIONS_H
+#define LLPYHSICS_EXTENSIONS_H
+
+class LLPhysicsExtensions
+{
+public:
+	static void quitSystem();
+
+	bool isFunctional();
+};
+
+#endif

indra/llcommon/aithreadsafe.h

@@ -2,7 +2,7 @@
  * @file aithreadsafe.h
  * @brief Implementation of AIThreadSafe, AIReadAccessConst, AIReadAccess and AIWriteAccess.
  *
- * Copyright (c) 2010, Aleric Inglewood.
+ * Copyright (c) 2010 - 2013, Aleric Inglewood.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -31,6 +31,9 @@
  *   Added AIThreadSafeSingleThread and friends.
  *   Added AIAccessConst (and derived AIAccess from it) to allow read
  *   access to a const AIThreadSafeSimple.
+ *
+ *   26/01/2013
+ *   Added support for LLCondition to AIThreadSafeSimple.
  */
 
 // This file defines wrapper template classes for arbitrary types T
@@ -106,8 +109,8 @@
 template<typename T> struct AIReadAccessConst;
 template<typename T> struct AIReadAccess;
 template<typename T> struct AIWriteAccess;
-template<typename T> struct AIAccessConst;
-template<typename T> struct AIAccess;
+template<typename T, typename MUTEX> struct AIAccessConst;
+template<typename T, typename MUTEX> struct AIAccess;
 template<typename T> struct AISTAccessConst;
 template<typename T> struct AISTAccess;
 
@@ -456,16 +459,16 @@ struct AIWriteAccess : public AIReadAccess<T>
  *
  * See also AIThreadSafe
  */
-template<typename T>
+template<typename T, typename MUTEX = LLMutex>
 class AIThreadSafeSimple : public AIThreadSafeBits<T>
 {
 protected:
 	// Only this one may access the object (through ptr()).
-	friend struct AIAccessConst<T>;
-	friend struct AIAccess<T>;
+	friend struct AIAccessConst<T, MUTEX>;
+	friend struct AIAccess<T, MUTEX>;
 
 	// Locking control.
-	LLMutex mMutex;
+	MUTEX mMutex;
 
 	friend struct AIRegisteredStateMachinesList;
 	// For use by AIThreadSafeSimpleDC and AIRegisteredStateMachinesList.
@@ -476,6 +479,9 @@ public:
 	// Only for use by AITHREADSAFESIMPLE, see below.
 	AIThreadSafeSimple(T* object) { llassert(object == AIThreadSafeBits<T>::ptr()); }
 
+	// If MUTEX is a LLCondition then this can be used to wake up the waiting thread.
+	void signal() { mMutex.signal(); }
+
 #if LL_DEBUG
 	// Can only be locked when there still exists an AIAccess object that
 	// references this object and will access it upon destruction.
@@ -506,6 +512,7 @@ public:
  *       If that is needed, have a look at AIThreadSafeSimpleDC.
  */
 #define AITHREADSAFESIMPLE(type, var, paramlist) AIThreadSafeSimple<type> var(new (var.memory()) type paramlist)
+#define AITHREADSAFESIMPLECONDITION(type, var, paramlist) AIThreadSafeSimple<type, LLCondition> var(new (var.memory()) type paramlist)
 
 /**
  * @brief A wrapper class for objects that need to be accessed by more than one thread.
@@ -536,18 +543,18 @@ public:
  *
  * which is not possible with AITHREADSAFESIMPLE.
  */
-template<typename T>
-class AIThreadSafeSimpleDC : public AIThreadSafeSimple<T>
+template<typename T, typename MUTEX = LLMutex>
+class AIThreadSafeSimpleDC : public AIThreadSafeSimple<T, MUTEX>
 {
 public:
 	// Construct a wrapper around a default constructed object.
-	AIThreadSafeSimpleDC(void) { new (AIThreadSafeSimple<T>::ptr()) T; }
+	AIThreadSafeSimpleDC(void) { new (AIThreadSafeSimple<T, MUTEX>::ptr()) T; }
 	// Allow an arbitrary parameter to be passed for construction.
-	template<typename T2> AIThreadSafeSimpleDC(T2 const& val) { new (AIThreadSafeSimple<T>::ptr()) T(val); }
+	template<typename T2> AIThreadSafeSimpleDC(T2 const& val) { new (AIThreadSafeSimple<T, MUTEX>::ptr()) T(val); }
 
 protected:
 	// For use by AIThreadSafeSimpleDCRootPool
-	AIThreadSafeSimpleDC(LLAPRRootPool& parent) : AIThreadSafeSimple<T>(parent) { new (AIThreadSafeSimple<T>::ptr()) T; }
+	AIThreadSafeSimpleDC(LLAPRRootPool& parent) : AIThreadSafeSimple<T, MUTEX>(parent) { new (AIThreadSafeSimple<T, MUTEX>::ptr()) T; }
 };
 
 // Helper class for AIThreadSafeSimpleDCRootPool to assure initialization of
@@ -587,11 +594,11 @@ public:
 /**
  * @brief Write lock object and provide read access.
  */
-template<typename T>
+template<typename T, typename MUTEX = LLMutex>
 struct AIAccessConst
 {
 	//! Construct a AIAccessConst from a constant AIThreadSafeSimple.
-	AIAccessConst(AIThreadSafeSimple<T> const& wrapper) : mWrapper(const_cast<AIThreadSafeSimple<T>&>(wrapper))
+	AIAccessConst(AIThreadSafeSimple<T, MUTEX> const& wrapper) : mWrapper(const_cast<AIThreadSafeSimple<T, MUTEX>&>(wrapper))
 #if AI_NEED_ACCESS_CC
 		, mIsCopyConstructed(false)
 #endif
@@ -613,8 +620,11 @@ struct AIAccessConst
 	  this->mWrapper.mMutex.unlock();
 	}
 
+	// If MUTEX is an LLCondition, then this can be used to wait for a signal.
+	void wait() { this->mWrapper.mMutex.wait(); }
+
 protected:
-	AIThreadSafeSimple<T>& mWrapper;		//!< Reference to the object that we provide access to.
+	AIThreadSafeSimple<T, MUTEX>& mWrapper;		//!< Reference to the object that we provide access to.
 
 #if AI_NEED_ACCESS_CC
 	bool mIsCopyConstructed;
@@ -630,11 +640,11 @@ private:
 /**
  * @brief Write lock object and provide read/write access.
  */
-template<typename T>
-struct AIAccess : public AIAccessConst<T>
+template<typename T, typename MUTEX = LLMutex>
+struct AIAccess : public AIAccessConst<T, MUTEX>
 {
 	//! Construct a AIAccess from a non-constant AIThreadSafeSimple.
-	AIAccess(AIThreadSafeSimple<T>& wrapper) : AIAccessConst<T>(wrapper) { }
+	AIAccess(AIThreadSafeSimple<T, MUTEX>& wrapper) : AIAccessConst<T, MUTEX>(wrapper) { }
 
 	//! Access the underlaying object for (read and) write access.
 	T* operator->() const { return this->mWrapper.ptr(); }

indra/llcommon/llhash.h

@@ -33,15 +33,15 @@
 #include <hash_map>
 #include <algorithm>
 #elif LL_DARWIN || LL_LINUX
-#  if GCC_VERSION >= 40300 || LL_ICC// gcc 4.3 or icc 11 and up
-#    include <backward/hashtable.h>
-#  elif GCC_VERSION >= 30400 // gcc 3.4 and up
-#    include <ext/hashtable.h>
-#  elif __GNUC__ >= 3
-#    include <ext/stl_hashtable.h>
-#  else
-#    include <hashtable.h>
-#  endif
+#if GCC_VERSION >= 40300 || LL_ICC || LL_CLANG// gcc 4.3 or icc 11 and up
+#  include <backward/hashtable.h> 
+#elif GCC_VERSION >= 30400 // gcc 3.4 and up
+#  include <ext/hashtable.h>
+#elif __GNUC__ >= 3
+#  include <ext/stl_hashtable.h>
+#else
+#  include <hashtable.h>
+#endif
 #elif LL_SOLARIS
 #include <ext/hashtable.h>
 #else

indra/llcommon/llprocessor.cpp

@@ -788,7 +788,7 @@ private:
 		LLPI_SET_INFO_INT(eModel, "model");
 
 		
-		S32 family;							 
+		S32 family = 0;							 
 		if (!cpuinfo["cpu family"].empty() 
 			&& LLStringUtil::convertToS32(cpuinfo["cpu family"], family))	
 		{ 

indra/llcommon/llstat.cpp

@@ -779,12 +779,8 @@ void LLStat::init()
 
 LLStat::stat_map_t& LLStat::getStatList()
 {
-	static LLStat::stat_map_t* stat_list = NULL;
-	if(!stat_list)
-	{
-		stat_list = new LLStat::stat_map_t();
-	}
-	return *stat_list;
+	static LLStat::stat_map_t stat_list;
+	return stat_list;
 }
 
 LLStat::LLStat(const U32 num_bins, const BOOL use_frame_timer)

indra/llcommon/llthread.cpp

@@ -103,7 +103,7 @@ void *APR_THREAD_FUNC LLThread::staticRun(apr_thread_t *apr_threadp, void *datap
 	--sRunning;
 
 	// We're done with the run function, this thread is done executing now.
-	threadp->mStatus = STOPPED;
+	threadp->terminated();
 
 	// Only now print this info [doing that before setting mStatus
 	// to STOPPED makes it much more likely that another thread runs

indra/llcommon/llthread.h

@@ -122,6 +122,9 @@ public:
 	// this kicks off the apr thread
 	void start(void);
 
+	// Can be used to tell the thread we're not interested anymore and it should abort.
+	void setQuitting();
+	
 	// Return thread-local data for the current thread.
 	static LLThreadLocalData& tldata(void) { return LLThreadLocalData::tldata(); }
 
@@ -141,11 +144,12 @@ protected:
 	friend void LLThreadLocalData::create(LLThread* threadp);
 	LLThreadLocalData*  mThreadLocalData;
 
-	void setQuitting();
-	
 	// virtual function overridden by subclass -- this will be called when the thread runs
 	virtual void run(void) = 0; 
 	
+	// This class is completely done (called from THREAD!).
+	virtual void terminated(void) { mStatus = STOPPED; }
+
 	// virtual predicate function -- returns true if the thread should wake up, false if it should sleep.
 	virtual bool runCondition(void);
 

indra/llmessage/llhttpclient.cpp

@@ -204,7 +204,9 @@ static void request(
 	DEBUG_CURLIO_PARAM(EDebugCurl debug),
 	EKeepAlive keepalive = keep_alive,
 	bool is_auth = false,
-	bool no_compression = false)
+	bool no_compression = false,
+	AIStateMachine* parent = NULL,
+	AIStateMachine::state_type new_parent_state = 0)
 {
 	if (responder)
 	{
@@ -227,7 +229,7 @@ static void request(
 		return ;
 	}
 
-	req->run();
+	req->run(parent, new_parent_state, parent != NULL);
 }
 
 void LLHTTPClient::getByteRange(std::string const& url, S32 offset, S32 bytes, ResponderPtr responder, AIHTTPHeaders& headers/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug))
@@ -684,9 +686,9 @@ void LLHTTPClient::put(std::string const& url, LLSD const& body, ResponderPtr re
 	request(url, LLURLRequest::HTTP_PUT, new LLSDInjector(body), responder, headers/*,*/ DEBUG_CURLIO_PARAM(debug));
 }
 
-void LLHTTPClient::post(std::string const& url, LLSD const& body, ResponderPtr responder, AIHTTPHeaders& headers/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug), EKeepAlive keepalive)
+void LLHTTPClient::post(std::string const& url, LLSD const& body, ResponderPtr responder, AIHTTPHeaders& headers/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug), EKeepAlive keepalive, AIStateMachine* parent, AIStateMachine::state_type new_parent_state)
 {
-	request(url, LLURLRequest::HTTP_POST, new LLSDInjector(body), responder, headers/*,*/ DEBUG_CURLIO_PARAM(debug), keepalive);
+	request(url, LLURLRequest::HTTP_POST, new LLSDInjector(body), responder, headers/*,*/ DEBUG_CURLIO_PARAM(debug), keepalive, false, false, parent, new_parent_state);
 }
 
 void LLHTTPClient::postXMLRPC(std::string const& url, XMLRPC_REQUEST xmlrpc_request, ResponderPtr responder, AIHTTPHeaders& headers/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug), EKeepAlive keepalive)

indra/llmessage/llhttpclient.h

@@ -45,6 +45,7 @@ class LLSD;
 class AIHTTPTimeoutPolicy;
 class LLBufferArray;
 class LLChannelDescriptors;
+class AIStateMachine;
 
 extern AIHTTPTimeoutPolicy responderIgnore_timeout;
 typedef struct _xmlrpc_request* XMLRPC_REQUEST;
@@ -418,9 +419,9 @@ public:
 	static void getHeaderOnly(std::string const& url, ResponderHeadersOnly* responder/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug = debug_off))
 	    { AIHTTPHeaders headers; getHeaderOnly(url, responder, headers/*,*/ DEBUG_CURLIO_PARAM(debug)); }
 
-	static void post(std::string const& url, LLSD const& body, ResponderPtr responder, AIHTTPHeaders& headers/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug = debug_off), EKeepAlive keepalive = keep_alive);
-	static void post(std::string const& url, LLSD const& body, ResponderPtr responder/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug = debug_off), EKeepAlive keepalive = keep_alive)
-	    { AIHTTPHeaders headers; post(url, body, responder, headers/*,*/ DEBUG_CURLIO_PARAM(debug), keepalive); }
+	static void post(std::string const& url, LLSD const& body, ResponderPtr responder, AIHTTPHeaders& headers/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug = debug_off), EKeepAlive keepalive = keep_alive, AIStateMachine* parent = NULL, U32 new_parent_state = 0);
+	static void post(std::string const& url, LLSD const& body, ResponderPtr responder/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug = debug_off), EKeepAlive keepalive = keep_alive, AIStateMachine* parent = NULL, U32 new_parent_state = 0)
+	    { AIHTTPHeaders headers; post(url, body, responder, headers/*,*/ DEBUG_CURLIO_PARAM(debug), keepalive, parent, new_parent_state); }
 
 	/** Takes ownership of request and deletes it when sent */
 	static void postXMLRPC(std::string const& url, XMLRPC_REQUEST request, ResponderPtr responder, AIHTTPHeaders& headers/*,*/ DEBUG_CURLIO_PARAM(EDebugCurl debug = debug_off), EKeepAlive keepalive = keep_alive);

indra/llprimitive/CMakeLists.txt

@@ -7,12 +7,16 @@ include(LLCommon)
 include(LLMath)
 include(LLMessage)
 include(LLXML)
+include(LLPhysicsExtensions)
+include(Colladadom)
 
 include_directories(
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLMESSAGE_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
+    ${LLPHYSICSEXTENSIONS_INCLUDE_DIRS}
+    ${COLLADADOM_INCLUDE_DIRS}
     )
 
 set(llprimitive_SOURCE_FILES

indra/llprimitive/llmodel.cpp

@@ -28,18 +28,25 @@
 
 #include "llmodel.h"
 #include "llmemory.h"
-#if MESH_IMPORT
-#include "llconvexdecomposition.h"
-#endif //MESH_IMPORT
+#include "LLConvexDecomposition.h"
 #include "llsdserialize.h"
 #include "llvector4a.h"
-
-#if MESH_IMPORT
+#if LL_MSVC
+#pragma warning (push)
+#pragma warning (disable : 4068)
+#pragma warning (disable : 4263)
+#pragma warning (disable : 4264)
+#endif
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverloaded-virtual"
 #include "dae.h"
 #include "dae/daeErrorHandler.h"
 #include "dom/domConstants.h"
 #include "dom/domMesh.h"
-#endif //MESH_IMPORT
+#pragma GCC diagnostic pop
+#if LL_MSVC
+#pragma warning (pop)
+#endif
 
 #ifdef LL_STANDALONE
 # include <zlib.h>
@@ -72,13 +79,10 @@ LLModel::~LLModel()
 {
 	if (mDecompID >= 0)
 	{
-#if	MESH_IMPORT
 		LLConvexDecomposition::getInstance()->deleteDecomposition(mDecompID);
-#endif //MESH_IMPORT
 	}
 }
 
-#if	MESH_IMPORT
 
 bool get_dom_sources(const domInputLocalOffset_Array& inputs, S32& pos_offset, S32& tc_offset, S32& norm_offset, S32 &idx_stride,
 					 domSource* &pos_source, domSource* &tc_source, domSource* &norm_source)
@@ -823,7 +827,6 @@ BOOL LLModel::createVolumeFacesFromDomMesh(domMesh* mesh)
 	
 	return FALSE;
 }
-#endif //MESH_IMPORT
 
 void LLModel::offsetMesh( const LLVector3& pivotPoint )
 {
@@ -1294,8 +1297,6 @@ void LLModel::generateNormals(F32 angle_cutoff)
 	}
 }
 
-#if MESH_IMPORT
-
 //static
 std::string LLModel::getElementLabel(daeElement *element)
 { // try to get a decent label for this element
@@ -1351,7 +1352,6 @@ LLModel* LLModel::loadModelFromDomMesh(domMesh *mesh)
 	ret->mLabel = getElementLabel(mesh);
 	return ret;
 }
-#endif //MESH_IMPORT
 
 std::string LLModel::getName() const
 {

indra/llprimitive/llmodel.h

@@ -32,10 +32,8 @@
 #include "v4math.h"
 #include "m4math.h"
 
-#if MESH_IMPORT
 class daeElement;
 class domMesh;
-#endif //MESH_IMPORT
 
 #define MAX_MODEL_FACES 8
 
@@ -147,10 +145,8 @@ public:
 		LLSD& mdl,
 		BOOL nowrite = FALSE, BOOL as_slm = FALSE);
 
-#if MESH_IMPORT
 	static LLModel* loadModelFromDomMesh(domMesh* mesh);
 	static std::string getElementLabel(daeElement* element);
-#endif //MESH_IMPORT
 	std::string getName() const;
 	std::string getMetric() const {return mMetric;}
 	EModelStatus getStatus() const {return mStatus;}
@@ -278,10 +274,8 @@ public:
 
 	EModelStatus mStatus ;
 protected:
-#if MESH_IMPORT
 	void addVolumeFacesFromDomMesh(domMesh* mesh);
 	virtual BOOL createVolumeFacesFromDomMesh(domMesh *mesh);
-#endif //MESH_IMPORT
 };
 
 #endif //LL_LLMODEL_H

indra/llwindow/llwindowsdl.cpp

@@ -1730,206 +1730,204 @@ void LLWindowSDL::gatherInput()
     {
         switch (event.type)
         {
-        case SDL_MOUSEMOTION:
-        {
-            LLCoordWindow winCoord(event.button.x, event.button.y);
-            LLCoordGL openGlCoord;
-            convertCoords(winCoord, &openGlCoord);
-            MASK mask = gKeyboard->currentMask(TRUE);
-            mCallbacks->handleMouseMove(this, openGlCoord, mask);
-            break;
-        }
-
-        case SDL_KEYDOWN:
-            mKeyScanCode = event.key.keysym.scancode;
-            mKeyVirtualKey = event.key.keysym.unicode;
-            mKeyModifiers = event.key.keysym.mod;
-
-            gKeyboard->handleKeyDown(event.key.keysym.sym, event.key.keysym.mod);
-            // part of the fix for SL-13243
-            if (SDLCheckGrabbyKeys(event.key.keysym.sym, TRUE) != 0)
-                SDLReallyCaptureInput(TRUE);
-
-            if (event.key.keysym.unicode)
+            case SDL_MOUSEMOTION:
             {
-                handleUnicodeUTF16(event.key.keysym.unicode,
-                                   gKeyboard->currentMask(FALSE));
-            }
-            break;
-
-        case SDL_KEYUP:
-            mKeyScanCode = event.key.keysym.scancode;
-            mKeyVirtualKey = event.key.keysym.unicode;
-            mKeyModifiers = event.key.keysym.mod;
-
-            if (SDLCheckGrabbyKeys(event.key.keysym.sym, FALSE) == 0)
-                SDLReallyCaptureInput(FALSE); // part of the fix for SL-13243
-
-            gKeyboard->handleKeyUp(event.key.keysym.sym, event.key.keysym.mod);
-            break;
-
-        case SDL_MOUSEBUTTONDOWN:
-        {
-            bool isDoubleClick = false;
-            LLCoordWindow winCoord(event.button.x, event.button.y);
-            LLCoordGL openGlCoord;
-            convertCoords(winCoord, &openGlCoord);
-            MASK mask = gKeyboard->currentMask(TRUE);
-
-            if (event.button.button == SDL_BUTTON_LEFT)   // SDL doesn't manage double clicking...
-            {
-                Uint32 now = SDL_GetTicks();
-                if ((now - lastLeftDown) > CLICK_THRESHOLD)
-                    leftClick = 1;
-                else
-                {
-                    if (++leftClick >= 2)
-                    {
-                        leftClick = 0;
-                        isDoubleClick = true;
-                    }
-                }
-                lastLeftDown = now;
-            }
-            else if (event.button.button == SDL_BUTTON_RIGHT)
-            {
-                Uint32 now = SDL_GetTicks();
-                if ((now - lastRightDown) > CLICK_THRESHOLD)
-                    rightClick = 1;
-                else
-                {
-                    if (++rightClick >= 2)
-                    {
-                        rightClick = 0;
-                        isDoubleClick = true;
-                    }
-                }
-                lastRightDown = now;
-            }
-
-            if (event.button.button == SDL_BUTTON_LEFT)  // left
-            {
-                if (isDoubleClick)
-                    mCallbacks->handleDoubleClick(this, openGlCoord, mask);
-                else
-                    mCallbacks->handleMouseDown(this, openGlCoord, mask);
-            }
-
-            else if (event.button.button == SDL_BUTTON_RIGHT)  // right
-            {
-                mCallbacks->handleRightMouseDown(this, openGlCoord, mask);
-            }
-
-            else if (event.button.button == SDL_BUTTON_MIDDLE)  // middle
-            {
-                mCallbacks->handleMiddleMouseDown(this, openGlCoord, mask);
-            }
-            else if (event.button.button == 4)  // mousewheel up...thanks to X11 for making SDL consider these "buttons".
-                mCallbacks->handleScrollWheel(this, -1);
-            else if (event.button.button == 5)  // mousewheel down...thanks to X11 for making SDL consider these "buttons".
-                mCallbacks->handleScrollWheel(this, 1);
-
-            break;
-        }
-
-        case SDL_MOUSEBUTTONUP:
-        {
-            LLCoordWindow winCoord(event.button.x, event.button.y);
-            LLCoordGL openGlCoord;
-            convertCoords(winCoord, &openGlCoord);
-            MASK mask = gKeyboard->currentMask(TRUE);
-
-            if (event.button.button == SDL_BUTTON_LEFT)  // left
-                mCallbacks->handleMouseUp(this, openGlCoord, mask);
-            else if (event.button.button == SDL_BUTTON_RIGHT)  // right
-                mCallbacks->handleRightMouseUp(this, openGlCoord, mask);
-            else if (event.button.button == SDL_BUTTON_MIDDLE)  // middle
-                mCallbacks->handleMiddleMouseUp(this, openGlCoord, mask);
-            // don't handle mousewheel here...
-
-            break;
-        }
-
-        case SDL_VIDEOEXPOSE:  // VIDEOEXPOSE doesn't specify the damage, but hey, it's OpenGL...repaint the whole thing!
-            mCallbacks->handlePaint(this, 0, 0, mWindow->w, mWindow->h);
-            break;
-
-        case SDL_VIDEORESIZE:
-        {
-            llinfos << "Handling a resize event: " << event.resize.w <<
-                       "x" << event.resize.h << llendl;
-
-            S32 width = llmax(event.resize.w, MIN_WINDOW_WIDTH);
-            S32 height = llmax(event.resize.h, MIN_WINDOW_HEIGHT);
-
-            if (width != mWindow->w || height != mWindow->h)
-            {
-                mWindow = SDL_SetVideoMode(width, height, 32, mSDLFlags);
-            }
-            if (!mWindow)
-            {
-                // *FIX: More informative dialog?
-                llinfos << "Could not recreate context after resize! Quitting..." << llendl;
-                if(mCallbacks->handleCloseRequest(this))
-                {
-                    // Get the app to initiate cleanup.
-                    mCallbacks->handleQuit(this);
-                    // The app is responsible for calling destroyWindow when done with GL
-                }
+                LLCoordWindow winCoord(event.button.x, event.button.y);
+                LLCoordGL openGlCoord;
+                convertCoords(winCoord, &openGlCoord);
+				MASK mask = gKeyboard->currentMask(TRUE);
+				mCallbacks->handleMouseMove(this, openGlCoord, mask);
                 break;
             }
 
-            mCallbacks->handleResize(this, width, height);
-            break;
-        }
-        case SDL_ACTIVEEVENT:
-            if (event.active.state & SDL_APPINPUTFOCUS)
+            case SDL_KEYDOWN:
+		    mKeyScanCode = event.key.keysym.scancode;
+		    mKeyVirtualKey = event.key.keysym.unicode;
+		    mKeyModifiers = event.key.keysym.mod;
+
+		    gKeyboard->handleKeyDown(event.key.keysym.sym, event.key.keysym.mod);
+		    // part of the fix for SL-13243
+		    if (SDLCheckGrabbyKeys(event.key.keysym.sym, TRUE) != 0)
+			    SDLReallyCaptureInput(TRUE);
+
+		    if (event.key.keysym.unicode)
+		    {
+			    handleUnicodeUTF16(event.key.keysym.unicode,
+					       gKeyboard->currentMask(FALSE));
+		    }
+                break;
+
+            case SDL_KEYUP:
+		    mKeyScanCode = event.key.keysym.scancode;
+		    mKeyVirtualKey = event.key.keysym.unicode;
+		    mKeyModifiers = event.key.keysym.mod;
+
+		    if (SDLCheckGrabbyKeys(event.key.keysym.sym, FALSE) == 0)
+			    SDLReallyCaptureInput(FALSE); // part of the fix for SL-13243
+
+		    gKeyboard->handleKeyUp(event.key.keysym.sym, event.key.keysym.mod);
+		    break;
+
+            case SDL_MOUSEBUTTONDOWN:
             {
-                // Note that for SDL (particularly on X11), keyboard
-                // and mouse focus are independent things.  Here we are
-                // tracking keyboard focus state changes.
+                bool isDoubleClick = false;
+                LLCoordWindow winCoord(event.button.x, event.button.y);
+                LLCoordGL openGlCoord;
+                convertCoords(winCoord, &openGlCoord);
+		MASK mask = gKeyboard->currentMask(TRUE);
 
-                // We have to do our own state massaging because SDL
-                // can send us two unfocus events in a row for example,
-                // which confuses the focus code [SL-24071].
-                if (event.active.gain != mHaveInputFocus)
+                if (event.button.button == SDL_BUTTON_LEFT)   // SDL doesn't manage double clicking...
                 {
-                    mHaveInputFocus = !!event.active.gain;
-
-                    if (mHaveInputFocus)
-                        mCallbacks->handleFocus(this);
+                    Uint32 now = SDL_GetTicks();
+                    if ((now - lastLeftDown) > CLICK_THRESHOLD)
+                        leftClick = 1;
                     else
-                        mCallbacks->handleFocusLost(this);
+                    {
+                        if (++leftClick >= 2)
+                        {
+                            leftClick = 0;
+			    isDoubleClick = true;
+                        }
+                    }
+                    lastLeftDown = now;
                 }
-            }
-            if (event.active.state & SDL_APPACTIVE)
-            {
-                // Change in iconification/minimization state.
-                if ((!event.active.gain) != mIsMinimized)
+                else if (event.button.button == SDL_BUTTON_RIGHT)
                 {
-                    mIsMinimized = (!event.active.gain);
-
-                    mCallbacks->handleActivate(this, !mIsMinimized);
-                    lldebugs << "SDL deiconification state switched to " << BOOL(event.active.gain) << llendl;
+                    Uint32 now = SDL_GetTicks();
+                    if ((now - lastRightDown) > CLICK_THRESHOLD)
+                        rightClick = 1;
+                    else
+                    {
+                        if (++rightClick >= 2)
+                        {
+                            rightClick = 0;
+    					    isDoubleClick = true;
+                        }
+                    }
+                    lastRightDown = now;
                 }
-                else
+
+                if (event.button.button == SDL_BUTTON_LEFT)  // left
                 {
-                    llinfos << "Ignored bogus redundant SDL deiconification state switch to " << BOOL(event.active.gain) << llendl;
+                    if (isDoubleClick)
+				        mCallbacks->handleDoubleClick(this, openGlCoord, mask);
+                    else
+    				    mCallbacks->handleMouseDown(this, openGlCoord, mask);
                 }
-            }
-            break;
 
-        case SDL_QUIT:
-            if(mCallbacks->handleCloseRequest(this))
-            {
-                // Get the app to initiate cleanup.
-                mCallbacks->handleQuit(this);
-                // The app is responsible for calling destroyWindow when done with GL
+                else if (event.button.button == SDL_BUTTON_RIGHT)  // right
+                {
+			mCallbacks->handleRightMouseDown(this, openGlCoord, mask);
+                }
+
+                else if (event.button.button == SDL_BUTTON_MIDDLE)  // middle
+				{
+				    mCallbacks->handleMiddleMouseDown(this, openGlCoord, mask);
+				}
+                else if (event.button.button == 4)  // mousewheel up...thanks to X11 for making SDL consider these "buttons".
+					mCallbacks->handleScrollWheel(this, -1);
+                else if (event.button.button == 5)  // mousewheel down...thanks to X11 for making SDL consider these "buttons".
+					mCallbacks->handleScrollWheel(this, 1);
+
+                break;
             }
-            break;
-        default:
-            //llinfos << "Unhandled SDL event type " << event.type << llendl;
-            break;
+
+            case SDL_MOUSEBUTTONUP:
+            {
+                LLCoordWindow winCoord(event.button.x, event.button.y);
+                LLCoordGL openGlCoord;
+                convertCoords(winCoord, &openGlCoord);
+		MASK mask = gKeyboard->currentMask(TRUE);
+
+                if (event.button.button == SDL_BUTTON_LEFT)  // left
+			mCallbacks->handleMouseUp(this, openGlCoord, mask);
+                else if (event.button.button == SDL_BUTTON_RIGHT)  // right
+			mCallbacks->handleRightMouseUp(this, openGlCoord, mask);
+                else if (event.button.button == SDL_BUTTON_MIDDLE)  // middle
+			mCallbacks->handleMiddleMouseUp(this, openGlCoord, mask);
+                // don't handle mousewheel here...
+
+                break;
+            }
+
+            case SDL_VIDEOEXPOSE:  // VIDEOEXPOSE doesn't specify the damage, but hey, it's OpenGL...repaint the whole thing!
+			    mCallbacks->handlePaint(this, 0, 0, mWindow->w, mWindow->h);
+                break;
+
+            case SDL_VIDEORESIZE:  // *FIX: handle this?
+            {
+		llinfos << "Handling a resize event: " << event.resize.w <<
+			"x" << event.resize.h << llendl;
+
+		S32 width = llmax(event.resize.w, MIN_WINDOW_WIDTH);
+		S32 height = llmax(event.resize.h, MIN_WINDOW_HEIGHT);
+
+		// *FIX: I'm not sure this is necessary!
+		mWindow = SDL_SetVideoMode(width, height, 32, mSDLFlags);
+		if (!mWindow)
+		{
+			// *FIX: More informative dialog?
+			llinfos << "Could not recreate context after resize! Quitting..." << llendl;
+			if(mCallbacks->handleCloseRequest(this))
+    			{
+    				// Get the app to initiate cleanup.
+    				mCallbacks->handleQuit(this);
+    				// The app is responsible for calling destroyWindow when done with GL
+    			}
+                break;
+		}
+
+		mCallbacks->handleResize(this, width, height);
+                break;
+            }
+            case SDL_ACTIVEEVENT:
+                if (event.active.state & SDL_APPINPUTFOCUS)
+                {
+			// Note that for SDL (particularly on X11), keyboard
+			// and mouse focus are independent things.  Here we are
+			// tracking keyboard focus state changes.
+
+			// We have to do our own state massaging because SDL
+			// can send us two unfocus events in a row for example,
+			// which confuses the focus code [SL-24071].
+			if (event.active.gain != mHaveInputFocus)
+			{
+				mHaveInputFocus = !!event.active.gain;
+
+				if (mHaveInputFocus)
+					mCallbacks->handleFocus(this);
+				else
+					mCallbacks->handleFocusLost(this);
+			}
+                }
+                if (event.active.state & SDL_APPACTIVE)
+                {
+			// Change in iconification/minimization state.
+			if ((!event.active.gain) != mIsMinimized)
+			{
+				mIsMinimized = (!event.active.gain);
+
+				mCallbacks->handleActivate(this, !mIsMinimized);
+				lldebugs << "SDL deiconification state switched to " << BOOL(event.active.gain) << llendl;
+			}
+			else
+			{
+				llinfos << "Ignored bogus redundant SDL deiconification state switch to " << BOOL(event.active.gain) << llendl;
+			}
+                }
+                break;
+
+            case SDL_QUIT:
+			    if(mCallbacks->handleCloseRequest(this))
+    			{
+    				// Get the app to initiate cleanup.
+    				mCallbacks->handleQuit(this);
+    				// The app is responsible for calling destroyWindow when done with GL
+    			}
+                break;
+	default:
+		//llinfos << "Unhandled SDL event type " << event.type << llendl;
+		break;
         }
     }
 	

indra/newview/CMakeLists.txt

@@ -27,8 +27,8 @@ include(LLImageJ2COJ)
 include(LLInventory)
 include(LLMath)
 include(LLMessage)
+include(LLPhysicsExtensions)
 include(LLPlugin)
-include(StateMachine)
 include(LLPrimitive)
 include(LLRender)
 include(LLUI)
@@ -39,10 +39,12 @@ include(LLXML)
 include(Linking)
 include(NDOF)
 include(GooglePerfTools)
+include(StateMachine)
 include(TemplateCheck)
 include(UI)
 include(LLKDU)
 include(ViewerMiscLibs)
+include(GLOD)
 include(ViewerArtwork.cmake)
 include(LLAppearance)
 
@@ -57,6 +59,7 @@ include_directories(
     ${HUNSPELL_INCLUDE_DIR}
     ${ELFIO_INCLUDE_DIR}
     ${JSONCPP_INCLUDE_DIRS}
+    ${GLOD_INCLUDE_DIRS}
     ${LLAUDIO_INCLUDE_DIRS}
     ${LLCHARACTER_INCLUDE_DIRS}
     ${LLCOMMON_INCLUDE_DIRS}
@@ -64,6 +67,7 @@ include_directories(
     ${LLINVENTORY_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLMESSAGE_INCLUDE_DIRS}
+    ${LLPHYSICSEXTENSIONS_INCLUDE_DIRS}
     ${LLPLUGIN_INCLUDE_DIRS}
     ${LLPRIMITIVE_INCLUDE_DIRS}
     ${LLRENDER_INCLUDE_DIRS}
@@ -220,6 +224,7 @@ set(viewer_SOURCE_FILES
     llfloatermediabrowser.cpp
     llfloatermemleak.cpp
     llfloatermessagelog.cpp
+    llfloatermodelpreview.cpp
     llfloatermodeluploadbase.cpp
     llfloatermute.cpp
     llfloaternamedesc.cpp
@@ -720,6 +725,7 @@ set(viewer_HEADER_FILES
     llfloatermediabrowser.h
     llfloatermemleak.h
     llfloatermessagelog.h
+    llfloatermodelpreview.h
     llfloatermodeluploadbase.h
     llfloatermute.h
     llfloaternamedesc.h
@@ -1560,6 +1566,7 @@ target_link_libraries(${VIEWER_BINARY_NAME}
     ${DBUSGLIB_LIBRARIES}
     ${OPENGL_LIBRARIES}
     ${FMODWRAPPER_LIBRARY} # must come after LLAudio
+    ${GLOD_LIBRARIES}
     ${APRUTIL_LIBRARIES}
     ${OPENGL_LIBRARIES}
     ${JSONCPP_LIBRARIES}
@@ -1570,6 +1577,7 @@ target_link_libraries(${VIEWER_BINARY_NAME}
     ${XMLRPCEPI_LIBRARIES}
     ${ELFIO_LIBRARIES}
     ${HUNSPELL_LIBRARY}
+    ${LLPHYSICSEXTENSIONS_LIBRARIES}
     ${LLAPPEARANCE_LIBRARIES}
     )
 

indra/newview/app_settings/settings.xml

@@ -6858,6 +6858,22 @@ This should be as low as possible, but too low may break functionality</string>
         <integer>0</integer>
       </array>
     </map>
+    <key>FloaterModelUploadRect</key>
+    <map>
+      <key>Comment</key>
+      <string>Rectangle for mesh upload floater</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Rect</string>
+      <key>Value</key>
+      <array>
+        <integer>0</integer>
+        <integer>480</integer>
+        <integer>940</integer>
+        <integer>52</integer>
+      </array>
+    </map>
     <key>FloaterMoveRect2</key>
     <map>
       <key>Comment</key>

indra/newview/llappviewer.cpp

@@ -1344,7 +1344,6 @@ bool LLAppViewer::mainLoop()
 						break;
 					}
 				}
-				gMeshRepo.update() ;
 				if ((LLStartUp::getStartupState() >= STATE_CLEANUP) &&
 					(frameTimer.getElapsedTimeF64() > FRAME_STALL_THRESHOLD))
 				{

indra/newview/llfloateractivespeakers.cpp

@@ -70,8 +70,6 @@ const LLColor4 INACTIVE_COLOR(0.3f, 0.3f, 0.3f, 0.5f);
 const LLColor4 ACTIVE_COLOR(0.5f, 0.5f, 0.5f, 1.f);
 const F32 TYPING_ANIMATION_FPS = 2.5f;
 
-static void on_avatar_name_lookup(const LLUUID&, const LLAvatarName& avatar_name, std::string& mDisplayName);
-
 LLSpeaker::LLSpeaker(const LLUUID& id, const std::string& name, const ESpeakerType type) : 
 	mStatus(LLSpeaker::STATUS_TEXT_ONLY),
 	mLastSpokeTime(0.f), 
@@ -84,7 +82,8 @@ LLSpeaker::LLSpeaker(const LLUUID& id, const std::string& name, const ESpeakerTy
 	mType(type),
 	mIsModerator(FALSE),
 	mModeratorMutedVoice(FALSE),
-	mModeratorMutedText(FALSE)
+	mModeratorMutedText(FALSE),
+	mNameRequested(false)
 {
 	// Make sure we also get the display name if SLIM or some other external
 	// voice client is used and not whatever is provided.
@@ -104,15 +103,14 @@ LLSpeaker::LLSpeaker(const LLUUID& id, const std::string& name, const ESpeakerTy
 
 void LLSpeaker::lookupName()
 {
-	LLAvatarNameCache::get(mID, boost::bind(&on_avatar_name_lookup, _1, _2, boost::ref(mDisplayName)));
-
-	// Also set the legacy name. We will need it to initiate a new
-	// IM session.
-	gCacheName->getFullName(mID, mLegacyName);
-	mLegacyName = LLCacheName::cleanFullName(mLegacyName);
+	if(!mNameRequested)
+	{
+		mNameRequested = true;
+		LLAvatarNameCache::get(mID, boost::bind(&LLSpeaker::onNameCache, this, _2));
+	}
 }
 
-static void on_avatar_name_lookup(const LLUUID&, const LLAvatarName& avatar_name, std::string& mDisplayName)
+void LLSpeaker::onNameCache(const LLAvatarName& avatar_name)
 {
 	LLAvatarNameCache::getPNSName(avatar_name, mDisplayName);
 // [RLVa:KB] - Checked: 2009-07-10 (RLVa-1.0.0g) | Added: RLVa-1.0.0g
@@ -120,6 +118,10 @@ static void on_avatar_name_lookup(const LLUUID&, const LLAvatarName& avatar_name
 	if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
 		mDisplayName = RlvStrings::getAnonym(mDisplayName);
 // [/RLVa:KB]
+
+	// Also set the legacy name. We will need it to initiate a new
+	// IM session.
+	mLegacyName = LLCacheName::cleanFullName(avatar_name.getLegacyName());
 }
 
 LLSpeakerTextModerationEvent::LLSpeakerTextModerationEvent(LLSpeaker* source)
@@ -616,6 +618,7 @@ void LLPanelActiveSpeakers::refreshSpeakers()
 								&& selected_speakerp->mType != LLSpeaker::SPEAKER_EXTERNAL
 								// Ansariel: No, we don't want to mute Lindens with display names
 								//&& !LLMuteList::getInstance()->isLinden(selected_speakerp->mDisplayName));
+								&& !selected_speakerp->mLegacyName.empty()
 								&& !LLMuteList::getInstance()->isLinden(selected_speakerp->mLegacyName));
 	}
 	mVolumeSlider->setValue(gVoiceClient->getUserVolume(selected_id));
@@ -788,7 +791,7 @@ void LLPanelActiveSpeakers::onDoubleClickSpeaker(void* user_data)
 
 	LLPointer<LLSpeaker> speakerp = panelp->mSpeakerMgr->findSpeaker(speaker_id);
 
-	if (speaker_id != gAgent.getID() && speakerp.notNull())
+	if (speaker_id != gAgent.getID() && speakerp.notNull() && !speakerp->mLegacyName.empty())
 	{
 		// Changed for display name support
 		//gIMMgr->addSession(speakerp->mDisplayName, IM_NOTHING_SPECIAL, speaker_id);

indra/newview/llfloateractivespeakers.h

@@ -39,7 +39,9 @@
 #include "llvoiceclient.h"
 #include "llframetimer.h"
 #include "llevent.h"
+
 #include <list>
+#include <boost/signals2.hpp>
 
 class LLScrollListCtrl;
 class LLButton;
@@ -52,7 +54,7 @@ class LLCheckBoxCtrl;
 
 
 // data for a given participant in a voice channel
-class LLSpeaker : public LLRefCount, public LLOldEvents::LLObservable, public LLHandleProvider<LLSpeaker>
+class LLSpeaker : public LLRefCount, public LLOldEvents::LLObservable, public LLHandleProvider<LLSpeaker>, public boost::signals2::trackable
 {
 public:
 	typedef enum e_speaker_type
@@ -76,6 +78,7 @@ public:
 	LLSpeaker(const LLUUID& id, const std::string& name = LLStringUtil::null, const ESpeakerType type = SPEAKER_AGENT);
 	~LLSpeaker() {};
 	void lookupName();
+	void onNameCache(const LLAvatarName& avatar_name);
 
 	ESpeakerStatus	mStatus;			// current activity status in speech group
 	F32				mLastSpokeTime;		// timestamp when this speaker last spoke
@@ -92,6 +95,7 @@ public:
 	BOOL			mModeratorMutedVoice;
 	BOOL			mModeratorMutedText;
 	std::string     mLegacyName;
+	bool			mNameRequested;
 };
 
 class LLSpeakerTextModerationEvent : public LLOldEvents::LLEvent

indra/newview/llfloatermodelpreview.h

@@ -33,14 +33,14 @@
 #ifndef LL_LLFLOATERMODELPREVIEW_H
 #define LL_LLFLOATERMODELPREVIEW_H
 
-#include "llmodel.h"
-#include "llquaternion.h"
-#include "llthread.h"
 
 #include "lldynamictexture.h"
-#include "llfloatermodeluploadbase.h"
+#include "llquaternion.h"
 #include "llmeshrepository.h"
+#include "llmodel.h"
+#include "llthread.h"
 #include "llviewermenufile.h"
+#include "llfloatermodeluploadbase.h"
 
 class LLComboBox;
 class LLVOAvatar;
@@ -70,7 +70,8 @@ public:
 		GENERATING_VERTEX_BUFFERS,
 		GENERATING_LOD,
 		DONE,
-		ERROR_PARSING //basically loading failed
+		ERROR_PARSING, //basically loading failed
+		ERROR_MATERIALS,
 	} eLoadState;
 
 	U32 mState;
@@ -170,14 +171,14 @@ public:
 	BOOL handleHover(S32 x, S32 y, MASK mask);
 	BOOL handleScrollWheel(S32 x, S32 y, S32 clicks); 
 
-	/*virtual*/ void onOpen();
+	/*virtual*/ void onOpen(/*const LLSD& key*/);
 
 	static void onMouseCaptureLostModelPreview(LLMouseHandler*);
 	static void setUploadAmount(S32 amount) { sUploadAmount = amount; }
 
 	void setDetails(F32 x, F32 y, F32 z, F32 streaming_cost, F32 physics_cost);
 
-	static void onBrowseLOD(void* user_data);
+	void onBrowseLOD(S32 lod);
 
 	static void onReset(void* data);
 
@@ -186,8 +187,10 @@ public:
 	void refresh();
 
 	void			loadModel(S32 lod);
+	void			loadModel_continued(AIFilePicker* filepicker, S32 lod);
 	void 			loadModel(S32 lod, const std::string& file_name, bool force_disable_slm = false);
 
+	void onViewOptionChecked(LLUICtrl* ctrl);
 	bool isViewOptionChecked(const LLSD& userdata);
 	bool isViewOptionEnabled(const LLSD& userdata);
 	void setViewOptionEnabled(const std::string& option, bool enabled);
@@ -210,34 +213,24 @@ public:
 
 protected:
 	friend class LLModelPreview;
-	friend class LLMeshFilePicker;
 	friend class LLPhysicsDecomp;
 
-	static void	onImportScaleCommit(LLUICtrl* ctrl, void*);
-	static void	onPelvisOffsetCommit(LLUICtrl* ctrl, void*);
-	static void	onUploadJointsCommit(LLUICtrl* ctrl, void*);
-	static void	onUploadSkinCommit(LLUICtrl* ctrl, void*);
+	static void		onImportScaleCommit(LLUICtrl*, void*);
+	static void		onPelvisOffsetCommit(LLUICtrl*, void*);
+	static void		onUploadJointsCommit(LLUICtrl*,void*);
+	static void		onUploadSkinCommit(LLUICtrl*,void*);
 
-	static void	onPreviewLODCommit(LLUICtrl* ctrl, void*);
+	static void		onPreviewLODCommit(LLUICtrl*,void*);
 
-	static void	onGenerateNormalsCommit(LLUICtrl* ctrl, void*);
+	static void		onGenerateNormalsCommit(LLUICtrl*,void*);
 
-	static void toggleGenerateNormals(LLUICtrl* ctrl, void*);
+	void toggleGenerateNormals();
 
-	static void	onAutoFillCommit(LLUICtrl* ctrl, void*);
+	static void		onAutoFillCommit(LLUICtrl*,void*);
 
-	static void toggleCalculateButtonCallBack(LLUICtrl* ctrl, void* userdata);
+	void onLODParamCommit(S32 lod, bool enforce_tri_limit);
 
-	static void onClickCalculateBtn(void* userdata);
-
-	static void onLoDSourceCommit(LLUICtrl* ctrl, void* userdata);
-
-	static void onViewOptionChecked(LLUICtrl* ctrl, void* userdata);
-
-	static void onLODParamCommit(LLUICtrl* ctrl, void* userdata);
-	static void onLODParamCommitEnforceTriLimit(LLUICtrl* ctrl, void* userdata);
-
-	static void	onExplodeCommit(LLUICtrl* ctrl, void*);
+	static void		onExplodeCommit(LLUICtrl*, void*);
 
 	static void onPhysicsParamCommit(LLUICtrl* ctrl, void* userdata);
 	static void onPhysicsStageExecute(LLUICtrl* ctrl, void* userdata);
@@ -252,19 +245,18 @@ protected:
 
 	void		draw();
 
-	void		initDecompControls();
+	void initDecompControls();
 
-	void		setStatusMessage(const std::string& msg);
+	void setStatusMessage(const std::string& msg);
 
 	LLModelPreview*	mModelPreview;
 
 	LLPhysicsDecomp::decomp_params mDecompParams;
 
-	S32			mLastMouseX;
-	S32			mLastMouseY;
-	LLRect		mPreviewRect;
-	U32			mGLName;
-	static S32	sUploadAmount;
+	S32				mLastMouseX;
+	S32				mLastMouseY;
+	LLRect			mPreviewRect;
+	static S32		sUploadAmount;
 
 	std::set<LLPointer<DecompRequest> > mCurRequest;
 	std::string mStatusMessage;
@@ -283,6 +275,11 @@ protected:
 	LLSD mModelPhysicsFee;
 
 private:
+	void onClickCalculateBtn();
+	void toggleCalculateButton();
+
+	void onLoDSourceCommit(S32 lod);
+
 	// Toggles between "Calculate weights & fee" and "Upload" buttons.
 	void toggleCalculateButton(bool visible);
 
@@ -295,17 +292,6 @@ private:
 	LLButton* mCalculateBtn;
 };
 
-class LLMeshFilePicker : public LLFilePickerThread
-{
-public:
-	LLMeshFilePicker(LLModelPreview* mp, S32 lod);
-	virtual void notify(const std::string& filename);
-
-private:
-	LLModelPreview* mMP;
-	S32 mLOD;
-};
-
 class LLModelPreview : public LLViewerDynamicTexture, public LLMutex
 {
 	typedef boost::signals2::signal<void (F32 x, F32 y, F32 z, F32 streaming_cost, F32 physics_cost)> details_signal_t;

indra/newview/llfloaterregioninfo.cpp

@@ -1173,7 +1173,7 @@ BOOL LLPanelRegionTextureInfo::validateTextureSizes()
 			return FALSE;
 		}
 
-		if (width > 1024 || height > 1024)
+		if (width > 512 || height > 512)
 		{
 
 			LLSD args;

indra/newview/llinventorybackup.cpp

@@ -175,7 +175,7 @@ ESaveFilter LLInventoryBackup::getSaveFilter(LLInventoryItem* item)
 		return FFSAVE_OGG;
 	case LLAssetType::AT_SCRIPT:
 	case LLAssetType::AT_LSL_TEXT:
-		return FFSAVE_LSL;
+		return FFSAVE_SCRIPT;
 	case LLAssetType::AT_ANIMATION:
 		return FFSAVE_ANIMATN;
 	case LLAssetType::AT_GESTURE:

indra/newview/llmeshrepository.cpp

@@ -37,9 +37,6 @@
 #include "llcallbacklist.h"
 #include "lldatapacker.h"
 #include "llfasttimer.h"
-#if MESH_IMPORT
-#include "llfloatermodelpreview.h"
-#endif //MESH_IMPORT
 #include "llfloaterperms.h"
 #include "lleconomy.h"
 #include "llimagej2c.h"
@@ -65,6 +62,8 @@
 #include "llinventorymodel.h"
 #include "llfoldertype.h"
 #include "llviewerparcelmgr.h"
+#include "llassetuploadresponders.h"
+#include "lluploadfloaterobservers.h"
 #include "aicurl.h"
 
 #include "boost/lexical_cast.hpp"
@@ -321,7 +320,6 @@ public:
 	/*virtual*/ char const* getName(void) const { return "LLMeshPhysicsShapeResponder"; }
 };
 
-#if MESH_IMPORT
 void log_upload_error(S32 status, const LLSD& content, std::string stage, std::string model_name)
 {
 	// Add notification popup.
@@ -373,19 +371,24 @@ void log_upload_error(S32 status, const LLSD& content, std::string stage, std::s
 
 class LLWholeModelFeeResponder : public LLHTTPClient::ResponderWithCompleted
 {
-	LLMeshUploadThread* mThread;
+	std::string& mWholeModelUploadURL;
 	LLSD mModelData;
 	LLHandle<LLWholeModelFeeObserver> mObserverHandle;
 public:
-	LLWholeModelFeeResponder(LLMeshUploadThread* thread, LLSD& model_data, LLHandle<LLWholeModelFeeObserver> observer_handle):
-		mThread(thread),
+	LLWholeModelFeeResponder(LLSD& model_data, LLHandle<LLWholeModelFeeObserver> observer_handle, std::string& url_out):
+		mWholeModelUploadURL(url_out),
 		mModelData(model_data),
 		mObserverHandle(observer_handle)
 	{
 	}
+
+	~LLWholeModelFeeResponder()
+	{
+	}
+
 	/*virtual*/ void completed(U32 status,
-						   const std::string& reason,
-						   const LLSD& content)
+							   const std::string& reason,
+							   const LLSD& content)
 	{
 		LLSD cc = content;
 		if (gSavedSettings.getS32("MeshUploadFakeErrors")&1)
@@ -393,27 +396,26 @@ public:
 			cc = llsd_from_file("fake_upload_error.xml");
 		}
 			
-		mThread->mPendingUploads--;
 		dump_llsd_to_file(cc,make_dump_name("whole_model_fee_response_",dump_num));
 
 		LLWholeModelFeeObserver* observer = mObserverHandle.get();
 
-		if (isGoodStatus(status) &&
+		if (((200 <= status) && (status < 300)) &&
 			cc["state"].asString() == "upload")
 		{
-			mThread->mWholeModelUploadURL = cc["uploader"].asString();
+			mWholeModelUploadURL = cc["uploader"].asString();
 
 			if (observer)
 			{
 				cc["data"]["upload_price"] = cc["upload_price"];
-				observer->onModelPhysicsFeeReceived(cc["data"], mThread->mWholeModelUploadURL);
+				observer->onModelPhysicsFeeReceived(cc["data"], mWholeModelUploadURL);
 			}
 		}
 		else
 		{
 			llwarns << "fee request failed" << llendl;
 			log_upload_error(status,cc,"fee",mModelData["name"]);
-			mThread->mWholeModelUploadURL = "";
+			mWholeModelUploadURL = "";
 
 			if (observer)
 			{
@@ -428,20 +430,23 @@ public:
 
 class LLWholeModelUploadResponder : public LLHTTPClient::ResponderWithCompleted
 {
-	LLMeshUploadThread* mThread;
 	LLSD mModelData;
 	LLHandle<LLWholeModelUploadObserver> mObserverHandle;
 	
 public:
-	LLWholeModelUploadResponder(LLMeshUploadThread* thread, LLSD& model_data, LLHandle<LLWholeModelUploadObserver> observer_handle):
-		mThread(thread),
+	LLWholeModelUploadResponder(LLSD& model_data, LLHandle<LLWholeModelUploadObserver> observer_handle):
 		mModelData(model_data),
 		mObserverHandle(observer_handle)
 	{
 	}
+
+	~LLWholeModelUploadResponder()
+	{
+	}
+
 	/*virtual*/ void completed(U32 status,
-						   const std::string& reason,
-						   const LLSD& content)
+							   const std::string& reason,
+							   const LLSD& content)
 	{
 		LLSD cc = content;
 		if (gSavedSettings.getS32("MeshUploadFakeErrors")&2)
@@ -449,15 +454,13 @@ public:
 			cc = llsd_from_file("fake_upload_error.xml");
 		}
 
-		//assert_main_thread();
-		mThread->mPendingUploads--;
 		dump_llsd_to_file(cc,make_dump_name("whole_model_upload_response_",dump_num));
 		
 		LLWholeModelUploadObserver* observer = mObserverHandle.get();
 
 		// requested "mesh" asset type isn't actually the type
 		// of the resultant object, fix it up here.
-		if (isGoodStatus(status) &&
+		if (((200 <= status) && (status < 300)) &&
 			cc["state"].asString() == "complete")
 		{
 			mModelData["asset_type"] = "object";
@@ -484,7 +487,6 @@ public:
 	/*virtual*/ AIHTTPTimeoutPolicy const& getHTTPTimeoutPolicy(void) const { return wholeModelUploadResponder_timeout; }
 	/*virtual*/ char const* getName(void) const { return "LLWholeModelUploadResponder"; }
 };
-#endif //MESH_IMPORT
 
 LLMeshRepoThread::LLMeshRepoThread()
 : LLThread("mesh repo") 
@@ -506,18 +508,15 @@ LLMeshRepoThread::~LLMeshRepoThread()
 
 void LLMeshRepoThread::run()
 {
-#if MESH_IMPORT
 	LLCDResult res = LLConvexDecomposition::initThread();
 	if (res != LLCD_OK)
 	{
 		llwarns << "convex decomposition unable to be loaded" << llendl;
 	}
-#endif //MESH_IMPORT
 
 	mSignal->lock();
 	while (!LLApp::isQuitting())
 	{
-		// Left braces in order not to change the indentation.
 		{
 			static U32 count = 0;
 
@@ -653,13 +652,12 @@ void LLMeshRepoThread::run()
 	}
 	mSignal->unlock();
 
-#if MESH_IMPORT
 	res = LLConvexDecomposition::quitThread();
 	if (res != LLCD_OK)
 	{
 		llwarns << "convex decomposition unable to be quit" << llendl;
 	}
-#endif //MESH_IMPORT
+
 }
 
 void LLMeshRepoThread::loadMeshSkinInfo(const LLUUID& mesh_id)
@@ -1118,13 +1116,12 @@ bool LLMeshRepoThread::headerReceived(const LLVolumeParams& mesh_params, U8* dat
 		}
 
 
-		LLMutexLock lock(mMutex); // <FS:ND/> FIRE-7182, make sure only one thread access mPendingLOD at the same time.
+		LLMutexLock lock(mMutex); // make sure only one thread access mPendingLOD at the same time.
 
 		//check for pending requests
 		pending_lod_map::iterator iter = mPendingLOD.find(mesh_params);
 		if (iter != mPendingLOD.end())
 		{
-			//			LLMutexLock lock(mMutex); <FS:ND/> FIRE-7182, lock was moved up, before calling mPendingLOD.find
 			for (U32 i = 0; i < iter->second.size(); ++i)
 			{
 				LODRequest req(mesh_params, iter->second[i]);
@@ -1273,23 +1270,17 @@ bool LLMeshRepoThread::physicsShapeReceived(const LLUUID& mesh_id, U8* data, S32
 	return true;
 }
 
-#if MESH_IMPORT
-LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data, LLVector3& scale, bool upload_textures,
-										bool upload_skin, bool upload_joints, std::string upload_url, bool do_upload,
-					   LLHandle<LLWholeModelFeeObserver> fee_observer, LLHandle<LLWholeModelUploadObserver> upload_observer)
-: LLThread("mesh upload"),
-	mDiscarded(FALSE),
-	mDoUpload(do_upload),
-	mWholeModelUploadURL(upload_url),
-	mFeeObserverHandle(fee_observer),
-	mUploadObserverHandle(upload_observer)
+void LLMeshUploadThread::init(LLMeshUploadThread::instance_list& data, LLVector3& scale, bool upload_textures,
+							  bool upload_skin, bool upload_joints, bool do_upload,
+							  LLHandle<LLWholeModelFeeObserver> const& fee_observer, LLHandle<LLWholeModelUploadObserver> const& upload_observer)
 {
+	mDoUpload = do_upload;
+	mFeeObserverHandle = fee_observer;
+	mUploadObserverHandle = upload_observer;
 	mInstanceList = data;
 	mUploadTextures = upload_textures;
 	mUploadSkin = upload_skin;
 	mUploadJoints = upload_joints;
-	mMutex = new LLMutex();
-	mPendingUploads = 0;
 	mOrigin = gAgent.getPositionAgent();
 	mHost = gAgent.getRegionHost();
 	
@@ -1300,11 +1291,6 @@ LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data,
 	mMeshUploadTimeOut = gSavedSettings.getS32("MeshUploadTimeOut") ;
 }
 
-LLMeshUploadThread::~LLMeshUploadThread()
-{
-
-}
-
 LLMeshUploadThread::DecompRequest::DecompRequest(LLModel* mdl, LLModel* base_model, LLMeshUploadThread* thread)
 {
 	mStage = "single_hull";
@@ -1342,30 +1328,87 @@ void LLMeshUploadThread::preStart()
 	}
 }
 
-void LLMeshUploadThread::discard()
+AIMeshUpload::AIMeshUpload(LLMeshUploadThread::instance_list& data, LLVector3& scale, bool upload_textures, bool upload_skin, bool upload_joints, std::string const& upload_url, bool do_upload,
+	LLHandle<LLWholeModelFeeObserver> const& fee_observer, LLHandle<LLWholeModelUploadObserver> const& upload_observer) : mWholeModelUploadURL(upload_url)
 {
-	LLMutexLock lock(mMutex) ;
-	mDiscarded = TRUE ;
+	mMeshUpload->init(data, scale, upload_textures, upload_skin, upload_joints, do_upload, fee_observer, upload_observer);
 }
 
-BOOL LLMeshUploadThread::isDiscarded()
+char const* AIMeshUpload::state_str_impl(state_type run_state) const
 {
-	LLMutexLock lock(mMutex) ;
-	return mDiscarded ;
-}
-
-void LLMeshUploadThread::run()
-{
-	if (mDoUpload)
+	switch (run_state)
 	{
-		doWholeModelUpload();
+		AI_CASE_RETURN(AIMeshUpload_start);
+		AI_CASE_RETURN(AIMeshUpload_threadFinished);
+		AI_CASE_RETURN(AIMeshUpload_responderFinished);
+	}
+	return "UNKNOWN STATE";
+}
+
+void AIMeshUpload::initialize_impl()
+{
+	mMeshUpload->preStart();
+	set_state(AIMeshUpload_start);
+}
+
+void AIMeshUpload::multiplex_impl()
+{
+	switch (mRunState)
+	{
+		case AIMeshUpload_start:
+			mMeshUpload.run(this, AIMeshUpload_threadFinished);
+			idle(AIMeshUpload_start);					// Wait till the thread finished.
+			break;
+		case AIMeshUpload_threadFinished:
+			mMeshUpload->postRequest(mWholeModelUploadURL, this);
+			idle(AIMeshUpload_threadFinished);			// Wait till the responder finished.
+			break;
+		case AIMeshUpload_responderFinished:
+			finish();
+			break;
+	}
+}
+
+bool LLMeshUploadThread::run()
+{
+	generateHulls();
+	wholeModelToLLSD(mModelData, mDoUpload);
+	if (!mDoUpload)
+	{
+		++dump_num;
+		dump_llsd_to_file(mModelData, make_dump_name("whole_model_fee_request_", dump_num));
 	}
 	else
 	{
-		requestWholeModelFee();
+		mBody = mModelData["asset_resources"];
+		dump_llsd_to_file(mBody, make_dump_name("whole_model_body_", dump_num));
+	}
+	return true;          // true = finish, false = abort.
+}
+
+void LLMeshUploadThread::postRequest(std::string& whole_model_upload_url, AIMeshUpload* state_machine)
+{
+	if (!mDoUpload)
+	{
+		LLHTTPClient::post(mWholeModelFeeCapability, mModelData,
+			new LLWholeModelFeeResponder(mModelData, mFeeObserverHandle, whole_model_upload_url)/*,*/
+			DEBUG_CURLIO_PARAM(debug_on), keep_alive, state_machine, AIMeshUpload_responderFinished);
+	}
+	else
+	{
+		LLHTTPClient::post(whole_model_upload_url, mBody,
+			new LLWholeModelUploadResponder(mModelData, mUploadObserverHandle)/*,*/
+			DEBUG_CURLIO_PARAM(debug_off), keep_alive, state_machine, AIMeshUpload_responderFinished);
 	}
 }
-#endif //MESH_IMPORT
+
+void AIMeshUpload::abort_impl()
+{
+}
+
+void AIMeshUpload::finish_impl()
+{
+}
 
 void dump_llsd_to_file(const LLSD& content, std::string filename)
 {
@@ -1384,7 +1427,6 @@ LLSD llsd_from_file(std::string filename)
 	return result;
 }
 
-#if MESH_IMPORT
 void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, bool include_textures)
 {
 	LLSD result;
@@ -1440,22 +1482,22 @@ void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, bool include_textures)
 			std::stringstream ostr;
 			
 			LLModel::Decomposition& decomp =
-			data.mModel[LLModel::LOD_PHYSICS].notNull() ? 
-			data.mModel[LLModel::LOD_PHYSICS]->mPhysics : 
-			data.mBaseModel->mPhysics;
+				data.mModel[LLModel::LOD_PHYSICS].notNull() ? 
+				data.mModel[LLModel::LOD_PHYSICS]->mPhysics : 
+				data.mBaseModel->mPhysics;
 
-		decomp.mBaseHull = mHullMap[data.mBaseModel];
+			decomp.mBaseHull = mHullMap[data.mBaseModel];
 
-		LLSD mesh_header = LLModel::writeModel(
-			ostr,  
-			data.mModel[LLModel::LOD_PHYSICS],
-			data.mModel[LLModel::LOD_HIGH],
-			data.mModel[LLModel::LOD_MEDIUM],
-			data.mModel[LLModel::LOD_LOW],
-			data.mModel[LLModel::LOD_IMPOSTOR], 
-			decomp,
-			mUploadSkin,
-			mUploadJoints);
+			LLSD mesh_header = LLModel::writeModel(
+				ostr,  
+				data.mModel[LLModel::LOD_PHYSICS],
+				data.mModel[LLModel::LOD_HIGH],
+				data.mModel[LLModel::LOD_MEDIUM],
+				data.mModel[LLModel::LOD_LOW],
+				data.mModel[LLModel::LOD_IMPOSTOR], 
+				decomp,
+				mUploadSkin,
+				mUploadJoints);
 
 			data.mAssetData = ostr.str();
 			std::string str = ostr.str();
@@ -1595,7 +1637,7 @@ void LLMeshUploadThread::generateHulls()
 		}
 
 		llassert(physics != NULL);
-		
+
 		DecompRequest* request = new DecompRequest(physics, data.mBaseModel, this);
 		if(request->isValid())
 		{
@@ -1613,42 +1655,6 @@ void LLMeshUploadThread::generateHulls()
 	}	
 }
 
-void LLMeshUploadThread::doWholeModelUpload()
-{
-	if (mWholeModelUploadURL.empty())
-	{
-		llinfos << "unable to upload, fee request failed" << llendl;
-	}
-	else
-	{
-		generateHulls();
-
-		LLSD full_model_data;
-		wholeModelToLLSD(full_model_data, true);
-		LLSD body = full_model_data["asset_resources"];
-		dump_llsd_to_file(body,make_dump_name("whole_model_body_",dump_num));
-		LLHTTPClient::post(mWholeModelUploadURL, body,
-						   new LLWholeModelUploadResponder(this, full_model_data, mUploadObserverHandle));
-	}
-}
-
-void LLMeshUploadThread::requestWholeModelFee()
-{
-	dump_num++;
-
-	generateHulls();
-
-	LLSD model_data;
-	wholeModelToLLSD(model_data,false);
-	dump_llsd_to_file(model_data,make_dump_name("whole_model_fee_request_",dump_num));
-
-	mPendingUploads++;
-	// This might throw AICurlNoEasyHandle.
-	LLHTTPClient::post(mWholeModelFeeCapability, model_data,
-					   new LLWholeModelFeeResponder(this, model_data, mFeeObserverHandle));
-}
-#endif //MESH_IMPORT
-
 void LLMeshRepoThread::notifyLoadedMeshes()
 {//called via gMeshRepo.notifyLoadedMeshes(). mMutex already locked
 	while (!mLoadedQ.empty())
@@ -1665,7 +1671,7 @@ void LLMeshRepoThread::notifyLoadedMeshes()
 		else
 		{
 			gMeshRepo.notifyMeshUnavailable(mesh.mMeshParams, 
-											LLVolumeLODGroup::getVolumeDetailFromScale(mesh.mVolume->getDetail()));
+				LLVolumeLODGroup::getVolumeDetailFromScale(mesh.mVolume->getDetail()));
 		}
 	}
 
@@ -1747,7 +1753,6 @@ S32 LLMeshRepository::getActualMeshLOD(LLSD& header, S32 lod)
 	return -1;
 }
 
-#if MESH_IMPORT
 void LLMeshRepository::cacheOutgoingMesh(LLMeshUploadData& data, LLSD& header)
 {
 	mThread->mMeshHeader[data.mUUID] = header;
@@ -1768,7 +1773,6 @@ void LLMeshRepository::cacheOutgoingMesh(LLMeshUploadData& data, LLSD& header)
 	}
 
 }
-#endif //MESH_IMPORT
 
 void LLMeshLODResponder::completedRaw(U32 status, const std::string& reason,
 							  const LLChannelDescriptors& channels,
@@ -2106,9 +2110,7 @@ void LLMeshRepository::init()
 {
 	mMeshMutex = new LLMutex();
 	
-#if MESH_IMPORT
 	LLConvexDecomposition::getInstance()->initSystem();
-#endif //MESH_IMPORT
 
 	mDecompThread = new LLPhysicsDecomp();
 	mDecompThread->start();
@@ -2128,14 +2130,6 @@ void LLMeshRepository::shutdown()
 {
 	llinfos << "Shutting down mesh repository." << llendl;
 
-#if MESH_IMPORT
-	for (U32 i = 0; i < mUploads.size(); ++i)
-	{
-		llinfos << "Discard the pending mesh uploads " << llendl;
-		mUploads[i]->discard() ; //discard the uploading requests.
-	}
-#endif //MESH_IMPORT
-
 	mThread->mSignal->signal();
 	
 	while (!mThread->isStopped())
@@ -2145,20 +2139,6 @@ void LLMeshRepository::shutdown()
 	delete mThread;
 	mThread = NULL;
 
-#if MESH_IMPORT
-	for (U32 i = 0; i < mUploads.size(); ++i)
-	{
-		llinfos << "Waiting for pending mesh upload " << i << "/" << mUploads.size() << llendl;
-		while (!mUploads[i]->isStopped())
-		{
-			apr_sleep(10);
-		}
-		delete mUploads[i];
-	}
-
-	mUploads.clear();
-#endif //MESH_IMPORT
-
 	delete mMeshMutex;
 	mMeshMutex = NULL;
 
@@ -2171,31 +2151,7 @@ void LLMeshRepository::shutdown()
 		mDecompThread = NULL;
 	}
 
-#if MESH_IMPORT
 	LLConvexDecomposition::quitSystem();
-#endif //MESH_IMPORT
-}
-
-//called in the main thread.
-S32 LLMeshRepository::update()
-{
-	S32 size = 0;
-#if MESH_IMPORT
-	if(mUploadWaitList.empty())
-	{
-		return 0 ;
-	}
-
-	size = mUploadWaitList.size() ;
-	for (S32 i = 0; i < size; ++i)
-	{
-		mUploads.push_back(mUploadWaitList[i]);
-		mUploadWaitList[i]->preStart() ;
-		mUploadWaitList[i]->start() ;
-	}
-	mUploadWaitList.clear() ;
-#endif //MESH_IMPORT
-	return size ;
 }
 
 S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_params, S32 detail, S32 last_lod)
@@ -2281,23 +2237,6 @@ void LLMeshRepository::notifyLoadedMeshes()
 	static const LLCachedControl<U32> max_concurrent_requests("MeshMaxConcurrentRequests");
 	LLMeshRepoThread::sMaxConcurrentRequests = max_concurrent_requests;
 
-#if MESH_IMPORT
-	//clean up completed upload threads
-	for (std::vector<LLMeshUploadThread*>::iterator iter = mUploads.begin(); iter != mUploads.end(); )
-	{
-		LLMeshUploadThread* thread = *iter;
-
-		if (thread->isStopped() && thread->finished())
-		{
-			iter = mUploads.erase(iter);
-			delete thread;
-		}
-		else
-		{
-			++iter;
-		}
-	}
-
 	//update inventory
 	if (!mInventoryQ.empty())
 	{
@@ -2354,7 +2293,7 @@ void LLMeshRepository::notifyLoadedMeshes()
 			
 			mInventoryQ.pop();
 		}
-#endif //MESH_IMPORT
+	}
 
 	//call completed callbacks on finished decompositions
 	mDecompThread->notifyCompleted();
@@ -2717,16 +2656,19 @@ LLSD& LLMeshRepoThread::getMeshHeader(const LLUUID& mesh_id)
 	return dummy_ret;
 }
 
-#if MESH_IMPORT
+
 void LLMeshRepository::uploadModel(std::vector<LLModelInstance>& data, LLVector3& scale, bool upload_textures,
 									bool upload_skin, bool upload_joints, std::string upload_url, bool do_upload,
 								   LLHandle<LLWholeModelFeeObserver> fee_observer, LLHandle<LLWholeModelUploadObserver> upload_observer)
 {
-	LLMeshUploadThread* thread = new LLMeshUploadThread(data, scale, upload_textures, upload_skin, upload_joints, upload_url, 
-														do_upload, fee_observer, upload_observer);
-	mUploadWaitList.push_back(thread);
+	if (do_upload && upload_url.empty())
+	{
+		llinfos << "unable to upload, fee request failed" << llendl;
+		return;
+	}
+	AIMeshUpload* uploader = new AIMeshUpload(data, scale, upload_textures, upload_skin, upload_joints, upload_url, do_upload, fee_observer, upload_observer);
+	uploader->run();
 }
-#endif //MESH_IMPORT
 
 S32 LLMeshRepository::getMeshSize(const LLUUID& mesh_id, S32 lod)
 {
@@ -2752,8 +2694,6 @@ S32 LLMeshRepository::getMeshSize(const LLUUID& mesh_id, S32 lod)
 
 }
 
-#if MESH_IMPORT
-
 void LLMeshUploadThread::decomposeMeshMatrix(LLMatrix4& transformation,
 											 LLVector3& result_pos,
 											 LLQuaternion& result_rot,
@@ -2794,8 +2734,6 @@ void LLMeshUploadThread::decomposeMeshMatrix(LLMatrix4& transformation,
 	result_rot = quat_rotation; 
 }
 
-#endif //MESH_IMPORT
-
 bool LLImportMaterial::operator<(const LLImportMaterial &rhs) const
 {
 	if (mDiffuseMap != rhs.mDiffuseMap)
@@ -2998,8 +2936,41 @@ S32 LLPhysicsDecomp::llcdCallback(const char* status, S32 p1, S32 p2)
 	return 1;
 }
 
+bool needTriangles( LLConvexDecomposition *aDC )
+{
+	if( !aDC )
+		return false;
+
+	LLCDParam const  *pParams(0);
+	int nParams = aDC->getParameters( &pParams );
+
+	if( nParams <= 0 )
+		return false;
+
+	for( int i = 0; i < nParams; ++i )
+	{
+		if( pParams[i].mName && strcmp( "nd_AlwaysNeedTriangles", pParams[i].mName ) == 0 )
+		{
+			if( LLCDParam::LLCD_BOOLEAN == pParams[i].mType && pParams[i].mDefault.mBool )
+				return true;
+			else
+				return false;
+		}
+	}
+
+	return false;
+}
+
 void LLPhysicsDecomp::setMeshData(LLCDMeshData& mesh, bool vertex_based)
 {
+	LLConvexDecomposition *pDeComp = LLConvexDecomposition::getInstance();
+
+	if( !pDeComp )
+		return;
+
+	if( vertex_based )
+		vertex_based = !needTriangles( pDeComp );
+
 	mesh.mVertexBase = mCurRequest->mPositions[0].mV;
 	mesh.mVertexStrideBytes = 12;
 	mesh.mNumVertices = mCurRequest->mPositions.size();
@@ -3013,26 +2984,20 @@ void LLPhysicsDecomp::setMeshData(LLCDMeshData& mesh, bool vertex_based)
 		mesh.mNumTriangles = mCurRequest->mIndices.size()/3;
 	}
 
-#if MESH_IMPORT
 	if ((vertex_based || mesh.mNumTriangles > 0) && mesh.mNumVertices > 2)
 	{
 		LLCDResult ret = LLCD_OK;
-		if (LLConvexDecomposition::getInstance() != NULL)
-		{
-			ret  = LLConvexDecomposition::getInstance()->setMeshData(&mesh, vertex_based);
-		}
+		ret  = LLConvexDecomposition::getInstance()->setMeshData(&mesh, vertex_based);
 
 		if (ret)
 		{
 			llerrs << "Convex Decomposition thread valid but could not set mesh data" << llendl;
 		}
 	}
-#endif //MESH_IMPORT
 }
 
 void LLPhysicsDecomp::doDecomposition()
 {
-#if MESH_IMPORT
 	LLCDMeshData mesh;
 	S32 stage = mStageID[mCurRequest->mStage];
 
@@ -3167,7 +3132,6 @@ void LLPhysicsDecomp::doDecomposition()
 			completeCurrent();						
 		}
 	}
-#endif //MESH_IMPORT
 }
 
 void LLPhysicsDecomp::completeCurrent()
@@ -3221,10 +3185,6 @@ void make_box(LLPhysicsDecomp::Request * request)
 
 void LLPhysicsDecomp::doDecompositionSingleHull()
 {
-#if !MESH_IMPORT
-	return;
-#endif //!MESH_IMPORT	
-#if MESH_IMPORT
 	LLConvexDecomposition* decomp = LLConvexDecomposition::getInstance();
 
 	if (decomp == NULL)
@@ -3245,11 +3205,12 @@ void LLPhysicsDecomp::doDecompositionSingleHull()
 	}
 	else
 	{
-		mMutex->lock();
-		mCurRequest->mHull.clear();
-		mCurRequest->mHull.resize(1);
-		mCurRequest->mHullMesh.clear();
-		mMutex->unlock();
+		{
+			LLMutexLock lock(mMutex);
+			mCurRequest->mHull.clear();
+			mCurRequest->mHull.resize(1);
+			mCurRequest->mHullMesh.clear();
+		}
 
 		std::vector<LLVector3> p;
 		LLCDHull hull;
@@ -3265,26 +3226,75 @@ void LLPhysicsDecomp::doDecompositionSingleHull()
 			p.push_back(vert);
 			v = (F32*) (((U8*) v) + hull.mVertexStrideBytes);
 		}
-						
-		mMutex->lock();
-		mCurRequest->mHull[0] = p;
-		mMutex->unlock();	
+
+		{
+			LLMutexLock lock(mMutex);
+			mCurRequest->mHull[0] = p;
+		}
 	}		
 
 	{
 		completeCurrent();
 		
 	}
-#endif //MESH_IMPORT
 }
 
+#ifdef ND_HASCONVEXDECOMP_TRACER
+
+class ndDecompTracer: public ndConvexDecompositionTracer
+{
+	int mRefCount;
+
+public:
+	ndDecompTracer()
+		: mRefCount(0)
+	{
+	}
+
+	virtual ~ndDecompTracer() { }
+
+	virtual void trace( char const *a_strMsg )
+	{
+		llinfos << a_strMsg << llendl;
+	}
+
+	virtual void startTraceData( char const *a_strWhat)
+	{
+		llinfos << a_strWhat << llendl;
+	}
+
+	virtual void traceData( char const *a_strData )
+	{
+		llinfos << a_strData << llendl;
+	}
+
+	virtual void endTraceData()
+	{
+
+	}
+
+	virtual int getLevel()
+	{
+		return eTraceFunctions;// | eTraceData;
+	}
+
+	virtual void addref()
+	{
+		++mRefCount;
+	}
+
+	virtual void release()
+	{
+		--mRefCount;
+		if( mRefCount == 0 )
+			delete this;
+	}
+};
+
+#endif
 
 void LLPhysicsDecomp::run()
 {
-#if !MESH_IMPORT
-	mInited = true;
-#endif //!MESH_IMPORT
-#if MESH_IMPORT
 	LLConvexDecomposition* decomp = LLConvexDecomposition::getInstance();
 	if (decomp == NULL)
 	{
@@ -3294,6 +3304,13 @@ void LLPhysicsDecomp::run()
 		return;
 	}
 
+#ifdef ND_HASCONVEXDECOMP_TRACER
+	ndConvexDecompositionTracable *pTraceable = dynamic_cast< ndConvexDecompositionTracable* >( decomp );
+
+	if( pTraceable )
+		pTraceable->setTracer( new ndDecompTracer() );
+#endif
+
 	decomp->initThread();
 	mInited = true;
 
@@ -3311,6 +3328,7 @@ void LLPhysicsDecomp::run()
 	}
 
 	mSignal->lock();
+
 	while (!mQuitting)
 	{
 		mSignal->wait();
@@ -3339,14 +3357,14 @@ void LLPhysicsDecomp::run()
 			}		
 		}
 	}
+
 	mSignal->unlock();
 
 	decomp->quitThread();
 	
-	mDone = true;
-#endif //MESH_IMPORT
-}
 
+	mDone = true;
+}
 
 void LLPhysicsDecomp::Request::assignData(LLModel* mdl) 
 {
@@ -3493,7 +3511,6 @@ void LLMeshRepository::buildPhysicsMesh(LLModel::Decomposition& decomp)
 		hull.mVertexBase = decomp.mHull[i][0].mV;
 		hull.mVertexStrideBytes = 12;
 
-#if MESH_IMPORT
 		LLCDMeshData mesh;
 		LLCDResult res = LLCD_OK;
 		if (LLConvexDecomposition::getInstance() != NULL)
@@ -3504,7 +3521,6 @@ void LLMeshRepository::buildPhysicsMesh(LLModel::Decomposition& decomp)
 		{
 			get_vertex_buffer_from_mesh(mesh, decomp.mMesh[i]);
 		}
-#endif //MESH_IMPORT
 	}
 
 	if (!decomp.mBaseHull.empty() && decomp.mBaseHullMesh.empty())
@@ -3514,7 +3530,6 @@ void LLMeshRepository::buildPhysicsMesh(LLModel::Decomposition& decomp)
 		hull.mVertexBase = decomp.mBaseHull[0].mV;
 		hull.mVertexStrideBytes = 12;
 
-#if MESH_IMPORT
 		LLCDMeshData mesh;
 		LLCDResult res = LLCD_OK;
 		if (LLConvexDecomposition::getInstance() != NULL)
@@ -3525,7 +3540,6 @@ void LLMeshRepository::buildPhysicsMesh(LLModel::Decomposition& decomp)
 		{
 			get_vertex_buffer_from_mesh(mesh, decomp.mBaseHullMesh);
 		}
-#endif //MESH_IMPORT
 	}
 }
 

indra/newview/llmeshrepository.h

@@ -33,37 +33,11 @@
 #include "llviewertexture.h"
 #include "llvolume.h"
 
-#if MESH_IMPORT
 #define LLCONVEXDECOMPINTER_STATIC 1
 
-#include "llconvexdecomposition.h"
-#endif //MESH_IMPORT
-
-#if !MESH_IMPORT
-//Placeholder structs from LLConvexDecomposition.h:
-struct LLCDMeshData
-{
-        enum IndexType 
-        {
-                INT_16,
-                INT_32
-        };
-
-        const float*    mVertexBase;
-        int                             mVertexStrideBytes;
-        int                             mNumVertices;
-        const void*             mIndexBase;
-        IndexType               mIndexType;
-        int                             mIndexStrideBytes;
-        int                             mNumTriangles;
-};
-struct LLCDHull
-{
-        const float*    mVertexBase;
-        int                             mVertexStrideBytes;
-        int                             mNumVertices;
-};
-#endif //!MESH_IMPORT
+#include "LLConvexDecomposition.h"
+#include "lluploadfloaterobservers.h"
+#include "aistatemachinethread.h"
 
 class LLVOVolume;
 class LLMeshResponder;
@@ -71,6 +45,7 @@ class LLMutex;
 class LLCondition;
 class LLVFS;
 class LLMeshRepository;
+class AIMeshUpload;
 
 class LLMeshUploadData
 {
@@ -245,8 +220,8 @@ public:
 	static S32 sActiveLODRequests;
 	static U32 sMaxConcurrentRequests;
 
-	LLMutex*		mMutex;
-	LLMutex*		mHeaderMutex;
+	LLMutex*	mMutex;
+	LLMutex*	mHeaderMutex;
 	LLCondition*	mSignal;
 
 	//map of known mesh headers
@@ -377,8 +352,7 @@ public:
 
 };
 
-#if MESH_IMPORT
-class LLMeshUploadThread : public LLThread 
+class LLMeshUploadThread : public AIThreadImpl
 {
 private:
 	S32 mMeshUploadTimeOut ; //maximum time in seconds to execute an uploading request.
@@ -400,6 +374,8 @@ public:
 
 	LLPointer<DecompRequest> mFinalDecomp;
 	bool mPhysicsComplete;
+	LLSD mModelData;
+	LLSD mBody;
 
 	typedef std::map<LLPointer<LLModel>, std::vector<LLVector3> > hull_map;
 	hull_map mHullMap;
@@ -410,33 +386,27 @@ public:
 	typedef std::map<LLPointer<LLModel>, instance_list> instance_map;
 	instance_map mInstance;
 
-	LLMutex*					mMutex;
-	S32				mPendingUploads;
 	LLVector3		mOrigin;
 	bool			mUploadTextures;
 	bool			mUploadSkin;
 	bool			mUploadJoints;
-	BOOL            mDiscarded ;
 
 	LLHost			mHost;
 	std::string		mWholeModelFeeCapability;
-	std::string		mWholeModelUploadURL;
 
-	LLMeshUploadThread(instance_list& data, LLVector3& scale, bool upload_textures,
-			bool upload_skin, bool upload_joints, std::string upload_url, bool do_upload = true,
-					   LLHandle<LLWholeModelFeeObserver> fee_observer= (LLHandle<LLWholeModelFeeObserver>()), LLHandle<LLWholeModelUploadObserver> upload_observer = (LLHandle<LLWholeModelUploadObserver>()));
-	~LLMeshUploadThread();
+#ifdef LL_DEBUG
+	LLMeshUploadThread(void) : AIThreadImpl("mesh upload") { }
+#endif
+	void init(instance_list& data, LLVector3& scale, bool upload_textures, bool upload_skin, bool upload_joints, bool do_upload,
+		LLHandle<LLWholeModelFeeObserver> const& fee_observer, LLHandle<LLWholeModelUploadObserver> const& upload_observer);
 
-	virtual void run();
+	void postRequest(std::string& url, AIMeshUpload* state_machine);
+
+	/*virtual*/ bool run();
 	void preStart();
-	void discard() ;
-	BOOL isDiscarded();
 
 	void generateHulls();
 
-	void doWholeModelUpload();
-	void requestWholeModelFee();
-
 	void wholeModelToLLSD(LLSD& dest, bool include_textures);
 
 	void decomposeMeshMatrix(LLMatrix4& transformation,
@@ -453,7 +423,34 @@ private:
 
 	bool mDoUpload; // if FALSE only model data will be requested, otherwise the model will be uploaded
 };
-#endif //MESH_IMPORT
+
+enum AIMeshUpload_state_type {
+	AIMeshUpload_start = AIStateMachine::max_state,
+	AIMeshUpload_threadFinished,
+	AIMeshUpload_responderFinished
+};
+
+class AIMeshUpload : public AIStateMachine
+{
+private:
+	AIStateMachineThread<LLMeshUploadThread> mMeshUpload;
+	std::string mWholeModelUploadURL;
+
+public:
+	AIMeshUpload(LLMeshUploadThread::instance_list& data, LLVector3& scale,
+		bool upload_textures, bool upload_skin, bool upload_joints, std::string const& upload_url, bool do_upload,
+		LLHandle<LLWholeModelFeeObserver> const& fee_observer, LLHandle<LLWholeModelUploadObserver> const& upload_observer);
+
+	void setWholeModelUploadURL(std::string const& whole_model_upload_url) { mWholeModelUploadURL = whole_model_upload_url; }
+
+protected:
+	// Implement AIStateMachine.
+	/*virtual*/ const char* state_str_impl(state_type) const;
+	/*virtual*/ void initialize_impl();
+	/*virtual*/ void multiplex_impl();
+	/*virtual*/ void abort_impl();
+	/*virtual*/ void finish_impl();
+};
 
 class LLMeshRepository
 {
@@ -475,7 +472,6 @@ public:
 
 	void init();
 	void shutdown();
-	S32 update() ;
 
 	//mesh management functions
 	S32 loadMesh(LLVOVolume* volume, const LLVolumeParams& mesh_params, S32 detail = 0, S32 last_lod = -1);
@@ -502,11 +498,10 @@ public:
 
 	LLSD& getMeshHeader(const LLUUID& mesh_id);
 
-#if MESH_IMPORT
 	void uploadModel(std::vector<LLModelInstance>& data, LLVector3& scale, bool upload_textures,
-			bool upload_skin, bool upload_joints, std::string upload_url, bool do_upload = true,
-					 LLHandle<LLWholeModelFeeObserver> fee_observer= (LLHandle<LLWholeModelFeeObserver>()), LLHandle<LLWholeModelUploadObserver> upload_observer = (LLHandle<LLWholeModelUploadObserver>()));
-#endif //MESH_IMPORT
+					 bool upload_skin, bool upload_joints, std::string upload_url, bool do_upload = true,
+					 LLHandle<LLWholeModelFeeObserver> fee_observer= (LLHandle<LLWholeModelFeeObserver>()),
+					 LLHandle<LLWholeModelUploadObserver> upload_observer = (LLHandle<LLWholeModelUploadObserver>()));
 
 	S32 getMeshSize(const LLUUID& mesh_id, S32 lod);
 
@@ -544,15 +539,9 @@ public:
 	
 	U32 mMeshThreadCount;
 
-#if MESH_IMPORT
 	void cacheOutgoingMesh(LLMeshUploadData& data, LLSD& header);
-#endif //MESH_IMPORT
 
 	LLMeshRepoThread* mThread;
-#if MESH_IMPORT
-	std::vector<LLMeshUploadThread*> mUploads;
-	std::vector<LLMeshUploadThread*> mUploadWaitList;
-#endif //MESH_IMPORT
 
 	LLPhysicsDecomp* mDecompThread;
 	

indra/newview/llpanelprofile.h

@@ -47,7 +47,8 @@ class LLPanelProfile : public LLPanel
 public:
 	/*virtual*/ BOOL postBuild();
 	/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
-	/*virtual*/ void onOpen();
+
+	void onOpen(const LLSD& key);
 
 	virtual void openPanel(LLPanel* panel, const LLSD& params);
 

indra/newview/llpreviewscript.cpp

@@ -1799,7 +1799,7 @@ void LLPreviewLSL::saveAs()
 	}
 
 	AIFilePicker* filepicker = AIFilePicker::create();
-	filepicker->open(default_filename, FFSAVE_LSL);
+	filepicker->open(default_filename, FFSAVE_SCRIPT);
 	filepicker->run(boost::bind(&LLPreviewLSL::saveAs_continued, this, filepicker));
 }
 
@@ -2756,7 +2756,7 @@ void LLLiveLSLEditor::saveAs()
 	}
 
 	AIFilePicker* filepicker = AIFilePicker::create();
-	filepicker->open(default_filename, FFSAVE_LSL);
+	filepicker->open(default_filename, FFSAVE_SCRIPT);
 	filepicker->run(boost::bind(&LLLiveLSLEditor::saveAs_continued, this, filepicker));
 }
 

indra/newview/lltoolcomp.cpp

@@ -491,7 +491,7 @@ BOOL LLToolCompCreate::handleMouseDown(S32 x, S32 y, MASK mask)
 	
 	mObjectPlacedOnMouseDown = TRUE;
 
-	return TRUE;
+	return handled;
 }
 
 void LLToolCompCreate::pickCallback(const LLPickInfo& pick_info)

indra/newview/llviewermenufile.cpp

@@ -40,9 +40,7 @@
 #include "statemachine/aifilepicker.h"
 #include "llfloateranimpreview.h"
 #include "llfloaterimagepreview.h"
-#ifdef MESH_UPLOAD
 #include "llfloatermodelpreview.h"
-#endif
 #include "llfloaternamedesc.h"
 #include "llfloatersnapshot.h"
 #include "llimage.h"
@@ -122,6 +120,14 @@ class LLFileEnableUpload : public view_listener_t
 	}
 };
 
+class LLFileEnableUploadModel : public view_listener_t
+{
+	bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+	{
+		return gMeshRepo.meshUploadEnabled();
+	}
+};
+
 //============================================================================
 
 #if LL_WINDOWS
@@ -304,6 +310,20 @@ class LLFileUploadImage : public view_listener_t, public AIFileUpload
 	}
 };
 
+class LLFileUploadModel : public view_listener_t
+{
+	bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+	{
+		LLFloaterModelPreview* fmp = new LLFloaterModelPreview("Model Preview");
+		LLUICtrlFactory::getInstance()->buildFloater(fmp, "floater_model_preview.xml");
+		if (fmp)
+		{
+			fmp->loadModel(3);
+		}
+		return true;
+	}
+};
+
 class LLFileUploadSound : public view_listener_t, public AIFileUpload
 {
 	bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
@@ -1330,6 +1350,7 @@ void init_menu_file()
 	(new LLFileUploadImage())->registerListener(gMenuHolder, "File.UploadImage");
 	(new LLFileUploadSound())->registerListener(gMenuHolder, "File.UploadSound");
 	(new LLFileUploadAnim())->registerListener(gMenuHolder, "File.UploadAnim");
+	(new LLFileUploadModel())->registerListener(gMenuHolder, "File.UploadModel");
 	(new LLFileUploadBulk())->registerListener(gMenuHolder, "File.UploadBulk");
 	(new LLFileCloseWindow())->registerListener(gMenuHolder, "File.CloseWindow");
 	(new LLFileCloseAllWindows())->registerListener(gMenuHolder, "File.CloseAllWindows");
@@ -1345,6 +1366,8 @@ void init_menu_file()
 	(new LLFileQuit())->registerListener(gMenuHolder, "File.Quit");
 	(new LLFileLogOut())->registerListener(gMenuHolder, "File.LogOut");
 	(new LLFileEnableUpload())->registerListener(gMenuHolder, "File.EnableUpload");
+	(new LLFileEnableUploadModel())->registerListener(gMenuHolder, "File.EnableUploadModel");
+
 	(new LLFileEnableSaveAs())->registerListener(gMenuHolder, "File.EnableSaveAs");
 }
 

indra/newview/llviewerobjectbackup.cpp

@@ -817,7 +817,7 @@ void LLObjectBackup::importObject(bool upload)
 	mRetexture = upload;
 	
 	// Open the file open dialog
-	AIFilePicker* filepicker = new AIFilePicker;
+	AIFilePicker* filepicker = AIFilePicker::create();
 	filepicker->open(FFLOAD_XML, "", "import");
 	filepicker->run(boost::bind(&LLObjectBackup::importObject_continued, this, filepicker));
 	

indra/newview/llviewerregion.cpp

@@ -1629,9 +1629,7 @@ void LLViewerRegionImpl::buildCapabilityNames(LLSD& capabilityNames)
 	//capabilityNames.append("LandResources"); //Script limits (llfloaterscriptlimits.cpp)
 	capabilityNames.append("MapLayer");
 	capabilityNames.append("MapLayerGod");
-#if MESH_IMPORT
 	capabilityNames.append("MeshUploadFlag");
-#endif //MESH_IMPORT
 	capabilityNames.append("NavMeshGenerationStatus");
 	capabilityNames.append("NewFileAgentInventory");
 	/*capabilityNames.append("ObjectMedia");
@@ -1828,7 +1826,7 @@ std::string LLViewerRegion::getCapability(const std::string& name) const
 {
 	if (!capabilitiesReceived() && (name!=std::string("Seed")) && (name!=std::string("ObjectMedia")))
 	{
-		llwarns << "getCapability("<<name<<") called before caps received" << llendl;
+		llwarns << "getCapability called before caps received" << llendl;
 	}
 	
 	CapabilityMap::const_iterator iter = mImpl->mCapabilities.find(name);

indra/newview/llvoiceclient.cpp

@@ -1579,7 +1579,7 @@ void LLVoiceClient::stateMachine()
 		LLViewerRegion *region = gAgent.getRegion();
 		LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
 		
-		if(region && parcel && region->capabilitiesReceived())
+		if(region && parcel)
 		{
 			S32 parcelLocalID = parcel->getLocalID();
 			std::string regionName = region->getName();
@@ -1876,7 +1876,7 @@ void LLVoiceClient::stateMachine()
 			{
 				LLViewerRegion *region = gAgent.getRegion();
 				
-				if(region && region->capabilitiesReceived())
+				if(region)
 				{
 					if ( region->getCapability("ProvisionVoiceAccountRequest") != "" )
 					{

indra/newview/skins/default/colors_base.xml

@@ -220,4 +220,7 @@
 <MultiSliderThumbCenterSelectedColor value="255, 50, 50, 255"/>
 <MultiSliderTriangleColor value="255, 255, 50, 255"/>
 
+<!-- Mesh upload colors -->
+<MeshImportTableNormalColor value="255, 255, 255, 255"/>
+<MeshImportTableHighlightColor value="51, 205, 255, 255"/>
 </settings>

indra/newview/skins/default/xui/en-us/floater_model_preview.xml

@@ -0,0 +1,605 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater name="Model Preview" title="Upload Model"
+ can_close="true" can_resize="false" can_minimize="true" can_drag_on_left="false"
+ min_width="940" min_height="480" width="940" height="480"
+ rect_control="FloaterModelUploadRect">
+
+  <string name="status_idle"></string>
+  <string name="status_parse_error">Error: Dae parsing issue - see log for details.</string>
+  <string name="status_material_mismatch">Error: Material of model is not a subset of reference model.</string>
+  <string name="status_reading_file">Loading...</string>
+  <string name="status_generating_meshes">Generating Meshes...</string>
+  <string name="status_vertex_number_overflow">Error: Vertex number is more than 65534, aborted!</string>
+  <!--string name="status_waiting_server">Sending weights &amp; fee request to server, please wait...</string>
+  <string name="status_uploading">Uploading the model, please wait...</string-->
+  <string name="bad_element">Error: element is invalid</string>
+  <string name="high">High</string>
+  <string name="medium">Medium</string>
+  <string name="low">Low</string>
+  <string name="lowest">Lowest</string>
+  <string name="mesh_status_good">Ship it!</string>
+  <string name="mesh_status_na">N/A</string>
+  <string name="mesh_status_none">None</string>
+  <string name="mesh_status_submesh_mismatch">Levels of detail have a different number of textureable faces.</string>
+  <string name="mesh_status_mesh_mismatch">Levels of detail have a different number of mesh instances.</string>
+  <string name="mesh_status_too_many_vertices">Level of detail has too many vertices.</string>
+  <string name="mesh_status_missing_lod">Missing required level of detail.</string>
+  <string name="mesh_status_invalid_material_list">LOD materials are not a subset of reference model.</string>
+  <string name="layer_all">All</string> <!-- Text to display in physics layer combo box for "all layers" -->
+  <string name="decomposing">Analyzing...</string>
+  <string name="simplifying">Simplifying...</string>
+  <string name="tbd">TBD</string>
+
+	<panel name="left_panel" follows="top|left"
+	 width="630" height="455" left="3" bottom_delta="-475">
+		<panel name="model_name_representation_panel" follows="top|left|bottom|right"
+		 width="525" height="50" left="3">
+			<text name="name_label" follows="top|left"
+			 left="15" bottom_delta="-15" width="290" height="15">
+				Model name:
+			</text>
+			<text name="model_category_label" follows="left|top"
+			 left_delta="300" bottom_delta="0" width="200" height="15">
+				This model represents...
+			</text>
+	        <line_editor name="description_form" max_length="64" follows="top|left"
+			 prevalidate_callback="ascii"
+			 left="15" top_delta="-15" width="290" height="20"/>
+			<combo_box name="model_category_combo" follows="left|top"
+			 left_delta="300"  bottom_delta="0" width="200" height="20">
+				<combo_item name="Choose one" value="MUT_Unspecified">
+					 Choose One...
+				</combo_item>
+				<combo_item name="Avatar shape" value="MUT_AvatarShape">
+					Avatar shape
+				</combo_item>
+				<combo_item name="Avatar attachment" value="MUT_AvatarAttachment">
+					Avatar attachment
+				</combo_item>
+				<combo_item name="Moving object (vehicle, animal)" value="MUT_MovingObject">
+					Moving object (vehicle, animal)
+				</combo_item>
+				<combo_item name="Building Component" value="MUT_BuildingComponent">
+					Building Component
+				</combo_item>
+				<combo_item name="Large, non moving etc" value="MUT_LargeStationary">
+					Large, non moving etc
+				</combo_item>
+				<combo_item name="Smaller, non-moving etc" value="MUT_SmallStationary">
+					Smaller, non-moving etc
+				</combo_item>
+				<combo_item name="Not really any of these" value="MUT_Other">
+					Not really any of these
+				</combo_item>
+			</combo_box>
+		</panel>
+		<tab_container name="import_tab" tab_position="top" follows="top|left"
+		 left="0" bottom_delta="-270" width="625" height="270">
+
+			<!-- LOD PANEL -->
+			<panel name="lod_panel" label="Level of Detail" title="Level of Detail">
+				<view_border name="lod_tab_border" bevel_style="none" follows="top|left"
+				 left="3" bottom_delta="-270" width="619" height="270"/>
+				<text name="source" follows="left|top" text_color="orange"
+				 left="75" bottom_delta="240" width="335" height="18">
+					Source
+				</text>
+				<text name="triangles" halign="right" follows="left|top" text_color="orange"
+				 left_delta="335" bottom_delta="0" width="65" height="18">
+					Triangles
+				</text>
+				<text name="vertices" halign="right" follows="left|top" text_color="orange"
+				 left_delta="65" bottom_delta="0" width="65" height="18">
+					Vertices
+				</text>
+
+				<text name="high_label" follows="left|top"
+				 left="10" bottom_delta="-24" width="65" height="18">
+					High
+				</text>
+				<combo_box name="lod_source_high" follows="top|left"
+				 left_delta="65" bottom_delta="0" width="135" height="20">
+					<combo_item name="Load from file" value="Load from file">
+						Load from file
+					</combo_item>
+					<combo_item name="Generate" value="Generate">
+						Generate
+					</combo_item>
+				</combo_box>
+				<line_editor name="lod_file_high" initial_value="" value=""
+				 follows="left|top"
+				 left_delta="140" bottom_delta="0" width="120" height="20"/>
+				<button name="lod_browse_high" label="Browse..."
+				 follows="left|top"
+				 left_delta="125" bottom_delta="0" width="70" height="20"/>
+				<combo_box name="lod_mode_high" follows="top|left" visible="false"
+				 left="215" bottom_delta="0" width="135" height="20">
+					<combo_item name="Triangle Limit" value="Triangle Limit">
+						Triangle Limit
+					</combo_item>
+					<combo_item name="Error Threshold" value="Error Threshold">
+						Error Threshold
+					</combo_item>
+				</combo_box>
+				<spinner name="lod_triangle_limit_high" follows="top|left"
+				 decimal_digits="0" increment="10" visible="false"
+				 left_delta="140" bottom_delta="-1" width="55" height="20"/>
+				<spinner name="lod_error_threshold_high" follows="top|left"
+				 max_val="100" increment="0.01" visible="false"
+				 left_delta="0" bottom_delta="-1" width="55" height="20"/>
+				<text name="high_triangles" halign="right" follows="left|top"
+				 initial_value="0" value="0"
+				 left_delta="55" bottom_delta="1" width="65" height="20"/>
+				<text name="high_vertices" halign="right" follows="left|top"
+				 initial_value="0" value="0"
+				 left_delta="65" bottom_delta="0" width="65" height="20"/>
+				<text name="high_status" halign="center" follows="left|top"
+				 initial_value="" value=""
+				 left_delta="65" bottom_delta="0" width="65" height="20"/>
+				<icon name="status_icon_high" image_name="red_x.png" mouse_opaque="true"
+				 follows="left|top"
+				 left_delta="20" bottom_delta="3" height="16" width="16"/>
+
+				<text name="medium_label" follows="left|top"
+				 left="10" bottom_delta="-32" width="65" height="18">
+					Medium
+				</text>
+				<combo_box name="lod_source_medium" follows="top|left"
+				 left_delta="65" bottom_delta="0" width="135" height="20">
+					<combo_item name="Load from file" value="Load from file">
+						Load from file
+					</combo_item>
+					<combo_item name="Generate" value="Generate">
+						Generate
+					</combo_item>
+					<combo_item name="Use LoD above" value="Use LoD above">
+						Use LoD above
+					</combo_item>
+				</combo_box>
+				<line_editor name="lod_file_medium" initial_value="" value=""
+				 follows="left|top" visible="false"
+				 left_delta="140" bottom_delta="0" width="120" height="20"/>
+				<button name="lod_browse_medium" label="Browse..."
+				 follows="left|top" visible="false"
+				 left_delta="125" bottom_delta="0" width="70" height="20"/>
+				<combo_box name="lod_mode_medium" follows="top|left"
+				 left="215" bottom_delta="0" width="135" height="20">
+					<combo_item name="Triangle Limit" value="Triangle Limit">
+						Triangle Limit
+					</combo_item>
+					<combo_item name="Error Threshold" value="Error Threshold">
+						Error Threshold
+					</combo_item>
+				</combo_box>
+				<spinner name="lod_triangle_limit_medium" follows="top|left"
+				 decimal_digits="0" increment="10"
+				 left_delta="140" bottom_delta="-1" width="55" height="20"/>
+				<spinner name="lod_error_threshold_medium" follows="top|left"
+				 max_val="100" increment="0.01" visible="false"
+				 left_delta="0" bottom_delta="-1" width="55" height="20"/>
+				<text name="medium_triangles" halign="right" follows="left|top"
+				 initial_value="0" value="0"
+				 left_delta="55" bottom_delta="1" width="65" height="20"/>
+				<text name="medium_vertices" halign="right" follows="left|top"
+				 initial_value="0" value="0"
+				 left_delta="65" bottom_delta="0" width="65" height="20"/>
+				<text name="medium_status" halign="center" follows="left|top"
+				 initial_value="" value=""
+				 left_delta="65" bottom_delta="0" width="65" height="20"/>
+				<icon name="status_icon_medium" image_name="red_x.png" mouse_opaque="true"
+				 follows="left|top"
+				 left_delta="20" bottom_delta="3" height="16" width="16"/>
+
+				<text name="low_label" follows="left|top"
+				 left="10" bottom_delta="-32" width="65" height="18">
+					Low
+				</text>
+				<combo_box name="lod_source_low" follows="top|left"
+				 left_delta="65" bottom_delta="0" width="135" height="20">
+					<combo_item name="Load from file" value="Load from file">
+						Load from file
+					</combo_item>
+					<combo_item name="Generate" value="Generate">
+						Generate
+					</combo_item>
+					<combo_item name="Use LoD above" value="Use LoD above">
+						Use LoD above
+					</combo_item>
+				</combo_box>
+				<line_editor name="lod_file_low" initial_value="" value=""
+				 follows="left|top" visible="false"
+				 left_delta="140" bottom_delta="0" width="120" height="20"/>
+				<button name="lod_browse_low" label="Browse..."
+				 follows="left|top" visible="false"
+				 left_delta="125" bottom_delta="0" width="70" height="20"/>
+				<combo_box name="lod_mode_low" follows="top|left"
+				 left="215" bottom_delta="0" width="135" height="20">
+					<combo_item name="Triangle Limit" value="Triangle Limit">
+						Triangle Limit
+					</combo_item>
+					<combo_item name="Error Threshold" value="Error Threshold">
+						Error Threshold
+					</combo_item>
+				</combo_box>
+				<spinner name="lod_triangle_limit_low" follows="top|left"
+				 decimal_digits="0" increment="10"
+				 left_delta="140" bottom_delta="-1" width="55" height="20"/>
+				<spinner name="lod_error_threshold_low" follows="top|left"
+				 max_val="100" increment="0.01" visible="false"
+				 left_delta="0" bottom_delta="-1" width="55" height="20"/>
+				<text name="low_triangles" halign="right" follows="left|top"
+				 initial_value="0" value="0"
+				 left_delta="55" bottom_delta="1" width="65" height="20"/>
+				<text name="low_vertices" halign="right" follows="left|top"
+				 initial_value="0" value="0"
+				 left_delta="65" bottom_delta="0" width="65" height="20"/>
+				<text name="low_status" halign="center" follows="left|top"
+				 initial_value="" value=""
+				 left_delta="65" bottom_delta="0" width="65" height="20"/>
+				<icon name="status_icon_low" image_name="red_x.png" mouse_opaque="true"
+				 follows="left|top"
+				 left_delta="20" bottom_delta="3" height="16" width="16"/>
+
+				<text name="lowest_label" follows="left|top"
+				 left="10" bottom_delta="-32" width="65" height="18">
+					Lowest
+				</text>
+				<combo_box name="lod_source_lowest" follows="top|left"
+				 left_delta="65" bottom_delta="0" width="135" height="20">
+					<combo_item name="Load from file" value="Load from file">
+						Load from file
+					</combo_item>
+					<combo_item name="Generate" value="Generate">
+						Generate
+					</combo_item>
+					<combo_item name="Use LoD above" value="Use LoD above">
+						Use LoD above
+					</combo_item>
+				</combo_box>
+				<line_editor name="lod_file_lowest" initial_value="" value=""
+				 follows="left|top" visible="false"
+				 left_delta="140" bottom_delta="0" width="120" height="20"/>
+				<button name="lod_browse_lowest" label="Browse..."
+				 follows="left|top" visible="false"
+				 left_delta="125" bottom_delta="0" width="70" height="20"/>
+				<combo_box name="lod_mode_lowest" follows="top|left"
+				 left="215" bottom_delta="0" width="135" height="20">
+					<combo_item name="Triangle Limit" value="Triangle Limit">
+						Triangle Limit
+					</combo_item>
+					<combo_item name="Error Threshold" value="Error Threshold">
+						Error Threshold
+					</combo_item>
+				</combo_box>
+				<spinner name="lod_triangle_limit_lowest" follows="top|left"
+				 decimal_digits="0" increment="10"
+				 left_delta="140" bottom_delta="-1" width="55" height="20"/>
+				<spinner name="lod_error_threshold_lowest" follows="top|left"
+				 max_val="100" increment="0.01" visible="false"
+				 left_delta="0" bottom_delta="-1" width="55" height="20"/>
+				<text name="lowest_triangles" halign="right" follows="left|top"
+				 initial_value="0" value="0"
+				 left_delta="55" bottom_delta="1" width="65" height="20"/>
+				<text name="lowest_vertices" halign="right" follows="left|top"
+				 initial_value="0" value="0"
+				 left_delta="65" bottom_delta="0" width="65" height="20"/>
+				<text name="lowest_status" halign="center" follows="left|top"
+				 initial_value="" value=""
+				 left_delta="65" bottom_delta="0" width="65" height="20"/>
+				<icon name="status_icon_lowest" image_name="red_x.png" mouse_opaque="true"
+				 follows="left|top"
+				 left_delta="20" bottom_delta="3" height="16" width="16"/>
+
+				<icon name="lod_status_message_icon" mouse_opaque="true" follows="left|top"
+				 left="10" bottom_delta="-32" width="16" height="16"/>
+				<text name="lod_status_message_text" word_wrap="true" wrap="true"
+				 follows="left|top"
+				 left_delta="22" bottom_delta="0" width="584" height="16"/>
+
+				<view_border name="lod_tab_border" bevel_style="none" follows="top|left"
+				 left="10" bottom_delta="-20" width="605" height="0"/>
+				<check_box name="gen_normals" label="Generate Normals" follows="top|left"
+				 left="10" bottom_delta="-32" width="100" height="16"/>
+				<text name="crease_label" follows="top|left" enabled="false"
+				 left="200" bottom_delta="0" width="100" height="16">
+					Crease Angle:
+				</text>
+				<spinner name="crease_angle" follows="top|left" enabled="false"
+				 initial_value="75" max_val="180" value="75"
+				 left_delta="105" bottom_delta="0" width="60" height="16"/>
+			</panel>
+
+			<!-- PHYSICS PANEL -->
+			<panel name="physics_panel" label="Physics" title="Physics">
+				<view_border name="physics_tab_border" bevel_style="none" follows="top|left"
+				 left="3" bottom_delta="-270" width="619" height="270"/>
+
+				<!-- ==== STEP 1: Level of Detail ==== -->
+				<panel name="physics geometry" follows="top|left"
+				 left="18" bottom_delta="230" height="25" width="589">
+					<text name="first_step_name" font="SansSerif" follows="top|left"
+					 left="0" bottom_delta="-20" width="210" height="20">
+						Step 1: Level of Detail
+					</text>
+                    <combo_box name="physics_lod_combo" follows="top|left"
+					 left_delta="220" bottom_delta="0" width="130" height="20"
+					 tool_tip="LOD to use for physics shape">
+						<combo_item name="choose_one">Choose one...</combo_item>
+						<combo_item name="physics_high">High</combo_item>
+						<combo_item name="physics_medium">Medium</combo_item>
+						<combo_item name="physics_low">Low</combo_item>
+						<combo_item name="physics_lowest">Lowest</combo_item>
+						<combo_item name="load_from_file">From file</combo_item>
+					</combo_box>
+					<line_editor name="physics_file" follows="top|left"
+					 left_delta="140" bottom_delta="0" width="154" height="20"/>
+					<button name="physics_browse" label="Browse..." follows="top|left"
+                     left_delta="159" bottom_delta="0" height="20" width="70"/>
+<!--
+					<check_box name="physics_optimize" label="Optimize" follows="left|top"
+					 width="130" left="10" bottom_delta="-24" height="20"/>
+                    <check_box name="physics_use_hull" label="Use Convex Hull" follows="left|top"
+					 width="130" left_delta="135" height="20"/>
+-->
+				</panel>
+
+				<!-- ==== STEP 2: Analyze ==== -->
+				<view_border name="physics_tab_border" bevel_style="none" follows="top|left"
+				 left="18" bottom_delta="-10" width="589" height="0"/>
+				<panel name="physics analysis" follows="top|left"
+				 left="18" bottom_delta="-75" width="589" height="65">
+					<text name="method_label" font="SansSerif" follows="top|left"
+					 left="0" bottom_delta="-20" width="210" height="20">
+						Step 2: Analyze
+					</text>
+					<text name="analysis_method_label" follows="top|left"
+					 left="0" bottom_delta="-20" width="100" height="16">
+						Method:
+					</text>
+                    <text name="quality_label" follows="top|left"
+					 left_delta="115" bottom_delta="0" width="100" height="16">
+						Quality:
+					</text>
+                    <text name="smooth_method_label" follows="top|left"
+					 left_delta="115" bottom_delta="0" width="100" height="16">
+						Smooth:
+					</text>
+					<combo_box name="Method" follows="top|left"
+					 left="0" bottom_delta="-20" width="100" height="20"/>
+					<combo_box name="Decompose Quality"
+					 left_delta="115" bottom_delta="0" width="100" height="20"/>
+					<combo_box name="Cosine%"
+					 left_delta="115" bottom_delta="0" width="100" height="20"/>
+					<check_box name="Close Holes (Slow)" label="Close Holes" follows="top|left"
+					 left_delta="110" bottom_delta="0" width="100" height="20"/>
+					<button name="Decompose" label="Analyze" follows="top|left"
+					 right="-1" bottom_delta="0" width="90" height="20"/>
+					<button name="decompose_cancel" label="Cancel" follows="top|left" visible="false"
+					 right="-1" bottom_delta="0" width="90" height="20"/>
+                </panel>
+
+				<!-- ==== STEP 3: Simplify ==== -->
+				<view_border name="physics_tab_border2" bevel_style="none" follows="top|left"
+				 left="18" bottom_delta="-10" width="589" height="0"/>
+                <panel name="physics simplification" follows="top|left"
+				 left="18" bottom_delta="-77" width="589" height="70">
+					<text name="second_step_label" font="SansSerif" follows="top|left"
+					 left="0" bottom_delta="-20" width="210" height="20">
+						Step 3: Simplify
+					</text>
+					<text name="simp_method_header" follows="top|left"
+					 left="0" bottom_delta="-20" width="100" height="16">
+						Method:
+					</text>
+                    <text name="pass_method_header" follows="top|left"
+					 left_delta="140" bottom_delta="0" width="51" height="16">
+						Passes:
+					</text>
+                    <text name="Detail Scale label" follows="top|left"
+					 left_delta="81" bottom_delta="0" width="80" height="16">
+						Detail scale:
+					</text>
+                    <text name="Retain%_label" follows="top|left" visible="false"
+					 left_delta="0" bottom_delta="0" width="80" height="16">
+						Retain:
+					</text>
+					<combo_box name="Simplify Method" follows="top|left"
+					 left="0" bottom_delta="-20" width="100" height="20"/>
+					<combo_box name="Combine Quality" value="1" follows="top|left"
+					 left_delta="140" bottom_delta="0" width="51" height="20"/>
+					<spinner name="Detail Scale" follows="top|left"
+					 left_delta="81" bottom_delta="-2" width="60" height="20"/>
+					<spinner name="Retain%" decimal_digits="0" follows="top|left" visible="false"
+					 left_delta="0" bottom_delta="0" width="60" height="20"/>
+					<button name="Simplify" label="Simplify" follows="top|left"
+					 left_delta="100" bottom_delta="2" width="90" height="20"/>
+                    <button name="simplify_cancel" label="Cancel" visible="false"
+					 left_delta="0" bottom_delta="0" width="90" height="20"/>
+				</panel>
+
+				<!-- ==== Results ==== -->
+				<view_border name="physics_tab_border3" bevel_style="none" follows="top|left"
+				 left="18" bottom_delta="-5" width="589" height="0"/>
+                <panel name="physics info" follows="top|left"
+				 left="18" bottom_delta="-27" width="589" height="20">
+					<text name="results_text" follows="top|left"
+					 left="0" bottom_delta="-18" width="50" height="16">
+						Results:
+					</text>
+					<text name="physics_triangles" follows="top|left"
+					 left_delta="60" bottom_delta="0" width="120" height="16">
+						Triangles: [TRIANGLES],
+					</text>
+					<text name="physics_points" follows="top|left"
+					 left_delta="130" bottom_delta="0" width="120" height="16">
+						Vertices: [POINTS],
+					</text>
+					<text name="physics_hulls" follows="top|left"
+					 left_delta="130" bottom_delta="0" width="120" height="16">
+						Hulls: [HULLS]
+					</text>
+				</panel>
+			</panel>
+
+			<!-- MODIFIERS PANEL -->
+			<panel name="modifiers_panel" label="Upload options" title="Upload options">
+				<view_border name="modifiers_tab_border" bevel_style="none" follows="top|left"
+				 left="3" bottom_delta="-270" width="619" height="270"/>
+				<text name="scale_label" follows="top|left"
+				 left="20" bottom="-38" width="140" height="20">
+					Scale (1 = no scaling):
+				</text>
+				<spinner name="import_scale" follows="top|left"
+				 min_val="0.01" max_val="64.0" initial_val="1.0" value="1.0"
+				 left_delta="150" bottom_delta="2" width="80" height="20"/>
+				<text name="dimensions_label" follows="top|left"
+				 left_delta="120" bottom_delta="-2" width="80" height="20">
+					Dimensions:
+				</text>
+				<text name="import_dimensions" follows="top|left"
+				 left_delta="90" bottom_delta="0" width="140" height="20">
+					[X] X [Y] X [Z]
+				</text>
+				<check_box name="upload_textures" label="Include textures" follows="top|left"
+				 left="20" bottom_delta="-24" width="120"  height="16"/>
+
+				<view_border name="modifiers_tab_border2" bevel_style="none" follows="top|left"
+				 left="18" bottom_delta="-10" width="589" height="0"/>
+				<text name="include_label" follows="top|left"
+				 left="20" bottom_delta="-28" width="150" height="16">
+					For avatar models only:
+				</text>
+				<check_box name="upload_skin" label="Include skin weight" follows="top|left"
+				 left_delta="0" bottom_delta="-24" width="140" height="16"/>
+				<text name="pelvis_offset_label" follows="top|left"
+				 left_delta="200" bottom_delta="0" width="200" height="16">
+					Z offset (raise or lower avatar):
+				</text>
+				<spinner name="pelvis_offset" follows="top|left"
+				 min_val="-3.00" max_val="3.0" initial_val="0.0"
+				 left_delta="180" bottom_delta="2" width="60" height="16"/>
+				<check_box name="upload_joints" label="Include joint positions" follows="top|left"
+				 left="20" bottom_delta="-26" width="140" height="16"/>
+<!-- Mesh Deformer bits
+				<check_box name="deform" label="Deform to avatar shape:" follows="top|left"
+				 left="20" bottom_delta="-24" width="140" height="16"/>
+				<radio_group name="deform_base" draw_border="false"
+				 left_delta="195" bottom_delta="0" height="16" width="330" follows="top|left">
+					<radio_item name="0" value="0"
+					 bottom="-16" left="0" height="16" width="100">
+						Default male
+					</radio_item>
+					<radio_item name="1" value="1"
+					 bottom="-16" left="110" height="16" width="100">
+						Default female
+					</radio_item>
+					<radio_item name="2" value="2"
+					 bottom="-16" left="220" height="16" width="100">
+						Worn shape
+					</radio_item>
+				</radio_group>
+-->
+			</panel>
+		</tab_container>
+
+		<panel name="weights_and_warning_panel" layout="top|left" follows="top|left"
+		 bottom="-410" left="0" width="625" height="60">
+			<button name="calculate_btn" label="Calculate weights &amp; fee" follows="top|left"
+			 left="5" bottom_delta="-20" width="150" height="20"
+			 tool_tip="Calculate weights &amp;fee"/>
+			<button name="cancel_btn" label="Cancel" follows="top|left"
+			 left_delta="155" bottom_delta="0" width="80" height="20"/>
+			<button name="ok_btn" label="Upload" visible="false" follows="top|left"
+			 left="35" bottom_delta="0" width="80" height="20"
+	         tool_tip="Upload to the simulator"/>
+			<button name="reset_btn" label="Clear settings &amp; reset form" follows="top|left"
+	         right="-5" bottom_delta="0" width="180" height="20"/>
+
+			<!-- WEIGHTS -->
+			<text name="upload_fee" word_wrap="true" follows="top|left"
+			 left="5" bottom_delta="-24" height="16" width="130">
+				Upload fee: L$ [FEE]
+			</text>
+			<text name="prim_weight" word_wrap="true" follows="top|left"
+			 left_delta="140" bottom_delta="0" height="16" width="120">
+				Land impact: [EQ]
+			</text>
+			<text name="download_weight" follows="top|left"
+			 left_delta="130" bottom_delta="0" height="16" width="100">
+				Download: [ST]
+			</text>
+			<text name="physics_weight" follows="top|left"
+			 left_delta="110" bottom_delta="0" height="16" width="90">
+				Physics: [PH]
+			</text>
+			<text name="server_weight" follows="top|left"
+			 left_delta="100" bottom_delta="0" height="16" width="90">
+				Server: [SIM]
+			</text>
+
+			<!-- NOTE MESSAGE -->
+			<text name="warning_title" font="SansSerif" follows="top|left"
+			 left="5" bottom_delta="-25" height="20" width="40" visible="true">
+				NOTE:
+			</text>
+			<text name="warning_message" wrap="true" parse_urls="true"
+			 follows="top|left" visible="false"
+			 left_delta="45" bottom_delta="-1" height="20" width="240">
+				You dont have rights to upload mesh models.
+			</text>
+			<text name="validate_url" wrap="true" parse_urls="true"
+			 follows="top|left" visible="false" hover="true"
+			 left_delta="245" bottom_delta="0" height="20" width="260">
+				Click here to find out how to get certified.
+			</text>
+
+			<text name="status" follows="top|left"
+			 left="5" bottom_delta="-20" height="16" width="615">
+				[STATUS]
+			</text>
+		</panel>
+	</panel>
+
+	<text name="lod_label" follows="left|top"
+	 left="640" bottom="-40" height="16" width="290">
+		Preview:
+	</text>
+
+	<panel name="preview_panel" border="true" bevel_style="none"
+	 follows="top|left"
+	 left="640" bottom_delta="-295" width="290" height="290"/>
+
+	<panel name="right_panel" follows="top|left|bottom|right"
+	 left_delta="0" bottom_delta="-140" width="290" height="130">
+		<combo_box name="preview_lod_combo" follows="left|top"
+		 tool_tip="LOD to view in preview render"
+		 left_delta="0" bottom_delta="-20" width="150" height="20">
+			<combo_item name="high">High</combo_item>
+			<combo_item name="medium">Medium</combo_item>
+			<combo_item name="low">Low</combo_item>
+			<combo_item name="lowest">Lowest</combo_item>
+		</combo_box>
+		<text name="label_display" follows="top|left"
+		 left_delta="180" bottom_delta="-3" width="50" height="20">
+			Display...
+		</text>
+		<check_box name="show_edges" label="Edges" follows="top|left"
+		 left_delta="0" bottom_delta="-16" width="80" height="16"/>
+		<check_box name="show_physics" label="Physics" follows="top|left"
+		 left_delta="0" bottom_delta="-16" width="80" height="16"/>
+		<check_box name="show_textures" label="Textures" follows="top|left"
+		 left_delta="0" bottom_delta="-16" width="80" height="16"/>
+		<check_box name="show_skin_weight" label="Skin weights" follows="top|left"
+		 left_delta="0" bottom_delta="-16" width="80" height="16"/>
+		<check_box name="show_joint_positions" label="Joints" follows="top|left"
+		 left_delta="0" bottom_delta="-16" width="80" height="16"/>
+
+		<text name="physics_explode_label" follows="top|left"
+		 left="2" bottom_delta="46" width="150" height="20">
+			Preview Spread:
+		</text>
+		<slider name="physics_explode" follows="top|left"
+		 min_val="0.0" max_val="3.0"
+		 left="0" bottom_delta="-16" width="150" height="20"/>
+	</panel>
+</floater>

indra/newview/skins/default/xui/en-us/menu_viewer.xml

@@ -19,6 +19,11 @@
         mouse_opaque="true" enabled="true"  >
         <on_click function="File.UploadAnim" userdata="" />
         <on_enable function="File.EnableUpload" />
+    </menu_item_call>
+	<menu_item_call label="Upload Mesh..." name="Upload Mesh"
+        mouse_opaque="true" enabled="true"  >
+        <on_click function="File.UploadModel" userdata="" />
+        <on_enable function="File.EnableUploadModel" />
     </menu_item_call>
     <menu_item_call label="Bulk ([UPLOADFEE] per file)..." name="Bulk Upload"
         mouse_opaque="true" enabled="true" >

indra/newview/skins/default/xui/en-us/notifications.xml

@@ -2831,9 +2831,9 @@ Are you sure you want to return objects owned by [USER_NAME]?
    name="InvalidTerrainBitDepth"
    type="alertmodal">
 Couldn't set region textures:
-Terrain texture [TEXTURE_NUM] has an invalid bit depth of [TEXTURE_BIT_DEPTH]. Probable cause is that the texture data contains transparency information.
+Terrain texture [TEXTURE_NUM] has an invalid bit depth of [TEXTURE_BIT_DEPTH].
 
-Replace texture [TEXTURE_NUM] with a 24-bit 1024x1024 or smaller image then click "Apply" again.
+Replace texture [TEXTURE_NUM] with a 24-bit 512x512 or smaller image then click "Apply" again.
   </notification>
 
   <notification
@@ -2843,7 +2843,7 @@ Replace texture [TEXTURE_NUM] with a 24-bit 1024x1024 or smaller image then clic
 Couldn&apos;t set region textures:
 Terrain texture [TEXTURE_NUM] is too large at [TEXTURE_SIZE_X]x[TEXTURE_SIZE_Y].
 
-Replace texture [TEXTURE_NUM] with a 24-bit 1024x1024 or smaller image then click &quot;Apply&quot; again.
+Replace texture [TEXTURE_NUM] with a 24-bit 512x512 or smaller image then click &quot;Apply&quot; again.
   </notification>
 
   <notification
@@ -7329,6 +7329,22 @@ The region you have entered is running a different simulator version. Click this
 The URL you clicked cannot be opened from this web browser.
   </notification>
 
+  <notification
+    name="MeshUploadError"
+    icon="alert.tga"
+    type="alert">
+    [LABEL] failed to upload: [MESSAGE] [IDENTIFIER]
+
+See the log file for details.
+  </notification>
+
+  <notification
+    name="MeshUploadPermError"
+    icon="alert.tga"
+    type="alert">
+    Error while requesting mesh upload permissons.
+  </notification>
+
   <notification
     name="RegionCapabilityRequestError"
     icon="alert.tga"

indra/newview/skins/default/xui/en-us/panel_region_texture.xml

@@ -11,7 +11,7 @@
 	</text>
 	<text bottom_delta="-26" follows="left|top" height="20" left="10"
 	     name="detail_texture_text" width="300">
-		Terrain Textures
+		Terrain Textures (requires 512x512, 24 bit .tga files)
 	</text>
 	<texture_picker bottom_delta="-100" follows="left|top" height="100" left="10"
 	     name="texture_detail_0" width="100" />

indra/newview/skins/default/xui/es/notifications.xml

@@ -1624,14 +1624,14 @@ Por favor, selecciona sólo uno y reinténtalo.
 		No se han podido configurar las texturas de la región:
 La textura del terreno [TEXTURE_NUM] tiene una profundidad de bites inválida: [TEXTURE_BIT_DEPTH].
 
-Cambia la textura [TEXTURE_NUM] por una imagen de 24-bit y 1024x1024 o menor, y pulsa de nuevo 'Aplicar' .
+Cambia la textura [TEXTURE_NUM] por una imagen de 24-bit y 512x512 o menor, y pulsa de nuevo 'Aplicar' .
 	</notification>
 	
 	<notification name="InvalidTerrainSize">
 		No se han podido configurar las texturas de la región:
 La textura del terreno [TEXTURE_NUM] es demasiado grande: [TEXTURE_SIZE_X]x[TEXTURE_SIZE_Y].
 
-Cambia la textura [TEXTURE_NUM] por una imagen de 24-bit y 1024x1024 o menor, y pulsa de nuevo &apos;Aplicar&apos; .
+Cambia la textura [TEXTURE_NUM] por una imagen de 24-bit y 512x512 o menor, y pulsa de nuevo &apos;Aplicar&apos; .
 	</notification>
 	
 	<notification name="RawUploadStarted">

indra/newview/skins/default/xui/es/panel_region_texture.xml

@@ -7,7 +7,7 @@
 		desconocida
 	</text>
 	<text name="detail_texture_text">
-		Texturas del Terreno
+		Texturas del Terreno (requiere archivos tga de 512x512, 24 bit)
 	</text>
 	<text name="height_text_lbl">
 		1 (baja)

indra/newview/skins/default/xui/fr/notifications.xml

@@ -1220,13 +1220,13 @@ Veuillez ne sélectionner qu'un seul objet.
 		Impossible de definir les textures de la région :
 La texture du terrain [TEXTURE_NUM] a une profondeur invalide ([TEXTURE_BIT_DEPTH]).
 
-Remplacer la texture [TEXTURE_NUM] avec une image de 24 bits, 1024x1024, ou plus petite, puis cliquez à nouveau sur Appliquer.
+Remplacer la texture [TEXTURE_NUM] avec une image de 24 bits, 512 X 512, ou plus petite, puis cliquez à nouveau sur Appliquer.
 	</notification>
 	<notification name="InvalidTerrainSize">
 		Impossible de definir les textures de la région :
 La texture du terrain [TEXTURE_NUM] est trop volumineuse ([TEXTURE_SIZE_X] X [TEXTURE_SIZE_Y]).
 
-Remplacer la texture [TEXTURE_NUM] avec une image de 24 bits, 1024x1024, ou plus petite, puis cliquez à nouveau sur Appliquer.
+Remplacer la texture [TEXTURE_NUM] avec une image de 24 bits, 512 X 512, ou plus petite, puis cliquez à nouveau sur Appliquer.
 	</notification>
 	<notification name="RawUploadStarted">
 		Le chargement a commencé. Cela va prendre une à deux minutes,
@@ -3261,4 +3261,4 @@ Si vous avez toujours des problèmes, veuillez consulter la page suivante : ht
   </notification>
 
 
-  </notifications>
+  </notifications>

indra/newview/skins/default/xui/fr/panel_region_texture.xml

@@ -6,6 +6,9 @@
 	<text name="region_text">
 		(inconnue)
 	</text>
+	<text name="base_texture_text">
+		Textures de base (fichiers 128x128, 24 bits .tga)
+	</text>
 	<text name="height_text_lbl">
 		1 (faible)
 	</text>
@@ -19,7 +22,7 @@
 		4 (élevé)
 	</text>
 	<text name="detail_texture_text">
-		Textures du terrain
+		Textures du terrain (fichiers.tga 512 x 512, 24 bits requis)
 	</text>
 	<text name="height_text_lbl5">
 		Limites d&apos;élévation de texture

indra/newview/statemachine/aifilepicker.cpp

@@ -176,6 +176,18 @@ void AIFilePicker::open(ELoadFilter filter, std::string const& default_path, std
 	  case FFLOAD_RAW:
 		  mFilter = "raw";
 		  break;
+	  case FFLOAD_MODEL:
+		  mFilter = "model";
+		  break;
+	  case FFLOAD_COLLADA:
+		  mFilter = "collada";
+		  break;
+	  case FFLOAD_SCRIPT:
+		  mFilter = "script";
+		  break;
+	  case FFLOAD_DICTIONARY:
+		  mFilter = "dictionary";
+		  break;
 	  case FFLOAD_INVGZ:
 		  mFilter = "invgz";
 		  break;
@@ -249,8 +261,8 @@ void AIFilePicker::open(std::string const& filename, ESaveFilter filter, std::st
 		case FFSAVE_GESTURE:
 			mFilter = "gesture";
 			break;
-		case FFSAVE_LSL:
-			mFilter = "lsl";
+		case FFSAVE_SCRIPT:
+			mFilter = "script";
 			break;
 		case FFSAVE_SHAPE:
 			mFilter = "shape";