skottie::internal::LayerBuilder Class Reference

#include <Layer.h>

Public Member Functions
	LayerBuilder (const skjson::ObjectValue &jlayer, const SkSize &comp_size)
	LayerBuilder (const LayerBuilder &)=default
	~LayerBuilder ()
int	index () const
bool	isCamera () const
sk_sp< sksg::Transform >	buildTransform (const AnimationBuilder &, CompositionBuilder *)
sk_sp< sksg::RenderNode >	buildRenderTree (const AnimationBuilder &, CompositionBuilder *, const LayerBuilder *prev_layer)
const sk_sp< sksg::RenderNode > &	contentTree () const
const SkSize &	size () const

Detailed Description

Definition at line 31 of file Layer.h.

Constructor & Destructor Documentation

LayerBuilder() [1/2]

skottie::internal::LayerBuilder::LayerBuilder	(	const skjson::ObjectValue &	jlayer,
		const SkSize &	comp_size
	)

Definition at line 329 of file Layer.cpp.

    : fJlayer(jlayer)
    , fIndex      (ParseDefault<int>(jlayer["ind"   ], -1))
    , fParentIndex(ParseDefault<int>(jlayer["parent"], -1))
    , fType       (ParseDefault<int>(jlayer["ty"    ], -1))
    , fAutoOrient (ParseDefault<int>(jlayer["ao"    ],  0))
    , fInfo{comp_size,
            ParseDefault<float>(jlayer["ip"], 0.0f),
            ParseDefault<float>(jlayer["op"], 0.0f)}
{
 
    if (this->isCamera() || ParseDefault<int>(jlayer["ddd"], 0)) {
        fFlags |= Flags::kIs3D;
    }
}

LayerBuilder() [2/2]

skottie::internal::LayerBuilder::LayerBuilder ( const LayerBuilder &  )

default

~LayerBuilder()

skottie::internal::LayerBuilder::~LayerBuilder ( )

default

Member Function Documentation

buildRenderTree()

sk_sp< sksg::RenderNode > skottie::internal::LayerBuilder::buildRenderTree	(	const AnimationBuilder &	abuilder,
		CompositionBuilder *	cbuilder,
		const LayerBuilder *	prev_layer
	)

Definition at line 431 of file Layer.cpp.

                                                                                      {
    const AnimationBuilder::AutoPropertyTracker apt(&abuilder, fJlayer, PropertyObserver::NodeType::LAYER);
 
    using LayerBuilder =
        sk_sp<sksg::RenderNode> (AnimationBuilder::*)(const skjson::ObjectValue&,
                                                      AnimationBuilder::LayerInfo*) const;
 
    // AE is annoyingly inconsistent in how effects interact with layer transforms: depending on
    // the layer type, effects are applied before or after the content is transformed.
    //
    // Empirically, pre-rendered layers (for some loose meaning of "pre-rendered") are in the
    // former category (effects are subject to transformation), while the remaining types are in
    // the latter.
    enum : uint32_t {
        kTransformEffects = 0x01, // The layer transform also applies to its effects.
        kForceSeek        = 0x02, // Dispatch all seek() events even when the layer is inactive.
    };
 
    static constexpr struct {
        LayerBuilder                      fBuilder;
        uint32_t                          fFlags;
    } gLayerBuildInfo[] = {
        { &AnimationBuilder::attachPrecompLayer, kTransformEffects },  // 'ty':  0 -> precomp
        { &AnimationBuilder::attachSolidLayer  , kTransformEffects },  // 'ty':  1 -> solid
        { &AnimationBuilder::attachFootageLayer, kTransformEffects },  // 'ty':  2 -> image
        { &AnimationBuilder::attachNullLayer   ,                 0 },  // 'ty':  3 -> null
        { &AnimationBuilder::attachShapeLayer  ,                 0 },  // 'ty':  4 -> shape
        { &AnimationBuilder::attachTextLayer   ,                 0 },  // 'ty':  5 -> text
        { &AnimationBuilder::attachAudioLayer  ,        kForceSeek },  // 'ty':  6 -> audio
        { nullptr                              ,                 0 },  // 'ty':  7 -> pholderVideo
        { nullptr                              ,                 0 },  // 'ty':  8 -> imageSeq
        { &AnimationBuilder::attachFootageLayer, kTransformEffects },  // 'ty':  9 -> video
        { nullptr                              ,                 0 },  // 'ty': 10 -> pholderStill
        { nullptr                              ,                 0 },  // 'ty': 11 -> guide
        { nullptr                              ,                 0 },  // 'ty': 12 -> adjustment
        { &AnimationBuilder::attachNullLayer   ,                 0 },  // 'ty': 13 -> camera
        { nullptr                              ,                 0 },  // 'ty': 14 -> light
    };
 
    if (fType < 0 || static_cast<size_t>(fType) >= std::size(gLayerBuildInfo)) {
        return nullptr;
    }
 
    const auto& build_info = gLayerBuildInfo[fType];
 
    // Switch to the layer animator scope (which at this point holds transform-only animators).
    AnimationBuilder::AutoScope ascope(&abuilder, std::move(fLayerScope));
 
    // Potentially null.
    sk_sp<sksg::RenderNode> layer;
 
    // Build the layer content fragment.
    if (build_info.fBuilder) {
        layer = (abuilder.*(build_info.fBuilder))(fJlayer, &fInfo);
    }
 
    // Clip layers with explicit dimensions.
    float w = 0, h = 0;
    if (::skottie::Parse<float>(fJlayer["w"], &w) && ::skottie::Parse<float>(fJlayer["h"], &h)) {
        layer = sksg::ClipEffect::Make(std::move(layer),
                                       sksg::Rect::Make(SkRect::MakeWH(w, h)),
#ifdef SK_LEGACY_SKOTTIE_CLIPPING
                                       /*aa=*/true, /*force_clip=*/false);
#else
                                       /*aa=*/true, /*force_clip=*/true);
#endif
    }
 
    // Optional layer mask.
    layer = AttachMask(fJlayer["masksProperties"], &abuilder, std::move(layer));
 
    // Does the transform apply to effects also?
    // (AE quirk: it doesn't - except for solid layers)
    const auto transform_effects = (build_info.fFlags & kTransformEffects);
 
    // Attach the transform before effects, when needed.
    if (fLayerTransform && !transform_effects) {
        layer = sksg::TransformEffect::Make(std::move(layer), fLayerTransform);
    }
 
    // Optional layer effects.
    if (const skjson::ArrayValue* jeffects = fJlayer["ef"]) {
        layer = EffectBuilder(&abuilder, fInfo.fSize, cbuilder)
                .attachEffects(*jeffects, std::move(layer));
    }
 
    // Attach the transform after effects, when needed.
    if (fLayerTransform && transform_effects) {
        layer = sksg::TransformEffect::Make(std::move(layer), std::move(fLayerTransform));
    }
 
    // Optional layer styles.
    if (const skjson::ArrayValue* jstyles = fJlayer["sy"]) {
        layer = EffectBuilder(&abuilder, fInfo.fSize, cbuilder)
                .attachStyles(*jstyles, std::move(layer));
    }
 
    // Optional layer opacity.
    // TODO: de-dupe this "ks" lookup with matrix above.
    if (const skjson::ObjectValue* jtransform = fJlayer["ks"]) {
        layer = abuilder.attachOpacity(*jtransform, std::move(layer));
    }
 
    // Stash the content tree in case it is needed for later mattes.
    fContentTree = layer;
    if (ParseDefault<bool>(fJlayer["hd"], false)) {
        layer = nullptr;
    }
 
    const auto has_animators    = !abuilder.fCurrentAnimatorScope->empty();
    const auto force_seek_count = build_info.fFlags & kForceSeek
            ? abuilder.fCurrentAnimatorScope->size()
            : fTransformAnimatorCount;
 
    sk_sp<Animator> controller = sk_make_sp<LayerController>(ascope.release(),
                                                             layer,
                                                             force_seek_count,
                                                             fInfo.fInPoint,
                                                             fInfo.fOutPoint);
 
    // Optional motion blur.
    if (layer && has_animators && this->hasMotionBlur(cbuilder)) {
        // Wrap both the layer node and the controller.
        auto motion_blur = MotionBlurEffect::Make(std::move(controller), std::move(layer),
                                                  cbuilder->fMotionBlurSamples,
                                                  cbuilder->fMotionBlurAngle,
                                                  cbuilder->fMotionBlurPhase);
        controller = sk_make_sp<MotionBlurController>(motion_blur);
        layer = std::move(motion_blur);
    }
 
    abuilder.fCurrentAnimatorScope->push_back(std::move(controller));
 
    if (ParseDefault<bool>(fJlayer["td"], false)) {
        // |layer| is a track matte.  We apply it as a mask to the next layer.
        return nullptr;
    }
 
    // Optional matte.
    const auto matte_mode = prev_layer
            ? ParseDefault<size_t>(fJlayer["tt"], 0)
            : 0;
    if (matte_mode > 0) {
        static constexpr sksg::MaskEffect::Mode gMatteModes[] = {
            sksg::MaskEffect::Mode::kAlphaNormal, // tt: 1
            sksg::MaskEffect::Mode::kAlphaInvert, // tt: 2
            sksg::MaskEffect::Mode::kLumaNormal,  // tt: 3
            sksg::MaskEffect::Mode::kLumaInvert,  // tt: 4
        };
 
        if (matte_mode <= std::size(gMatteModes)) {
            // The current layer is masked with the previous layer *content*.
            layer = sksg::MaskEffect::Make(std::move(layer),
                                           prev_layer->fContentTree,
                                           gMatteModes[matte_mode - 1]);
        } else {
            abuilder.log(Logger::Level::kError, nullptr,
                         "Unknown track matte mode: %zu\n", matte_mode);
        }
    }
 
    // Finally, attach an optional blend mode.
    // NB: blend modes are never applied to matte sources (layer content only).
    return abuilder.attachBlendMode(fJlayer, std::move(layer));
}

buildTransform()

sk_sp< sksg::Transform > skottie::internal::LayerBuilder::buildTransform	(	const AnimationBuilder &	abuilder,
		CompositionBuilder *	cbuilder
	)

Definition at line 353 of file Layer.cpp.

                                                                                  {
    // Depending on the leaf node type, we treat the whole transform chain as either 2D or 3D.
    const auto transform_chain_type = this->is3D() ? TransformType::k3D
                                                   : TransformType::k2D;
    fLayerTransform = this->getTransform(abuilder, cbuilder, transform_chain_type);
 
    return fLayerTransform;
}

contentTree()

const sk_sp< sksg::RenderNode > & skottie::internal::LayerBuilder::contentTree ( ) const

inline

Definition at line 48 of file Layer.h.

{ return fContentTree; }

index()

int skottie::internal::LayerBuilder::index ( ) const

inline

Definition at line 37 of file Layer.h.

{ return fIndex; }

isCamera()

bool skottie::internal::LayerBuilder::isCamera

(

)

const

Definition at line 347 of file Layer.cpp.

                                  {
    static constexpr int kCameraLayerType = 13;
 
    return fType == kCameraLayerType;
}

size()

const SkSize & skottie::internal::LayerBuilder::size ( ) const

inline

Definition at line 50 of file Layer.h.

{ return fInfo.fSize; }

---

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

• third_party/skia/modules/skottie/src/Layer.h
• third_party/skia/modules/skottie/src/Layer.cpp