Text archives Help

---

Author: sparker
Date: Mon Dec 31 00:11:42 2007
New Revision: 1960

Modified:
   trunk/Engine/Control/RTRT.cc
   trunk/Engine/Control/RTRT.h
Log:
Fleshed out notion of time for animation


Modified: trunk/Engine/Control/RTRT.cc
==============================================================================
--- trunk/Engine/Control/RTRT.cc        (original)
+++ trunk/Engine/Control/RTRT.cc        Mon Dec 31 00:11:42 2007
@@ -151,7 +151,8 @@
   workersChanged = false;
   lastChanged = false;
   running=false;
-  animFrameState.frameNumber = 0;
+  animFrameState.frameSerialNumber = 0;
+  animFrameState.animationFrameNumber = 0;
   animFrameState.frameTime = 0;
   animFrameState.shutter_open = 0;
   animFrameState.shutter_close = 0;
@@ -226,8 +227,8 @@
   // #if NOTFINISHED
 
   if(whence == MantaInterface::Relative) {
-    frame += animFrameState.frameNumber;
-        }
+    frame += animFrameState.frameSerialNumber;
+  }
   // #endif
 
   oneShots.insert(OneShotMapType::value_type(frame, callback));
@@ -240,8 +241,8 @@
   callbackLock.writeLock();
 
   if(whence == MantaInterface::Relative) {
-    frame += animFrameState.frameNumber;
-        }
+    frame += animFrameState.frameSerialNumber;
+  }
 
   parallelOneShots.insert(OneShotMapType::value_type(frame, callback));
   callbackLock.writeUnlock();
@@ -396,11 +397,71 @@
 
///////////////////////////////////////////////////////////////////////////////
 
///////////////////////////////////////////////////////////////////////////////
 
-void RTRT::setTimeMode(TimeMode /*tm*/, double /*rate*/)
+void RTRT::setTimeMode(TimeMode tm, double ts)
+{
+  // If this gets used often, we may need to add a lock to avoid shear if 
part
+  // of the data gets picked up at just the wrong moment
+  if(timeMode == tm){
+    // Since the time modes are the same, assume that the rate is changing 
and
+    // solve for a new offset that will keep the current time the same.
+    double r1, r2;
+    switch(timeMode){
+    case RealTime: {
+      r1 = timeScale;
+      r2 = ts;
+    } break;
+    case FixedRate: {
+      r1 = 1./frameRate;
+      r2 = 1./ts;
+    } break;
+    case Static:
+    default: {
+      r1 = r2 = 1;
+    } break;
+    }
+    double time = Time::currentSeconds();
+    timeOffset += (r2-r1)*time;
+    timeScale = ts;
+    timeMode = tm;
+  } else {
+    switch(timeMode){
+    case RealTime: {
+      timeScale = ts;
+    } break;
+    case FixedRate: {
+      frameRate = ts;
+    } break;
+    case Static: {
+    } break;
+    }
+    timeMode = tm;
+  }
+}
+
+void RTRT::startTime()
+{
+  if(time_is_stopped){
+    double time = Time::currentSeconds();
+    timeOffset += time - stoptime * timeScale;
+    time_is_stopped = false;
+  }
+}
+
+void RTRT::stopTime()
+{
+  if(!time_is_stopped){
+    stoptime = Time::currentSeconds();
+    time_is_stopped = true;
+  }
+}
+
+bool RTRT::timeIsStopped()
 {
-  NOT_FINISHED("RTRT::setTimeMode");
+  return time_is_stopped;
 }
 
+
+
 #define MANTA_CHECK_POINTER(ptr) if (ptr == 0) throw InvalidState( #ptr );
 
 
///////////////////////////////////////////////////////////////////////////////
@@ -608,20 +669,26 @@
   for(;;){
     // P0 update frame number, time, etc.
     if(proc == 0){
-      animFrameState.frameNumber++;
-      switch(timeMode){
-      case RealTime:
-        animFrameState.shutter_open = animFrameState.shutter_close;
-        animFrameState.frameTime = Time::currentSeconds() * timeScale;
-        animFrameState.shutter_close = animFrameState.frameTime;
-        break;
-      case FixedRate:
-        animFrameState.shutter_open = animFrameState.shutter_close;
-        animFrameState.frameTime = 
static_cast<double>(animFrameState.frameNumber) / frameRate;
-        animFrameState.shutter_close = animFrameState.frameTime;
-        break;
-      case Static:
-        break;
+      animFrameState.frameSerialNumber++;
+      if(time_is_stopped){
+        // Time is stopped - leave the frame state where it is
+      } else {
+        animFrameState.animationFrameNumber++;
+      
+        switch(timeMode){
+        case RealTime:
+          animFrameState.shutter_open = animFrameState.shutter_close;
+          animFrameState.frameTime = (Time::currentSeconds() - timeOffset) * 
timeScale;
+          animFrameState.shutter_close = animFrameState.frameTime;
+          break;
+        case FixedRate:
+          animFrameState.shutter_open = animFrameState.shutter_close;
+          animFrameState.frameTime = 
static_cast<double>(animFrameState.animationFrameNumber) / frameRate;
+          animFrameState.shutter_close = animFrameState.frameTime;
+          break;
+        case Static:
+          break;
+        }
       }
 
       // Update the number of workers to be used for the animation and
@@ -672,7 +739,7 @@
 
     // P0 resize images for next frame
     if(proc == 0)
-      resizeImages(animFrameState.frameNumber);
+      resizeImages(animFrameState.frameSerialNumber);
 
     // Update the number of workers to be used for the rendering of this 
frame
     if(proc == 0){
@@ -755,7 +822,7 @@
           // thread, so allocators inside setupPipelines don't blow
           // up.
           setupPipelines(workersRendering == 0?1:workersRendering);
-          resizeImages(renderFrameState.frameNumber);
+          resizeImages(renderFrameState.frameSerialNumber);
         }
 
         // Wait for processor zero to setup the image pipeline
@@ -791,7 +858,7 @@
       for(ChannelListType::iterator iter = channels.begin();
           iter != channels.end(); iter++){
         Channel* channel = *iter;
-        long displayFrame = 
(renderFrameState.frameNumber-1)%channel->pipelineDepth;
+        long displayFrame = 
(renderFrameState.frameSerialNumber-1)%channel->pipelineDepth;
         Image* image = channel->images[displayFrame];
         if(image && image->isValid()){
           DisplayContext myContext(proc, workersAnimAndImage, displayFrame, 
channel->pipelineDepth);
@@ -843,7 +910,7 @@
     {
       for(size_t index = 0;index < channels.size();index++){
         Channel* channel = channels[index];
-        long renderFrame = 
renderFrameState.frameNumber%channel->pipelineDepth;
+        long renderFrame = 
renderFrameState.frameSerialNumber%channel->pipelineDepth;
         Image* image = channel->images[renderFrame];
         RenderContext myContext(this, index, proc, workersRendering, 
&renderFrameState,
                                 currentLoadBalancer, currentPixelSampler,
@@ -879,7 +946,7 @@
 
   // Parallel one shot callbacks.
   ParallelOneShotMapType::iterator iter = parallelOneShots.begin();
-  while(iter != parallelOneShots.end() && iter->first < 
animFrameState.frameNumber){
+  while(iter != parallelOneShots.end() && iter->first < 
animFrameState.frameSerialNumber){
     iter->second->call(proc, numProcs);
 
     // Add a deletion transaction.
@@ -923,7 +990,7 @@
     // One-shots are always done by p0, since we do not always know
     // how many there will be, and we need to potentially update the map
     OneShotMapType::iterator iter = oneShots.begin();
-    while(iter != oneShots.end() && iter->first < 
animFrameState.frameNumber){
+    while(iter != oneShots.end() && iter->first < 
animFrameState.frameSerialNumber){
       iter->second->call(proc, numProcs);
       delete iter->second;
       oneShots.erase(iter);

Modified: trunk/Engine/Control/RTRT.h
==============================================================================
--- trunk/Engine/Control/RTRT.h (original)
+++ trunk/Engine/Control/RTRT.h Mon Dec 31 00:11:42 2007
@@ -127,9 +127,12 @@
 
     // Control of time/animation
     virtual void setTimeMode(TimeMode tm, double rate);
+    virtual void startTime();
+    virtual void stopTime();
+    virtual bool timeIsStopped();
 
     // Query functions
-    virtual int getCurrentFrame() const { return animFrameState.frameNumber; 
};
+    virtual const FrameState& getFrameState() const { return animFrameState; 
};
 
     
///////////////////////////////////////////////////////////////////////////
     
///////////////////////////////////////////////////////////////////////////
@@ -347,6 +350,9 @@
     // Time control
     TimeMode timeMode;
     double timeScale;
+    double timeOffset;
+    double stoptime;
+    bool time_is_stopped;
     double frameRate;
 
     char pad0[MAXCACHELINESIZE];

---

• [Manta] r1960 - trunk/Engine/Control, sparker, 12/31/2007

---

Archive powered by MHonArc 2.6.16.