Implement pen_stamp block

Author: adazem009

src/blocks/penblocks.cpp

@@ -1,9 +1,14 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/executioncontext.h>
+#include <scratchcpp/target.h>
+#include <scratchcpp/ispritehandler.h>
+#include <scratchcpp/istagehandler.h>
 
 #include "penblocks.h"
 #include "penlayer.h"
+#include "spritemodel.h"
+#include "stagemodel.h"
 
 using namespace scratchcpprender;
 using namespace libscratchcpp;
@@ -26,6 +31,7 @@ Rgb PenBlocks::color() const
 void PenBlocks::registerBlocks(IEngine *engine)
 {
     engine->addCompileFunction(this, "pen_clear", &compileClear);
+    engine->addCompileFunction(this, "pen_stamp", &compileStamp);
 }
 
 CompilerValue *PenBlocks::compileClear(Compiler *compiler)
@@ -34,6 +40,12 @@ CompilerValue *PenBlocks::compileClear(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *PenBlocks::compileStamp(Compiler *compiler)
+{
+    compiler->addTargetFunctionCall("pen_stamp");
+    return nullptr;
+}
+
 BLOCK_EXPORT void pen_clear(ExecutionContext *ctx)
 {
     IEngine *engine = ctx->engine();
@@ -44,3 +56,24 @@ BLOCK_EXPORT void pen_clear(ExecutionContext *ctx)
         engine->requestRedraw();
     }
 }
+
+BLOCK_EXPORT void pen_stamp(Target *target)
+{
+    IEngine *engine = target->engine();
+    IPenLayer *penLayer = PenLayer::getProjectPenLayer(engine);
+
+    if (penLayer) {
+        IRenderedTarget *renderedTarget = nullptr;
+
+        if (target->isStage()) {
+            IStageHandler *iface = static_cast<Stage *>(target)->getInterface();
+            renderedTarget = static_cast<StageModel *>(iface)->renderedTarget();
+        } else {
+            ISpriteHandler *iface = static_cast<Sprite *>(target)->getInterface();
+            renderedTarget = static_cast<SpriteModel *>(iface)->renderedTarget();
+        }
+
+        penLayer->stamp(renderedTarget);
+        engine->requestRedraw();
+    }
+}

src/blocks/penblocks.h

@@ -14,6 +14,7 @@ class PenBlocks : public libscratchcpp::IExtension
 
     private:
         static libscratchcpp::CompilerValue *compileClear(libscratchcpp::Compiler *compiler);
+        static libscratchcpp::CompilerValue *compileStamp(libscratchcpp::Compiler *compiler);
 };
 
 } // namespace scratchcpprender

test/blocks/pen_blocks_test.cpp

@@ -1,5 +1,6 @@
 #include <scratchcpp/project.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/stage.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/script.h>
 #include <scratchcpp/thread.h>
@@ -9,6 +10,9 @@
 #include <gtest/gtest.h>
 
 #include "penlayer.h"
+#include "spritemodel.h"
+#include "stagemodel.h"
+#include "renderedtarget.h"
 #include "blocks/penblocks.h"
 
 using namespace scratchcpprender;
@@ -70,3 +74,45 @@ TEST_F(PenBlocksTest, Clear)
     EXPECT_CALL(m_engineMock, requestRedraw());
     thread->run();
 }
+
+TEST_F(PenBlocksTest, Stamp_Sprite)
+{
+    auto sprite = std::make_shared<Sprite>();
+    sprite->setEngine(&m_engineMock);
+
+    RenderedTarget renderedTarget;
+    SpriteModel model;
+    model.init(sprite.get());
+    model.setRenderedTarget(&renderedTarget);
+    sprite->setInterface(&model);
+
+    ScriptBuilder builder(m_extension.get(), m_engine, sprite);
+    builder.addBlock("pen_stamp");
+
+    auto thread = buildScript(builder, sprite.get());
+
+    EXPECT_CALL(m_penLayer, stamp(&renderedTarget));
+    EXPECT_CALL(m_engineMock, requestRedraw());
+    thread->run();
+}
+
+TEST_F(PenBlocksTest, Stamp_Stage)
+{
+    auto stage = std::make_shared<Stage>();
+    stage->setEngine(&m_engineMock);
+
+    RenderedTarget renderedTarget;
+    StageModel model;
+    model.init(stage.get());
+    model.setRenderedTarget(&renderedTarget);
+    stage->setInterface(&model);
+
+    ScriptBuilder builder(m_extension.get(), m_engine, stage);
+    builder.addBlock("pen_stamp");
+
+    auto thread = buildScript(builder, stage.get());
+
+    EXPECT_CALL(m_penLayer, stamp(&renderedTarget));
+    EXPECT_CALL(m_engineMock, requestRedraw());
+    thread->run();
+}