Report pending text reshapes in scene content-changed check and skip redundant holder dirtying.

Author: Hparty

include/pagx/PAGComposition.h

@@ -190,6 +190,11 @@ class PAGComposition : public PAGLayer {
   // ViewModel/Animation-driven text once per draw. fontConfig is borrowed for the call.
   void flushTextHolders(FontConfig* fontConfig);
 
+  // Returns true if any TextHolder in this composition's binding (or a descendant composition's)
+  // has a pending reshape. Used by PAGScene::hasContentChanged so a dirty holder is not dropped by
+  // the dirty gate before flush runs.
+  bool hasDirtyTextHolders() const;
+
   friend class PAGScene;
 };
 

playground/pagx-viewer/src/cpp/PAGXView.cpp

@@ -21,6 +21,7 @@
 #include <emscripten/html5.h>
 #include <algorithm>
 #include <cstdint>
+#include "pagx/PAGAnimation.h"
 #include "pagx/PAGXImporter.h"
 #include "pagx/tgfx.h"
 #include "pagx/types/Data.h"

resources/text_reshape_demo.pagx

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<pagx width="400" height="200" viewModel="@MainVM">
+  <Resources>
+    <ViewModel id="MainVM">
+      <Property id="title" name="title" type="String" default="VM Default"/>
+      <Property id="size" name="size" type="Number" default="40"/>
+    </ViewModel>
+  </Resources>
+
+  <Layer id="animLayer" name="AnimText" width="400" height="100">
+    <Group>
+      <Text id="animText" text="Hello" fontFamily="NotoSansSC" fontSize="40" position="20,70"/>
+      <Fill color="#000000"/>
+    </Group>
+    <Timelines>
+      <Animation ref="@textAnim"/>
+    </Timelines>
+  </Layer>
+
+  <Layer id="vmLayer" name="VMText" width="400" height="100" y="100">
+    <Group>
+      <Text id="vmText" text="VM Default" fontFamily="NotoSansSC" fontSize="40" position="20,170"/>
+      <Fill color="#0000FF"/>
+    </Group>
+  </Layer>
+
+  <DataBind source="$vm.title" target="@vmText" channel="text"/>
+  <DataBind source="$vm.size" target="@vmText" channel="fontSize"/>
+
+  <Animations>
+    <Animation id="textAnim" duration="120" frameRate="60" loop="once">
+      <Object target="animText">
+        <Channel name="text" type="string">
+          <Key time="0" value="Hello" interpolation="hold"/>
+          <Key time="60" value="Animated" interpolation="hold"/>
+        </Channel>
+      </Object>
+    </Animation>
+  </Animations>
+</pagx>

src/pagx/PAGScene.cpp

@@ -764,7 +764,16 @@ tgfx::DisplayList* PAGScene::getDisplayListForOptions() const {
 }
 
 bool PAGScene::hasContentChanged() const {
-  return displayList != nullptr && displayList->hasContentChanged();
+  if (displayList == nullptr) {
+    return false;
+  }
+  // A pending TextHolder reshape (ViewModel/Animation drove a text-shaping channel) has not yet
+  // touched the tgfx objects — flush runs inside Record(). Without this check the dirty gate would
+  // skip the frame and the reshape would never reach the screen.
+  if (_rootComposition != nullptr && _rootComposition->hasDirtyTextHolders()) {
+    return true;
+  }
+  return displayList->hasContentChanged();
 }
 
 std::unique_ptr<tgfx::Recording> Record(tgfx::Context* context,

src/pagx/runtime/PAGComposition.cpp

@@ -483,4 +483,18 @@ void PAGComposition::flushTextHolders(FontConfig* fontConfig) {
   }
 }
 
+bool PAGComposition::hasDirtyTextHolders() const {
+  if (binding != nullptr && binding->hasDirtyTextHolders()) {
+    return true;
+  }
+  std::vector<PAGComposition*> childComps = {};
+  CollectChildCompositions(const_cast<PAGComposition*>(this), childComps);
+  for (auto* childComp : childComps) {
+    if (childComp->hasDirtyTextHolders()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace pagx

src/renderer/LayerBuilder.cpp

@@ -131,6 +131,15 @@ void RuntimeBinding::flushTextHolders(FontConfig* fontConfig) {
   }
 }
 
+bool RuntimeBinding::hasDirtyTextHolders() const {
+  for (const auto& holder : textHolders) {
+    if (holder != nullptr && holder->isDirty()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 void RuntimeBinding::remove(const Node* node) {
   targets.erase(node);
   std::vector<std::shared_ptr<TextHolder>> stillAlive;

src/renderer/LayerBuilder.h

@@ -318,6 +318,10 @@ struct RuntimeBinding {
   // Animation channels have been applied. fontConfig is borrowed for the duration of the call.
   void flushTextHolders(FontConfig* fontConfig);
 
+  // Returns true if any TextHolder has a pending reshape (apply recorded a change since the last
+  // flush). Used by PAGScene's content-changed check so a dirty holder is not skipped before flush.
+  bool hasDirtyTextHolders() const;
+
  private:
   // Returns the existing target for the node, creating a plain RuntimeTarget if none exists yet.
   RuntimeTarget* ensureTarget(const Node* node) {

src/renderer/TextHolder.cpp

@@ -66,46 +66,56 @@ void TextHolder::apply(Text* node, const std::string& channel, const KeyValue& v
   auto& glyph = entry->glyph;
   // Continuous attributes mix from the current value (the role a tgfx object plays for other
   // channels); discrete attributes ignore mix and overwrite, matching the existing writer
-  // convention (WriteLayerBlendMode / WriteLayerName).
+  // convention (WriteLayerBlendMode / WriteLayerName). Only mark dirty when the value actually
+  // changes: Hold-interpolated animation channels re-apply the same value every advance, so a
+  // blind dirty flag would trigger a full reshape at every draw.
   if (channel == "fontSize") {
     const auto* v = std::get_if<float>(&value);
     if (v == nullptr) {
       return;
     }
-    glyph.fontSize = MixFloat(glyph.fontSize, *v, mix);
+    auto mixed = MixFloat(glyph.fontSize, *v, mix);
+    if (mixed == glyph.fontSize) {
+      return;
+    }
+    glyph.fontSize = mixed;
   } else if (channel == "letterSpacing") {
     const auto* v = std::get_if<float>(&value);
     if (v == nullptr) {
       return;
     }
-    glyph.letterSpacing = MixFloat(glyph.letterSpacing, *v, mix);
+    auto mixed = MixFloat(glyph.letterSpacing, *v, mix);
+    if (mixed == glyph.letterSpacing) {
+      return;
+    }
+    glyph.letterSpacing = mixed;
   } else if (channel == "text") {
     const auto* v = std::get_if<std::string>(&value);
-    if (v == nullptr) {
+    if (v == nullptr || *v == glyph.text) {
       return;
     }
     glyph.text = *v;
   } else if (channel == "fontFamily") {
     const auto* v = std::get_if<std::string>(&value);
-    if (v == nullptr) {
+    if (v == nullptr || *v == glyph.fontFamily) {
       return;
     }
     glyph.fontFamily = *v;
   } else if (channel == "fontStyle") {
     const auto* v = std::get_if<std::string>(&value);
-    if (v == nullptr) {
+    if (v == nullptr || *v == glyph.fontStyle) {
       return;
     }
     glyph.fontStyle = *v;
   } else if (channel == "fauxBold") {
     const auto* v = std::get_if<bool>(&value);
-    if (v == nullptr) {
+    if (v == nullptr || *v == glyph.fauxBold) {
       return;
     }
     glyph.fauxBold = *v;
   } else if (channel == "fauxItalic") {
     const auto* v = std::get_if<bool>(&value);
-    if (v == nullptr) {
+    if (v == nullptr || *v == glyph.fauxItalic) {
       return;
     }
     glyph.fauxItalic = *v;

src/renderer/TextHolder.h

@@ -77,6 +77,13 @@ class TextHolder {
   // borrowed for the duration of the call to build a LayoutContext; the holder does not retain it.
   void flush(FontConfig* fontConfig);
 
+  // Returns true if apply() has recorded a change since the last flush(). Callers (PAGScene's
+  // content-changed check) use this to avoid skipping a frame that would otherwise drop the reshape
+  // before flush runs.
+  bool isDirty() const {
+    return dirty;
+  }
+
   // Drops the entry for the given node (called when its runtime target is being removed from the
   // binding, so a later flush never dereferences a freed target). Returns true if the holder has
   // no entries left, letting the binding drop the now-empty holder.

test/src/PAGXTest.cpp

@@ -13566,5 +13566,80 @@ PAGX_TEST(PAGXTest, SMDataBindTypeMismatch) {
   EXPECT_EQ(smTimeline->getCurrentState("main"), "low");
 }
 
+// Smoke test: the demo pagx file (animation + viewmodel driving text channels) parses cleanly.
+PAGX_TEST(PAGXTest, TextReshapeDemoParses) {
+  auto doc =
+      pagx::PAGXImporter::FromFile(ProjectPath::Absolute("resources/text_reshape_demo.pagx"));
+  ASSERT_NE(doc, nullptr);
+  for (const auto& err : doc->errors) {
+    FAIL() << "parse error: " << err;
+  }
+  EXPECT_EQ(doc->layers.size(), 2u);
+  EXPECT_EQ(doc->animations.size(), 1u);
+  EXPECT_EQ(doc->dataBinds.size(), 2u);
+  ASSERT_NE(doc->viewModel, nullptr);
+  EXPECT_EQ(doc->viewModel->id, "MainVM");
+  EXPECT_NE(doc->findNode<pagx::Animation>("textAnim"), nullptr);
+  auto* vmText = doc->findNode<pagx::Text>("vmText");
+  ASSERT_NE(vmText, nullptr);
+  EXPECT_EQ(vmText->text, "VM Default");
+}
+
+// Verifies the demo pagx's animation and viewmodel both reshape text through the runtime holder:
+// after advancing the default timeline past the second keyframe, the animated Text's blob width
+// changes to the "Animated" glyph extent; after driving the ViewModel's "title" property, the
+// bound Text's blob width changes to the new content. Both go through PAGScene::draw so the
+// holder's flush (setTextBlob) reflects in the bound tgfx::Text.
+PAGX_TEST(PAGXTest, TextReshapeDemoAnimationAndViewModel) {
+  auto doc =
+      pagx::PAGXImporter::FromFile(ProjectPath::Absolute("resources/text_reshape_demo.pagx"));
+  ASSERT_NE(doc, nullptr);
+  pagx::FontConfig fontConfig;
+  for (const auto& fontPath : GetFallbackFontPaths()) {
+    fontConfig.addFallbackFont(fontPath, 0);
+  }
+  doc->applyLayout(&fontConfig);
+  auto scene = pagx::PAGScene::Make(doc);
+  ASSERT_NE(scene, nullptr);
+  auto surface = pagx::PAGSurface::MakeOffscreen(400, 200);
+  ASSERT_NE(surface, nullptr);
+
+  auto* animText = doc->findNode<pagx::Text>("animText");
+  ASSERT_NE(animText, nullptr);
+  auto* vmTextNode = doc->findNode<pagx::Text>("vmText");
+  ASSERT_NE(vmTextNode, nullptr);
+
+  // First frame: animation at time 0 ("Hello"), viewmodel default ("VM Default").
+  EXPECT_TRUE(scene->draw(surface));
+  auto binding = scene->mutableBinding();
+  ASSERT_NE(binding, nullptr);
+  auto animRuntime = binding->get<tgfx::Text>(animText);
+  ASSERT_NE(animRuntime, nullptr);
+  ASSERT_NE(animRuntime->textBlob(), nullptr);
+  float animWidthBefore = animRuntime->textBlob()->getBounds().width();
+  auto vmRuntime = binding->get<tgfx::Text>(vmTextNode);
+  ASSERT_NE(vmRuntime, nullptr);
+  ASSERT_NE(vmRuntime->textBlob(), nullptr);
+  float vmWidthBefore = vmRuntime->textBlob()->getBounds().width();
+
+  // Advance the document-level animation past frame 60 (1s at 60fps) so the Hold keyframe value
+  // "Animated" takes effect, then draw.
+  auto defaultTimeline = scene->getDefaultTimeline();
+  ASSERT_NE(defaultTimeline, nullptr);
+  defaultTimeline->advanceAndApply(1'000'000);
+  EXPECT_TRUE(scene->draw(surface));
+  ASSERT_NE(animRuntime->textBlob(), nullptr);
+  float animWidthAfter = animRuntime->textBlob()->getBounds().width();
+  // "Animated" is longer than "Hello", so the blob width must grow.
+  EXPECT_GT(animWidthAfter, animWidthBefore) << "animation did not reshape animText to 'Animated'";
+
+  // Drive the ViewModel's "title" property and draw: the bound vmText must reshape.
+  scene->viewModel()->propertyString("title")->value("ReshapedByVM");
+  EXPECT_TRUE(scene->draw(surface));
+  ASSERT_NE(vmRuntime->textBlob(), nullptr);
+  float vmWidthAfter = vmRuntime->textBlob()->getBounds().width();
+  EXPECT_NE(vmWidthAfter, vmWidthBefore) << "viewmodel did not reshape vmText to 'ReshapedByVM'";
+}
+
 // Canonical scene render test: Composition-wrapped layer with animation via scene.
 }  // namespace pag