skottie::Animation Class Reference

#include <Skottie.h>

Inheritance diagram for skottie::Animation:

Classes
class	Builder

Public Types
enum	RenderFlag : uint32_t { kSkipTopLevelIsolation = 0x01 , kDisableTopLevelClipping = 0x02 }
using	RenderFlags = uint32_t

Public Member Functions
	~Animation ()
void	render (SkCanvas *canvas, const SkRect *dst=nullptr) const
void	render (SkCanvas *canvas, const SkRect *dst, RenderFlags) const
void	seek (SkScalar t, sksg::InvalidationController *ic=nullptr)
void	seekFrame (double t, sksg::InvalidationController *ic=nullptr)
void	seekFrameTime (double t, sksg::InvalidationController *=nullptr)
double	duration () const
double	fps () const
double	inPoint () const
double	outPoint () const
const SkString &	version () const
const SkSize &	size () const
Public Member Functions inherited from SkNVRefCnt< Animation >
	SkNVRefCnt ()
	~SkNVRefCnt ()
bool	unique () const
void	ref () const
void	unref () const
void	deref () const
bool	refCntGreaterThan (int32_t threadIsolatedTestCnt) const

Static Public Member Functions
static sk_sp< Animation >	Make (const char *data, size_t length)
static sk_sp< Animation >	Make (SkStream *)
static sk_sp< Animation >	MakeFromFile (const char path[])

Detailed Description

Definition at line 93 of file Skottie.h.

Member Typedef Documentation

RenderFlags

using skottie::Animation::RenderFlags = uint32_t

Definition at line 220 of file Skottie.h.

Member Enumeration Documentation

RenderFlag

enum skottie::Animation::RenderFlag : uint32_t

Enumerator
kSkipTopLevelIsolation
kDisableTopLevelClipping

Definition at line 210 of file Skottie.h.

                    : uint32_t {
        // When rendering into a known transparent buffer, clients can pass
        // this flag to avoid some unnecessary compositing overhead for
        // animations using layer blend modes.
        kSkipTopLevelIsolation   = 0x01,
        // By default, content is clipped to the intrinsic animation
        // bounds (as determined by its size).  If this flag is set,
        // then the animation can draw outside of the bounds.
        kDisableTopLevelClipping = 0x02,
    };

Constructor & Destructor Documentation

~Animation()

skottie::Animation::~Animation ( )

default

Member Function Documentation

duration()

double skottie::Animation::duration ( ) const

inline

Returns the animation duration in seconds.

Definition at line 268 of file Skottie.h.

{ return fDuration; }

fps()

double skottie::Animation::fps ( ) const

inline

Returns the animation frame rate (frames / second).

Definition at line 273 of file Skottie.h.

{ return fFPS; }

inPoint()

double skottie::Animation::inPoint ( ) const

inline

Animation in point, in frame index units.

Definition at line 278 of file Skottie.h.

{ return fInPoint;  }

Make() [1/2]

sk_sp< Animation > skottie::Animation::Make ( const char *  data, size_t  length  )

static

Animation factories.

Use the Builder helper above for more options/control.

Definition at line 534 of file Skottie.cpp.

                                                                {
    return Builder().make(data, length);
}

Make() [2/2]

sk_sp< Animation > skottie::Animation::Make ( SkStream *  stream )

static

Definition at line 538 of file Skottie.cpp.

                                                 {
    return Builder().make(stream);
}

MakeFromFile()

sk_sp< Animation > skottie::Animation::MakeFromFile ( const char  path[] )

static

Definition at line 542 of file Skottie.cpp.

                                                          {
    return Builder().makeFromFile(path);
}

outPoint()

double skottie::Animation::outPoint ( ) const

inline

Animation out point, in frame index units.

Definition at line 283 of file Skottie.h.

{ return fOutPoint; }

render() [1/2]

void skottie::Animation::render	(	SkCanvas *	canvas,
		const SkRect *	dst,
		RenderFlags	renderFlags
	)		const

Definition at line 486 of file Skottie.cpp.

                                                                                          {
    TRACE_EVENT0("skottie", TRACE_FUNC);
 
    if (!fSceneRoot)
        return;
 
    SkAutoCanvasRestore restore(canvas, true);
 
    const SkRect srcR = SkRect::MakeSize(this->size());
    if (dstR) {
        canvas->concat(SkMatrix::RectToRect(srcR, *dstR, SkMatrix::kCenter_ScaleToFit));
    }
 
    if (!(renderFlags & RenderFlag::kDisableTopLevelClipping)) {
        canvas->clipRect(srcR);
    }
 
    if ((fFlags & Flags::kRequiresTopLevelIsolation) &&
        !(renderFlags & RenderFlag::kSkipTopLevelIsolation)) {
        // The animation uses non-trivial blending, and needs
        // to be rendered into a separate/transparent layer.
        canvas->saveLayer(srcR, nullptr);
    }
 
    fSceneRoot->render(canvas);
}

render() [2/2]

void skottie::Animation::render	(	SkCanvas *	canvas,
		const SkRect *	dst = nullptr
	)		const

Draws the current animation frame.

It is undefined behavior to call render() on a newly created Animation before specifying an initial frame via one of the seek() variants.

Parameters

canvas	destination canvas
dst	optional destination rect
flags	optional RenderFlags

Definition at line 482 of file Skottie.cpp.

                                                                 {
    this->render(canvas, dstR, 0);
}

seek()

void skottie::Animation::seek ( SkScalar  t, sksg::InvalidationController *  ic = nullptr  )

inline

[Deprecated: use one of the other versions.]

Updates the animation state for |t|.

Parameters

t	normalized [0..1] frame selector (0 -> first frame, 1 -> final frame)
ic	optional invalidation controller (dirty region tracking)

Definition at line 244 of file Skottie.h.

                                                                    {
        this->seekFrameTime(t * this->duration(), ic);
    }

seekFrame()

void skottie::Animation::seekFrame	(	double	t,
		sksg::InvalidationController *	ic = nullptr
	)

Update the animation state to match |t|, specified as a frame index i.e. relative to duration() * fps().

Fractional values are allowed and meaningful - e.g.

0.0 -> first frame 1.0 -> second frame 0.5 -> halfway between first and second frame

Definition at line 513 of file Skottie.cpp.

                                                                  {
    TRACE_EVENT0("skottie", TRACE_FUNC);
 
    if (!fSceneRoot)
        return;
 
    // Per AE/Lottie semantics out_point is exclusive.
    const auto kLastValidFrame = std::nextafterf(fOutPoint, fInPoint),
                     comp_time = SkTPin<float>(fInPoint + t, fInPoint, kLastValidFrame);
 
    for (const auto& anim : fAnimators) {
        anim->seek(comp_time);
    }
 
    fSceneRoot->revalidate(ic, SkMatrix::I());
}

seekFrameTime()

void skottie::Animation::seekFrameTime	(	double	t,
		sksg::InvalidationController *	ic = nullptr
	)

Update the animation state to match t, specifed in frame time i.e. relative to duration().

Definition at line 530 of file Skottie.cpp.

                                                                      {
    this->seekFrame(t * fFPS, ic);
}

size()

const SkSize & skottie::Animation::size ( ) const

inline

Definition at line 286 of file Skottie.h.

{ return fSize;    }

version()

const SkString & skottie::Animation::version ( ) const

inline

Definition at line 285 of file Skottie.h.

{ return fVersion; }

---

The documentation for this class was generated from the following files:

• third_party/skia/modules/skottie/include/Skottie.h
• third_party/skia/modules/skottie/src/Skottie.cpp