working at making a better visualizer

Pika/pluggins/pluggins/sushiViewer/sushiViewer.cpp

@@ -43,11 +43,22 @@ void SushiViewer::displaySushiTransformImgui(::sushi::Transform & e, glm::vec4 p
 
 		ImGui::Text("Transform element editor");
 
-		ImGui::Combo("Pos type", &copy.placementType, "Relative\0Absolute\0");
-		ImGui::Combo("Size type", &copy.dimensionsType, "Percentage\0Absolute\0");
-
-		ImGui::DragFloat2("Pos", &e.pos[0]);
-		ImGui::DragFloat2("Size", &e.size[0]);
+		ImGui::Combo("Anchor", &copy.anchorPoint, "topLeft"
+			"\0top Middle"
+			"\0top Right"
+			"\0middle Left"
+			"\0center"
+			"\0middle Right"
+			"\0bottom Left"
+			"\0bottom Middle"
+			"\0bottom Right"
+			"\0absolute\0");
+
+		ImGui::DragFloat2("Pos pixels", &e.positionPixels[0]);
+		ImGui::DragFloat2("Pos percentage", &e.positionPercentage[0], 0.01);
+
+		ImGui::DragFloat2("Size pixels", &e.sizePixels[0]);
+		ImGui::DragFloat2("Size percentage", &e.sizePercentage[0], 0.01);
 
 		e.changeSettings(copy, parent);
 
@@ -81,16 +92,17 @@ void SushiViewer::displaySushiParentElementImgui(::sushi::SushiParent &e, glm::v
 		ImGui::Separator();
 
 		sushi::Transform transform;
-		transform.relativeTransformPixelSize({10, 10, 100, 100});
+		transform.anchorPoint = sushi::Transform::center; 
+		transform.sizePercentage = glm::vec2(0.5f);
 
 		if (ImGui::Button("Add element"))
 		{
-			sushiContext.addElement(e, "New Element", transform, sushi::Background());
+			img.elementId = sushiContext.addElement(e, "New Element", transform, sushi::Background());
 		}
 
 		if (ImGui::Button("Add parent"))
 		{
-			sushiContext.addParent(e, "New Parent", transform, sushi::Background({0.5,0.2,0.2,1.f}));
+			img.elementId = sushiContext.addParent(e, "New Parent", transform, sushi::Background({0.5,0.2,0.2,1.f}));
 		}
 
 		ImGui::Separator();
@@ -197,22 +209,23 @@ void visitSelect(sushi::SushiParent &parent, unsigned int &id, sushi::SushiUiEle
 bool SushiViewer::update(pika::Input input, pika::WindowState windowState, RequestedContainerInfo &requestedInfo)
 {
 	bool leftCtrlHeld = input.buttons[pika::Button::LeftCtrl].held();
+	//bool shiftHeld = input.buttons[pika::Button::Shift].held();
 
 #pragma region update stuff
 	glClear(GL_COLOR_BUFFER_BIT);
 	renderer.updateWindowMetrics(windowState.windowW, windowState.windowH);
 
-	if (leftCtrlHeld)
+	//if (leftCtrlHeld)
 	{
 		sushi::SushiInput in;
 		in.mouseX = input.mouseX;
 		in.mouseY = input.mouseY;
 		sushiContext.update(renderer, in);
 	}
-	else
-	{
-		sushiContext.update(renderer, pika::toSushi(input));
-	}
+	//else
+	//{
+	//	sushiContext.update(renderer, pika::toSushi(input));
+	//}
 #pragma endregion
 
 
@@ -231,7 +244,7 @@ bool SushiViewer::update(pika::Input input, pika::WindowState windowState, Reque
 			img.elementId = c.root.id;
 		}
 		
-		if (leftCtrlHeld && input.lMouse.held())
+		if (input.lMouse.held())
 		{		
 			visitSelect(sushiContext.root, img.elementId, selectedElement, selectedParent,
 				{input.mouseX, input.mouseY});
@@ -275,17 +288,135 @@ bool SushiViewer::update(pika::Input input, pika::WindowState windowState, Reque
 	}
 	ImGui::End();
 
+	auto drawDisplacement = [&](glm::vec4 from, glm::vec4 to, glm::vec4 color)
+	{
+		if (to.x != from.x || to.y != from.y)
+		{
+			renderer.renderRectangle(to, color);
+
+			renderer.renderLine(to, from, color);
+		}
+		
+		renderer.renderRectangleOutline(from, color, 2.f);
+	};
+
+	auto drawGyzmos = [&](glm::vec4 pos, sushi::Transform &t, glm::vec4 parentPos)
+	{
+		//todo add alias render box
+		renderer.renderRectangleOutline(pos,
+			{0,1,0,0.5}, 4.0f);
+
+		glm::vec4 center = {glm::vec2(pos) + glm::vec2(pos.z, pos.w) / 2.f - glm::vec2(3,3), 
+			6.f,6.f};
+	
+		glm::vec4 originalCenter = center;
+		originalCenter.x -= t.positionPixels.x;
+		originalCenter.y -= t.positionPixels.y;
+
+		if (t.anchorPoint != sushi::Transform::anchor::absolute &&
+			(t.positionPixels.x != 0 || t.positionPixels.y != 0))
+		{
+			drawDisplacement(originalCenter, center, {0,1,0,0.5});
+		}
+		else
+		{
+			renderer.renderRectangleOutline(originalCenter, {0,1,0,0.5}, 2.f);
+		}
+				
+		glm::vec4 newCenter = {};
+
+		switch (t.anchorPoint)
+		{
+
+			case ::sushi::Transform::topLeft:
+			{
+				
+			}
+			break;
+
+			case ::sushi::Transform::topMiddle:
+			{
+				
+			}
+			break;
+
+			case ::sushi::Transform::toRight:
+			{
+				
+			}
+			break;
+
+			case ::sushi::Transform::middleLeft:
+			{
+				
+			}
+			break;
+
+			case ::sushi::Transform::center:
+			{
+				newCenter = {glm::vec2(parentPos)
+					+ glm::vec2(parentPos.z, parentPos.w) / 2.f - glm::vec2(3, 3), 6.f, 6.f};
+			}
+			break;
+
+			case ::sushi::Transform::middleRight:
+			{
+				
+			}
+			break;
+
+			case ::sushi::Transform::bottomLeft:
+			{
+				
+			}
+			break;
+
+			case ::sushi::Transform::bottomMiddle:
+			{
+				
+			}
+			break;
+
+			case ::sushi::Transform::bottomRight:
+			{
+				
+			}
+			break;
+
+			case ::sushi::Transform::absolute:
+			{
+
+				
+			}
+			break;
+		
+		}
+
+		drawDisplacement(newCenter, originalCenter, {0.8,0.5,0,0.5});
+
+
+	};
 
 	if (selectedElement)
 	{
-		renderer.renderRectangleOutline(selectedElement->outData.absTransform,
-			{1,0,0,0.5}, 4.0f);
+		glm::vec4 parentTransform = {0,0,renderer.windowW, renderer.windowH};
+
+		if (selectedParent) { parentTransform = selectedParent->outData.absTransform; }
+
+		drawGyzmos(selectedElement->outData.absTransform, selectedElement->transform, parentTransform);
+
+		if (selectedParent)
+		{
+			//todo add alias render box
+			renderer.renderRectangleOutline(selectedParent->outData.absTransform,
+				{0.5,0.5,0,0.5}, 4.0f);
+		}
+
 	}else
 	if (selectedParent)
 	{
 		//todo add alias render box
-		renderer.renderRectangleOutline(selectedParent->outData.absTransform, 
-			{1,0,0,0.5}, 4.0f);
+		drawGyzmos(selectedParent->outData.absTransform, selectedParent->transform, selectedParent->outData.absTransform);
 	}
 
 

Pika/resources/logs.txt

@@ -1,2 +1,2 @@
-#2023-09-06 18:05:02: Created container: SushiViewer
-#2023-09-06 18:06:51: Destroyed continer: SushiViewer #1
+#2023-09-06 19:36:18: Created container: SushiViewer
+#2023-09-06 19:36:37: Destroyed continer: SushiViewer #1

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

@@ -64,13 +64,13 @@ namespace sushi
 		void update(gl2d::Renderer2D &renderer, 
 			sushi::SushiInput &input);
 
-		void addElement(
+		unsigned int addElement(
 			SushiParent &parent,
 			const char *name,
 			Transform &transform,
 			Background &background);
 
-		void addParent(
+		unsigned int addParent(
 			SushiParent &parent,
 			const char *name,
 			Transform &transform,

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

@@ -9,47 +9,69 @@ namespace sushi
 
 	struct Transform
 	{
-		enum
-		{
-			RelativeTransform = 0,
-			AbsoluteTransform,
-		};
+		//enum
+		//{
+		//	RelativeTransform = 0,
+		//	AbsoluteTransform,
+		//};
+		//
+		//enum
+		//{
+		//	DimensionsPercentage = 0,
+		//	DimensionsPixelsAbsolute,
+		//};
+		//
+		//union
+		//{
+		//	glm::vec4 dimensions = {0,0,1,1};
+		//	struct
+		//	{
+		//		glm::vec2 pos;
+		//		glm::vec2 size;
+		//	};
+		//};
+		//
+		//int placementType = RelativeTransform;
+		//int dimensionsType = DimensionsPercentage;
 
-		enum
-		{
-			DimensionsPercentage = 0,
-			DimensionsPixelsAbsolute,
-		};
+		glm::vec2 sizePixels = {0,0};
+		glm::vec2 sizePercentage = {1,1};
 
-		union
+		glm::vec2 positionPixels = {};
+		glm::vec2 positionPercentage = {};
+
+		enum anchor
 		{
-			glm::vec4 dimensions = {0,0,1,1};
-			struct
-			{
-				glm::vec2 pos;
-				glm::vec2 size;
-			};
+			topLeft = 0,
+			topMiddle,
+			toRight,
+			middleLeft,
+			center,
+			middleRight,
+			bottomLeft,
+			bottomMiddle,
+			bottomRight,
+			absolute,
 		};
 
-		int placementType = RelativeTransform;
-		int dimensionsType = DimensionsPercentage;
+		int anchorPoint = topLeft;
 
-		void absoluteTransformPixelSize(glm::vec4 dimensions);
-		void relativeTransformPixelSize(glm::vec4 dimensions);
-		void relativeTransformDimensionsPercentage(glm::vec4 dimensions);
+		//void absoluteTransformPixelSize(glm::vec4 dimensions);
+		//void relativeTransformPixelSize(glm::vec4 dimensions);
+		//void relativeTransformDimensionsPercentage(glm::vec4 dimensions);
 
 		glm::vec4 applyTransform(glm::vec4 parent);
 
 		void changeSettings(Transform t, glm::vec4 parent)
 		{
 			//todo
-			this->placementType = t.placementType;
-			this->dimensionsType = t.dimensionsType;
+			//this->placementType = t.placementType;
+			//this->dimensionsType = t.dimensionsType;
+
+			anchorPoint = t.anchorPoint;
 		}
 	};
 
-	Transform defaultTransform();
-
 	struct Background
 	{
 		Background() {};

Pika/thirdparty/sushi/src/sushi.cpp

@@ -3,7 +3,7 @@
 namespace sushi
 {
 
-	void SushyContext::addElement(
+	unsigned int SushyContext::addElement(
 		SushiParent &parent,
 		const char *name,
 		Transform &transform,
@@ -17,9 +17,11 @@ namespace sushi
 		std::strncpy(element.name, name, sizeof(element.name) - 1);
 		
 		parent.allUiElements.push_back(element);
+
+		return currentIdCounter - 1;
 	}
 
-	void SushyContext::addParent(
+	unsigned int SushyContext::addParent(
 		SushiParent &parent,
 		const char *name,
 		Transform &transform,
@@ -33,6 +35,8 @@ namespace sushi
 		std::strncpy(newParent.name, name, sizeof(newParent.name) - 1);
 
 		parent.subElements.push_back(newParent);
+
+		return currentIdCounter - 1;
 	}
 
 	void SushyContext::createBasicSchene(int baseId, const char *name)

Pika/thirdparty/sushi/src/sushiPrimitives.cpp

@@ -1,4 +1,5 @@
 #include <sushi/sushiPrimitives.h>
+#include <cassert>
 
 namespace sushi
 {
@@ -18,26 +19,26 @@ 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;
-	}
-	
-	void Transform::relativeTransformDimensionsPercentage(glm::vec4 dimensions)
-	{
-		this->dimensions = dimensions;
-		placementType = RelativeTransform;
-		dimensionsType = DimensionsPercentage;
-	}
+	//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;
+	//}
+	//
+	//void Transform::relativeTransformDimensionsPercentage(glm::vec4 dimensions)
+	//{
+	//	this->dimensions = dimensions;
+	//	placementType = RelativeTransform;
+	//	dimensionsType = DimensionsPercentage;
+	//}
 
 	glm::vec4 Transform::applyTransform(glm::vec4 parent)
 	{
@@ -45,48 +46,154 @@ namespace sushi
 		const glm::vec2 parentSize = {parent.z, parent.w};
 
 		glm::vec2 pos = {};
-		glm::vec2 size = {};
+		glm::vec2 size = parentSize * sizePercentage + sizePixels;
 
-		switch (dimensionsType)
+		auto leftAlign = [&]()
 		{
-		case DimensionsPercentage:
-		{
-			size = glm::vec2(dimensions.z, dimensions.w) * parentSize;
-		}
-		break;
+			pos.x = parentPos.x;
+		};
 
-		case DimensionsPixelsAbsolute:
+		auto topAlign = [&]()
 		{
-			size = glm::vec2(dimensions.z, dimensions.w);
-		}
-		break;
-
-		default:
-		return {};
-		//todo special error functions
+			pos.y = parentPos.y;
 		};
 
-		//determine position;
-		switch (placementType)
+		auto middleXAlign = [&]()
 		{
-		case RelativeTransform:
+			pos.x = parentPos.x + (parentSize.x / 2.f) - (size.x / 2.f);
+		};
+
+		auto middleyAlign = [&]()
 		{
-			pos = parentPos + glm::vec2(dimensions);
-		}
-		break;
+			pos.y = parentPos.y + (parentSize.y / 2.f) - (size.y / 2.f);
+		};
 
-		case AbsoluteTransform:
+		auto rightAlign = [&]()
 		{
-			pos = glm::vec2(dimensions);
-		}
-		break;
+			pos.x = parentPos.x + parentSize.x - size.x;
+		};
 
-		default:
-		return {};
-		//todo special error functions
+		auto bottomAlign = [&]()
+		{
+			pos.y = parentPos.y + parentSize.y - size.y;
 		};
 
+		switch (anchorPoint)
+		{
+			case topLeft:
+			{
+				leftAlign();
+				topAlign();
+			}
+			break;
+
+			case topMiddle:
+			{
+				middleXAlign();
+				topAlign();
+			}
+			break;
+
+			case toRight:
+			{
+				rightAlign();
+				topAlign();
+			}
+			break;
+
+			case middleLeft:
+			{
+				leftAlign();
+				middleyAlign();
+			}
+			break;
+
+			case center:
+			{
+				middleXAlign();
+				middleyAlign();
+			}
+			break;
+
+			case middleRight:
+			{
+				rightAlign();
+				middleyAlign();
+			}
+			break;
+
+			case bottomLeft:
+			{
+				leftAlign();
+				bottomAlign();
+			}
+			break;
+
+			case bottomMiddle:
+			{
+				middleXAlign();
+				bottomAlign();
+			}
+			break;
+
+			case bottomRight:
+			{
+				rightAlign();
+				bottomAlign();
+			}
+			break;
+
+			case absolute:
+			{
+				
+				size = sizePixels;
+			}
+			break;
+			default:
+			//todo signal error in production
+			assert(0); //invalid anchor point
+			return {};
+		}
 
+		pos += positionPixels + parentSize * positionPercentage;
+		//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};
@@ -97,10 +204,4 @@ namespace sushi
 		renderer.renderRectangle(pos, color);
 	}
 
-	Transform defaultTransform()
-	{
-		Transform t;
-		t.relativeTransformDimensionsPercentage({0,0,1,1});
-		return Transform();
-	}
 };