skottie::internal::CompositionBuilder Class Reference

#include <Composition.h>

Inheritance diagram for skottie::internal::CompositionBuilder:

Public Member Functions
	CompositionBuilder (const AnimationBuilder &, const SkSize &, const skjson::ObjectValue &)
	~CompositionBuilder ()
sk_sp< sksg::RenderNode >	build (const AnimationBuilder &)
LayerBuilder *	layerBuilder (int layer_index)

Friends
class	LayerBuilder

Detailed Description

Definition at line 32 of file Composition.h.

Constructor & Destructor Documentation

CompositionBuilder()

skottie::internal::CompositionBuilder::CompositionBuilder	(	const AnimationBuilder &	abuilder,
		const SkSize &	size,
		const skjson::ObjectValue &	jcomp
	)

Definition at line 53 of file Composition.cpp.

    : fSize(size) {
 
    // Optional motion blur params.
    if (const skjson::ObjectValue* jmb = jcomp["mb"]) {
        static constexpr size_t kMaxSamplesPerFrame = 64;
        fMotionBlurSamples = std::min(ParseDefault<size_t>((*jmb)["spf"], 1ul),
                                      kMaxSamplesPerFrame);
        fMotionBlurAngle = SkTPin(ParseDefault((*jmb)["sa"], 0.0f),    0.0f, 720.0f);
        fMotionBlurPhase = SkTPin(ParseDefault((*jmb)["sp"], 0.0f), -360.0f, 360.0f);
    }
 
    int camera_builder_index = -1;
 
    // Prepare layer builders.
    if (const skjson::ArrayValue* jlayers = jcomp["layers"]) {
        fLayerBuilders.reserve(SkToInt(jlayers->size()));
        for (const skjson::ObjectValue* jlayer : *jlayers) {
            if (!jlayer) continue;
 
            const auto  lbuilder_index = fLayerBuilders.size();
            fLayerBuilders.emplace_back(*jlayer, fSize);
            const auto& lbuilder = fLayerBuilders.back();
 
            fLayerIndexMap.set(lbuilder.index(), lbuilder_index);
 
            // Keep track of the camera builder.
            if (lbuilder.isCamera()) {
                // We only support one (first) camera for now.
                if (camera_builder_index < 0) {
                    camera_builder_index = SkToInt(lbuilder_index);
                } else {
                    abuilder.log(Logger::Level::kWarning, jlayer,
                                 "Ignoring duplicate camera layer.");
                }
            }
        }
    }
 
    // Attach a camera transform upfront, if needed (required to build
    // all other 3D transform chains).
    if (camera_builder_index >= 0) {
        // Explicit camera.
        fCameraTransform = fLayerBuilders[camera_builder_index].buildTransform(abuilder, this);
    } else if (ParseDefault<int>(jcomp["ddd"], 0) && !fSize.isEmpty()) {
        // Default/implicit camera when 3D layers are present.
        fCameraTransform = CameraAdaper::DefaultCameraTransform(fSize);
    }
}

~CompositionBuilder()

skottie::internal::CompositionBuilder::~CompositionBuilder ( )

default

Member Function Documentation

build()

sk_sp< sksg::RenderNode > skottie::internal::CompositionBuilder::build

(

const AnimationBuilder &

abuilder

)

Definition at line 119 of file Composition.cpp.

                                                                                {
    // First pass - transitively attach layer transform chains.
    for (auto& lbuilder : fLayerBuilders) {
        lbuilder.buildTransform(abuilder, this);
    }
 
    // Second pass - attach actual layer contents and finalize the layer render tree.
    std::vector<sk_sp<sksg::RenderNode>> layers;
    layers.reserve(fLayerBuilders.size());
 
    LayerBuilder* prev_layer = nullptr;
    for (auto& lbuilder : fLayerBuilders) {
        if (auto layer = lbuilder.buildRenderTree(abuilder, this, prev_layer)) {
            layers.push_back(std::move(layer));
        }
        prev_layer = &lbuilder;
    }
 
    if (layers.empty()) {
        return nullptr;
    }
 
    if (layers.size() == 1) {
        return std::move(layers[0]);
    }
 
    // Layers are painted in bottom->top order.
    std::reverse(layers.begin(), layers.end());
    layers.shrink_to_fit();
 
    return sksg::Group::Make(std::move(layers));
}

layerBuilder()

LayerBuilder * skottie::internal::CompositionBuilder::layerBuilder

(

int

layer_index

)

Definition at line 107 of file Composition.cpp.

                                                              {
    if (layer_index < 0) {
        return nullptr;
    }
 
    if (const auto* idx = fLayerIndexMap.find(layer_index)) {
        return &fLayerBuilders[SkToInt(*idx)];
    }
 
    return nullptr;
}

Friends And Related Function Documentation

LayerBuilder

friend class LayerBuilder

friend

Definition at line 44 of file Composition.h.

---

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

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