174 lines
4.7 KiB
C++
174 lines
4.7 KiB
C++
//
|
|
// VROTransaction.h
|
|
// ViroRenderer
|
|
//
|
|
// Created by Raj Advani on 10/22/15.
|
|
// Copyright © 2015 Viro Media. All rights reserved.
|
|
//
|
|
|
|
#ifndef VROTransaction_h
|
|
#define VROTransaction_h
|
|
|
|
#include <stdio.h>
|
|
#include <vector>
|
|
#include <memory>
|
|
#include <functional>
|
|
#include "VROAnimation.h"
|
|
#include "VROTimingFunction.h"
|
|
|
|
class VROTransaction {
|
|
|
|
public:
|
|
|
|
#pragma mark - Static Animation API
|
|
|
|
/*
|
|
Retrieve the active (most deeply nested) uncommitted VROTransaction. Returns
|
|
nullptr if there is no active VROTransaction.
|
|
*/
|
|
static std::shared_ptr<VROTransaction> get();
|
|
|
|
/*
|
|
Return true if there exists an uncommitted VROTransaction with duration greater
|
|
than zero. If false, then animations are considered disabled.
|
|
*/
|
|
static bool isActive();
|
|
|
|
/*
|
|
Update the T values for all committed animation transactions.
|
|
*/
|
|
static void update();
|
|
|
|
/*
|
|
Begin a new VROTransaction on this thread, and make this the active animation
|
|
transaction.
|
|
*/
|
|
static void begin();
|
|
|
|
/*
|
|
Adds the given transaction to the openTransactions stack. Internal use only by the Java API.
|
|
Enables creating a new transaction off the rendering thread, before adding it to the animation
|
|
stack on the rendering thread.
|
|
*/
|
|
static void add(std::shared_ptr<VROTransaction> transaction);
|
|
|
|
/*
|
|
Pauses a VROTransaction if it hasn't yet been paused.
|
|
*/
|
|
static void pause(std::shared_ptr<VROTransaction> transaction);
|
|
|
|
/*
|
|
Resumes a paused a VROTransaction. The animation will continue to
|
|
play from where it had left off.
|
|
*/
|
|
static void resume(std::shared_ptr<VROTransaction> transaction);
|
|
|
|
/*
|
|
Cancels a VROTransaction at the current T value. Cancelled transactions
|
|
can no longer be paused or resumed.
|
|
|
|
Note: this is currently only used internally and currently isn't hooked
|
|
up to animations at all (it won't cancel animations, call callbacks, etc).
|
|
|
|
TODO: VIRO-1464 Add ability to cancel (vs terminate) animations
|
|
*/
|
|
static void cancel(std::shared_ptr<VROTransaction> transaction);
|
|
|
|
/*
|
|
Terminates a VROTransaction. Terminated transactions can no longer
|
|
be paused or resumed.
|
|
*/
|
|
static void terminate(std::shared_ptr<VROTransaction> transaction, bool jumpToEnd);
|
|
|
|
/*
|
|
Commit the active VROTransaction.
|
|
*/
|
|
static std::shared_ptr<VROTransaction> commit();
|
|
|
|
/*
|
|
Set the animation duration for the active animation transaction, in seconds.
|
|
*/
|
|
static void setAnimationDuration(float durationSeconds);
|
|
static float getAnimationDuration();
|
|
|
|
/*
|
|
Set the time in seconds that we wait before the animation starts (after
|
|
the animation is committed).
|
|
*/
|
|
static void setAnimationDelay(float delaySeconds);
|
|
|
|
/*
|
|
Set to true to make this transaction automatically loop to the beginning on finish.
|
|
In effect - reset _time to beginning of animation onFinish if _loop is set.
|
|
*/
|
|
static void setAnimationLoop(bool loop);
|
|
|
|
/*
|
|
Set a callback to invoke when the active transaction completes (after duration
|
|
seconds).
|
|
*/
|
|
static void setFinishCallback(std::function<void(bool terminate)> finishCallback);
|
|
|
|
/*
|
|
Set a timing function, which defines the curve of the animation (ease in, ease out,
|
|
etc.)
|
|
*/
|
|
static void setTimingFunction(VROTimingFunctionType timingFunctionType);
|
|
static void setTimingFunction(std::unique_ptr<VROTimingFunction> timingFunction);
|
|
|
|
#pragma mark - VROTransaction
|
|
|
|
VROTransaction();
|
|
~VROTransaction() {}
|
|
|
|
/*
|
|
Get the T value (between 0 and 1) representing current progress through this
|
|
animation.
|
|
*/
|
|
double getT() {
|
|
return _t;
|
|
}
|
|
|
|
/*
|
|
Return true if this animation has a duration of 0.
|
|
*/
|
|
bool isDegenerate() {
|
|
return _durationSeconds <= 0;
|
|
}
|
|
|
|
/*
|
|
Add a new animation to this transaction.
|
|
*/
|
|
void addAnimation(std::shared_ptr<VROAnimation> animation) {
|
|
_animations.push_back(animation);
|
|
}
|
|
|
|
/*
|
|
Process another frame of all animations in this transaction. The
|
|
t value here is prior to timing function transformation.
|
|
*/
|
|
void processAnimations(float t);
|
|
|
|
/*
|
|
Invoked when the transaction is finished.
|
|
*/
|
|
void onTermination();
|
|
|
|
private:
|
|
|
|
double _t;
|
|
double _durationSeconds;
|
|
double _startTimeSeconds;
|
|
double _delayTimeSeconds;
|
|
double _processedTimeWhenPaused;
|
|
bool _paused;
|
|
bool _loop;
|
|
std::unique_ptr<VROTimingFunction> _timingFunction;
|
|
|
|
std::function<void(bool terminate)> _finishCallback;
|
|
std::vector<std::shared_ptr<VROAnimation>> _animations;
|
|
|
|
};
|
|
|
|
#endif /* VROTransaction_h */
|