[SUTK] Added tests for Renderable's draw order updates

sutk/include/sutk/Renderable.hpp

@@ -25,6 +25,8 @@ namespace SUTK
 
 		// Called by UIDriver to reset the redraw flag
 		void setRedraw(com::Bool isRedraw) noexcept { m_isRedraw = isRedraw; }
+		// This must never be called outside of Renderable (at least for now)
+		void setDrawOrder(u32 drawOrder) { m_drawOrder = drawOrder;  m_isDrawOrderDirty = true; }
 
 	protected:
 		// Rendering Geometries (or Text) requires conversion from local coordinates to global coordinates (target rendering backend, SGE)
@@ -54,7 +56,6 @@ namespace SUTK
 
 		bool isDrawOrderDirty() const noexcept { return m_isDrawOrderDirty; }
 
-		void setDrawOrder(u32 drawOrder) { m_drawOrder = drawOrder;  m_isDrawOrderDirty = true; }
 		u32 getDrawOrder() const noexcept { return m_drawOrder; }
 
 		com::Bool isRedraw() const noexcept { return com::Bool { m_isRedraw || com::cast_away_const(this)->isDirty() || isDrawOrderDirty() }; }

sutk/include/sutk/RenderableContainer.hpp

@@ -13,6 +13,8 @@ namespace SUTK
 	private:
 		Renderable* m_renderable;
 
+		// This must never be called outside of the RenderableContainer and Renderable class
+		void setRenderable(Renderable* renderable) noexcept;
 	protected:
 
 		RenderableContainer(UIDriver& driver, Container* parent = nullptr, com::Bool isLayoutIgnore = com::Bool::False(), Layer layer = InvalidLayer) noexcept;
@@ -22,9 +24,8 @@ namespace SUTK
 		virtual void onParentResize(const Rect2Df& newRect, bool isPositionChanged, bool isSizeChanged) override;
 		virtual void onResize(const Rect2Df& newRect, bool isPositionChanged, bool isSizeChanged) override;
 		virtual void onAnscestorChange(Container* anscestor) noexcept override;
-
+		
 	public:
-		void setRenderable(Renderable* renderable) noexcept;
 		virtual Renderable* getRenderable() noexcept { return m_renderable; }
 	};
 }

sutk/source/Label.cpp

@@ -43,24 +43,29 @@ namespace SUTK
 		{
 			debug_log_info("Recreating Small Text due to reassociation");
 
-			// Disassociate old SmallText renderable from this Renderable Container
-			setRenderable(com::null_pointer<Renderable>());
+			// Save clonable data before destroying the m_text renderable (SmallText)
+			auto hAlign = m_text->getHorizontalAlignment();
+			auto vAlign = m_text->getVerticalAlignment();
+			auto data = m_text->getData();
+			auto color = m_text->getColor();
+			auto fontSize = m_text->getFontSize();
+			auto isActive = m_text->isActive();
+			auto font = m_text->getFont();
+
+			// Destroy the old SmallText renderable first as we can't associate a new Renderable to a RenderableContainer
+			// already associated with its old Renderable (SmallText)
+			getUIDriver().destroyRenderable<SmallText>(m_text);
 
 			// Create a new SmallText
 			SmallText* text = getUIDriver().createRenderable<SmallText>(this, textGroup);
-			text->setAlignment(m_text->getHorizontalAlignment(), m_text->getVerticalAlignment());
-			text->setData(m_text->getData());
-			text->setColor(m_text->getColor());
-			text->setFontSize(m_text->getFontSize());
-			text->setActive(m_text->isActive());
-			text->setFont(m_text->getFont());
-
-			// Destroy the old SmallText renderable
-			getUIDriver().destroyRenderable<SmallText>(m_text);
+			text->setAlignment(hAlign, vAlign);
+			text->setData(data);
+			text->setColor(color);
+			text->setFontSize(fontSize);
+			text->setActive(isActive);
+			text->setFont(font);
 
 			m_text = text;
-			// Update Renderable also, otherwise the new SubText renderable won't be able to get callbacks on this RenderableContainer (Label)
-			setRenderable(m_text);
 		}
 		m_textGroup = textGroup;
 	}

sutk/source/Renderable.cpp

@@ -10,7 +10,7 @@ namespace SUTK
 		{
 			// NOTE: We can't call RenderableContainer::getRenderable() here because it is virtual, and can be overriden
 			// And in that override, one may instantiate this Renderable() which will lead to non-terminating recursion!
-			com_assert(COM_DESCRIPTION(!container->m_renderable), "Only one Renderable is allowed per RenderableContainer");
+			com_assert(COM_DESCRIPTION(!container->m_renderable), "Only one Renderable is allowed per RenderableContainer, destroy the previous one first!");
 			container->setRenderable(this);
 		}
 		driver.addRenderable(this);
@@ -30,7 +30,6 @@ namespace SUTK
 
 	void Renderable::onAnscestorChange(Container* anscestor) noexcept
 	{
-		std::cout << "Draw Order Set: " << getContainer()->getDepth() << std::endl;
 		setDrawOrder(getContainer()->getDepth());
 	}
 

sutk/source/tests/auto_tests/test.Renderable.getDrawOrder.cpp

@@ -0,0 +1,117 @@
+#include <sutk/AutoTest.hpp>
+#include <sutk/Renderable.hpp>
+#include <sutk/UIDriver.hpp>
+
+namespace SUTK::AutoTests
+{
+	class DummyRenderable : public Renderable
+	{
+	public:
+		using Renderable::Renderable;
+
+		virtual bool isDirty() noexcept override { return false; }
+		virtual void update() noexcept override { }
+	};
+
+	class RenderableGetDrawOrder : public AutoTest
+	{
+	public:
+		// Inherit base constructors as it is
+		using AutoTest::AutoTest;
+		virtual TestResult run(SUTK::UIDriver* driver) override
+		{
+			// 1. Create Renderable -> it should automatically derive Draw Order from the RenderableContainer
+			// 2. RenderableContainer::setRenderable() -> must be private and user code shouldn't be able to call it directly
+			// 3. Renderable::setDrawOrder() -> must be private and user code shouldn't be able to call it directly
+			// 4. (Any Anscestor Container)::setParent() -> All the Renderables below and including the container should be able to update their Draw Order
+
+			Container* c1 = driver->createContainer<Container>();
+
+			Container* c2 = driver->createContainer<Container>(c1);
+			Container* c3 = driver->createContainer<Container>(c1);
+
+			RenderableContainer* c4 = driver->createContainer<RenderableContainer>(c2);
+			RenderableContainer* c5 = driver->createContainer<RenderableContainer>(c2);
+
+			Container* c6 = driver->createContainer<Container>(c4);
+
+			Container* c7 = driver->createContainer<Container>(c6);
+			RenderableContainer* c8 = driver->createContainer<RenderableContainer>(c6);
+
+			RenderableContainer* c9 = driver->createContainer<RenderableContainer>(c7);
+			RenderableContainer* c10 = driver->createContainer<RenderableContainer>(c7);
+
+			DummyRenderable* r4 = driver->createRenderable<DummyRenderable>(c4);
+			EXPECT_EQ(r4->getDrawOrder(), 2);
+			DummyRenderable* r5 = driver->createRenderable<DummyRenderable>(c5);
+			EXPECT_EQ(r5->getDrawOrder(), 2);
+			DummyRenderable* r8 = driver->createRenderable<DummyRenderable>(c8);
+			EXPECT_EQ(r8->getDrawOrder(), 4);
+			DummyRenderable* r9 = driver->createRenderable<DummyRenderable>(c9);
+			EXPECT_EQ(r9->getDrawOrder(), 5);
+			DummyRenderable* r10 = driver->createRenderable<DummyRenderable>(c10);
+			EXPECT_EQ(r10->getDrawOrder(), 5);
+
+			EXPECT_EQ(r4->getDrawOrder(), 2);
+			EXPECT_EQ(r5->getDrawOrder(), 2);
+			EXPECT_EQ(r8->getDrawOrder(), 4);
+			EXPECT_EQ(r9->getDrawOrder(), 5);
+			EXPECT_EQ(r10->getDrawOrder(), 5);
+
+			c1->setLayer(1000);
+
+			EXPECT_EQ(r4->getDrawOrder(), 1002);
+			EXPECT_EQ(r5->getDrawOrder(), 1002);
+			EXPECT_EQ(r8->getDrawOrder(), 1004);
+			EXPECT_EQ(r9->getDrawOrder(), 1005);
+			EXPECT_EQ(r10->getDrawOrder(), 1005);
+
+			c2->setParent(com::null_pointer<Container>());
+
+			EXPECT_EQ(r4->getDrawOrder(), 1);
+			EXPECT_EQ(r5->getDrawOrder(), 1);
+			EXPECT_EQ(r8->getDrawOrder(), 3);
+			EXPECT_EQ(r9->getDrawOrder(), 4);
+			EXPECT_EQ(r10->getDrawOrder(), 4);
+
+			c3->setLayer(2000);
+
+			c2->setParent(c3);
+
+			EXPECT_EQ(r4->getDrawOrder(), 2002);
+			EXPECT_EQ(r5->getDrawOrder(), 2002);
+			EXPECT_EQ(r8->getDrawOrder(), 2004);
+			EXPECT_EQ(r9->getDrawOrder(), 2005);
+			EXPECT_EQ(r10->getDrawOrder(), 2005);
+
+			c2->setParent(c1);
+
+			EXPECT_EQ(r4->getDrawOrder(), 1002);
+			EXPECT_EQ(r5->getDrawOrder(), 1002);
+			EXPECT_EQ(r8->getDrawOrder(), 1004);
+			EXPECT_EQ(r9->getDrawOrder(), 1005);
+			EXPECT_EQ(r10->getDrawOrder(), 1005);
+
+			driver->destroyRenderable(r4);
+			driver->destroyRenderable(r5);
+			driver->destroyRenderable(r8);
+			driver->destroyRenderable(r9);
+			driver->destroyRenderable(r10);
+
+			driver->destroyContainer(c10);
+			driver->destroyContainer(c9);
+			driver->destroyContainer(c8);
+			driver->destroyContainer(c7);
+			driver->destroyContainer(c6);
+			driver->destroyContainer(c5);
+			driver->destroyContainer(c4);
+			driver->destroyContainer(c3);
+			driver->destroyContainer(c2);
+			driver->destroyContainer(c1);
+
+			return TestResult::passed();
+		}
+	};
+
+	static RenderableGetDrawOrder instance("test.Renderable.getDrawOrder()", com::True);
+}