It's silly that this was necessary... but it was. AMD... :(

If the world is in focus and build button is pressed without the build floater open, don't bother focusing.
If a floater is in focus and build button is pressed without the build floater open, focus the build floater
If the build floater is in the background and the button is pressed, focus the build floater.
If the build floater is in focus and the button is pressed, close the build floater.
If the build floater is  not in focus but nothing else is, close the build floater.

.gitignore

@@ -26,3 +26,12 @@ qtcreator-build/
 /.pc
 /build-*
 /viewer-*
+/indra/newview/res/viewerRes.rc
+/indra/newview/res/viewerRes_bc.rc
+/indra/newview/English.lproj/InfoPlist.strings
+/indra/newview/linux_tools/handle_secondlifeprotocol.sh
+/indra/newview/linux_tools/install.sh
+/indra/newview/linux_tools/refresh_desktop_app_entry.sh
+/indra/newview/linux_tools/wrapper.sh
+
+

LICENSES/LEGAL-intel_matrixlib.txt

@@ -0,0 +1,29 @@
+INTEL LICENSE AGREEMENT
+
+IMPORTANT - READ BEFORE COPYING OR USING. 
+Do not use or load this library and any associated materials (collectively, 
+the "Software") until you have read the following terms and conditions. By 
+loading or using the Software, you agree to the terms of this Agreement. If 
+you do not wish to so agree, do not use the Software.
+
+LICENSE:  Subject to the restrictions below, Intel Corporation ("Intel") 
+grants to you the permission to use, copy, distribute and prepare derivative 
+works of this Software for any purpose and without fee, provided, that 
+Intel's copyright notice appear in all copies of the Software files.
+The distribution of derivative works of the Software is also subject to the 
+following limitations:  you (i) are solely responsible to your customers for 
+any liability which may arise from the distribution, (ii) do not make any 
+statement that your product is "certified", or that its performance is 
+guaranteed, by Intel, and (iii) do not use Intel's name or trademarks to 
+market your product without written permission.
+
+EXCLUSION OF ALL WARRANTIES. The Software is provided "AS IS" without any 
+express or implies warranty of any kind including warranties of 
+merchantability, noninfringement, or fitness for a particular purpose.  
+Intel does not warrant or assume responsibility for the accuracy or 
+completeness of any information contained within the Software.
+As this Software is given free of charge, in no event shall Intel be liable 
+for any damages whatsoever arising out of the use of or inability to use the 
+Software, even if Intel has been adviced of the possibility of such damages. 
+Intel does not assume any responsibility for any errors which may appear in 
+this Software nor any responsibility to update it.

README

@@ -15,8 +15,8 @@ Singularity Viewer is a SecondLife(tm) protocol compatible client application.
 It can be used to access SecondLife services as well as a number of others such
 as those based upon the OpenSim platform.
 
-Singulariy is maintained by a small group of volunteers who can be contacted
+Singularity is maintained by a small group of volunteers who can be contacted
-both, in-world (SingularityViewer group) as well on IRC (#SingularityViewer
+both, in-world (SingularityViewer group) as well as on IRC (#SingularityViewer
 @ FreeNode). Bug requests and features requests can be submitted through our
 Issue Tracker (http://code.google.com/p/singularity-viewer/issues/list or from
 the viewer menu: Help --> Bug Reporting --> Singularity Issue Tracker...)

indra/CMakeLists.txt

@@ -75,7 +75,6 @@ if (WINDOWS AND EXISTS ${LIBS_CLOSED_DIR}copy_win_scripts)
 endif (WINDOWS AND EXISTS ${LIBS_CLOSED_DIR}copy_win_scripts)
 
 add_custom_target(viewer)
-add_subdirectory(${LIBS_OPEN_PREFIX}llcrashlogger)
 add_subdirectory(${LIBS_OPEN_PREFIX}llplugin)
 add_subdirectory(${LIBS_OPEN_PREFIX}llui)
 
@@ -87,28 +86,6 @@ add_subdirectory(${LIBS_OPEN_PREFIX}plugins)
 #  add_subdirectory(${VIEWER_PREFIX}test_apps/llplugintest)
 #endif (NOT LINUX)
 
-if (LINUX)
-  add_subdirectory(${VIEWER_PREFIX}linux_crash_logger)
-  add_dependencies(viewer linux-crash-logger-strip-target)
-elseif (DARWIN)
-  #add_subdirectory(${VIEWER_PREFIX}mac_crash_logger)
-  #add_subdirectory(${VIEWER_PREFIX}mac_updater)
-  add_dependencies(viewer mac-crash-logger)
-  #add_dependencies(viewer mac-updater)
-elseif (WINDOWS)
-  add_subdirectory(${VIEWER_PREFIX}win_crash_logger)
-  # cmake EXISTS requires an absolute path, see indra/cmake/Variables.cmake
-  if (EXISTS ${VIEWER_DIR}win_setup)
-    add_subdirectory(${VIEWER_DIR}win_setup)
-  endif (EXISTS ${VIEWER_DIR}win_setup)
-  add_subdirectory(${VIEWER_PREFIX}win_updater)
-  add_dependencies(viewer windows-updater)
-  add_dependencies(viewer windows-crash-logger)
-elseif (SOLARIS)
-  add_subdirectory(solaris_crash_logger)
-  add_dependencies(viewer solaris-crash-logger)
-endif (LINUX)
-
 add_subdirectory(${VIEWER_PREFIX}newview/statemachine)
 add_subdirectory(${VIEWER_PREFIX}newview)
 add_dependencies(viewer secondlife-bin)

indra/aistatemachine/CMakeLists.txt

@@ -21,6 +21,7 @@ set(aistatemachine_SOURCE_FILES
     aistatemachine.cpp
     aistatemachinethread.cpp
     aitimer.cpp
+    aicondition.cpp
     )
 
 set(aistatemachine_HEADER_FILES
@@ -29,6 +30,7 @@ set(aistatemachine_HEADER_FILES
     aistatemachine.h
     aistatemachinethread.h
     aitimer.h
+    aicondition.h
     )
 
 set_source_files_properties(${aistatemachine_HEADER_FILES}

indra/aistatemachine/aicondition.cpp

@@ -0,0 +1,89 @@
+/**
+ * @file aicondition.cpp
+ * @brief Implementation of AICondition
+ *
+ * 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.
+ *
+ *   14/10/2013
+ *   Initial version, written by Aleric Inglewood @ SL
+ */
+
+#include "sys.h"
+#include "aicondition.h"
+#include "aistatemachine.h"
+
+void AIConditionBase::wait(AIStateMachine* state_machine)
+{
+  // The condition must be locked before calling AIStateMachine::wait().
+  llassert(mutex().isSelfLocked());
+  // Add the new state machine at the end.
+  mWaitingStateMachines.push_back(state_machine);
+}
+
+void AIConditionBase::remove(AIStateMachine* state_machine)
+{
+  mutex().lock();
+  // Remove all occurances of state_machine from the queue.
+  queue_t::iterator const end = mWaitingStateMachines.end();
+  queue_t::iterator last = end;
+  for (queue_t::iterator iter = mWaitingStateMachines.begin(); iter != last; ++iter)
+  {
+	if (iter->get() == state_machine)
+	{
+	  if (--last == iter)
+	  {
+		break;
+	  }
+	  queue_t::value_type::swap(*iter, *last);
+	}
+  }
+  // This invalidates all iterators involved, including end, but not any iterators to the remaining elements.
+  mWaitingStateMachines.erase(last, end);
+  mutex().unlock();
+}
+
+void AIConditionBase::signal(int n)
+{
+  // The condition must be locked before calling AICondition::signal or AICondition::broadcast.
+  llassert(mutex().isSelfLocked());
+  // Signal n state machines.
+  while (n > 0 && !mWaitingStateMachines.empty())
+  {
+	LLPointer<AIStateMachine> state_machine = mWaitingStateMachines.front();
+	bool success = state_machine->signalled();
+	// Only state machines that are actually still blocked should be in the queue:
+	// they are removed from the queue by calling AICondition::remove whenever
+	// they are unblocked for whatever reason...
+	llassert(success);
+	if (success)
+	{
+	  ++n;
+	}
+	else
+	{
+	  // We never get here...
+	  remove(state_machine.get());
+	}
+  }
+}
+

indra/aistatemachine/aicondition.h

@@ -0,0 +1,110 @@
+/**
+ * @file aicondition.h
+ * @brief Condition variable for statemachines.
+ *
+ * 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.
+ *
+ *   14/10/2013
+ *   Initial version, written by Aleric Inglewood @ SL
+ */
+
+#ifndef AICONDITION_H
+#define AICONDITION_H
+
+#include <deque>
+#include <llpointer.h>
+#include "aithreadsafe.h"
+
+class AIStateMachine;
+class LLMutex;
+
+// class AICondition
+//
+// Call AIStateMachine::wait(AICondition&) in the multiplex_impl of a state machine to
+// make the state machine go idle until some thread calls AICondition::signal().
+//
+// If the state machine is no longer running or wasn't waiting anymore because
+// something else woke it up, then AICondition::signal() will wake up another
+// state machine (if any).
+//
+// Usage:
+//
+// struct Foo { bool met(); };	// Returns true when the condition is met.
+// AICondition<Foo> Condition_t;
+// AIAccess<Foo> Condition_wat;
+//
+// // Some thread-safe condition variable.
+// Condition_t condition;
+//
+// // Inside the state machine:
+// {
+//   ...
+//   state WAIT_FOR_CONDITION:
+//   {
+//     // Lock condition and check it. Wait if condition is not met yet.
+//     {
+//       Condition_wat condition_w(condition);
+//       if (!condition_w->met())
+//       {
+//         wait(condition);
+//         break;
+//       }
+//     }
+//     set_state(CONDITION_MET);
+//     break;
+//   }
+//   CONDITION_MET:
+//   {
+//
+
+class AIConditionBase
+{
+  public:
+	virtual ~AIConditionBase() { }
+
+	void signal(int n = 1);											// Call this when the condition was met to release n state machines.
+	void broadcast(void) { signal(mWaitingStateMachines.size()); }	// Release all blocked state machines.
+
+  private:
+	// These functions are called by AIStateMachine.
+	friend class AIStateMachine;
+	void wait(AIStateMachine* state_machine);
+	void remove(AIStateMachine* state_machine);
+
+  protected:
+	virtual LLMutex& mutex(void)  = 0;
+
+  protected:
+	typedef std::deque<LLPointer<AIStateMachine> > queue_t;
+	queue_t mWaitingStateMachines;
+};
+
+template<typename T>
+class AICondition : public AIThreadSafeSimpleDC<T>, public AIConditionBase
+{
+  protected:
+	/*virtual*/ LLMutex& mutex(void) { return this->mMutex; }
+};
+
+#endif
+

indra/aistatemachine/aistatemachine.cpp

@@ -33,6 +33,7 @@
 
 #include "linden_common.h"
 #include "aistatemachine.h"
+#include "aicondition.h"
 #include "lltimer.h"
 
 //==================================================================
@@ -283,7 +284,7 @@ char const* HelloWorld::state_str_impl(state_type run_state) const
 
 void AIEngine::add(AIStateMachine* state_machine)
 {
-  Dout(dc::statemachine, "Adding state machine [" << (void*)state_machine << "] to " << mName);
+  Dout(dc::statemachine(state_machine->mSMDebug), "Adding state machine [" << (void*)state_machine << "] to " << mName);
   engine_state_type_wat engine_state_w(mEngineState);
   engine_state_w->list.push_back(QueueElement(state_machine));
   if (engine_state_w->waiting)
@@ -292,7 +293,36 @@ void AIEngine::add(AIStateMachine* state_machine)
   }
 }
 
-extern void print_statemachine_diagnostics(U64 total_clocks, U64 max_delta, AIEngine::queued_type::const_reference slowest_state_machine);
+#if STATE_MACHINE_PROFILING
+// Called from AIStateMachine::mainloop
+void print_statemachine_diagnostics(U64 total_clocks, AIStateMachine::StateTimerBase::TimeData& slowest_timer, AIEngine::queued_type::const_reference slowest_element)
+{
+	AIStateMachine const& slowest_state_machine = slowest_element.statemachine();
+	F64 const tfactor = 1000 / calc_clock_frequency();
+	std::ostringstream msg;
+
+	U64 max_delta = slowest_timer.GetDuration();
+
+	if (total_clocks > max_delta)
+	{
+		msg << "AIStateMachine::mainloop did run for " << (total_clocks * tfactor) << " ms. The slowest ";
+	}
+	else
+	{
+		msg << "AIStateMachine::mainloop: A ";
+	}
+	msg << "state machine " << "(" << slowest_state_machine.getName() << ") " << "ran for " << (max_delta * tfactor) << " ms";
+	if (slowest_state_machine.getRuntime() > max_delta)
+	{
+		msg << " (" << (slowest_state_machine.getRuntime() * tfactor) << " ms in total now)";
+	}
+	msg << ".\n";
+
+	AIStateMachine::StateTimerBase::DumpTimers(msg);
+
+	llwarns << msg.str() << llendl;
+}
+#endif
 
 // MAIN-THREAD
 void AIEngine::mainloop(void)
@@ -304,33 +334,38 @@ void AIEngine::mainloop(void)
 	queued_element = engine_state_w->list.begin();
   }
   U64 total_clocks = 0;
-#ifndef LL_RELEASE_FOR_DOWNLOAD
+#if STATE_MACHINE_PROFILING
-  U64 max_delta = 0;
   queued_type::value_type slowest_element(NULL);
+  AIStateMachine::StateTimerRoot::TimeData slowest_timer;
 #endif
   while (queued_element != end)
   {
 	AIStateMachine& state_machine(queued_element->statemachine());
-	U64 start = get_clock_count();
+	AIStateMachine::StateTimerBase::TimeData time_data;
-	if (!state_machine.sleep(start))
+	if (!state_machine.sleep(get_clock_count()))
 	{
-	  state_machine.multiplex(AIStateMachine::normal_run);
+		AIStateMachine::StateTimerRoot timer(state_machine.getName());
+		state_machine.multiplex(AIStateMachine::normal_run);
+		time_data = timer.GetTimerData();
 	}
-	U64 delta = get_clock_count() - start;
+	if (U64 delta = time_data.GetDuration())
-	state_machine.add(delta);
-	total_clocks += delta;
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-	if (delta > max_delta)
 	{
-	  max_delta = delta;
+		state_machine.add(delta);
-	  slowest_element = *queued_element;
+		total_clocks += delta;
-	}
+#if STATE_MACHINE_PROFILING
+		if (delta > slowest_timer.GetDuration())
+		{
+			slowest_element = *queued_element;
+			slowest_timer = time_data;
+		}
 #endif
+	}
+
 	bool active = state_machine.active(this);		// This locks mState shortly, so it must be called before locking mEngineState because add() locks mEngineState while holding mState.
 	engine_state_type_wat engine_state_w(mEngineState);
 	if (!active)
 	{
-	  Dout(dc::statemachine, "Erasing state machine [" << (void*)&state_machine << "] from " << mName);
+	  Dout(dc::statemachine(state_machine.mSMDebug), "Erasing state machine [" << (void*)&state_machine << "] from " << mName);
 	  engine_state_w->list.erase(queued_element++);
 	}
 	else
@@ -339,8 +374,8 @@ void AIEngine::mainloop(void)
 	}
 	if (total_clocks >= sMaxCount)
 	{
-#ifndef LL_RELEASE_FOR_DOWNLOAD
+#if STATE_MACHINE_PROFILING
-	  print_statemachine_diagnostics(total_clocks, max_delta, slowest_element);
+		print_statemachine_diagnostics(total_clocks, slowest_timer, slowest_element);
 #endif
 	  Dout(dc::statemachine, "Sorting " << engine_state_w->list.size() << " state machines.");
 	  engine_state_w->list.sort(QueueElementComp());
@@ -372,7 +407,7 @@ void AIEngine::setMaxCount(F32 StateMachineMaxTime)
   sMaxCount = calc_clock_frequency() * StateMachineMaxTime / 1000;
 }
 
-#if defined(CWDEBUG) || defined(DEBUG_CURLIO)
+#ifdef CWDEBUG
 char const* AIStateMachine::event_str(event_type event)
 {
   switch(event)
@@ -392,7 +427,7 @@ void AIStateMachine::multiplex(event_type event)
   // If this fails then you are using a pointer to a state machine instead of an LLPointer.
   llassert(event == initial_run || getNumRefs() > 0);
 
-  DoutEntering(dc::statemachine, "AIStateMachine::multiplex(" << event_str(event) << ") [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::multiplex(" << event_str(event) << ") [" << (void*)this << "]");
 
   base_state_type state;
   state_type run_state;
@@ -407,7 +442,7 @@ void AIStateMachine::multiplex(event_type event)
 	llassert(!mMultiplexMutex.isSelfLocked());		// We may never enter recursively!
 	if (!mMultiplexMutex.tryLock())
 	{
-	  Dout(dc::statemachine, "Leaving because it is already being run [" << (void*)this << "]");
+	  Dout(dc::statemachine(mSMDebug), "Leaving because it is already being run [" << (void*)this << "]");
 	  return;
 	}
 
@@ -421,7 +456,7 @@ void AIStateMachine::multiplex(event_type event)
 	// we should indeed run, again.
 	if (event == schedule_run && !sub_state_type_rat(mSubState)->need_run)
 	{
-	  Dout(dc::statemachine, "Leaving because it was already being run [" << (void*)this << "]");
+	  Dout(dc::statemachine(mSMDebug), "Leaving because it was already being run [" << (void*)this << "]");
 	  return;
 	}
 
@@ -440,9 +475,9 @@ void AIStateMachine::multiplex(event_type event)
 	{
 #ifdef CWDEBUG
 	  if (state == bs_multiplex)
-		Dout(dc::statemachine, "Running state bs_multiplex / " << state_str_impl(run_state) << " [" << (void*)this << "]");
+		Dout(dc::statemachine(mSMDebug), "Running state bs_multiplex / " << state_str_impl(run_state) << " [" << (void*)this << "]");
 	  else
-		Dout(dc::statemachine, "Running state " << state_str(state) << " [" << (void*)this << "]");
+		Dout(dc::statemachine(mSMDebug), "Running state " << state_str(state) << " [" << (void*)this << "]");
 #endif
 
 #ifdef SHOW_ASSERT
@@ -503,7 +538,7 @@ void AIStateMachine::multiplex(event_type event)
 		// run of bs_reset is not a problem because it happens to be a NoOp.
 		state = (state == bs_initialize) ? bs_reset : bs_abort;
 #ifdef CWDEBUG
-		Dout(dc::statemachine, "Late abort detected! Running state " << state_str(state) << " instead [" << (void*)this << "]");
+		Dout(dc::statemachine(mSMDebug), "Late abort detected! Running state " << state_str(state) << " instead [" << (void*)this << "]");
 #endif
 	  }
 #ifdef SHOW_ASSERT
@@ -665,7 +700,7 @@ void AIStateMachine::multiplex(event_type event)
 
 #ifdef CWDEBUG
 		if (state != state_w->base_state)
-		  Dout(dc::statemachine, "Base state changed from " << state_str(state) << " to " << state_str(state_w->base_state) <<
+		  Dout(dc::statemachine(mSMDebug), "Base state changed from " << state_str(state) << " to " << state_str(state_w->base_state) <<
 			  "; need_new_run = " << (need_new_run ? "true" : "false") << " [" << (void*)this << "]");
 #endif
 	  }
@@ -699,11 +734,15 @@ void AIStateMachine::multiplex(event_type event)
 			// Mark that we're added to this engine, and at the same time, that we're not added to the previous one.
 			state_w->current_engine = engine;
 		  }
+#ifdef SHOW_ASSERT
+		  // We are leaving the loop, but we're not idle. The statemachine should re-enter the loop again.
+		  mDebugShouldRun = true;
+#endif
 		}
 		else
 		{
-		  // Remove this state machine from any engine.
+		  // Remove this state machine from any engine,
-		  // Cause the engine to remove us.
+		  // causing the engine to remove us.
 		  state_w->current_engine = NULL;
 		}
 
@@ -747,9 +786,25 @@ void AIStateMachine::multiplex(event_type event)
   }
 }
 
+#if STATE_MACHINE_PROFILING
+std::vector<AIStateMachine::StateTimerBase*> AIStateMachine::StateTimerBase::mTimerStack;
+AIStateMachine::StateTimerBase::TimeData AIStateMachine::StateTimerBase::TimeData::sRoot("");
+void AIStateMachine::StateTimer::TimeData::DumpTimer(std::ostringstream& msg, std::string prefix)
+{
+	F64 const tfactor = 1000 / calc_clock_frequency();
+	msg << prefix << mName << " " << (mEnd - mStart)*tfactor << "ms" << std::endl;
+	prefix.push_back(' ');
+	std::vector<TimeData>::iterator it;
+	for (it = mChildren.begin(); it != mChildren.end(); ++it)
+	{
+		it->DumpTimer(msg, prefix);
+	}
+}
+#endif
+
 AIStateMachine::state_type AIStateMachine::begin_loop(base_state_type base_state)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::begin_loop(" << state_str(base_state) << ") [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::begin_loop(" << state_str(base_state) << ") [" << (void*)this << "]");
 
   sub_state_type_wat sub_state_w(mSubState);
   // Honor a subsequent call to idle() (only necessary in bs_multiplex, but it doesn't hurt to reset this flag in other states too).
@@ -759,7 +814,7 @@ AIStateMachine::state_type AIStateMachine::begin_loop(base_state_type base_state
   // Honor previous calls to advance_state() (once run_state is initialized).
   if (base_state == bs_multiplex && sub_state_w->advance_state > sub_state_w->run_state)
   {
-	Dout(dc::statemachine, "Copying advance_state to run_state, because it is larger [" << state_str_impl(sub_state_w->advance_state) << " > " << state_str_impl(sub_state_w->run_state) << "]");
+	Dout(dc::statemachine(mSMDebug), "Copying advance_state to run_state, because it is larger [" << state_str_impl(sub_state_w->advance_state) << " > " << state_str_impl(sub_state_w->run_state) << "]");
 	sub_state_w->run_state = sub_state_w->advance_state;
   }
 #ifdef SHOW_ASSERT
@@ -789,7 +844,7 @@ AIStateMachine::state_type AIStateMachine::begin_loop(base_state_type base_state
 
 void AIStateMachine::run(AIStateMachine* parent, state_type new_parent_state, bool abort_parent, bool on_abort_signal_parent, AIEngine* default_engine)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::run(" <<
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::run(" <<
 	  (void*)parent << ", " <<
 	  (parent ? parent->state_str_impl(new_parent_state) : "NA") <<
 	  ", abort_parent = " << (abort_parent ? "true" : "false") <<
@@ -839,7 +894,7 @@ void AIStateMachine::run(AIStateMachine* parent, state_type new_parent_state, bo
 
 void AIStateMachine::run(callback_type::signal_type::slot_type const& slot, AIEngine* default_engine)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::run(<slot>, default_engine = " << default_engine->name() << ") [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::run(<slot>, default_engine = " << default_engine->name() << ") [" << (void*)this << "]");
 
 #ifdef SHOW_ASSERT
   {
@@ -874,7 +929,7 @@ void AIStateMachine::run(callback_type::signal_type::slot_type const& slot, AIEn
 
 void AIStateMachine::callback(void)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::callback() [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::callback() [" << (void*)this << "]");
 
   bool aborted = sub_state_type_rat(mSubState)->aborted;
   if (mParent)
@@ -920,7 +975,7 @@ void AIStateMachine::force_killed(void)
 
 void AIStateMachine::kill(void)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::kill() [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::kill() [" << (void*)this << "]");
 #ifdef SHOW_ASSERT
   {
 	multiplex_state_type_rat state_r(mState);
@@ -937,7 +992,7 @@ void AIStateMachine::kill(void)
 
 void AIStateMachine::reset()
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::reset() [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::reset() [" << (void*)this << "]");
 #ifdef SHOW_ASSERT
   mDebugAborted = false;
   mDebugContPending = false;
@@ -960,6 +1015,8 @@ void AIStateMachine::reset()
 	sub_state_w->reset = true;
 	// Start running.
 	sub_state_w->idle = false;
+	// We're not waiting for a condition.
+	sub_state_w->blocked = NULL;
 	// Keep running till we reach at least bs_multiplex.
 	sub_state_w->need_run = true;
   }
@@ -972,7 +1029,7 @@ void AIStateMachine::reset()
 
 void AIStateMachine::set_state(state_type new_state)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::set_state(" << state_str_impl(new_state) << ") [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::set_state(" << state_str_impl(new_state) << ") [" << (void*)this << "]");
 #ifdef SHOW_ASSERT
   {
 	multiplex_state_type_rat state_r(mState);
@@ -983,6 +1040,8 @@ void AIStateMachine::set_state(state_type new_state)
   }
 #endif
   sub_state_type_wat sub_state_w(mSubState);
+  // It should never happen that set_state() is called while we're blocked.
+  llassert(!sub_state_w->blocked);
   // Force current state to the requested state.
   sub_state_w->run_state = new_state;
   // Void last call to advance_state.
@@ -999,13 +1058,13 @@ void AIStateMachine::set_state(state_type new_state)
 
 void AIStateMachine::advance_state(state_type new_state)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::advance_state(" << state_str_impl(new_state) << ") [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::advance_state(" << state_str_impl(new_state) << ") [" << (void*)this << "]");
   {
 	sub_state_type_wat sub_state_w(mSubState);
 	// Ignore call to advance_state when the currently queued state is already greater or equal to the requested state.
 	if (sub_state_w->advance_state >= new_state)
 	{
-	  Dout(dc::statemachine, "Ignored, because " << state_str_impl(sub_state_w->advance_state) << " >= " << state_str_impl(new_state) << ".");
+	  Dout(dc::statemachine(mSMDebug), "Ignored, because " << state_str_impl(sub_state_w->advance_state) << " >= " << state_str_impl(new_state) << ".");
 	  return;
 	}
 	// Ignore call to advance_state when the current state is greater than the requested state: the new state would be
@@ -1014,7 +1073,7 @@ void AIStateMachine::advance_state(state_type new_state)
 	// the state change is and should be being ignored: the statemachine would start running it's current state (again).
 	if (sub_state_w->run_state > new_state)
 	{
-	  Dout(dc::statemachine, "Ignored, because " << state_str_impl(sub_state_w->run_state) << " > " << state_str_impl(new_state) << " (current state).");
+	  Dout(dc::statemachine(mSMDebug), "Ignored, because " << state_str_impl(sub_state_w->run_state) << " > " << state_str_impl(new_state) << " (current state).");
 	  return;
 	}
 	// Increment state.
@@ -1023,6 +1082,13 @@ void AIStateMachine::advance_state(state_type new_state)
 	sub_state_w->idle = false;
 	// Ignore a call to idle if it occurs before we leave multiplex_impl().
 	sub_state_w->skip_idle = true;
+	// No longer say we woke up when signalled() is called.
+	if (sub_state_w->blocked)
+	{
+	  Dout(dc::statemachine(mSMDebug), "Removing statemachine from condition " << (void*)sub_state_w->blocked);
+	  sub_state_w->blocked->remove(this);
+	  sub_state_w->blocked = NULL;
+	}
 	// Mark that a re-entry of multiplex() is necessary.
 	sub_state_w->need_run = true;
 #ifdef SHOW_ASSERT
@@ -1048,7 +1114,7 @@ void AIStateMachine::advance_state(state_type new_state)
 
 void AIStateMachine::idle(void)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::idle() [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::idle() [" << (void*)this << "]");
 #ifdef SHOW_ASSERT
   {
 	multiplex_state_type_rat state_r(mState);
@@ -1066,7 +1132,7 @@ void AIStateMachine::idle(void)
   // Ignore call to idle() when advance_state() was called since last call to set_state().
   if (sub_state_w->skip_idle)
   {
-	Dout(dc::statemachine, "Ignored, because skip_idle is true (advance_state() was called last).");
+	Dout(dc::statemachine(mSMDebug), "Ignored, because skip_idle is true (advance_state() was called last).");
 	return;
   }
   // Mark that we are idle.
@@ -1075,13 +1141,54 @@ void AIStateMachine::idle(void)
   mSleep = 0;
 }
 
+// This function is very much like idle().
+void AIStateMachine::wait(AIConditionBase& condition)
+{
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::wait(" << (void*)&condition << ") [" << (void*)this << "]");
+#ifdef SHOW_ASSERT
+  {
+	multiplex_state_type_rat state_r(mState);
+	// wait() may only be called multiplex_impl().
+	llassert(state_r->base_state == bs_multiplex);
+	// May only be called by the thread that is holding mMultiplexMutex.
+	llassert(mThreadId.equals_current_thread());
+  }
+  // wait() following set_state() cancels the reason to run because of the call to set_state.
+  mDebugSetStatePending = false;
+#endif
+  sub_state_type_wat sub_state_w(mSubState);
+  // As wait() may only be called from within the state machine, it should never happen that the state machine is already idle.
+  llassert(!sub_state_w->idle);
+  // Ignore call to wait() when advance_state() was called since last call to set_state().
+  if (sub_state_w->skip_idle)
+  {
+	Dout(dc::statemachine(mSMDebug), "Ignored, because skip_idle is true (advance_state() was called last).");
+	return;
+  }
+  // Register ourselves with the condition object.
+  condition.wait(this);
+  // Mark that we are idle.
+  sub_state_w->idle = true;
+  // Mark that we are waiting for a condition.
+  sub_state_w->blocked = &condition;
+  // Not sleeping (anymore).
+  mSleep = 0;
+}
+
 void AIStateMachine::cont(void)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::cont() [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::cont() [" << (void*)this << "]");
   {
 	sub_state_type_wat sub_state_w(mSubState);
 	// Void last call to idle(), if any.
 	sub_state_w->idle = false;
+	// No longer say we woke up when signalled() is called.
+	if (sub_state_w->blocked)
+	{
+	  Dout(dc::statemachine(mSMDebug), "Removing statemachine from condition " << (void*)sub_state_w->blocked);
+	  sub_state_w->blocked->remove(this);
+	  sub_state_w->blocked = NULL;
+	}
 	// Mark that a re-entry of multiplex() is necessary.
 	sub_state_w->need_run = true;
 #ifdef SHOW_ASSERT
@@ -1095,15 +1202,56 @@ void AIStateMachine::cont(void)
   }
 }
 
+// This function is very much like cont(), except that it has no effect when we are not in a blocked state.
+// Returns true if the state machine was unblocked, false if it was already unblocked.
+bool AIStateMachine::signalled(void)
+{
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::signalled() [" << (void*)this << "]");
+  {
+	sub_state_type_wat sub_state_w(mSubState);
+	// Test if we are blocked or not.
+	if (sub_state_w->blocked)
+	{
+	  Dout(dc::statemachine(mSMDebug), "Removing statemachine from condition " << (void*)sub_state_w->blocked);
+	  sub_state_w->blocked->remove(this);
+	  sub_state_w->blocked = NULL;
+	}
+	else
+	{
+	  return false;
+	}
+	// Void last call to wait().
+	sub_state_w->idle = false;
+	// Mark that a re-entry of multiplex() is necessary.
+	sub_state_w->need_run = true;
+#ifdef SHOW_ASSERT
+	// From this moment.
+	mDebugContPending = true;
+#endif
+  }
+  if (!mMultiplexMutex.isSelfLocked())
+  {
+	multiplex(schedule_run);
+  }
+  return true;
+}
+
 void AIStateMachine::abort(void)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::abort() [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::abort() [" << (void*)this << "]");
   bool is_waiting = false;
   {
 	multiplex_state_type_rat state_r(mState);
 	sub_state_type_wat sub_state_w(mSubState);
 	// Mark that we are aborted, iff we didn't already finish.
 	sub_state_w->aborted = !sub_state_w->finished;
+	// No longer say we woke up when signalled() is called.
+	if (sub_state_w->blocked)
+	{
+	  Dout(dc::statemachine(mSMDebug), "Removing statemachine from condition " << (void*)sub_state_w->blocked);
+	  sub_state_w->blocked->remove(this);
+	  sub_state_w->blocked = NULL;
+	}
 	// Mark that a re-entry of multiplex() is necessary.
 	sub_state_w->need_run = true;
 	// Schedule a new run when this state machine is waiting.
@@ -1128,7 +1276,7 @@ void AIStateMachine::abort(void)
 
 void AIStateMachine::finish(void)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::finish() [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::finish() [" << (void*)this << "]");
 #ifdef SHOW_ASSERT
   {
 	multiplex_state_type_rat state_r(mState);
@@ -1147,7 +1295,7 @@ void AIStateMachine::finish(void)
 
 void AIStateMachine::yield(void)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::yield() [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::yield() [" << (void*)this << "]");
   multiplex_state_type_rat state_r(mState);
   // yield() may only be called from multiplex_impl().
   llassert(state_r->base_state == bs_multiplex);
@@ -1160,7 +1308,7 @@ void AIStateMachine::yield(void)
 void AIStateMachine::yield(AIEngine* engine)
 {
   llassert(engine);
-  DoutEntering(dc::statemachine, "AIStateMachine::yield(" << engine->name() << ") [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::yield(" << engine->name() << ") [" << (void*)this << "]");
 #ifdef SHOW_ASSERT
   {
 	multiplex_state_type_rat state_r(mState);
@@ -1173,9 +1321,19 @@ void AIStateMachine::yield(AIEngine* engine)
   mYieldEngine = engine;
 }
 
+bool AIStateMachine::yield_if_not(AIEngine* engine)
+{
+  if (engine && multiplex_state_type_rat(mState)->current_engine != engine)
+  {
+	yield(engine);
+	return true;
+  }
+  return false;
+}
+
 void AIStateMachine::yield_frame(unsigned int frames)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::yield_frame(" << frames << ") [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::yield_frame(" << frames << ") [" << (void*)this << "]");
   mSleep = -(S64)frames;
   // Sleeping is always done from the main thread.
   yield(&gMainThreadEngine);
@@ -1183,7 +1341,7 @@ void AIStateMachine::yield_frame(unsigned int frames)
 
 void AIStateMachine::yield_ms(unsigned int ms)
 {
-  DoutEntering(dc::statemachine, "AIStateMachine::yield_ms(" << ms << ") [" << (void*)this << "]");
+  DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::yield_ms(" << ms << ") [" << (void*)this << "]");
   mSleep = get_clock_count() + calc_clock_frequency() * ms / 1000;
   // Sleeping is always done from the main thread.
   yield(&gMainThreadEngine);
@@ -1233,7 +1391,7 @@ void AIEngine::threadloop(void)
 	engine_state_type_wat engine_state_w(mEngineState);
 	if (!active)
 	{
-	  Dout(dc::statemachine, "Erasing state machine [" << (void*)&state_machine << "] from " << mName);
+	  Dout(dc::statemachine(state_machine.mSMDebug), "Erasing state machine [" << (void*)&state_machine << "] from " << mName);
 	  engine_state_w->list.erase(queued_element++);
 	}
 	else

indra/aistatemachine/aistatemachine.h

@@ -36,9 +36,11 @@
 
 #include "aithreadsafe.h"
 #include <llpointer.h>
+#include "lltimer.h"
 #include <list>
 #include <boost/signals2.hpp>
 
+class AIConditionBase;
 class AIStateMachine;
 
 class AIEngine
@@ -97,11 +99,143 @@ class AIEngine
 extern AIEngine gMainThreadEngine;
 extern AIEngine gStateMachineThreadEngine;
 
+#ifndef STATE_MACHINE_PROFILING
+#ifndef LL_RELEASE_FOR_DOWNLOAD
+#define STATE_MACHINE_PROFILING 1
+#endif
+#endif
+
 class AIStateMachine : public LLThreadSafeRefCount
 {
   public:
 	typedef U32 state_type;		//!< The type of run_state
 
+	// A simple timer class that will calculate time delta between ctor and GetTimerData call.
+	// Time data is stored as a nested TimeData object.
+	// If STATE_MACHINE_PROFILING is defined then a stack of all StateTimers from root is maintained for debug output.
+	class StateTimerBase
+	{
+	public:
+		class TimeData
+		{
+			friend class StateTimerBase;
+		public:
+			TimeData() : mStart(-1), mEnd(-1) {}
+			U64 GetDuration() {	return mEnd - mStart; }
+		private:
+			U64 mStart, mEnd;
+
+#if !STATE_MACHINE_PROFILING
+			TimeData(const std::string& name) : mStart(get_clock_count()), mEnd(get_clock_count()) {}
+#else
+			TimeData(const std::string& name) : mName(name), mStart(get_clock_count()), mEnd(get_clock_count()) {}
+			void DumpTimer(std::ostringstream& msg, std::string prefix);
+			std::vector<TimeData> mChildren;
+			std::string mName;	
+			static TimeData sRoot;
+#endif
+		};
+#if !STATE_MACHINE_PROFILING
+		StateTimerBase(const std::string& name) : mData(name) {}
+		~StateTimerBase() {}
+	protected:
+		TimeData mData;
+		// Return a copy of the underlying timer data.
+		// This allows the data live beyond the scope of the state timer.
+	public:
+		const TimeData GetTimerData()
+		{
+			mData.mEnd = get_clock_count();	//set mEnd to current time, since GetTimerData() will always be called before the dtor, obv.
+			return mData;
+		}
+#else
+	protected:
+		// Ctors/dtors are hidden. Only StateTimerRoot and StateTimer are permitted to access them.
+		StateTimerBase() : mData(NULL) {}
+		~StateTimerBase()
+		{
+			// If mData is null then the timer was not registered due to being in the wrong thread or the root timer wasn't in the expected state.
+			if (!mData)
+				return;
+			mData->mEnd = get_clock_count();
+			mTimerStack.pop_back();
+		}
+
+		// Also hide internals from everything except StateTimerRoot and StateTimer
+		bool AddAsRoot(const std::string& name)
+		{
+			
+			if (!is_main_thread())
+				return true;	//Ignoring this timer, but pretending it was added.
+			if (!mTimerStack.empty())
+				return false;
+			TimeData::sRoot = TimeData(name);
+			mData = &TimeData::sRoot;
+			mData->mChildren.clear();	
+			mTimerStack.push_back(this);
+			return true;
+		}
+		bool AddAsChild(const std::string& name)
+		{
+			if (!is_main_thread())
+				return true;	//Ignoring this timer, but pretending it was added.
+			if (mTimerStack.empty())
+				return false;
+			mTimerStack.back()->mData->mChildren.push_back(TimeData(name));
+			mData = &mTimerStack.back()->mData->mChildren.back();
+			mTimerStack.push_back(this);
+			return true;
+		}
+
+		TimeData* mData;
+		static std::vector<StateTimerBase*> mTimerStack;
+
+	public:
+		// Debug spew
+		static void DumpTimers(std::ostringstream& msg)
+		{
+			TimeData::sRoot.DumpTimer(msg, "");
+		}
+
+		// Return a copy of the underlying timer data.
+		// This allows the data live beyond the scope of the state timer.
+		const TimeData GetTimerData() const
+		{
+			if (mData)
+			{
+				TimeData ret = *mData;
+				ret.mEnd = get_clock_count();	//set mEnd to current time, since GetTimerData() will always be called before the dtor, obv.
+				return ret;
+			}
+			return TimeData();
+		}
+#endif
+	};
+public:
+#if !STATE_MACHINE_PROFILING
+	typedef StateTimerBase StateTimerRoot;
+	typedef StateTimerBase StateTimer;
+#else
+	class StateTimerRoot : public StateTimerBase
+	{ //A StateTimerRoot can become a child if a root already exists.
+	public:
+		StateTimerRoot(const std::string& name)
+		{
+			if(!AddAsRoot(name))
+				AddAsChild(name);	
+		}
+	};
+	class StateTimer : public StateTimerBase
+	{ //A StateTimer can never become a root
+	public:
+		StateTimer(const std::string& name)
+		{
+			AddAsChild(name);
+		}
+	};
+#endif
+
+
   protected:
 	// The type of event that causes multiplex() to be called.
 	enum event_type {
@@ -132,6 +266,7 @@ class AIStateMachine : public LLThreadSafeRefCount
 	struct sub_state_type {
 	  state_type		run_state;
 	  state_type		advance_state;
+	  AIConditionBase*	blocked;
 	  bool				reset;
 	  bool				need_run;
 	  bool				idle;
@@ -195,20 +330,36 @@ class AIStateMachine : public LLThreadSafeRefCount
 	bool mDebugAdvanceStatePending;				// True while advance_state() was called by not handled yet.
 	bool mDebugRefCalled;						// True when ref() is called (or will be called within the critial area of mMultiplexMutex).
 #endif
+#ifdef CWDEBUG
+  protected:
+	bool mSMDebug;								// Print debug output only when true.
+#endif
+  private:
 	U64 mRuntime;								// Total time spent running in the main thread (in clocks).
 
   public:
-	AIStateMachine(void) : mCallback(NULL), mDefaultEngine(NULL), mYieldEngine(NULL),
+	AIStateMachine(CWD_ONLY(bool debug)) : mCallback(NULL), mDefaultEngine(NULL), mYieldEngine(NULL),
 #ifdef SHOW_ASSERT
 		mThreadId(AIThreadID::none), mDebugLastState(bs_killed), mDebugShouldRun(false), mDebugAborted(false), mDebugContPending(false),
 		mDebugSetStatePending(false), mDebugAdvanceStatePending(false), mDebugRefCalled(false),
+#endif
+#ifdef CWDEBUG
+		mSMDebug(debug),
 #endif
 		mRuntime(0)
 	{ }
 
   protected:
-	// The user should call finish() (or abort(), or kill() from the call back when finish_impl() calls run()), not delete a class derived from AIStateMachine directly.
+	// The user should call finish() (or abort(), or kill() from the call back when finish_impl() calls run()),
-	virtual ~AIStateMachine() { llassert(multiplex_state_type_rat(mState)->base_state == bs_killed); }
+	// not delete a class derived from AIStateMachine directly. Deleting it directly before calling run() is
+	// ok however.
+	virtual ~AIStateMachine()
+	{
+#ifdef SHOW_ASSERT
+	  base_state_type state = multiplex_state_type_rat(mState)->base_state;
+	  llassert(state == bs_killed || state == bs_reset);
+#endif
+	}
  
   public:
 	// These functions may be called directly after creation, or from within finish_impl(), or from the call back function.
@@ -224,11 +375,13 @@ class AIStateMachine : public LLThreadSafeRefCount
 	void set_state(state_type new_state);									// Run this state the NEXT loop.
 	// These functions can only be called from within multiplex_impl().
 	void idle(void);														// Go idle unless cont() or advance_state() were called since the start of the current loop, or until they are called.
+	void wait(AIConditionBase& condition);									// The same as idle(), but wake up when AICondition<T>::signal() is called.
 	void finish(void);														// Mark that the state machine finished and schedule the call back.
 	void yield(void);														// Yield to give CPU to other state machines, but do not go idle.
 	void yield(AIEngine* engine);											// Yield to give CPU to other state machines, but do not go idle. Continue running from engine 'engine'.
 	void yield_frame(unsigned int frames);									// Run from the main-thread engine after at least 'frames' frames have passed.
 	void yield_ms(unsigned int ms);											// Run from the main-thread engine after roughly 'ms' miliseconds have passed.
+	bool yield_if_not(AIEngine* engine);									// Do not really yield, unless the current engine is not 'engine'. Returns true if it switched engine.
 
   public:
 	// This function can be called from multiplex_imp(), but also by a child state machine and
@@ -236,11 +389,12 @@ class AIStateMachine : public LLThreadSafeRefCount
 	// to access this state machine.
 	void abort(void);														// Abort the state machine (unsuccessful finish).
 
-	// These are the only two functions that can be called by any thread at any moment.
+	// These are the only three functions that can be called by any thread at any moment.
 	// Those threads should use an LLPointer<AIStateMachine> to access this state machine.
 	void cont(void);														// Guarantee at least one full run of multiplex() after this function is called. Cancels the last call to idle().
 	void advance_state(state_type new_state);								// Guarantee at least one full run of multiplex() after this function is called
 																			// iff new_state is larger than the last state that was processed.
+	bool signalled(void);													// Call cont() iff this state machine is still blocked after a call to wait(). Returns false if it already unblocked.
 
   public:
 	// Accessors.
@@ -274,19 +428,23 @@ class AIStateMachine : public LLThreadSafeRefCount
 
 	// Return stringified state, for debugging purposes.
 	char const* state_str(base_state_type state);
-#if defined(CWDEBUG) || defined(DEBUG_CURLIO)
+#ifdef CWDEBUG
 	char const* event_str(event_type event);
 #endif
 
 	void add(U64 count) { mRuntime += count; }
 	U64 getRuntime(void) const { return mRuntime; }
 
+	// For diagnostics. Every derived class must override this.
+	virtual const char* getName() const = 0;
+
   protected:
 	virtual void initialize_impl(void) = 0;
 	virtual void multiplex_impl(state_type run_state) = 0;
 	virtual void abort_impl(void) { }
 	virtual void finish_impl(void) { }
 	virtual char const* state_str_impl(state_type run_state) const = 0;
+	virtual void force_killed(void);										// Called from AIEngine::flush().
 
   private:
 	void reset(void);														// Called from run() to (re)initialize a (re)start.
@@ -303,7 +461,6 @@ class AIStateMachine : public LLThreadSafeRefCount
 		mSleep = 0;
 	  return mSleep != 0;
 	}
-	void force_killed(void);												// Called from AIEngine::flush().
 
 	friend class AIEngine;						// Calls multiplex() and force_killed().
 };

indra/aistatemachine/aistatemachinethread.h

@@ -181,7 +181,11 @@ class AIStateMachineThreadBase : public AIStateMachine {
 	static state_type const max_state = wait_stopped + 1;
 
   protected:
-	AIStateMachineThreadBase(void) { }
+	AIStateMachineThreadBase(CWD_ONLY(bool debug))
+#ifdef CWDEBUG
+	  : AIStateMachine(debug)
+#endif
+	{ }
 
   private:
 	// Handle initializing the object.
@@ -217,7 +221,10 @@ class AIStateMachineThread : public AIStateMachineThreadBase {
 
   public:
 	// Constructor.
-	AIStateMachineThread(void)
+	AIStateMachineThread(CWD_ONLY(bool debug))
+#ifdef CWDEBUG
+		: AIStateMachineThreadBase(debug)
+#endif
 	{
 	  *AIThreadImpl::StateMachineThread_wat(mThreadImpl.mStateMachineThread) = this;
 	}
@@ -225,6 +232,13 @@ class AIStateMachineThread : public AIStateMachineThreadBase {
 	// Accessor.
 	THREAD_IMPL& thread_impl(void) { return mThreadImpl; }
 
+	/*virtual*/ const char* getName() const
+	{
+#define STRIZE(arg) #arg
+		return "AIStateMachineThread<"STRIZE(THREAD_IMPL)">";
+#undef STRIZE
+	}
+
   protected:
 	/*virtual*/ AIThreadImpl& impl(void) { return mThreadImpl; }
 };

indra/aistatemachine/aitimer.h

@@ -76,7 +76,11 @@ class AITimer : public AIStateMachine {
 	F64 mInterval;					//!< Input variable: interval after which the event will be generated, in seconds.
 
   public:
-	AITimer(void) : mInterval(0) { DoutEntering(dc::statemachine, "AITimer(void) [" << (void*)this << "]"); }
+	AITimer(CWD_ONLY(bool debug = false)) :
+#ifdef CWDEBUG
+		AIStateMachine(debug),
+#endif
+		mInterval(0) { DoutEntering(dc::statemachine(mSMDebug), "AITimer(void) [" << (void*)this << "]"); }
 
 	/**
 	 * @brief Set the interval after which the timer should expire.
@@ -94,9 +98,11 @@ class AITimer : public AIStateMachine {
 	 */
 	F64 getInterval(void) const { return mInterval; }
 
+	/*virtual*/ const char* getName() const { return "AITimer"; }
+
   protected:
 	// Call finish() (or abort()), not delete.
-	/*virtual*/ ~AITimer() { DoutEntering(dc::statemachine, "~AITimer() [" << (void*)this << "]"); mFrameTimer.cancel(); }
+	/*virtual*/ ~AITimer() { DoutEntering(dc::statemachine(mSMDebug), "~AITimer() [" << (void*)this << "]"); mFrameTimer.cancel(); }
 
 	// Handle initializing the object.
 	/*virtual*/ void initialize_impl(void);

indra/cmake/00-Common.cmake

@@ -12,11 +12,25 @@ include(Variables)
 
 set(CMAKE_CXX_FLAGS_DEBUG "-D_DEBUG -DLL_DEBUG=1")
 set(CMAKE_CXX_FLAGS_RELEASE
-    "-DLL_RELEASE=1 -DLL_RELEASE_FOR_DOWNLOAD=1 -D_SECURE_SCL=0 -DLL_SEND_CRASH_REPORTS=1 -DNDEBUG")
+    "-DLL_RELEASE=1 -DLL_RELEASE_FOR_DOWNLOAD=1 -D_SECURE_SCL=0 -DNDEBUG")
 set(CMAKE_C_FLAGS_RELEASE
     "${CMAKE_CXX_FLAGS_RELEASE}")
 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO 
-    "-DLL_RELEASE=1 -D_SECURE_SCL=0 -DLL_SEND_CRASH_REPORTS=0 -DNDEBUG -DLL_RELEASE_WITH_DEBUG_INFO=1")
+    "-DLL_RELEASE=1 -D_SECURE_SCL=0 -DNDEBUG -DLL_RELEASE_WITH_DEBUG_INFO=1")
+
+# Configure crash reporting
+set(RELEASE_CRASH_REPORTING OFF CACHE BOOL "Enable use of crash reporting in release builds")
+set(NON_RELEASE_CRASH_REPORTING OFF CACHE BOOL "Enable use of crash reporting in developer builds")
+
+if(RELEASE_CRASH_REPORTING)
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DLL_SEND_CRASH_REPORTS=1")
+endif()
+
+if(NON_RELEASE_CRASH_REPORTING)
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DLL_SEND_CRASH_REPORTS=1")
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DLL_SEND_CRASH_REPORTS=1")
+endif()
+
 
 # Don't bother with a MinSizeRel build.
 
@@ -32,10 +46,17 @@ if (WINDOWS)
     set(MSVC_DIR 10.0)
     set(MSVC_SUFFIX 100)
   endif (MSVC10)
+  if (MSVC11)
+    set(MSVC_DIR 11.0)
+    set(MSVC_SUFFIX 110)
+  endif (MSVC11)
 
   # Remove default /Zm1000 flag that cmake inserts
   string (REPLACE "/Zm1000" " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
+  # Always use /Zm140
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zm140")
+
   # Don't build DLLs.
   set(BUILD_SHARED_LIBS OFF)
 
@@ -64,11 +85,17 @@ if (WINDOWS)
       /W3
       /c
       /Zc:forScope
-	  /Zc:wchar_t-
+	    /Zc:wchar_t-
       /nologo
       /Oy-
-	  /arch:SSE2
       )
+  
+  # SSE2 is implied on win64
+  if(WORD_SIZE EQUAL 32)
+    add_definitions(/arch:SSE2)
+  else(WORD_SIZE EQUAL 32)
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /wd4267 /wd4250 /wd4244")
+  endif(WORD_SIZE EQUAL 32)
 
   # 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)")
@@ -103,7 +130,7 @@ if (LINUX)
       -pthread
       )
 
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -D_FORTIFY_SOURCE=2 ")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 ")
 
   # Don't catch SIGCHLD in our base application class for the viewer
   # some of our 3rd party libs may need their *own* SIGCHLD handler to work.  Sigh!
@@ -222,30 +249,28 @@ endif (LINUX)
 
 
 if (DARWIN)
-  add_definitions(-DLL_DARWIN=1 -D_XOPEN_SOURCE)
+  add_definitions(-DLL_DARWIN=1)
-  set(CMAKE_CXX_LINK_FLAGS "-Wl,-headerpad_max_install_names,-search_paths_first")
+  set(CMAKE_CXX_LINK_FLAGS "-Wl,-no_compact_unwind -Wl,-headerpad_max_install_names,-search_paths_first")
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_CXX_LINK_FLAGS}")
-
+  set(DARWIN_extra_cstar_flags "-g")
-  if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DARWIN_extra_cstar_flags} -ftemplate-depth=256")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mlong-branch")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  ${DARWIN_extra_cstar_flags}")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mlong-branch")
+  # NOTE: it's critical that the optimization flag is put in front.
-    # NOTE: it's critical that the optimization flag is put in front.
+  # NOTE: it's critical to have both CXX_FLAGS and C_FLAGS covered.
-    # NOTE: it's critical to have both CXX_FLAGS and C_FLAGS covered.
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O0 ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
+  set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O0 ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
+  set(CMAKE_XCODE_ATTRIBUTE_CLANG_X86_VECTOR_INSTRUCTIONS SSE3)
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
+  set(CMAKE_XCODE_ATTRIBUTE_GCC_OPTIMIZATION_LEVEL -O3)
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
+  set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse3 ${CMAKE_CXX_FLAGS_RELEASE}")
-  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  set(CMAKE_C_FLAGS_RELEASE "-O3 -msse3 ${CMAKE_C_FLAGS_RELEASE}")
-    # NOTE: it's critical that the optimization flag is put in front.
+  if (XCODE_VERSION GREATER 4.2)
-    # NOTE: it's critical to have both CXX_FLAGS and C_FLAGS covered.
+    set(ENABLE_SIGNING TRUE)
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -msse3")
+    set(SIGNING_IDENTITY "Developer ID Application: Linden Research, Inc.")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -msse3")
+  endif (XCODE_VERSION GREATER 4.2)
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -msse3")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3 -msse3")
-  endif()
 endif (DARWIN)
 
 
+
 if (LINUX OR DARWIN)
   if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     add_definitions(-DLL_GNUC=1)
@@ -253,13 +278,11 @@ if (LINUX OR DARWIN)
     set(UNIX_CXX_WARNINGS "${UNIX_WARNINGS} -Wno-reorder -Wno-non-virtual-dtor -Woverloaded-virtual")
   elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
     add_definitions(-DLL_CLANG=1)
-    set(UNIX_WARNINGS "-Wall -Wno-sign-compare -Wno-trigraphs -Wno-tautological-compare -Wno-char-subscripts -Wno-gnu -Wno-logical-op-parentheses -Wno-non-virtual-dtor")
+    set(UNIX_WARNINGS "-Wall -Wno-sign-compare -Wno-trigraphs -Wno-tautological-compare -Wno-char-subscripts -Wno-gnu -Wno-logical-op-parentheses -Wno-logical-not-parentheses -Wno-non-virtual-dtor -Wno-deprecated")
-    set(UNIX_WARNINGS "${UNIX_WARNINGS} -Woverloaded-virtual -Wno-parentheses-equality -Wno-reorder -Wno-unused-function -Wno-unused-value -Wno-unused-variable")
+    set(UNIX_WARNINGS "${UNIX_WARNINGS} -Woverloaded-virtual -Wno-parentheses-equality -Wno-reorder -Wno-unused-function -Wno-unused-value -Wno-unused-variable -Wno-unused-private-field -Wno-parentheses")
     set(UNIX_CXX_WARNINGS "${UNIX_WARNINGS}")
   elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
     add_definitions(-DLL_ICC=1)
-    set(UNIX_WARNINGS "-wd327 -wd597 -wd858")
-    set(UNIX_CXX_WARNINGS "${UNIX_WARNINGS}")
   endif ()
   
   if (NOT DISABLE_FATAL_WARNINGS)

indra/cmake/Boost.cmake

@@ -8,34 +8,77 @@ if (STANDALONE)
   include(FindBoost)
 
   set(Boost_USE_MULTITHREADED ON)
-  find_package(Boost 1.40.0 COMPONENTS date_time filesystem program_options regex system thread wave)
+  find_package(Boost 1.51.0 COMPONENTS date_time filesystem program_options regex system thread wave context)
 else (STANDALONE)
   use_prebuilt_binary(boost)
   set(Boost_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include)
+  set(Boost_VERSION "1.52")
 
   if (WINDOWS)
-    set(BOOST_VERSION 1_45)
+    set(Boost_CONTEXT_LIBRARY 
-    set(BOOST_OPTIM_SUFFIX mt)
+        optimized libboost_context-mt
-    set(BOOST_DEBUG_SUFFIX mt-gd)
+        debug libboost_context-mt-gd)
-
+    set(Boost_FILESYSTEM_LIBRARY 
+        optimized libboost_filesystem-mt
+        debug libboost_filesystem-mt-gd)
     set(Boost_PROGRAM_OPTIONS_LIBRARY 
-          optimized libboost_program_options-vc${MSVC_SUFFIX}-${BOOST_OPTIM_SUFFIX}-${BOOST_VERSION}
+        optimized libboost_program_options-mt
-          debug libboost_program_options-vc${MSVC_SUFFIX}-${BOOST_DEBUG_SUFFIX}-${BOOST_VERSION})
+        debug libboost_program_options-mt-gd)
     set(Boost_REGEX_LIBRARY
-          optimized libboost_regex-vc${MSVC_SUFFIX}-${BOOST_OPTIM_SUFFIX}-${BOOST_VERSION}
+        optimized libboost_regex-mt
-          debug libboost_regex-vc${MSVC_SUFFIX}-${BOOST_DEBUG_SUFFIX}-${BOOST_VERSION})
+        debug libboost_regex-mt-gd)
-
+    set(Boost_SIGNALS_LIBRARY 
-  elseif (DARWIN)
+        optimized libboost_signals-mt
-    set(Boost_FILESYSTEM_LIBRARY boost_filesystem)
+        debug libboost_signals-mt-gd)
-    set(Boost_PROGRAM_OPTIONS_LIBRARY boost_program_options)
+    set(Boost_SYSTEM_LIBRARY 
-    set(Boost_REGEX_LIBRARY boost_regex)
+        optimized libboost_system-mt
-    set(Boost_SYSTEM_LIBRARY boost_system)  
+        debug libboost_system-mt-gd)
-    set(Boost_DATE_TIME_LIBRARY boost_date_time)
+    set(Boost_THREAD_LIBRARY 
+        optimized libboost_thread-mt
+        debug libboost_thread-mt-gd)
   elseif (LINUX)
-    set(Boost_FILESYSTEM_LIBRARY boost_filesystem-mt)
+    set(Boost_CONTEXT_LIBRARY
-    set(Boost_PROGRAM_OPTIONS_LIBRARY boost_program_options-mt)
+        optimized boost_context-mt
-    set(Boost_REGEX_LIBRARY boost_regex-mt)
+        debug boost_context-mt-d)
-    set(Boost_SYSTEM_LIBRARY boost_system-mt)  
+    set(Boost_FILESYSTEM_LIBRARY
-    set(Boost_DATE_TIME_LIBRARY boost_date_time-mt)
+        optimized boost_filesystem-mt
+        debug boost_filesystem-mt-d)
+    set(Boost_PROGRAM_OPTIONS_LIBRARY
+        optimized boost_program_options-mt
+        debug boost_program_options-mt-d)
+    set(Boost_REGEX_LIBRARY
+        optimized boost_regex-mt
+        debug boost_regex-mt-d)
+    set(Boost_SIGNALS_LIBRARY
+        optimized boost_signals-mt
+        debug boost_signals-mt-d)
+    set(Boost_SYSTEM_LIBRARY
+        optimized boost_system-mt
+        debug boost_system-mt-d)
+    set(Boost_THREAD_LIBRARY
+        optimized boost_thread-mt
+        debug boost_thread-mt-d)
+  elseif (DARWIN)
+    set(Boost_CONTEXT_LIBRARY
+        optimized boost_context-mt
+        debug boost_context-mt-d)
+    set(Boost_FILESYSTEM_LIBRARY
+        optimized boost_filesystem-mt
+        debug boost_filesystem-mt-d)
+    set(Boost_PROGRAM_OPTIONS_LIBRARY
+        optimized boost_program_options-mt
+        debug boost_program_options-mt-d)
+    set(Boost_REGEX_LIBRARY
+        optimized boost_regex-mt
+        debug boost_regex-mt-d)
+    set(Boost_SIGNALS_LIBRARY
+        optimized boost_signals-mt
+        debug boost_signals-mt-d)
+    set(Boost_SYSTEM_LIBRARY
+        optimized boost_system-mt
+        debug boost_system-mt-d)
+    set(Boost_THREAD_LIBRARY
+        optimized boost_thread-mt
+        debug boost_thread-mt-d)
   endif (WINDOWS)
 endif (STANDALONE)

indra/cmake/BuildVersion.cmake

@@ -33,6 +33,48 @@ configure_file(
     ${CMAKE_SOURCE_DIR}/llcommon/llversionviewer.h
 )
 
+if (WINDOWS)
+   configure_file(
+       ${CMAKE_SOURCE_DIR}/newview/res/viewerRes.rc.in
+       ${CMAKE_SOURCE_DIR}/newview/res/viewerRes.rc
+   )
+   
+   configure_file(
+       ${CMAKE_SOURCE_DIR}/newview/res/viewerRes_bc.rc.in
+       ${CMAKE_SOURCE_DIR}/newview/res/viewerRes_bc.rc
+   )
+endif (WINDOWS)
+
+if (DARWIN)
+   configure_file(
+       ${CMAKE_SOURCE_DIR}/newview/English.lproj/InfoPlist.strings.in
+       ${CMAKE_SOURCE_DIR}/newview/English.lproj/InfoPlist.strings
+   )
+endif (DARWIN)
+
+if (LINUX)
+   configure_file(
+       ${CMAKE_SOURCE_DIR}/newview/linux_tools/wrapper.sh.in
+       ${CMAKE_SOURCE_DIR}/newview/linux_tools/wrapper.sh
+       @ONLY
+   )
+   configure_file(
+       ${CMAKE_SOURCE_DIR}/newview/linux_tools/handle_secondlifeprotocol.sh.in
+       ${CMAKE_SOURCE_DIR}/newview/linux_tools/handle_secondlifeprotocol.sh
+       @ONLY
+   )
+   configure_file(
+       ${CMAKE_SOURCE_DIR}/newview/linux_tools/install.sh.in
+       ${CMAKE_SOURCE_DIR}/newview/linux_tools/install.sh
+       @ONLY
+   )
+   configure_file(
+       ${CMAKE_SOURCE_DIR}/newview/linux_tools/refresh_desktop_app_entry.sh.in
+       ${CMAKE_SOURCE_DIR}/newview/linux_tools/refresh_desktop_app_entry.sh
+       @ONLY
+   )
+endif (LINUX)
+
 # Compose the version.
 set(viewer_VERSION "${vMAJOR}.${vMINOR}.${vPATCH}.${vBUILD}")
 if (viewer_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$")

indra/cmake/CMakeLists.txt

@@ -37,6 +37,7 @@ set(cmake_SOURCE_FILES
     FindColladadom.cmake
     FindELFIO.cmake
     FindGLOD.cmake
+    FindGoogleBreakpad.cmake
     FindGooglePerfTools.cmake
     FindHunSpell.cmake
     FindJsonCpp.cmake
@@ -50,6 +51,7 @@ set(cmake_SOURCE_FILES
     GStreamer010Plugin.cmake
     Glui.cmake
     Glut.cmake
+    GoogleBreakpad.cmake
     GooglePerfTools.cmake
     Hunspell.cmake
     JPEG.cmake
@@ -59,7 +61,6 @@ set(cmake_SOURCE_FILES
     LLAudio.cmake
     LLCharacter.cmake
     LLCommon.cmake
-    LLCrashLogger.cmake
     LLImage.cmake
     LLImageJ2COJ.cmake
     LLInventory.cmake
@@ -69,6 +70,7 @@ set(cmake_SOURCE_FILES
     LLPlugin.cmake
     LLPrimitive.cmake
     LLPhysicsExtensions.cmake
+    LLSharedLibs.cmake
     LLQtWebkit.cmake
     LLRender.cmake
     LLUI.cmake
@@ -79,6 +81,7 @@ set(cmake_SOURCE_FILES
     Linking.cmake
     MediaPluginBase.cmake
     NDOF.cmake
+    NVAPI.cmake
     OPENAL.cmake
     OpenGL.cmake
     OpenJPEG.cmake

indra/cmake/Colladadom.cmake

@@ -10,9 +10,9 @@ if (STANDALONE)
 else (STANDALONE)
   use_prebuilt_binary(colladadom)
 
-  if (NOT WINDOWS)
+  if (NOT WINDOWS AND NOT LINUX)
 	use_prebuilt_binary(pcre)
-  endif (NOT WINDOWS)
+  endif (NOT WINDOWS AND NOT LINUX)
 
   if (NOT DARWIN AND NOT WINDOWS)
 	use_prebuilt_binary(libxml)
@@ -28,18 +28,12 @@ else (STANDALONE)
 	  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/ConfigurePkgConfig.cmake

@@ -14,7 +14,7 @@ IF("$ENV{PKG_CONFIG_LIBDIR}" STREQUAL "")
   else (WORD_SIZE EQUAL 32)
     SET(PKG_CONFIG_NO_MULTI_GUESS /usr/lib64 /usr/lib)
     SET(PKG_CONFIG_NO_MULTI_LOCAL_GUESS /usr/local/lib64 /usr/local/lib)
-    SET(PKG_CONFIG_MULTI_GUESS /usr/local/lib/x86_64-linux-gnu)
+    SET(PKG_CONFIG_MULTI_GUESS /usr/lib/x86_64-linux-gnu)
     SET(PKG_CONFIG_MULTI_LOCAL_GUESS /usr/local/lib/x86_64-linux-gnu)
   endif (WORD_SIZE EQUAL 32)
   

indra/cmake/CopyWinLibs.cmake

@@ -6,13 +6,24 @@
 
 include(CMakeCopyIfDifferent)
 
+if(WORD_SIZE EQUAL 32)
+    set(debug_libs_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/debug")
+    set(release_libs_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/release")
+else(WORD_SIZE EQUAL 32)
+    set(debug_libs_dir "${CMAKE_SOURCE_DIR}/../libraries/x86_64-win/lib/debug")
+    set(release_libs_dir "${CMAKE_SOURCE_DIR}/../libraries/x86_64-win/lib/release")
+endif(WORD_SIZE EQUAL 32)
+
 set(vivox_src_dir "${CMAKE_SOURCE_DIR}/newview/vivox-runtime/i686-win32")
 set(vivox_files
-    SLVoice.exe
+    ca-bundle.crt
-    alut.dll
+    libsndfile-1.dll
-    vivoxsdk.dll
     ortp.dll
-    wrap_oal.dll
+    SLVoice.exe
+    vivoxoal.dll
+    vivoxplatform.dll
+    vivoxsdk.dll
+    zlib1.dll
     )
 copy_if_different(
     ${vivox_src_dir}
@@ -23,7 +34,7 @@ copy_if_different(
 set(all_targets ${all_targets} ${out_targets})
 
 
-set(debug_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/debug")
+set(debug_src_dir "${debug_libs_dir}")
 set(debug_files
     libhunspell.dll
     libapr-1.dll
@@ -44,7 +55,7 @@ copy_if_different(
 set(all_targets ${all_targets} ${out_targets})
 
 # Debug config runtime files required for the plugin test mule
-set(plugintest_debug_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/debug")
+set(plugintest_debug_src_dir "${debug_libs_dir}")
 set(plugintest_debug_files
     libeay32.dll
     qtcored4.dll
@@ -63,7 +74,7 @@ copy_if_different(
 set(all_targets ${all_targets} ${out_targets})
 
 # Debug config runtime files required for the plugin test mule (Qt image format plugins)
-set(plugintest_debug_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/debug/imageformats")
+set(plugintest_debug_src_dir "${debug_libs_dir}/imageformats")
 set(plugintest_debug_files
     qgifd4.dll
     qicod4.dll
@@ -89,7 +100,7 @@ copy_if_different(
 set(all_targets ${all_targets} ${out_targets})
 
 # Release & ReleaseDebInfo config runtime files required for the plugin test mule
-set(plugintest_release_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/release")
+set(plugintest_release_src_dir "${release_libs_dir}")
 set(plugintest_release_files
     libeay32.dll
     qtcore4.dll
@@ -116,7 +127,7 @@ copy_if_different(
 set(all_targets ${all_targets} ${out_targets})
 
 # Release & ReleaseDebInfo config runtime files required for the plugin test mule (Qt image format plugins)
-set(plugintest_release_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/release/imageformats")
+set(plugintest_release_src_dir "${release_libs_dir}/imageformats")
 set(plugintest_release_files
     qgif4.dll
     qico4.dll
@@ -158,7 +169,7 @@ copy_if_different(
 set(all_targets ${all_targets} ${out_targets})
 
 # Debug config runtime files required for the plugins
-set(plugins_debug_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/debug")
+set(plugins_debug_src_dir "${debug_libs_dir}")
 set(plugins_debug_files
     libeay32.dll
     qtcored4.dll
@@ -177,7 +188,7 @@ copy_if_different(
 set(all_targets ${all_targets} ${out_targets})
 
 # Release & ReleaseDebInfo config runtime files required for the plugins
-set(plugins_release_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/release")
+set(plugins_release_src_dir "${release_libs_dir}")
 set(plugins_release_files
     libeay32.dll
     qtcore4.dll
@@ -203,9 +214,9 @@ copy_if_different(
     )
 set(all_targets ${all_targets} ${out_targets})
 
-set(release_src_dir "${CMAKE_SOURCE_DIR}/../libraries/i686-win32/lib/release")
+
+set(release_src_dir "${release_libs_dir}")
 set(release_files
-    libtcmalloc_minimal.dll
     libhunspell.dll
     libapr-1.dll
     libaprutil-1.dll
@@ -216,8 +227,21 @@ set(release_files
     glod.dll
     )
 
+if(WORD_SIZE EQUAL 32)
+    set(release_files ${release_files}
+    libtcmalloc_minimal.dll
+    )
+endif(WORD_SIZE EQUAL 32)
+
+
 if(FMODEX)
-    find_path(FMODEX_BINARY_DIR fmodex.dll
+    if (WORD_SIZE EQUAL 32)
+        set(fmodex_dll_file "fmodex.dll")
+    else (WORD_SIZE EQUAL 32)
+        set(fmodex_dll_file "fmodex64.dll")
+    endif (WORD_SIZE EQUAL 32)
+    
+    find_path(FMODEX_BINARY_DIR "${fmodex_dll_file}"
           "${release_src_dir}"
           "${FMODEX_SDK_DIR}/api"
           "${FMODEX_SDK_DIR}"
@@ -225,11 +249,11 @@ if(FMODEX)
           )
 
     if(FMODEX_BINARY_DIR)
-        copy_if_different("${FMODEX_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/Release" out_targets fmodex.dll)
+        copy_if_different("${FMODEX_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/Release" out_targets "${fmodex_dll_file}")
         set(all_targets ${all_targets} ${out_targets})
-        copy_if_different("${FMODEX_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo" out_targets fmodex.dll)
+        copy_if_different("${FMODEX_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo" out_targets "${fmodex_dll_file}")
         set(all_targets ${all_targets} ${out_targets})
-        copy_if_different("${FMODEX_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/Debug" out_targets fmodex.dll)
+        copy_if_different("${FMODEX_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/Debug" out_targets "${fmodex_dll_file}")
         set(all_targets ${all_targets} ${out_targets})
     endif(FMODEX_BINARY_DIR)
 endif(FMODEX)
@@ -285,105 +309,6 @@ copy_if_different(
     )
 set(all_targets ${all_targets} ${out_targets})
 
-# Copy MS C runtime dlls, required for packaging.
-# *TODO - Adapt this to support VC9
-if (MSVC80)
-    FIND_PATH(debug_msvc8_redist_path msvcr80d.dll
-        PATHS
-         [HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup\\VC;ProductDir]/redist/Debug_NonRedist/x86/Microsoft.VC80.DebugCRT
-        NO_DEFAULT_PATH
-        NO_DEFAULT_PATH
-        )
-
-    if(EXISTS ${debug_msvc8_redist_path})
-        set(debug_msvc8_files
-            msvcr80d.dll
-            msvcp80d.dll
-            Microsoft.VC80.DebugCRT.manifest
-            )
-
-        copy_if_different(
-            ${debug_msvc8_redist_path} 
-            "${CMAKE_CURRENT_BINARY_DIR}/Debug"
-            out_targets 
-            ${debug_msvc8_files}
-            )
-        set(all_targets ${all_targets} ${out_targets})
-
-        set(debug_appconfig_file ${CMAKE_CURRENT_BINARY_DIR}/Debug/${VIEWER_BINARY_NAME}.exe.config)
-        add_custom_command(
-            OUTPUT ${debug_appconfig_file}
-            COMMAND ${PYTHON_EXECUTABLE}
-            ARGS
-              ${CMAKE_CURRENT_SOURCE_DIR}/build_win32_appConfig.py
-              ${CMAKE_CURRENT_BINARY_DIR}/Debug/Microsoft.VC80.DebugCRT.manifest
-              ${CMAKE_CURRENT_SOURCE_DIR}/SecondLifeDebug.exe.config
-              ${debug_appconfig_file}
-            DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/Debug/Microsoft.VC80.DebugCRT.manifest
-            COMMENT "Creating debug app config file"
-            )
-
-    endif (EXISTS ${debug_msvc8_redist_path})
-
-    FIND_PATH(release_msvc8_redist_path msvcr80.dll
-        PATHS
-         [HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup\\VC;ProductDir]/redist/x86/Microsoft.VC80.CRT
-        NO_DEFAULT_PATH
-        NO_DEFAULT_PATH
-        )
-
-    if(EXISTS ${release_msvc8_redist_path})
-        set(release_msvc8_files
-            msvcr80.dll
-            msvcp80.dll
-            Microsoft.VC80.CRT.manifest
-            )
-
-        copy_if_different(
-            ${release_msvc8_redist_path} 
-            "${CMAKE_CURRENT_BINARY_DIR}/Release"
-            out_targets 
-            ${release_msvc8_files}
-            )
-        set(all_targets ${all_targets} ${out_targets})
-
-        copy_if_different(
-            ${release_msvc8_redist_path} 
-            "${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo"
-            out_targets 
-            ${release_msvc8_files}
-            )
-        set(all_targets ${all_targets} ${out_targets})
-
-        set(release_appconfig_file ${CMAKE_CURRENT_BINARY_DIR}/Release/${VIEWER_BINARY_NAME}.exe.config)
-        add_custom_command(
-            OUTPUT ${release_appconfig_file}
-            COMMAND ${PYTHON_EXECUTABLE}
-            ARGS
-              ${CMAKE_CURRENT_SOURCE_DIR}/build_win32_appConfig.py
-              ${CMAKE_CURRENT_BINARY_DIR}/Release/Microsoft.VC80.CRT.manifest
-              ${CMAKE_CURRENT_SOURCE_DIR}/SecondLife.exe.config
-              ${release_appconfig_file}
-            DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/Release/Microsoft.VC80.CRT.manifest
-            COMMENT "Creating release app config file"
-            )
-            
-        set(relwithdebinfo_appconfig_file ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/${VIEWER_BINARY_NAME}.exe.config)
-        add_custom_command(
-            OUTPUT ${relwithdebinfo_appconfig_file}
-            COMMAND ${PYTHON_EXECUTABLE}
-            ARGS
-              ${CMAKE_CURRENT_SOURCE_DIR}/build_win32_appConfig.py
-              ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/Microsoft.VC80.CRT.manifest
-              ${CMAKE_CURRENT_SOURCE_DIR}/SecondLife.exe.config
-              ${relwithdebinfo_appconfig_file}
-            DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/Microsoft.VC80.CRT.manifest
-            COMMENT "Creating relwithdebinfo app config file"
-            )
-          
-    endif (EXISTS ${release_msvc8_redist_path})
-endif (MSVC80)
-
 add_custom_target(copy_win_libs ALL
   DEPENDS 
     ${all_targets}

indra/cmake/DirectX.cmake

@@ -44,10 +44,15 @@ if (WINDOWS)
                "$ENV{ProgramFiles(x86)}/Windows Kits/8.0"
                )
 
-    if (WIN_KIT_ROOT_DIR)
+    find_path (WIN_KIT_LIB_DIR dxguid.lib
+               "${WIN_KIT_ROOT_DIR}/Lib/winv6.3/um/${DIRECTX_ARCHITECTURE}"
+               "${WIN_KIT_ROOT_DIR}/Lib/Win8/um/${DIRECTX_ARCHITECTURE}"
+               )
+
+    if (WIN_KIT_ROOT_DIR AND WIN_KIT_LIB_DIR)
       set (DIRECTX_INCLUDE_DIR "${WIN_KIT_ROOT_DIR}/Include/um" "${WIN_KIT_ROOT_DIR}/Include/shared")
-      set (DIRECTX_LIBRARY_DIR "${WIN_KIT_ROOT_DIR}/Lib/Win8/um/${DIRECTX_ARCHITECTURE}")
+      set (DIRECTX_LIBRARY_DIR "${WIN_KIT_LIB_DIR}")
-    endif (WIN_KIT_ROOT_DIR)
+    endif (WIN_KIT_ROOT_DIR AND WIN_KIT_LIB_DIR)
   endif (DIRECTX_ROOT_DIR)
 
   if (DIRECTX_INCLUDE_DIR)

indra/cmake/FMODEX.cmake

@@ -16,7 +16,7 @@ if (NOT FMODEX_LIBRARY)
                    )
     elseif(WORD_SIZE EQUAL 64)
       find_library(FMODEX_LIBRARY
-                   fmodex64 fmodexL64
+                   fmodex64_vc fmodexL64_vc fmodex64 fmodexL64
                    PATHS
                    "${FMODEX_SDK_DIR}/api/lib"
                    "${FMODEX_SDK_DIR}/api"
@@ -25,21 +25,31 @@ if (NOT FMODEX_LIBRARY)
                    )
     endif(WORD_SIZE EQUAL 32)
   endif(FMODEX_SDK_DIR)
-  if(WINDOWS AND NOT FMODEX_LIBRARY)
+  if(WINDOWS AND NOT FMODEX_SDK_DIR)
-    set(FMODEX_PROG_DIR "$ENV{PROGRAMFILES}/FMOD SoundSystem/FMOD Programmers API Windows")
+    GET_FILENAME_COMPONENT(FMODEX_PROG_DIR [HKEY_CURRENT_USER\\Software\\FMOD\ Programmers\ API\ Windows] ABSOLUTE CACHE)
-    find_library(FMODEX_LIBRARY
+    if(WORD_SIZE EQUAL 32)
-                 fmodex_vc fmodexL_vc
+      find_library(FMODEX_LIBRARY
-                 PATHS
+                   fmodex_vc fmodexL_vc
-                 "${FMODEX_PROG_DIR}/api/lib"
+                   PATHS
-                 "${FMODEX_PROG_DIR}/api"
+                   "${FMODEX_PROG_DIR}/api/lib"
-                 "${FMODEX_PROG_DIR}"
+                   "${FMODEX_PROG_DIR}/api"
-                 )
+                   "${FMODEX_PROG_DIR}"
+                   )
+    else(WORD_SIZE EQUAL 32)
+      find_library(FMODEX_LIBRARY
+                   fmodex64_vc fmodexL64_vc
+                   PATHS
+                   "${FMODEX_PROG_DIR}/api/lib"
+                   "${FMODEX_PROG_DIR}/api"
+                   "${FMODEX_PROG_DIR}"
+                   )
+    endif(WORD_SIZE EQUAL 32)
     if(FMODEX_LIBRARY)
       message(STATUS "Found fmodex in ${FMODEX_PROG_DIR}")
       set(FMODEX_SDK_DIR "${FMODEX_PROG_DIR}")
       set(FMODEX_SDK_DIR "${FMODEX_PROG_DIR}" CACHE PATH "Path to the FMOD Ex SDK." FORCE)
     endif(FMODEX_LIBRARY)
-  endif(WINDOWS AND NOT FMODEX_LIBRARY)
+  endif(WINDOWS AND NOT FMODEX_SDK_DIR)
 endif (NOT FMODEX_LIBRARY)
 
 find_path(FMODEX_INCLUDE_DIR fmod.hpp

indra/cmake/FindGoogleBreakpad.cmake

@@ -0,0 +1,40 @@
+# -*- cmake -*-
+
+# - Find Google BreakPad
+# Find the Google BreakPad includes and library
+# This module defines
+#  BREAKPAD_INCLUDE_DIRECTORIES, where to find the Goole BreakPad includes.
+#  BREAKPAD_EXCEPTION_HANDLER_LIBRARIES, the libraries needed to use Google BreakPad.
+#  BREAKPAD_EXCEPTION_HANDLER_FOUND, If false, do not try to use Google BreakPad.
+# also defined, but not for general use are
+#  BREAKPAD_EXCEPTION_HANDLER_LIBRARY, where to find the Google BreakPad library.
+
+FIND_PATH(BREAKPAD_INCLUDE_DIRECTORIES common/using_std_string.h PATH_SUFFIXES google_breakpad)
+
+SET(BREAKPAD_EXCEPTION_HANDLER_NAMES ${BREAKPAD_EXCEPTION_HANDLER_NAMES} breakpad_client)
+FIND_LIBRARY(BREAKPAD_EXCEPTION_HANDLER_LIBRARY
+  NAMES ${BREAKPAD_EXCEPTION_HANDLER_NAMES}
+  )
+
+IF (BREAKPAD_EXCEPTION_HANDLER_LIBRARY AND BREAKPAD_INCLUDE_DIRECTORIES)
+    SET(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES ${BREAKPAD_EXCEPTION_HANDLER_LIBRARY})
+    SET(BREAKPAD_EXCEPTION_HANDLER_FOUND "YES")
+ELSE (BREAKPAD_EXCEPTION_HANDLER_LIBRARY AND BREAKPAD_INCLUDE_DIRECTORIES)
+    SET(BREAKPAD_EXCEPTION_HANDLER_FOUND "NO")
+ENDIF (BREAKPAD_EXCEPTION_HANDLER_LIBRARY AND BREAKPAD_INCLUDE_DIRECTORIES)
+
+
+IF (BREAKPAD_EXCEPTION_HANDLER_FOUND)
+   IF (NOT BREAKPAD_EXCEPTION_HANDLER_FIND_QUIETLY)
+      MESSAGE(STATUS "Found Google BreakPad: ${BREAKPAD_EXCEPTION_HANDLER_LIBRARIES}")
+   ENDIF (NOT BREAKPAD_EXCEPTION_HANDLER_FIND_QUIETLY)
+ELSE (BREAKPAD_EXCEPTION_HANDLER_FOUND)
+   IF (BREAKPAD_EXCEPTION_HANDLER_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find Google BreakPad library")
+   ENDIF (BREAKPAD_EXCEPTION_HANDLER_FIND_REQUIRED)
+ENDIF (BREAKPAD_EXCEPTION_HANDLER_FOUND)
+
+MARK_AS_ADVANCED(
+  BREAKPAD_EXCEPTION_HANDLER_LIBRARY
+  BREAKPAD_INCLUDE_DIRECTORIES
+  )

indra/cmake/GoogleBreakpad.cmake

@@ -0,0 +1,21 @@
+# -*- cmake -*-
+include(Prebuilt)
+
+if (STANDALONE)
+  set(BREAKPAD_EXCEPTION_HANDLER_FIND_REQUIRED ON)
+  include(FindGoogleBreakpad)
+else (STANDALONE)
+  use_prebuilt_binary(google_breakpad)
+  if (DARWIN)
+    set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES exception_handler)
+  endif (DARWIN)
+  if (LINUX)
+    set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES breakpad_client)
+  endif (LINUX)
+  if (WINDOWS)
+    set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES exception_handler crash_generation_client crash_generation_server common)
+  endif (WINDOWS)
+  # yes, this does look dumb, no, it's not incorrect
+  # I think it's incorrect: the second one should go --Aleric
+  set(BREAKPAD_INCLUDE_DIRECTORIES "${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/google_breakpad" "${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/google_breakpad/google_breakpad")
+endif (STANDALONE)

indra/cmake/LLAddBuildTest.cmake

@@ -159,3 +159,23 @@ MACRO(ADD_VIEWER_COMM_BUILD_TEST name parent wrapper)
 ##  MESSAGE(STATUS "ADD_VIEWER_COMM_BUILD_TEST ${name} wrapper = ${wrapper}")
     ADD_COMM_BUILD_TEST("${name}" "${parent}" "${wrapper}" llviewerprecompiledheaders.cpp)
 ENDMACRO(ADD_VIEWER_COMM_BUILD_TEST name parent wrapper)
+MACRO(SET_TEST_PATH LISTVAR)
+  IF(WINDOWS)
+    # We typically build/package only Release variants of third-party
+    # libraries, so append the Release staging dir in case the library being
+    # sought doesn't have a debug variant.
+    set(${LISTVAR} ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR} ${SHARED_LIB_STAGING_DIR}/Release)
+  ELSEIF(DARWIN)
+    # We typically build/package only Release variants of third-party
+    # libraries, so append the Release staging dir in case the library being
+    # sought doesn't have a debug variant.
+    set(${LISTVAR} ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources ${SHARED_LIB_STAGING_DIR}/Release/Resources /usr/lib)
+  ELSE(WINDOWS)
+    # Linux uses a single staging directory anyway.
+    IF (STANDALONE)
+      set(${LISTVAR} ${CMAKE_BINARY_DIR}/llcommon /usr/lib /usr/local/lib)
+    ELSE (STANDALONE)
+      set(${LISTVAR} ${SHARED_LIB_STAGING_DIR} /usr/lib)
+    ENDIF (STANDALONE)
+  ENDIF(WINDOWS)
+ENDMACRO(SET_TEST_PATH)

indra/cmake/LLCrashLogger.cmake

@@ -1,7 +0,0 @@
-# -*- cmake -*-
-
-set(LLCRASHLOGGER_INCLUDE_DIRS
-    ${LIBS_OPEN_DIR}/llcrashlogger
-    )
-
-set(LLCRASHLOGGER_LIBRARIES llcrashlogger)

indra/cmake/LLSharedLibs.cmake

@@ -0,0 +1,73 @@
+# ll_deploy_sharedlibs_command
+# target_exe: the cmake target of the executable for which the shared libs will be deployed.
+macro(ll_deploy_sharedlibs_command target_exe) 
+  get_target_property(TARGET_LOCATION ${target_exe} LOCATION)
+  get_filename_component(OUTPUT_PATH ${TARGET_LOCATION} PATH)
+  
+  if(DARWIN)
+    SET_TEST_PATH(SEARCH_DIRS)
+    get_target_property(IS_BUNDLE ${target_exe} MACOSX_BUNDLE)
+    if(IS_BUNDLE)
+      # If its a bundle the exe is not in the target location, this should find it.
+      get_filename_component(TARGET_FILE ${TARGET_LOCATION} NAME)
+      set(OUTPUT_PATH ${TARGET_LOCATION}.app/Contents/MacOS)
+      set(TARGET_LOCATION ${OUTPUT_PATH}/${TARGET_FILE})
+      set(OUTPUT_PATH ${OUTPUT_PATH}/../Resources)
+    endif(IS_BUNDLE)
+  elseif(WINDOWS)
+    SET_TEST_PATH(SEARCH_DIRS)
+    LIST(APPEND SEARCH_DIRS "$ENV{SystemRoot}/system32")
+  elseif(LINUX)
+    SET_TEST_PATH(SEARCH_DIRS)
+    set(OUTPUT_PATH ${OUTPUT_PATH}/lib)
+  endif(DARWIN)
+
+  add_custom_command(
+    TARGET ${target_exe} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} 
+    ARGS
+    "-DBIN_NAME=\"${TARGET_LOCATION}\""
+    "-DSEARCH_DIRS=\"${SEARCH_DIRS}\""
+    "-DDST_PATH=\"${OUTPUT_PATH}\""
+    "-P"
+    "${CMAKE_SOURCE_DIR}/cmake/DeploySharedLibs.cmake"
+    )
+
+endmacro(ll_deploy_sharedlibs_command)
+
+# ll_stage_sharedlib
+# Performs config and adds a copy command for a sharedlib target.
+macro(ll_stage_sharedlib DSO_TARGET)
+  # target gets written to the DLL staging directory.
+  # Also this directory is shared with RunBuildTest.cmake, y'know, for the tests.
+  set_target_properties(${DSO_TARGET} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${SHARED_LIB_STAGING_DIR})
+  if(NOT WINDOWS)
+    get_target_property(DSO_PATH ${DSO_TARGET} LOCATION)
+    get_filename_component(DSO_FILE ${DSO_PATH} NAME)
+    if(DARWIN)
+      set(SHARED_LIB_STAGING_DIR_CONFIG ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources)
+    else(DARWIN)
+      set(SHARED_LIB_STAGING_DIR_CONFIG ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR})
+    endif(DARWIN)
+
+      # *TODO - maybe make this a symbolic link? -brad
+      add_custom_command(
+        TARGET ${DSO_TARGET} POST_BUILD
+        COMMAND ${CMAKE_COMMAND}
+        ARGS
+          -E
+          copy_if_different
+          ${DSO_PATH}
+          ${SHARED_LIB_STAGING_DIR_CONFIG}/${DSO_FILE}
+          COMMENT "Copying llcommon to the staging folder."
+        )
+    endif(NOT WINDOWS)
+
+  if (DARWIN)
+    set_target_properties(${DSO_TARGET} PROPERTIES
+      BUILD_WITH_INSTALL_RPATH 1
+      INSTALL_NAME_DIR "@executable_path/../Resources"
+      )
+  endif(DARWIN)
+
+endmacro(ll_stage_sharedlib)

indra/cmake/Linking.cmake

@@ -5,22 +5,29 @@ set(${CMAKE_CURRENT_LIST_FILE}_INCLUDED "YES")
 include(Variables)
 
 if (NOT STANDALONE)
-  if (WINDOWS)
+  set(ARCH_PREBUILT_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib)
-    set(ARCH_PREBUILT_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib)
+  set(ARCH_PREBUILT_DIRS_RELEASE ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/release)
-    set(ARCH_PREBUILT_DIRS_RELEASE ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/release)
+  set(ARCH_PREBUILT_DIRS_DEBUG ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/debug)
-    set(ARCH_PREBUILT_DIRS_DEBUG ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/debug)
+
-  elseif (LINUX)
+  if(WINDOWS OR ${CMAKE_GENERATOR} MATCHES "Xcode")
-    set(ARCH_PREBUILT_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/release)
+    # the cmake xcode and VS generators implicitly append ${CMAKE_CFG_INTDIR} to the library paths for us
-    set(ARCH_PREBUILT_DIRS_RELEASE ${ARCH_PREBUILT_DIRS})
+    # fortunately both windows and darwin are case insensitive filesystems so this works.
-    set(ARCH_PREBUILT_DIRS_DEBUG ${ARCH_PREBUILT_DIRS})
+    set(ARCH_PREBUILT_LINK_DIRS "${ARCH_PREBUILT_DIRS}")
-  elseif (DARWIN)
+  else(WINDOWS OR ${CMAKE_GENERATOR} MATCHES "Xcode")
-    set(ARCH_PREBUILT_DIRS ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib)
+    # else block is for linux and any other makefile based generators
-    set(ARCH_PREBUILT_DIRS_RELEASE ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/release)
+    string(TOLOWER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_LOWER)
-    set(ARCH_PREBUILT_DIRS_DEBUG ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/lib/debug)
+    set(ARCH_PREBUILT_LINK_DIRS ${ARCH_PREBUILT_DIRS}/${CMAKE_BUILD_TYPE_LOWER})
-  endif (WINDOWS)
+  endif(WINDOWS OR ${CMAKE_GENERATOR} MATCHES "Xcode")
+
+  if (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Release")
+    # When we're building something other than Release, append the
+    # packages/lib/release directory to deal with autobuild packages that don't
+    # provide (e.g.) lib/debug libraries.
+    list(APPEND ARCH_PREBUILT_LINK_DIRS ${ARCH_PREBUILT_DIRS_RELEASE})
+  endif (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Release")
 endif (NOT STANDALONE)
 
-link_directories(${ARCH_PREBUILT_DIRS})
+link_directories(${ARCH_PREBUILT_LINK_DIRS})
 
 if (LINUX)
   set(DL_LIBRARY dl)

indra/cmake/NVAPI.cmake

@@ -0,0 +1,21 @@
+# -*- cmake -*-
+include(Prebuilt)
+include(Variables)
+
+set(NVAPI ON CACHE BOOL "Use NVAPI.")
+
+if (NVAPI)
+  if (WINDOWS)
+    use_prebuilt_binary(nvapi)
+    if (WORD_SIZE EQUAL 32)
+      set(NVAPI_LIBRARY nvapi)
+    elseif (WORD_SIZE EQUAL 64)
+      set(NVAPI_LIBRARY nvapi64)
+    endif (WORD_SIZE EQUAL 32)	
+  else (WINDOWS)
+    set(NVAPI_LIBRARY "")
+  endif (WINDOWS)
+else (NVAPI)
+  set(NVAPI_LIBRARY "")
+endif (NVAPI)
+

indra/cmake/QuickTimePlugin.cmake

@@ -8,7 +8,7 @@ endif(INSTALL_PROPRIETARY)
 if (DARWIN)
   include(CMakeFindFrameworks)
   find_library(QUICKTIME_LIBRARY QuickTime)
-elseif (WINDOWS)
+elseif (WINDOWS AND WORD_SIZE EQUAL 32)
   set(QUICKTIME_SDK_DIR "$ENV{PROGRAMFILES}/QuickTime SDK"
       CACHE PATH "Location of the QuickTime SDK.")
 

indra/cmake/Variables.cmake

@@ -37,10 +37,15 @@ set(LIBS_PREBUILT_DIR ${CMAKE_SOURCE_DIR}/../libraries CACHE PATH
 
 if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
   set(WINDOWS ON BOOL FORCE)
-  set(ARCH i686)
+  if (WORD_SIZE EQUAL 32)
-  set(LL_ARCH ${ARCH}_win32)
+    set(ARCH i686)
-  set(LL_ARCH_DIR ${ARCH}-win32)
+    set(LL_ARCH ${ARCH}_win32)
-  set(WORD_SIZE 32)
+    set(LL_ARCH_DIR ${ARCH}-win32)
+  elseif (WORD_SIZE EQUAL 64)
+    set(ARCH x86_64)
+    set(LL_ARCH ${ARCH}_win)
+    set(LL_ARCH_DIR ${ARCH}-win)
+  endif (WORD_SIZE EQUAL 32)
 endif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 
 if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
@@ -92,24 +97,54 @@ endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   set(DARWIN 1)
 
-  if(${CMAKE_GENERATOR} MATCHES Xcode)
+  execute_process(
-    #SDK Compiler and Deployment targets for XCode
+    COMMAND sh -c "xcodebuild -version | grep Xcode  | cut -d ' ' -f2 | cut -d'.' -f1-2"
-    if (${XCODE_VERSION} VERSION_LESS 4.0.0)
+    OUTPUT_VARIABLE XCODE_VERSION )
-      set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.5.sdk)
+  string(REGEX REPLACE "(\r?\n)+$" "" XCODE_VERSION "${XCODE_VERSION}")
-      set(CMAKE_OSX_DEPLOYMENT_TARGET 10.5)
+  
-    else (${XCODE_VERSION} VERSION_LESS 4.0.0)
+#   # To support a different SDK update these Xcode settings:
-      set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.6.sdk)
+#   if (XCODE_VERSION GREATER 4.9) # (Which would be 5.0+)
-      set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6)
+#     set(CMAKE_OSX_DEPLOYMENT_TARGET 10.8)
-    endif (${XCODE_VERSION} VERSION_LESS 4.0.0)
+# 	set(CMAKE_OSX_SYSROOT macosx10.9)
-  else(${CMAKE_GENERATOR} MATCHES Xcode)
+#   else (XCODE_VERION GREATER 4.9)
-    set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.6.sdk)
+#     if (XCODE_VERSION GREATER 4.5)
-    set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6)
+#         set(CMAKE_OSX_DEPLOYMENT_TARGET 10.7)
-  endif(${CMAKE_GENERATOR} MATCHES Xcode)
+#         set(CMAKE_OSX_SYSROOT macosx10.8)
+#     else (XCODE_VERSION GREATER 4.5)
+#         if (XCODE_VERSION GREATER 4.2)
+#           set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6)
+#           set(CMAKE_OSX_SYSROOT macosx10.7)
+#         else (XCODE_VERSION GREATER 4.2)
+#           set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6)
+#           set(CMAKE_OSX_SYSROOT macosx10.7)
+#         endif (XCODE_VERSION GREATER 4.2)
+#     endif (XCODE_VERSION GREATER 4.5)
+#   endif (XCODE_VERSION GREATER 4.9)
 
-  set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvmgcc42")
+  # Hardcode SDK we build against until we can test and allow newer ones
+  # as autodetected in the code above
+  set(CMAKE_OSX_DEPLOYMENT_TARGET 10.6)
+  set(CMAKE_OSX_SYSROOT macosx10.6)
+
+  # Support for Unix Makefiles generator
+  if (CMAKE_GENERATOR STREQUAL "Unix Makefiles")
+    execute_process(COMMAND xcodebuild -version -sdk "${CMAKE_OSX_SYSROOT}" Path | head -n 1 OUTPUT_VARIABLE CMAKE_OSX_SYSROOT)
+    string(REGEX REPLACE "(\r?\n)+$" "" CMAKE_OSX_SYSROOT "${CMAKE_OSX_SYSROOT}")
+  endif (CMAKE_GENERATOR STREQUAL "Unix Makefiles")
+      
+  # LLVM-GCC has been removed in Xcode5
+  if (XCODE_VERSION GREATER 4.9)
+    set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvm.clang.1_0")
+  else (XCODE_VERSION GREATER 4.9)
+    set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvmgcc42")
+  endif (XCODE_VERSION GREATER 4.9)
 
   set(CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT dwarf-with-dsym)
 
+  message(STATUS "Xcode version: ${XCODE_VERSION}")
+  message(STATUS "OSX sysroot: ${CMAKE_OSX_SYSROOT}")
+  message(STATUS "OSX deployment target: ${CMAKE_OSX_DEPLOYMENT_TARGET}")
+  
   # Build only for i386 by default, system default on MacOSX 10.6 is x86_64
   set(CMAKE_OSX_ARCHITECTURES i386)
   set(ARCH i386)
@@ -119,26 +154,29 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   set(LL_ARCH_DIR universal-darwin)
 endif (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 
-if (WINDOWS)
+if (WINDOWS AND WORD_SIZE EQUAL 32)
   set(PREBUILT_TYPE windows)
+elseif (WINDOWS AND WORD_SIZE EQUAL 64)
+  set(PREBUILT_TYPE windows64)
 elseif(DARWIN)
   set(PREBUILT_TYPE darwin)
 elseif(LINUX AND WORD_SIZE EQUAL 32)
   set(PREBUILT_TYPE linux)
 elseif(LINUX AND WORD_SIZE EQUAL 64)
   set(PREBUILT_TYPE linux64)
-endif(WINDOWS)
+endif(WINDOWS AND WORD_SIZE EQUAL 32)
 
 # Default deploy grid
 set(GRID agni CACHE STRING "Target Grid")
 
 set(VIEWER_CHANNEL "Singularity" CACHE STRING "Viewer Channel Name")
-set(VIEWER_LOGIN_CHANNEL ${VIEWER_CHANNEL} CACHE STRING "Fake login channel for A/B Testing")
+set(VIEWER_LOGIN_CHANNEL "${VIEWER_CHANNEL}" CACHE STRING "Fake login channel for A/B Testing")
 set(VIEWER_BRANDING_ID "singularity" CACHE STRING "Viewer branding id (currently secondlife|snowglobe)")
 
 # *TODO: break out proper Branding-secondlife.cmake, Branding-snowglobe.cmake, etc
-set(VIEWER_BRANDING_NAME "Singularity")
+string(REGEX REPLACE " +" "" VIEWER_CHANNEL_ONE_WORD "${VIEWER_CHANNEL}")
-set(VIEWER_BRANDING_NAME_CAMELCASE "Singularity")
+set(VIEWER_BRANDING_NAME "${VIEWER_CHANNEL_ONE_WORD}")
+set(VIEWER_BRANDING_NAME_CAMELCASE "${VIEWER_CHANNEL_ONE_WORD}")
 
 set(STANDALONE OFF CACHE BOOL "Do not use Linden-supplied prebuilt libraries.")
 

indra/cwdebug/debug.h

@@ -28,95 +28,16 @@
 #ifndef CWDEBUG
 
 #ifdef DEBUG_CURLIO
-
+#error DEBUG_CURLIO is not supported without libcwd.
-// If CWDEBUG is not defined, but DEBUG_CURLIO is, then replace
+// In order to use DEBUG_CURLIO you must install and use libcwd.
-// some of the cwd macro's with something that generates viewer
+// Download libcwd:
-// specific debug output. Note that this generates a LOT of
+// git clone https://github.com/CarloWood/libcwd.git
-// output and should not normally be defined.
+#endif
-
-#include <string>
-#include "llpreprocessor.h"
-
-namespace debug {
-namespace libcwd {
-
-struct buf2str {
-  buf2str(char const* buf, int size) : mBuf(buf), mSize(size) { }
-  char const* mBuf;
-  int mSize;
-};
-
-struct libcwd_do_type {
- void on() const { }
-};
-extern LL_COMMON_API libcwd_do_type const libcw_do;
-
-} // namespace libcwd
-
-enum print_thread_id_t { print_thread_id };
-inline void init() { }
-struct Indent {
-  int M_indent;
-  static ll_thread_local int S_indentation;
-  enum LL_COMMON_API print_nt { print };
-  LL_COMMON_API Indent(int indent);
-  LL_COMMON_API ~Indent();
-};
-
-extern LL_COMMON_API std::ostream& operator<<(std::ostream& os, libcwd::buf2str const& b2s);
-extern LL_COMMON_API std::ostream& operator<<(std::ostream& os, Indent::print_nt);
-extern LL_COMMON_API std::ostream& operator<<(std::ostream& os, print_thread_id_t);
-
-namespace dc {
-
-struct fake_channel {
-  int mOn;
-  char const* mLabel;
-  fake_channel(int on, char const* label) : mOn(on), mLabel(label) { }
-  fake_channel(void) : mOn(0) { }
-  bool is_on() const { return !!mOn; }
-  bool is_off() const { return !mOn; }
-  void on() const { }
-  void off() const { }
-};
-extern LL_COMMON_API fake_channel const warning;
-extern LL_COMMON_API fake_channel const curl;
-extern LL_COMMON_API fake_channel const curlio;
-extern LL_COMMON_API fake_channel const curltr;
-extern LL_COMMON_API fake_channel const statemachine;
-extern LL_COMMON_API fake_channel const notice;
-extern LL_COMMON_API fake_channel const snapshot;
-
-} // namespace dc
-} // namespace debug
-
-#define LIBCWD_DEBUG_CHANNELS debug
-#define LibcwDoutScopeBegin(a, b, c) do { using namespace debug; using namespace debug::libcwd; llinfos_nf << print_thread_id << (c).mLabel << ": " << Indent::print;
-#define LibcwDoutStream llcont
-#define LibcwDoutScopeEnd llcont << llendl; } while(0)
-
-#define Debug(x) do { using namespace debug; using namespace debug::libcwd; x; } while(0)
-#define Dout(a, b) do { using namespace debug; using namespace debug::libcwd; if ((a).mOn) { llinfos_nf << print_thread_id << (a).mLabel << ": " << Indent::print << b << llendl; } } while(0)
-#define DoutEntering(a, b) \
-  int __slviewer_debug_indentation = 2; \
-  { \
-	using namespace debug; \
-	using namespace debug::libcwd; \
-	if ((a).mOn) \
-	  llinfos_nf << print_thread_id << (a).mLabel << ": " << Indent::print << "Entering " << b << llendl; \
-    else \
-	  __slviewer_debug_indentation = 0; \
-  } \
-  debug::Indent __slviewer_debug_indent(__slviewer_debug_indentation);
-
-#else // !DEBUG_CURLIO
 
 #define Debug(x)
 #define Dout(a, b)
 #define DoutEntering(a, b)
 
-#endif // !DEBUG_CURLIO
-
 #ifndef DOXYGEN         // No need to document this.  See http://libcwd.sourceforge.net/ for more info.
 
 #include <iostream>
@@ -144,6 +65,11 @@ extern LL_COMMON_API fake_channel const snapshot;
 #define CWDEBUG_MARKER 0
 
 #define BACKTRACE do { } while(0)
+#ifdef DEBUG_CURLIO
+#define CWD_ONLY(...) __VA_ARGS__
+#else
+#define CWD_ONLY(...)
+#endif
 
 #endif // !DOXYGEN
 
@@ -180,6 +106,7 @@ extern LL_COMMON_API fake_channel const snapshot;
 #include <set>
 
 #define CWD_API __attribute__ ((visibility("default")))
+#define CWD_ONLY(...) __VA_ARGS__
 
 //! Debug specific code.
 namespace debug {
@@ -384,6 +311,40 @@ void InstanceTracker<T>::dump(void)
 
 } // namespace debug
 
+template<class T>
+class AIDebugInstanceCounter
+{
+  public:
+	static int sInstanceCount;
+
+  protected:
+	static void print_count(char const* name, int count, bool destruction);
+
+	AIDebugInstanceCounter()
+	{
+	  print_count(typeid(T).name(), ++sInstanceCount, false);
+	}
+	AIDebugInstanceCounter(AIDebugInstanceCounter const&)
+	{
+	  print_count(typeid(T).name(), ++sInstanceCount, false);
+	}
+	~AIDebugInstanceCounter()
+	{
+	  print_count(typeid(T).name(), --sInstanceCount, true);
+	}
+};
+
+//static
+template<class T>
+int AIDebugInstanceCounter<T>::sInstanceCount;
+
+//static
+template<class T>
+void AIDebugInstanceCounter<T>::print_count(char const* name, int count, bool destruction)
+{
+  Dout(dc::notice, (destruction ? "Destructed " : "Constructing ") << name << ", now " << count << " instance" << ((count == 1) ? "." : "s."));
+}
+
 //! Debugging macro.
 //
 // Print "Entering " << \a data to channel \a cntrl and increment

indra/develop.py

@@ -169,7 +169,7 @@ class PlatformSetup(object):
             raise
 
     def parse_build_opts(self, arguments):
-        opts, targets = getopt.getopt(arguments, 'o:', ['option='])
+        opts, targets = getopt.getopt(arguments, 'D:o:', ['option='])
         build_opts = []
         for o, a in opts:
             if o in ('-o', '--option'):
@@ -221,6 +221,7 @@ class UnixSetup(PlatformSetup):
     exe_suffixes = ('',)
 
     def __init__(self):
+        PlatformSetup.__init__(self)
         super(UnixSetup, self).__init__()
         self.generator = 'Unix Makefiles'
 
@@ -263,6 +264,7 @@ class UnixSetup(PlatformSetup):
 
 class LinuxSetup(UnixSetup):
     def __init__(self):
+        UnixSetup.__init__(self)
         super(LinuxSetup, self).__init__()
         try:
             self.debian_sarge = open('/etc/debian_version').read().strip() == '3.1'
@@ -384,6 +386,7 @@ class LinuxSetup(UnixSetup):
         
 class DarwinSetup(UnixSetup):
     def __init__(self):
+        UnixSetup.__init__(self)
         super(DarwinSetup, self).__init__()
         self.generator = 'Xcode'
 
@@ -443,14 +446,21 @@ class WindowsSetup(PlatformSetup):
         'vc100' : {
             'gen' : r'Visual Studio 10',
             'ver' : r'10.0'
+            },
+        'vc110' : {
+            'gen' : r'Visual Studio 11',
+            'ver' : r'11.0'
             }
         }
+    
     gens['vs2010'] = gens['vc100']
+    gens['vs2012'] = gens['vc110']
 
     search_path = r'C:\windows'
     exe_suffixes = ('.exe', '.bat', '.com')
 
     def __init__(self):
+        PlatformSetup.__init__(self)
         super(WindowsSetup, self).__init__()
         self._generator = None
         self.incredibuild = False
@@ -491,7 +501,10 @@ class WindowsSetup(PlatformSetup):
         return 'win32'
 
     def build_dirs(self):
-        return ['build-' + self.generator]
+        if self.word_size == 64:
+            return ['build-' + self.generator + '-Win64']
+        else:
+            return ['build-' + self.generator]
 
     def cmake_commandline(self, src_dir, build_dir, opts, simple):
         args = dict(
@@ -503,6 +516,9 @@ class WindowsSetup(PlatformSetup):
             project_name=self.project_name,
             word_size=self.word_size,
             )
+        if self.word_size == 64:
+            args["generator"] += r' Win64'
+
         #if simple:
         #    return 'cmake %(opts)s "%(dir)s"' % args
         return ('cmake -G "%(generator)s" '
@@ -596,15 +612,15 @@ class WindowsSetup(PlatformSetup):
         if environment == '':
             environment = self.find_visual_studio_express()
             if environment == '':
-				environment = self.find_visual_studio_express_single()
+                environment = self.find_visual_studio_express_single()
-				if environment == '':
+                if environment == '':
-					print >> sys.stderr, "Something went very wrong during build stage, could not find a Visual Studio?"
+                    print >> sys.stderr, "Something went very wrong during build stage, could not find a Visual Studio?"
-				else:
+                else:
-					build_dirs=self.build_dirs()
+                    build_dirs=self.build_dirs()
-					print >> sys.stderr, "\nSolution generation complete, it can can now be found in:", build_dirs[0]    
+                    print >> sys.stderr, "\nSolution generation complete, it can can now be found in:", build_dirs[0]    
-					print >> sys.stderr, "\nAs you are using an Express Visual Studio, the build step cannot be automated"
+                    print >> sys.stderr, "\nAs you are using an Express Visual Studio, the build step cannot be automated"
-					print >> sys.stderr, "\nPlease see https://wiki.secondlife.com/wiki/Microsoft_Visual_Studio#Extra_steps_for_Visual_Studio_Express_editions for Visual Studio Express specific information"
+                    print >> sys.stderr, "\nPlease see https://wiki.secondlife.com/wiki/Microsoft_Visual_Studio#Extra_steps_for_Visual_Studio_Express_editions for Visual Studio Express specific information"
-					exit(0)
+                    exit(0)
     
         # devenv.com is CLI friendly, devenv.exe... not so much.
         return ('"%sdevenv.com" %s.sln /build %s' % 
@@ -646,7 +662,7 @@ class WindowsSetup(PlatformSetup):
                           os.path.join(build_dir,'Singularity.sln') +
                           ' --config ' + self.build_type +
                           ' --startup secondlife-bin')
-            print 'Running %r in %r' % (vstool_cmd, getcwd())
+            print 'Running vstool %r in %r' % (vstool_cmd, getcwd())
             self.run(vstool_cmd)        
             print >> open(stamp, 'w'), self.build_type
         
@@ -660,11 +676,11 @@ class WindowsSetup(PlatformSetup):
                 if targets:
                     for t in targets:
                         cmd = '%s /project %s %s' % (build_cmd, t, ' '.join(opts))
-                        print 'Running %r in %r' % (cmd, d)
+                        print 'Running build(targets) %r in %r' % (cmd, d)
                         self.run(cmd)
                 else:
                     cmd = '%s %s' % (build_cmd, ' '.join(opts))
-                    print 'Running %r in %r' % (cmd, d)
+                    print 'Running build %r in %r' % (cmd, d)
                     self.run(cmd)
             finally:
                 os.chdir(cwd)
@@ -685,6 +701,8 @@ class CygwinSetup(WindowsSetup):
             project_name=self.project_name,
             word_size=self.word_size,
             )
+        if self.word_size == 64:
+            args["generator"] += r' Win64'
         #if simple:
         #    return 'cmake %(opts)s "%(dir)s"' % args
         return ('cmake -G "%(generator)s" '

indra/lib/python/indra/util/llmanifest.py

@@ -39,6 +39,7 @@ import shutil
 import sys
 import tarfile
 import errno
+import subprocess
 
 def path_ancestors(path):
     drive, path = os.path.splitdrive(os.path.normpath(path))
@@ -192,6 +193,8 @@ def usage(srctree=""):
             arg['description'] % nd)
 
 def main():
+    print "cwd:", os.getcwd()
+    print " ".join(sys.argv)
     option_names = [arg['name'] + '=' for arg in ARGUMENTS]
     option_names.append('help')
     options, remainder = getopt.getopt(sys.argv[1:], "", option_names)
@@ -266,7 +269,7 @@ class LLManifest(object):
     __metaclass__ = LLManifestRegistry
     manifests = {}
     def for_platform(self, platform, arch = None):
-        if arch:
+        if arch and platform != "windows":
             platform = platform + '_' + arch
         return self.manifests[platform.lower()]
     for_platform = classmethod(for_platform)
@@ -391,20 +394,19 @@ class LLManifest(object):
         debugging/informational purpoases, prints out the command's
         output as it is received."""
         print "Running command:", command
-        fd = os.popen(command, 'r')
+        fd = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
         lines = []
         while True:
-            lines.append(fd.readline())
+            lines.append(fd.stdout.readline())
             if lines[-1] == '':
                 break
             else:
-                print lines[-1],
+                print lines[-1].rstrip('\n'),
         output = ''.join(lines)
-        status = fd.close()
+        if fd.returncode:
-        if status:
             raise RuntimeError(
                 "Command %s returned non-zero status (%s) \noutput:\n%s"
-                % (command, status, output) )
+                % (command, fd.returncode, output) )
         return output
 
     def created_path(self, path):

indra/libhacd/hacdHACD.cpp

@@ -138,7 +138,7 @@ namespace HACD
             if (m_callBack)
             {
                 char msg[1024];
-                sprintf(msg, "nCC %lu\n", m_graph.m_nCCs);
+                sprintf(msg, "nCC %zu\n", m_graph.m_nCCs);
                 (*m_callBack)(msg, 0.0, 0.0,  m_graph.GetNVertices());
                 
             }
@@ -679,7 +679,7 @@ namespace HACD
                 {
 					if ((!condition1) && m_callBack)
 					{
-						sprintf(msg, "\n-> %lu\t%f\t%f\t%f\n", m_pqueue.size(), m_graph.m_vertices[v1].m_surf*100.0/m_area, m_graph.m_vertices[v2].m_surf*100.0/m_area, m_graph.m_edges[currentEdge.m_name].m_concavity);
+						sprintf(msg, "\n-> %zu\t%f\t%f\t%f\n", m_pqueue.size(), m_graph.m_vertices[v1].m_surf*100.0/m_area, m_graph.m_vertices[v2].m_surf*100.0/m_area, m_graph.m_edges[currentEdge.m_name].m_concavity);
 						(*m_callBack)(msg, progress, globalConcavity,  m_graph.GetNVertices());
 					}
 					globalConcavity = std::max<double>(globalConcavity ,m_graph.m_edges[currentEdge.m_name].m_concavity);
@@ -879,7 +879,7 @@ namespace HACD
                 if (m_callBack) 
                 {
                     char msg[1024];
-                    sprintf(msg, "\t CH(%lu) \t %lu \t %lf \t %lu \t %f \t %lu\n", v, static_cast<unsigned long>(p), m_graph.m_vertices[v].m_concavity, m_graph.m_vertices[v].m_distPoints.Size(),  m_graph.m_vertices[v].m_surf*100.0/m_area, m_graph.m_vertices[v].m_ancestors.size());
+                    sprintf(msg, "\t CH(%zu) \t %zu \t %lf \t %zu \t %f \t %zu\n", v, p, m_graph.m_vertices[v].m_concavity, m_graph.m_vertices[v].m_distPoints.Size(),  m_graph.m_vertices[v].m_surf*100.0/m_area, m_graph.m_vertices[v].m_ancestors.size());
 					(*m_callBack)(msg, 0.0, 0.0, m_nClusters);
 					p++;
                 }

indra/libhacd/hacdHACD.h

@@ -22,7 +22,9 @@
 #include <set>
 #include <vector>
 #include <queue>
-
+#if defined(_MSC_VER) && _MSC_VER >= 1700
+#include <functional>
+#endif
 namespace HACD
 {
     const double                                    sc_pi = 3.14159265;
@@ -315,7 +317,7 @@ namespace HACD
         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 HACD * const                         CreateHACD(HeapManager * heapManager);
         friend void                                 DestroyHACD(HACD * const hacd);
 	};
     inline HACD * const CreateHACD(HeapManager * heapManager) 

indra/libhacd/hacdRaycastMesh.cpp

@@ -106,7 +106,7 @@ namespace HACD
 		m_nMaxNodes = 0;
 		for(size_t k = 0; k < maxDepth; k++)
 		{
-			m_nMaxNodes += (1 << maxDepth);
+			m_nMaxNodes += (static_cast<size_t>(1) << maxDepth);
 		}
 		m_nodes = new RMNode[m_nMaxNodes];
 		RMNode & root = m_nodes[AddNode()];

indra/libndhacd/CMakeLists.txt

@@ -7,7 +7,7 @@ include(00-Common)
 include_directories(${LIBS_OPEN_DIR}/libhacd)
 
 set (libndhacd_SOURCE_FILES
-    LLConvexDecomposition.cpp
+    llconvexdecomposition.cpp
     nd_hacdConvexDecomposition.cpp
     nd_hacdStructs.cpp
     nd_hacdUtils.cpp
@@ -16,12 +16,12 @@ set (libndhacd_SOURCE_FILES
 )
 
 set (libndhacd_HEADER_FILES
-    LLConvexDecomposition.h
+    llconvexdecomposition.h
     ndConvexDecomposition.h
     nd_hacdConvexDecomposition.h
     nd_hacdStructs.h
     nd_StructTracer.h
-    LLConvexDecompositionStubImpl.h
+    llconvexdecompositionstubimpl.h
     nd_EnterExitTracer.h
     nd_hacdDefines.h
     nd_hacdUtils.h

indra/libndhacd/llconvexdecomposition.cpp

@@ -1,5 +1,5 @@
 /** 
- * @file   LLConvexDecomposition.cpp
+ * @file   llconvexdecomposition.cpp
  * @author falcon@lindenlab.com
  * @brief  A stub implementation of LLConvexDecomposition interface
  *
@@ -35,7 +35,7 @@
 
 #include "nd_hacdConvexDecomposition.h"
 
-#include "LLConvexDecomposition.h"
+#include "llconvexdecomposition.h"
 
 
 /*static */bool LLConvexDecomposition::s_isInitialized = false;

indra/libndhacd/llconvexdecomposition.h

@@ -1,5 +1,5 @@
 /** 
- * @file LLConvexDecomposition.cpp
+ * @file llconvexdecomposition.cpp
  * @brief LLConvexDecomposition interface definition
  *
  * $LicenseInfo:firstyear=2011&license=viewerlgpl$

indra/libndhacd/llconvexdecompositionstubimpl.cpp

@@ -1,5 +1,5 @@
 /** 
- * @file   LLConvexDecompositionStubImpl.cpp
+ * @file   llconvexdecompositionstubimpl.cpp
  * @author falcon@lindenlab.com
  * @brief  A stub implementation of LLConvexDecomposition
  *
@@ -28,7 +28,7 @@
 
 #include <string.h>
 #include <memory>
-#include "LLConvexDecompositionStubImpl.h"
+#include "llconvexdecompositionstubimpl.h"
 
 LLConvexDecomposition* LLConvexDecompositionImpl::getInstance()
 {

indra/libndhacd/llconvexdecompositionstubimpl.h

@@ -1,5 +1,5 @@
 /** 
- * @file   LLConvexDecompositionStubImpl.h
+ * @file   llconvexdecompositionstubimpl.h
  * @author falcon@lindenlab.com
  * @brief  A stub implementation of LLConvexDecomposition
  *
@@ -29,7 +29,7 @@
 #ifndef LL_CONVEX_DECOMP_UTIL_H
 #define LL_CONVEX_DECOMP_UTIL_H
 
-#include "LLConvexDecomposition.h"
+#include "llconvexdecomposition.h"
 
 class LLConvexDecompositionImpl : public LLConvexDecomposition
 {

indra/libndhacd/nd_StructTracer.h

@@ -21,7 +21,7 @@
 
 
 #include "ndConvexDecomposition.h"
-#include "LLConvexDecomposition.h"
+#include "llconvexdecomposition.h"
 #include "nd_hacdStructs.h"
 
 namespace ndStructTracer

indra/libndhacd/nd_hacdConvexDecomposition.h

@@ -19,7 +19,7 @@
 #ifndef ND_HACD_CONVEXDECOMP_H
 #define ND_HACD_CONVEXDECOMP_H
 
-#include "LLConvexDecomposition.h"
+#include "llconvexdecomposition.h"
 
 #include <map>
 #include <vector>

indra/libndhacd/nd_hacdStructs.cpp

@@ -17,7 +17,6 @@
  */
 
 #include "nd_hacdStructs.h"
-#include "LLConvexDecomposition.h"
 
 void DecompHull::clear()
 {

indra/libndhacd/nd_hacdStructs.h

@@ -21,7 +21,7 @@
 
 #include "nd_hacdDefines.h"
 #include "hacdHACD.h"
-#include "LLConvexDecomposition.h"
+#include "llconvexdecomposition.h"
 #include <vector>
 
 struct LLCDHull;

indra/libndhacd/nd_hacdUtils.h

@@ -20,7 +20,6 @@
 #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 );

indra/linux_crash_logger/CMakeLists.txt

@@ -1,72 +0,0 @@
-# -*- cmake -*-
-
-project(linux_crash_logger)
-
-include(00-Common)
-include(LLCommon)
-include(LLCrashLogger)
-include(LLMath)
-include(LLMessage)
-include(LLVFS)
-include(LLXML)
-include(Linking)
-include(UI)
-
-include_directories(
-    ${LLCOMMON_INCLUDE_DIRS}
-    ${LLCRASHLOGGER_INCLUDE_DIRS}
-    ${LLMATH_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
-    ${LLXML_INCLUDE_DIRS}
-    )
-
-set(linux_crash_logger_SOURCE_FILES
-    linux_crash_logger.cpp
-    llcrashloggerlinux.cpp
-    )
-
-set(linux_crash_logger_HEADER_FILES
-    CMakeLists.txt
-
-    llcrashloggerlinux.h
-    )
-
-set_source_files_properties(${linux_crash_logger_HEADER_FILES}
-                            PROPERTIES HEADER_FILE_ONLY TRUE)
-
-list(APPEND linux_crash_logger_SOURCE_FILES
-     ${linux_crash_logger_HEADER_FILES}
-     )
-
-set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed")
-
-add_executable(linux-crash-logger ${linux_crash_logger_SOURCE_FILES})
-
-target_link_libraries(linux-crash-logger
-    ${LLCRASHLOGGER_LIBRARIES}
-    ${LLVFS_LIBRARIES}
-    ${LLXML_LIBRARIES}
-    ${LLMESSAGE_LIBRARIES}
-    ${LLUI_LIBRARIES}
-    ${LLVFS_LIBRARIES}
-    ${LLMATH_LIBRARIES}
-    ${LLCOMMON_LIBRARIES}
-    ${UI_LIBRARIES}
-    ${DB_LIBRARIES}
-    ${XMLRPCEPI_LIBRARIES}
-    ${CURL_LIBRARIES}
-    ${APR_LIBRARIES}
-    ${APRUTIL_LIBRARIES}
-    ${CRYPTO_LIBRARIES}
-    rt
-    )
-
-add_custom_command(
-    OUTPUT linux-crash-logger-stripped
-    COMMAND strip
-    ARGS --strip-debug -o linux-crash-logger-stripped linux-crash-logger
-    DEPENDS linux-crash-logger
-    )
-
-add_custom_target(linux-crash-logger-strip-target ALL
-                  DEPENDS linux-crash-logger-stripped)

indra/linux_crash_logger/linux_crash_logger.cpp

@@ -1,45 +0,0 @@
-/** 
- * @file linux_crash_logger.cpp
- * @brief Linux crash logger implementation
- *
- * $LicenseInfo:firstyear=2003&license=viewergpl$
- * 
- * Copyright (c) 2003-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * 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, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#include "llcrashloggerlinux.h"
-
-int main(int argc, char **argv)
-{
-	LLCrashLoggerLinux app;
-	app.parseCommandOptions(argc, argv);
-	app.init();
-	app.mainLoop();
-	app.cleanup();
-	return 0;
-}
-
-

indra/linux_crash_logger/llcrashloggerlinux.cpp

@@ -1,148 +0,0 @@
-/** 
- * @file llcrashloggerlinux.cpp
- * @brief Linux crash logger implementation
- *
- * $LicenseInfo:firstyear=2003&license=viewergpl$
- * 
- * Copyright (c) 2003-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * 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, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#include "llcrashloggerlinux.h"
-
-#include <iostream>
-
-#include "linden_common.h"
-
-#include "boost/tokenizer.hpp"
-
-#include "indra_constants.h"	// CRASH_BEHAVIOR_ASK, CRASH_SETTING_NAME
-#include "llerror.h"
-#include "llfile.h"
-#include "lltimer.h"
-#include "llstring.h"
-#include "lldir.h"
-#include "llsdserialize.h"
-
-#if LL_GTK
-# include "gtk/gtk.h"
-#endif // LL_GTK
-
-#define MAX_LOADSTRING 100
-
-// These need to be localized.
-static const char dialog_text[] =
-"Second Life appears to have crashed or frozen last time it ran.\n"
-"This crash reporter collects information about your computer's hardware, operating system, and some Second Life logs, all of which are used for debugging purposes only.\n"
-"\n"
-"Send crash report?";
-
-static const char dialog_title[] =
-"Second Life Crash Logger";
-
-#if LL_GTK
-static void response_callback (GtkDialog *dialog,
-			       gint       arg1,
-			       gpointer   user_data)
-{
-	gint *response = (gint*)user_data;
-	*response = arg1;
-	gtk_widget_destroy(GTK_WIDGET(dialog));
-	gtk_main_quit();
-}
-#endif // LL_GTK
-
-static BOOL do_ask_dialog(void)
-{
-#if LL_GTK
-	gtk_disable_setlocale();
-	if (!gtk_init_check(NULL, NULL)) {
-		llinfos << "Could not initialize GTK for 'ask to send crash report' dialog; not sending report." << llendl;
-		return FALSE;
-	}
-	
-	GtkWidget *win = NULL;
-	GtkDialogFlags flags = GTK_DIALOG_MODAL;
-	GtkMessageType messagetype = GTK_MESSAGE_QUESTION;
-	GtkButtonsType buttons = GTK_BUTTONS_YES_NO;
-	gint response = GTK_RESPONSE_NONE;
-
-	win = gtk_message_dialog_new(NULL,
-				     flags, messagetype, buttons,
-				     "%s", dialog_text);
-	gtk_window_set_type_hint(GTK_WINDOW(win),
-				 GDK_WINDOW_TYPE_HINT_DIALOG);
-	gtk_window_set_title(GTK_WINDOW(win), dialog_title);
-	g_signal_connect (win,
-			  "response", 
-			  G_CALLBACK (response_callback),
-			  &response);
-	gtk_widget_show_all (win);
-	gtk_main();
-
-	return (GTK_RESPONSE_OK == response ||
-		GTK_RESPONSE_YES == response ||
-		GTK_RESPONSE_APPLY == response);
-#else
-	return FALSE;
-#endif // LL_GTK
-}
-
-LLCrashLoggerLinux::LLCrashLoggerLinux(void)
-{
-}
-
-LLCrashLoggerLinux::~LLCrashLoggerLinux(void)
-{
-}
-
-void LLCrashLoggerLinux::gatherPlatformSpecificFiles()
-{
-	mFileMap["CrashLog"] = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"stack_trace.log").c_str();
-}
-
-bool LLCrashLoggerLinux::mainLoop()
-{
-	bool send_logs = true;
-	if(CRASH_BEHAVIOR_ASK == getCrashBehavior())
-	{
-		send_logs = do_ask_dialog();
-	}
-	else if(CRASH_BEHAVIOR_NEVER_SEND == getCrashBehavior())
-	{
-		send_logs = false;
-	}
-
-	if(send_logs)
-	{
-		sendCrashLogs();
-	}
-	return true;
-}
-
-void LLCrashLoggerLinux::updateApplication(const std::string& message)
-{
-	LLCrashLogger::updateApplication(message);
-}

indra/linux_crash_logger/llcrashloggerlinux.h

@@ -1,50 +0,0 @@
-/** 
- * @file llcrashloggerlinux.h
- * @brief Linux crash logger definition
- *
- * $LicenseInfo:firstyear=2003&license=viewergpl$
- * 
- * Copyright (c) 2003-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * 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, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#ifndef LLCRASHLOGGERLINUX_H
-#define LLCRASHLOGGERLINUX_H
-
-#include "linden_common.h"
-#include "llcrashlogger.h"
-#include "llstring.h"
-
-class LLCrashLoggerLinux : public LLCrashLogger
-{
-public:
-	LLCrashLoggerLinux(void);
-	~LLCrashLoggerLinux(void);
-	virtual bool mainLoop();
-	virtual void updateApplication(const std::string& = LLStringUtil::null);
-	virtual void gatherPlatformSpecificFiles();
-};
-
-#endif

indra/llappearance/llavatarappearance.cpp

@@ -983,19 +983,19 @@ BOOL LLAvatarAppearance::loadSkeletonNode ()
 	mRoot->addChild(mMeshLOD[MESH_ID_SKIRT]);
 	mRoot->addChild(mMeshLOD[MESH_ID_HEAD]);
 
-	LLAvatarJoint *skull = (LLAvatarJoint*)mRoot->findJoint("mSkull");
+	LLJoint *skull = mRoot->findJoint("mSkull");
 	if (skull)
 	{
 		skull->addChild(mMeshLOD[MESH_ID_HAIR] );
 	}
 
-	LLAvatarJoint *eyeL = (LLAvatarJoint*)mRoot->findJoint("mEyeLeft");
+	LLJoint *eyeL = mRoot->findJoint("mEyeLeft");
 	if (eyeL)
 	{
 		eyeL->addChild( mMeshLOD[MESH_ID_EYEBALL_LEFT] );
 	}
 
-	LLAvatarJoint *eyeR = (LLAvatarJoint*)mRoot->findJoint("mEyeRight");
+	LLJoint *eyeR = mRoot->findJoint("mEyeRight");
 	if (eyeR)
 	{
 		eyeR->addChild( mMeshLOD[MESH_ID_EYEBALL_RIGHT] );

indra/llappearance/llavatarjoint.cpp

@@ -105,8 +105,9 @@ void LLAvatarJoint::setValid( BOOL valid, BOOL recursive )
 		for (child_list_t::iterator iter = mChildren.begin();
 			 iter != mChildren.end(); ++iter)
 		{
-			LLAvatarJoint* joint = (LLAvatarJoint*)(*iter);
+			LLAvatarJoint* joint = dynamic_cast<LLAvatarJoint*>(*iter);
-			joint->setValid(valid, TRUE);
+			if (joint)
+				joint->setValid(valid, TRUE);
 		}
 	}
 
@@ -124,7 +125,8 @@ void LLAvatarJoint::setSkeletonComponents( U32 comp, BOOL recursive )
 			 iter != mChildren.end(); ++iter)
 		{
 			LLAvatarJoint* joint = dynamic_cast<LLAvatarJoint*>(*iter);
-			joint->setSkeletonComponents(comp, recursive);
+			if (joint)
+				joint->setSkeletonComponents(comp, recursive);
 		}
 	}
 }
@@ -138,8 +140,9 @@ void LLAvatarJoint::setVisible(BOOL visible, BOOL recursive)
 		for (child_list_t::iterator iter = mChildren.begin();
 			 iter != mChildren.end(); ++iter)
 		{
-			LLAvatarJoint* joint = (LLAvatarJoint*)(*iter);
+			LLAvatarJoint* joint = dynamic_cast<LLAvatarJoint*>(*iter);
-			joint->setVisible(visible, recursive);
+			if(joint)
+				joint->setVisible(visible, recursive);
 		}
 	}
 }
@@ -150,7 +153,8 @@ void LLAvatarJoint::updateFaceSizes(U32 &num_vertices, U32& num_indices, F32 pix
 		 iter != mChildren.end(); ++iter)
 	{
 		LLAvatarJoint* joint = dynamic_cast<LLAvatarJoint*>(*iter);
-		joint->updateFaceSizes(num_vertices, num_indices, pixel_area);
+		if (joint)
+			joint->updateFaceSizes(num_vertices, num_indices, pixel_area);
 	}
 }
 
@@ -160,7 +164,8 @@ void LLAvatarJoint::updateFaceData(LLFace *face, F32 pixel_area, BOOL damp_wind,
 		 iter != mChildren.end(); ++iter)
 	{
 		LLAvatarJoint* joint = dynamic_cast<LLAvatarJoint*>(*iter);
-		joint->updateFaceData(face, pixel_area, damp_wind, terse_update);
+		if (joint)
+			joint->updateFaceData(face, pixel_area, damp_wind, terse_update);
 	}
 }
 
@@ -170,7 +175,8 @@ void LLAvatarJoint::updateJointGeometry()
 		 iter != mChildren.end(); ++iter)
 	{
 		LLAvatarJoint* joint = dynamic_cast<LLAvatarJoint*>(*iter);
-		joint->updateJointGeometry();
+		if (joint)
+			joint->updateJointGeometry();
 	}
 }
 
@@ -184,6 +190,9 @@ BOOL LLAvatarJoint::updateLOD(F32 pixel_area, BOOL activate)
 		 iter != mChildren.end(); ++iter)
 	{
 		LLAvatarJoint* joint = dynamic_cast<LLAvatarJoint*>(*iter);
+		if (!joint)
+			continue;
+
 		F32 jointLOD = joint->getLOD();
 		
 		if (found_lod || jointLOD == DEFAULT_AVATAR_JOINT_LOD)
@@ -213,7 +222,8 @@ void LLAvatarJoint::dump()
 		 iter != mChildren.end(); ++iter)
 	{
 		LLAvatarJoint* joint = dynamic_cast<LLAvatarJoint*>(*iter);
-		joint->dump();
+		if (joint)
+			joint->dump();
 	}
 }
 
@@ -260,7 +270,7 @@ void LLAvatarJointCollisionVolume::renderCollision()
 	updateWorldMatrix();
 	
 	gGL.pushMatrix();
-	gGL.multMatrix( &mXform.getWorldMatrix().mMatrix[0][0] );
+	gGL.multMatrix( mXform.getWorldMatrix() );
 
 	gGL.diffuseColor3f( 0.f, 0.f, 1.f );
 	

indra/llappearance/llavatarjointmesh.cpp

@@ -83,30 +83,28 @@ LLSkinJoint::~LLSkinJoint()
 //-----------------------------------------------------------------------------
 // LLSkinJoint::setupSkinJoint()
 //-----------------------------------------------------------------------------
-BOOL LLSkinJoint::setupSkinJoint( LLAvatarJoint *joint)
+void LLSkinJoint::setupSkinJoint( LLJoint *joint)
 {
+	mRootToJointSkinOffset.clearVec();
+	mRootToParentJointSkinOffset.clearVec();
+	
 	// find the named joint
-	mJoint = joint;
+	if (!(mJoint = joint))
-	if ( !mJoint )
 	{
 		llinfos << "Can't find joint" << llendl;
+		return;
 	}
 
 	// compute the inverse root skin matrix
-	mRootToJointSkinOffset.clearVec();
+	do
-
-	LLVector3 rootSkinOffset;
-	while (joint)
 	{
-		rootSkinOffset += joint->getSkinOffset();
+		mRootToJointSkinOffset -= joint->getSkinOffset();
-		joint = (LLAvatarJoint*)joint->getParent();
+	} while (joint = joint->getParent());
-	}
 
-	mRootToJointSkinOffset = -rootSkinOffset;
 	mRootToParentJointSkinOffset = mRootToJointSkinOffset;
 	mRootToParentJointSkinOffset += mJoint->getSkinOffset();
 
-	return TRUE;
+	return;
 }
 
 
@@ -307,15 +305,14 @@ void LLAvatarJointMesh::setMesh( LLPolyMesh *mesh )
 		for (jn = 0; jn < numJointNames; jn++)
 		{
 			//llinfos << "Setting up joint " << jointNames[jn] << llendl;
-			LLAvatarJoint* joint = (LLAvatarJoint*)(getRoot()->findJoint(jointNames[jn]) );
+			mSkinJoints[jn].setupSkinJoint( getRoot()->findJoint(jointNames[jn]) );
-			mSkinJoints[jn].setupSkinJoint( joint );
 		}
 	}
 
 	// setup joint array
 	if (!mMesh->isLOD())
 	{
-		setupJoint((LLAvatarJoint*)getRoot());
+		setupJoint(getRoot());
 	}
 
 //	llinfos << "joint render entries: " << mMesh->mJointRenderData.count() << llendl;
@@ -324,7 +321,7 @@ void LLAvatarJointMesh::setMesh( LLPolyMesh *mesh )
 //-----------------------------------------------------------------------------
 // setupJoint()
 //-----------------------------------------------------------------------------
-void LLAvatarJointMesh::setupJoint(LLAvatarJoint* current_joint)
+void LLAvatarJointMesh::setupJoint(LLJoint* current_joint)
 {
 //	llinfos << "Mesh: " << getName() << llendl;
 
@@ -345,7 +342,7 @@ void LLAvatarJointMesh::setupJoint(LLAvatarJoint* current_joint)
 		if(mMesh->mJointRenderData.count() && mMesh->mJointRenderData[mMesh->mJointRenderData.count() - 1]->mWorldMatrix == &current_joint->getParent()->getWorldMatrix())
 		{
 			// ...then just add ourselves
-			LLAvatarJoint* jointp = js.mJoint;
+			LLJoint* jointp = js.mJoint;
 			mMesh->mJointRenderData.put(new LLJointRenderData(&jointp->getWorldMatrix(), &js));
 //			llinfos << "joint " << joint_count << js.mJoint->getName() << llendl;
 //			joint_count++;
@@ -366,8 +363,9 @@ void LLAvatarJointMesh::setupJoint(LLAvatarJoint* current_joint)
 	for (LLJoint::child_list_t::iterator iter = current_joint->mChildren.begin();
 		 iter != current_joint->mChildren.end(); ++iter)
 	{
-		LLAvatarJoint* child_joint = (LLAvatarJoint*)(*iter);
+		LLAvatarJoint* child_joint = dynamic_cast<LLAvatarJoint*>(*iter);
-		setupJoint(child_joint);
+		if(child_joint)
+			setupJoint(child_joint);
 	}
 }
 

indra/llappearance/llavatarjointmesh.h

@@ -49,9 +49,9 @@ class LLSkinJoint
 public:
 	LLSkinJoint();
 	~LLSkinJoint();
-	BOOL setupSkinJoint( LLAvatarJoint *joint);
+	void setupSkinJoint( LLJoint *joint);
 
-	LLAvatarJoint	*mJoint;
+	LLJoint*		mJoint;
 	LLVector3		mRootToJointSkinOffset;
 	LLVector3		mRootToParentJointSkinOffset;
 };
@@ -122,7 +122,7 @@ public:
 	void setMesh( LLPolyMesh *mesh );
 
 	// Sets up joint matrix data for rendering
-	void setupJoint(LLAvatarJoint* current_joint);
+	void setupJoint(LLJoint* current_joint);
 
 	// Sets ID for picking
 	void setMeshID( S32 id ) {mMeshID = id;}

indra/llappearance/lldriverparam.h

@@ -117,7 +117,8 @@ public:
 	/*virtual*/ void				stopAnimating(BOOL upload_bake);
 	/*virtual*/ BOOL				linkDrivenParams(visual_param_mapper mapper, BOOL only_cross_params);
 	/*virtual*/ void				resetDrivenParams();
-	
+	/*virtual*/ char const*			getTypeString(void) const { return "param_driver"; }
+
 	// LLViewerVisualParam Virtual functions
 	/*virtual*/ F32					getTotalDistortion();
 	/*virtual*/ const LLVector4a&	getAvgDistortion();

indra/llappearance/llpolymesh.cpp

@@ -231,9 +231,9 @@ BOOL LLPolyMeshSharedData::allocateVertexData( U32 numVertices )
         mBaseCoords = (LLVector4a*) ll_aligned_malloc_16(numVertices*sizeof(LLVector4a));
         mBaseNormals = (LLVector4a*) ll_aligned_malloc_16(numVertices*sizeof(LLVector4a));
         mBaseBinormals = (LLVector4a*) ll_aligned_malloc_16(numVertices*sizeof(LLVector4a));
-        mTexCoords = (LLVector2*) ll_aligned_malloc_16(numVertices*sizeof(LLVector2));
+        mTexCoords = (LLVector2*) ll_aligned_malloc_16((numVertices+numVertices%2)*sizeof(LLVector2));
-        mDetailTexCoords = (LLVector2*) ll_aligned_malloc_16(numVertices*sizeof(LLVector2));
+        mDetailTexCoords = (LLVector2*) ll_aligned_malloc_16((numVertices+numVertices%2)*sizeof(LLVector2));
-        mWeights = (F32*) ll_aligned_malloc_16(numVertices*sizeof(F32));
+        mWeights = (F32*) ll_aligned_malloc_16(((numVertices)*sizeof(F32)+0xF) & ~0xF);
         for (i = 0; i < numVertices; i++)
 	{
 		mBaseCoords[i].clear();
@@ -1302,6 +1302,57 @@ BOOL LLPolyMesh::saveOBJ(LLFILE *fp)
 	return TRUE;
 }
 
+// Finds binormal based on three vertices with texture coordinates.
+// Fills in dummy values if the triangle has degenerate texture coordinates.
+void calc_binormal_from_triangle(LLVector4a& binormal,
+
+	const LLVector4a& pos0,
+	const LLVector2& tex0,
+	const LLVector4a& pos1,
+	const LLVector2& tex1,
+	const LLVector4a& pos2,
+	const LLVector2& tex2)
+{
+	LLVector4a rx0( pos0[VX], tex0.mV[VX], tex0.mV[VY] );
+	LLVector4a rx1( pos1[VX], tex1.mV[VX], tex1.mV[VY] );
+	LLVector4a rx2( pos2[VX], tex2.mV[VX], tex2.mV[VY] );
+	
+	LLVector4a ry0( pos0[VY], tex0.mV[VX], tex0.mV[VY] );
+	LLVector4a ry1( pos1[VY], tex1.mV[VX], tex1.mV[VY] );
+	LLVector4a ry2( pos2[VY], tex2.mV[VX], tex2.mV[VY] );
+
+	LLVector4a rz0( pos0[VZ], tex0.mV[VX], tex0.mV[VY] );
+	LLVector4a rz1( pos1[VZ], tex1.mV[VX], tex1.mV[VY] );
+	LLVector4a rz2( pos2[VZ], tex2.mV[VX], tex2.mV[VY] );
+	
+	LLVector4a lhs, rhs;
+
+	LLVector4a r0; 
+	lhs.setSub(rx0, rx1); rhs.setSub(rx0, rx2);
+	r0.setCross3(lhs, rhs);
+		
+	LLVector4a r1;
+	lhs.setSub(ry0, ry1); rhs.setSub(ry0, ry2);
+	r1.setCross3(lhs, rhs);
+
+	LLVector4a r2;
+	lhs.setSub(rz0, rz1); rhs.setSub(rz0, rz2);
+	r2.setCross3(lhs, rhs);
+
+	if( r0[VX] && r1[VX] && r2[VX] )
+	{
+		binormal.set(
+				-r0[VZ] / r0[VX],
+				-r1[VZ] / r1[VX],
+				-r2[VZ] / r2[VX]);
+		// binormal.normVec();
+	}
+	else
+	{
+		binormal.set( 0, 1 , 0 );
+	}
+}
+
 //-----------------------------------------------------------------------------
 // LLPolyMesh::loadOBJ()
 //-----------------------------------------------------------------------------

indra/llappearance/llpolymesh.h

@@ -146,10 +146,10 @@ public:
 class LLJointRenderData
 {
 public:
-	LLJointRenderData(const LLMatrix4* world_matrix, LLSkinJoint* skin_joint) : mWorldMatrix(world_matrix), mSkinJoint(skin_joint) {}
+	LLJointRenderData(const LLMatrix4a* world_matrix, LLSkinJoint* skin_joint) : mWorldMatrix(world_matrix), mSkinJoint(skin_joint) {}
 	~LLJointRenderData(){}
 
-	const LLMatrix4*		mWorldMatrix;
+	const LLMatrix4a*		mWorldMatrix;
 	LLSkinJoint*			mSkinJoint;
 };
 

indra/llappearance/llpolymorph.h

@@ -173,6 +173,7 @@ public:
 	// LLVisualParam Virtual functions
 	///*virtual*/ BOOL				parseData(LLXmlTreeNode* node);
 	/*virtual*/ void				apply( ESex sex );
+	/*virtual*/ char const*			getTypeString(void) const { return "param_morph"; }
 	
 	// LLViewerVisualParam Virtual functions
 	/*virtual*/ F32					getTotalDistortion();

indra/llappearance/llpolyskeletaldistortion.cpp

@@ -154,13 +154,13 @@ BOOL LLPolySkeletalDistortion::setInfo(LLPolySkeletalDistortionInfo *info)
                 for (LLJoint::child_list_t::iterator iter = joint->mChildren.begin();
                      iter != joint->mChildren.end(); ++iter)
                 {
-                        LLAvatarJoint* child_joint = (LLAvatarJoint*)(*iter);
+					LLAvatarJoint* child_joint = dynamic_cast<LLAvatarJoint*>(*iter);
-                        if (child_joint->inheritScale())
+					if (child_joint && child_joint->inheritScale())
-                        {
+                    {
-                                LLVector3 childDeformation = LLVector3(child_joint->getScale());
+                            LLVector3 childDeformation = LLVector3(child_joint->getScale());
-                                childDeformation.scaleVec(bone_info->mScaleDeformation);
+                            childDeformation.scaleVec(bone_info->mScaleDeformation);
-                                mJointScales[child_joint] = childDeformation;
+                            mJointScales[child_joint] = childDeformation;
-                        }
+                    }
                 }
 
                 if (bone_info->mHasPositionDeformation)

indra/llappearance/llpolyskeletaldistortion.h

@@ -68,7 +68,16 @@ class LLPolySkeletalDistortionInfo : public LLViewerVisualParamInfo
 {
 	friend class LLPolySkeletalDistortion;
 public:
-	
+	void* operator new(size_t size)
+	{
+		return ll_aligned_malloc_16(size);
+	}
+
+	void operator delete(void* ptr)
+	{
+		ll_aligned_free_16(ptr);
+	}
+
 	LLPolySkeletalDistortionInfo();
 	/*virtual*/ ~LLPolySkeletalDistortionInfo() {};
 	
@@ -77,12 +86,12 @@ public:
 protected:
 	typedef std::vector<LLPolySkeletalBoneInfo> bone_info_list_t;
 	bone_info_list_t mBoneInfoList;
-};
+} LL_ALIGN_POSTFIX(16);
-
 //-----------------------------------------------------------------------------
 // LLPolySkeletalDeformation
 // A set of joint scale data for deforming the avatar mesh
 //-----------------------------------------------------------------------------
+LL_ALIGN_PREFIX(16)
 class LLPolySkeletalDistortion : public LLViewerVisualParam
 {
 public:
@@ -109,7 +118,8 @@ public:
 	// LLVisualParam Virtual functions
 	///*virtual*/ BOOL				parseData(LLXmlTreeNode* node);
 	/*virtual*/ void				apply( ESex sex );
-	
+	/*virtual*/ char const*			getTypeString(void) const { return "param_skeleton"; }
+
 	// LLViewerVisualParam Virtual functions
 	/*virtual*/ F32					getTotalDistortion() { return 0.1f; }
 	/*virtual*/ const LLVector4a&	getAvgDistortion()	{ return mDefaultVec; }

indra/llappearance/lltexlayer.cpp

@@ -1126,7 +1126,10 @@ BOOL LLTexLayer::render(S32 x, S32 y, S32 width, S32 height)
 	// *TODO: Is this correct?
 	//gPipeline.disableLights();
 	stop_glerror();
-	glDisable(GL_LIGHTING);
+	if (!LLGLSLShader::sNoFixedFunction)
+	{
+		glDisable(GL_LIGHTING);
+	}
 	stop_glerror();
 
 	bool use_shaders = LLGLSLShader::sNoFixedFunction;

indra/llappearance/lltexlayerparams.h

@@ -86,6 +86,7 @@ public:
 	/*virtual*/ void		setWeight(F32 weight, BOOL upload_bake);
 	/*virtual*/ void		setAnimationTarget(F32 target_value, BOOL upload_bake); 
 	/*virtual*/ void		animate(F32 delta, BOOL upload_bake);
+	/*virtual*/ char const* getTypeString(void) const { return "param_alpha"; }
 
 	// LLViewerVisualParam Virtual functions
 	/*virtual*/ F32					getTotalDistortion()									{ return 1.f; }
@@ -177,7 +178,7 @@ public:
 	/*virtual*/ void			setWeight(F32 weight, BOOL upload_bake);
 	/*virtual*/ void			setAnimationTarget(F32 target_value, BOOL upload_bake);
 	/*virtual*/ void			animate(F32 delta, BOOL upload_bake);
-
+	/*virtual*/ char const* getTypeString(void) const { return "param_color"; }
 
 	// LLViewerVisualParam Virtual functions
 	/*virtual*/ F32					getTotalDistortion()									{ return 1.f; }

indra/llappearance/llviewervisualparam.cpp

@@ -143,6 +143,12 @@ BOOL LLViewerVisualParam::setInfo(LLViewerVisualParamInfo *info)
 	return TRUE;
 }
 
+//virtual
+std::string LLViewerVisualParam::getDumpWearableTypeName(void) const
+{
+  return LLWearableType::getTypeName(LLWearableType::EType(getInfo()->mWearableType));
+}
+
 /*
 //=============================================================================
 // These virtual functions should always be overridden,

indra/llappearance/llviewervisualparam.h

@@ -82,6 +82,7 @@ public:
 	
 	// LLVisualParam Virtual functions
 	///*virtual*/ BOOL			parseData(LLXmlTreeNode* node);
+	/*virtual*/ std::string		getDumpWearableTypeName(void) const;
 
 	// New Virtual functions
 	virtual F32					getTotalDistortion() = 0;

indra/llappearance/llwearable.h

@@ -41,6 +41,7 @@ class LLVisualParam;
 class LLTexGlobalColorInfo;
 class LLTexGlobalColor;
 class LLAvatarAppearance;
+class AIArchetype;
 
 // Abstract class.
 class LLWearable

indra/llaudio/llaudiodecodemgr.cpp

@@ -611,8 +611,10 @@ void LLAudioDecodeMgr::Impl::processQueue(const F32 num_secs)
 				llwarns << mCurrentDecodep->getUUID() << " has invalid vorbis data, aborting decode" << llendl;
 				mCurrentDecodep->flushBadFile();
 				LLAudioData *adp = gAudiop->getAudioData(mCurrentDecodep->getUUID());
-				adp->setHasValidData(false);
+				if(adp)
-				adp->setHasCompletedDecode(true);
+				{
+					adp->setLoadState(LLAudioData::STATE_LOAD_ERROR);
+				}
 				mCurrentDecodep = NULL;
 				done = TRUE;
 			}
@@ -634,10 +636,7 @@ void LLAudioDecodeMgr::Impl::processQueue(const F32 num_secs)
 					}
 					else if (mCurrentDecodep->isValid() && mCurrentDecodep->isDone())
 					{
-						adp->setHasCompletedDecode(true);
+						adp->setLoadState(LLAudioData::STATE_LOAD_READY);
-						adp->setHasDecodedData(true);
-						adp->setHasValidData(true);
-
 						// At this point, we could see if anyone needs this sound immediately, but
 						// I'm not sure that there's a reason to - we need to poll all of the playing
 						// sounds anyway.
@@ -645,7 +644,7 @@ void LLAudioDecodeMgr::Impl::processQueue(const F32 num_secs)
 					}
 					else
 					{
-						adp->setHasCompletedDecode(true);
+						adp->setLoadState(LLAudioData::STATE_LOAD_ERROR);
 						llinfos << "Vorbis decode failed for " << mCurrentDecodep->getUUID() << llendl;
 					}
 					mCurrentDecodep = NULL;
@@ -685,6 +684,11 @@ void LLAudioDecodeMgr::Impl::processQueue(const F32 num_secs)
 				mCurrentDecodep = new LLVorbisDecodeState(uuid, d_path);
 				if (!mCurrentDecodep->initDecode())
 				{
+					LLAudioData *adp = gAudiop->getAudioData(uuid);
+					if(adp)
+					{
+						adp->setLoadState(LLAudioData::STATE_LOAD_ERROR);
+					}
 					mCurrentDecodep = NULL;
 				}
 			}
@@ -709,23 +713,13 @@ void LLAudioDecodeMgr::processQueue(const F32 num_secs)
 	mImpl->processQueue(num_secs);
 }
 
-BOOL LLAudioDecodeMgr::addDecodeRequest(const LLUUID &uuid)
+bool LLAudioDecodeMgr::addDecodeRequest(const LLUUID &uuid)
 {
-	if (gAudiop->hasDecodedFile(uuid))
+	if(!uuid.notNull())
-	{
+		return false;
-		// Already have a decoded version, don't need to decode it.
+	else if (!gAssetStorage || !gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND))
-		//llinfos << "addDecodeRequest for " << uuid << " has decoded file already" << llendl;
+		return false;
-		return TRUE;
+	
-	}
+	mImpl->mDecodeQueue.push(uuid);
-
+	return true;
-	if (gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND))
-	{
-		// Just put it on the decode queue.
-		//llinfos << "addDecodeRequest for " << uuid << " has local asset file already" << llendl;
-		mImpl->mDecodeQueue.push(uuid);
-		return TRUE;
-	}
-
-	//llinfos << "addDecodeRequest for " << uuid << " no file available" << llendl;
-	return FALSE;
 }

indra/llaudio/llaudiodecodemgr.h

@@ -24,7 +24,7 @@
  */
 
 #ifndef LL_LLAUDIODECODEMGR_H
-#define LL_LLAUDIODECODEMG_H
+#define LL_LLAUDIODECODEMGR_H
 
 #include "stdtypes.h"
 
@@ -44,7 +44,7 @@ public:
 	~LLAudioDecodeMgr();
 
 	void processQueue(const F32 num_secs = 0.005);
-	BOOL addDecodeRequest(const LLUUID &uuid);
+	bool addDecodeRequest(const LLUUID &uuid);
 	void addAudioRequest(const LLUUID &uuid);
 	
 protected:

indra/llaudio/llaudioengine.h

@@ -147,7 +147,7 @@ public:
 					  const LLVector3d &pos_global = LLVector3d::zero,
 					  const LLUUID source_object = LLUUID::null);
 					  // </edit>
-	bool preloadSound(const LLUUID &id);
+	bool preloadSound(const LLUUID &id);	//Preloads sounds without requiring a source.
 
 	void addAudioSource(LLAudioSource *asp);
 	void cleanupAudioSource(LLAudioSource *asp);
@@ -177,9 +177,6 @@ public:
 	void cleanupBuffer(LLAudioBuffer *bufferp);
 
 	bool hasDecodedFile(const LLUUID &uuid);
-	bool hasLocalFile(const LLUUID &uuid);
-
-	bool updateBufferForData(LLAudioData *adp, const LLUUID &audio_uuid = LLUUID::null);
 
 	void setAllowLargeSounds(bool allow) { mAllowLargeSounds = allow ;}
 	bool getAllowLargeSounds() const {return mAllowLargeSounds;}
@@ -229,7 +226,7 @@ protected:
 	S32 mNumChannels;
 	bool mEnableWind;
 
-	LLUUID mCurrentTransfer; // Audio file currently being transferred by the system
+	LLAudioData* mCurrentTransfer; // Audio file currently being transferred by the system
 	LLFrameTimer mCurrentTransferTimer;
 
 	// A list of all audio sources that are known to the viewer at this time.
@@ -244,6 +241,7 @@ public://Jay: IDGAF
 	source_map mAllSources;
 protected:
 	data_map mAllData;
+	std::list<LLUUID> mPreloadSystemList;
 	LLAudioChannel *mChannels[MAX_CHANNELS];
 
 	// Buffers needs to change into a different data structure, as the number of buffers
@@ -287,9 +285,7 @@ public:
 	virtual void update();						// Update this audio source
 	void updatePriority();
 
-	void preload(const LLUUID &audio_id); // Only used for preloading UI sounds, now.
+	void preload(const LLUUID &audio_id);
-
-	void addAudioData(LLAudioData *adp, bool set_current = TRUE);
 
 	void setAmbient(const bool ambient)						{ mAmbient = ambient; }
 	bool isAmbient() const									{ return mAmbient; }
@@ -319,6 +315,7 @@ public:
 	LLVector3d getPositionGlobal() const							{ return mPositionGlobal; }
 	LLVector3 getVelocity()	const									{ return mVelocity; }				
 	F32 getPriority() const											{ return mPriority; }
+	void setPriority(F32 priority)									{ mPriority = priority; }
 
 	// Gain should always be clamped between 0 and 1.
 	F32 getGain() const												{ return mGain; }
@@ -402,25 +399,27 @@ public:
 	LLUUID getID() const				{ return mID; }
 	LLAudioBuffer *getBuffer() const	{ return mBufferp; }
 
-	bool	hasLocalData() const		{ return mHasLocalData; }
+	enum ELoadState
-	bool	hasDecodedData() const		{ return mHasDecodedData; }
+	{
-	bool	hasCompletedDecode() const	{ return mHasCompletedDecode; }
+		STATE_LOAD_ERROR,
-	bool	hasValidData() const		{ return mHasValidData; }
+		STATE_LOAD_REQ_FETCH,
+		STATE_LOAD_FETCHING,
+		STATE_LOAD_REQ_DECODE,
+		STATE_LOAD_DECODING,
+		STATE_LOAD_READY
+	};
+	ELoadState	getLoadState() const			{ return mLoadState; }
+	ELoadState	setLoadState(ELoadState state)	{ return mLoadState = state; }
+	bool		isInPreload() const				{ return mLoadState > STATE_LOAD_ERROR && mLoadState < STATE_LOAD_READY; }
 
-	void	setHasLocalData(const bool hld)		{ mHasLocalData = hld; }
+	void updateLoadState();
-	void	setHasDecodedData(const bool hdd)	{ mHasDecodedData = hdd; }
-	void	setHasCompletedDecode(const bool hcd)	{ mHasCompletedDecode = hcd; }
-	void	setHasValidData(const bool hvd)		{ mHasValidData = hvd; }
 
 	friend class LLAudioEngine; // Severe laziness, bad.
 
 protected:
 	LLUUID mID;
 	LLAudioBuffer *mBufferp;	// If this data is being used by the audio system, a pointer to the buffer will be set here.
-	bool mHasLocalData;			// Set true if the sound asset file is available locally
+	ELoadState mLoadState;
-	bool mHasDecodedData;		// Set true if the sound file has been decoded
-	bool mHasCompletedDecode;	// Set true when the sound is decoded
-	bool mHasValidData;			// Set false if decoding failed, meaning the sound asset is bad
 };
 
 
@@ -450,11 +449,10 @@ protected:
 	virtual void play() = 0;
 	virtual void playSynced(LLAudioChannel *channelp) = 0;
 	virtual void cleanup();
-	void setWaiting(bool waiting)               { mWaiting = waiting; }
 
 public:
 	virtual bool isPlaying() = 0;
-	bool isWaiting() const						{ return mWaiting; }
+	bool isFree() const							{ return mCurrentSourcep==NULL; }
 
 protected:
 	virtual bool updateBuffer(); // Check to see if the buffer associated with the source changed, and update if necessary.
@@ -465,7 +463,6 @@ protected:
 	LLAudioSource	*mCurrentSourcep;
 	LLAudioBuffer	*mCurrentBufferp;
 	bool			mLoopedThisFrame;
-	bool			mWaiting;	// Waiting for sync.
 	F32             mSecondaryGain;
 };
 

indra/llaudio/llaudioengine_fmod.cpp

@@ -590,6 +590,7 @@ void LLAudioChannelFMOD::cleanup()
 	}
 
 	mChannelID = 0;
+	mLastSamplePos = 0;
 }
 
 
@@ -600,6 +601,12 @@ void LLAudioChannelFMOD::play()
 		llwarns << "Playing without a channelID, aborting" << llendl;
 		return;
 	}
+	
+	if(!FSOUND_IsPaused(mChannelID))
+	{
+		FSOUND_SetPaused(mChannelID, true);
+		FSOUND_SetCurrentPosition(mChannelID, 0);
+	}
 
 	if (!FSOUND_SetPaused(mChannelID, false))
 	{

indra/llaudio/llaudioengine_fmodex.cpp

@@ -59,8 +59,13 @@ bool attemptDelayLoad()
 {
 	__try
 	{
+#if defined(_WIN64)
+		if( FAILED( __HrLoadAllImportsForDll( "fmodex64.dll" ) ) )
+			return false;
+#else
 		if( FAILED( __HrLoadAllImportsForDll( "fmodex.dll" ) ) )
 			return false;
+#endif
 	}
 	__except( EXCEPTION_EXECUTE_HANDLER )
 	{
@@ -97,17 +102,17 @@ public:
 		DEAD,
 		UNKNOWN
 	};
-	STATUS getPtrStatus(LLAudioChannelFMODEX* channel)
+	STATUS getPtrStatus(LLAudioChannel* channel)
 	{
 		if(!channel)
 			return UNKNOWN;
-		return getPtrStatus(channel->mChannelp);
+		return getPtrStatus(dynamic_cast<LLAudioChannelFMODEX*>(channel)->mChannelp);
 	}
-	STATUS getPtrStatus(LLAudioBufferFMODEX* sound)
+	STATUS getPtrStatus(LLAudioBuffer* sound)
 	{
 		if(!sound)
 			return UNKNOWN;
-		return getPtrStatus(sound->mSoundp);
+		return getPtrStatus(dynamic_cast<LLAudioBufferFMODEX*>(sound)->mSoundp);
 	}
 	STATUS getPtrStatus(FMOD::Channel* channel)
 	{
@@ -131,18 +136,14 @@ public:
 	}
 	void addNewSound(FMOD::Sound* sound)
 	{
-		llassert(getPtrStatus(sound) != ACTIVE);
+		assertActiveState(sound,true,false);
 
 		mDeadSounds.erase(sound);
 		mActiveSounds.insert(std::make_pair(sound,std::set<FMOD::Channel*>()));
 	}
 	void removeSound(FMOD::Sound* sound)
 	{
-#ifdef SHOW_ASSERT
+		assertActiveState(sound,true);
-		STATUS status = getPtrStatus(sound);
-		llassert(status != DEAD);
-		llassert(status != UNKNOWN);
-#endif
 
 		active_sounds_t::const_iterator it = mActiveSounds.find(sound);
 		llassert(it != mActiveSounds.end());
@@ -150,49 +151,39 @@ public:
 		{
 			if(!it->second.empty())
 			{
-#ifdef LL_RELEASE_FOR_DOWNLOAD
 				LL_WARNS("AudioImpl")	<< "Removing sound " << sound << " with attached channels: \n";
-#else
-				LL_ERRS("AudioImpl")	<< "Removing sound " << sound << " with attached channels: \n";
-#endif
 				for(std::set<FMOD::Channel*>::iterator it2 = it->second.begin(); it2 != it->second.end();++it2)
 				{
 					switch(getPtrStatus(*it2))
 					{
 					case ACTIVE:
-						llcont << " Channel " << *it2 << " ACTIVE\n";
+						LL_CONT << " Channel " << *it2 << " ACTIVE\n";
 						break;
 					case DEAD:
-						llcont << " Channel " << *it2 << " DEAD\n";
+						LL_CONT << " Channel " << *it2 << " DEAD\n";
 						break;
 					default:
-						llcont << " Channel " << *it2 << " UNKNOWN\n";
+						LL_CONT << " Channel " << *it2 << " UNKNOWN\n";
 					}
 				}
-				llcont << llendl;
+				LL_CONT << LL_ENDL;
 			}
+			llassert(it->second.empty());
 			mDeadSounds.insert(sound);
 			mActiveSounds.erase(sound);
 		}
 	}
 	void addNewChannelToSound(FMOD::Sound* sound,FMOD::Channel* channel)
 	{
-		STATUS status = getPtrStatus(sound);
+		assertActiveState(sound,true);
-		llassert(status != DEAD);
+		assertActiveState(channel,true,false);
-		llassert(status != UNKNOWN);
-		status = getPtrStatus(channel);
-		llassert(status != ACTIVE);
 
 		mActiveSounds[sound].insert(channel);
 		mActiveChannels.insert(std::make_pair(channel,sound));
 	}
 	void removeChannel(FMOD::Channel* channel)
 	{
-#ifdef SHOW_ASSERT
+		assertActiveState(channel,true);
-		STATUS status = getPtrStatus(channel);
-		llassert(status != DEAD);
-		llassert(status != UNKNOWN);
-#endif
 
 		active_channels_t::const_iterator it = mActiveChannels.find(channel);
 		llassert(it != mActiveChannels.end());
@@ -214,25 +205,32 @@ public:
 			mActiveChannels.erase(channel);
 		}
 	}
+
+	template <typename T>
+	void assertActiveState(T ptr, bool try_log=false, bool active=true)
+	{
+#ifndef SHOW_ASSERT
+		if(try_log && sVerboseDebugging)
+#endif
+		{
+			CFMODSoundChecks::STATUS chan = getPtrStatus(ptr);
+			if(try_log && sVerboseDebugging)
+			{
+				if(active)
+				{
+					if(chan == CFMODSoundChecks::DEAD)
+						LL_WARNS("AudioImpl") << __FUNCTION__ << ": Using unexpectedly dead " << typeid(T*).name() << " " << ptr << LL_ENDL;
+					else if(chan == CFMODSoundChecks::UNKNOWN)
+						LL_WARNS("AudioImpl") << __FUNCTION__ << ": Using unexpectedly unknown " << typeid(T*).name() << " " << ptr << LL_ENDL;
+				}
+				else if(chan == CFMODSoundChecks::ACTIVE)
+						LL_WARNS("AudioImpl") << __FUNCTION__ << ": Using unexpectedly active " << typeid(T*).name() << " " << ptr << LL_ENDL;
+			}
+			llassert( active == (chan == CFMODSoundChecks::ACTIVE) );
+		}
+	}
 } gSoundCheck;
 
-bool isActive(LLAudioChannel* channel)
-{
-	return gSoundCheck.getPtrStatus(dynamic_cast<LLAudioChannelFMODEX*>(channel)) == CFMODSoundChecks::ACTIVE;
-}
-bool isActive(LLAudioBuffer* sound)
-{
-	return gSoundCheck.getPtrStatus(dynamic_cast<LLAudioBufferFMODEX*>(sound)) == CFMODSoundChecks::ACTIVE;
-}
-
-#define CHECK_PTR(ptr) \
-	if(sVerboseDebugging){\
-	CFMODSoundChecks::STATUS chan = gSoundCheck.getPtrStatus(ptr); \
-	if(chan == CFMODSoundChecks::DEAD) \
-		LL_DEBUGS("AudioImpl") << __FUNCTION__ << ": Using dead " << typeid(ptr).name() << " " << ptr << llendl; \
-	else if(chan == CFMODSoundChecks::UNKNOWN) \
-		LL_DEBUGS("AudioImpl") << __FUNCTION__ << ": Using unknown " << typeid(ptr).name() << " " << ptr << llendl;} \
-
 LLAudioEngine_FMODEX::LLAudioEngine_FMODEX(bool enable_profiler, bool verbose_debugging)
 {
 	sVerboseDebugging = verbose_debugging;
@@ -253,7 +251,7 @@ inline bool Check_FMOD_Error(FMOD_RESULT result, const char *string)
 {
 	if(result == FMOD_OK)
 		return false;
-	LL_WARNS("AudioImpl") << string << " Error: " << FMOD_ErrorString(result) << llendl;
+	LL_WARNS("AudioImpl") << string << " Error: " << FMOD_ErrorString(result) << LL_ENDL;
 	return true;
 }
 
@@ -261,11 +259,11 @@ void* F_STDCALL decode_alloc(unsigned int size, FMOD_MEMORY_TYPE type, const cha
 {
 	if(type & FMOD_MEMORY_STREAM_DECODE)
 	{
-		LL_INFOS("AudioImpl") << "Decode buffer size: " << size << llendl;
+		LL_INFOS("AudioImpl") << "Decode buffer size: " << size << LL_ENDL;
 	}
 	else if(type & FMOD_MEMORY_STREAM_FILE)
 	{
-		LL_INFOS("AudioImpl") << "Stream buffer size: " << size << llendl;
+		LL_INFOS("AudioImpl") << "Stream buffer size: " << size << LL_ENDL;
 	}
 	return new char[size];
 }
@@ -504,7 +502,7 @@ void LLAudioEngine_FMODEX::allocateListener(void)
 	mListenerp = (LLListener *) new LLListener_FMODEX(mSystem);
 	if (!mListenerp)
 	{
-		LL_WARNS("AudioImpl") << "Listener creation failed" << llendl;
+		LL_WARNS("AudioImpl") << "Listener creation failed" << LL_ENDL;
 	}
 }
 
@@ -513,16 +511,18 @@ void LLAudioEngine_FMODEX::shutdown()
 {
 	stopInternetStream();
 
-	LL_INFOS("AudioImpl") << "About to LLAudioEngine::shutdown()" << llendl;
+	LL_INFOS("AudioImpl") << "About to LLAudioEngine::shutdown()" << LL_ENDL;
 	LLAudioEngine::shutdown();
 	
-	LL_INFOS("AudioImpl") << "LLAudioEngine_FMODEX::shutdown() closing FMOD Ex" << llendl;
+	LL_INFOS("AudioImpl") << "LLAudioEngine_FMODEX::shutdown() closing FMOD Ex" << LL_ENDL;
 	if ( mSystem ) // speculative fix for MAINT-2657
 	{
-	mSystem->close();
+		LL_INFOS("AudioImpl") << "LLAudioEngine_FMODEX::shutdown() Requesting FMOD Ex system closure" << LL_ENDL;
-	mSystem->release();
+		mSystem->close();
+		LL_INFOS("AudioImpl") << "LLAudioEngine_FMODEX::shutdown() Requesting FMOD Ex system release" << LL_ENDL;
+		mSystem->release();
 	}
-	LL_INFOS("AudioImpl") << "LLAudioEngine_FMODEX::shutdown() done closing FMOD Ex" << llendl;
+	LL_INFOS("AudioImpl") << "LLAudioEngine_FMODEX::shutdown() done closing FMOD Ex" << LL_ENDL;
 
 	delete mListenerp;
 	mListenerp = NULL;
@@ -654,7 +654,7 @@ LLAudioChannelFMODEX::LLAudioChannelFMODEX(FMOD::System *system) : LLAudioChanne
 LLAudioChannelFMODEX::~LLAudioChannelFMODEX()
 {
 	if(sVerboseDebugging)
-		LL_DEBUGS("AudioImpl") << "Destructing Audio Channel. mChannelp = " << mChannelp << llendl;
+		LL_DEBUGS("AudioImpl") << "Destructing Audio Channel. mChannelp = " << mChannelp << LL_ENDL;
 
 	cleanup();
 }
@@ -678,7 +678,7 @@ void LLAudioChannelFMODEX::onRelease()
 {
 	llassert(mChannelp);
 	if(sVerboseDebugging)
-		LL_DEBUGS("AudioImpl") << "Fmod signaled channel release for channel  " << mChannelp << llendl;
+		LL_DEBUGS("AudioImpl") << "Fmod signaled channel release for channel  " << mChannelp << LL_ENDL;
 	gSoundCheck.removeChannel(mChannelp);
 	mChannelp = NULL;	//Null out channel here so cleanup doesn't try to redundantly stop it.
 	cleanup();
@@ -688,42 +688,32 @@ bool LLAudioChannelFMODEX::updateBuffer()
 {
 	if (LLAudioChannel::updateBuffer())
 	{
-		// Base class update returned true, which means that we need to actually
+		// Base class update returned true, which means the channel buffer was changed, and not is null.
-		// set up the channel for a different buffer.
-
-		LLAudioBufferFMODEX *bufferp = (LLAudioBufferFMODEX *)mCurrentSourcep->getCurrentBuffer();
-
-		llassert(mCurrentBufferp != NULL);
-		llassert(mCurrentBufferp == bufferp);
 
 		// Grab the FMOD sample associated with the buffer
-		FMOD::Sound *soundp = bufferp->getSound();
+		FMOD::Sound *soundp = ((LLAudioBufferFMODEX*)mCurrentBufferp)->getSound();
 		if (!soundp)
 		{
 			// This is bad, there should ALWAYS be a sound associated with a legit
 			// buffer.
-			LL_ERRS("AudioImpl") << "No FMOD sound!" << llendl;
+			LL_ERRS("AudioImpl") << "No FMOD sound!" << LL_ENDL;
 			return false;
 		}
 
-
 		// Actually play the sound.  Start it off paused so we can do all the necessary
 		// setup.
 		if(!mChannelp)
 		{
-			llassert(!isActive(this));
-
 			FMOD_RESULT result = getSystem()->playSound(FMOD_CHANNEL_FREE, soundp, true, &mChannelp);
 			Check_FMOD_Error(result, "FMOD::System::playSound");
 			if(result == FMOD_OK)
 			{
 				if(sVerboseDebugging)
-					LL_DEBUGS("AudioImpl") << "Created channel " << mChannelp << " for sound " << soundp << llendl;
+					LL_DEBUGS("AudioImpl") << "Created channel " << mChannelp << " for sound " << soundp << LL_ENDL;
 
 				gSoundCheck.addNewChannelToSound(soundp,mChannelp);
 				mChannelp->setCallback(&channel_callback);
 				mChannelp->setUserData(this);
-				llassert(isActive(this));
 			}
 		}
 	}
@@ -731,11 +721,9 @@ bool LLAudioChannelFMODEX::updateBuffer()
 	// If we have a source for the channel, we need to update its gain.
 	if (mCurrentSourcep && mChannelp)
 	{
-		// SJB: warnings can spam and hurt framerate, disabling
 		FMOD_RESULT result;
 
-		CHECK_PTR(mChannelp);
+		gSoundCheck.assertActiveState(this);
-
 		result = mChannelp->setVolume(getSecondaryGain() * mCurrentSourcep->getGain());
 		Check_FMOD_Error(result, "FMOD::Channel::setVolume");
 		result = mChannelp->setMode(mCurrentSourcep->isLoop() ? FMOD_LOOP_NORMAL : FMOD_LOOP_OFF);
@@ -762,7 +750,7 @@ void LLAudioChannelFMODEX::update3DPosition()
 		return;
 	}
 
-	CHECK_PTR(mChannelp);
+	gSoundCheck.assertActiveState(this);
 
 	if (mCurrentSourcep->isAmbient())
 	{
@@ -790,7 +778,7 @@ void LLAudioChannelFMODEX::updateLoop()
 		return;
 	}
 
-	CHECK_PTR(mChannelp);
+	gSoundCheck.assertActiveState(this);
 
 	//
 	// Hack:  We keep track of whether we looped or not by seeing when the
@@ -814,26 +802,20 @@ void LLAudioChannelFMODEX::cleanup()
 
 	if (!mChannelp)
 	{
-		llassert(!isActive(this));
 		llassert(mCurrentBufferp == NULL);
-		//llinfos << "Aborting cleanup with no channel handle." << llendl;
+		//LL_INFOS("AudioImpl") << "Aborting cleanup with no channel handle." << LL_ENDL;
 		return;
 	}
 
-	CHECK_PTR(mChannelp);
-
 	if(sVerboseDebugging)
-		LL_DEBUGS("AudioImpl") << "Stopping channel " << mChannelp << llendl;
+		LL_DEBUGS("AudioImpl") << "Stopping channel " << mChannelp << LL_ENDL;
 
+	gSoundCheck.removeChannel(mChannelp);
 	mChannelp->setCallback(NULL);
-	if(!Check_FMOD_Error(mChannelp->stop(),"FMOD::Channel::stop"))
+	Check_FMOD_Error(mChannelp->stop(),"FMOD::Channel::stop");
-	{
-		gSoundCheck.removeChannel(mChannelp);
-	}
 
 	mChannelp = NULL;
-	llassert(!isActive(this));
+	mLastSamplePos = 0;
-
 }
 
 
@@ -841,18 +823,23 @@ void LLAudioChannelFMODEX::play()
 {
 	if (!mChannelp)
 	{
-		LL_WARNS("AudioImpl") << "Playing without a channel handle, aborting" << llendl;
+		LL_WARNS("AudioImpl") << "Playing without a channel handle, aborting" << LL_ENDL;
 		return;
 	}
 
-	llassert(isActive(this));
+	gSoundCheck.assertActiveState(this,true);
-
-	CHECK_PTR(mChannelp);
 
+	bool paused=true;
+	Check_FMOD_Error(mChannelp->getPaused(&paused), "FMOD::Channel::getPaused");
+	if(!paused)
+	{
+		Check_FMOD_Error(mChannelp->setPaused(true), "FMOD::Channel::setPaused");
+		Check_FMOD_Error(mChannelp->setPosition(0,FMOD_TIMEUNIT_PCMBYTES), "FMOD::Channel::setPosition");
+	}
 	Check_FMOD_Error(mChannelp->setPaused(false), "FMOD::Channel::setPaused");
 
 	if(sVerboseDebugging)
-		LL_DEBUGS("AudioImpl") << "Playing channel " << mChannelp << llendl;
+		LL_DEBUGS("AudioImpl") << "Playing channel " << mChannelp << LL_ENDL;
 
 	getSource()->setPlayedOnce(true);
 
@@ -870,10 +857,10 @@ void LLAudioChannelFMODEX::playSynced(LLAudioChannel *channelp)
 		return;
 	}
 
-	CHECK_PTR(mChannelp);
+	gSoundCheck.assertActiveState(this,true);
 
 	U32 cur_pos;
-	if(Check_FMOD_Error(mChannelp->getPosition(&cur_pos,FMOD_TIMEUNIT_PCMBYTES), "Unable to retrieve current position"))
+	if(Check_FMOD_Error(fmod_channelp->mChannelp->getPosition(&cur_pos,FMOD_TIMEUNIT_PCMBYTES), "Unable to retrieve current position"))
 		return;
 
 	cur_pos %= mCurrentBufferp->getLength();
@@ -893,7 +880,7 @@ bool LLAudioChannelFMODEX::isPlaying()
 		return false;
 	}
 
-	CHECK_PTR(mChannelp);
+	gSoundCheck.assertActiveState(this);
 
 	bool paused, playing;
 	Check_FMOD_Error(mChannelp->getPaused(&paused),"FMOD::Channel::getPaused");
@@ -917,11 +904,10 @@ LLAudioBufferFMODEX::~LLAudioBufferFMODEX()
 	if(mSoundp)
 	{
 		if(sVerboseDebugging)
-			LL_DEBUGS("AudioImpl") << "Release sound " << mSoundp << llendl;
+			LL_DEBUGS("AudioImpl") << "Release sound " << mSoundp << LL_ENDL;
 
-		CHECK_PTR(mSoundp);
-		Check_FMOD_Error(mSoundp->release(),"FMOD::Sound::Release");
 		gSoundCheck.removeSound(mSoundp);
+		Check_FMOD_Error(mSoundp->release(),"FMOD::Sound::Release");
 		mSoundp = NULL;
 	}
 }
@@ -945,10 +931,9 @@ bool LLAudioBufferFMODEX::loadWAV(const std::string& filename)
 	
 	if (mSoundp)
 	{
-		CHECK_PTR(mSoundp);
+		gSoundCheck.removeSound(mSoundp);
 		// If there's already something loaded in this buffer, clean it up.
 		Check_FMOD_Error(mSoundp->release(),"FMOD::Sound::release");
-		gSoundCheck.removeSound(mSoundp);
 		mSoundp = NULL;
 	}
 
@@ -967,7 +952,7 @@ bool LLAudioBufferFMODEX::loadWAV(const std::string& filename)
 	if (result != FMOD_OK)
 	{
 		// We failed to load the file for some reason.
-		LL_WARNS("AudioImpl") << "Could not load data '" << filename << "': " << FMOD_ErrorString(result) << llendl;
+		LL_WARNS("AudioImpl") << "Could not load data '" << filename << "': " << FMOD_ErrorString(result) << LL_ENDL;
 
 		//
 		// If we EVER want to load wav files provided by end users, we need
@@ -992,7 +977,7 @@ U32 LLAudioBufferFMODEX::getLength()
 		return 0;
 	}
 
-	CHECK_PTR(mSoundp);
+	gSoundCheck.assertActiveState(this);
 	U32 length;
 	Check_FMOD_Error(mSoundp->getLength(&length, FMOD_TIMEUNIT_PCMBYTES),"FMOD::Sound::getLength");
 	return length;
@@ -1001,7 +986,7 @@ U32 LLAudioBufferFMODEX::getLength()
 
 void LLAudioChannelFMODEX::set3DMode(bool use3d)
 {
-	CHECK_PTR(mChannelp);
+	gSoundCheck.assertActiveState(this);
 
 	FMOD_MODE current_mode;
 	if(Check_FMOD_Error(mChannelp->getMode(&current_mode),"FMOD::Channel::getMode"))

indra/llaudio/llaudioengine_openal.cpp

@@ -189,6 +189,7 @@ void LLAudioChannelOpenAL::cleanup()
 	LLAudioChannel::cleanup();
 	alSourceStop(mALSource);
 	alSourcei(mALSource, AL_BUFFER, AL_NONE);
+	mLastSamplePos = 0;
 }
 
 void LLAudioChannelOpenAL::play()
@@ -199,11 +200,13 @@ void LLAudioChannelOpenAL::play()
 		return;
 	}
 
-	if(!isPlaying())
+	if(isPlaying())
 	{
-		alSourcePlay(mALSource);
+		alSourceStop(mALSource);
-		getSource()->setPlayedOnce(true);
 	}
+
+	alSourcePlay(mALSource);
+	getSource()->setPlayedOnce(true);
 }
 
 void LLAudioChannelOpenAL::playSynced(LLAudioChannel *channelp)

indra/llaudio/lllistener_openal.cpp

@@ -39,6 +39,13 @@ LLListener_OpenAL::~LLListener_OpenAL()
 {
 }
 
+void LLListener_OpenAL::init()
+{
+	// do inherited
+	LLListener::init();
+	mRolloffFactor = 1.0f;
+}
+
 void LLListener_OpenAL::translate(LLVector3 offset)
 {
 	//llinfos << "LLListener_OpenAL::translate() : " << offset << llendl;

indra/llaudio/lllistener_openal.h

@@ -38,6 +38,7 @@ class LLListener_OpenAL  : public LLListener
  public:  
 	LLListener_OpenAL();
 	virtual ~LLListener_OpenAL();
+	virtual void init();
 
 	virtual void translate(LLVector3 offset);
 	virtual void setPosition(LLVector3 pos);

indra/llcharacter/CMakeLists.txt

@@ -29,7 +29,6 @@ set(llcharacter_SOURCE_FILES
     lljointsolverrp3.cpp
     llkeyframefallmotion.cpp
     llkeyframemotion.cpp
-    llkeyframemotionparam.cpp
     llkeyframestandmotion.cpp
     llkeyframewalkmotion.cpp
     llmotion.cpp
@@ -57,7 +56,6 @@ set(llcharacter_HEADER_FILES
     lljointstate.h
     llkeyframefallmotion.h
     llkeyframemotion.h
-    llkeyframemotionparam.h
     llkeyframestandmotion.h
     llkeyframewalkmotion.h
     llmotion.h

indra/llcharacter/llcharacter.cpp

@@ -72,21 +72,11 @@ LLCharacter::~LLCharacter()
 		delete param;
 	}
 
-	U32 i ;
+	bool erased = vector_replace_with_last(sInstances,this);
-	U32 size = sInstances.size() ;
-	for(i = 0 ; i < size ; i++)
-	{
-		if(sInstances[i] == this)
-		{
-			break ;
-		}
-	}
 
-	llassert_always(i < size) ;
+	llassert_always(erased) ;
 
 	llassert_always(sAllowInstancesChange) ;
-	sInstances[i] = sInstances[size - 1] ;
-	sInstances.pop_back() ;
 }
 
 
@@ -136,7 +126,6 @@ LLMotion* LLCharacter::findMotion( const LLUUID &id )
 
 //-----------------------------------------------------------------------------
 // createMotion()
-// NOTE: Always assign the result to a LLPointer!
 //-----------------------------------------------------------------------------
 LLMotion* LLCharacter::createMotion( const LLUUID &id )
 {
@@ -195,11 +184,26 @@ void LLCharacter::updateMotions(e_update_t update_type)
 {
 	if (update_type == HIDDEN_UPDATE)
 	{
+		//<singu>
+		// Keep updating avatars that have at least one motion that is synchronized with a still running motion.
+		// This call tells the other controllers that we are in principle hidden.
+		// It returns false if we need to keep updating anyway.
+		if (!mMotionController.hidden(true))
+		{
+			mMotionController.updateMotions(LLCharacter::NORMAL_UPDATE);
+			return;
+		}
+		//</singu>
 		LLFastTimer t(FTM_UPDATE_HIDDEN_ANIMATION);
 		mMotionController.updateMotionsMinimal();
 	}
 	else
 	{
+		//<singu>
+		// This call tells the other controllers that we are visible and that they need
+		// to keep updating if they are synchronized with us, even if they are hidden.
+		mMotionController.hidden(false);
+		//</singu>
 		LLFastTimer t(FTM_UPDATE_ANIMATION);
 		// unpause if the number of outstanding pause requests has dropped to the initial one
 		if (mMotionController.isPaused() && mPauseRequest->getNumRefs() == 1)
@@ -529,3 +533,17 @@ LLAnimPauseRequest LLCharacter::requestPause()
 	return mPauseRequest;
 }
 
+void LLCharacter::requestPause(std::vector<LLAnimPauseRequest>& avatar_pause_handles)
+{
+	mMotionController.pauseAllMotions();
+	avatar_pause_handles.push_back(mPauseRequest);
+}
+
+void LLCharacter::pauseAllSyncedCharacters(std::vector<LLAnimPauseRequest>& avatar_pause_handles)
+{
+	// Pause this avatar.
+	requestPause(avatar_pause_handles);
+	// Also pause all avatars with synchronized motions.
+	mMotionController.pauseAllSyncedCharacters(avatar_pause_handles);
+}
+

indra/llcharacter/llcharacter.h

@@ -146,6 +146,7 @@ public:
 
 	// is this motion active?
 	BOOL isMotionActive( const LLUUID& id );
+	bool isMotionActive(U32 bit) const { return mMotionController.isactive(bit); }
 
 	// Event handler for motion deactivation.
 	// Called when a motion has completely stopped and has been deactivated.
@@ -158,6 +159,8 @@ public:
 	void updateMotions(e_update_t update_type);
 
 	LLAnimPauseRequest requestPause();
+	void requestPause(std::vector<LLAnimPauseRequest>& avatar_pause_handles);
+	void pauseAllSyncedCharacters(std::vector<LLAnimPauseRequest>& avatar_pause_handles);
 	BOOL areAnimationsPaused() const { return mMotionController.isPaused(); }
 	void setAnimTimeFactor(F32 factor) { mMotionController.setTimeFactor(factor); }
 	void setTimeStep(F32 time_step) { mMotionController.setTimeStep(time_step); }

indra/llcharacter/lleditingmotion.cpp

@@ -49,7 +49,7 @@ S32 LLEditingMotion::sHandPosePriority = 3;
 // LLEditingMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLEditingMotion::LLEditingMotion( const LLUUID &id) : LLMotion(id)
+LLEditingMotion::LLEditingMotion(LLUUID const& id, LLMotionController* controller) : AIMaskedMotion(id, controller, ANIM_AGENT_EDITING)
 {
 	mCharacter = NULL;
 
@@ -155,7 +155,7 @@ BOOL LLEditingMotion::onActivate()
 	mShoulderJoint.setRotation(	mShoulderState->getJoint()->getRotation() );
 	mElbowJoint.setRotation(	mElbowState->getJoint()->getRotation() );
 
-	return TRUE;
+	return AIMaskedMotion::onActivate();
 }
 
 //-----------------------------------------------------------------------------
@@ -215,7 +215,16 @@ BOOL LLEditingMotion::onUpdate(F32 time, U8* joint_mask)
 	if (!target.isFinite())
 	{
 		llwarns << "Non finite target in editing motion with target distance of " << target_dist << 
-			" and focus point " << focus_pt << " and pointAtPt: " << *pointAtPt << llendl;
+			" and focus point " << focus_pt << " and pointAtPt: ";
+		if (pointAtPt)
+		{
+		  llcont << *pointAtPt;
+		}
+		else
+		{
+		  llcont << "NULL";
+		}
+		llcont << llendl;
 	}
 	
 	mTarget.setPosition( target + mParentJoint.getPosition());
@@ -247,12 +256,4 @@ BOOL LLEditingMotion::onUpdate(F32 time, U8* joint_mask)
 	return result;
 }
 
-//-----------------------------------------------------------------------------
-// LLEditingMotion::onDeactivate()
-//-----------------------------------------------------------------------------
-void LLEditingMotion::onDeactivate()
-{
-}
-
-
 // End

indra/llcharacter/lleditingmotion.h

@@ -49,11 +49,11 @@
 // class LLEditingMotion
 //-----------------------------------------------------------------------------
 class LLEditingMotion :
-	public LLMotion
+	public AIMaskedMotion
 {
 public:
 	// Constructor
-	LLEditingMotion(const LLUUID &id);
+	LLEditingMotion(LLUUID const& id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLEditingMotion();
@@ -65,7 +65,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLEditingMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLEditingMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------
@@ -107,9 +107,6 @@ public:
 	// must return FALSE when the motion is completed.
 	virtual BOOL onUpdate(F32 time, U8* joint_mask);
 
-	// called when a motion is deactivated
-	virtual void onDeactivate();
-
 public:
 	//-------------------------------------------------------------------------
 	// joint states to be animated

indra/llcharacter/llhandmotion.cpp

@@ -61,7 +61,7 @@ const F32 HAND_MORPH_BLEND_TIME = 0.2f;
 // LLHandMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLHandMotion::LLHandMotion(const LLUUID &id) : LLMotion(id)
+LLHandMotion::LLHandMotion(LLUUID const& id, LLMotionController* controller) : AIMaskedMotion(id, controller, ANIM_AGENT_HAND_MOTION)
 {
 	mCharacter = NULL;
 	mLastTime = 0.f;
@@ -112,7 +112,7 @@ BOOL LLHandMotion::onActivate()
 		mCharacter->setVisualParamWeight(gHandPoseNames[mCurrentPose], 1.f);
 		mCharacter->updateVisualParams();
 	}
-	return TRUE;
+	return AIMaskedMotion::onActivate();
 }
 
 
@@ -235,14 +235,6 @@ BOOL LLHandMotion::onUpdate(F32 time, U8* joint_mask)
 	return TRUE;
 }
 
-
-//-----------------------------------------------------------------------------
-// LLHandMotion::onDeactivate()
-//-----------------------------------------------------------------------------
-void LLHandMotion::onDeactivate()
-{
-}
-
 //-----------------------------------------------------------------------------
 // LLHandMotion::getHandPoseName()
 //-----------------------------------------------------------------------------

indra/llcharacter/llhandmotion.h

@@ -45,7 +45,7 @@
 // class LLHandMotion
 //-----------------------------------------------------------------------------
 class LLHandMotion :
-	public LLMotion
+	public AIMaskedMotion
 {
 public:
 	typedef enum e_hand_pose
@@ -68,7 +68,7 @@ public:
 	} eHandPose;
 
 	// Constructor
-	LLHandMotion(const LLUUID &id);
+	LLHandMotion(LLUUID const& id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLHandMotion();
@@ -80,7 +80,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLHandMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLHandMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------
@@ -122,9 +122,6 @@ public:
 	// must return FALSE when the motion is completed.
 	virtual BOOL onUpdate(F32 time, U8* joint_mask);
 
-	// called when a motion is deactivated
-	virtual void onDeactivate();
-
 	virtual BOOL canDeprecate() { return FALSE; }
 
 	static std::string getHandPoseName(eHandPose pose);

indra/llcharacter/llheadrotmotion.cpp

@@ -76,8 +76,8 @@ const F32 EYE_BLINK_TIME_DELTA = 0.005f; // time between one eye starting a blin
 // LLHeadRotMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLHeadRotMotion::LLHeadRotMotion(const LLUUID &id) : 
+LLHeadRotMotion::LLHeadRotMotion(LLUUID const& id, LLMotionController* controller) :
-	LLMotion(id),
+	AIMaskedMotion(id, controller, ANIM_AGENT_HEAD_ROT),
 	mCharacter(NULL),
 	mTorsoJoint(NULL),
 	mHeadJoint(NULL)
@@ -104,7 +104,10 @@ LLHeadRotMotion::~LLHeadRotMotion()
 LLMotion::LLMotionInitStatus LLHeadRotMotion::onInitialize(LLCharacter *character)
 {
 	if (!character)
+	{
+		llwarns << "character is NULL." << llendl;
 		return STATUS_FAILURE;
+	}
 	mCharacter = character;
 
 	mPelvisJoint = character->getJoint("mPelvis");
@@ -169,16 +172,6 @@ LLMotion::LLMotionInitStatus LLHeadRotMotion::onInitialize(LLCharacter *characte
 	return STATUS_SUCCESS;
 }
 
-
-//-----------------------------------------------------------------------------
-// LLHeadRotMotion::onActivate()
-//-----------------------------------------------------------------------------
-BOOL LLHeadRotMotion::onActivate()
-{
-	return TRUE;
-}
-
-
 //-----------------------------------------------------------------------------
 // LLHeadRotMotion::onUpdate()
 //-----------------------------------------------------------------------------
@@ -263,19 +256,11 @@ BOOL LLHeadRotMotion::onUpdate(F32 time, U8* joint_mask)
 }
 
 
-//-----------------------------------------------------------------------------
-// LLHeadRotMotion::onDeactivate()
-//-----------------------------------------------------------------------------
-void LLHeadRotMotion::onDeactivate()
-{
-}
-
-
 //-----------------------------------------------------------------------------
 // LLEyeMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLEyeMotion::LLEyeMotion(const LLUUID &id) : LLMotion(id)
+LLEyeMotion::LLEyeMotion(LLUUID const& id, LLMotionController* controller) : AIMaskedMotion(id, controller, ANIM_AGENT_EYE)
 {
 	mCharacter = NULL;
 	mEyeJitterTime = 0.f;
@@ -343,16 +328,6 @@ LLMotion::LLMotionInitStatus LLEyeMotion::onInitialize(LLCharacter *character)
 	return STATUS_SUCCESS;
 }
 
-
-//-----------------------------------------------------------------------------
-// LLEyeMotion::onActivate()
-//-----------------------------------------------------------------------------
-BOOL LLEyeMotion::onActivate()
-{
-	return TRUE;
-}
-
-
 //-----------------------------------------------------------------------------
 // LLEyeMotion::onUpdate()
 //-----------------------------------------------------------------------------
@@ -533,6 +508,8 @@ void LLEyeMotion::onDeactivate()
 	{
 		joint->setRotation(LLQuaternion::DEFAULT);
 	}
+
+	AIMaskedMotion::onDeactivate();
 }
 
 // End

indra/llcharacter/llheadrotmotion.h

@@ -46,11 +46,11 @@
 // class LLHeadRotMotion
 //-----------------------------------------------------------------------------
 class LLHeadRotMotion :
-	public LLMotion
+	public AIMaskedMotion
 {
 public:
 	// Constructor
-	LLHeadRotMotion(const LLUUID &id);
+	LLHeadRotMotion(LLUUID const& id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLHeadRotMotion();
@@ -62,7 +62,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLHeadRotMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLHeadRotMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------
@@ -94,19 +94,11 @@ public:
 	// must return true to indicate success and be available for activation
 	virtual LLMotionInitStatus onInitialize(LLCharacter *character);
 
-	// called when a motion is activated
-	// must return TRUE to indicate success, or else
-	// it will be deactivated
-	virtual BOOL onActivate();
-
 	// called per time step
 	// must return TRUE while it is active, and
 	// must return FALSE when the motion is completed.
 	virtual BOOL onUpdate(F32 time, U8* joint_mask);
 
-	// called when a motion is deactivated
-	virtual void onDeactivate();
-
 public:
 	//-------------------------------------------------------------------------
 	// joint states to be animated
@@ -129,11 +121,11 @@ public:
 // class LLEyeMotion
 //-----------------------------------------------------------------------------
 class LLEyeMotion :
-	public LLMotion
+	public AIMaskedMotion
 {
 public:
 	// Constructor
-	LLEyeMotion(const LLUUID &id);
+	LLEyeMotion(LLUUID const& id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLEyeMotion();
@@ -145,7 +137,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create( const LLUUID &id) { return new LLEyeMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLEyeMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------
@@ -177,11 +169,6 @@ public:
 	// must return true to indicate success and be available for activation
 	virtual LLMotionInitStatus onInitialize(LLCharacter *character);
 
-	// called when a motion is activated
-	// must return TRUE to indicate success, or else
-	// it will be deactivated
-	virtual BOOL onActivate();
-
 	// called per time step
 	// must return TRUE while it is active, and
 	// must return FALSE when the motion is completed.

indra/llcharacter/lljoint.cpp

@@ -312,19 +312,15 @@ void LLJoint::setWorldPosition( const LLVector3& pos )
 		return;
 	}
 
-	LLMatrix4 temp_matrix = getWorldMatrix();
+	LLMatrix4a temp_matrix = getWorldMatrix();
-	temp_matrix.mMatrix[VW][VX] = pos.mV[VX];
+	temp_matrix.setTranslate_affine(pos);
-	temp_matrix.mMatrix[VW][VY] = pos.mV[VY];
-	temp_matrix.mMatrix[VW][VZ] = pos.mV[VZ];
 
-	LLMatrix4 parentWorldMatrix = mParent->getWorldMatrix();
+	LLMatrix4a invParentWorldMatrix = mParent->getWorldMatrix();
-	LLMatrix4 invParentWorldMatrix = parentWorldMatrix.invert();
+	invParentWorldMatrix.invert();
 
-	temp_matrix *= invParentWorldMatrix;
+	invParentWorldMatrix.mul(temp_matrix);
 
-	LLVector3 localPos(	temp_matrix.mMatrix[VW][VX],
+	LLVector3 localPos(	invParentWorldMatrix.getRow<LLMatrix4a::ROW_TRANS>().getF32ptr() );
-						temp_matrix.mMatrix[VW][VY],
-						temp_matrix.mMatrix[VW][VZ] );
 
 	setPosition( localPos );
 }
@@ -383,19 +379,19 @@ void LLJoint::setWorldRotation( const LLQuaternion& rot )
 		this->setRotation( rot );
 		return;
 	}
+	
+	LLMatrix4a parentWorldMatrix = mParent->getWorldMatrix();
+	LLQuaternion2 rota(rot);
+	LLMatrix4a temp_mat(rota);
 
-	LLMatrix4 temp_mat(rot);
+	LLMatrix4a invParentWorldMatrix = mParent->getWorldMatrix();
+	invParentWorldMatrix.setTranslate_affine(LLVector3(0.f));
 
-	LLMatrix4 parentWorldMatrix = mParent->getWorldMatrix();
+	invParentWorldMatrix.invert();
-	parentWorldMatrix.mMatrix[VW][VX] = 0;
-	parentWorldMatrix.mMatrix[VW][VY] = 0;
-	parentWorldMatrix.mMatrix[VW][VZ] = 0;
 
-	LLMatrix4 invParentWorldMatrix = parentWorldMatrix.invert();
+	invParentWorldMatrix.mul(temp_mat);
 
-	temp_mat *= invParentWorldMatrix;
+	setRotation(LLQuaternion(LLMatrix4(invParentWorldMatrix.getF32ptr())));
-
-	setRotation(LLQuaternion(temp_mat));
 }
 
 
@@ -425,7 +421,7 @@ void LLJoint::setScale( const LLVector3& scale )
 //--------------------------------------------------------------------
 // getWorldMatrix()
 //--------------------------------------------------------------------
-const LLMatrix4 &LLJoint::getWorldMatrix()
+const LLMatrix4a &LLJoint::getWorldMatrix()
 {
 	updateWorldMatrixParent();
 

indra/llcharacter/lljoint.h

@@ -41,7 +41,7 @@
 #include "lldarray.h"
 
 const S32 LL_CHARACTER_MAX_JOINTS_PER_MESH = 15;
-const U32 LL_CHARACTER_MAX_JOINTS = 32; // must be divisible by 4!
+const U32 LL_CHARACTER_MAX_JOINTS = 32; // must be divisible by 16!
 const U32 LL_HAND_JOINT_NUM = 31;
 const U32 LL_FACE_JOINT_NUM = 30;
 const S32 LL_CHARACTER_MAX_PRIORITY = 7;
@@ -162,7 +162,7 @@ public:
 	void setScale( const LLVector3& scale );
 
 	// get/set world matrix
-	const LLMatrix4 &getWorldMatrix();
+	const LLMatrix4a &getWorldMatrix();
 	void setWorldMatrix( const LLMatrix4& mat );
 
 	void updateWorldMatrixChildren();

indra/llcharacter/lljointsolverrp3.cpp

@@ -171,12 +171,14 @@ void LLJointSolverRP3::solve()
 	//-------------------------------------------------------------------------
 	// get the poleVector in world space
 	//-------------------------------------------------------------------------
-	LLMatrix4 worldJointAParentMat;
+	LLVector3 poleVec = mPoleVector;
 	if ( mJointA->getParent() )
 	{
-		worldJointAParentMat = mJointA->getParent()->getWorldMatrix();
+		LLVector4a pole_veca;
+		pole_veca.load3(mPoleVector.mV);
+		mJointA->getParent()->getWorldMatrix().rotate(pole_veca,pole_veca);
+		poleVec.set(pole_veca.getF32ptr());
 	}
-	LLVector3 poleVec = rotate_vector( mPoleVector, worldJointAParentMat );
 
 	//-------------------------------------------------------------------------
 	// compute the following:

indra/llcharacter/llkeyframefallmotion.cpp

@@ -49,7 +49,7 @@
 // LLKeyframeFallMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLKeyframeFallMotion::LLKeyframeFallMotion(const LLUUID &id) : LLKeyframeMotion(id)
+LLKeyframeFallMotion::LLKeyframeFallMotion(LLUUID const& id, LLMotionController* controller) : LLKeyframeMotion(id, controller)
 {
 	mVelocityZ = 0.f;
 	mCharacter = NULL;

indra/llcharacter/llkeyframefallmotion.h

@@ -47,7 +47,7 @@ class LLKeyframeFallMotion :
 {
 public:
 	// Constructor
-	LLKeyframeFallMotion(const LLUUID &id);
+	LLKeyframeFallMotion(LLUUID const& id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLKeyframeFallMotion();
@@ -59,7 +59,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLKeyframeFallMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLKeyframeFallMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------

indra/llcharacter/llkeyframemotion.cpp

@@ -84,38 +84,55 @@ LLKeyframeMotion::JointMotionList::~JointMotionList()
 	for_each(mJointMotionArray.begin(), mJointMotionArray.end(), DeletePointer());
 }
 
-U32 LLKeyframeMotion::JointMotionList::dumpDiagInfo()
+//Singu: add parameter 'silent'.
+U32 LLKeyframeMotion::JointMotionList::dumpDiagInfo(bool silent) const
 {
 	S32	total_size = sizeof(JointMotionList);
 
 	for (U32 i = 0; i < getNumJointMotions(); i++)
 	{
-		LLKeyframeMotion::JointMotion* joint_motion_p = mJointMotionArray[i];
+		LLKeyframeMotion::JointMotion const* joint_motion_p = mJointMotionArray[i];
 
-		llinfos << "\tJoint " << joint_motion_p->mJointName << llendl;
+		if (!silent)
+		{
+			llinfos << "\tJoint " << joint_motion_p->mJointName << llendl;
+		}
 		if (joint_motion_p->mUsage & LLJointState::SCALE)
 		{
-			llinfos << "\t" << joint_motion_p->mScaleCurve.mNumKeys << " scale keys at " 
+			if (!silent)
-			<< joint_motion_p->mScaleCurve.mNumKeys * sizeof(ScaleKey) << " bytes" << llendl;
+			{
-
+				llinfos << "\t" << joint_motion_p->mScaleCurve.mNumKeys << " scale keys at "
+				<< joint_motion_p->mScaleCurve.mNumKeys * sizeof(ScaleKey) << " bytes" << llendl;
+			}
 			total_size += joint_motion_p->mScaleCurve.mNumKeys * sizeof(ScaleKey);
 		}
 		if (joint_motion_p->mUsage & LLJointState::ROT)
 		{
-			llinfos << "\t" << joint_motion_p->mRotationCurve.mNumKeys << " rotation keys at " 
+			if (!silent)
-			<< joint_motion_p->mRotationCurve.mNumKeys * sizeof(RotationKey) << " bytes" << llendl;
+			{
-
+				llinfos << "\t" << joint_motion_p->mRotationCurve.mNumKeys << " rotation keys at "
+				<< joint_motion_p->mRotationCurve.mNumKeys * sizeof(RotationKey) << " bytes" << llendl;
+			}
 			total_size += joint_motion_p->mRotationCurve.mNumKeys * sizeof(RotationKey);
 		}
 		if (joint_motion_p->mUsage & LLJointState::POS)
 		{
-			llinfos << "\t" << joint_motion_p->mPositionCurve.mNumKeys << " position keys at " 
+			if (!silent)
-			<< joint_motion_p->mPositionCurve.mNumKeys * sizeof(PositionKey) << " bytes" << llendl;
+			{
-
+				llinfos << "\t" << joint_motion_p->mPositionCurve.mNumKeys << " position keys at "
+				<< joint_motion_p->mPositionCurve.mNumKeys * sizeof(PositionKey) << " bytes" << llendl;
+			}
 			total_size += joint_motion_p->mPositionCurve.mNumKeys * sizeof(PositionKey);
 		}
 	}
-	llinfos << "Size: " << total_size << " bytes" << llendl;
+	//Singu: Also add memory used by the constraints.
+	S32 constraints_size = mConstraints.size() * sizeof(constraint_list_t::value_type);
+	total_size += constraints_size;
+	if (!silent)
+	{
+		llinfos << "\t" << mConstraints.size() << " constraints at " << constraints_size << " bytes" << llendl;
+		llinfos << "Size: " << total_size << " bytes" << llendl;
+	}
 
 	return total_size;
 }
@@ -427,9 +444,8 @@ void LLKeyframeMotion::JointMotion::update(LLJointState* joint_state, F32 time,
 // LLKeyframeMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLKeyframeMotion::LLKeyframeMotion(const LLUUID &id) 
+LLKeyframeMotion::LLKeyframeMotion(const LLUUID &id, LLMotionController* controller)
-	: LLMotion(id),
+	: LLMotion(id, controller),
-		mJointMotionList(NULL),
 		mPelvisp(NULL),
 		mLastSkeletonSerialNum(0),
 		mLastUpdateTime(0.f),
@@ -452,9 +468,9 @@ LLKeyframeMotion::~LLKeyframeMotion()
 //-----------------------------------------------------------------------------
 // create()
 //-----------------------------------------------------------------------------
-LLMotion *LLKeyframeMotion::create(const LLUUID &id)
+LLMotion* LLKeyframeMotion::create(LLUUID const& id, LLMotionController* controller)
 {
-	return new LLKeyframeMotion(id);
+	return new LLKeyframeMotion(id, controller);
 }
 
 //-----------------------------------------------------------------------------
@@ -484,7 +500,9 @@ LLJoint* LLKeyframeMotion::getJoint(U32 index)
 		index = (S32)mJointStates.size() - 1;
 	// </edit>
 	LLJoint* joint = mJointStates[index]->getJoint();
-	llassert_always (joint);
+	if(!joint) {
+		LL_WARNS_ONCE("Animation") << "Missing joint index:"<< index << " ID:" << mID << " Name:" << mName << LL_ENDL;
+	}
 	return joint;
 }
 
@@ -515,6 +533,7 @@ LLMotion::LLMotionInitStatus LLKeyframeMotion::onInitialize(LLCharacter *charact
 	case ASSET_FETCHED:
 		return STATUS_HOLD;
 	case ASSET_FETCH_FAILED:
+		llwarns << "Trying to initialize a motion that failed to be fetched." << llendl;
 		return STATUS_FAILURE;
 	case ASSET_LOADED:
 		return STATUS_SUCCESS;
@@ -524,7 +543,7 @@ LLMotion::LLMotionInitStatus LLKeyframeMotion::onInitialize(LLCharacter *charact
 		break;
 	}
 
-	LLKeyframeMotion::JointMotionList* joint_motion_list = LLKeyframeDataCache::getKeyframeData(getID());
+	LLKeyframeMotion::JointMotionListPtr joint_motion_list = LLKeyframeDataCache::getKeyframeData(getID());
 
 	if(joint_motion_list)
 	{
@@ -799,7 +818,44 @@ void LLKeyframeMotion::onDeactivate()
 //-----------------------------------------------------------------------------
 // setStopTime()
 //-----------------------------------------------------------------------------
-// time is in seconds since character creation
+//
+// Consider a looping animation of 20 frames, where the loop in point is at 3 frames
+// and the loop out point at 16 frames:
+//
+// The first 3 frames of the animation would be the "loop in" animation.
+// The last 4 frames of the animation would be the "loop out" animation.
+// Frames 4 through 15 would be the looping animation frames.
+//
+// If the animation would not be looping, all frames would just be played once sequentially:
+//
+// mActivationTimestamp -.
+//                       v
+//						 0  3         15 16  20
+//						 |  |           \|   |
+//						 ---------------------
+//                       <-->                    <-- mLoopInPoint (relative to mActivationTimestamp)
+//                       <-------------->        <-- mLoopOutPoint (relative to mActivationTimestamp)
+//                       <----mDuration------>
+//
+// When looping the animation would repeat frames 3 to 16 (loop) a few times, for example:
+//
+// 0  3         15 3         15 3         15 3         15 16  20
+// |  |  loop 1   \|  loop 2   \|  loop 3   \|  loop 4   \|   |
+// ------------------------------------------------------------
+//LOOP^                                             ^      LOOP
+// IN |                                      <----->|      OUT
+//  start_loop_time          loop_fraction_time-'  time
+//
+// The time at which the animation is started corresponds to frame 0 and is stored
+// in mActivationTimestamp (in seconds since character creation).
+//
+// If setStopTime() is called with a time somewhere inside loop 4,
+// then 'loop_fraction_time' is the time from the beginning of
+// loop 4 till 'time'. Thus 'time - loop_fraction_time' is the first
+// frame of loop 4, and '(time - loop_fraction_time) +
+// (mJointMotionList->mDuration - mJointMotionList->mLoopInPoint)'
+// would correspond to frame 20.
+//
 void LLKeyframeMotion::setStopTime(F32 time)
 {
 	LLMotion::setStopTime(time);
@@ -817,6 +873,8 @@ void LLKeyframeMotion::setStopTime(F32 time)
 			loop_fraction_time = fmod(time - start_loop_time, 
 				mJointMotionList->mLoopOutPoint - mJointMotionList->mLoopInPoint);
 		}
+		// This sets mStopTimestamp to the time that corresponds to the end of the animation (ie, frame 20 in the above example)
+		// minus the ease out duration, so that the animation eases out during the loop out and finishes exactly at the end.
 		mStopTimestamp = llmax(time, 
 			(time - loop_fraction_time) + (mJointMotionList->mDuration - mJointMotionList->mLoopInPoint) - getEaseOutDuration());
 	}
@@ -1225,13 +1283,42 @@ void LLKeyframeMotion::applyConstraint(JointConstraint* constraint, F32 time, U8
 	}
 }
 
+// Helper class.
+template<typename T>
+struct AIAutoDestruct
+{
+  T* mPtr;
+  AIAutoDestruct() : mPtr(NULL) { }
+  ~AIAutoDestruct() { delete mPtr; }
+  void add(T* ptr) { mPtr = ptr; }
+};
+
 //-----------------------------------------------------------------------------
 // deserialize()
 //-----------------------------------------------------------------------------
 BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp)
 {
 	BOOL old_version = FALSE;
-	mJointMotionList = new LLKeyframeMotion::JointMotionList;
+
+	//<singu>
+
+	// First add a new LLKeyframeMotion::JointMotionList to the cache, then assign a pointer
+	// to that to mJointMotionList. In LLs code the cache is never deleted again. Now it is
+	// is deleted when the last mJointMotionList pointer is destructed.
+	//
+	// It is possible that we get here for an already added animation, because animations can
+	// be requested multiple times (we get here from LLKeyframeMotion::onLoadComplete) when
+	// the animation was still downloading from a previous request for another LLMotionController
+	// object (avatar). In that case we just overwrite the old data while decoding it again.
+	mJointMotionList = LLKeyframeDataCache::getKeyframeData(getID());
+	bool singu_new_joint_motion_list = !mJointMotionList;
+	if (singu_new_joint_motion_list)
+	{
+		// Create a new JointMotionList.
+		mJointMotionList = LLKeyframeDataCache::createKeyframeData(getID());
+	}
+
+	//</singu>
 
 	//-------------------------------------------------------------------------
 	// get base priority
@@ -1394,8 +1481,10 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp)
 		return FALSE;
 	}
 
-	mJointMotionList->mJointMotionArray.clear();
+	if (singu_new_joint_motion_list)
-	mJointMotionList->mJointMotionArray.reserve(num_motions);
+	{
+		mJointMotionList->mJointMotionArray.reserve(num_motions);
+	}
 	mJointStates.clear();
 	mJointStates.reserve(num_motions);
 
@@ -1405,8 +1494,19 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp)
 
 	for(U32 i=0; i<num_motions; ++i)
 	{
+		AIAutoDestruct<JointMotion> watcher;
+
 		JointMotion* joint_motion = new JointMotion;		
-		mJointMotionList->mJointMotionArray.push_back(joint_motion);
+		if (singu_new_joint_motion_list)
+		{
+			// Pass ownership to mJointMotionList.
+			mJointMotionList->mJointMotionArray.push_back(joint_motion);
+		}
+		else
+		{
+			// Just delete this at the end.
+			watcher.add(joint_motion);
+		}
 		
 		std::string joint_name;
 		if (!dp.unpackString(joint_name, "joint_name"))
@@ -1834,7 +1934,15 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp)
 				return FALSE;
 			}
 
-			mJointMotionList->mConstraints.push_front(constraintp);
+			AIAutoDestruct<JointConstraintSharedData> watcher;
+			if (singu_new_joint_motion_list)
+			{
+				mJointMotionList->mConstraints.push_front(constraintp);
+			}
+			else
+			{
+				watcher.add(constraintp);
+			}
 
 			constraintp->mJointStateIndices = new S32[constraintp->mChainLength + 1]; // note: mChainLength is size-limited - comes from a byte
 			
@@ -1874,15 +1982,12 @@ BOOL LLKeyframeMotion::deserialize(LLDataPacker& dp)
 				if (constraintp->mJointStateIndices[i] < 0 )
 				{
 					llwarns << "No joint index for constraint " << i << llendl;
-					delete constraintp;
 					return FALSE;
 				}
 			}
 		}
 	}
 
-	// *FIX: support cleanup of old keyframe data
-	LLKeyframeDataCache::addKeyframeData(getID(),  mJointMotionList);
 	mAssetStatus = ASSET_LOADED;
 
 	setupPose();
@@ -2224,16 +2329,24 @@ void LLKeyframeMotion::onLoadComplete(LLVFS *vfs,
 //--------------------------------------------------------------------
 // LLKeyframeDataCache::dumpDiagInfo()
 //--------------------------------------------------------------------
-void LLKeyframeDataCache::dumpDiagInfo()
+// <singu>
+// quiet = 0 : print everything in detail.
+//         1 : print the UUIDs of all animations in the cache and the total memory usage.
+//         2 : only print the total memory usage.
+// </singu>
+void LLKeyframeDataCache::dumpDiagInfo(int quiet)
 {
 	// keep track of totals
 	U32 total_size = 0;
 
 	char buf[1024];		/* Flawfinder: ignore */
 
-	llinfos << "-----------------------------------------------------" << llendl;
+	if (quiet < 2)
-	llinfos << "       Global Motion Table (DEBUG only)" << llendl;
+	{
-	llinfos << "-----------------------------------------------------" << llendl;
+	  llinfos << "-----------------------------------------------------" << llendl;
+	  llinfos << "       Global Motion Table" << llendl;
+	  llinfos << "-----------------------------------------------------" << llendl;
+	}
 
 	// print each loaded mesh, and it's memory usage
 	for (keyframe_data_map_t::iterator map_it = sKeyframeDataMap.begin();
@@ -2241,30 +2354,46 @@ void LLKeyframeDataCache::dumpDiagInfo()
 	{
 		U32 joint_motion_kb;
 
-		LLKeyframeMotion::JointMotionList *motion_list_p = map_it->second;
+		LLKeyframeMotion::JointMotionList const* motion_list_p = map_it->get();
 
-		llinfos << "Motion: " << map_it->first << llendl;
+		if (quiet < 2)
+		{
+			llinfos << "Motion: " << map_it->key() << llendl;
+		}
 
-		joint_motion_kb = motion_list_p->dumpDiagInfo();
+		if (motion_list_p)
-
+		{
-		total_size += joint_motion_kb;
+		  joint_motion_kb = motion_list_p->dumpDiagInfo(quiet);
+		  total_size += joint_motion_kb;
+		}
 	}
 
-	llinfos << "-----------------------------------------------------" << llendl;
+	if (quiet < 2)
+	{
+		llinfos << "-----------------------------------------------------" << llendl;
+	}
 	llinfos << "Motions\tTotal Size" << llendl;
 	snprintf(buf, sizeof(buf), "%d\t\t%d bytes", (S32)sKeyframeDataMap.size(), total_size );		/* Flawfinder: ignore */
 	llinfos << buf << llendl;
-	llinfos << "-----------------------------------------------------" << llendl;
+	if (quiet < 2)
+	{
+		llinfos << "-----------------------------------------------------" << llendl;
+	}
 }
 
 
 //--------------------------------------------------------------------
-// LLKeyframeDataCache::addKeyframeData()
+// LLKeyframeDataCache::createKeyframeData()
 //--------------------------------------------------------------------
-void LLKeyframeDataCache::addKeyframeData(const LLUUID& id, LLKeyframeMotion::JointMotionList* joint_motion_listp)
+//<singu> This function replaces LLKeyframeDataCache::addKeyframeData and was rewritten to fix a memory leak (aka, the usage of AICachedPointer).
+LLKeyframeMotion::JointMotionListPtr LLKeyframeDataCache::createKeyframeData(LLUUID const& id)
 {
-	sKeyframeDataMap[id] = joint_motion_listp;
+	std::pair<keyframe_data_map_t::iterator, bool> result =
+		sKeyframeDataMap.insert(AICachedPointer<LLUUID, LLKeyframeMotion::JointMotionList>(id, new LLKeyframeMotion::JointMotionList, &sKeyframeDataMap));
+	llassert(result.second);	// id may not already exist in the cache.
+	return &*result.first;		// Construct and return a JointMotionListPt from a pointer to the actually inserted AICachedPointer.
 }
+//</singu>
 
 //--------------------------------------------------------------------
 // LLKeyframeDataCache::removeKeyframeData()
@@ -2274,7 +2403,6 @@ void LLKeyframeDataCache::removeKeyframeData(const LLUUID& id)
 	keyframe_data_map_t::iterator found_data = sKeyframeDataMap.find(id);
 	if (found_data != sKeyframeDataMap.end())
 	{
-		delete found_data->second;
 		sKeyframeDataMap.erase(found_data);
 	}
 }
@@ -2282,14 +2410,14 @@ void LLKeyframeDataCache::removeKeyframeData(const LLUUID& id)
 //--------------------------------------------------------------------
 // LLKeyframeDataCache::getKeyframeData()
 //--------------------------------------------------------------------
-LLKeyframeMotion::JointMotionList* LLKeyframeDataCache::getKeyframeData(const LLUUID& id)
+LLKeyframeMotion::JointMotionListPtr LLKeyframeDataCache::getKeyframeData(const LLUUID& id)
 {
 	keyframe_data_map_t::iterator found_data = sKeyframeDataMap.find(id);
 	if (found_data == sKeyframeDataMap.end())
 	{
 		return NULL;
 	}
-	return found_data->second;
+	return &*found_data;			// Construct and return a JointMotionListPt from a pointer to the found AICachedPointer.
 }
 
 //--------------------------------------------------------------------
@@ -2305,7 +2433,6 @@ LLKeyframeDataCache::~LLKeyframeDataCache()
 //-----------------------------------------------------------------------------
 void LLKeyframeDataCache::clear()
 {
-	for_each(sKeyframeDataMap.begin(), sKeyframeDataMap.end(), DeletePairedPointer());
 	sKeyframeDataMap.clear();
 }
 

indra/llcharacter/llkeyframemotion.h

@@ -5,6 +5,7 @@
  * $LicenseInfo:firstyear=2001&license=viewergpl$
  * 
  * Copyright (c) 2001-2009, Linden Research, Inc.
+ * AICachedPointer and AICachedPointPtr copyright (c) 2013, Aleric Inglewood.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -48,10 +49,12 @@
 #include "v3dmath.h"
 #include "v3math.h"
 #include "llbvhconsts.h"
+#include <boost/intrusive_ptr.hpp>
 
 class LLKeyframeDataCache;
 class LLVFS;
 class LLDataPacker;
+class LLMotionController;
 
 #define MIN_REQUIRED_PIXEL_AREA_KEYFRAME (40.f)
 #define MAX_CHAIN_LENGTH (4)
@@ -59,6 +62,112 @@ class LLDataPacker;
 const S32 KEYFRAME_MOTION_VERSION = 1;
 const S32 KEYFRAME_MOTION_SUBVERSION = 0;
 
+//-----------------------------------------------------------------------------
+// <singu>
+
+template<typename KEY, typename T>
+class AICachedPointer;
+
+template<typename KEY, typename T>
+void intrusive_ptr_add_ref(AICachedPointer<KEY, T> const* p);
+
+template<typename KEY, typename T>
+void intrusive_ptr_release(AICachedPointer<KEY, T> const* p);
+
+template<typename KEY, typename T>
+class AICachedPointer
+{
+  public:
+	typedef std::set<AICachedPointer<KEY, T> > container_type;
+
+  private:
+	KEY mKey;							// The unique key.
+	LLPointer<T> mData;					// The actual data pointer.
+	container_type* mCache;				// Pointer to the underlaying cache.
+	mutable int mRefCount;				// Number of AICachedPointerPtr's pointing to this object.
+
+  public:
+	// Construct a NULL pointer. This is needed when adding a new entry to a std::set, it is always first default constructed.
+	AICachedPointer(void) : mCache(NULL) { }
+
+	// Copy constructor. This is needed to replace the std::set inserted instance with its actual value.
+	AICachedPointer(AICachedPointer const& cptr) : mKey(cptr.mKey), mData(cptr.mData), mCache(cptr.mCache), mRefCount(0) { }
+
+	// Construct a AICachedPointer that points to 'ptr' with key 'key'.
+	AICachedPointer(KEY const& key, T* ptr, container_type* cache) : mKey(key), mData(ptr), mCache(cache), mRefCount(-1) { }
+
+	// Construct a temporary NULL pointer that can be used in a search for a key.
+	AICachedPointer(KEY const& key) : mKey(key), mCache(NULL) { }
+
+	// Accessors for key and data.
+	KEY const& key(void) const { return mKey; }
+	T const* get(void) const { return mData.get(); }
+	T* get(void) { return mData.get(); }
+
+	// Order only by key.
+	friend bool operator<(AICachedPointer const& cp1, AICachedPointer const& cp2) { return cp1.mKey < cp2.mKey; }
+
+  private:
+	friend void intrusive_ptr_add_ref<>(AICachedPointer<KEY, T> const* p);
+	friend void intrusive_ptr_release<>(AICachedPointer<KEY, T> const* p);
+
+  private:
+	AICachedPointer& operator=(AICachedPointer const&);
+};
+
+template<typename KEY, typename T>
+void intrusive_ptr_add_ref(AICachedPointer<KEY, T> const* p)
+{
+  llassert(p->mCache);
+  if (p->mCache)
+  {
+	p->mRefCount++;
+  }
+}
+
+template<typename KEY, typename T>
+void intrusive_ptr_release(AICachedPointer<KEY, T> const* p)
+{
+  llassert(p->mCache);
+  if (p->mCache)
+  {
+	if (--p->mRefCount == 0)
+	{
+	  p->mCache->erase(p->mKey);
+	}
+  }
+}
+
+template<typename KEY, typename T>
+class AICachedPointerPtr
+{
+  private:
+	boost::intrusive_ptr<AICachedPointer<KEY, T> const> mPtr;
+	static int sCnt;
+
+  public:
+	AICachedPointerPtr(void) { ++sCnt; }
+	AICachedPointerPtr(AICachedPointerPtr const& cpp) : mPtr(cpp.mPtr) { ++sCnt; }
+	AICachedPointerPtr(AICachedPointer<KEY, T> const* cp) : mPtr(cp) { ++sCnt; }
+	~AICachedPointerPtr() { --sCnt; }
+
+	typedef boost::intrusive_ptr<AICachedPointer<KEY, T> const> const AICachedPointerPtr<KEY, T>::* const bool_type;
+	operator bool_type() const { return mPtr ? &AICachedPointerPtr<KEY, T>::mPtr : NULL; }
+
+	T const* operator->() const { return mPtr->get(); }
+	T* operator->() { return const_cast<AICachedPointer<KEY, T>&>(*mPtr).get(); }
+	T const& operator*() const { return *mPtr->get(); }
+	T& operator*() { return *const_cast<AICachedPointer<KEY, T>&>(*mPtr).get(); }
+
+	AICachedPointerPtr& operator=(AICachedPointerPtr const& cpp) { mPtr = cpp.mPtr; return *this; }
+};
+
+template<typename KEY, typename T>
+int AICachedPointerPtr<KEY, T>::sCnt;
+
+// </singu>
+//-----------------------------------------------------------------------------
+
 //-----------------------------------------------------------------------------
 // class LLKeyframeMotion
 //-----------------------------------------------------------------------------
@@ -68,7 +177,7 @@ class LLKeyframeMotion :
 	friend class LLKeyframeDataCache;
 public:
 	// Constructor
-	LLKeyframeMotion(const LLUUID &id);
+	LLKeyframeMotion(const LLUUID &id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLKeyframeMotion();
@@ -85,7 +194,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID& id);
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller);
 
 public:
 	//-------------------------------------------------------------------------
@@ -158,7 +267,7 @@ public:
 	U32		getFileSize();
 	BOOL	serialize(LLDataPacker& dp) const;
 	BOOL	deserialize(LLDataPacker& dp);
-	BOOL	isLoaded() { return mJointMotionList != NULL; }
+	BOOL	isLoaded() { return !!mJointMotionList; }
 
 
 	// setters for modifying a keyframe animation
@@ -393,7 +502,7 @@ public:
 	//-------------------------------------------------------------------------
 	// JointMotionList
 	//-------------------------------------------------------------------------
-	class JointMotionList
+	class JointMotionList : public LLRefCount
 	{
 	public:
 		std::vector<JointMotion*> mJointMotionArray;
@@ -416,19 +525,22 @@ public:
 	public:
 		JointMotionList();
 		~JointMotionList();
-		U32 dumpDiagInfo();
+		U32 dumpDiagInfo(bool silent = false) const;
 		JointMotion* getJointMotion(U32 index) const { llassert(index < mJointMotionArray.size()); return mJointMotionArray[index]; }
 		U32 getNumJointMotions() const { return mJointMotionArray.size(); }
 	};
 
 
+	// Singu: Type of a pointer to the cached pointer (in LLKeyframeDataCache::sKeyframeDataMap) to a JointMotionList object.
+	typedef AICachedPointerPtr<LLUUID, JointMotionList> JointMotionListPtr;
+
 protected:
 	static LLVFS*				sVFS;
 
 	//-------------------------------------------------------------------------
 	// Member Data
 	//-------------------------------------------------------------------------
-	JointMotionList*				mJointMotionList;
+	JointMotionListPtr				mJointMotionList;			// singu: automatically clean up cache entry when destructed.
 	std::vector<LLPointer<LLJointState> > mJointStates;
 	LLJoint*						mPelvisp;
 	LLCharacter*					mCharacter;
@@ -442,21 +554,24 @@ protected:
 
 class LLKeyframeDataCache
 {
-public:
+private:
-	// *FIX: implement this as an actual singleton member of LLKeyframeMotion
+	friend class LLKeyframeMotion;
 	LLKeyframeDataCache(){};
 	~LLKeyframeDataCache();
 
-	typedef std::map<LLUUID, class LLKeyframeMotion::JointMotionList*> keyframe_data_map_t; 
+public:
+	typedef AICachedPointer<LLUUID, LLKeyframeMotion::JointMotionList>::container_type keyframe_data_map_t;	// singu: add automatic cache cleanup.
 	static keyframe_data_map_t sKeyframeDataMap;
 
-	static void addKeyframeData(const LLUUID& id, LLKeyframeMotion::JointMotionList*);
+	//<singu>
-	static LLKeyframeMotion::JointMotionList* getKeyframeData(const LLUUID& id);
+	static LLKeyframeMotion::JointMotionListPtr createKeyframeData(LLUUID const& id);	// id may not exist.
+	static LLKeyframeMotion::JointMotionListPtr    getKeyframeData(LLUUID const& id);	// id may or may not exists. Returns a NULL pointer when it doesn't exist.
+	//</singu>
 
 	static void removeKeyframeData(const LLUUID& id);
 
 	//print out diagnostic info
-	static void dumpDiagInfo();
+	static void dumpDiagInfo(int quiet = 0);	// singu: added param 'quiet'.
 	static void clear();
 };
 

indra/llcharacter/llkeyframemotionparam.cpp

@@ -1,456 +0,0 @@
-/** 
- * @file llkeyframemotionparam.cpp
- * @brief Implementation of LLKeyframeMotion class.
- *
- * $LicenseInfo:firstyear=2001&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$
- */
-
-//-----------------------------------------------------------------------------
-// Header Files
-//-----------------------------------------------------------------------------
-#include "linden_common.h"
-
-#include "llkeyframemotionparam.h"
-#include "llcharacter.h"
-#include "llmath.h"
-#include "m3math.h"
-#include "lldir.h"
-#include "llanimationstates.h"
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam class
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam()
-// Class Constructor
-//-----------------------------------------------------------------------------
-LLKeyframeMotionParam::LLKeyframeMotionParam( const LLUUID &id) : LLMotion(id)
-{
-	mDefaultKeyframeMotion = NULL;
-	mCharacter = NULL;
-
-	mEaseInDuration = 0.f;
-	mEaseOutDuration = 0.f;
-	mDuration = 0.f;
-	mPriority = LLJoint::LOW_PRIORITY;
-}
-
-
-//-----------------------------------------------------------------------------
-// ~LLKeyframeMotionParam()
-// Class Destructor
-//-----------------------------------------------------------------------------
-LLKeyframeMotionParam::~LLKeyframeMotionParam()
-{
-	for (motion_map_t::iterator iter = mParameterizedMotions.begin();
-		 iter != mParameterizedMotions.end(); ++iter)
-	{
-		motion_list_t& motionList = iter->second;
-		for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
-		{
-			const ParameterizedMotion& paramMotion = *iter2;
-			delete paramMotion.mMotion;
-		}
-		motionList.clear();
-	}
-	mParameterizedMotions.clear();
-}
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::onInitialize(LLCharacter *character)
-//-----------------------------------------------------------------------------
-LLMotion::LLMotionInitStatus LLKeyframeMotionParam::onInitialize(LLCharacter *character)
-{
-	mCharacter = character;
-
-	if (!loadMotions())
-	{
-		return STATUS_FAILURE;	
-	}
-	
-	for (motion_map_t::iterator iter = mParameterizedMotions.begin();
-		 iter != mParameterizedMotions.end(); ++iter)
-	{
-		motion_list_t& motionList = iter->second;
-		for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
-		{
-			const ParameterizedMotion& paramMotion = *iter2;
-			LLMotion* motion = paramMotion.mMotion;
-			motion->onInitialize(character);
-
-			if (motion->getDuration() > mEaseInDuration)
-			{
-				mEaseInDuration = motion->getEaseInDuration();
-			}
-
-			if (motion->getEaseOutDuration() > mEaseOutDuration)
-			{
-				mEaseOutDuration = motion->getEaseOutDuration();
-			}
-
-			if (motion->getDuration() > mDuration)
-			{
-				mDuration = motion->getDuration();
-			}
-
-			if (motion->getPriority() > mPriority)
-			{
-				mPriority = motion->getPriority();
-			}
-
-			LLPose *pose = motion->getPose();
-
-			mPoseBlender.addMotion(motion);
-			for (LLJointState *jsp = pose->getFirstJointState(); jsp; jsp = pose->getNextJointState())
-			{
-				LLPose *blendedPose = mPoseBlender.getBlendedPose();
-				blendedPose->addJointState(jsp);
-			}
-		}
-	}
-
-	return STATUS_SUCCESS;
-}
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::onActivate()
-//-----------------------------------------------------------------------------
-BOOL LLKeyframeMotionParam::onActivate()
-{
-	for (motion_map_t::iterator iter = mParameterizedMotions.begin();
-		 iter != mParameterizedMotions.end(); ++iter)
-	{
-		motion_list_t& motionList = iter->second;
-		for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
-		{
-			const ParameterizedMotion& paramMotion = *iter2;
-			paramMotion.mMotion->activate(mActivationTimestamp);
-		}
-	}
-	return TRUE;
-}
-
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::onUpdate()
-//-----------------------------------------------------------------------------
-BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
-{
-	F32 weightFactor = 1.f / (F32)mParameterizedMotions.size();
-
-	// zero out all pose weights
-	for (motion_map_t::iterator iter = mParameterizedMotions.begin();
-		 iter != mParameterizedMotions.end(); ++iter)
-	{
-		motion_list_t& motionList = iter->second;
-		for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
-		{
-			const ParameterizedMotion& paramMotion = *iter2;
-//			llinfos << "Weight for pose " << paramMotion.mMotion->getName() << " is " << paramMotion.mMotion->getPose()->getWeight() << llendl;
-			paramMotion.mMotion->getPose()->setWeight(0.f);
-		}
-	}
-
-
-	for (motion_map_t::iterator iter = mParameterizedMotions.begin();
-		 iter != mParameterizedMotions.end(); ++iter)
-	{
-		const std::string& paramName = iter->first;
-		F32* paramValue = (F32 *)mCharacter->getAnimationData(paramName);
-		if (NULL == paramValue) // unexpected, but...
-		{
-			llwarns << "paramValue == NULL" << llendl;
-			continue;
-		}
-
-		// DANGER! Do not modify mParameterizedMotions while using these pointers!
-		const ParameterizedMotion* firstMotion = NULL;
-		const ParameterizedMotion* secondMotion = NULL;
-
-		motion_list_t& motionList = iter->second;
-		for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
-		{
-			const ParameterizedMotion& paramMotion = *iter2;
-			paramMotion.mMotion->onUpdate(time, joint_mask);
-			
-			F32 distToParam = paramMotion.mParam - *paramValue;
-			
-			if ( distToParam <= 0.f)
-			{
-				// keep track of the motion closest to the parameter value
-				firstMotion = &paramMotion;
-			}
-			else
-			{
-				// we've passed the parameter value
-				// so store the first motion we find as the second one we want to blend...
-				if (firstMotion && !secondMotion )
-				{
-					secondMotion = &paramMotion;
-				}
-				//...or, if we've seen no other motion so far, make sure we blend to this only
-				else if (!firstMotion)
-				{
-					firstMotion = &paramMotion;
-					secondMotion = &paramMotion;
-				}
-			}
-		}
-
-		LLPose *firstPose;
-		LLPose *secondPose;
-
-		if (firstMotion)
-			firstPose = firstMotion->mMotion->getPose();
-		else
-			firstPose = NULL;
-
-		if (secondMotion)
-			secondPose = secondMotion->mMotion->getPose();
-		else
-			secondPose = NULL;
-		
-		// now modify weight of the subanim (only if we are blending between two motions)
-		if (firstMotion && secondMotion)
-		{
-			if (firstMotion == secondMotion)
-			{
-				firstPose->setWeight(weightFactor);
-			}
-			else if (firstMotion->mParam == secondMotion->mParam)
-			{
-				firstPose->setWeight(0.5f * weightFactor);
-				secondPose->setWeight(0.5f * weightFactor);
-			}
-			else
-			{
-				F32 first_weight = 1.f - 
-					((llclamp(*paramValue - firstMotion->mParam, 0.f, (secondMotion->mParam - firstMotion->mParam))) / 
-						(secondMotion->mParam - firstMotion->mParam));
-				first_weight = llclamp(first_weight, 0.f, 1.f);
-				
-				F32 second_weight = 1.f - first_weight;
-				
-				firstPose->setWeight(first_weight * weightFactor);
-				secondPose->setWeight(second_weight * weightFactor);
-
-//				llinfos << "Parameter " << *paramName << ": " << *paramValue << llendl;
-//				llinfos << "Weights " << firstPose->getWeight() << " " << secondPose->getWeight() << llendl;
-			}
-		}
-		else if (firstMotion && !secondMotion)
-		{
-			firstPose->setWeight(weightFactor);
-		}
-	}
-
-	// blend poses
-	mPoseBlender.blendAndApply();
-
-	llinfos << "Param Motion weight " << mPoseBlender.getBlendedPose()->getWeight() << llendl;
-
-	return TRUE;
-}
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::onDeactivate()
-//-----------------------------------------------------------------------------
-void LLKeyframeMotionParam::onDeactivate()
-{
-	for (motion_map_t::iterator iter = mParameterizedMotions.begin();
-		 iter != mParameterizedMotions.end(); ++iter)
-	{
-		motion_list_t& motionList = iter->second;
-		for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
-		{
-			const ParameterizedMotion& paramMotion = *iter2;
-			paramMotion.mMotion->onDeactivate();
-		}
-	}
-}
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::addKeyframeMotion()
-//-----------------------------------------------------------------------------
-BOOL LLKeyframeMotionParam::addKeyframeMotion(char *name, const LLUUID &id, char *param, F32 value)
-{
-	LLMotion *newMotion = mCharacter->createMotion( id );
-	
-	if (!newMotion)
-	{
-		return FALSE;
-	}
-	
-	newMotion->setName(name);
-
-	// now add motion to this list
-	mParameterizedMotions[param].insert(ParameterizedMotion(newMotion, value));
-
-	return TRUE;
-}
-
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::setDefaultKeyframeMotion()
-//-----------------------------------------------------------------------------
-void LLKeyframeMotionParam::setDefaultKeyframeMotion(char *name)
-{
-	for (motion_map_t::iterator iter = mParameterizedMotions.begin();
-		 iter != mParameterizedMotions.end(); ++iter)
-	{
-		motion_list_t& motionList = iter->second;
-		for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
-		{
-			const ParameterizedMotion& paramMotion = *iter2;
-			if (paramMotion.mMotion->getName() == name)
-			{
-				mDefaultKeyframeMotion = paramMotion.mMotion;
-			}
-		}
-	}
-}
-
-//-----------------------------------------------------------------------------
-// loadMotions()
-//-----------------------------------------------------------------------------
-BOOL LLKeyframeMotionParam::loadMotions()
-{
-	//-------------------------------------------------------------------------
-	// Load named file by concatenating the character prefix with the motion name.
-	// Load data into a buffer to be parsed.
-	//-------------------------------------------------------------------------
-	//std::string path = gDirUtilp->getExpandedFilename(LL_PATH_MOTIONS,mCharacter->getAnimationPrefix())
-	//	+ "_" + getName() + ".llp";
-	//RN: deprecated unused reference to "motion" directory
-	std::string path;
-
-
-	//-------------------------------------------------------------------------
-	// open the file
-	//-------------------------------------------------------------------------
-	S32 fileSize = 0;
-	LLAPRFile infile(path, LL_APR_R, &fileSize);
-	apr_file_t* fp = infile.getFileHandle() ;
-	if (!fp || fileSize == 0)
-	{
-		llinfos << "ERROR: can't open: " << path << llendl;
-		return FALSE;
-	}
-
-	// allocate a text buffer
-	try
-	{
-		std::vector<char> text(fileSize+1);
-
-		//-------------------------------------------------------------------------
-		// load data from file into buffer
-		//-------------------------------------------------------------------------
-		bool error = false;
-		char *p = &text[0];
-		while ( 1 )
-		{
-			if (apr_file_eof(fp) == APR_EOF)
-			{
-				break;
-			}
-			if (apr_file_gets(p, 1024, fp) != APR_SUCCESS)
-			{
-				error = true;
-				break;
-			}
-			while ( *(++p) )
-				;
-		}
-
-		//-------------------------------------------------------------------------
-		// close the file
-		//-------------------------------------------------------------------------
-		infile.close();
-
-		//-------------------------------------------------------------------------
-		// check for error
-		//-------------------------------------------------------------------------
-		llassert( p <= (&text[0] + fileSize) );
-
-		if ( error )
-		{
-			llinfos << "ERROR: error while reading from " << path << llendl;
-			return FALSE;
-		}
-
-		llinfos << "Loading parametric keyframe data for: " << getName() << llendl;
-
-		//-------------------------------------------------------------------------
-		// parse the text and build keyframe data structures
-		//-------------------------------------------------------------------------
-		p = &text[0];
-		S32 num;
-		char strA[80]; /* Flawfinder: ignore */
-		char strB[80]; /* Flawfinder: ignore */
-		F32 floatA = 0.0f;
-
-
-		//-------------------------------------------------------------------------
-		// get priority
-		//-------------------------------------------------------------------------
-		BOOL isFirstMotion = TRUE;
-		num = sscanf(p, "%79s %79s %f", strA, strB, &floatA);	/* Flawfinder: ignore */
-
-		while(1)
-		{
-			if (num == 0 || num == EOF) break;
-			if ((num != 3))
-			{
-				llinfos << "WARNING: can't read parametric motion" << llendl;
-				return FALSE;
-			}
-
-			addKeyframeMotion(strA, gAnimLibrary.stringToAnimState(std::string(strA)), strB, floatA);
-			if (isFirstMotion)
-			{
-				isFirstMotion = FALSE;
-				setDefaultKeyframeMotion(strA);
-			}
-		
-			p = strstr(p, "\n");
-			if (!p)
-			{
-				break;
-			}
-			
-			p++;
-			num = sscanf(p, "%79s %79s %f", strA, strB, &floatA);	/* Flawfinder: ignore */
-		}
-
-		return TRUE;
-	}
-	catch(std::bad_alloc)
-	{
-		llinfos << "ERROR: Unable to allocate keyframe text buffer." << llendl;
-		return FALSE;
-	}
-}
-
-// End

indra/llcharacter/llkeyframemotionparam.h

@@ -1,176 +0,0 @@
-/** 
- * @file llkeyframemotionparam.h
- * @brief Implementation of LLKeframeMotionParam class.
- *
- * $LicenseInfo:firstyear=2002&license=viewergpl$
- * 
- * Copyright (c) 2002-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * 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, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLKEYFRAMEMOTIONPARAM_H
-#define LL_LLKEYFRAMEMOTIONPARAM_H
-
-//-----------------------------------------------------------------------------
-// Header files
-//-----------------------------------------------------------------------------
-
-#include <string>
-
-#include "llmotion.h"
-#include "lljointstate.h"
-#include "v3math.h"
-#include "llquaternion.h"
-#include "linked_lists.h"
-#include "llkeyframemotion.h"
-
-//-----------------------------------------------------------------------------
-// class LLKeyframeMotionParam
-//-----------------------------------------------------------------------------
-class LLKeyframeMotionParam :
-	public LLMotion
-{
-public:
-	// Constructor
-	LLKeyframeMotionParam(const LLUUID &id);
-
-	// Destructor
-	virtual ~LLKeyframeMotionParam();
-
-public:
-	//-------------------------------------------------------------------------
-	// functions to support MotionController and MotionRegistry
-	//-------------------------------------------------------------------------
-
-	// static constructor
-	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLKeyframeMotionParam(id); }
-
-public:
-	//-------------------------------------------------------------------------
-	// animation callbacks to be implemented by subclasses
-	//-------------------------------------------------------------------------
-
-	// motions must specify whether or not they loop
-	virtual BOOL getLoop() {
-		return TRUE;
-	}
-
-	// motions must report their total duration
-	virtual F32 getDuration() { 
-		return mDuration;
-	}
-
-	// motions must report their "ease in" duration
-	virtual F32 getEaseInDuration() { 
-		return mEaseInDuration;
-	}
-
-	// motions must report their "ease out" duration.
-	virtual F32 getEaseOutDuration() { 
-		return mEaseOutDuration;
-	}
-
-	// motions must report their priority
-	virtual LLJoint::JointPriority getPriority() { 
-		return mPriority;
-	}
-
-	virtual LLMotionBlendType getBlendType() { return NORMAL_BLEND; }
-
-	// called to determine when a motion should be activated/deactivated based on avatar pixel coverage
-	virtual F32 getMinPixelArea() { return MIN_REQUIRED_PIXEL_AREA_KEYFRAME; }
-
-	// run-time (post constructor) initialization,
-	// called after parameters have been set
-	// must return true to indicate success and be available for activation
-	virtual LLMotionInitStatus onInitialize(LLCharacter *character);
-
-	// called when a motion is activated
-	// must return TRUE to indicate success, or else
-	// it will be deactivated
-	virtual BOOL onActivate();
-
-	// called per time step
-	// must return TRUE while it is active, and
-	// must return FALSE when the motion is completed.
-	virtual BOOL onUpdate(F32 time, U8* joint_mask);
-
-	// called when a motion is deactivated
-	virtual void onDeactivate();
-
-	virtual LLPose* getPose() { return mPoseBlender.getBlendedPose();}
-
-protected:
-	//-------------------------------------------------------------------------
-	// new functions defined by this subclass
-	//-------------------------------------------------------------------------
-	struct ParameterizedMotion
-	{
-		ParameterizedMotion(LLMotion* motion, F32 param) : mMotion(motion), mParam(param) {}
-		LLMotion* mMotion;
-		F32 mParam;
-	};
-	
-	// add a motion and associated parameter triplet
-	BOOL addKeyframeMotion(char *name, const LLUUID &id, char *param, F32 value);
-	
-	// set default motion for LOD and retrieving blend constants
-	void setDefaultKeyframeMotion(char *);
-
-	BOOL loadMotions();
-
-protected:
-	//-------------------------------------------------------------------------
-	// Member Data
-	//-------------------------------------------------------------------------
-
-	struct compare_motions
-	{
-		bool operator() (const ParameterizedMotion& a, const ParameterizedMotion& b) const
-		{
-			if (a.mParam != b.mParam)
-				return (a.mParam < b.mParam);
-			else
-				return a.mMotion < b.mMotion;
-		}
-	};
-	
-	typedef std::set < ParameterizedMotion, compare_motions > motion_list_t;
-	typedef std::map <std::string, motion_list_t > motion_map_t;
-	motion_map_t 		mParameterizedMotions;
-	LLMotion*			mDefaultKeyframeMotion;
-	LLCharacter*		mCharacter;
-	LLPoseBlender		mPoseBlender;
-
-	F32					mEaseInDuration;
-	F32					mEaseOutDuration;
-	F32					mDuration;
-	LLJoint::JointPriority	mPriority;
-
-	LLUUID				mTransactionID;
-};
-
-#endif // LL_LLKEYFRAMEMOTIONPARAM_H

indra/llcharacter/llkeyframestandmotion.cpp

@@ -50,7 +50,7 @@ const F32 POSITION_THRESHOLD = 0.1f;
 // LLKeyframeStandMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLKeyframeStandMotion::LLKeyframeStandMotion(const LLUUID &id) : LLKeyframeMotion(id)
+LLKeyframeStandMotion::LLKeyframeStandMotion(LLUUID const& id, LLMotionController* controller) : LLKeyframeMotion(id, controller)
 {
 	mFlipFeet = FALSE;
 	mCharacter = NULL;
@@ -286,40 +286,38 @@ BOOL LLKeyframeStandMotion::onUpdate(F32 time, U8* joint_mask)
 	//-------------------------------------------------------------------------
 	if ( mTrackAnkles )
 	{
-		LLVector4 dirLeft4 = mAnkleLeftJoint.getWorldMatrix().getFwdRow4();
+		const LLVector4a& dirLeft4 = mAnkleLeftJoint.getWorldMatrix().getRow<LLMatrix4a::ROW_FWD>();
-		LLVector4 dirRight4 = mAnkleRightJoint.getWorldMatrix().getFwdRow4();
+		const LLVector4a& dirRight4 = mAnkleRightJoint.getWorldMatrix().getRow<LLMatrix4a::ROW_FWD>();
-		LLVector3 dirLeft = vec4to3( dirLeft4 );
-		LLVector3 dirRight = vec4to3( dirRight4 );
 
-		LLVector3 up;
+		LLVector4a up;
-		LLVector3 dir;
+		LLVector4a dir;
-		LLVector3 left;
+		LLVector4a left;
 
-		up = mNormalLeft;
+		up.load3(mNormalLeft.mV);
-		up.normVec();
+		up.normalize3fast();
 		if (mFlipFeet)
 		{
-			up *= -1.0f;
+			up.negate();
 		}
-		dir = dirLeft;
+		dir = dirLeft4;
-		dir.normVec();
+		dir.normalize3fast();
-		left = up % dir;
+		left.setCross3(up,dir);
-		left.normVec();
+		left.normalize3fast();
-		dir = left % up;
+		dir.setCross3(left,up);
-		mRotationLeft = LLQuaternion( dir, left, up );
+		mRotationLeft = LLQuaternion( LLVector3(dir.getF32ptr()), LLVector3(left.getF32ptr()), LLVector3(up.getF32ptr()));
 
-		up = mNormalRight;
+		up.load3(mNormalRight.mV);
-		up.normVec();
+		up.normalize3fast();
 		if (mFlipFeet)
 		{
-			up *= -1.0f;
+			up.negate();
 		}
-		dir = dirRight;
+		dir = dirRight4;
-		dir.normVec();
+		dir.normalize3fast();
-		left = up % dir;
+		left.setCross3(up,dir);
-		left.normVec();
+		left.normalize3fast();
-		dir = left % up;
+		dir.setCross3(left,up);
-		mRotationRight = LLQuaternion( dir, left, up );
+		mRotationRight = LLQuaternion( LLVector3(dir.getF32ptr()), LLVector3(left.getF32ptr()), LLVector3(up.getF32ptr()));
 	}
 	mAnkleLeftJoint.setWorldRotation( mRotationLeft );
 	mAnkleRightJoint.setWorldRotation( mRotationRight );

indra/llcharacter/llkeyframestandmotion.h

@@ -48,7 +48,7 @@ class LLKeyframeStandMotion :
 {
 public:
 	// Constructor
-	LLKeyframeStandMotion(const LLUUID &id);
+	LLKeyframeStandMotion(LLUUID const& id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLKeyframeStandMotion();
@@ -60,7 +60,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLKeyframeStandMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLKeyframeStandMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------

indra/llcharacter/llkeyframewalkmotion.cpp

@@ -55,8 +55,8 @@ const F32 SPEED_ADJUST_TIME_CONSTANT = 0.1f; 	// time constant for speed adjustm
 // LLKeyframeWalkMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLKeyframeWalkMotion::LLKeyframeWalkMotion(const LLUUID &id)
+LLKeyframeWalkMotion::LLKeyframeWalkMotion(LLUUID const& id, LLMotionController* controller)
-:	LLKeyframeMotion(id),
+:	LLKeyframeMotion(id, controller),
     mCharacter(NULL),
     mCyclePhase(0.0f),
     mRealTimeLast(0.0f),
@@ -138,8 +138,8 @@ BOOL LLKeyframeWalkMotion::onUpdate(F32 time, U8* joint_mask)
 // LLWalkAdjustMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLWalkAdjustMotion::LLWalkAdjustMotion(const LLUUID &id) :
+LLWalkAdjustMotion::LLWalkAdjustMotion(LLUUID const& id, LLMotionController* controller) :
-	LLMotion(id),
+	AIMaskedMotion(id, controller, ANIM_AGENT_WALK_ADJUST),
 	mLastTime(0.f),
 	mAnimSpeed(0.f),
 	mAdjustedSpeed(0.f),
@@ -193,7 +193,7 @@ BOOL LLWalkAdjustMotion::onActivate()
 	F32 rightAnkleOffset = (mRightAnkleJoint->getWorldPosition() - mCharacter->getCharacterPosition()).magVec();
 	mAnkleOffset = llmax(leftAnkleOffset, rightAnkleOffset);
 
-	return TRUE;
+	return AIMaskedMotion::onActivate();
 }
 
 //-----------------------------------------------------------------------------
@@ -280,7 +280,7 @@ BOOL LLWalkAdjustMotion::onUpdate(F32 time, U8* joint_mask)
 		avatar_movement_dir.normalize();
 
 		// planted foot speed is avatar velocity - foot slip amount along avatar movement direction
-		F32 foot_speed = speed - ((foot_slip_vector * avatar_movement_dir) / delta_time);
+		F32 foot_speed = llmax(0.f, speed - ((foot_slip_vector * avatar_movement_dir) / delta_time));
 
 		// multiply animation playback rate so that foot speed matches avatar speed
 		F32 min_speed_multiplier = clamp_rescale(speed, 0.f, 1.f, 0.f, 0.1f);
@@ -325,13 +325,14 @@ BOOL LLWalkAdjustMotion::onUpdate(F32 time, U8* joint_mask)
 void LLWalkAdjustMotion::onDeactivate()
 {
 	mCharacter->removeAnimationData("Walk Speed");
+	AIMaskedMotion::onDeactivate();
 }
 
 //-----------------------------------------------------------------------------
 // LLFlyAdjustMotion::LLFlyAdjustMotion()
 //-----------------------------------------------------------------------------
-LLFlyAdjustMotion::LLFlyAdjustMotion(const LLUUID &id)
+LLFlyAdjustMotion::LLFlyAdjustMotion(LLUUID const& id, LLMotionController* controller)
-	: LLMotion(id),
+	: AIMaskedMotion(id, controller, ANIM_AGENT_FLY_ADJUST),
 	  mRoll(0.f)
 {
 	mName = "fly_adjust";
@@ -368,7 +369,7 @@ BOOL LLFlyAdjustMotion::onActivate()
 	mPelvisState->setPosition(LLVector3::zero);
 	mPelvisState->setRotation(LLQuaternion::DEFAULT);
 	mRoll = 0.f;
-	return TRUE;
+	return AIMaskedMotion::onActivate();
 }
 
 //-----------------------------------------------------------------------------

indra/llcharacter/llkeyframewalkmotion.h

@@ -52,7 +52,7 @@ class LLKeyframeWalkMotion :
 	friend class LLWalkAdjustMotion;
 public:
 	// Constructor
-	LLKeyframeWalkMotion(const LLUUID &id);
+	LLKeyframeWalkMotion(LLUUID const& id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLKeyframeWalkMotion();
@@ -64,7 +64,7 @@ public:
 	
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLKeyframeWalkMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLKeyframeWalkMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------
@@ -86,11 +86,11 @@ public:
 	S32			mDownFoot;
 };
 
-class LLWalkAdjustMotion : public LLMotion
+class LLWalkAdjustMotion : public AIMaskedMotion
 {
 public:
 	// Constructor
-	LLWalkAdjustMotion(const LLUUID &id);
+	LLWalkAdjustMotion(LLUUID const& id, LLMotionController* controller);
 
 public:
 	//-------------------------------------------------------------------------
@@ -99,7 +99,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLWalkAdjustMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLWalkAdjustMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------
@@ -136,11 +136,11 @@ public:
 	F32				mAnkleOffset;
 };
 
-class LLFlyAdjustMotion : public LLMotion
+class LLFlyAdjustMotion : public AIMaskedMotion
 {
 public:
 	// Constructor
-	LLFlyAdjustMotion(const LLUUID &id);
+	LLFlyAdjustMotion(LLUUID const& id, LLMotionController* controller);
 
 public:
 	//-------------------------------------------------------------------------
@@ -149,7 +149,7 @@ public:
 
 	// static constructor
 	// all subclasses must implement such a function and register it
-	static LLMotion *create(const LLUUID &id) { return new LLFlyAdjustMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLFlyAdjustMotion(id, controller); }
 
 public:
 	//-------------------------------------------------------------------------
@@ -157,7 +157,6 @@ public:
 	//-------------------------------------------------------------------------
 	virtual LLMotionInitStatus onInitialize(LLCharacter *character);
 	virtual BOOL onActivate();
-	virtual void onDeactivate() {};
 	virtual BOOL onUpdate(F32 time, U8* joint_mask);
 	virtual LLJoint::JointPriority getPriority(){return LLJoint::HIGHER_PRIORITY;}
 	virtual BOOL getLoop() { return TRUE; }

indra/llcharacter/llmotion.cpp

@@ -37,6 +37,125 @@
 
 #include "llmotion.h"
 #include "llcriticaldamp.h"
+#include "llmotioncontroller.h"
+
+//<singu>
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// AISyncClientMotion class
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+AISyncKey* AISyncClientMotion::createSyncKey(AISyncKey const* from_key) const
+{
+  // The const cast is needed because getDuration() is non-const while it should have been.
+  AISyncClientMotion* self = const_cast<AISyncClientMotion*>(this);
+  // Only synchronize motions with the same duration and loop value.
+  return new AISyncKeyMotion(from_key, self->getDuration(), self->getLoop());
+}
+
+void AISyncClientMotion::aisync_loading(void)
+{
+  // Register the motion for (possible) synchronization: this marks the time at which is should have started.
+  unregister_client();	// In case it is already registered. Getting here means we are being (re)started now, we need to synchronize with other motions that start now.
+  register_client();
+}
+
+void AISyncClientMotion::aisync_loaded(void)
+{
+  AISyncServer* server = this->server();
+  if (!server)
+  {
+	// Already expired without being synchronized (no other motion was started at the same time).
+	return;
+  }
+  AISyncKey const& key = server->key();		// The allocation of this is owned by server.
+  // There is no need to resync if there was not another motion started at the same time and the key already expired.
+  bool need_resync = !(server->never_synced() && key.expired());
+  AISyncKey* new_key = NULL;
+  if (need_resync)
+  {
+	// Create a new key using the old start time.
+	new_key = createSyncKey(&key);
+  }
+  server->remove(this);						// This resets mServer and might even delete server.
+  if (need_resync)
+  {
+	// Add the client to another server (based on the new key). This takes ownership of the key allocation.
+	AISyncServerMap::instance().register_client(this, new_key);
+  }
+}
+
+F32 LLMotion::getRuntime(void) const
+{
+  llassert(mActive);
+  return mController->getAnimTime() - mActivationTimestamp;
+}
+
+F32 LLMotion::getAnimTime(void) const
+{
+  return mController->getAnimTime();
+}
+
+F32 LLMotion::syncActivationTime(F32 time)
+{
+  AISyncServer* server = this->server();
+  if (!server)
+  {
+	register_client();
+	server = this->server();
+  }
+  AISyncServer::client_list_t const& clients = server->getClients();
+  if (clients.size() > 1)
+  {
+	// Look for the client with the smallest runtime.
+	AISyncClientMotion* motion_with_smallest_runtime = NULL;
+	F32 runtime = 1e10;
+	// Run over all motions in this to be synchronized group.
+	for (AISyncServer::client_list_t::const_iterator client = clients.begin(); client != clients.end(); ++client)
+	{
+	  if ((client->mReadyEvents & 2))		// Is this motion active? Motions that aren't loaded yet are not active.
+	  {
+		// Currently, if event 2 is set then this is an LLMotion.
+		llassert(dynamic_cast<AISyncClientMotion*>(client->mClientPtr));
+		AISyncClientMotion* motion = static_cast<AISyncClientMotion*>(client->mClientPtr);
+		// Deactivated motions should have been deregistered, certainly not have event 2 set.
+		llassert(static_cast<LLMotion*>(motion)->isActive());
+		if (motion->getRuntime() < runtime)
+		{
+		  // This is a bit fuzzy since theoretically the runtime of all active motions in the list should be the same.
+		  // Just use the smallest value to get rid of some randomness. We might even synchronizing with ourselves
+		  // in which case 'time' would be set to a value such that mActivationTimestamp won't change.
+		  // In practise however, this list will contain only two clients: this, being inactive, and our partner.
+		  runtime = motion->getRuntime();
+		  motion_with_smallest_runtime = motion;
+		}
+	  }
+	}
+	//-----------------------------------------------------------------------------------------
+	// Here is where the actual synchronization takes place.
+	// Current we only synchronize looped motions.
+	if (getLoop())
+	{
+	  if (motion_with_smallest_runtime)
+	  {
+		// Pretend the motion was started in the past at the same time as the other motion(s).
+		time = getAnimTime() - runtime;
+	  }
+	}
+	//-----------------------------------------------------------------------------------------
+  }
+
+  return time;
+}
+
+void AISyncClientMotion::deregistered(void)
+{
+#ifdef SHOW_ASSERT
+  mReadyEvents = 0;
+#endif
+}
+//</singu>
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
@@ -48,10 +167,11 @@
 // LLMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLMotion::LLMotion( const LLUUID &id ) :
+LLMotion::LLMotion(LLUUID const& id, LLMotionController* controller) :
 	mStopped(TRUE),
 	mActive(FALSE),
 	mID(id),
+	mController(controller),
 	mActivationTimestamp(0.f),
 	mStopTimestamp(0.f),
 	mSendStopTimestamp(F32_MAX),
@@ -147,6 +267,19 @@ void LLMotion::activate(F32 time)
 {
 	mActivationTimestamp = time;
 	mStopped = FALSE;
+	//<singu>
+	if (mController && !mController->syncing_disabled())	// Avoid being registered when syncing is disabled for this motion.
+	{
+		if (mActive)
+		{
+			// If the motion is already active then we are being restarted.
+			// Unregister it first (if it is registered) so that the call to ready will cause it to be registered
+			// and be synchronized with other motions that are started at this moment.
+			unregister_client();
+		}
+		ready(6, 2 | (mController->isHidden() ? 0 : 4));	// Signal that mActivationTimestamp is set/valid (2), and that this server has a visible motion (4) (or not).
+	}
+	//</singu>
 	mActive = TRUE;
 	onActivate();
 }
@@ -159,6 +292,14 @@ void LLMotion::deactivate()
 	mActive = FALSE;
 	mPose.setWeight(0.f);
 
+	//<singu>
+	if (server())						// Only when this motion is already registered.
+	{
+		ready(6, 0);					// Signal that mActivationTimestamp is no longer valid.
+		unregister_client();			// No longer running, so no longer a part of this sync group.
+	}
+	//</singu>
+
 	if (mDeactivateCallback)
 	{
 		(*mDeactivateCallback)(mDeactivateCallbackUserData);
@@ -174,4 +315,19 @@ BOOL LLMotion::canDeprecate()
 	return TRUE;
 }
 
+//-----------------------------------------------------------------------------
+// AIMaskedMotion
+//-----------------------------------------------------------------------------
+
+BOOL AIMaskedMotion::onActivate()
+{
+	mController->activated(mMaskBit);
+	return TRUE;
+}
+
+void AIMaskedMotion::onDeactivate()
+{
+	mController->deactivated(mMaskBit);
+}
+
 // End

indra/llcharacter/llmotion.h

@@ -38,16 +38,85 @@
 //-----------------------------------------------------------------------------
 #include <string>
 
+#include "aisyncclient.h"
 #include "llerror.h"
 #include "llpose.h"
 #include "lluuid.h"
 
 class LLCharacter;
+class LLMotionController;
+
+//-----------------------------------------------------------------------------
+// class AISync* stuff
+//-----------------------------------------------------------------------------
+
+class AISyncKeyMotion : public AISyncKey
+{
+  private:
+	F32 mDuration;
+	bool mLoop;
+
+  public:
+	AISyncKeyMotion(AISyncKey const* from_key, F32 duration, bool loop) : AISyncKey(from_key), mDuration(duration), mLoop(loop) { }
+
+  // Virtual functions of AISyncKey.
+  public:
+	/*virtual*/ synckeytype_t getkeytype(void) const
+	{
+	  // Return a unique identifier for this class, where the low 8 bits represent the syncgroup.
+	  return synckeytype_motion;
+	}
+
+    /*virtual*/ bool equals(AISyncKey const& key) const
+	{
+	  switch (key.getkeytype())
+	  {
+		case synckeytype_motion:
+		{
+		  // The other key is of the same type.
+		  AISyncKeyMotion const& motion_key = static_cast<AISyncKeyMotion const&>(key);
+		  return mLoop == motion_key.mLoop && is_approx_equal(mDuration, motion_key.mDuration);
+		}
+		default:
+		  // The keys must be in the same syncgroup.
+		  break;
+	  }
+	  return false;
+	}
+};
+
+class AISyncClientMotion : public AISyncClient
+{
+  protected:
+	// Make sure that clients that are destroyed are first unregistered.
+	// This is needed, for example, when loading fails or when excess motions are being purged.
+	/*virtual*/ ~AISyncClientMotion() { unregister_client(); }
+
+	// AISyncClient events.
+	/*virtual*/ AISyncKey* createSyncKey(AISyncKey const* from_key = NULL) const;
+	/*virtual*/ void event1_ready(void) { }
+	/*virtual*/ void event1_not_ready(void) { }
+	/*virtual*/ void deregistered(void);
+
+  protected:
+	// This is called when the server sent us a message that it wants us to play this animation, but we can't because it isn't fully downloaded yet.
+	void aisync_loading(void);
+	// This is called when that motion is successfully loaded and it has to be re-registered because now the duration etc is known.
+	void aisync_loaded(void);
+
+  public:
+	// Virtual functions of AISyncClientMotion.
+	// These are defined by classes derived from LLMotion (which is derived from this class).
+	virtual BOOL getLoop() = 0;
+	virtual F32 getDuration() = 0;
+	virtual F32 getAnimTime(void) const  = 0;
+	virtual F32 getRuntime(void) const  = 0;
+};
 
 //-----------------------------------------------------------------------------
 // class LLMotion
 //-----------------------------------------------------------------------------
-class LLMotion
+class LLMotion : public AISyncClientMotion
 {
 	friend class LLMotionController;
 	
@@ -66,7 +135,7 @@ public:
 	};
 
 	// Constructor
-	LLMotion(const LLUUID &id);
+	LLMotion(LLUUID const& id, LLMotionController* controller);
 
 	// Destructor
 	virtual ~LLMotion();
@@ -114,7 +183,22 @@ protected:
 	BOOL isActive() { return mActive; }
 public:
 	void activate(F32 time);
-	
+
+	//<singu>
+	// Returns the time that this motion has been running.
+	virtual F32 getRuntime(void) const;
+
+	// Return the current time (in seconds since creation of the controller).
+	virtual F32 getAnimTime(void) const;
+
+	// This is called when a motion is to be activated, but might need synchronization.
+	// It adjusts the start time to match that of other motions in the same synchronization group that were already started.
+	F32 syncActivationTime(F32 time);
+
+	// Accessor.
+	LLMotionController* getController(void) const { return mController; }
+	//</singu>
+
 public:
 	//-------------------------------------------------------------------------
 	// animation callbacks to be implemented by subclasses
@@ -181,6 +265,9 @@ protected:
 	//-------------------------------------------------------------------------
 	std::string		mName;			// instance name assigned by motion controller
 	LLUUID			mID;
+	//<singu>
+	LLMotionController* mController;
+	//</singu>
 	
 	F32 mActivationTimestamp;	// time when motion was activated
 	F32 mStopTimestamp;			// time when motion was told to stop
@@ -199,9 +286,9 @@ protected:
 class LLTestMotion : public LLMotion
 {
 public:
-	LLTestMotion(const LLUUID &id) : LLMotion(id){}
+	LLTestMotion(LLUUID const& id, LLMotionController* controller) : LLMotion(id, controller){}
 	~LLTestMotion() {}
-	static LLMotion *create(const LLUUID& id) { return new LLTestMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLTestMotion(id, controller); }
 	BOOL getLoop() { return FALSE; }
 	F32 getDuration() { return 0.0f; }
 	F32 getEaseInDuration() { return 0.0f; }
@@ -223,9 +310,9 @@ public:
 class LLNullMotion : public LLMotion
 {
 public:
-	LLNullMotion(const LLUUID &id) : LLMotion(id) {}
+	LLNullMotion(LLUUID const& id, LLMotionController* controller) : LLMotion(id, controller) {}
 	~LLNullMotion() {}
-	static LLMotion *create(const LLUUID &id) { return new LLNullMotion(id); }
+	static LLMotion* create(LLUUID const& id, LLMotionController* controller) { return new LLNullMotion(id, controller); }
 
 	// motions must specify whether or not they loop
 	/*virtual*/ BOOL getLoop() { return TRUE; }
@@ -266,5 +353,41 @@ public:
 	// called when a motion is deactivated
 	/*virtual*/ void onDeactivate() {}
 };
+
+
+//-----------------------------------------------------------------------------
+// AIMaskedMotion
+//-----------------------------------------------------------------------------
+
+// These motions have a bit assigned in LLMotionController::mActiveMask
+// that is set and uset upon activation/deactivation.
+
+// This must be in the same order as ANIM_AGENT_BODY_NOISE_ID through ANIM_AGENT_WALK_ADJUST_ID in llvoavatar.cpp.
+U32 const ANIM_AGENT_BODY_NOISE		= 0x001;
+U32 const ANIM_AGENT_BREATHE_ROT	= 0x002;
+U32 const ANIM_AGENT_PHYSICS_MOTION	= 0x004;
+U32 const ANIM_AGENT_EDITING		= 0x008;
+U32 const ANIM_AGENT_EYE			= 0x010;
+U32 const ANIM_AGENT_FLY_ADJUST		= 0x020;
+U32 const ANIM_AGENT_HAND_MOTION	= 0x040;
+U32 const ANIM_AGENT_HEAD_ROT		= 0x080;
+U32 const ANIM_AGENT_PELVIS_FIX		= 0x100;
+U32 const ANIM_AGENT_TARGET			= 0x200;
+U32 const ANIM_AGENT_WALK_ADJUST	= 0x400;
+
+class AIMaskedMotion : public LLMotion
+{
+private:
+	U32 mMaskBit;
+
+public:
+	AIMaskedMotion(LLUUID const& id, LLMotionController* controller, U32 mask_bit) : LLMotion(id, controller), mMaskBit(mask_bit) { }
+
+	/*virtual*/ BOOL onActivate();
+	/*virtual*/ void onDeactivate();
+
+	U32 getMaskBit(void) const { return mMaskBit; }
+};
+
 #endif // LL_LLMOTION_H
 

indra/llcharacter/llmotioncontroller.cpp

@@ -97,7 +97,7 @@ void LLMotionRegistry::markBad( const LLUUID& id )
 //-----------------------------------------------------------------------------
 // createMotion()
 //-----------------------------------------------------------------------------
-LLMotion *LLMotionRegistry::createMotion( const LLUUID &id )
+LLMotion* LLMotionRegistry::createMotion(LLUUID const& id, LLMotionController* controller)
 {
 	LLMotionConstructor constructor = get_if_there(mMotionTable, id, LLMotionConstructor(NULL));
 	LLMotion* motion = NULL;
@@ -105,11 +105,11 @@ LLMotion *LLMotionRegistry::createMotion( const LLUUID &id )
 	if ( constructor == NULL )
 	{
 		// *FIX: need to replace with a better default scheme. RN
-		motion = LLKeyframeMotion::create(id);
+		motion = LLKeyframeMotion::create(id, controller);
 	}
 	else
 	{
-		motion = constructor(id);
+		motion = constructor(id, controller);
 	}
 
 	return motion;
@@ -126,18 +126,22 @@ LLMotion *LLMotionRegistry::createMotion( const LLUUID &id )
 // Class Constructor
 //-----------------------------------------------------------------------------
 LLMotionController::LLMotionController()
-	: mTimeFactor(sCurrentTimeFactor),
+	: mIsSelf(FALSE),
+	  mTimeFactor(sCurrentTimeFactor),
 	  mCharacter(NULL),
-	  mAnimTime(0.f),
+	  mActiveMask(0),
+	  mDisableSyncing(0),
+	  mHidden(false),
+	  mHaveVisibleSyncedMotions(false),
 	  mPrevTimerElapsed(0.f),
+	  mAnimTime(0.f),
 	  mLastTime(0.0f),
 	  mHasRunOnce(FALSE),
 	  mPaused(FALSE),
 	  mPauseTime(0.f),
 	  mTimeStep(0.f),
 	  mTimeStepCount(0),
-	  mLastInterp(0.f),
+	  mLastInterp(0.f)
-	  mIsSelf(FALSE)
 {
 }
 
@@ -168,7 +172,15 @@ void LLMotionController::deleteAllMotions()
 	mLoadingMotions.clear();
 	mLoadedMotions.clear();
 	mActiveMotions.clear();
-
+	//<singu>
+	mActiveMask = 0;
+	for_each(mDeprecatedMotions.begin(), mDeprecatedMotions.end(), DeletePointer());
+	mDeprecatedMotions.clear();
+	for (motion_map_t::iterator iter = mAllMotions.begin(); iter != mAllMotions.end(); ++iter)
+	{
+		iter->second->unregister_client();
+	}
+	//</singu>
 	for_each(mAllMotions.begin(), mAllMotions.end(), DeletePairedPointer());
 	mAllMotions.clear();
 }
@@ -178,26 +190,19 @@ void LLMotionController::deleteAllMotions()
 //-----------------------------------------------------------------------------
 void LLMotionController::purgeExcessMotions()
 {
-	if (mLoadedMotions.size() > MAX_MOTION_INSTANCES)
+	//<singu>
+	// The old code attempted to remove non-active motions from mDeprecatedMotions,
+	// but that is nonsense: there are no motions in mDeprecatedMotions that are not active.
+	if (mLoadedMotions.size() <= MAX_MOTION_INSTANCES)
 	{
-		// clean up deprecated motions
+		// Speed up, no need to create motions_to_kill.
-		for (motion_set_t::iterator deprecated_motion_it = mDeprecatedMotions.begin(); 
+		return;
-			 deprecated_motion_it != mDeprecatedMotions.end(); )
-		{
-			motion_set_t::iterator cur_iter = deprecated_motion_it++;
-			LLMotion* cur_motionp = *cur_iter;
-			if (!isMotionActive(cur_motionp))
-			{
-				// Motion is deprecated so we know it's not cannonical,
-				//  we can safely remove the instance
-				removeMotionInstance(cur_motionp); // modifies mDeprecatedMotions
-				mDeprecatedMotions.erase(cur_iter);
-			}
-		}
 	}
+	//</singu>
 
 	std::set<LLUUID> motions_to_kill;
-	if (mLoadedMotions.size() > MAX_MOTION_INSTANCES)
+
+	if (1)	// Singu: leave indentation alone...
 	{
 		// too many motions active this frame, kill all blenders
 		mPoseBlender.clearBlenders();
@@ -308,24 +313,44 @@ BOOL LLMotionController::registerMotion( const LLUUID& id, LLMotionConstructor c
 void LLMotionController::removeMotion( const LLUUID& id)
 {
 	LLMotion* motionp = findMotion(id);
-	mAllMotions.erase(id);
+	//<singu>
-	removeMotionInstance(motionp);
+	// If a motion is erased from mAllMotions, it must be deleted.
+	if (motionp)
+	{
+		mAllMotions.erase(id);
+		removeMotionInstance(motionp);
+		delete motionp;
+	}
+	//</singu>
 }
 
 // removes instance of a motion from all runtime structures, but does
 // not erase entry by ID, as this could be a duplicate instance
-// use removeMotion(id) to remove all references to a given motion by id.
+// use removeMotion(id) to remove a reference to a given motion by id
+// (that will not remove (active) deprecated motions).
 void LLMotionController::removeMotionInstance(LLMotion* motionp)
 {
 	if (motionp)
 	{
 		llassert(findMotion(motionp->getID()) != motionp);
-		if (motionp->isActive())
-			motionp->deactivate();
 		mLoadingMotions.erase(motionp);
 		mLoadedMotions.erase(motionp);
 		mActiveMotions.remove(motionp);
-		delete motionp;
+		//<singu>
+		// Deactivation moved here. Only delete motionp when it is being removed from mDeprecatedMotions.
+		if (motionp->isActive())
+		{
+			motionp->deactivate();
+			// If a motion is deactivated, it must be removed from mDeprecatedMotions if there.
+			motion_set_t::iterator found_it = mDeprecatedMotions.find(motionp);
+			if (found_it != mDeprecatedMotions.end())
+			{
+				mDeprecatedMotions.erase(found_it);
+				// If a motion is erased from mDeprecatedMotions, it must be deleted.
+				delete motionp;
+			}
+		}
+		//</singu>
 	}
 }
 
@@ -341,7 +366,7 @@ LLMotion* LLMotionController::createMotion( const LLUUID &id )
 	if (!motion)
 	{
 		// look up constructor and create it
-		motion = sRegistry.createMotion(id);
+		motion = sRegistry.createMotion(id, this);
 		if (!motion)
 		{
 			return NULL;
@@ -393,6 +418,7 @@ BOOL LLMotionController::startMotion(const LLUUID &id, F32 start_offset)
 	if (motion
 		&& !mPaused
 		&& motion->canDeprecate()
+		&& motion->isActive()											// singu: do not deprecate motions that are not active.
 		&& motion->getFadeWeight() > 0.01f // not LOD-ed out
 		&& (motion->isBlending() || motion->getStopTime() != 0.f))
 	{
@@ -418,7 +444,19 @@ BOOL LLMotionController::startMotion(const LLUUID &id, F32 start_offset)
 	}
 
 //	llinfos << "Starting motion " << name << llendl;
-	return activateMotionInstance(motion, mAnimTime - start_offset);
+	//<singu>
+	F32 start_time = mAnimTime - start_offset;
+	if (!mDisableSyncing)
+	{
+	  start_time = motion->syncActivationTime(start_time);
+	}
+	++mDisableSyncing;
+	//</singu>
+	BOOL res = activateMotionInstance(motion, start_time);
+	//<singu>
+	--mDisableSyncing;
+	//</singu>
+	return res;
 }
 
 
@@ -774,7 +812,19 @@ void LLMotionController::updateLoadingMotions()
 			// this motion should be playing
 			if (!motionp->isStopped())
 			{
-				activateMotionInstance(motionp, mAnimTime);
+				//<singu>
+				F32 start_time = mAnimTime;
+				if (!mDisableSyncing)
+				{
+				  motionp->aisync_loaded();
+				  start_time = motionp->syncActivationTime(start_time);
+				}
+				++mDisableSyncing;
+				//</singu>
+				activateMotionInstance(motionp, start_time);
+				//<singu>
+				--mDisableSyncing;
+				//</singu>
 			}
 		}
 		else if (status == LLMotion::STATUS_FAILURE)
@@ -782,12 +832,15 @@ void LLMotionController::updateLoadingMotions()
 			llinfos << "Motion " << motionp->getID() << " init failed." << llendl;
 			sRegistry.markBad(motionp->getID());
 			mLoadingMotions.erase(curiter);
-			motion_set_t::iterator found_it = mDeprecatedMotions.find(motionp);
+			// Singu note: a motion in mLoadingMotions will not be in mActiveMotions
-			if (found_it != mDeprecatedMotions.end())
+			// and therefore not be in mDeprecatedMotions. So, we don't have to
-			{
+			// check for it's existence there.
-				mDeprecatedMotions.erase(found_it);
+			llassert(mDeprecatedMotions.find(motionp) == mDeprecatedMotions.end());
-			}
 			mAllMotions.erase(motionp->getID());
+			//<singu>
+			// Make sure we're not registered anymore.
+			motionp->unregister_client();
+			//</singu>
 			delete motionp;
 		}
 	}
@@ -821,8 +874,15 @@ void LLMotionController::updateMotions(bool force_update)
 		{
 			F32 time_interval = fmodf(update_time, mTimeStep);
 
-			// always animate *ahead* of actual time
+            //<singu>
-			S32 quantum_count = llmax(0, llfloor((update_time - time_interval) / mTimeStep)) + 1;
+            // This old code is nonsense.
+            //S32 quantum_count = llmax(0, llround((update_time - time_interval) / mTimeStep)) + 1;
+            // (update_time - time_interval) / mTimeStep is an integer! We need llround to get rid of floating point errors, not llfloor.
+            // Moreover, just rounding off to the nearest integer with llround(update_time / mTimeStep) makes a lot more sense:
+            // it is the best we can do to get as close to what we should draw as possible.
+            // However, mAnimTime may only be incremented; therefore make sure of that with the llmax.
+			S32 quantum_count = llmax(llround(update_time / mTimeStep), llceil(mAnimTime / mTimeStep));
+            //</singu>
 			if (quantum_count == mTimeStepCount)
 			{
 				// we're still in same time quantum as before, so just interpolate and exit
@@ -848,7 +908,8 @@ void LLMotionController::updateMotions(bool force_update)
 		}
 		else
 		{
-			mAnimTime = update_time;
+			// Singu note: mAnimTime may never be set back in time.
+			mAnimTime = llmax(mAnimTime, update_time);
 		}
 	}
 
@@ -915,6 +976,12 @@ BOOL LLMotionController::activateMotionInstance(LLMotion *motion, F32 time)
 
 	if (mLoadingMotions.find(motion) != mLoadingMotions.end())
 	{
+		//<singu>
+		if (!syncing_disabled())
+		{
+			motion->aisync_loading();
+		}
+		//</singu>
 		// we want to start this motion, but we can't yet, so flag it as started
 		motion->setStopped(FALSE);
 		// report pending animations as activated
@@ -970,18 +1037,16 @@ BOOL LLMotionController::activateMotionInstance(LLMotion *motion, F32 time)
 //-----------------------------------------------------------------------------
 BOOL LLMotionController::deactivateMotionInstance(LLMotion *motion)
 {
-	motion->deactivate();
-
 	motion_set_t::iterator found_it = mDeprecatedMotions.find(motion);
 	if (found_it != mDeprecatedMotions.end())
 	{
 		// deprecated motions need to be completely excised
-		removeMotionInstance(motion);	
+		removeMotionInstance(motion);							// singu note: this deactivates motion and removes it from mDeprecatedMotions.
-		mDeprecatedMotions.erase(found_it);
 	}
 	else
 	{
 		// for motions that we are keeping, simply remove from active queue
+		motion->deactivate();									// singu note: moved here from the top of the function.
 		mActiveMotions.remove(motion);
 	}
 
@@ -1049,11 +1114,26 @@ void LLMotionController::dumpMotions()
 			state_string += std::string("L");
 		if (std::find(mActiveMotions.begin(), mActiveMotions.end(), motion)!=mActiveMotions.end())
 			state_string += std::string("A");
-		if (mDeprecatedMotions.find(motion) != mDeprecatedMotions.end())
+		llassert(mDeprecatedMotions.find(motion) == mDeprecatedMotions.end());	// singu: it's impossible that a motion is in mAllMotions and mDeprecatedMotions at the same time.
-			state_string += std::string("D");
 		llinfos << gAnimLibrary.animationName(id) << " " << state_string << llendl;
-		
 	}
+	//<singu>
+	// Also dump the deprecated motions.
+	for (motion_set_t::iterator iter = mDeprecatedMotions.begin();
+		 iter != mDeprecatedMotions.end(); ++iter)
+	{
+		std::string state_string;
+		LLMotion* motion = *iter;
+		LLUUID id = motion->getID();
+		llassert(mLoadingMotions.find(motion) == mLoadingMotions.end());
+		if (mLoadedMotions.find(motion) != mLoadedMotions.end())
+			state_string += std::string("L");
+		if (std::find(mActiveMotions.begin(), mActiveMotions.end(), motion)!=mActiveMotions.end())
+			state_string += std::string("A");
+		state_string += "D";
+		llinfos << gAnimLibrary.animationName(id) << " " << state_string << llendl;
+	}
+	//</singu>
 }
 
 //-----------------------------------------------------------------------------
@@ -1061,11 +1141,11 @@ void LLMotionController::dumpMotions()
 //-----------------------------------------------------------------------------
 void LLMotionController::deactivateAllMotions()
 {
-	for (motion_map_t::iterator iter = mAllMotions.begin();
+	// Singu note: this must run over mActiveMotions: other motions are not active,
-		 iter != mAllMotions.end(); iter++)
+	// and running over mAllMotions will miss the ones in mDeprecatedMotions.
+	for (motion_list_t::iterator iter = mActiveMotions.begin(); iter != mActiveMotions.end();)
 	{
-		LLMotion* motionp = iter->second;
+		deactivateMotionInstance(*iter++);	// This might invalidate iter by erasing it from mActiveMotions.
-		deactivateMotionInstance(motionp);
 	}
 }
 
@@ -1086,8 +1166,7 @@ void LLMotionController::flushAllMotions()
 		active_motions.push_back(std::make_pair(motionp->getID(),dtime));
 		motionp->deactivate(); // don't call deactivateMotionInstance() because we are going to reactivate it
 	}
- 	mActiveMotions.clear();
+
-	
 	// delete all motion instances
 	deleteAllMotions();
 
@@ -1096,13 +1175,136 @@ void LLMotionController::flushAllMotions()
 	mCharacter->removeAnimationData("Hand Pose");
 
 	// restart motions
+	//<singu>
+	// Because we called motionp->deactivate() above, instead of deactivateMotionInstance(),
+	// prevent calling AISyncClientMotion::activateInstance in startMotion below.
+	disable_syncing();
+	//</singu>
 	for (std::vector<std::pair<LLUUID,F32> >::iterator iter = active_motions.begin();
 		 iter != active_motions.end(); ++iter)
 	{
 		startMotion(iter->first, iter->second);
 	}
+	//<singu>
+	enable_syncing();
+	//</singu>
 }
 
+//<singu>
+//-----------------------------------------------------------------------------
+// toggle_hidden()
+//-----------------------------------------------------------------------------
+void LLMotionController::toggle_hidden(void)
+{
+	mHaveVisibleSyncedMotions = mHidden;		// Default is false if we just became invisible (otherwise this value isn't used).
+	mHidden = !mHidden;
+	synceventset_t const visible = mHidden ? 0 : 4;
+
+	// Run over all motions.
+	for (motion_list_t::iterator iter = mActiveMotions.begin(); iter != mActiveMotions.end(); ++iter)
+	{
+		LLMotion* motionp = *iter;
+		AISyncServer* server = motionp->server();
+		if (server && !server->never_synced() && motionp->isActive())			// Skip motions that aren't synchronized at all or that are not active.
+		{
+			bool visible_before = server->events_with_at_least_one_client_ready() & 4;
+			server->ready(4, visible, motionp);									// Mark that now we are visible or no longer visible.
+			bool visible_after = server->events_with_at_least_one_client_ready() & 4;
+			if (visible_after)													// Are there any synchronized motions (left) that ARE visible?
+			{
+				mHaveVisibleSyncedMotions = true;
+			}
+			if (visible_before != visible_after)
+			{
+				// The group as a whole now might need to change whether or not it is animated.
+				AISyncServer::client_list_t const& clients = server->getClients();
+				for (AISyncServer::client_list_t::const_iterator client = clients.begin(); client != clients.end(); ++client)
+				{
+					LLMotion* motion = dynamic_cast<LLMotion*>(client->mClientPtr);
+					if (!motion)
+					{
+						continue;
+					}
+					LLMotionController* controller = motion->getController();
+					if (controller == this)
+					{
+						continue;
+					}
+					if (visible_after)
+					{
+					  // Us becoming visible means that all synchronized avatars need to be animated again too.
+					  controller->setHaveVisibleSyncedMotions();
+					}
+					else
+					{
+					  // Us becoming hidden means that all synchronized avatars might stop animating.
+					  controller->refresh_hidden();		// It is extremely unlikely, but harmless, to call this twice on the same controller.
+					}
+				}
+			}
+		}
+	}
+}
+
+void LLMotionController::refresh_hidden(void)
+{
+	mHaveVisibleSyncedMotions = !mHidden;
+
+	// Run over all motions.
+	for (motion_list_t::iterator iter = mActiveMotions.begin(); iter != mActiveMotions.end(); ++iter)
+	{
+		LLMotion* motionp = *iter;
+		AISyncServer* server = motionp->server();
+		if (server && !server->never_synced() && motionp->isActive())			// Skip motions that aren't synchronized at all or that are not active.
+		{
+			bool visible_after = server->events_with_at_least_one_client_ready() & 4;
+			if (visible_after)													// Are there any synchronized motions (left) that ARE visible?
+			{
+				mHaveVisibleSyncedMotions = true;
+			}
+		}
+	}
+}
+
+void LLMotionController::pauseAllSyncedCharacters(std::vector<LLAnimPauseRequest>& avatar_pause_handles)
+{
+	// Run over all motions.
+	for (motion_list_t::iterator iter = mActiveMotions.begin(); iter != mActiveMotions.end(); ++iter)
+	{
+		LLMotion* motionp = *iter;
+		AISyncServer* server = motionp->server();
+		if (server && !server->never_synced() && motionp->isActive())			// Skip motions that aren't synchronized at all or that are not active.
+		{
+			// Run over all clients of the found servers.
+			AISyncServer::client_list_t const& clients = server->getClients();
+			for (AISyncServer::client_list_t::const_iterator client = clients.begin(); client != clients.end(); ++client)
+			{
+				LLMotion* motion = dynamic_cast<LLMotion*>(client->mClientPtr);
+				if (!motion)
+				{
+					continue;
+				}
+				LLMotionController* controller = motion->getController();
+				if (controller == this)
+				{
+					continue;
+				}
+				controller->requestPause(avatar_pause_handles);
+			}
+		}
+	}
+}
+
+void LLMotionController::requestPause(std::vector<LLAnimPauseRequest>& avatar_pause_handles)
+{
+	if (mCharacter)
+	{
+		mCharacter->requestPause(avatar_pause_handles);
+	}
+}
+
+//</singu>
+
 //-----------------------------------------------------------------------------
 // pause()
 //-----------------------------------------------------------------------------

indra/llcharacter/llmotioncontroller.h

@@ -51,11 +51,14 @@
 // This is necessary because llcharacter.h includes this file.
 //-----------------------------------------------------------------------------
 class LLCharacter;
+class LLMotionController;
+class LLPauseRequestHandle;
+typedef LLPointer<LLPauseRequestHandle> LLAnimPauseRequest;
 
 //-----------------------------------------------------------------------------
 // LLMotionRegistry
 //-----------------------------------------------------------------------------
-typedef LLMotion*(*LLMotionConstructor)(const LLUUID &id);
+typedef LLMotion* (*LLMotionConstructor)(LLUUID const& id, LLMotionController*);
 
 class LLMotionRegistry
 {
@@ -72,7 +75,7 @@ public:
 
 	// creates a new instance of a named motion
 	// returns NULL motion is not registered
-	LLMotion *createMotion( const LLUUID &id );
+	LLMotion* createMotion(LLUUID const& id, LLMotionController* controller);
 
 	// initialization of motion failed, don't try to create this motion again
 	void markBad( const LLUUID& id );
@@ -115,7 +118,6 @@ public:
 
 	// unregisters a motion with the controller
 	// (actually just forwards call to motion registry)
-	// returns true if successfull
 	void removeMotion( const LLUUID& id );
 
 	// start motion
@@ -150,10 +152,20 @@ public:
 	//Flush is a liar.
 	void deactivateAllMotions();	
 
+	//<singu>
+	void activated(U32 bit) { mActiveMask |= bit; }
+	void deactivated(U32 bit) { mActiveMask &= ~bit; }
+	bool isactive(U32 bit) const { return (mActiveMask & bit) != 0; }
+	//</singu>
+
 	// pause and continue all motions
 	void pauseAllMotions();
 	void unpauseAllMotions();
 	BOOL isPaused() const { return mPaused; }
+	//<singu>
+	void requestPause(std::vector<LLAnimPauseRequest>& avatar_pause_handles);
+	void pauseAllSyncedCharacters(std::vector<LLAnimPauseRequest>& avatar_pause_handles);
+	//</singu>
 
 	void setTimeStep(F32 step);
 
@@ -180,7 +192,10 @@ protected:
 	// internal operations act on motion instances directly
 	// as there can be duplicate motions per id during blending overlap
 	void deleteAllMotions();
+	// singu: LLMotion needs access to activateMotionInstance.
+public:
 	BOOL activateMotionInstance(LLMotion *motion, F32 time);
+protected:
 	BOOL deactivateMotionInstance(LLMotion *motion);
 	void deprecateMotionInstance(LLMotion* motion);
 	BOOL stopMotionInstance(LLMotion *motion, BOOL stop_imemdiate);
@@ -205,10 +220,13 @@ protected:
 //	Life cycle of an animation:
 //
 //	Animations are instantiated and immediately put in the mAllMotions map for their entire lifetime.
+//	Singu note: that is not true, they are moved to mDeprecatedMotions (often) for the last part of their lifetime.
 //	If the animations depend on any asset data, the appropriate data is fetched from the data server,
 //	and the animation is put on the mLoadingMotions list.
 //	Once an animations is loaded, it will be initialized and put on the mLoadedMotions list.
 //	Any animation that is currently playing also sits in the mActiveMotions list.
+//	Singu note: animations are only put in mDeprecatedMotions if and while they are playing,
+//	therefore animations in mDeprecatedMotions will be (must be) active and in mActiveMotions.
 
 	typedef std::map<LLUUID, LLMotion*> motion_map_t;
 	motion_map_t	mAllMotions;
@@ -217,7 +235,13 @@ protected:
 	motion_set_t		mLoadedMotions;
 	motion_list_t		mActiveMotions;
 	motion_set_t		mDeprecatedMotions;
-	
+
+	//<singu>
+	U32					mActiveMask;
+	int					mDisableSyncing;			// Set while LLMotion::onActivate (and onDeactivate) are called for this controller.
+	bool				mHidden;					// The value of the last call to hidden().
+	bool				mHaveVisibleSyncedMotions;	// Set when we are synchronized with one or more motions of a controller that is not hidden.
+	//</singu>
 	LLFrameTimer		mTimer;
 	F32					mPrevTimerElapsed;
 	F32					mAnimTime;
@@ -230,6 +254,26 @@ protected:
 	F32					mLastInterp;
 
 	U8					mJointSignature[2][LL_CHARACTER_MAX_JOINTS];
+
+	//<singu>
+public:
+	// Internal administration for AISync.
+	void disable_syncing(void) { mDisableSyncing += 100; }
+	void enable_syncing(void) { mDisableSyncing -= 100; }
+	bool syncing_disabled(void) const { return mDisableSyncing >= 100; }
+
+	// Accessors needed for synchronization.
+	F32 getAnimTime(void) const { return mAnimTime; }
+	bool isHidden(void) const { return mHidden; }
+
+	// Called often. Should return false if we still need to keep updating our motions even if we're not visible.
+	bool hidden(bool not_visible) { if (mHidden != not_visible) toggle_hidden(); return !mHaveVisibleSyncedMotions; }
+
+private:
+	void toggle_hidden(void);
+	void refresh_hidden(void);
+	void setHaveVisibleSyncedMotions(void) { mHaveVisibleSyncedMotions = true; }
+	//</singu>
 };
 
 //-----------------------------------------------------------------------------

indra/llcharacter/lltargetingmotion.cpp

@@ -52,7 +52,7 @@ const F32 TORSO_ROT_FRACTION = 0.5f;
 // LLTargetingMotion()
 // Class Constructor
 //-----------------------------------------------------------------------------
-LLTargetingMotion::LLTargetingMotion(const LLUUID &id) : LLMotion(id)
+LLTargetingMotion::LLTargetingMotion(LLUUID const& id, LLMotionController* controller) : AIMaskedMotion(id, controller, ANIM_AGENT_TARGET)
 {
 	mCharacter = NULL;
 	mName = "targeting";
@@ -99,14 +99,6 @@ LLMotion::LLMotionInitStatus LLTargetingMotion::onInitialize(LLCharacter *charac
 	return STATUS_SUCCESS;
 }
 
-//-----------------------------------------------------------------------------
-// LLTargetingMotion::onActivate()
-//-----------------------------------------------------------------------------
-BOOL LLTargetingMotion::onActivate()
-{
-	return TRUE;
-}
-
 //-----------------------------------------------------------------------------
 // LLTargetingMotion::onUpdate()
 //-----------------------------------------------------------------------------
@@ -166,12 +158,4 @@ BOOL LLTargetingMotion::onUpdate(F32 time, U8* joint_mask)
 	return result;
 }
 
-//-----------------------------------------------------------------------------
-// LLTargetingMotion::onDeactivate()
-//-----------------------------------------------------------------------------
-void LLTargetingMotion::onDeactivate()
-{
-}
-
-
 // End