made the mcdungeons menu

Pika/CMakeLists.txt

@@ -26,6 +26,7 @@ add_subdirectory(thirdparty/glfw-3.3.2)
 add_subdirectory(thirdparty/glad)
 add_subdirectory(thirdparty/gl2d)
 add_subdirectory(thirdparty/gl3d)
+add_subdirectory(thirdparty/glui)
 add_subdirectory(thirdparty/glm)
 add_subdirectory(thirdparty/stb_image)
 add_subdirectory(thirdparty/stb_truetype)
@@ -73,7 +74,7 @@ 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 glm stb_image stb_truetype imgui safeSave)
+target_link_libraries(pikaCore PRIVATE glad glfw gl2d gl3d glui glm stb_image stb_truetype imgui safeSave)
 #################^^^^^^^^#############################
 
 
@@ -89,7 +90,7 @@ 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 glm stb_image stb_truetype imgui safeSave)
+target_link_libraries(pikaGameplay PRIVATE glad glfw gl2d gl3d glui glm stb_image stb_truetype imgui safeSave)
 #################^^^^^^^^^^^^^^############################
 
 
@@ -111,7 +112,7 @@ target_include_directories(pikaProduction PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/ga
 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 glm stb_image stb_truetype imgui safeSave)
+target_link_libraries(pikaProduction PRIVATE glad glfw gl2d gl3d glui glm stb_image stb_truetype imgui safeSave)
 
 
 

Pika/core/pikaSTD/engineLibraresSupport/engineGL2DSupport.cpp

@@ -0,0 +1,61 @@
+#include "engineGL2DSupport.h"
+
+
+::gl2d::Texture pika::gl2d::loadTextureWithPixelPadding(const char *path, RequestedContainerInfo &info, int blockSize,
+	bool pixelated, bool useMipMaps)
+{
+	::gl2d::Texture t = {};
+	size_t s = 0;
+	if (info.getFileSizeBinary(path, s))
+	{
+		void *data = new unsigned char[s];
+		if (info.readEntireFileBinary(path, data, s))
+		{
+			t.createFromFileDataWithPixelPadding((unsigned char *)data, s, blockSize, pixelated, useMipMaps);
+
+		}
+
+		delete[] data;
+	}
+	else { return 0; }
+
+	return t;
+}
+
+::gl2d::Texture pika::gl2d::loadTexture(const char *path, RequestedContainerInfo &info, bool pixelated, bool useMipMaps)
+{
+	::gl2d::Texture t = {};
+	size_t s = 0;
+	if (info.getFileSizeBinary(path, s))
+	{
+		void *data = new unsigned char[s];
+		if (info.readEntireFileBinary(path, data, s))
+		{
+			t.createFromFileData((unsigned char *)data, s, pixelated, useMipMaps);
+		}
+
+		delete[] data;
+	}
+	else { return 0; }
+
+	return t;
+}
+
+::gl2d::Font pika::gl2d::loadFont(const char *path, RequestedContainerInfo &info)
+{
+	::gl2d::Font f = {};
+	size_t s = 0;
+	if (info.getFileSizeBinary(path, s))
+	{
+		void *data = new unsigned char[s];
+		if (info.readEntireFileBinary(path, data, s))
+		{
+			f.createFromTTF((unsigned char *)data, s);
+		}
+
+		delete[] data;
+	}
+	else { return f; }
+
+	return f;
+}

Pika/core/pikaSTD/engineLibraresSupport/engineGL2DSupport.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <gl2d/gl2d.h>
+#include <baseContainer.h>
+
+
+namespace pika
+{
+
+	namespace gl2d
+	{
+
+
+		::gl2d::Texture loadTextureWithPixelPadding(const char *path, RequestedContainerInfo &info, int blockSize,
+			bool pixelated = false, bool useMipMaps = true);
+
+		::gl2d::Texture loadTexture(const char *path, RequestedContainerInfo &info,
+			bool pixelated = false, bool useMipMaps = true);
+
+		::gl2d::Font loadFont(const char *path, RequestedContainerInfo &info);
+
+
+	}
+
+}

Pika/gameplay/containers.h

@@ -22,6 +22,7 @@ Container *getContainer(const char* name, pika::memory::MemoryArena *memoryArena
 #include "pluggins/pikatextEditor.h"
 #include "containers/minecraftDungeons/mcDungeonsEditor.h"
 #include "containers/minecraftDungeons/mcDungeonsgameplay.h"
+#include "containers/minecraftDungeons/mcDungeonsMenu.h"
 
 #define PIKA_ALL_CONTAINERS() \
 	PIKA_DECLARE_CONTAINER(Gameplay) \
@@ -32,4 +33,5 @@ Container *getContainer(const char* name, pika::memory::MemoryArena *memoryArena
 	PIKA_DECLARE_CONTAINER(Mario) \
 	PIKA_DECLARE_CONTAINER(MarioEditor) \
 	PIKA_DECLARE_CONTAINER(McDungeonsEditor) \
-	PIKA_DECLARE_CONTAINER(McDungeonsGameplay) 
+	PIKA_DECLARE_CONTAINER(McDungeonsGameplay) \
+	PIKA_DECLARE_CONTAINER(McDungeonsMenu) 

Pika/gameplay/containers/mario/marioEditor.h

@@ -7,6 +7,7 @@
 #include <pikaSizes.h>
 #include "marioCommon.h"
 #include <safeSave/safeSave.h>
+#include <engineLibraresSupport/engineGL2DSupport.h>
 
 struct MarioEditor: public Container
 {
@@ -52,20 +53,9 @@ struct MarioEditor: public Container
 		//gl2d::setErrorFuncCallback() //tood
 		//pika::initShortcutApi();
 
-		size_t s = 0;
-		if (requestedInfo.getFileSizeBinary(PIKA_RESOURCES_PATH "/mario/1985_tiles.png", s))
-		{
-			void *data = new unsigned char[s];
-			if (requestedInfo.readEntireFileBinary(PIKA_RESOURCES_PATH "/mario/1985_tiles.png", data, s))
-			{
-				tiles.createFromFileDataWithPixelPadding((unsigned char*)data, s, 8, true, false);
-
-			}
-			else { return 0; }
-
-			delete[] data;
-		}
-		else { return 0; }
+		
+		tiles = pika::gl2d::loadTextureWithPixelPadding(PIKA_RESOURCES_PATH "/mario/1985_tiles.png", requestedInfo, 8, true, false);
+		if (tiles.id == 0) { return 0; }
 
 
 		atlas = gl2d::TextureAtlasPadding(8, 10, 8*8, 8*10);

Pika/gameplay/containers/minecraftDungeons/mcDungeons.cpp

@@ -4,7 +4,7 @@
 
 
 
-void  McDungeonsGameplay::resolveConstrains(Player &player)
+void  McDungeonsGameplay::resolveConstrains(PhysicsComponent &player)
 {
 	glm::ivec2 mapSize = {150,150};
 
@@ -78,7 +78,7 @@ end:
 
 }
 
-void  McDungeonsGameplay::checkCollisionBrute(Player &player, glm::vec2 &pos, glm::vec2 lastPos
+void  McDungeonsGameplay::checkCollisionBrute(PhysicsComponent &player, glm::vec2 &pos, glm::vec2 lastPos
 	, bool &upTouch, bool &downTouch, bool &leftTouch, bool &rightTouch)
 {
 	glm::vec2 delta = pos - lastPos;
@@ -106,7 +106,7 @@ void  McDungeonsGameplay::checkCollisionBrute(Player &player, glm::vec2 &pos, gl
 
 
 const int playerPosY = 13;
-glm::vec2  McDungeonsGameplay::performCollision(Player &player, glm::vec2 pos, glm::vec2 size,
+glm::vec2  McDungeonsGameplay::performCollision(PhysicsComponent &player, glm::vec2 pos, glm::vec2 size,
 	glm::vec2 delta, bool &upTouch, bool &downTouch, bool &leftTouch, bool &rightTouch)
 {
 

Pika/gameplay/containers/minecraftDungeons/mcDungeonsMenu.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include <gl2d/gl2d.h>
+#include <imgui.h>
+#include <baseContainer.h>
+#include <shortcutApi/shortcutApi.h>
+#include <pikaSizes.h>
+#include <imgui_spinner.h>
+#include <glui/glui.h>
+#include <engineLibraresSupport/engineGL2DSupport.h>
+
+struct McDungeonsMenu : public Container
+{
+
+	gl2d::Renderer2D renderer;
+	gl2d::Font font;
+	gl2d::Texture logo;
+	gl2d::Texture button;
+	glui::RendererUi ui;
+
+	//todo user can request imgui ids; shortcut manager context; allocators
+	static ContainerStaticInfo containerInfo()
+	{
+		ContainerStaticInfo info = {};
+		info.defaultHeapMemorySize = pika::MB(100);
+
+		info.requestImguiFbo = true; 
+
+		
+		
+
+		return info;
+	}
+
+
+	bool create(RequestedContainerInfo &requestedInfo, pika::StaticString<256> commandLineArgument)
+	{
+		renderer.create();
+		//pika::initShortcutApi(); //todo do this in dll load
+
+		font = pika::gl2d::loadFont(PIKA_RESOURCES_PATH "mcDungeons/CommodorePixeled.ttf", requestedInfo);
+		logo = pika::gl2d::loadTexture(PIKA_RESOURCES_PATH "mcDungeons/logo.png", requestedInfo);
+		button = pika::gl2d::loadTexture(PIKA_RESOURCES_PATH "mcDungeons/button.png", requestedInfo);
+
+
+
+
+		return true;
+	}
+
+	bool update(pika::Input input, pika::WindowState windowState,
+		RequestedContainerInfo &requestedInfo)
+	{
+		//todo keep window on top stuff
+
+		glClear(GL_COLOR_BUFFER_BIT);
+
+
+
+		renderer.updateWindowMetrics(windowState.w, windowState.h);
+
+		
+		ui.Begin(69);
+		{
+			
+			ui.Texture(1, logo);
+
+			if (ui.Button("Start game", Colors_White, button))
+			{
+
+			}
+
+			ui.BeginMenu("Settings", Colors_White, button);
+			{
+				if (ui.Button("Adaptive rezolution", Colors_White, button))
+				{
+
+				}
+			}
+			ui.EndMenu();
+
+		}
+		ui.End();
+
+
+		ui.renderFrame(renderer, font, {input.mouseX, input.mouseY},
+			input.lMouse.pressed(), input.lMouse.held(), input.lMouse.released(),
+			input.buttons[pika::Button::Escape].released(), input.typedInput, input.deltaTime);
+
+		renderer.flush();
+
+		
+
+		return true;
+	}
+
+	//optional
+	void destruct()
+	{
+
+		//todo
+		//renderer.clear();
+		
+	}
+
+};
+
+//todo flag to clear screen from engine
+//todo error popup
+//todo error popup disable in release

Pika/gameplay/containers/minecraftDungeons/mcDungeonsgameplay.h

@@ -28,7 +28,7 @@ struct McDungeonsGameplay: public Container
 		return info;
 	}
 
-	struct Player
+	struct PhysicsComponent
 	{
 		glm::vec2 size = glm::vec2(0.3f, 0.3f);
 		glm::vec2 position = {glm::vec2(0,0)};
@@ -40,17 +40,33 @@ struct McDungeonsGameplay: public Container
 		bool movingRight = 0;
 		bool grounded = 0;
 
+		float rotation = 0;
+		float desiredRotation = 0;
+
 		void updateMove() { lastPos = position; }
 	};
 
-	void resolveConstrains(Player &player);
+	void resolveConstrains(PhysicsComponent &player);
 
-	void checkCollisionBrute(Player &player, glm::vec2 &pos, glm::vec2 lastPos
+	void checkCollisionBrute(PhysicsComponent &player, glm::vec2 &pos, glm::vec2 lastPos
 		, bool &upTouch, bool &downTouch, bool &leftTouch, bool &rightTouch);
 
-	glm::vec2 performCollision(Player &player, glm::vec2 pos, glm::vec2 size,
+	glm::vec2 performCollision(PhysicsComponent &player, glm::vec2 pos, glm::vec2 size,
 		glm::vec2 delta, bool &upTouch, bool &downTouch, bool &leftTouch, bool &rightTouch);
 
+
+	struct Zombie
+	{
+		PhysicsComponent physics;
+		gl3d::Entity entity;
+
+		Zombie() {};
+		Zombie(int x, int z) { physics.position = {x,z}; physics.lastPos = {x,z}; };
+	};
+
+	std::vector<Zombie> enemies;
+
+
 	gl3d::Entity player;
 
 	enum Animations
@@ -73,9 +89,8 @@ struct McDungeonsGameplay: public Container
 
 	gl3d::Entity sword;
 
-	Player playerPhysics;
-	float rotation = 0;
-	float desiredRotation = 0;
+	PhysicsComponent playerPhysics;
+	
 
 	pika::gl3d::General3DEditor editor;
 
@@ -448,6 +463,8 @@ struct McDungeonsGameplay: public Container
 		model = createWorld(renderer, defaultMat[0]);
 		entity = renderer.createEntity(model);
 
+		auto zombieMat = renderer.loadMaterial(PIKA_RESOURCES_PATH "mcDungeons/zombie.mtl", 0);
+		if (zombieMat.size() != 1) { return false; }
 
 		auto playerModel = renderer.loadModel(PIKA_RESOURCES_PATH "mcDungeons/steve.glb", 0, 1);
 		//auto mat = renderer.loadMaterial(PIKA_RESOURCES_PATH "mcDungeons/steve.mtl", 0);
@@ -467,6 +484,30 @@ struct McDungeonsGameplay: public Container
 		auto swordModel = renderer.loadModel(PIKA_RESOURCES_PATH "/mcDungeons/minecraft_sword.glb", gl3d::TextureLoadQuality::maxQuality, 0.1);
 		sword = renderer.createEntity(swordModel, {}, false);
 
+		//enemies
+		{
+			enemies.push_back(Zombie(22, 33));
+			
+
+			for (auto &i : enemies)
+			{
+				i.entity = renderer.createEntity(playerModel, gl3d::Transform{glm::vec3{i.physics.position.x, 13, i.physics.position.y}}, false);
+			
+				int count = renderer.getEntityMeshesCount(i.entity);
+				if (!count)return 0;
+				for (int j = 0; j < count; j++)
+				{
+					renderer.setEntityMeshMaterial(i.entity, j, zombieMat[0]);
+				}
+				
+				renderer.setEntityAnimate(i.entity, true);
+				renderer.setEntityAnimationIndex(i.entity, Animations::zombieIdle);
+			}
+
+
+		}
+
+
 		renderer.camera.farPlane = 200;
 		renderer.directionalShadows.frustumSplits[0] = 0.06;
 		renderer.directionalShadows.frustumSplits[1] = 0.110;
@@ -572,7 +613,7 @@ struct McDungeonsGameplay: public Container
 						return x * (1 - a) + y * (a);
 					};
 					
-					desiredRotation = std::atan2(dir.x, dir.y);
+					playerPhysics.desiredRotation = std::atan2(dir.x, dir.y);
 					renderer.setEntityAnimationIndex(player, Animations::run);
 				}
 				else
@@ -591,47 +632,47 @@ struct McDungeonsGameplay: public Container
 			{
 				const float pi2 = 3.1415926f * 2.f;
 
-				if (desiredRotation != rotation)
+				if (playerPhysics.desiredRotation != playerPhysics.rotation)
 				{
 					float pozDistance = 0;
 					float negDistance = 0;
-					if (desiredRotation > rotation)
+					if (playerPhysics.desiredRotation > playerPhysics.rotation)
 					{
-						pozDistance = desiredRotation - rotation;
-						negDistance = rotation + pi2 - desiredRotation;
+						pozDistance = playerPhysics.desiredRotation - playerPhysics.rotation;
+						negDistance = playerPhysics.rotation + pi2 - playerPhysics.desiredRotation;
 					}
 					else
 					{
-						pozDistance = pi2 - rotation + desiredRotation;
-						negDistance = rotation - desiredRotation;
+						pozDistance = pi2 - playerPhysics.rotation + playerPhysics.desiredRotation;
+						negDistance = playerPhysics.rotation - playerPhysics.desiredRotation;
 					}
 
 					float speed = input.deltaTime * 3.141592f * 2.f;
-					float oldRot = rotation;
+					float oldRot = playerPhysics.rotation;
 					if (pozDistance > negDistance)
 					{
 						if (negDistance < speed)
 						{
-							rotation = desiredRotation;
+							playerPhysics.rotation = playerPhysics.desiredRotation;
 						}
 						else
 						{
-							rotation -= speed;
+							playerPhysics.rotation -= speed;
 						}
 					}
 					else
 					{
 						if (pozDistance < speed)
 						{
-							rotation = desiredRotation;
+							playerPhysics.rotation = playerPhysics.desiredRotation;
 						}
 						else
 						{
-							rotation += speed;
+							playerPhysics.rotation += speed;
 						}
 					}
 
-					if (rotation > pi2) { rotation -= pi2; }
+					if (playerPhysics.rotation > pi2) { playerPhysics.rotation -= pi2; }
 					
 
 				}
@@ -643,22 +684,41 @@ struct McDungeonsGameplay: public Container
 			resolveConstrains(playerPhysics);
 			playerPhysics.updateMove();
 
+			auto setTransform = [&](PhysicsComponent &p, gl3d::Entity &e)
+			{
+				gl3d::Transform t;
+				t.rotation.y = p.rotation;
+				t.position = glm::vec3(p.position.x, 12.55, p.position.y);
+				t.scale = glm::vec3(0.45);
+				renderer.setEntityTransform(e, t);
+				return t;
+			};
+
 		#pragma region player position
-			gl3d::Transform t;
-			t.rotation.y = rotation;
-			t.position = glm::vec3(playerPhysics.position.x, 13, playerPhysics.position.y);
-			t.scale = glm::vec3(0.5);
-			renderer.setEntityTransform(player, t);
+			auto t = setTransform(playerPhysics, player);
 			glm::vec3 playerPos = t.position;
 			glm::vec3 cameraViewDir = glm::normalize(glm::vec3(-1, 1.7, 1));
 			glm::vec3 cameraPos = playerPos + cameraViewDir * 12.f;
 		#pragma endregion
 
+			for (auto &e : enemies)
+			{
+				setTransform(e.physics, e.entity);
+			}
+
+
 		#pragma region sword
 			{
 				gl3d::Transform t;
 				renderer.getEntityJointTransform(player, "arm.r", t);
-				t.scale = glm::vec3(1);
+				t.scale = glm::vec3(0.5);
+
+				gl3d::Transform offset;
+				offset.rotation.x = glm::radians(90.f);
+				//offset.position.y = -1.f;
+
+				t.setFromMatrix(t.getTransformMatrix() *offset.getTransformMatrix());
+
 				renderer.setEntityTransform(sword, t);
 			}
 		#pragma endregion

Pika/resources/logs.txt

@@ -1,4 +1,4 @@
-#2023-03-11 10:22:10: Created container: Gameplay
-#2023-03-11 10:22:15: Created container: McDungeonsGameplay
-#2023-03-11 10:22:21: Destroyed continer: Gameplay #1
-#2023-03-11 10:22:21: Destroyed continer: McDungeonsGameplay #2
+#2023-03-14 12:50:30: Created container: Gameplay
+#2023-03-14 12:51:10: Created container: McDungeonsMenu
+#2023-03-14 12:51:12: Destroyed continer: Gameplay #1
+#2023-03-14 12:51:12: Destroyed continer: McDungeonsMenu #2

Pika/resources/mcDungeons/zombie.mtl

@@ -0,0 +1,17 @@
+# Blender MTL File: 'None'
+# Material Count: 1
+
+newmtl None
+
+Kd 1.000000 1.000000 1.000000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+Pm 0
+Pr 0.5
+Ao 1
+illum 2
+map_Kd zombie.png
+# map_Kn normal.png
+# map_RMA rma.png
+# map_emissive emissive.png

Pika/thirdparty/gl2d/src/gl2d.cpp

@@ -49,10 +49,8 @@
 #include <Windows.h>
 #endif
 
-#include <fstream>
 #include <sstream>
 #include <algorithm>
-#include <iostream>
 
 //if you are not using visual studio make shure you link to "Opengl32.lib"
 #ifdef _MSC_VER
@@ -167,7 +165,7 @@ namespace gl2d
 
 	void defaultErrorFunc(const char *msg)
 	{
-		std::cerr << "gl2d error: " << msg << "\n";
+		//std::cerr << "gl2d error: " << msg << "\n";
 	}
 
 	errorFuncType *setErrorFuncCallback(errorFuncType *newFunc)
@@ -474,28 +472,28 @@ namespace gl2d
 
 	void Font::createFromFile(const char *file)
 	{
-		std::ifstream fileFont(file, std::ios::binary);
-
-		if (!fileFont.is_open())
-		{
-			char c[300] = {0};
-			strcat(c, "error openning: ");
-			strcat(c + strlen(c), file);
-			errorFunc(c);
-			return;
-		}
-
-		int fileSize = 0;
-		fileFont.seekg(0, std::ios::end);
-		fileSize = (int)fileFont.tellg();
-		fileFont.seekg(0, std::ios::beg);
-		unsigned char *fileData = new unsigned char[fileSize];
-		fileFont.read((char *)fileData, fileSize);
-		fileFont.close();
-
-		createFromTTF(fileData, fileSize);
-
-		delete[] fileData;
+		//std::ifstream fileFont(file, std::ios::binary);
+		//
+		//if (!fileFont.is_open())
+		//{
+		//	char c[300] = {0};
+		//	strcat(c, "error openning: ");
+		//	strcat(c + strlen(c), file);
+		//	errorFunc(c);
+		//	return;
+		//}
+		//
+		//int fileSize = 0;
+		//fileFont.seekg(0, std::ios::end);
+		//fileSize = (int)fileFont.tellg();
+		//fileFont.seekg(0, std::ios::beg);
+		//unsigned char *fileData = new unsigned char[fileSize];
+		//fileFont.read((char *)fileData, fileSize);
+		//fileFont.close();
+		//
+		//createFromTTF(fileData, fileSize);
+		//
+		//delete[] fileData;
 	}
 
 
@@ -1668,56 +1666,56 @@ namespace gl2d
 
 	void Texture::loadFromFile(const char *fileName, bool pixelated, bool useMipMaps)
 	{
-		std::ifstream file(fileName, std::ios::binary);
-
-		if (!file.is_open())
-		{
-			char c[300] = {0};
-			strcat(c, "error openning: ");
-			strcat(c + strlen(c), fileName);
-			errorFunc(c);
-			return;
-		}
-
-		int fileSize = 0;
-		file.seekg(0, std::ios::end);
-		fileSize = (int)file.tellg();
-		file.seekg(0, std::ios::beg);
-		unsigned char *fileData = new unsigned char[fileSize];
-		file.read((char *)fileData, fileSize);
-		file.close();
-
-		createFromFileData(fileData, fileSize, pixelated, useMipMaps);
-
-		delete[] fileData;
+		//std::ifstream file(fileName, std::ios::binary);
+		//
+		//if (!file.is_open())
+		//{
+		//	char c[300] = {0};
+		//	strcat(c, "error openning: ");
+		//	strcat(c + strlen(c), fileName);
+		//	errorFunc(c);
+		//	return;
+		//}
+		//
+		//int fileSize = 0;
+		//file.seekg(0, std::ios::end);
+		//fileSize = (int)file.tellg();
+		//file.seekg(0, std::ios::beg);
+		//unsigned char *fileData = new unsigned char[fileSize];
+		//file.read((char *)fileData, fileSize);
+		//file.close();
+		//
+		//createFromFileData(fileData, fileSize, pixelated, useMipMaps);
+		//
+		//delete[] fileData;
 
 	}
 
 	void Texture::loadFromFileWithPixelPadding(const char *fileName, int blockSize,
 		bool pixelated, bool useMipMaps)
 	{
-		std::ifstream file(fileName, std::ios::binary);
-
-		if (!file.is_open())
-		{
-			char c[300] = {0};
-			strcat(c, "error openning: ");
-			strcat(c + strlen(c), fileName);
-			errorFunc(c);
-			return;
-		}
-
-		int fileSize = 0;
-		file.seekg(0, std::ios::end);
-		fileSize = (int)file.tellg();
-		file.seekg(0, std::ios::beg);
-		unsigned char *fileData = new unsigned char[fileSize];
-		file.read((char *)fileData, fileSize);
-		file.close();
-
-		createFromFileDataWithPixelPadding(fileData, fileSize, blockSize, pixelated, useMipMaps);
-
-		delete[] fileData;
+		//std::ifstream file(fileName, std::ios::binary);
+		//
+		//if (!file.is_open())
+		//{
+		//	char c[300] = {0};
+		//	strcat(c, "error openning: ");
+		//	strcat(c + strlen(c), fileName);
+		//	errorFunc(c);
+		//	return;
+		//}
+		//
+		//int fileSize = 0;
+		//file.seekg(0, std::ios::end);
+		//fileSize = (int)file.tellg();
+		//file.seekg(0, std::ios::beg);
+		//unsigned char *fileData = new unsigned char[fileSize];
+		//file.read((char *)fileData, fileSize);
+		//file.close();
+		//
+		//createFromFileDataWithPixelPadding(fileData, fileSize, blockSize, pixelated, useMipMaps);
+		//
+		//delete[] fileData;
 
 	}
 

Pika/thirdparty/gl3d/gl3d.cpp

@@ -38661,26 +38661,27 @@ namespace gl3d
 			return false;
 		}
 
-		//if (!en.animate())
-		//{
-		//	Transform t;
-		//
-		//	t.position = en.joints[boneIndex].trans;
-		//	t.scale = en.joints[boneIndex].scale;
-		//	t.rotation = glm::eulerAngles(en.joints[boneIndex].rotation);
-		//
-		//	glm::mat4 mat = t.getTransformMatrix();
-		//	mat = getTransformMatrix(en.transform) * mat;
-		//	t.setFromMatrix(mat);
-		//	return true;
-		//}
-		//else
+		glm::mat4 beginPos = en.joints[boneIndex].localBindTransform;
+
+		if (!en.animate())
 		{
-			glm::mat4 mat = en.joints[boneIndex].worldMatrix;
+			//t.position = en.joints[boneIndex].trans;
+			//t.scale = en.joints[boneIndex].scale;
+			//t.rotation = glm::eulerAngles(en.joints[boneIndex].rotation);
+		
+			//glm::mat4 mat = t.getTransformMatrix();
+			glm::mat4 mat = beginPos;
 			mat = getTransformMatrix(en.transform) * mat;
 			t.setFromMatrix(mat);
 			return true;
 		}
+		else
+		{
+			glm::mat4 mat = en.joints[boneIndex].worldMatrix;
+			mat = getTransformMatrix(en.transform) * mat * beginPos;
+			t.setFromMatrix(mat);
+			return true;
+		}
 		
 	}
 

Pika/thirdparty/glui/CMakeLists.txt

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.1)
+project(glui)
+
+add_library(glui)
+target_sources(glui PRIVATE "src/glui.cpp")
+target_include_directories(glui PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
+target_link_libraries(glui PUBLIC glm glad stb_image stb_truetype gl2d)

Pika/thirdparty/glui/include/glui/glui.h

@@ -0,0 +1,139 @@
+//////////////////////////////////////////////////
+//gl2d.h				1.0.0
+//Copyright(c) 2023 Luta Vlad
+//https://github.com/meemknight/glui
+//
+//
+//	dependences: gl2d, glew, glm, stb_image, stb_trueType
+//
+//
+//////////////////////////////////////////////////
+
+
+#pragma once
+#include "gl2d/gl2d.h"
+#include <string>
+#include <unordered_map>
+
+namespace glui
+{
+
+	struct RendererUi
+	{
+
+		void renderFrame(
+			gl2d::Renderer2D &renderer,
+			gl2d::Font &font,
+			glm::ivec2 mousePos,
+			bool mouseClick,
+			bool mouseHeld,
+			bool mouseReleased,
+			bool escapeReleased,
+			const std::string &typedInput,
+			float deltaTime
+		);
+
+		bool Button(std::string name,
+			const gl2d::Color4f colors, const gl2d::Texture texture = {});
+
+		void Texture(int id, gl2d::Texture t, gl2d::Color4f colors = {1,1,1,1}, glm::vec4 textureCoords = {0,1,1,0});
+
+		bool ButtonWithTexture(int id, gl2d::Texture t, gl2d::Color4f colors = {1,1,1,1}, glm::vec4 textureCoords = {0,1,1,0});
+
+		bool Toggle(std::string name,
+			const gl2d::Color4f colors, bool *toggle, const gl2d::Texture texture = {}, const gl2d::Texture overTexture = {});
+
+		//returns true if you should render it, clicked is optional
+		bool CustomWidget(int id, glm::vec4 *transform, bool *hovered = 0, bool *clicked = 0);
+
+		void Text(std::string name,
+			const gl2d::Color4f colors);
+
+		void InputText(std::string name,
+			char *text, size_t textSizeWithNullChar, gl2d::Color4f color = {0,0,0,0}, const gl2d::Texture texture = {});
+
+		void sliderFloat(std::string name, float *value, float min, float max,
+			gl2d::Texture sliderTexture = {}, gl2d::Color4f sliderColor = {1,1,1,1},
+			gl2d::Texture ballTexture = {}, gl2d::Color4f ballColor = {1,1,1,1});
+
+		void sliderInt(std::string name, int *value, int min, int max,
+			gl2d::Texture sliderTexture = {}, gl2d::Color4f sliderColor = {1,1,1,1},
+			gl2d::Texture ballTexture = {}, gl2d::Color4f ballColor = {1,1,1,1});
+
+		void colorPicker(std::string name, float *color3Component, gl2d::Texture sliderTexture = {},
+			gl2d::Texture ballTexture = {});
+
+		void newColum(int id);
+
+		void PushId(int id);
+
+		void PopId();
+
+		void BeginMenu(std::string name, const gl2d::Color4f colors, const gl2d::Texture texture);
+		void EndMenu();
+
+		void Begin(int id);
+		void End();
+
+		struct Internal
+		{
+			struct InputData
+			{
+				glm::ivec2 mousePos = {};
+				bool mouseClick = 0;
+				bool mouseHeld = 0;
+				bool mouseReleased = 0;
+				bool escapeReleased = 0;
+			};
+
+			struct Widget
+			{
+				int type = 0;
+				bool justCreated = true;
+				bool usedThisFrame = 0;
+				InputData lastFrameData = {};
+				gl2d::Color4f colors = Colors_White;
+				gl2d::Color4f colors2 = Colors_White;
+				gl2d::Texture texture = {};
+				gl2d::Texture textureOver = {};
+				glm::vec4 textureCoords = {};
+				bool returnFromUpdate = 0;
+				bool customWidgetUsed = 0;
+				void *pointer = 0;
+				bool clicked = 0; //todo for all?
+				bool hovered = 0;
+				float min = 0;
+				float max = 0;
+				int minInt = 0;
+				int maxInt = 0;
+				glm::vec4 returnTransform = {};//todo mabe for every widget?
+
+				struct PersistentData
+				{
+					bool sliderBeingDragged = 0;
+					bool sliderBeingDragged2 = 0;
+					bool sliderBeingDragged3 = 0;
+				}pd;
+
+				size_t textSize = 0;
+			};
+			
+
+			std::vector<std::pair<std::string, Widget>> widgetsVector;
+
+			std::unordered_map<std::string, Widget> widgets;
+
+			std::unordered_map<int, std::vector<std::string>> allMenuStacks;
+
+			std::string idStr;
+		}internal;
+
+	};
+
+
+	void defaultErrorFunc(const char* msg);
+	using errorFuncType = decltype(defaultErrorFunc);
+
+	
+
+};

Pika/thirdparty/glui/src/glui.cpp

@@ -0,0 +1,1436 @@
+#include "glui/glui.h"
+#include "gl2d/gl2d.h"
+#include <unordered_map>
+#include <iostream>
+#include <sstream>
+
+namespace glui
+{
+
+
+	void defaultErrorFunc(const char* msg)
+	{
+		std::cerr << "glui error: " << msg << "\n";
+	}
+
+	static errorFuncType* errorFunc = defaultErrorFunc;
+
+	errorFuncType* setErrorFuncCallback(errorFuncType* newFunc)
+	{
+		auto a = errorFunc;
+		errorFunc = newFunc;
+		return a;
+	}
+
+	enum widgetType
+	{
+		none = 0,
+		button,
+		toggle,
+		text,
+		textInput,
+		beginMenu,
+		endMenu,
+		texture,
+		buttonWithTexture,
+		sliderFloatW,
+		colorPickerW,
+		newColumW,
+		sliderIntW,
+		customWidget,
+	};
+
+	
+
+	
+
+	bool aabb(glm::vec4 transform, glm::vec2 point)
+	{
+		if (
+			point.x >= transform.x &&
+			point.y >= transform.y &&
+			point.x <= transform.x + transform.z &&
+			point.y <= transform.y + transform.w
+			)
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	
+
+	constexpr float pressDownSize = 0.04f;
+	constexpr float shadowSize = 0.1f;
+	constexpr float outlineSize = 0.02f;
+	constexpr float textFit = 1.2f;
+
+	constexpr float minimizeRatio = 0.9f;
+
+	constexpr float buttonFit  = 0.6f;
+	
+	constexpr float inSizeY = 0.8;
+	constexpr float inSizeX = 0.8;
+	constexpr float mainInSizeX = 0.9;
+	constexpr float mainInSizeY = 0.9;
+
+	void splitTransforms(glm::vec4& down, glm::vec4& newTransform, glm::vec4 transform)
+	{
+		down = transform;
+		newTransform = transform;
+		float border = shadowSize * std::min(transform.w, transform.z);
+		down.w = border;
+		newTransform.w -= border;
+		down.y += newTransform.w;
+	}
+
+	glm::vec4 stepColorUp(glm::vec4 color, float perc)
+	{
+		glm::vec4 inversColor = glm::vec4(1, 1, 1, 1) - color;
+		inversColor = inversColor * perc + color;
+	
+		inversColor = glm::clamp(inversColor, {0,0,0,0}, {1,1,1,1});
+
+		return glm::vec4(glm::vec3(inversColor), color.a);
+	}
+	glm::vec4 stepColorDown(glm::vec4 color, float perc)
+	{
+		color.r *= perc;
+		color.g *= perc;
+		color.b *= perc;
+		return color;
+	}
+
+	std::string getString(std::string s)
+	{
+		auto f = s.find("##");
+		if (f != s.npos)
+		{
+			s = std::string(s.begin(), s.begin() + f);
+		}
+		return s;
+	}
+
+	void renderFancyBox(gl2d::Renderer2D& renderer, glm::vec4 transform, glm::vec4 color, gl2d::Texture t, bool hovered, bool clicked)
+	{
+		if (color.a <= 0.01f) { return; }
+
+		float colorDim = 0.f;
+		if (hovered)
+		{
+			colorDim += 0.2f;
+			if (clicked)
+			{
+				colorDim = -0.8f;
+			}
+		}
+
+		glm::vec4 newColor = {};
+		if (colorDim >= 0)
+		{
+			newColor = stepColorUp(color, colorDim);
+		}
+		else
+		{
+			newColor = stepColorDown(color, -colorDim); //todo refactor this functions
+		}
+
+		auto lightColor = stepColorUp(newColor, 0.02);
+		auto darkColor = stepColorDown(newColor, 0.5f);
+		auto darkerColor = stepColorDown(newColor, 0.25f);
+		
+		auto outlineColor = stepColorUp(newColor, 0.3);
+		//auto outlineColor = darkerColor;
+
+		glm::vec4 colorVector[4] = {darkColor, darkColor, lightColor, lightColor};
+
+		if (t.id == 0)
+		{
+			
+			float calculatedOutline = outlineSize * std::min(transform.w, transform.z);
+			if (hovered)
+			{
+				renderer.renderRectangle(transform, outlineColor);
+			}
+			else
+			{
+				renderer.renderRectangle(transform, darkColor);
+			}
+			transform.x += calculatedOutline;
+			transform.y += calculatedOutline;
+			transform.z -= calculatedOutline * 2;
+			transform.w -= calculatedOutline * 2;
+
+			glm::vec4 middle = {};
+			glm::vec4 down = {};
+			splitTransforms(down, middle, transform);
+			renderer.renderRectangle(middle, colorVector);
+			renderer.renderRectangle(down, darkerColor);
+
+		}
+		else
+		{
+			//renderer.renderRectangle(transform, newColor, {}, 0.f, t);
+			//renderer.render9Patch2(transform, newColor, {}, 0.f, t, GL2D_DefaultTextureCoords, {2.f/26.f, 24.f / 26.f,24.f / 26.f,2.f / 26.f});
+			renderer.render9Patch2(transform, newColor, {}, 0.f, t, GL2D_DefaultTextureCoords, {0.2,0.8,0.8,0.2});
+		
+		}
+	}
+
+	//just z and w components of transform used
+	float determineTextSize(gl2d::Renderer2D &renderer, const std::string &str, gl2d::Font &f, glm::vec4 transform, bool minimize = true)
+	{
+		auto newStr = getString(str);
+		float size = textFit;
+
+		auto s = renderer.getTextSize(newStr.c_str(), f, size);
+
+		float ratioX = transform.z / s.x;
+		float ratioY = transform.w / s.y;
+
+
+		if (ratioX > 1 && ratioY > 1)
+		{
+			
+			///keep size
+			//return size;
+			
+			//else
+			//{
+			//	if (ratioX > ratioY)
+			//	{
+			//		return size * ratioY;
+			//	}
+			//	else
+			//	{
+			//		return size * ratioX;
+			//	}
+			//}
+
+		}
+		else
+		{
+			if (ratioX < ratioY)
+			{
+				size *= ratioX;
+			}
+			else
+			{
+				size *= ratioY;
+			}
+		}
+
+		if (minimize)
+		{
+			size *= minimizeRatio;
+		}
+
+		return size;
+	}
+
+	glm::vec4 determineTextPos(gl2d::Renderer2D& renderer, const std::string& str, gl2d::Font& f, glm::vec4 transform,
+		bool noTexture, bool minimize = true)
+	{
+		auto newStr = getString(str);
+		auto newS = determineTextSize(renderer, newStr, f, transform);
+
+		auto s = renderer.getTextSize(newStr.c_str(), f, newS);
+
+		glm::vec2 pos = glm::vec2(transform);
+
+		pos.x += transform.z / 2.f;
+		pos.y += transform.w / 2.f;
+
+		pos -= s / 2.f;
+
+		return glm::vec4{pos, s};
+	}
+
+	//todo reuse the upper function
+	void renderText(gl2d::Renderer2D& renderer,const std::string &str, gl2d::Font& f, glm::vec4 transform, glm::vec4 color, 
+		bool noTexture, bool minimize = true)
+	{
+		auto newStr = getString(str);
+		auto newS = determineTextSize(renderer, newStr, f, transform, minimize);
+
+		glm::vec2 pos = glm::vec2(transform);
+		
+		pos.x += transform.z / 2.f;
+		pos.y += transform.w / 2.f;
+
+
+		renderer.renderText(pos, newStr.c_str(), f, color, newS);
+	}
+
+	glm::vec4 computeTextureNewPosition(glm::vec4 transform, gl2d::Texture t)
+	{
+		auto tsize = t.GetSize();
+
+		if (tsize.y == 0) { return {}; }
+		if (transform.w == 0) { return {}; }
+
+		float aspectRatio = tsize.x / (float)tsize.y;
+		float boxAspectRatio = transform.z / transform.w;
+
+		if (aspectRatio < boxAspectRatio) // the texture is shorter than the box 
+		{
+			glm::vec2 newSize = {};
+			newSize.y = transform.w;
+			newSize.x = aspectRatio * newSize.y;
+
+			glm::vec4 newPos = {transform.x, transform.y, newSize};
+			newPos.x += (transform.z - newSize.x) / 2.f;
+
+			return newPos;
+		}
+		else if (aspectRatio > boxAspectRatio) //the texture is longer than the box
+		{
+			glm::vec2 newSize = {};
+			newSize.x = transform.z;
+			newSize.y = newSize.x / aspectRatio;
+
+			glm::vec4 newPos = {transform.x, transform.y, newSize};
+			newPos.y += (transform.w - newSize.y) / 2.f;
+			
+			return newPos;
+		}
+		else // if (aspectRatio == boxAspectRatio) // redundant
+		{
+			return transform;
+		}
+	}
+
+	void renderTexture(gl2d::Renderer2D &renderer, glm::vec4 transform, gl2d::Texture t, gl2d::Color4f c, glm::vec4 textureCoordonates)
+	{
+		auto newPos = computeTextureNewPosition(transform, t);
+
+		renderer.renderRectangle(newPos, c,
+			{}, 0.f, t);
+	}
+
+	void renderSliderFloat(gl2d::Renderer2D &renderer, glm::vec4 transform, float *value, float min, float max, 
+		bool &sliderBeingDragged,
+		gl2d::Texture barT, gl2d::Color4f barC, gl2d::Texture ballT, gl2d::Color4f ballC, RendererUi::Internal::InputData &input)
+	{
+
+		float barSize = 7;
+		float barIndent = 16;
+
+		glm::vec4 barTransform(transform.x + barIndent, transform.y + (transform.w - barSize) / 2.f,
+			transform.z - barIndent * 2.f, barSize);
+
+		float bulletSize = 14.f;
+
+		glm::vec4 bulletTransform(barTransform.x - (bulletSize) / 2.f, barTransform.y + (barSize - bulletSize) / 2.f,
+			bulletSize, bulletSize);
+
+
+		bulletTransform.x += std::max( std::min((*value - min) / (max - min), 1.f), 0.f)
+			* barTransform.z;
+
+		//todo color
+		renderFancyBox(renderer, barTransform, barC, barT, 0, 0);
+
+		bool hovered = false;
+		bool clicked = false;
+
+		if (sliderBeingDragged == true && input.mouseHeld)
+		{
+			hovered = true;
+			clicked = true;
+		}
+		else
+		{
+			if (aabb(barTransform, input.mousePos))
+			{
+				hovered = true;
+
+				if (input.mouseClick)
+				{
+					clicked = true;
+				}
+			}
+		}
+
+		if (clicked)
+		{
+			sliderBeingDragged = true;
+
+			int begin = barTransform.x;
+			int end = barTransform.x + barTransform.z;
+
+			int mouseX = input.mousePos.x;
+
+			float mouseVal = (mouseX - (float)begin) / (end - (float)begin);
+
+			mouseVal = glm::clamp(mouseVal, 0.f, 1.f);
+
+			mouseVal *= max - min;
+			mouseVal += min;
+
+			*value = mouseVal;
+		}
+		else
+		{
+			sliderBeingDragged = false;
+		}
+
+		renderFancyBox(renderer, bulletTransform, ballC, ballT,
+			hovered, clicked);
+		
+	}
+
+	void renderSliderInt(gl2d::Renderer2D &renderer, glm::vec4 transform, int *value, int min, int max,
+		bool &sliderBeingDragged,
+		gl2d::Texture barT, gl2d::Color4f barC, gl2d::Texture ballT, gl2d::Color4f ballC, RendererUi::Internal::InputData &input)
+	{
+
+		float barSize = 7;
+		float barIndent = 16;
+
+		glm::vec4 barTransform(transform.x + barIndent, transform.y + (transform.w - barSize) / 2.f,
+			transform.z - barIndent * 2.f, barSize);
+
+		float bulletSize = 14.f;
+
+		glm::vec4 bulletTransform(barTransform.x - (bulletSize) / 2.f, barTransform.y + (barSize - bulletSize) / 2.f,
+			bulletSize, bulletSize);
+
+
+		bulletTransform.x += std::max(std::min((*value - min) / (float)(max - min), 1.f), 0.f)
+			* barTransform.z;
+
+		//todo color
+		renderFancyBox(renderer, barTransform, barC, barT, 0, 0);
+
+		bool hovered = false;
+		bool clicked = false;
+
+		if (sliderBeingDragged == true && input.mouseHeld)
+		{
+			hovered = true;
+			clicked = true;
+		}
+		else
+		{
+			if (aabb(barTransform, input.mousePos))
+			{
+				hovered = true;
+
+				if (input.mouseClick)
+				{
+					clicked = true;
+				}
+			}
+		}
+
+		if (clicked)
+		{
+			sliderBeingDragged = true;
+
+			int begin = barTransform.x;
+			int end = barTransform.x + barTransform.z;
+
+			int mouseX = input.mousePos.x;
+
+			float mouseVal = (mouseX - (float)begin) / (end - (float)begin);
+
+			mouseVal = glm::clamp(mouseVal, 0.f, 1.f);
+
+			mouseVal *= max - min;
+			mouseVal += min;
+
+			*value = mouseVal;
+		}
+		else
+		{
+			sliderBeingDragged = false;
+		}
+
+		renderFancyBox(renderer, bulletTransform, ballC, ballT,
+			hovered, clicked);
+
+	}
+
+
+	float timer=0;
+	int currentId = 0;
+	bool idWasSet = 0;
+
+
+	void RendererUi::renderFrame(gl2d::Renderer2D& renderer, gl2d::Font& font, glm::ivec2 mousePos, bool mouseClick,
+		bool mouseHeld, bool mouseReleased, bool escapeReleased, const std::string& typedInput, float deltaTime)
+	{
+		if (!idWasSet)
+		{
+			return;
+		}
+		//find the menu stack for this Begin()
+		
+		auto iterMenuStack = internal.allMenuStacks.find(currentId);
+		if (iterMenuStack == internal.allMenuStacks.end())
+		{
+			iterMenuStack = internal.allMenuStacks.insert({currentId, {}}).first;
+		}
+		auto &currentMenuStack = iterMenuStack->second;
+
+		idWasSet = 0;
+		currentId = 0;
+
+		if (escapeReleased && !currentMenuStack.empty())
+		{
+			currentMenuStack.pop_back();
+		}
+
+		timer += deltaTime*2;
+		if (timer >= 2.f)
+		{
+			timer -= 2;
+		}
+
+		//clear some data
+		for (auto &i : internal.widgets)
+		{
+			if (i.second.type == widgetType::customWidget)
+			{
+				i.second.customWidgetUsed = false;
+			}
+		}
+
+		std::vector<std::pair<std::string, Internal::Widget>> widgetsCopy;
+		widgetsCopy.reserve(internal.widgetsVector.size());
+
+		auto currentMenuStackCopy = currentMenuStack;
+		{
+			std::vector<std::string> menuStack;
+
+			std::string nextMenu = "";
+			bool shouldIgnor = false;
+
+			if (!currentMenuStackCopy.empty())
+			{
+				nextMenu = currentMenuStackCopy.front();
+				currentMenuStackCopy.erase(currentMenuStackCopy.begin());
+				shouldIgnor = true;
+			}
+
+			int nextStackSizeToLook = 0;
+			int nextStackSizeToLookMin = 0;
+
+			for (auto& i : internal.widgetsVector)
+			{
+
+				if (i.second.type == widgetType::beginMenu)
+				{
+					menuStack.push_back(i.first);
+
+					if (i.first == nextMenu)
+					{
+						if (!currentMenuStackCopy.empty())
+						{
+							nextMenu = currentMenuStackCopy.front();
+							currentMenuStackCopy.erase(currentMenuStackCopy.begin());
+							shouldIgnor = true;
+
+						}
+						else
+						{
+							shouldIgnor = false;
+							nextStackSizeToLookMin = menuStack.size();
+						}
+					}else
+					if (i.first != nextMenu && shouldIgnor != true)
+					{
+						shouldIgnor = true;
+						nextStackSizeToLook = menuStack.size() - 1;
+						widgetsCopy.push_back(i);
+					}
+					
+					continue;
+				}
+
+				if (i.second.type == widgetType::endMenu)
+				{
+					i.first = "##$" + menuStack.back();
+					menuStack.pop_back();
+
+					if (nextStackSizeToLook == menuStack.size())
+					{
+						shouldIgnor = false;
+					}
+
+					if (menuStack.size() < nextStackSizeToLookMin)
+					{
+						shouldIgnor = true;
+					}
+
+					continue;
+				}
+
+				if (shouldIgnor)
+				{
+					continue;
+				}
+
+				widgetsCopy.push_back(i);
+			
+			}
+		};
+
+		auto computePos = [&](int elementsHeight, float &advanceSizeY)
+		{
+			float sizeWithPaddY = ((float)renderer.windowH / elementsHeight);
+			float sizeY = sizeWithPaddY * inSizeY;
+			float paddSizeY = sizeWithPaddY * (1 - inSizeY) / 2.f;
+
+			float sizeWithPaddX = (float)renderer.windowW;
+			float sizeX = sizeWithPaddX * inSizeX;
+			float paddSizeX = sizeWithPaddX * (1 - inSizeX) / 2.f;
+
+			glm::vec4 computedPos = {};
+			computedPos.x = paddSizeX + (float)renderer.windowW * (1 - mainInSizeX) * 0.5f;
+			computedPos.y = paddSizeY + (float)renderer.windowH * (1 - mainInSizeY) * 0.5f;
+			computedPos.z = sizeX * mainInSizeX;
+			computedPos.w = sizeY * mainInSizeY;
+
+			advanceSizeY = (paddSizeY * 2 + sizeY) * mainInSizeY;
+
+			return computedPos;
+		};
+
+		std::vector<std::pair<glm::vec4, float>> colums;
+
+		int widgetsCountUntillNewColumW = 0;
+
+		for (int i = 0; i < widgetsCopy.size(); i++)
+		{
+			if (widgetsCopy[i].second.type == glui::widgetType::newColumW)
+			{
+				float padd = 0;
+				auto rez = computePos(widgetsCountUntillNewColumW, padd);
+				colums.push_back({rez, padd});
+				widgetsCountUntillNewColumW = 0;
+			}
+			else
+			{
+				widgetsCountUntillNewColumW++;
+			}
+		}
+		if (widgetsCountUntillNewColumW != 0)
+		{
+			float padd = 0;
+			auto rez = computePos(widgetsCountUntillNewColumW, padd);
+			colums.push_back({rez, padd});
+			widgetsCountUntillNewColumW = 0;
+		}
+
+		int currentColum = 0;
+
+		for (auto &i : colums)
+		{
+			i.first.z /= colums.size();
+		}
+		float columAdvanceSize = colums[0].first.z; //all colums have the same width for now
+		float beginY = colums[0].first.y; //all colums start from the same height fot now
+
+		for (int i=0; i<colums.size(); i++)
+		{
+			colums[i].first.x += columAdvanceSize * i;
+		}
+
+		auto camera = renderer.currentCamera;
+		renderer.currentCamera.setDefault();
+
+		Internal::InputData input = {};
+		input.mousePos = mousePos;
+		input.mouseClick = mouseClick;
+		input.mouseHeld = mouseHeld;
+		input.mouseReleased = mouseReleased;
+		input.escapeReleased = escapeReleased;
+
+		
+		for (auto& i : widgetsCopy)
+		{
+
+			auto find = internal.widgets.find(i.first);
+
+			if (find == internal.widgets.end())
+			{
+				
+				i.second.usedThisFrame = true;
+				i.second.justCreated = true;
+				internal.widgets.insert(i);
+				
+				//continue;
+			}
+			else 
+			{
+				
+				if (find->second.type != i.second.type)
+				{
+					errorFunc("reupdated a widget with a different type");
+				}
+
+				if (find->second.usedThisFrame == true)
+				{
+					errorFunc("used a widget name twice");
+				}
+
+				auto pd = find->second.pd;
+
+				find->second = i.second;
+				find->second.justCreated = false;
+				find->second.pd = pd;
+
+				find->second.usedThisFrame = true;
+				//continue;
+			}
+
+			{
+				auto &j = *internal.widgets.find(i.first);
+				auto& widget = j.second;
+
+				auto drawButton = [&]()
+				{
+					auto transformDrawn = colums[currentColum].first;
+					auto aabbTransform = colums[currentColum].first;
+					bool hovered = 0;
+					bool clicked = 0;
+					auto textColor = Colors_White;
+
+					if (widget.colors.a <= 0.01f)
+					{
+						auto p = determineTextPos(renderer, j.first, font, transformDrawn, true);
+						aabbTransform = p;
+					}
+
+					if (aabb(aabbTransform, input.mousePos))
+					{
+						hovered = true;
+						if (input.mouseHeld)
+						{
+							clicked = true;
+							transformDrawn.y += transformDrawn.w * pressDownSize;
+						}
+					}
+
+					if (hovered && widget.colors.a <= 0.01f)
+					{
+						textColor = stepColorDown(textColor, 0.8);
+					}
+
+					if (input.mouseReleased && aabb(aabbTransform, input.mousePos))
+					{
+						widget.returnFromUpdate = true;
+					}
+					else
+					{
+						widget.returnFromUpdate = false;
+					}
+
+					renderFancyBox(renderer, transformDrawn, widget.colors, widget.texture, hovered, clicked);
+
+					if ((widget.colors.a <= 0.01f || i.second.texture.id == 0))
+					{
+						renderText(renderer, j.first, font, transformDrawn, textColor, true, !hovered);
+					}
+					else
+					{
+						renderText(renderer, j.first, font, transformDrawn, textColor, false, !hovered);
+					}
+
+					return widget.returnFromUpdate;
+				};
+
+				
+				switch (widget.type)
+				{
+					case widgetType::button:
+					{
+						
+						drawButton();
+
+						break;
+					}
+					case widgetType::toggle:
+					{
+						auto transformDrawn = colums[currentColum].first;
+						bool hovered = 0;
+						bool clicked = 0;
+
+						glm::vec4 toggleTransform = transformDrawn;
+						glm::vec4 textTransform = transformDrawn;
+						textTransform.z -= toggleTransform.w;
+						toggleTransform.z = toggleTransform.w;
+
+						auto p = determineTextPos(renderer, j.first, font, textTransform, true);
+						toggleTransform.x = p.x + p.z;
+
+						glm::vec4 aabbBox = p;
+						aabbBox.z += toggleTransform.z;
+						aabbBox.y = std::min(toggleTransform.y, textTransform.y);
+						aabbBox.w = std::max(toggleTransform.w, textTransform.w);
+
+						if (aabb(aabbBox, input.mousePos))
+						{
+							hovered = true;
+							if (input.mouseHeld)
+							{
+								clicked = true;
+								textTransform.y += transformDrawn.w * pressDownSize;
+								toggleTransform.y += transformDrawn.w * pressDownSize;
+							}
+						}
+
+						if (input.mouseReleased && aabb(aabbBox, input.mousePos))
+						{
+							*(bool*)(widget.pointer) = !(*(bool*)(widget.pointer));
+						}
+
+						widget.returnFromUpdate = *(bool*)(widget.pointer);
+
+
+						if (hovered)
+						{
+							renderText(renderer, j.first, font, textTransform, stepColorDown(Colors_White, 0.8),
+								true, false);
+						}
+						else
+						{
+							renderText(renderer, j.first, font, textTransform, Colors_White, true);
+						}
+						
+
+						if (widget.returnFromUpdate)
+						{
+							auto small = toggleTransform;
+							small.z *= buttonFit;
+							small.w *= buttonFit;
+							small.x += toggleTransform.z * (1.f - buttonFit) / 2.f;
+							small.y += toggleTransform.w * (1.f - buttonFit) / 2.f;
+
+							renderFancyBox(renderer, toggleTransform, widget.colors, widget.texture, hovered, clicked);
+
+							if (widget.textureOver.id)
+							{
+								renderFancyBox(renderer, toggleTransform, Colors_White, widget.textureOver, false, false);
+							}
+							else
+							{
+								renderFancyBox(renderer, small, widget.colors, widget.textureOver, false, false);
+							}
+						}
+						else
+						{
+							renderFancyBox(renderer, toggleTransform, widget.colors, widget.texture, hovered, clicked);
+						}
+
+
+
+						break;
+					}
+					case widgetType::text:
+					{
+
+						renderText(renderer, j.first, font, colums[currentColum].first, j.second.colors, true);
+
+						break;
+					}
+					case widgetType::textInput:
+					{
+
+						char* text = (char*)j.second.pointer;
+						size_t n = j.second.textSize;
+
+						int pos = strlen(text);
+
+						for (auto i : typedInput)
+						{
+							if (i == 8) //backspace
+							{
+								if (pos > 0)
+								{
+									pos--;
+									text[pos] = 0;
+								}
+							}
+							else if (i == '\n')
+							{
+								//ignore
+							}
+							else
+							{
+								if (pos < n - 1)
+								{
+									text[pos] = i;
+									pos++;
+									text[pos] = 0;
+								}
+							}
+						}
+
+						if (i.second.texture.id != 0)
+						{
+							renderFancyBox(renderer, colums[currentColum].first, i.second.colors, widget.texture, 0, 0);
+						}
+						
+						std::string textCopy = text;
+						if ((int)timer % 2)
+						{
+							textCopy += "|";
+						}
+
+						renderText(renderer, textCopy, font, colums[currentColum].first, Colors_White, true);
+
+
+						break;
+					}
+					case widgetType::beginMenu:
+					{
+
+						if (drawButton()) 
+						{
+							currentMenuStack.push_back(i.first);
+						};
+
+						break;
+					}
+
+					case widgetType::texture:
+					{
+
+						renderTexture(renderer, colums[currentColum].first, j.second.texture, j.second.colors,
+							j.second.textureCoords);
+
+						break;
+					}
+
+					case widgetType::buttonWithTexture:
+					{
+						bool hovered = false;
+						bool clicked = false;
+						glm::vec4 transformDrawn = computeTextureNewPosition(colums[currentColum].first, j.second.texture);
+						glm::vec4 aabbPos = transformDrawn;
+						glm::vec4 color = j.second.colors;
+
+
+						if (aabb(aabbPos, input.mousePos))
+						{
+							hovered = true;
+							if (input.mouseHeld)
+							{
+								clicked = true;
+								transformDrawn.y += transformDrawn.w * pressDownSize;
+							}
+						}
+
+						if (hovered)
+						{
+							color = stepColorDown(color, 0.8);
+						}
+
+						if (input.mouseReleased && aabb(aabbPos, input.mousePos))
+						{
+							widget.returnFromUpdate = true;
+						}
+						else
+						{
+							widget.returnFromUpdate = false;
+						}
+
+						renderTexture(renderer, transformDrawn, j.second.texture, color,
+							j.second.textureCoords);
+
+						break;
+					}
+
+					case widgetType::sliderFloatW:
+					{
+						if (j.second.max <= j.second.min) { break; }
+
+						auto computedPos = colums[currentColum].first;
+
+						glm::vec4 textTransform{computedPos.x, computedPos.y, computedPos.z / 2, computedPos.w};
+						glm::vec4 sliderTransform{computedPos.x + computedPos.z / 2, computedPos.y, computedPos.z/2, computedPos.w};
+
+						float *value = (float*)j.second.pointer;
+						if (!value) { break; }
+
+						*value = std::min(*value, j.second.max);
+						*value = std::max(*value, j.second.min);
+
+
+						std::string text = j.first;
+						
+						std::ostringstream s;
+						s.precision(2);
+						s << std::fixed << *value;
+
+						text = getString(text) + ": " + s.str();
+
+						renderText(renderer, text, font, textTransform, j.second.colors, true);
+
+						renderSliderFloat(renderer, sliderTransform,
+							value, j.second.min, j.second.max, j.second.pd.sliderBeingDragged,
+							j.second.texture, j.second.colors, j.second.textureOver, j.second.colors2, input);
+
+						break;
+					}
+
+
+					case widgetType::colorPickerW:
+					{
+						auto computedPos = colums[currentColum].first;
+
+						glm::vec4 textTransform{computedPos.x, computedPos.y, computedPos.z / 4, computedPos.w};
+						glm::vec4 transform1{computedPos.x + (computedPos.z / 4.f)*1, computedPos.y, computedPos.z / 4.f, computedPos.w};
+						glm::vec4 transform2{computedPos.x + (computedPos.z / 4.f)*2, computedPos.y, computedPos.z / 4.f, computedPos.w};
+						glm::vec4 transform3{computedPos.x + (computedPos.z / 4.f)*3, computedPos.y, computedPos.z / 4.f, computedPos.w};
+
+						float *value;
+						value = (float *)j.second.pointer;
+
+						if (!value) { break; }
+
+						glm::vec4 color = {value[0], value[1], value[2], 1};
+
+						renderText(renderer, j.first, font, textTransform, color, true);
+
+						renderSliderFloat(renderer, transform1,
+							value+0, 0, 1, j.second.pd.sliderBeingDragged,
+							j.second.texture, {1,0,0,1}, j.second.textureOver, {1,0,0,1}, input);
+
+						renderSliderFloat(renderer, transform2,
+							value+1, 0, 1, j.second.pd.sliderBeingDragged2,
+							j.second.texture, {0,1,0,1}, j.second.textureOver, {0,1,0,1}, input);
+
+						renderSliderFloat(renderer, transform3,
+							value+2, 0, 1, j.second.pd.sliderBeingDragged3,
+							j.second.texture, {0,0,1,1}, j.second.textureOver, {0,0,1,1}, input);
+
+						break;
+					}
+					case widgetType::newColumW:
+					{
+						currentColum++;
+						colums[currentColum].first.y -= colums[currentColum].second; //neagate end of loop;
+						break;
+					}
+
+					case widgetType::sliderIntW: 
+					{
+						if (j.second.maxInt <= j.second.minInt) { break; }
+
+						auto computedPos = colums[currentColum].first;
+
+						glm::vec4 textTransform{computedPos.x, computedPos.y, computedPos.z / 2, computedPos.w};
+						glm::vec4 sliderTransform{computedPos.x + computedPos.z / 2, computedPos.y, computedPos.z / 2, computedPos.w};
+
+						int *value = (int *)j.second.pointer;
+						if (!value) { break; }
+
+						*value = std::min(*value, j.second.maxInt);
+						*value = std::max(*value, j.second.minInt);
+
+
+						std::string text = j.first;
+
+						text = getString(text) + ": " + std::to_string(*value);
+
+						renderText(renderer, text, font, textTransform, j.second.colors, true);
+
+						renderSliderInt(renderer, sliderTransform,
+							value, j.second.minInt, j.second.maxInt, j.second.pd.sliderBeingDragged,
+							j.second.texture, j.second.colors, j.second.textureOver, j.second.colors2, input);
+
+					
+						break;
+					}
+
+					case widgetType::customWidget:
+					{
+						j.second.returnTransform = colums[currentColum].first;
+						j.second.customWidgetUsed = true;
+
+						j.second.hovered = aabb(j.second.returnTransform, mousePos);
+						
+						j.second.clicked = aabb(j.second.returnTransform, mousePos) && mouseHeld;
+
+						break;
+					}
+
+				}
+
+				widget.justCreated = false;
+				widget.lastFrameData = input;
+			}
+
+			colums[currentColum].first.y += colums[currentColum].second;
+		}
+
+		
+		//clear unused data
+		{
+			std::unordered_map<std::string, Internal::Widget> widgets2;
+			widgets2.reserve(internal.widgets.size());
+			for (auto& i : internal.widgets)
+			{
+				if (i.second.usedThisFrame)
+				{
+					i.second.usedThisFrame = false;
+					widgets2.insert(i);
+				}
+			}
+			internal.widgets = widgets2;
+		}
+
+		
+		renderer.currentCamera = camera;
+
+		internal.widgetsVector.clear();
+
+		if (!internal.idStr.empty())
+		{
+			errorFunc("More pushes than pops");
+		}
+		internal.idStr.clear();
+
+	}
+
+	bool RendererUi::Button(std::string name, const gl2d::Color4f colors, const gl2d::Texture texture)
+	{
+		name += internal.idStr;
+
+		Internal::Widget widget = {};
+		widget.type = widgetType::button;
+		widget.colors = colors;
+		widget.texture = texture;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+		internal.widgetsVector.push_back({name, widget});
+
+		auto find = internal.widgets.find(name);
+		if (find != internal.widgets.end())
+		{
+			return find->second.returnFromUpdate;
+		}
+		else
+		{
+			return false;
+		}
+		
+	}
+
+	void RendererUi::Texture(int id, gl2d::Texture t, gl2d::Color4f colors, glm::vec4 textureCoords)
+	{
+		Internal::Widget widget = {};
+		widget.type = widgetType::texture;
+		widget.texture = t;
+		widget.colors = colors;
+		widget.textureCoords = textureCoords;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+
+		internal.widgetsVector.push_back({"##$texture" + std::to_string(id), widget});
+	}
+
+	bool RendererUi::ButtonWithTexture(int id, gl2d::Texture t, gl2d::Color4f colors, glm::vec4 textureCoords)
+	{
+		Internal::Widget widget = {};
+		widget.type = widgetType::buttonWithTexture;
+		widget.texture = t;
+		widget.colors = colors;
+		widget.textureCoords = textureCoords;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+
+		std::string name = "##$textureWithId:" + std::to_string(id);
+
+		internal.widgetsVector.push_back({name, widget});
+
+		auto find = internal.widgets.find(name);
+		if (find != internal.widgets.end())
+		{
+			return find->second.returnFromUpdate;
+		}
+		else
+		{
+			return false;
+		}
+
+	}
+
+	bool RendererUi::Toggle(std::string name, const gl2d::Color4f colors, bool* toggle, const gl2d::Texture texture, const gl2d::Texture overTexture)
+	{
+		name += internal.idStr;
+
+		Internal::Widget widget = {};
+		widget.type = widgetType::toggle;
+		widget.colors = colors;
+		widget.texture = texture;
+		widget.textureOver = overTexture;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+		widget.pointer = toggle;
+		internal.widgetsVector.push_back({name, widget});
+
+		auto find = internal.widgets.find(name);
+		if (find != internal.widgets.end())
+		{
+			return find->second.returnFromUpdate;
+		}
+		else
+		{
+			return false;
+		}
+
+	}
+
+	bool RendererUi::CustomWidget(int id, glm::vec4 *transform, bool *hovered, bool *clicked)
+	{
+		std::string name = "##$customWidgetWithId:" + std::to_string(id);
+
+		Internal::Widget widget = {};
+		widget.type = widgetType::customWidget;
+		widget.pointer = transform;
+
+		internal.widgetsVector.push_back({name, widget});
+
+		auto find = internal.widgets.find(name);
+		if (find != internal.widgets.end())
+		{
+			*transform = find->second.returnTransform;
+
+			if (hovered)
+			{
+				*hovered = find->second.hovered;
+				*clicked = find->second.clicked;
+			}
+
+			return find->second.customWidgetUsed;
+		}
+		else
+		{
+			*transform = {};
+
+			return false;
+		}
+	}
+
+	void RendererUi::Text(std::string name, const gl2d::Color4f colors)
+	{
+		name += internal.idStr;
+
+		Internal::Widget widget = {};
+		widget.type = widgetType::text;
+		widget.colors = colors;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+		internal.widgetsVector.push_back({name, widget});
+	}
+
+	void RendererUi::InputText(std::string name, char* text, size_t textSizeWithNullChar,
+		gl2d::Color4f color, const gl2d::Texture texture)
+	{
+		name += internal.idStr;
+
+		Internal::Widget widget = {};
+		widget.type = widgetType::textInput;
+		widget.pointer = text;
+		widget.colors = color;
+		widget.textSize = textSizeWithNullChar;
+		widget.texture = texture;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+		internal.widgetsVector.push_back({name, widget});
+	}
+
+	void RendererUi::sliderFloat(std::string name, float *value, float min, float max,
+		gl2d::Texture sliderTexture, gl2d::Color4f sliderColor,
+		gl2d::Texture ballTexture, gl2d::Color4f ballColor)
+	{
+		name += internal.idStr;
+
+		Internal::Widget widget = {};
+		widget.type = widgetType::sliderFloatW;
+		widget.pointer = value;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+		widget.min = min;
+		widget.max = max;
+		widget.colors = sliderColor;
+		widget.colors2 = ballColor;
+		widget.texture = sliderTexture;
+		widget.textureOver = ballTexture;
+
+		internal.widgetsVector.push_back({name, widget});
+	}
+
+	void RendererUi::sliderInt(std::string name, int *value, int min, int max,
+		gl2d::Texture sliderTexture, gl2d::Color4f sliderColor, gl2d::Texture ballTexture, gl2d::Color4f ballColor)
+	{
+		name += internal.idStr;
+
+		Internal::Widget widget = {};
+		widget.type = widgetType::sliderIntW;
+		widget.pointer = value;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+		widget.minInt = min;
+		widget.maxInt = max;
+		widget.colors = sliderColor;
+		widget.colors2 = ballColor;
+		widget.texture = sliderTexture;
+		widget.textureOver = ballTexture;
+
+		internal.widgetsVector.push_back({name, widget});
+	}
+
+	void RendererUi::colorPicker(std::string name, float *color3Component, gl2d::Texture sliderTexture, gl2d::Texture ballTexture)
+	{
+		Internal::Widget widget = {};
+		widget.type = widgetType::colorPickerW;
+		widget.pointer = color3Component;
+		widget.texture = sliderTexture;
+		widget.textureOver = ballTexture;
+
+		internal.widgetsVector.push_back({name, widget});
+
+	}
+
+	void RendererUi::newColum(int id)
+	{
+		Internal::Widget widget = {};
+		widget.type = widgetType::newColumW;
+
+		internal.widgetsVector.push_back({"##$colum" + std::to_string(id), widget});
+	}
+
+	void RendererUi::PushId(int id)
+	{
+		char a = *(((char*)&id) + 0);
+		char b = *(((char*)&id) + 1);
+		char c = *(((char*)&id) + 2);
+		char d = *(((char*)&id) + 3);
+
+		internal.idStr.push_back('#');
+		internal.idStr.push_back('#');
+		internal.idStr.push_back(a);
+		internal.idStr.push_back(b);
+		internal.idStr.push_back(c);
+		internal.idStr.push_back(d);
+	}
+
+	void PushIdInternal(RendererUi &r, int id)
+	{
+		r.internal.idStr.push_back('#');
+		r.PushId(id);
+	}
+
+	void PopIdInternal(RendererUi &r)
+	{
+		r.PopId();
+
+		if (r.internal.idStr.empty())
+		{
+			errorFunc("More pops than pushes or inconsistent usage of begin end");
+			return;
+		}
+		else
+		{
+			if (r.internal.idStr.back() != '#')
+			{
+				errorFunc("Inconsistent usage of begin end push pop");
+				return;
+			}
+			r.internal.idStr.pop_back();
+		}
+	}
+
+	void RendererUi::PopId()
+	{
+		if (internal.idStr.size() < 6)
+		{
+			errorFunc("More pops than pushes or inconsistent usage of begin end");
+			return;
+		}
+
+		internal.idStr.pop_back();
+		internal.idStr.pop_back();
+		internal.idStr.pop_back();
+		internal.idStr.pop_back();
+		internal.idStr.pop_back();
+		internal.idStr.pop_back();
+	}
+
+	int hash(const std::string &s)
+	{
+		unsigned int h = 0;
+		int pos = 0;
+		for (const auto i : s)
+		{
+			h += i*pos;
+			pos += 1;
+			pos %= 10;
+		}
+		return h;
+	}
+
+	void RendererUi::BeginMenu(std::string name, const gl2d::Color4f colors, const gl2d::Texture texture)
+	{
+		Internal::Widget widget = {};
+		widget.type = widgetType::beginMenu;
+		widget.colors = colors;
+		widget.texture = texture;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+		internal.widgetsVector.push_back({name, widget});
+
+		PushIdInternal(*this, hash(name));
+	}
+
+	void RendererUi::EndMenu()
+	{
+		Internal::Widget widget = {};
+		widget.type = widgetType::endMenu;
+		widget.usedThisFrame = true;
+		widget.justCreated = true;
+		internal.widgetsVector.push_back({"", widget});
+
+		PopIdInternal(*this);
+	}
+
+	//todo change ids to be unsigned and long + better hahs function
+
+	void RendererUi::Begin(int id)
+	{
+		if (!idWasSet)
+		{
+			idWasSet = true;
+			currentId = id;
+		}
+		else
+		{
+			if (currentId == id)
+			{
+				errorFunc("Forgot to call renderFrame or more than one begin this frame");
+			}
+			else
+			{
+				errorFunc("More than one begin this frame");
+			}
+		}
+
+		//will still push even if id was set so we don't get errors from inconsistent pushes
+		PushIdInternal(*this, id);
+	}
+
+	void RendererUi::End()
+	{
+		PopIdInternal(*this);
+	}
+
+};