working at sushi

Pika/CMakeLists.txt

@@ -37,6 +37,7 @@ add_subdirectory(thirdparty/imgui-docking)
 add_subdirectory(thirdparty/safeSafe)
 add_subdirectory(thirdparty/profilerLib)
 add_subdirectory(thirdparty/box2d-2.4.1)
+add_subdirectory(thirdparty/sushi)
 
 #Define some macros for the project sources
 file(GLOB_RECURSE PIKA_SOURCES_CORE_CONFIG			CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/core/coreConfig/*.cpp")
@@ -78,7 +79,8 @@ target_include_directories(pikaCore PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pik
 target_include_directories(pikaCore PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pikaRuntime/")
 target_include_directories(pikaCore PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pikaSTD/")
 target_include_directories(pikaCore PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/sharedRuntime/")
-target_link_libraries(pikaCore PRIVATE glad glfw gl2d  gl3d glui glm stb_image stb_truetype imgui safeSave profilerLib)
+target_link_libraries(pikaCore PRIVATE glad glfw gl2d  gl3d glui
+	glm stb_image stb_truetype imgui safeSave profilerLib sushi)
 #################^^^^^^^^#############################
 
 
@@ -94,30 +96,32 @@ target_include_directories(pikaGameplay PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core
 target_include_directories(pikaGameplay PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/gameplay/")
 target_include_directories(pikaGameplay PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/sharedRuntime/")
 target_include_directories(pikaGameplay PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/pluggins/")
-target_link_libraries(pikaGameplay PRIVATE glad glfw gl2d gl3d glui glm stb_image stb_truetype imgui safeSave profilerLib box2d)
+target_link_libraries(pikaGameplay PRIVATE glad glfw gl2d gl3d glui glm stb_image 
+	stb_truetype imgui safeSave profilerLib box2d sushi)
 #################^^^^^^^^^^^^^^############################
 
 
 
 
 #pikaProduction ###########################################
-#add_executable(pikaProduction)
-#
-#target_compile_definitions(pikaProduction PUBLIC PIKA_PRODUCTION)
-#set_property(TARGET pikaProduction PROPERTY CXX_STANDARD 17)
-#
-#target_sources(pikaProduction PRIVATE 
-#	"${PIKA_SOURCES_CORE_CONFIG}" "${PIKA_SOURCES_CORE_EDITOR}" "${PIKA_SOURCES_PLUGGINS}"
-#	"${PIKA_SOURCES_CORE_RUNTIME}" "${PIKA_SOURCES_CORE_STD}" "${PIKA_SOURCES_GAMEPLAY}" "${PIKA_SOURCES_CORE_SHARED_RUNTIME}")
-#target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/coreConfig/")
-#target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pikaEditor/")
-#target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pikaRuntime/")
-#target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pikaSTD/")
-#target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/gameplay/")
-#target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/sharedRuntime/")
-#target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/pluggins/")
-#
-#target_link_libraries(pikaProduction PRIVATE glad glfw gl2d gl3d glui glm stb_image stb_truetype imgui safeSave profilerLib box2d)
+add_executable(pikaProduction)
+
+target_compile_definitions(pikaProduction PUBLIC PIKA_PRODUCTION)
+set_property(TARGET pikaProduction PROPERTY CXX_STANDARD 17)
+
+target_sources(pikaProduction PRIVATE 
+	"${PIKA_SOURCES_CORE_CONFIG}" "${PIKA_SOURCES_CORE_EDITOR}" "${PIKA_SOURCES_PLUGGINS}"
+	"${PIKA_SOURCES_CORE_RUNTIME}" "${PIKA_SOURCES_CORE_STD}" "${PIKA_SOURCES_GAMEPLAY}" "${PIKA_SOURCES_CORE_SHARED_RUNTIME}")
+target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/coreConfig/")
+target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pikaEditor/")
+target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pikaRuntime/")
+target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/pikaSTD/")
+target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/gameplay/")
+target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/core/sharedRuntime/")
+target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/pluggins/")
+
+target_link_libraries(pikaProduction PRIVATE glad glfw gl2d gl3d glui glm stb_image 
+	stb_truetype imgui safeSave profilerLib box2d sushi)
 
 
 

Pika/core/pikaRuntime/containerManager/containerManager.cpp

@@ -616,7 +616,8 @@ void pika::ContainerManager::update(pika::LoadedDll &loadedDll, pika::PikaWindow
 
 	for (auto &i : containersToCreate)
 	{
-		createContainer(i.containerName.to_string(), loadedDll, logs, imguiIdManager, consoleWindow, i.cmdArgs.to_string());
+		auto s = i.cmdArgs.to_string();
+		createContainer(i.containerName.to_string(), loadedDll, logs, imguiIdManager, consoleWindow, s);
 	}
 
 #pragma endregion

Pika/core/pikaSTD/engineLibraresSupport/sushi/engineSushiSupport.cpp

@@ -0,0 +1,68 @@
+#include "engineSushiSupport.h"
+
+namespace pika
+{
+
+	::sushi::SushiInput toSushi(const pika::Input &in)
+	{
+		::sushi::SushiInput out = {};
+
+		out.lMouse = toSushi(in.lMouse);
+		out.rMouse = toSushi(in.rMouse);
+
+		out.mouseX = in.mouseX;
+		out.mouseY = in.mouseY;
+
+		static_assert(::sushi::SushiButton::BUTTONS_COUNT == ::pika::Button::BUTTONS_COUNT, "");
+		for (int i = 0; i < ::sushi::SushiButton::BUTTONS_COUNT; i++)
+		{
+			out.buttons[i] = toSushi(in.buttons[i]);
+		}
+
+		static_assert(sizeof(::sushi::SushiInput::typedInput) == sizeof(::pika::Input::typedInput), "");
+		memcpy(out.typedInput, in.typedInput, sizeof(::sushi::SushiInput::typedInput));
+
+		out.deltaTime = in.deltaTime;
+
+		static_assert(::sushi::SushiInput::MAX_CONTROLLERS_COUNT == ::pika::Input::MAX_CONTROLLERS_COUNT, "");
+
+		for (int i = 0; i < ::sushi::SushiInput::MAX_CONTROLLERS_COUNT; i++)
+		{
+			out.controllers[i] = toSushi(in.controllers[i]);
+		}
+		
+		out.anyController = toSushi(in.anyController);
+
+		return out;
+	}
+	
+	::sushi::SushiController toSushi(const pika::Controller &in)
+	{
+		::sushi::SushiController out = {};
+
+		out.LT = in.LT;
+		out.RT = in.RT;
+		out.connected = in.connected;
+		out.LStick.x = in.LStick.x;
+		out.LStick.y = in.LStick.y;
+		out.RStick.x = in.RStick.x;
+		out.RStick.y = in.RStick.y;
+
+		static_assert(::sushi::SushiController::ButtonsCount == ::pika::Controller::ButtonsCount, "");
+
+		for (int i = 0; i < ::sushi::SushiController::ButtonsCount; i++)
+		{
+			out.buttons[i] = toSushi(in.buttons[i]);
+		}
+
+		return out;
+	}
+	
+	::sushi::SushiButton toSushi(const pika::Button &in)
+	{
+		::sushi::SushiButton out = {};
+		out.flags = in.flags;
+		return out;
+	}
+
+};

Pika/core/pikaSTD/engineLibraresSupport/sushi/engineSushiSupport.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <windowSystemm/window.h>
+#include <sushi/sushiInput.h>
+
+namespace pika
+{
+	::sushi::SushiInput toSushi(const pika::Input &in);
+	::sushi::SushiController toSushi(const pika::Controller &in);
+	::sushi::SushiButton toSushi(const pika::Button &in);
+
+};
+

Pika/gameplay/containers.h

@@ -15,40 +15,45 @@ Container *getContainer(const char* name, pika::memory::MemoryArena *memoryArena
 
 #include "containers/pikaGameplay.h"
 #include "containers/threedtest.h"
+
+#include "pluggins/immageviewer.h"
+#include "pluggins/threeDEditor.h"
+#include "pluggins/pikatextEditor.h"
+#include "pluggins/sushiViewer/sushiViewer.h"
+
 //#include "containers/mario/mario.h"
 //#include "containers/mario/marioEditor.h"
 //#include "containers/mario/marioNeuralVizualizer.h"
 //#include "containers/mario/marioNeuralTrainer.h"
-#include "pluggins/immageviewer.h"
-#include "pluggins/threeDEditor.h"
-#include "pluggins/pikatextEditor.h"
 //#include "containers/minecraftDungeons/mcDungeonsEditor.h"
 //#include "containers/minecraftDungeons/mcDungeonsgameplay.h"
 //#include "containers/minecraftDungeons/mcDungeonsMenu.h"
-#include "containers/hollowknight/hollowknight.h"
+//#include "containers/hollowknight/hollowknight.h"
 
 #if PIKA_PRODUCTION == 1
 
 #define PIKA_ALL_CONTAINERS() \
-	PIKA_DECLARE_CONTAINER(Gameplay) 
 	//PIKA_DECLARE_CONTAINER(McDungeonsGameplay) \
 	//PIKA_DECLARE_CONTAINER(McDungeonsMenu) 
+	//PIKA_DECLARE_CONTAINER(Gameplay) 
+
 
 #else
 
 #define PIKA_ALL_CONTAINERS() \
 	PIKA_DECLARE_CONTAINER(Gameplay) \
+	PIKA_DECLARE_CONTAINER(SushiViewer) \
 	PIKA_DECLARE_CONTAINER(ImmageViewer) \
 	PIKA_DECLARE_CONTAINER(ThreeDTest) \
 	PIKA_DECLARE_CONTAINER(ThreeDEditor) \
-	PIKA_DECLARE_CONTAINER(PikaTextEditor) \
-	PIKA_DECLARE_CONTAINER(Holloknight)
+	PIKA_DECLARE_CONTAINER(PikaTextEditor) 
+	//PIKA_DECLARE_CONTAINER(Holloknight)\
 	//PIKA_DECLARE_CONTAINER(Mario) \
 	//PIKA_DECLARE_CONTAINER(MarioEditor) \
 	//PIKA_DECLARE_CONTAINER(MarioNeuralTrainer) \
 	//PIKA_DECLARE_CONTAINER(MarioNeuralVizualizer) \
 	//PIKA_DECLARE_CONTAINER(McDungeonsEditor) \
 	//PIKA_DECLARE_CONTAINER(McDungeonsGameplay) \
-	//PIKA_DECLARE_CONTAINER(McDungeonsMenu) \
+	//PIKA_DECLARE_CONTAINER(McDungeonsMenu) 
 
 #endif

Pika/gameplay/containers/hollowknight/hollowknight.h

@@ -56,6 +56,7 @@ struct Holloknight: public Container
 		info.requestImguiFbo = true; 
 		info.pushAnImguiIdForMe = true;
 
+
 		return info;
 	}
 

Pika/gameplay/containers/mario/mario.h

@@ -126,7 +126,6 @@ struct Mario: public Container
 				player.position.position = {1,1};
 				player.lastPos = {1,1};
 			}
-
 		
 		}
 		

Pika/gameplay/containers/mario/marioCommon.h

@@ -196,10 +196,9 @@ struct GameplayRenderer
 		}
 		else { return 0; }
 
-		//todo push pop or sthing
-		pika::memory::setGlobalAllocatorToStandard();
+		pika::memory::pushCustomAllocatorsToStandard();
 		marioTexture.loadFromFile(PIKA_RESOURCES_PATH "/mario/mario.png", true, false);
-		pika::memory::setGlobalAllocator(requestedInfo.mainAllocator);
+		pika::memory::popCustomAllocatorsToStandard();
 
 
 		atlas = gl2d::TextureAtlasPadding(8, 10, 8 * 8, 8 * 10);

Pika/gameplay/containers/minecraftDungeons/mcDungeonsMenu.h

@@ -24,7 +24,7 @@ struct McDungeonsMenu : public Container
 		info.defaultHeapMemorySize = pika::MB(100);
 
 		info.requestImguiFbo = true; 
-		info.openOnApplicationStartup = true;
+		//info.openOnApplicationStartup = true;
 		
 		
 

Pika/gameplay/containers/minecraftDungeons/mcDungeonsgameplay.h

@@ -14,6 +14,7 @@
 #include <engineLibraresSupport/engineGL2DSupport.h>
 #include <glui/glui.h>
 #include <profilerLib.h>
+static int diamondsCollected = 0;
 
 struct McDungeonsGameplay: public Container
 {
@@ -28,7 +29,7 @@ struct McDungeonsGameplay: public Container
 		info.requestImguiFbo = true;
 		info.requestImguiIds = 1;
 
-		//info.openOnApplicationStartup = true;
+		info.openOnApplicationStartup = true;
 
 		return info;
 	}
@@ -75,7 +76,6 @@ struct McDungeonsGameplay: public Container
 
 	std::vector<gl3d::Entity> diamonds;
 
-
 	gl3d::Entity player;
 
 	enum Animations
@@ -425,6 +425,10 @@ struct McDungeonsGameplay: public Container
 
 	bool create(RequestedContainerInfo &requestedInfo, pika::StaticString<256> commandLineArgument)
 	{
+		char format[100] = {};
+		sprintf(format, "%p\n", &diamondsCollected);
+		requestedInfo.consoleWrite(format);
+
 		playerPhysics.position = {14,26};
 		playerPhysics.lastPos = {14,26};
 
@@ -1004,6 +1008,7 @@ struct McDungeonsGameplay: public Container
 				renderer.deleteEntity(diamonds[i]);
 				diamonds.erase(diamonds.begin() + i);
 				i--;
+				diamondsCollected++;
 				continue;
 			}
 			
@@ -1040,7 +1045,8 @@ struct McDungeonsGameplay: public Container
 					{1,1,1,0.5});
 
 				std::string s;
-				s += std::to_string(5 - diamonds.size());
+				//s += std::to_string(5 - diamonds.size());
+				s += std::to_string(diamondsCollected);
 				s += "/5";
 
 				renderer2d.renderText({glui::Box().xLeftPerc(0.5f).yTopPerc(0.9f)()}, s.c_str(), font,

Pika/gameplay/containers/pikaGameplay.h

@@ -28,6 +28,8 @@ struct Gameplay : public Container
 
 		info.requestImguiFbo = true; //todo this should not affect the compatibility of input recording
 
+		//info.openOnApplicationStartup = true;
+
 		//info.bonusAllocators.push_back(100);
 		//info.bonusAllocators.push_back(200);
 		//info.bonusAllocators.push_back(300);

Pika/pluggins/pluggins/sushiViewer/sushiViewer.cpp

@@ -0,0 +1,51 @@
+#include <pluggins/sushiViewer/sushiViewer.h>
+#include <engineLibraresSupport/sushi/engineSushiSupport.h>
+
+
+//todo user can request imgui ids; shortcut manager context; allocators
+
+ContainerStaticInfo SushiViewer::containerInfo()
+{
+	ContainerStaticInfo info = {};
+	info.defaultHeapMemorySize = pika::MB(10);
+
+	info.requestImguiFbo = true; //todo this should not affect the compatibility of input recording
+
+
+
+	return info;
+}
+
+bool SushiViewer::create(RequestedContainerInfo &requestedInfo, pika::StaticString<256> commandLineArgument)
+{
+	renderer.create(requestedInfo.requestedFBO.fbo);
+
+	sushi::SushiUiElement element;
+	element.color = Colors_Magenta;
+	element.transform.absoluteTransformPixelSize({100,100,200,100});
+
+	sushiContext.allUiElements.push_back(element);
+
+	return true;
+}
+
+bool SushiViewer::update(pika::Input input, pika::WindowState windowState, RequestedContainerInfo &requestedInfo)
+{
+	glClear(GL_COLOR_BUFFER_BIT);
+	renderer.updateWindowMetrics(windowState.windowW, windowState.windowH);
+
+
+	sushiContext.update(renderer, pika::toSushi(input));
+
+
+	renderer.flush();
+
+	return true;
+}
+
+//optional
+
+void SushiViewer::destruct(RequestedContainerInfo &requestedInfo)
+{
+
+}

Pika/pluggins/pluggins/sushiViewer/sushiViewer.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <gl2d/gl2d.h>
+#include <imgui.h>
+#include <baseContainer.h>
+#include <shortcutApi/shortcutApi.h>
+#include <pikaSizes.h>
+#include <imgui_spinner.h>
+#include <sushi/sushi.h>
+
+
+struct SushiViewer: public Container
+{
+
+	gl2d::Renderer2D renderer;
+	sushi::SushyContext sushiContext;
+
+	static ContainerStaticInfo containerInfo();
+
+	bool create(RequestedContainerInfo &requestedInfo, pika::StaticString<256> commandLineArgument);
+
+	bool update(pika::Input input, pika::WindowState windowState,
+		RequestedContainerInfo &requestedInfo);
+
+	void destruct(RequestedContainerInfo &requestedInfo);
+
+};
+

Pika/resources/logs.txt

@@ -1,2 +1,2 @@
-#2023-07-21 11:48:34: Created container: Gameplay
-#2023-07-21 11:48:39: Destroyed continer: Gameplay #1
+#2023-09-06 13:46:12: Created container: SushiViewer
+#2023-09-06 13:46:25: Destroyed continer: SushiViewer #1

Pika/thirdparty/sushi/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.1)
+project(sushi)
+
+add_library(sushi)
+
+file(GLOB_RECURSE SUSHI_SRCS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
+
+target_sources(sushi PRIVATE "${SUSHI_SRCS}")
+target_include_directories(sushi PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
+target_link_libraries(sushi PUBLIC glm glad stb_image stb_truetype gl2d)

Pika/thirdparty/sushi/include/sushi/sushi.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <gl2d/gl2d.h>
+#include <sushi/sushiPrimitives.h>
+#include <sushi/sushiInput.h>
+
+namespace sushi
+{
+
+	struct SushiUiElement;
+
+	//this is a sushi context. Holds all the windows and manages stuff
+	struct SushyContext
+	{
+
+		std::vector<SushiUiElement> allUiElements;
+
+		//draw regions are like this: x, y, w, h
+		void update(gl2d::Renderer2D &renderer, 
+			sushi::SushiInput &input);
+
+		glm::vec4 background = {0,0,0,1};
+
+	};
+
+	
+
+	//this can also be a window or a button or whatever you want
+	struct SushiUiElement
+	{
+
+		Transform transform;
+		glm::vec4 color = {1,1,1,1};
+
+
+
+	};
+
+
+
+};

Pika/thirdparty/sushi/include/sushi/sushiInput.h

@@ -0,0 +1,127 @@
+#pragma once
+#include <cstdint>
+
+#define SUSHY_BUTTON_ADD_FLAG(NAME, SETNAME, VALUE)	\
+	bool NAME() const {return (flags & ((std::uint32_t)1<<VALUE)); } \
+	void SETNAME(bool s) { \
+		if (s) { flags = flags | ((std::uint32_t)1 << VALUE); }	\
+			else { flags = flags & ~((std::uint32_t)1 << VALUE); }	\
+		}
+
+
+namespace sushi
+{
+
+
+	struct SushiButton
+	{
+		//internal use only, might change how it works later
+		std::uint32_t flags = 0;
+
+		//true in the first frame the key is pressed
+		SUSHY_BUTTON_ADD_FLAG(pressed, setPressed, 0);
+
+		//true while the key is held
+		SUSHY_BUTTON_ADD_FLAG(held, setHeld, 1);
+
+		//true in the frame the key is released
+		SUSHY_BUTTON_ADD_FLAG(released, setReleased, 2);
+
+		//true in the first frame is pressed then after a pause true every few milliseconds
+		SUSHY_BUTTON_ADD_FLAG(typed, setTyped, 3);
+
+		//todo implement
+		//true if the key is double pressed (true only for one frame, 3 presses would yield only one frame of this being true)
+		SUSHY_BUTTON_ADD_FLAG(doublePressed, setDoublePressed, 4);
+
+		//last state of the button (last frame)
+		SUSHY_BUTTON_ADD_FLAG(lastState, setLastState, 5);
+
+		enum
+		{
+			A = 0,
+			B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
+			NR0, NR1, NR2, NR3, NR4, NR5, NR6, NR7, NR8, NR9,
+			Space, Enter, Escape,
+			Up, Down, Left, Right,
+			LeftCtrl, Tab, LeftAlt,
+			BUTTONS_COUNT, //
+		};
+
+	};
+
+	struct SushiController
+	{
+		enum Buttons
+		{
+			A = 0,
+			B,
+			X,
+			Y,
+			LBumper,
+			RBumper,
+			Back,
+			Start,
+			Guide,
+			LThumb,
+			Rthumb,
+			Up,
+			Right,
+			Down,
+			Left,
+			ButtonsCount
+		};
+
+		SushiButton buttons[Buttons::ButtonsCount] = {};
+
+		float LT = 0.f;
+		float RT = 0.f;
+
+		struct
+		{
+			constexpr static float JOYSTICK_SENSITIVITY = 0.7f;
+
+			float x = 0.f, y = 0.f;
+
+			bool left() { return x < -JOYSTICK_SENSITIVITY; }
+			bool right() { return x > JOYSTICK_SENSITIVITY; }
+			bool up() { return y > JOYSTICK_SENSITIVITY; }
+			bool down() { return y < -JOYSTICK_SENSITIVITY; }
+
+		}LStick, RStick;
+
+		bool connected = 0;
+
+		void resetAllButtons()
+		{
+			*this = {};
+		}
+	};
+
+	struct SushiInput
+	{
+		//typed input doesn't work with mouse buttons
+		SushiButton lMouse = {};
+		SushiButton rMouse = {};
+
+		//mouse position relative to window
+		int mouseX = 0;
+		int mouseY = 0;
+
+		SushiButton buttons[SushiButton::BUTTONS_COUNT] = {};
+
+		char typedInput[20] = {};
+
+		float deltaTime = 0;
+
+		constexpr static int MAX_CONTROLLERS_COUNT = 4; //don't change
+		SushiController controllers[MAX_CONTROLLERS_COUNT] = {};
+
+		//a logic or between all the controllers
+		SushiController anyController = {};
+	};
+
+
+};
+
+#undef SUSHY_BUTTON_ADD_FLAG

Pika/thirdparty/sushi/include/sushi/sushiPrimitives.h

@@ -0,0 +1,43 @@
+#pragma once
+#include <glm/glm.hpp>
+
+namespace sushi
+{
+
+	struct Transform
+	{
+		enum
+		{
+			NoTransformErr = 0,
+			RelativeTransform,
+			AbsoluteTransform,
+		};
+
+		enum
+		{
+			NoDimensionsErr = 0,
+			DimensionsPercentage,
+			DimensionsPixelsAbsolute,
+		};
+
+		union
+		{
+			glm::vec4 dimensions = {};
+			struct
+			{
+				glm::vec2 pos;
+				glm::vec2 size;
+			};
+		};
+
+		int placementType = 0;
+		int dimensionsType = 0;
+
+		void absoluteTransformPixelSize(glm::vec4 dimensions);
+		void relativeTransformPixelSize(glm::vec4 dimensions);
+
+		glm::vec4 applyTransform(glm::vec4 parent);
+	};
+
+
+};

Pika/thirdparty/sushi/src/sushi.cpp

@@ -0,0 +1,41 @@
+#include <sushi/sushi.h>
+
+namespace sushi
+{
+
+
+	void sushi::SushyContext::update(gl2d::Renderer2D &renderer,
+		sushi::SushiInput &input)
+	{
+
+		if (renderer.windowH == 0 || renderer.windowW == 0)
+		{
+			return;
+		}
+
+		glm::vec4 drawRegion = {0, 0, renderer.windowW, renderer.windowH};
+
+		renderer.pushCamera();
+		{
+			//backgrouund
+			renderer.renderRectangle(drawRegion, background);
+
+
+			auto uiElSize = allUiElements.size();
+			for (int i = 0; i < uiElSize; i++)
+			{
+				glm::vec4 rectRez = allUiElements[i].transform.applyTransform(drawRegion);
+
+				renderer.renderRectangle(rectRez, allUiElements[i].color);
+
+			}
+
+		}
+		renderer.popCamera();
+	}
+
+
+
+
+};
+

Pika/thirdparty/sushi/src/sushiPrimitives.cpp

@@ -0,0 +1,74 @@
+#include <sushi/sushiPrimitives.h>
+
+namespace sushi
+{
+	void Transform::absoluteTransformPixelSize(glm::vec4 dimensions)
+	{
+		this->dimensions = dimensions;
+		placementType = AbsoluteTransform;
+		dimensionsType = DimensionsPixelsAbsolute;
+	}
+	
+	void Transform::relativeTransformPixelSize(glm::vec4 dimensions)
+	{
+		this->dimensions = dimensions;
+		placementType = RelativeTransform;
+		dimensionsType = DimensionsPixelsAbsolute;
+	}
+
+	glm::vec4 Transform::applyTransform(glm::vec4 parent)
+	{
+		const glm::vec2 parentPos = parent;
+		const glm::vec2 parentSize = {parent.z, parent.w};
+
+		glm::vec2 pos = {};
+		glm::vec2 size = {};
+
+		switch (dimensionsType)
+		{
+		case DimensionsPercentage:
+		{
+			size = glm::vec2(dimensions.z, dimensions.w) * parentSize;
+		}
+		break;
+
+		case DimensionsPixelsAbsolute:
+		{
+			size = glm::vec2(dimensions.z, dimensions.w);
+		}
+		break;
+
+		default:
+		return {};
+		//todo special error functions
+		};
+
+		//determine position;
+		switch (placementType)
+		{
+		case RelativeTransform:
+		{
+			pos = parentPos + glm::vec2(dimensions);
+		}
+		break;
+
+		case AbsoluteTransform:
+		{
+			pos = glm::vec2(dimensions);
+		}
+		break;
+
+		default:
+		return {};
+		//todo special error functions
+		};
+
+
+
+
+		return {pos, size};
+	}
+
+
+
+};