painter.setDrawRegion(
VRect(int(surface.drawRegionPosX()), int(surface.drawRegionPosY()),
int(surface.drawRegionWidth()), int(surface.drawRegionHeight())));
-
- // layer surface should be created if it is not created already or its size
- // is changed.
- bool isLayerSurfaceCreated = mSurfaceCache.is_layer_surface_created();
- bool isLayerSurfaceSizeChanged =
- isLayerSurfaceCreated &&
- (mSurfaceCache.get_layer_surface()->width() != surface.width() ||
- mSurfaceCache.get_layer_surface()->height() != surface.height());
-
- if (!isLayerSurfaceCreated || isLayerSurfaceSizeChanged) {
- if (isLayerSurfaceCreated && isLayerSurfaceSizeChanged)
- mSurfaceCache.delete_layer_surface();
-
- mSurfaceCache.create_layer_surface(surface.width(), surface.height(),
- VBitmap::Format::ARGB32_Premultiplied);
-
- // set layer draw region
- mSurfaceCache.get_layer_painter()->setDrawRegion(
- VRect(int(surface.drawRegionPosX()), int(surface.drawRegionPosY()),
- int(surface.drawRegionWidth()), int(surface.drawRegionHeight())));
- }
-
mRootLayer->render(&painter, {}, {}, mSurfaceCache);
painter.end();
return true;
}
void renderer::Layer::render(VPainter *painter, const VRle &inheritMask,
- const VRle &matteRle, SurfaceCache &cache)
+ const VRle &matteRle, SurfaceCache &)
{
auto renderlist = renderList();
mask = inheritMask;
}
- VPainter *usedPainter = painter;
-
- if (cache.get_layer_painter() != nullptr) {
- usedPainter = cache.get_layer_painter();
- usedPainter->begin(cache.get_layer_surface());
- }
-
for (auto &i : renderlist) {
- usedPainter->setBrush(i->mBrush);
+ painter->setBrush(i->mBrush);
VRle rle = i->rle();
if (matteRle.empty()) {
if (mask.empty()) {
// no mask no matte
- usedPainter->drawRle(VPoint(), rle);
+ painter->drawRle(VPoint(), rle);
} else {
// only mask
- usedPainter->drawRle(rle, mask);
+ painter->drawRle(rle, mask);
}
+
} else {
if (!mask.empty()) rle = rle & mask;
if (rle.empty()) continue;
if (matteType() == model::MatteType::AlphaInv) {
rle = rle - matteRle;
- usedPainter->drawRle(VPoint(), rle);
+ painter->drawRle(VPoint(), rle);
} else {
// render with matteRle as clip.
- usedPainter->drawRle(rle, matteRle);
+ painter->drawRle(rle, matteRle);
}
}
}
-
- if (cache.get_layer_painter() != nullptr) {
- usedPainter->end();
- painter->drawBitmap(VPoint(), *cache.get_layer_surface(), mCombinedAlpha * 255.0f);
- }
}
void renderer::LayerMask::preprocess(const VRect &clip)
void renderer::ShapeLayer::updateContent()
{
- mRoot->update(frameNo(), combinedMatrix(), combinedAlpha(), flag());
+ mRoot->update(frameNo(), combinedMatrix(), 1.0f , flag());
if (mLayerData->hasPathOperator()) {
mRoot->applyTrim();
return {mDrawableList.data(), mDrawableList.size()};
}
+void renderer::ShapeLayer::render(VPainter *painter, const VRle &inheritMask,
+ const VRle &matteRle, SurfaceCache &cache)
+{
+ if (vIsZero(combinedAlpha())) return;
+
+ if (vCompare(combinedAlpha(), 1.0)) {
+ Layer::render(painter, inheritMask, matteRle, cache);
+ } else {
+ //do offscreen rendering
+ VSize size = painter->clipBoundingRect().size();
+ VPainter srcPainter;
+ VBitmap srcBitmap = cache.make_surface(size.width(), size.height());
+ srcPainter.begin(&srcBitmap);
+ Layer::render(&srcPainter, inheritMask, matteRle, cache);
+ srcPainter.end();
+ painter->drawBitmap(VPoint(), srcBitmap,
+ uint8_t(combinedAlpha() * 255.0f));
+ cache.release_surface(srcBitmap);
+ }
+}
+
bool renderer::Group::resolveKeyPath(LOTKeyPath &keyPath, uint32_t depth,
LOTVariant &value)
{
mMatrix = m;
- alpha = mModel.transform()->opacity(frameNo);
+ alpha = parentAlpha * mModel.transform()->opacity(frameNo);
if (!vCompare(alpha, parentAlpha)) {
newFlag |= DirtyFlagBit::Alpha;
}
}
void release_surface(VBitmap &surface) { mCache.push_back(surface); }
- bool is_layer_surface_created() const { return mIsLayerBitmapCreated; }
- void create_layer_surface(size_t width, size_t height, VBitmap::Format format)
- {
- if (mIsLayerBitmapCreated) return;
-
- mLayerBitmap = std::make_unique<VBitmap>(width, height, format);
- mBitmapPainter = std::make_unique<VPainter>(mLayerBitmap.get());
- mIsLayerBitmapCreated = true;
- }
- void delete_layer_surface()
- {
- if (!mIsLayerBitmapCreated) return;
-
- mLayerBitmap.reset();
- mBitmapPainter.reset();
- mIsLayerBitmapCreated = false;
- }
- VPainter* get_layer_painter() const { return mBitmapPainter.get(); }
- VBitmap* get_layer_surface() const { return mLayerBitmap.get(); }
private:
std::vector<VBitmap> mCache;
- std::unique_ptr<VBitmap> mLayerBitmap{nullptr};
- std::unique_ptr<VPainter> mBitmapPainter{nullptr};
- bool mIsLayerBitmapCreated{false};
};
class Drawable final : public VDrawable {
void buildLayerNode() final;
bool resolveKeyPath(LOTKeyPath &keyPath, uint32_t depth,
LOTVariant &value) override;
+ void render(VPainter *painter, const VRle &mask, const VRle &matteRle,
+ SurfaceCache &cache) final;
protected:
void preprocessStage(const VRect &clip) final;