Implement pen_stamp block

Author: adazem009

src/blocks/penblocks.cpp

@@ -2,12 +2,14 @@
 
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/stage.h>
 #include <scratchcpp/input.h>
 
 #include "penblocks.h"
 #include "penlayer.h"
 #include "penstate.h"
 #include "spritemodel.h"
+#include "stagemodel.h"
 
 using namespace scratchcpprender;
 using namespace libscratchcpp;
@@ -31,6 +33,7 @@ void PenBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
     engine->addCompileFunction(this, "pen_clear", &compileClear);
+    engine->addCompileFunction(this, "pen_stamp", &compileStamp);
     engine->addCompileFunction(this, "pen_penDown", &compilePenDown);
     engine->addCompileFunction(this, "pen_penUp", &compilePenUp);
     engine->addCompileFunction(this, "pen_setPenColorToColor", &compileSetPenColorToColor);
@@ -57,6 +60,11 @@ void PenBlocks::compileClear(Compiler *compiler)
     compiler->addFunctionCall(&clear);
 }
 
+void PenBlocks::compileStamp(Compiler *compiler)
+{
+    compiler->addFunctionCall(&stamp);
+}
+
 void PenBlocks::compilePenDown(Compiler *compiler)
 {
     compiler->addFunctionCall(&penDown);
@@ -179,6 +187,29 @@ unsigned int PenBlocks::clear(VirtualMachine *vm)
     return 0;
 }
 
+unsigned int PenBlocks::stamp(libscratchcpp::VirtualMachine *vm)
+{
+    IPenLayer *penLayer = PenLayer::getProjectPenLayer(vm->engine());
+
+    if (penLayer) {
+        Target *target = vm->target();
+        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);
+        vm->engine()->requestRedraw();
+    }
+
+    return 0;
+}
+
 unsigned int PenBlocks::penDown(VirtualMachine *vm)
 {
     SpriteModel *model = getSpriteModel(vm);

src/blocks/penblocks.h

@@ -29,6 +29,7 @@ class PenBlocks : public libscratchcpp::IBlockSection
         void registerBlocks(libscratchcpp::IEngine *engine) override;
 
         static void compileClear(libscratchcpp::Compiler *compiler);
+        static void compileStamp(libscratchcpp::Compiler *compiler);
         static void compilePenDown(libscratchcpp::Compiler *compiler);
         static void compilePenUp(libscratchcpp::Compiler *compiler);
         static void compileSetPenColorToColor(libscratchcpp::Compiler *compiler);
@@ -42,6 +43,7 @@ class PenBlocks : public libscratchcpp::IBlockSection
         static void compileSetPenHueToNumber(libscratchcpp::Compiler *compiler);
 
         static unsigned int clear(libscratchcpp::VirtualMachine *vm);
+        static unsigned int stamp(libscratchcpp::VirtualMachine *vm);
         static unsigned int penDown(libscratchcpp::VirtualMachine *vm);
         static unsigned int penUp(libscratchcpp::VirtualMachine *vm);
         static unsigned int setPenColorToColor(libscratchcpp::VirtualMachine *vm);

test/blocks/pen_blocks_test.cpp

@@ -4,9 +4,11 @@
 #include <scratchcpp/field.h>
 #include <penlayer.h>
 #include <spritemodel.h>
+#include <stagemodel.h>
 #include <blocks/penblocks.h>
 #include <enginemock.h>
 #include <penlayermock.h>
+#include <renderedtargetmock.h>
 
 #include "../common.h"
 
@@ -92,6 +94,7 @@ TEST_F(PenBlocksTest, RegisterBlocks)
 {
     // Blocks
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_clear", &PenBlocks::compileClear));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_stamp", &PenBlocks::compileStamp));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_penDown", &PenBlocks::compilePenDown));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_penUp", &PenBlocks::compilePenUp));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "pen_setPenColorToColor", &PenBlocks::compileSetPenColorToColor));
@@ -133,6 +136,66 @@ TEST_F(PenBlocksTest, Clear)
     ASSERT_TRUE(compiler.lists().empty());
 }
 
+TEST_F(PenBlocksTest, Stamp)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "pen_stamp");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&PenBlocks::stamp)).WillOnce(Return(2));
+    compiler.init();
+    compiler.setBlock(block);
+    PenBlocks::compileStamp(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 2, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
+TEST_F(PenBlocksTest, StampImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &PenBlocks::stamp };
+
+    PenLayerMock penLayer;
+    PenLayer::addPenLayer(&m_engineMock, &penLayer);
+    RenderedTargetMock renderedTarget;
+
+    // Test sprite
+    libscratchcpp::Sprite sprite;
+    SpriteModel spriteModel;
+    sprite.setInterface(&spriteModel);
+    spriteModel.setRenderedTarget(&renderedTarget);
+
+    VirtualMachine vm1(&sprite, &m_engineMock, nullptr);
+    vm1.setBytecode(bytecode);
+    vm1.setFunctions(functions);
+
+    EXPECT_CALL(penLayer, stamp(&renderedTarget));
+    EXPECT_CALL(m_engineMock, requestRedraw());
+    vm1.run();
+
+    ASSERT_EQ(vm1.registerCount(), 0);
+
+    // Test stage
+    libscratchcpp::Stage stage;
+    StageModel stageModel;
+    stage.setInterface(&stageModel);
+    stageModel.setRenderedTarget(&renderedTarget);
+
+    VirtualMachine vm2(&stage, &m_engineMock, nullptr);
+    vm2.setBytecode(bytecode);
+    vm2.setFunctions(functions);
+
+    EXPECT_CALL(penLayer, stamp(&renderedTarget));
+    EXPECT_CALL(m_engineMock, requestRedraw());
+    vm2.run();
+
+    ASSERT_EQ(vm2.registerCount(), 0);
+}
+
 TEST_F(PenBlocksTest, ClearImpl)
 {
     static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };