Synchronize looping animations that start at the same moment.

indra/llcharacter/llmotion.cpp

@@ -39,6 +39,122 @@
 #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;
+  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)
+{
+  mReadyEvents = 0;
+}
+//</singu>
+
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // LLMotion class
@@ -149,6 +265,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();
 }
@@ -161,6 +290,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);