mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-25 12:42:41 -06:00
182 lines
6.8 KiB
Python
182 lines
6.8 KiB
Python
"""AnimControlInterval module: contains the AnimControlInterval class"""
|
|
|
|
__all__ = ['AnimControlInterval']
|
|
|
|
from pandac.PandaModules import *
|
|
from direct.directnotify.DirectNotifyGlobal import *
|
|
import Interval
|
|
import math
|
|
|
|
class AnimControlInterval(Interval.Interval):
|
|
|
|
# create AnimControlInterval DirectNotify category
|
|
notify = directNotify.newCategory('AnimControlInterval')
|
|
|
|
# Name counter
|
|
animNum = 1
|
|
# Class methods
|
|
|
|
# Plays an animation. The subrange of the animation
|
|
# to be played may be specified via frames (startFrame up to and
|
|
# including endFrame) or seconds (startTime up to and including
|
|
# endTime). If neither is specified, the default is the entire
|
|
# range of the animation.
|
|
|
|
# this class requires either an AnimControl, or an AnimControlCollection
|
|
# (in which case, each anim control must be the same length)
|
|
|
|
# The duration may be implicit or explicit. If it is omitted, it
|
|
# is taken to be endTime - startTime. There's not much point in
|
|
# specifying otherwise unless you also specify loop=1, which will
|
|
# loop the animation over its frame range during the duration of
|
|
# the interval.
|
|
|
|
# Note: if loop == 0 and duration > anim duration then the
|
|
# animation will play once and then hold its final pose for the
|
|
# remainder of the interval.
|
|
|
|
# loop = 1 implies a loop within the entire range of animation,
|
|
# while constrainedLoop = 1 implies a loop within startFrame and
|
|
# endFrame only.
|
|
|
|
def __init__(self, controls, loop=0, constrainedLoop=0,
|
|
duration=None, startTime=None, endTime=None,
|
|
startFrame=None, endFrame=None,
|
|
playRate=1.0, name=None):
|
|
# Generate unique id
|
|
id = 'AnimControl-%d' % (AnimControlInterval.animNum)
|
|
AnimControlInterval.animNum += 1
|
|
# Record class specific variables
|
|
|
|
if(isinstance(controls, AnimControlCollection)):
|
|
self.controls = controls
|
|
if(config.GetBool("strict-anim-ival",0)):
|
|
checkSz = self.controls.getAnim(0).getNumFrames()
|
|
for i in range(1,self.controls.getNumAnims()):
|
|
if(checkSz != self.controls.getAnim(i).getNumFrames()):
|
|
self.notify.error("anim controls don't have the same number of frames!")
|
|
elif(isinstance(controls, AnimControl)):
|
|
self.controls = AnimControlCollection()
|
|
self.controls.storeAnim(controls,"")
|
|
else:
|
|
self.notify.error("invalid input control(s) for AnimControlInterval")
|
|
|
|
self.loopAnim = loop
|
|
self.constrainedLoop = constrainedLoop
|
|
self.playRate = playRate
|
|
|
|
# If no name specified, use id as name
|
|
if (name == None):
|
|
name = id
|
|
|
|
self.frameRate = self.controls.getAnim(0).getFrameRate() * abs(playRate)
|
|
# Compute start and end frames.
|
|
if startFrame != None:
|
|
self.startFrame = startFrame
|
|
elif startTime != None:
|
|
self.startFrame = startTime * self.frameRate
|
|
else:
|
|
self.startFrame = 0
|
|
|
|
if endFrame != None:
|
|
self.endFrame = endFrame
|
|
elif endTime != None:
|
|
self.endFrame = endTime * self.frameRate
|
|
elif duration != None:
|
|
if startTime == None:
|
|
startTime = float(self.startFrame) / float(self.frameRate)
|
|
endTime = startTime + duration
|
|
self.endFrame = duration * self.frameRate
|
|
else:
|
|
# No end frame specified. Choose the maximum of all
|
|
# of the controls' numbers of frames.
|
|
numFrames = self.controls.getAnim(0).getNumFrames()
|
|
self.endFrame = numFrames - 1
|
|
|
|
# Must we play the animation backwards? We play backwards if
|
|
# either (or both) of the following is true: the playRate is
|
|
# negative, or endFrame is before startFrame.
|
|
self.reverse = (playRate < 0)
|
|
if self.endFrame < self.startFrame:
|
|
self.reverse = 1
|
|
t = self.endFrame
|
|
self.endFrame = self.startFrame
|
|
self.startFrame = t
|
|
|
|
self.numFrames = self.endFrame - self.startFrame + 1
|
|
|
|
# Compute duration if no duration specified
|
|
self.implicitDuration = 0
|
|
if duration == None:
|
|
self.implicitDuration = 1
|
|
duration = float(self.numFrames) / self.frameRate
|
|
|
|
# Initialize superclass
|
|
Interval.Interval.__init__(self, name, duration)
|
|
|
|
def getCurrentFrame(self):
|
|
"""Calculate the current frame playing in this interval.
|
|
|
|
returns a float value between startFrame and endFrame, inclusive
|
|
returns None if there are any problems
|
|
"""
|
|
retval = None
|
|
if not self.isStopped():
|
|
framesPlayed = self.numFrames * self.currT
|
|
retval = self.startFrame + framesPlayed
|
|
return retval
|
|
|
|
def privStep(self, t):
|
|
frameCount = t * self.frameRate
|
|
if self.constrainedLoop:
|
|
frameCount = frameCount % self.numFrames
|
|
|
|
if self.reverse:
|
|
absFrame = self.endFrame - frameCount
|
|
else:
|
|
absFrame = self.startFrame + frameCount
|
|
|
|
# Calc integer frame number
|
|
intFrame = int(math.floor(absFrame + 0.0001))
|
|
|
|
# Pose anim
|
|
|
|
# We use our pre-computed list of animControls for
|
|
# efficiency's sake, rather than going through the relatively
|
|
# expensive Actor interface every frame.
|
|
|
|
# Each animControl might have a different number of frames.
|
|
numFrames = self.controls.getAnim(0).getNumFrames()
|
|
if self.loopAnim:
|
|
frame = (intFrame % numFrames) + (absFrame - intFrame)
|
|
else:
|
|
frame = max(min(absFrame, numFrames - 1), 0)
|
|
|
|
self.controls.poseAll(frame)
|
|
|
|
self.state = CInterval.SStarted
|
|
self.currT = t
|
|
|
|
def privFinalize(self):
|
|
if self.implicitDuration and not self.loopAnim:
|
|
# As a special case, we ensure we end up posed to the last
|
|
# frame of the animation if the original duration was
|
|
# implicit. This is necessary only to guard against
|
|
# possible roundoff error in computing the final frame
|
|
# from the duration. We don't do this in the case of a
|
|
# looping animation, however, because this would introduce
|
|
# a hitch in the animation when it plays back-to-back with
|
|
# the next cycle.
|
|
if self.reverse:
|
|
self.controls.poseAll(self.startFrame)
|
|
else:
|
|
self.controls.poseAll(self.endFrame)
|
|
|
|
else:
|
|
# Otherwise, the user-specified duration determines which
|
|
# is our final frame.
|
|
self.privStep(self.getDuration())
|
|
|
|
self.state = CInterval.SFinal
|
|
self.intervalDone()
|
|
|