Adding Display ratio

src/GDTFManager.cpp

@@ -2906,12 +2906,14 @@ GdtfGeometryDisplay::GdtfGeometryDisplay(GdtfGeometry* parent)
 					:GdtfGeometry(parent)
 {
 	fTexture = "";
+	fAspectRatio = 0;
 }
 
 GdtfGeometryDisplay::GdtfGeometryDisplay(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent) 
 					:GdtfGeometry(name,refToModel,ma, parent)
 {
-	fTexture = "";	
+	fTexture = "";
+	fAspectRatio = 0;
 }
 
 GdtfGeometryDisplay::~GdtfGeometryDisplay()
@@ -2928,12 +2930,56 @@ void GdtfGeometryDisplay::SetTexture(const TXString& texture)
 	fTexture = texture;
 }
 
+const double& GdtfGeometryDisplay::GetAspectRatio() const
+{
+	return fAspectRatio;
+}
+
+void GdtfGeometryDisplay::SetAspectRatio( const double& aspectRatio )
+{
+	fAspectRatio = aspectRatio;
+}
+
+const size_t& GdtfGeometryDisplay::GetWidth() const
+{
+	return fWidth;
+}
+
+void GdtfGeometryDisplay::SetWidth( size_t width )
+{
+	fWidth = width;
+}
+
+const size_t& GdtfGeometryDisplay::GetHeight() const
+{
+	return fHeight;
+}
+
+void GdtfGeometryDisplay::SetHeight( size_t height )
+{
+	fHeight = height;
+}
+
+void GdtfGeometryDisplay::SetIsCurved( const bool& isCurved )
+{
+	fIsCurved = isCurved;
+}
+
+void GdtfGeometryDisplay::GetIsCurved( bool& curvedRadius ) const
+{
+	curvedRadius = fIsCurved;
+}
+
 void GdtfGeometryDisplay::OnPrintToFile(IXMLFileNodePtr pNode) 
 {
 	//------------------------------------------------------------------------------------
 	// Call the parent
 	GdtfGeometry::OnPrintToFile(pNode);
-	pNode->SetNodeAttributeValue(XML_GDTF_DisplayTexture, fTexture);
+	pNode->SetNodeAttributeValue( XML_GDTF_DisplayTexture,		fTexture );
+	pNode->SetNodeAttributeValue( XML_GDTF_DisplayAspectRatio, 	GdtfConverter::ConvertDouble(fAspectRatio) );
+	pNode->SetNodeAttributeValue( XML_GDTF_DisplayWidth,		GdtfConverter::ConvertInteger(fWidth) );
+	pNode->SetNodeAttributeValue( XML_GDTF_DisplayHeight,		GdtfConverter::ConvertInteger( fHeight ) );
+	pNode->SetNodeAttributeValue( XML_GDTF_DisplayIsCurved,		fIsCurved ? "true" : "false" );
 }
 
 void GdtfGeometryDisplay::OnReadFromNode(const IXMLFileNodePtr& pNode)
@@ -2942,7 +2988,18 @@ void GdtfGeometryDisplay::OnReadFromNode(const IXMLFileNodePtr& pNode)
 	// Call the parent
 	GdtfGeometry::OnReadFromNode(pNode);
 
-	pNode->GetNodeAttributeValue(XML_GDTF_DisplayTexture, fTexture);
+	TXString width, height, aspectRatio, isCurved = "";
+
+	pNode->GetNodeAttributeValue( XML_GDTF_DisplayTexture, fTexture);
+	pNode->GetNodeAttributeValue( XML_GDTF_DisplayAspectRatio, aspectRatio );
+	pNode->GetNodeAttributeValue( XML_GDTF_DisplayWidth, width );
+	pNode->GetNodeAttributeValue( XML_GDTF_DisplayHeight, height );
+	pNode->GetNodeAttributeValue( XML_GDTF_DisplayIsCurved, isCurved );
+
+	GdtfConverter::ConvertInteger(	width,			pNode,		fWidth );
+	GdtfConverter::ConvertInteger(	height,			pNode,		fHeight );
+	GdtfConverter::ConvertDouble(	aspectRatio,	pNode,		fAspectRatio );
+	GdtfConverter::ConvertBool(		isCurved,		pNode,		fIsCurved );
 }
 
 void GdtfGeometryDisplay::OnErrorCheck(const IXMLFileNodePtr& pNode)

src/GDTFManager.h

@@ -951,10 +951,26 @@ namespace SceneData
 												~GdtfGeometryDisplay();
 	private:
 		TXString								fTexture;
+		size_t									fWidth;
+		size_t									fHeight;
+		double									fAspectRatio;
+		bool 									fIsCurved;
+
 	public:
 		virtual EGdtfObjectType					GetObjectType();
 		const TXString&							GetTexture();
+		void									GetIsCurved( bool& curvedRadius ) const;
+		const size_t&							GetHeight() const;
+		const size_t&							GetWidth() const;
+		const double&							GetAspectRatio() const;
+
 		void									SetTexture(const TXString& texture);
+		void									SetAspectRatio( const double& aspectRatio );
+		void									SetWidth( size_t width );
+		void 									SetHeight( size_t height );
+		void									SetIsCurved( const bool& isCurved );
+
+
 	protected:
 		virtual	TXString						GetNodeName();
 		virtual	void							OnPrintToFile(IXMLFileNodePtr pNode);

src/Implementation/CGdtfGeometry.cpp

@@ -983,6 +983,118 @@ VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetTexture(MvrStrin
 	return kVCOMError_NoError;
 }
 
+VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetAspectRatio(double& aspectRatio) 
+{
+	if(!fGeometry) return kVCOMError_Failed;
+
+	if( fGeometryType != EGdtfObjectType::eGdtfGeometryDisplay) return kVCOMError_Failed;
+
+	SceneData::GdtfGeometryDisplayPtr display = static_cast<SceneData::GdtfGeometryDisplayPtr>(fGeometry);
+	if(!display) return kVCOMError_Failed;
+
+	aspectRatio = display->GetAspectRatio();
+
+	return kVCOMError_NoError;
+}
+
+VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetAspectRatio(double aspectRatio)
+{
+	if (!fGeometry) return kVCOMError_NotInitialized;
+
+	if( fGeometryType != EGdtfObjectType::eGdtfGeometryDisplay) return kVCOMError_WrongGeometryType;
+
+	SceneData::GdtfGeometryDisplayPtr display = static_cast<SceneData::GdtfGeometryDisplayPtr>(fGeometry);
+	if(!display) return kVCOMError_Failed;
+
+	display->SetAspectRatio(aspectRatio);
+
+	return kVCOMError_NoError;
+}
+
+VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetWidth(size_t& width) 
+{
+	if(!fGeometry) return kVCOMError_Failed;
+
+	if( fGeometryType != EGdtfObjectType::eGdtfGeometryDisplay) return kVCOMError_Failed;
+
+	SceneData::GdtfGeometryDisplayPtr display = static_cast<SceneData::GdtfGeometryDisplayPtr>(fGeometry);
+	if(!display) return kVCOMError_Failed;
+
+	width = display->GetWidth();
+
+	return kVCOMError_NoError;
+}
+
+VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetWidth(size_t width)
+{
+	if (!fGeometry) return kVCOMError_NotInitialized;
+
+	if( fGeometryType != EGdtfObjectType::eGdtfGeometryDisplay) return kVCOMError_WrongGeometryType;
+
+	SceneData::GdtfGeometryDisplayPtr display = static_cast<SceneData::GdtfGeometryDisplayPtr>(fGeometry);
+	if(!display) return kVCOMError_Failed;
+
+	display->SetWidth(width);
+
+	return kVCOMError_NoError;
+}
+
+VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetHeight(size_t& height) 
+{
+	if(!fGeometry) return kVCOMError_Failed;
+
+	if( fGeometryType != EGdtfObjectType::eGdtfGeometryDisplay) return kVCOMError_Failed;
+
+	SceneData::GdtfGeometryDisplayPtr display = static_cast<SceneData::GdtfGeometryDisplayPtr>(fGeometry);
+	if(!display) return kVCOMError_Failed;
+
+	height = display->GetHeight();
+
+	return kVCOMError_NoError;
+}
+
+VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetHeight(size_t height)
+{
+	if (!fGeometry) return kVCOMError_NotInitialized;
+
+	if( fGeometryType != EGdtfObjectType::eGdtfGeometryDisplay) return kVCOMError_WrongGeometryType;
+
+	SceneData::GdtfGeometryDisplayPtr display = static_cast<SceneData::GdtfGeometryDisplayPtr>(fGeometry);
+	if(!display) return kVCOMError_Failed;
+
+	display->SetHeight(height);
+
+	return kVCOMError_NoError;
+}
+
+VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetIsCurved(bool& isCurved) 
+{
+	if(!fGeometry) return kVCOMError_Failed;
+
+	if( fGeometryType != EGdtfObjectType::eGdtfGeometryDisplay) return kVCOMError_Failed;
+
+	SceneData::GdtfGeometryDisplayPtr display = static_cast<SceneData::GdtfGeometryDisplayPtr>(fGeometry);
+	if(!display) return kVCOMError_Failed;
+
+	display->GetIsCurved(isCurved);
+
+	return kVCOMError_NoError;
+}
+
+VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetIsCurved(bool isCurved)
+{
+	if (!fGeometry) return kVCOMError_NotInitialized;
+
+	if( fGeometryType != EGdtfObjectType::eGdtfGeometryDisplay) return kVCOMError_WrongGeometryType;
+
+	SceneData::GdtfGeometryDisplayPtr display = static_cast<SceneData::GdtfGeometryDisplayPtr>(fGeometry);
+	if(!display) return kVCOMError_Failed;
+
+	display->SetIsCurved(isCurved);
+
+	return kVCOMError_NoError;
+}
+
 VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetCountLinkedDmxChannel(size_t& count, IGdtfDmxMode * forMode)
 {
 	// Get Count

src/Implementation/CGdtfGeometry.h

@@ -65,7 +65,16 @@ namespace VectorworksMVR
 
         // Display
 		virtual MvrString VCOM_CALLTYPE		GetTexture();
-		virtual VCOMError VCOM_CALLTYPE		SetTexture(MvrString texture);
+        virtual VCOMError VCOM_CALLTYPE		GetAspectRatio(double& aspectRatio);
+        virtual VCOMError VCOM_CALLTYPE		GetWidth( size_t& width );
+        virtual VCOMError VCOM_CALLTYPE		GetHeight( size_t& height );
+        virtual VCOMError VCOM_CALLTYPE     GetIsCurved( bool& isCurved );
+
+        virtual VCOMError VCOM_CALLTYPE		SetTexture(MvrString texture);
+        virtual VCOMError VCOM_CALLTYPE		SetAspectRatio(double aspectRatio);
+		virtual VCOMError VCOM_CALLTYPE		SetWidth( size_t width );
+		virtual VCOMError VCOM_CALLTYPE		SetHeight( size_t height );
+        virtual VCOMError VCOM_CALLTYPE     SetIsCurved( bool isCurved );
 
         // Helpers
         virtual VCOMError VCOM_CALLTYPE     GetCountLinkedDmxChannel(size_t& count, IGdtfDmxMode * forMode);

src/Include/IMediaRessourceVectorInterface.h

@@ -860,7 +860,16 @@ namespace VectorworksMVR
 
 		// Display
 		virtual MvrString VCOM_CALLTYPE		GetTexture() = 0;
+		virtual VCOMError VCOM_CALLTYPE		GetAspectRatio(double& aspectRatio) = 0;
+		virtual VCOMError VCOM_CALLTYPE		GetWidth( size_t& width ) = 0;
+		virtual VCOMError VCOM_CALLTYPE		GetHeight( size_t& height ) = 0;
+		virtual VCOMError VCOM_CALLTYPE     GetIsCurved( bool& isCurved ) = 0;
+
 		virtual VCOMError VCOM_CALLTYPE		SetTexture(MvrString texture) = 0;
+		virtual VCOMError VCOM_CALLTYPE		SetAspectRatio(double aspectRatio) = 0;
+		virtual VCOMError VCOM_CALLTYPE		SetWidth( size_t width ) = 0;
+		virtual VCOMError VCOM_CALLTYPE		SetHeight( size_t height ) = 0;
+		virtual VCOMError VCOM_CALLTYPE     SetIsCurved( bool isCurved ) = 0;
 
 		// GDTF 1.2
 		// Lamp

src/Prefix/CommonPrefix.h

@@ -452,6 +452,10 @@ const Sint32 kGDTF_CurrentMinorVersion = 2;
 
 #define XML_GDTF_DisplayNodeName                "Display"
 #define XML_GDTF_DisplayTexture                 "Texture"
+#define XML_GDTF_DisplayAspectRatio				"AspectRatio"
+#define XML_GDTF_DisplayWidth					"Width"
+#define XML_GDTF_DisplayHeight					"Height"
+#define XML_GDTF_DisplayIsCurved				"IsCurved"
 
 #define XML_GDTF_LaserProtocolNodeName          "Protocol"
 #define XML_GDTF_LaserProtocolName              "Name"

unittest/EmptyGeometryUnitTest.cpp

@@ -13,18 +13,28 @@ using namespace VectorworksMVR::GdtfDefines;
 #define __checkVCOM(x) this->checkVCOM(x, #x)
 #define __checkVCOM_NotSet(x) this->checkVCOM_NotSet(x, #x)
 
-GdtfEmptyModelTest::GdtfEmptyModelTest(const std::string& currentDir) : GdtfUnitTest(currentDir)
+GdtfEmptyModelTest::GdtfEmptyModelTest(const std::string& currentDir)
 {
 }
 
 GdtfEmptyModelTest::~GdtfEmptyModelTest()
 {  
 }
 
+bool GdtfEmptyModelTest::ExecuteTest()
+{
+    std::cout << "=                                    GdtfEmptyModelTest                         =" << std::endl;
 
-std::string GdtfEmptyModelTest::GetUnitTestName()
-{  
-    return  std::string("GdtfEmptyModel");
+	VectorworksMVR::IGdtfFixturePtr fixture( IID_IGdtfFixture );
+	fixture->OpenForWrite( "EmptyGeometryUnitTest", "MVR Group", MvrUUID(1,1,1,1) );
+
+    WriteFile(fixture);
+
+	fixture->Close();
+
+    ReadFile(fixture);
+
+    return true;
 }
 
 void GdtfEmptyModelTest::WriteFile(VectorworksMVR::IGdtfFixturePtr& fixture)
@@ -54,6 +64,11 @@ void GdtfEmptyModelTest::WriteFile(VectorworksMVR::IGdtfFixturePtr& fixture)
         IGdtfGeometryPtr geometry4;
         __checkVCOM(geometry1->CreateGeometry(EGdtfObjectType::eGdtfGeometryDisplay, "Geometry4", filledModel, STransformMatrix(), &geometry4));
         __checkVCOM(geometry4->SetTexture("Texture.png"));
+        __checkVCOM(geometry4->SetAspectRatio( 1.78 ));
+        __checkVCOM(geometry4->SetWidth(4700));
+        __checkVCOM(geometry4->SetHeight(2700));
+        __checkVCOM(geometry4->SetIsCurved(false));
+
 
         // Magnet
         IGdtfGeometryPtr geometry5;
@@ -200,6 +215,22 @@ void GdtfEmptyModelTest::ReadFile(VectorworksMVR::IGdtfFixturePtr& fixture)
 
         checkifEqual("Check Texture", geometry4->GetTexture(), "Texture.png");
 
+		double aspectRatio = 0.0;
+        geometry4->GetAspectRatio( aspectRatio );
+        checkifEqual("Check Aspect Ratio", aspectRatio, 1.78);
+
+		size_t width = 0;
+        geometry4->GetWidth( width );
+		checkifEqual( "Check Width", width, (size_t) 4700 );
+
+		size_t height = 0;
+        geometry4->GetHeight( height );
+		checkifEqual( "Check Height", height, (size_t) 2700 );
+
+		bool isCurved = false;
+		geometry4->GetIsCurved( isCurved );
+		checkifEqual( "Check IsCurved", isCurved, false );
+
         // Magnet
         IGdtfGeometryPtr geoMagnet;
         __checkVCOM(geometry1->GetInternalGeometryAt(3, &geoMagnet));

unittest/EmptyGeometryUnitTest.h

@@ -7,16 +7,16 @@
 #include "GdtfUnittestHandler.h"
 
 
-class GdtfEmptyModelTest : public GdtfUnitTest
+class GdtfEmptyModelTest : public Unittest
 {
 public:
     GdtfEmptyModelTest(const std::string& currentDir);
     virtual ~GdtfEmptyModelTest();
 protected:
-    std::string virtual GetUnitTestName() override;
+    bool virtual ExecuteTest();
 
 private:
-    void virtual WriteFile(VectorworksMVR::IGdtfFixturePtr& fixtureDuringRead) override;
-    void virtual ReadFile(VectorworksMVR::IGdtfFixturePtr& fixtureDuringWrite) override;
+    void WriteFile(VectorworksMVR::IGdtfFixturePtr& fixtureDuringRead);
+    void ReadFile(VectorworksMVR::IGdtfFixturePtr& fixtureDuringWrite);
 
 };

unittest/Unittest.cpp

@@ -265,6 +265,7 @@ void Unittest::checkifEqual(const std::string& check, const std::string& aspecte
 
 	fFailedTests.push_back(test);
 
+	std::cout << "Failed Test: " << test.fMessage << std::endl;
 };
 
 bool Unittest::checkVCOM(VectorworksMVR::VCOMError error, const std::string& check)

unittest/Utility.cpp

@@ -53,6 +53,7 @@ bool UnitTestUtil::GetFolderAppDataLocal(std::string& outPath)
 	if(!result) return false;
     std::wstring ws(buffer);
 	outPath = std::string(ws.begin(), ws.end());
+	std::cout << "AppData Local Folder: " << outPath << std::endl;
 
 #elif _LINUX
 	// LINUX_IMPLEMENTATION - done