void
Clock::Begin (TimeSpan parentTime)
{
//printf ("clock %p (%s) begin\n", this, GetName ());
emit_completed = false;
has_completed = false;
was_stopped = false;
/* we're starting. initialize our current_time field */
SetCurrentTime ((parentTime - root_parent_time - timeline->GetBeginTime ()) * timeline->GetSpeedRatio());
Duration d = GetNaturalDuration ();
if (d.HasTimeSpan ()) {
if (d.GetTimeSpan() == 0) {
progress = 1.0;
}
else {
progress = (double)current_time / d.GetTimeSpan();
if (progress > 1.0)
progress = 1.0;
}
}
else
progress = 0.0;
CalculateFillTime ();
SetClockState (Clock::Active);
// force the time manager to tick the clock hierarchy to wake it up
time_manager->NeedClockTick ();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *event -
//-----------------------------------------------------------------------------
void C_SceneEntity::DispatchProcessLoop( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::LOOP );
float backtime = (float)atof( event->GetParameters() );
bool process = true;
int counter = event->GetLoopCount();
if ( counter != -1 )
{
int remaining = event->GetNumLoopsRemaining();
if ( remaining <= 0 )
{
process = false;
}
else
{
event->SetNumLoopsRemaining( --remaining );
}
}
if ( !process )
return;
scene->LoopToTime( backtime );
SetCurrentTime( backtime, true );
}
void RarTime::SetAgeText(char *TimeText)
{
uint Seconds=0,Value=0;
for (int I=0;TimeText[I]!=0;I++)
{
int Ch=TimeText[I];
if (IsDigit(Ch))
Value=Value*10+Ch-'0';
else
{
switch(etoupper(Ch))
{
case 'D':
Seconds+=Value*24*3600;
break;
case 'H':
Seconds+=Value*3600;
break;
case 'M':
Seconds+=Value*60;
break;
case 'S':
Seconds+=Value;
break;
}
Value=0;
}
}
SetCurrentTime();
int64 RawTime=GetRaw();
SetRaw(RawTime-INT32TO64(0,Seconds)*10000000);
}
// https://w3c.github.io/web-animations/#set-the-animation-playback-rate
void
Animation::SetPlaybackRate(double aPlaybackRate)
{
if (aPlaybackRate == mPlaybackRate) {
return;
}
AutoMutationBatchForAnimation mb(*this);
Nullable<TimeDuration> previousTime = GetCurrentTime();
mPlaybackRate = aPlaybackRate;
if (!previousTime.IsNull()) {
SetCurrentTime(previousTime.Value());
}
// In the case where GetCurrentTime() returns the same result before and
// after updating mPlaybackRate, SetCurrentTime will return early since,
// as far as it can tell, nothing has changed.
// As a result, we need to perform the following updates here:
// - update timing (since, if the sign of the playback rate has changed, our
// finished state may have changed),
// - dispatch a change notification for the changed playback rate, and
// - update the playback rate on animations on layers.
UpdateTiming(SeekFlag::DidSeek, SyncNotifyFlag::Async);
if (IsRelevant()) {
nsNodeUtils::AnimationChanged(this);
}
PostUpdate();
}
void CModelGTF::UpdateModel()
{
// Grab a pointer to the model
t3DModel *pModel = &m_Model;
// Make sure there are objects and animation speed in the model
if(!pModel->pObject.size() || pModel->animSpeed <= 0) return;
// Initialize a start and end frame. In this tutorial we don't add a way
// to keep track of each animation, so we just play all of the animations
// in a sequence. If we wanted to only play certain animations the start
// frame and end frame would need to be changed for each animation.
int startFrame = 0;
int endFrame = pModel->pObject[0].numFrames;
// This gives us the next frame we are going to. We mod the current frame plus
// 1 by the current animations end frame to make sure the next frame is valid.
pModel->nextFrame = (pModel->currentFrame + 1) % endFrame;
// If the next frame is zero, that means that we need to start the animation over.
// To do this, we set nextFrame to the starting frame of this animation.
if(pModel->nextFrame == 0)
pModel->nextFrame = startFrame;
// Next, we want to get the current time that we are interpolating by. Remember,
// if t = 0 then we are at the beginning of the animation, where if t = 1 we are at the end.
// Anything from 0 to 1 can be thought of as a percentage from 0 to 100 percent complete.
SetCurrentTime();
}
AbstractTimelineMarker::AbstractTimelineMarker(const char* aName,
MarkerTracingType aTracingType)
: mName(aName)
, mTracingType(aTracingType)
{
MOZ_COUNT_CTOR(AbstractTimelineMarker);
SetCurrentTime();
}
bool wxSVGDocument::Load(const wxString& filename, const wxString& encoding) {
bool result = wxSvgXmlDocument::Load(filename, encoding);
if (result) {
m_path = wxPathOnly(filename);
}
SetCurrentTime(0);
return result;
}
void
Animation::SetPlaybackRate(double aPlaybackRate)
{
Nullable<TimeDuration> previousTime = GetCurrentTime();
mPlaybackRate = aPlaybackRate;
if (!previousTime.IsNull()) {
SetCurrentTime(previousTime.Value());
}
}
void Widget::SetConnect()
{
//每秒显示时间
connect(m_timer,SIGNAL(timeout()),this,SLOT(SetCurrentTime()));
//返回今天
connect(m_TotodayButton,SIGNAL(clicked()),this,SLOT(ReturnToday()));
connect(m_Calendar,SIGNAL(selectionChanged()),this,SLOT(DateChanged()));
connect(m_NextDayButton,SIGNAL(clicked()),this,SLOT(ToNextDay()));
connect(m_ToPreDayButton,SIGNAL(clicked()),this,SLOT(ToPreDay()));
connect(m_YearComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(ToCertainDate()));
connect(m_MonthComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(ToCertainDate()));
connect(m_DayComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(ToCertainDate()));
connect(m_YearComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(SetCBDay()));
connect(m_MonthComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(SetCBDay()));
QTimer::singleShot(0,this,SLOT(SetCurrentTime()));
QTimer::singleShot(0,this,SLOT(DateChanged()));
}
void
Animation::SetPlaybackRate(double aPlaybackRate)
{
Nullable<TimeDuration> previousTime = GetCurrentTime();
mPlaybackRate = aPlaybackRate;
if (!previousTime.IsNull()) {
ErrorResult rv;
SetCurrentTime(previousTime.Value());
MOZ_ASSERT(!rv.Failed(), "Should not assert for non-null time");
}
}
CGameTimer::CGameTimer( double dCurrentime )
{
m_nSec = 0;
m_nMin = 0;
m_nHour = 0;
m_nDay = 0;
m_dBeginTime = 0;
m_dCurrentTime = 0;
SetCurrentTime( dCurrentime );
m_bFixed = FALSE;
}
CGameTimer::CGameTimer()
{
m_nSec = 0;
m_nMin = 0;
m_nHour = 0;
m_nDay = 0;
m_dBeginTime = 0;
m_dCurrentTime = 0;
SetCurrentTime( 3, 15 );
m_bFixed = FALSE;
}
void
Animation::SetCurrentTimeAsDouble(const Nullable<double>& aCurrentTime,
ErrorResult& aRv)
{
if (aCurrentTime.IsNull()) {
if (!GetCurrentTime().IsNull()) {
aRv.Throw(NS_ERROR_DOM_TYPE_ERR);
}
return;
}
return SetCurrentTime(TimeDuration::FromMilliseconds(aCurrentTime.Value()));
}
/*
Output command with controlmode
*/
void OutputCmdType002( char *cmdPtr, long cmdLen, short isSetTime )
{
int n;
long len;
char buf[CMD_BUF_MAX_SIZE];
char *p = buf;
n = SetBJLStart(p); p += n;
n = SetControlMode(p); p += n;
if ( isSetTime ) {
n = SetCurrentTime(p); p+=n;
}
memcpy( p, cmdPtr, cmdLen ); p += cmdLen;
n = SetBJLEnd(p); p += n;
*p = 0x00; p++;
len = (long)(p - buf);
PutPrintData( buf, len );
}
/*
Output command
*/
void OutputCmdType001( char *cmdPtr, long cmdLen )
{
int n;
long len;
char buf[CMD_BUF_MAX_SIZE];
char *p = buf;
/* Output SetTime */
n = SetBJLStart(p); p += n;
n = SetControlMode(p); p += n;
n = SetCurrentTime(p); p+=n;
n = SetBJLEnd(p); p += n;
/* Output Command */
n = SetBJLStart(p); p += n;
memcpy( p, cmdPtr, cmdLen ); p += cmdLen;
n = SetBJLEnd(p); p += n;
*p = 0x00; p++;
len = (long)(p - buf);
PutPrintData( buf, len );
}
// https://w3c.github.io/web-animations/#finish-an-animation
void
Animation::Finish(ErrorResult& aRv)
{
if (mPlaybackRate == 0 ||
(mPlaybackRate > 0 && EffectEnd() == TimeDuration::Forever())) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
TimeDuration limit =
mPlaybackRate > 0 ? TimeDuration(EffectEnd()) : TimeDuration(0);
SetCurrentTime(limit);
if (mPendingState == PendingState::PlayPending) {
CancelPendingTasks();
if (mReady) {
mReady->MaybeResolve(this);
}
}
UpdateFinishedState(true);
PostUpdate();
}
bool CModelMD3::UpdateModel(t3DModel *pModel,bool loop)
{
int startFrame = 0;
int endFrame = 1;
tAnimationInfo *pAnim = &(pModel->pAnimations[pModel->currentAnim]);
if(pModel->numOfAnimations)
{
startFrame = pAnim->startFrame;
endFrame = pAnim->endFrame;
}
pModel->nextFrame = (pModel->currentFrame + 1) % endFrame;
if(pModel->nextFrame == 0)
{
pModel->nextFrame = startFrame;
if(!loop)
return true;
}
SetCurrentTime(pModel);
return false;
}
void CAnimBlendAssociation::Start(float fStartTime)
{
usFlags |= 0x01;
SetCurrentTime(fStartTime);
}
void CGameTimer::SetCurrentTime( int nDay, int nHour )
{
int nSec = ( ( nDay * 24 ) + nHour ) * 60 * 60;
SetCurrentTime( nSec * TIMESPEED );
}
bool
Clock::UpdateFromParentTime (TimeSpan parentTime)
{
#define CLAMP_NORMALIZED_TIME do { \
if (normalizedTime < 0.0) normalizedTime = 0.0; \
if (normalizedTime > 1.0) normalizedTime = 1.0; \
} while (0)
//
// The idea behind this method is that it is possible (and
// easier, and clearer) to apply a simple function to our
// parent clock's time to calculate our own time.
//
// We also calculate our progress (MS uses the term
// "normalized time"), a value in the range [0-1] at the same
// time.
//
// This clock's localTime runs from the range
// [0-natural_duration] for natural_durations with timespans,
// and [0-$forever] for Forever durations. Automatic
// durations are translated into timespans.
if (timeline == NULL) {
// printf ("timeline is null!? f**k yeah! (clock = %s)\n", name);
Stop ();
return false;
}
if (!GetHasStarted() && !GetWasStopped() && (GetBeginOnTick() || timeline->GetBeginTime () <= parentTime)) {
if (GetBeginOnTick())
BeginOnTick (false);
Begin (parentTime);
}
// root_parent_time is the time we were added to our parent clock.
// timeline->GetBeginTime() is expressed in the time-space of the parent clock.
//
// subtracting those two translates our start time to 0
//
// we then have to account for our accumulated pause time, and
// scale the whole thing by our speed ratio.
//
// the result is a timespan unaffected by repeatbehavior or
// autoreverse. it is simple the timespan our clock has been
// running.
TimeSpan localTime = (parentTime - root_parent_time - timeline->GetBeginTime() - accumulated_pause_time) * timeline->GetSpeedRatio();
bool seek_completed = false;
if (is_seeking) {
// if we're seeking, we need to arrange for the above
// localTime formula to keep time correctly. we clear
// accumulated_pause_time, and adjust root_parent_time
// such that we can re-evaluate localTime and have
// localTime = seek_time.
begin_pause_time = 0;
accumulated_pause_time = 0;
/* seek_time = localTime
seek_time = (parentTime - root_parent_time - timeline->BeginTime() - 0) * timeline->GetSpeedRatio ()
seek_time
------------------------- = parentTime - root_parent_time - timeline->BeginTime();
timeline->GetSpeedRatio()
seek_time
root_parent_time = parentTime - timeline->BeginTime() - -------------------------
timeline->GetSpeedRatio()
*/
root_parent_time = parentTime - (timeline->GetBeginTime () - seek_time) / timeline->GetSpeedRatio ();
localTime = (seek_time - timeline->GetBeginTime()) * timeline->GetSpeedRatio();
is_seeking = false;
seek_completed = true;
if (!GetHasStarted())
CalculateFillTime ();
}
else if (is_paused) {
// if we're paused and not seeking, we don't update
// anything.
return false;
}
// the clock doesn't update and we don't progress if the
// translated local time is before our begin time. Keep in
// mind that this can happen *after* a clock has started,
// since parentTime isn't strictly increasing. It can
// decrease and represent a time before our start time.
if (localTime < 0)
return true;
if (GetClockState () == Clock::Stopped) {
if (!seek_completed)
return false;
// even for stopped clocks we update their position if they're seeked.
}
double normalizedTime = 0.0;
// we only do the bulk of the work if the duration has a
// timespan. if we're automatic/forever, our normalizedTime
// stays pegged at 0.0, and our localTime progresses
// undisturbed. i.e. a RepeatBehavior="2x" means nothing if
// the Duration of the animation is forever.
if (GetNaturalDuration().HasTimeSpan()) {
TimeSpan natural_duration_timespan = GetNaturalDuration().GetTimeSpan();
if (natural_duration_timespan <= 0) {
// for clocks with instantaneous begin times/durations, expressable like so:
// <DoubleAnimation Storyboard.TargetProperty="Opacity" To="1" BeginTime="00:00:00" Duration="00:00:00" />
// we keep our localtime pegged at 0 (FIXME:
// without filling?) and our normalizedTime at
// 1. The latter makes sure that value is applied in full.
localTime = 0;
normalizedTime = 1.0;
if (GetClockState () == Clock::Active) {
FillOnNextTick ();
Completed ();
SetCurrentTime (localTime);
progress = normalizedTime;
return false;
}
}
else if (natural_duration_timespan > 0) {
RepeatBehavior *repeat = timeline->GetRepeatBehavior ();
if (!repeat->IsForever() && localTime >= fillTime) {
// fillTime represents the local time
// at which the number of repeats
// (expressed either as a timespan or
// e.g. "2x") and autoreverses have
// completed. i.e. it's the
// $natural_duration * $repeat_count
// for repeat behaviors with counts,
// and $repeat_duration for repeat
// behaviors with timespans.
// if the timeline is auto-reversible,
// we always end at localTime = 0.
// Otherwise we know it's fillTime.
localTime = timeline->GetAutoReverse () ? 0 : fillTime;
normalizedTime = (double)localTime / natural_duration_timespan;
CLAMP_NORMALIZED_TIME;
if (GetClockState () == Clock::Active) {
FillOnNextTick ();
Completed ();
}
else if ((moonlight_flags & RUNTIME_INIT_USE_IDLE_HINT) && GetClockState () == Clock::Filling) {
return false;
}
}
else {
if (GetClockState () != Clock::Active)
SetClockState (Clock::Active);
if (localTime > 0) {
double t = (double)localTime / natural_duration_timespan;
int ti = (int)t;
double fract = t - ti;
// This block of code is the first time where localTime is translated
// into per-repeat/per-autoreverse segments. We do it here because it
// allows us to use a cute hack for determining if we're ascending or
// descending.
//
// for instance:
// <storyboard duration="00:00:12">
// <doubleanimation begintime="00:00:00" repeatbehavior="2x" autoreverse="<below>" duration="00:00:03" />
// </storyboard>
//
// autoreverse = true autoreverse = false
// 0 / 3 = 0 = 0 0 / 3 = 0 = 0
// 1 / 3 = .333 > 0.333 1 / 3 = .333 > 0.333
// 2 / 3 = .666 > 0.666 2 / 3 = .666 > 0.666
// 3 / 3 = 1 = 1 3 / 3 = 1 = 1
// 4 / 3 = 1.33 < 0.666 4 / 3 = 1.33 > 0.333
// 5 / 3 = 1.66 < 0.333 5 / 3 = 1.66 > 0.666
// 6 / 3 = 2 = 0 6 / 3 = 2 = 1
// 7 / 3 = 2.33 > 0.333
// 8 / 3 = 2.66 > 0.666
// 9 / 3 = 3 = 1
// 10 / 3 = 3.33 < 0.666
// 11 / 3 = 3.66 < 0.333
// 12 / 3 = 4 = 0
// a little explanation: the $localtime / $natural_duration = $foo is done
// to factor out the repeat count. we know that the time within a given repeated
// run is just the fractional part of that (if the result has a fraction), or 0 or 1.
// the >,<,= column above represents whether we're increasing, decreasing, or at an
// end-point, respectively.
if (timeline->GetAutoReverse()) {
// left column above
if (ti & 1) {
// e.g:
// 3 / 3 = 1 = 1
// 4 / 3 = 1.33 < 0.666
// 5 / 3 = 1.66 < 0.333
// we know we're either at normalized time 1 (at our duration), or we're descending,
// based on if there's a fractional component.
if (ti == t) {
normalizedTime = 1.0;
localTime = natural_duration_timespan;
}
else {
/* we're descending */
normalizedTime = 1.0 - fract;
CLAMP_NORMALIZED_TIME;
localTime = normalizedTime * natural_duration_timespan;
}
}
else {
// e.g:
// 6 / 3 = 2 = 0
// 7 / 3 = 2.33 > 0.333
// 8 / 3 = 2.66 > 0.666
// we know we're either at normalizd time 0 (at our start time), or we're ascending,
// based on if there's a fractional component.
if (ti == t) {
normalizedTime = 0.0;
localTime = 0;
}
else {
/* we're ascending */
normalizedTime = fract;
CLAMP_NORMALIZED_TIME;
localTime = normalizedTime * natural_duration_timespan;
}
}
}
else {
// e.g.:
// 0 / 3 = 0 = 0
// 1 / 3 = .333 > 0.333
// 2 / 3 = .666 > 0.666
// 3 / 3 = 1 = 1
// 4 / 3 = 1.33 > 0.333
// 5 / 3 = 1.66 > 0.666
// 6 / 3 = 2 = 1
// we're always ascending here (since autoreverse is off), and we know we're > 0,
// so we don't need to concern ourselves with that case. At the integer points we're
// at our duration, and otherwise we're at the fractional value.
if (ti == t) {
normalizedTime = 1.0;
localTime = natural_duration_timespan;
}
else {
/* we're ascending */
normalizedTime = fract;
CLAMP_NORMALIZED_TIME;
localTime = normalizedTime * natural_duration_timespan;
}
}
}
}
}
}
SetCurrentTime (localTime);
progress = normalizedTime;
// we check to see if there's a clockgroup in our hierarchy
// that's Filling. if there is, we return false here, since
// we won't be updated beyond our current time anyway.
if (moonlight_flags & RUNTIME_INIT_USE_IDLE_HINT) {
Clock *cg = this;
while ((cg = cg->GetParentClock())) {
if (cg->GetClockState () == Clock::Active && !((ClockGroup*)cg)->IsTimeManagerClockGroup())
return true;
}
return false;
}
return true;
}
void CAnimBlendAssociation::SyncAnimation(CAnimBlendAssociation *pOtherAssoc)
{
SetCurrentTime(pOtherAssoc->fCurrentTime / pOtherAssoc->fTotalTime * m_pAnimHierarchy->fTotalTime);
}
CAnimBlendAssociation::CAnimBlendAssociation(CAnimBlendAssociation& assoc)
{
SetCurrentTime(assoc.m_assoc.currentTime / assoc.m_assoc.fTotalTime * m_assoc.animHierarchy->m_totalTime);
}
