PassRefPtr<RenderStyle> CompositeAnimation::animate(RenderObject* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
{
RefPtr<RenderStyle> resultStyle;
// We don't do any transitions if we don't have a currentStyle (on startup).
updateTransitions(renderer, currentStyle, targetStyle);
updateKeyframeAnimations(renderer, currentStyle, targetStyle);
m_keyframeAnimations.checkConsistency();
if (currentStyle) {
// Now that we have transition objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
if (!m_transitions.isEmpty()) {
CSSPropertyTransitionsMap::const_iterator end = m_transitions.end();
for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) {
if (ImplicitAnimation* anim = it->second.get())
anim->animate(this, renderer, currentStyle, targetStyle, resultStyle);
}
}
}
// Now that we have animation objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
for (Vector<AtomicStringImpl*>::const_iterator it = m_keyframeAnimationOrderMap.begin(); it != m_keyframeAnimationOrderMap.end(); ++it) {
RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(*it);
if (keyframeAnim)
keyframeAnim->animate(this, renderer, currentStyle, targetStyle, resultStyle);
}
return resultStyle ? resultStyle.release() : targetStyle;
}
void Scene::moveMulti( Clip *clip, int clipTrack, double newPos )
{
QMutexLocker ml( &mutex );
if ( clip->position() == newPos )
return;
double delta = newPos - clip->position();
double margin = profile.getVideoFrameDuration() / 4.0;
Track *t = tracks[clipTrack];
int count = t->clipCount();
int clipIndex = 0;
int k = 0;
while ( k < count ) {
Clip *c = t->clipAt( k );
// find clip
if ( c == clip ) {
clipIndex = k;
break;
}
++k;
}
removeTransitions( clip, clipTrack, clipTrack, clipIndex, newPos, clip->length(), margin, true );
clip->setPosition( clip->position() + delta );
while ( ++k < count ) {
Clip *c = t->clipAt( k );
c->setPosition( c->position() + delta );
}
updateTransitions( clip, clipTrack, margin );
clip->setInput( NULL );
update = true;
}
Ref<RenderStyle> CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle)
{
RefPtr<RenderStyle> resultStyle;
// We don't do any transitions if we don't have a currentStyle (on startup).
updateTransitions(&renderer, currentStyle, &targetStyle);
updateKeyframeAnimations(&renderer, currentStyle, &targetStyle);
m_keyframeAnimations.checkConsistency();
if (currentStyle) {
// Now that we have transition objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
if (!m_transitions.isEmpty()) {
for (auto& transition : m_transitions.values())
transition->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
}
}
// Now that we have animation objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
for (auto& name : m_keyframeAnimationOrderMap) {
RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name);
if (keyframeAnim)
keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
}
if (resultStyle)
return resultStyle.releaseNonNull();
return targetStyle;
}
bool CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle, Ref<RenderStyle>& blendedStyle)
{
// We don't do any transitions if we don't have a currentStyle (on startup).
updateTransitions(&renderer, currentStyle, &targetStyle);
updateKeyframeAnimations(&renderer, currentStyle, &targetStyle);
m_keyframeAnimations.checkConsistency();
RefPtr<RenderStyle> animatedStyle;
bool animationStateChanged = false;
if (currentStyle) {
// Now that we have transition objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
for (auto& transition : m_transitions.values()) {
if (transition->animate(this, &renderer, currentStyle, &targetStyle, animatedStyle))
animationStateChanged = true;
}
}
// Now that we have animation objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
for (auto& name : m_keyframeAnimationOrderMap) {
RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name);
if (keyframeAnim && keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, animatedStyle))
animationStateChanged = true;
}
if (animatedStyle)
blendedStyle = animatedStyle.releaseNonNull();
else
blendedStyle = targetStyle;
return animationStateChanged;
}
void TSShapeInstance::transitionToSequence(TSThread * thread, S32 seq, F32 pos, F32 duration, bool continuePlay)
{
// make sure all transforms on all detail levels are accurate
sortThreads();
animateNodeSubtrees();
thread->transitionToSequence(seq,pos,duration,continuePlay);
setDirty(AllDirtyMask);
mGroundThread = NULL;
if (mScaleCurrentlyAnimated && !thread->getSequence()->animatesScale())
checkScaleCurrentlyAnimated();
else if (!mScaleCurrentlyAnimated && thread->getSequence()->animatesScale())
mScaleCurrentlyAnimated=true;
mTransitionRotationNodes.overlap(thread->transitionData.oldRotationNodes);
mTransitionRotationNodes.overlap(thread->getSequence()->rotationMatters);
mTransitionTranslationNodes.overlap(thread->transitionData.oldTranslationNodes);
mTransitionTranslationNodes.overlap(thread->getSequence()->translationMatters);
mTransitionScaleNodes.overlap(thread->transitionData.oldScaleNodes);
mTransitionScaleNodes.overlap(thread->getSequence()->scaleMatters);
// if we aren't already in the list of transition threads, add us now
S32 i;
for (i=0; i<mTransitionThreads.size(); i++)
if (mTransitionThreads[i]==thread)
break;
if (i==mTransitionThreads.size())
mTransitionThreads.push_back(thread);
updateTransitions();
}
void Scene::move( Clip *clip, int clipTrack, double newPos, int newTrack )
{
QMutexLocker ml( &mutex );
if ( clip->position() == newPos && clipTrack == newTrack )
return;
double margin = profile.getVideoFrameDuration() / 4.0;
int insert, self = 0;
Track *t = tracks[newTrack];
insert = t->clipCount();
for ( int i = 0; i < t->clipCount(); ++i ) {
Clip *c = t->clipAt( i );
if ( c == clip ) {
++self;
continue;
}
if ( newPos < c->position() ) {
insert = i;
break;
}
}
insert -= self;
removeTransitions( clip, clipTrack, newTrack, insert, newPos, clip->length(), margin );
tracks[clipTrack]->removeClip( clip );
t->insertClipAt( clip, insert );
clip->setPosition( newPos );
updateTransitions( clip, newTrack, margin );
clip->setInput( NULL );
update = true;
}
void Unit::update()
{
if (isPaused)
return;
auto curTime = the::timer::globalTime();
dt = curTime - lastTimeUpdated;
lastTimeUpdated = curTime;
updateTransitions();
}
void Scene::addClip( Clip *clip, int track )
{
QMutexLocker ml( &mutex );
double margin = profile.getVideoFrameDuration() / 4.0;
Track *t = tracks[track];
int i = 0, cc = t->clipCount();
while ( i < cc ) {
Clip *c = t->clipAt( i );
if ( clip->position() < c->position() ) {
t->insertClipAt( clip, i );
updateTransitions( clip, track, margin );
update = true;
return;
}
++i;
}
t->insertClipAt( clip, i );
updateTransitions( clip, track, margin );
}
void Scene::resize( Clip *clip, double newLength, int track )
{
QMutexLocker ml( &mutex );
if ( clip->length() == newLength )
return;
double margin = profile.getVideoFrameDuration() / 4.0;
removeTransitions( clip, track, track, tracks[track]->indexOf( clip ), clip->position(), newLength, margin );
double old = clip->position() + clip->length();
if ( clip->getSource()->getType() == InputBase::FFMPEG && clip->getSpeed() < 0 )
clip->setStart( clip->start() + ((clip->length() - newLength) * qAbs(clip->getSpeed())) );
clip->setLength( newLength );
updateTransitions( clip, track, margin );
clip->setInput( NULL );
update = updateCurrentPosition( qMin( old, clip->position() + clip->length() ), qMax( old, clip->position() + clip->length() ) );
}
void TSShapeInstance::clearTransition(TSThread * thread)
{
if (!thread->transitionData.inTransition)
return;
// if other transitions are still playing,
// make sure transforms are up to date
if (mTransitionThreads.size()>1)
animateNodeSubtrees();
// turn off transition...
thread->transitionData.inTransition = false;
// remove us from transition list
S32 i;
if (mTransitionThreads.size() != 0) {
for (i=0; i<mTransitionThreads.size(); i++)
if (mTransitionThreads[i]==thread)
break;
AssertFatal(i!=mTransitionThreads.size(),"TSShapeInstance::clearTransition");
mTransitionThreads.erase(i);
}
// recompute transitionNodes
mTransitionRotationNodes.clearAll();
mTransitionTranslationNodes.clearAll();
mTransitionScaleNodes.clearAll();
for (i=0; i<mTransitionThreads.size(); i++)
{
mTransitionRotationNodes.overlap(mTransitionThreads[i]->transitionData.oldRotationNodes);
mTransitionRotationNodes.overlap(mTransitionThreads[i]->getSequence()->rotationMatters);
mTransitionTranslationNodes.overlap(mTransitionThreads[i]->transitionData.oldTranslationNodes);
mTransitionTranslationNodes.overlap(mTransitionThreads[i]->getSequence()->translationMatters);
mTransitionScaleNodes.overlap(mTransitionThreads[i]->transitionData.oldScaleNodes);
mTransitionScaleNodes.overlap(mTransitionThreads[i]->getSequence()->scaleMatters);
}
setDirty(ThreadDirty);
updateTransitions();
}
void TSShapeInstance::setSequence(TSThread * thread, S32 seq, F32 pos)
{
if ( (thread->transitionData.inTransition && mTransitionThreads.size()>1) || mTransitionThreads.size()>0)
{
// if we have transitions, make sure transforms are up to date...
sortThreads();
animateNodeSubtrees();
}
thread->setSequence(seq,pos);
setDirty(AllDirtyMask);
mGroundThread = NULL;
if (mScaleCurrentlyAnimated && !thread->getSequence()->animatesScale())
checkScaleCurrentlyAnimated();
else if (!mScaleCurrentlyAnimated && thread->getSequence()->animatesScale())
mScaleCurrentlyAnimated=true;
updateTransitions();
}
RenderStyle* CompositeAnimation::animate(RenderObject* renderer, const RenderStyle* currentStyle, RenderStyle* targetStyle)
{
RenderStyle* resultStyle = 0;
// We don't do any transitions if we don't have a currentStyle (on startup)
updateTransitions(renderer, currentStyle, targetStyle);
if (currentStyle) {
// Now that we have transition objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
CSSPropertyTransitionsMap::const_iterator end = m_transitions.end();
for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) {
ImplicitAnimation* anim = it->second;
if (anim) {
anim->animate(this, renderer, currentStyle, targetStyle, resultStyle);
}
}
}
updateKeyframeAnimations(renderer, currentStyle, targetStyle);
// Now that we have animation objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
if (targetStyle->hasAnimations()) {
for (size_t i = 0; i < targetStyle->animations()->size(); ++i) {
const Animation* anim = (*targetStyle->animations())[i].get();
if (anim->isValidAnimation()) {
AtomicString name(anim->name());
KeyframeAnimation* keyframeAnim = m_keyframeAnimations.get(name.impl());
if (keyframeAnim)
keyframeAnim->animate(this, renderer, currentStyle, targetStyle, resultStyle);
}
}
}
cleanupFinishedAnimations(renderer);
return resultStyle ? resultStyle : targetStyle;
}
PassRefPtr<RenderStyle> CompositeAnimationPrivate::animate(RenderObject* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
{
RefPtr<RenderStyle> resultStyle;
// Update animations first so we can see if any transitions are overridden
updateKeyframeAnimations(renderer, currentStyle, targetStyle);
// We don't do any transitions if we don't have a currentStyle (on startup)
updateTransitions(renderer, currentStyle, targetStyle);
if (currentStyle) {
// Now that we have transition objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
CSSPropertyTransitionsMap::const_iterator end = m_transitions.end();
for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) {
if (ImplicitAnimation* anim = it->second.get())
anim->animate(m_compositeAnimation, renderer, currentStyle, targetStyle, resultStyle);
}
}
// Now that we have animation objects ready, let them know about the new goal state. We want them
// to fill in a RenderStyle*& only if needed.
if (targetStyle->hasAnimations()) {
for (size_t i = 0; i < targetStyle->animations()->size(); ++i) {
const Animation* anim = targetStyle->animations()->animation(i);
if (anim->isValidAnimation()) {
AtomicString animationName(anim->name());
RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(animationName.impl());
if (keyframeAnim)
keyframeAnim->animate(m_compositeAnimation, renderer, currentStyle, targetStyle, resultStyle);
}
}
}
cleanupFinishedAnimations(renderer);
return resultStyle ? resultStyle.release() : targetStyle;
}
void Scene::resizeStart( Clip *clip, double newPos, double newLength, int track )
{
QMutexLocker ml( &mutex );
if ( clip->position() == newPos && clip->length() == newLength )
return;
double margin = profile.getVideoFrameDuration() / 4.0;
int insert, self = 0;
Track *t = tracks[track];
insert = t->clipCount();
for ( int i = 0; i < t->clipCount(); ++i ) {
Clip *c = t->clipAt( i );
if ( c == clip ) {
++self;
continue;
}
if ( newPos < c->position() ) {
insert = i;
break;
}
}
insert -= self;
double old = clip->position();
removeTransitions( clip, track, track, insert, newPos, newLength, margin );
t->removeClip( clip );
t->insertClipAt( clip, insert );
if ( clip->getSource()->getType() == InputBase::FFMPEG && clip->getSpeed() >= 0 )
clip->setStart( clip->start() + ((clip->length() - newLength) * qAbs(clip->getSpeed())) );
clip->setLength( newLength );
clip->setPosition( newPos );
updateTransitions( clip, track, margin );
clip->setInput( NULL );
update = updateCurrentPosition( qMin( old, clip->position() ), qMax( old, clip->position() ) );
}
