Made Arena class

Author: Chi-EEE

src/arena/Arena.cpp

@@ -0,0 +1,43 @@
+#include "Arena.h"
+
+namespace arena {
+	Arena::Arena(ArenaType arena_type, Canvas canvas) : arena_type(arena_type), canvas(canvas)
+	{
+	}
+
+	tl::expected<Arena, std::string> Arena::create(ArenaType arena_type)
+	{
+		std::string arenaFile;
+		switch (arena_type)
+		{
+		case Training:
+			arenaFile = "./assets/arena/Bone.png";
+			break;
+		default:
+			break;
+		}
+		auto imageResult = Image::fromFile(arenaFile);
+		if (!imageResult.has_value()) {
+			return tl::make_unexpected(imageResult.error());
+		}
+		auto image = imageResult.value();
+		Canvas canvas = Canvas(image.get_width(), image.get_height());
+		canvas.draw_image(image, SkRect::MakeXYWH(0, 0, image.get_width(), image.get_height()));
+		canvas.save("./tests.png");
+		return Arena(arena_type, canvas);
+	}
+
+	Arena::~Arena()
+	{
+
+	}
+
+	Arena Arena::clone()
+	{
+		return Arena(this->arena_type, this->canvas.clone());
+	}
+	tl::expected<nullptr_t, std::string> Arena::save(std::string fileName)
+	{
+		return this->canvas.save(fileName);
+	}
+}

src/arena/Arena.h

@@ -0,0 +1,25 @@
+#include "ArenaType.h"
+#include "../canvas/Canvas.h"
+#ifndef ARENA_H
+#define ARENA_H
+
+#pragma once
+
+using namespace canvas;
+
+namespace arena {
+    class Arena
+    {
+    public:
+        static tl::expected<Arena, std::string> create(ArenaType arena_type);
+        ~Arena();
+        Arena clone();
+        tl::expected<nullptr_t, std::string> save(std::string fileName);
+    private:
+        Arena(ArenaType arena_type, Canvas canvas);
+        ArenaType arena_type;
+        Canvas canvas;
+    };
+}
+
+#endif

src/arena/ArenaType.h

@@ -0,0 +1,13 @@
+#ifndef ARENATYPE_H
+#define ARENATYPE_H
+
+#pragma once
+
+#include <string>
+
+enum ArenaType
+{
+	Training,
+};
+
+#endif

src/Canvas.cpp src/canvas/Canvas.cpp

@@ -3,20 +3,47 @@
 namespace canvas {
 	Canvas::Canvas(int width, int height)
 	{
-		surface = SkSurface::MakeRasterN32Premul(width, height);
+		this->surface = SkSurface::MakeRasterN32Premul(width, height);
 		//canvas = std::make_unique<SkCanvas>(surface->getCanvas());
 	}
 
-	Canvas::~Canvas()
+	Canvas Canvas::clone()
 	{
+		int width = this->get_width();
+		int height = this->get_height();
+		Canvas canvas = Canvas(width, width);
+		canvas.draw_image(this->snapshot(), SkRect::MakeLTRB(0, 0, width, height));
+		return canvas;
+	}
 
+	Canvas::~Canvas()
+	{
 	}
 
-	void Canvas::drawImage(Image image, SkRect dstRect)
+	void Canvas::draw_image(Image image, SkRect dstRect)
 	{
 		surface->getCanvas()->drawImageRect(image.getImage(), dstRect, SkSamplingOptions());
 	}
 
+	Canvas Canvas::crop(const SkRect& cropRect)
+	{
+		Canvas croppedCanvas = Canvas(cropRect.fRight - cropRect.fLeft, cropRect.fTop - cropRect.fBottom);
+		croppedCanvas.draw_image(this->surface->makeImageSnapshot(), cropRect);
+		return croppedCanvas;
+	}
+
+	Canvas Canvas::stretch(const SkPoint& stretchVector)
+	{
+		Canvas stretchedCanvas = Canvas(stretchVector.fX, stretchVector.fY);
+		stretchedCanvas.draw_image(this->surface->makeImageSnapshot(), SkRect::MakeXYWH(0, 0, stretchVector.fX, stretchVector.fY));
+		return stretchedCanvas;
+	}
+
+	sk_sp<SkImage> Canvas::snapshot()
+	{
+		return this->surface->makeImageSnapshot();
+	}
+
 	void Canvas::clear()
 	{
 		surface->getCanvas()->clear(SK_ColorTRANSPARENT);

src/Canvas.h src/canvas/Canvas.h

@@ -23,10 +23,20 @@ namespace canvas {
 	{
 	public:
 		Canvas(int width, int height);
+		Canvas clone();
 		~Canvas();
-		void drawImage(Image image, SkRect dstRect);
-		void clear();
+		int get_width() {
+			return this->surface->width();
+		}
+		int get_height() {
+			return this->surface->height();
+		}
+		void draw_image(Image image, SkRect dstRect);
+		Canvas crop(const SkRect& cropRect);
+		Canvas stretch(const SkPoint& stretchVector);
+		sk_sp<SkImage> snapshot();
 		tl::expected<nullptr_t, std::string> save(std::string fileName);
+		void clear();
 
 	private:
 		sk_sp<SkSurface> surface;

src/Image.cpp src/canvas/Image.cpp

@@ -1,7 +1,7 @@
 #include "Image.h"
 
 namespace canvas {
-	tl::expected<Image, std::string> Image::create(std::string fileName)
+	tl::expected<Image, std::string> Image::fromFile(std::string fileName)
 	{
 		sk_sp<SkData> imageData = SkData::MakeFromFileName(fileName.c_str());
 		if (!imageData) {
@@ -12,10 +12,10 @@ namespace canvas {
 		if (!image) {
 			return tl::make_unexpected("Failed to create SkImage from encoded data!");
 		}
-		return Image(imageData, image);
+		return Image(image);
 	}
 
-	Image::Image(sk_sp<SkData> imageData, sk_sp<SkImage> image) : imageData(imageData), image(image)
+	Image::Image(sk_sp<SkImage> image) : image(image)
 	{
 	}
 

src/Image.h src/canvas/Image.h

@@ -12,15 +12,19 @@ namespace canvas {
 	class Image
 	{
 	public:
-		static tl::expected<Image, std::string> create(std::string fileName);
+		static tl::expected<Image, std::string> fromFile(std::string file);
+		Image(sk_sp<SkImage> image);
 		~Image();
 		sk_sp<SkImage> getImage() {
 			return image;
 		}
-
+		int get_width() {
+			return this->image->width();
+		}
+		int get_height() {
+			return this->image->height();
+		}
 	private:
-		Image(sk_sp<SkData> imageData, sk_sp<SkImage> image);
-		sk_sp<SkData> imageData;
 		sk_sp<SkImage> image;
 	};
 }

src/main.cpp

@@ -1,25 +1,18 @@
 #include <iostream>
-#include "Canvas.h"
-
-#include "core/SkBitmap.h"
-#include "core/SkCanvas.h"
-#include "core/SkData.h"
-#include "core/SkImage.h"
-#include "core/SkRect.h"
-#include "core/SkStream.h"
-#include "core/SkSurface.h"
-#include "core/SkTypes.h"
+#include "canvas/Canvas.h"
+#include "arena/Arena.h"
 
 using namespace canvas;
+using namespace arena;
 
 int main() {
-    Canvas* canvas = new Canvas(200, 200);
-    SkRect dstRect = SkRect::MakeXYWH(50, 50, 200, 200); // Left, top, width, height
-    auto imageResult = Image::create("./assets/arena/Bone.png");
-    if (imageResult.has_value()) {
-        auto image = imageResult.value();
-        canvas->drawImage(image, dstRect);
-        canvas->save("./tests.png");
+    auto arenaResult = Arena::create(ArenaType::Training);
+    if (arenaResult.has_value()) {
+        Arena arena = arenaResult.value();
+        arena.save("./testArena.png");
+    }
+    else {
+        std::cerr << "An error has occurred: " << arenaResult.error() << '\n';
     }
     return 0;
 }

xmake.lua

@@ -6,6 +6,8 @@ target("CR-Battle-Dataset-Generator")
     set_kind("binary")
     add_files("src/*.cpp")
     add_headerfiles("src/*.h")
+    add_files("src/*/*.cpp")
+    add_headerfiles("src/*/*.h")
     add_packages("skia")
     add_packages("tl_expected")
 --