diff --git a/.github/workflows/artifact.yml b/.github/workflows/artifact.yml index 8a9083e8..8baaa8c1 100644 --- a/.github/workflows/artifact.yml +++ b/.github/workflows/artifact.yml @@ -9,8 +9,8 @@ on: type: choice options: - ubuntu-22.04 - - windows-latest - - macos-latest + - windows-2022 + - macos-14 jobs: build_artifact: diff --git a/src/GDTFManager.cpp b/src/GDTFManager.cpp index 1431fccf..8cc1bccf 100644 --- a/src/GDTFManager.cpp +++ b/src/GDTFManager.cpp @@ -2220,6 +2220,15 @@ GdtfGeometryPtr GdtfGeometry::AddGeometrySupport(const TXString& name, GdtfModel return geo; } +GdtfGeometryPtr GdtfGeometry::AddGeometrySpeaker(const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma) +{ + GdtfGeometry* geo = new GdtfGeometrySpeaker(name, refToModel, ma, this); + + fInternalGeometries.push_back(geo); + + return geo; +} + GdtfGeometryPtr GdtfGeometry::AddGeometryMagnet(const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma) { GdtfGeometry* geo = new GdtfGeometryMagnet(name, refToModel, ma, this); @@ -2293,6 +2302,7 @@ void GdtfGeometry::OnReadFromNode(const IXMLFileNodePtr& pNode) else if (childNodeName == XML_GDTF_InventoryNodeName) { geometry = new GdtfGeometryInventory(this);} else if (childNodeName == XML_GDTF_StructureNodeName) { geometry = new GdtfGeometryStructure(this);} else if (childNodeName == XML_GDTF_SupportNodeName) { geometry = new GdtfGeometrySupport(this);} + else if (childNodeName == XML_GDTF_SpeakerNodeName) { geometry = new GdtfGeometrySpeaker(this);} else if (childNodeName == XML_GDTF_MagnetNodeName) { geometry = new GdtfGeometryMagnet(this);} else if (childNodeName == XML_GDTF_BreakNodeName) { hasBreak = true; } else if (childNodeName == XML_GDTF_LaserProtocolNodeName) { return; /* Laser Protocols are handled in the Laser OnReadFromNode function */ } @@ -2911,7 +2921,7 @@ GdtfGeometryDisplay::GdtfGeometryDisplay(GdtfGeometry* parent) GdtfGeometryDisplay::GdtfGeometryDisplay(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent) :GdtfGeometry(name,refToModel,ma, parent) { - fTexture = ""; + fTexture = ""; } GdtfGeometryDisplay::~GdtfGeometryDisplay() @@ -2928,12 +2938,45 @@ void GdtfGeometryDisplay::SetTexture(const TXString& texture) fTexture = texture; } +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_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 +2985,16 @@ void GdtfGeometryDisplay::OnReadFromNode(const IXMLFileNodePtr& pNode) // Call the parent GdtfGeometry::OnReadFromNode(pNode); - pNode->GetNodeAttributeValue(XML_GDTF_DisplayTexture, fTexture); + TXString width, height, isCurved = ""; + + pNode->GetNodeAttributeValue( XML_GDTF_DisplayTexture, fTexture); + 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::ConvertBool( isCurved, pNode, fIsCurved ); } void GdtfGeometryDisplay::OnErrorCheck(const IXMLFileNodePtr& pNode) @@ -4264,6 +4316,203 @@ TXString GdtfGeometrySupport::GetNodeName() return XML_GDTF_SupportNodeName; } +//------------------------------------------------------------------------------------ +// GdtfGeometrySpeaker +GdtfGeometrySpeaker::GdtfGeometrySpeaker(GdtfGeometry* parent) + :GdtfGeometry(parent) +{ + fFrequencyMin = 0; + fFrequencyMax = 0; + fMaxSPL = 0; + fImpedance = 0; + fSoundAngleRotationMax = 0; + fVerticalCoverageUp = 0; + fVerticalCoverageDown = 0; + fHorizontalCoverageLeft = 0; + fHorizontalCoverageRight= 0; +} + +GdtfGeometrySpeaker::GdtfGeometrySpeaker(const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma, GdtfGeometry* parent) + :GdtfGeometry(name, refToModel, ma, parent) +{ + fFrequencyMin = 0; + fFrequencyMax = 0; + fMaxSPL = 0; + fImpedance = 0; + fSoundAngleRotationMax = 0; + fVerticalCoverageUp = 0; + fVerticalCoverageDown = 0; + fHorizontalCoverageLeft = 0; + fHorizontalCoverageRight= 0; +} + +GdtfGeometrySpeaker::~GdtfGeometrySpeaker() +{ +} + +double GdtfGeometrySpeaker::GetFrequencyMin() const +{ + return fFrequencyMin; +} + +double GdtfGeometrySpeaker::GetFrequencyMax() const +{ + return fFrequencyMax; +} + +double GdtfGeometrySpeaker::GetMaxSPL() const +{ + return fMaxSPL; +} + +double GdtfGeometrySpeaker::GetImpedance() const +{ + return fImpedance; +} + +double GdtfGeometrySpeaker::GetSoundAngleRotationMax() const +{ + return fSoundAngleRotationMax; +} + +double GdtfGeometrySpeaker::GetVerticalCoverageUp() const +{ + return fVerticalCoverageUp; +} + +double GdtfGeometrySpeaker::GetVerticalCoverageDown() const +{ + return fVerticalCoverageDown; +} + +double GdtfGeometrySpeaker::GetHorizontalCoverageLeft() const +{ + return fHorizontalCoverageLeft; +} + +double GdtfGeometrySpeaker::GetHorizontalCoverageRight() const +{ + return fHorizontalCoverageRight; +} + +void GdtfGeometrySpeaker::SetFrequencyMin(double frequencyMin) +{ + fFrequencyMin = frequencyMin; +} + +void GdtfGeometrySpeaker::SetFrequencyMax(double frequencyMax) +{ + fFrequencyMax = frequencyMax; +} + +void GdtfGeometrySpeaker::SetMaxSPL(double maxSPL) +{ + fMaxSPL = maxSPL; +} + +void GdtfGeometrySpeaker::SetImpedance(double impedance) +{ + fImpedance = impedance; +} + +void GdtfGeometrySpeaker::SetSoundAngleRotationMax(double soundAngleRotationMax) +{ + fSoundAngleRotationMax = soundAngleRotationMax; +} + +void GdtfGeometrySpeaker::SetVerticalCoverageUp(double verticalCoverageUp) +{ + fVerticalCoverageUp = verticalCoverageUp; +} + +void GdtfGeometrySpeaker::SetVerticalCoverageDown(double verticalCoverageDown) +{ + fVerticalCoverageDown = verticalCoverageDown; +} + +void GdtfGeometrySpeaker::SetHorizontalCoverageLeft(double horizontalCoverageLeft) +{ + fHorizontalCoverageLeft = horizontalCoverageLeft; +} + +void GdtfGeometrySpeaker::SetHorizontalCoverageRight(double horizontalCoverageRight) +{ + fHorizontalCoverageRight = horizontalCoverageRight; +} + +void GdtfGeometrySpeaker::OnPrintToFile(IXMLFileNodePtr pNode) +{ + //------------------------------------------------------------------------------------ + // Call the parent + GdtfGeometry::OnPrintToFile(pNode); + + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerFrequencyMin, GdtfConverter::ConvertDouble(fFrequencyMin)); + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerFrequencyMax, GdtfConverter::ConvertDouble(fFrequencyMax)); + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerMaxSPL, GdtfConverter::ConvertDouble(fMaxSPL)); + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerImpedance, GdtfConverter::ConvertDouble(fImpedance)); + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerSoundAngleRotationMax, GdtfConverter::ConvertDouble(fSoundAngleRotationMax)); + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerVerticalCoverageUp, GdtfConverter::ConvertDouble(fVerticalCoverageUp)); + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerVerticalCoverageDown, GdtfConverter::ConvertDouble(fVerticalCoverageDown)); + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerHorizontalCoverageLeft, GdtfConverter::ConvertDouble(fHorizontalCoverageLeft)); + pNode->SetNodeAttributeValue(XML_GDTF_SpeakerHorizontalCoverageRight, GdtfConverter::ConvertDouble(fHorizontalCoverageRight)); +} + +void GdtfGeometrySpeaker::OnReadFromNode(const IXMLFileNodePtr& pNode) +{ + //------------------------------------------------------------------------------------ + // Call the parent + GdtfGeometry::OnReadFromNode(pNode); + + TXString frequencyMin; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerFrequencyMin, frequencyMin); GdtfConverter::ConvertDouble(frequencyMin, pNode, fFrequencyMin); + TXString frequencyMax; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerFrequencyMax, frequencyMax); GdtfConverter::ConvertDouble(frequencyMax, pNode, fFrequencyMax); + TXString maxSPL; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerMaxSPL, maxSPL); GdtfConverter::ConvertDouble(maxSPL, pNode, fMaxSPL); + TXString impedance; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerImpedance, impedance); GdtfConverter::ConvertDouble(impedance, pNode, fImpedance); + TXString soundAngleRotationMax; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerSoundAngleRotationMax, soundAngleRotationMax); GdtfConverter::ConvertDouble(soundAngleRotationMax, pNode, fSoundAngleRotationMax); + TXString verticalCoverageUp; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerVerticalCoverageUp, verticalCoverageUp); GdtfConverter::ConvertDouble(verticalCoverageUp, pNode, fVerticalCoverageUp); + TXString verticalCoverageDown; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerVerticalCoverageDown, verticalCoverageDown); GdtfConverter::ConvertDouble(verticalCoverageDown, pNode, fVerticalCoverageDown); + TXString horizontalCoverageLeft; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerHorizontalCoverageLeft, horizontalCoverageLeft); GdtfConverter::ConvertDouble(horizontalCoverageLeft, pNode, fHorizontalCoverageLeft); + TXString horizontalCoverageRight; pNode->GetNodeAttributeValue(XML_GDTF_SpeakerHorizontalCoverageRight, horizontalCoverageRight); GdtfConverter::ConvertDouble(horizontalCoverageRight, pNode, fHorizontalCoverageRight); +} + +void GdtfGeometrySpeaker::OnErrorCheck(const IXMLFileNodePtr& pNode) +{ + //------------------------------------------------------------------------------------ + // Call the parent + GdtfObject::OnErrorCheck(pNode); + + //------------------------------------------------------------------------------------ + // Create needed and optional Attribute Arrays + TXStringArray needed; + TXStringArray optional; + needed.push_back(XML_GDTF_GeometryName); + optional.push_back(XML_GDTF_GeometryModelRef); + needed.push_back(XML_GDTF_GeometryMatrix); + + needed.push_back(XML_GDTF_SpeakerFrequencyMin); + needed.push_back(XML_GDTF_SpeakerFrequencyMax); + needed.push_back(XML_GDTF_SpeakerMaxSPL); + needed.push_back(XML_GDTF_SpeakerImpedance); + needed.push_back(XML_GDTF_SpeakerSoundAngleRotationMax); + needed.push_back(XML_GDTF_SpeakerVerticalCoverageUp); + needed.push_back(XML_GDTF_SpeakerVerticalCoverageDown); + needed.push_back(XML_GDTF_SpeakerHorizontalCoverageLeft); + needed.push_back(XML_GDTF_SpeakerHorizontalCoverageRight); + + //------------------------------------------------------------------------------------ + // Check Attributes for node + GdtfParsingError::CheckNodeAttributes(pNode, needed, optional); +} + +EGdtfObjectType GdtfGeometrySpeaker::GetObjectType() +{ + return EGdtfObjectType::eGdtfGeometrySpeaker; +} + +TXString GdtfGeometrySpeaker::GetNodeName() +{ + return XML_GDTF_SpeakerNodeName; +} + //------------------------------------------------------------------------------------ // GdtfGeometryMagnet GdtfGeometryMagnet::GdtfGeometryMagnet(GdtfGeometry* parent) @@ -5573,7 +5822,14 @@ const TXString& GdtfDmxChannel::GetName() TXString dmxChannelName; if(fGeomRef) { dmxChannelName += fGeomRef->GetName(); } dmxChannelName += "_"; - if(fLogicalChannels.size() > 0) { dmxChannelName += fLogicalChannels[0]->GetAttribute()->GetName(); } + if(fLogicalChannels.size() > 0) + { + auto attr = fLogicalChannels[ 0 ]->GetAttribute(); + if ( attr != nullptr ) + { + dmxChannelName += attr->GetName(); + } + } this->SetName(dmxChannelName); @@ -9671,6 +9927,7 @@ void GdtfFixture::OnReadFromNode(const IXMLFileNodePtr& pNode) else if (childNodeName == XML_GDTF_InventoryNodeName) { geometry = new GdtfGeometryInventory(nullptr);} else if (childNodeName == XML_GDTF_StructureNodeName) { geometry = new GdtfGeometryStructure(nullptr);} else if (childNodeName == XML_GDTF_SupportNodeName) { geometry = new GdtfGeometrySupport(nullptr);} + else if (childNodeName == XML_GDTF_SpeakerNodeName) { geometry = new GdtfGeometrySpeaker(nullptr);} else if (childNodeName == XML_GDTF_MagnetNodeName) { geometry = new GdtfGeometryMagnet(nullptr);} else { DSTOP((kEveryone,"There is a node that was not expected!")); } @@ -10051,6 +10308,15 @@ GdtfGeometryPtr GdtfFixture::AddGeometrySupport(const TXString& name, GdtfModelP return geo; } +GdtfGeometryPtr GdtfFixture::AddGeometrySpeaker(const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma) +{ + GdtfGeometry* geo = new GdtfGeometrySpeaker(name, refToModel, ma, nullptr); + + fGeometries.push_back(geo); + + return geo; +} + GdtfGeometryPtr GdtfFixture::AddGeometryMagnet(const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma) { GdtfGeometry* geo = new GdtfGeometryMagnet(name, refToModel, ma, nullptr); diff --git a/src/GDTFManager.h b/src/GDTFManager.h index 9820bf6b..0f77579b 100644 --- a/src/GDTFManager.h +++ b/src/GDTFManager.h @@ -810,6 +810,7 @@ namespace SceneData GdtfGeometry* AddGeometryInventory( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); GdtfGeometry* AddGeometryStructure( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); GdtfGeometry* AddGeometrySupport( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); + GdtfGeometry* AddGeometrySpeaker( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); GdtfGeometry* AddGeometryMagnet( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); protected: @@ -963,10 +964,23 @@ namespace SceneData ~GdtfGeometryDisplay(); private: TXString fTexture; + size_t fWidth; + size_t fHeight; + bool fIsCurved; + public: virtual EGdtfObjectType GetObjectType(); const TXString& GetTexture(); + void GetIsCurved( bool& curvedRadius ) const; + const size_t& GetHeight() const; + const size_t& GetWidth() const; + void SetTexture(const TXString& texture); + void SetWidth( size_t width ); + void SetHeight( size_t height ); + void SetIsCurved( const bool& isCurved ); + + protected: virtual TXString GetNodeName(); virtual void OnPrintToFile(IXMLFileNodePtr pNode); @@ -1316,6 +1330,58 @@ namespace SceneData }; typedef GdtfGeometrySupport* GdtfGeometrySupportPtr; + class GdtfGeometrySpeaker : public GdtfGeometry + { + public: + GdtfGeometrySpeaker(GdtfGeometry* parent); + GdtfGeometrySpeaker(const TXString& name, GdtfModelPtr refToModel,const VWTransformMatrix& ma, GdtfGeometry* parent); + + ~GdtfGeometrySpeaker(); + + private: + double fFrequencyMin; + double fFrequencyMax; + double fMaxSPL; + double fImpedance; + double fSoundAngleRotationMax; + double fVerticalCoverageUp; + double fVerticalCoverageDown; + double fHorizontalCoverageLeft; + double fHorizontalCoverageRight; + + public: + virtual EGdtfObjectType GetObjectType(); + + // Getters + double GetFrequencyMin() const; + double GetFrequencyMax() const; + double GetMaxSPL() const; + double GetImpedance() const; + double GetSoundAngleRotationMax() const; + double GetVerticalCoverageUp() const; + double GetVerticalCoverageDown() const; + double GetHorizontalCoverageLeft() const; + double GetHorizontalCoverageRight() const; + + // Setters + void SetFrequencyMin(double frequencyMin); + void SetFrequencyMax(double frequencyMax); + void SetMaxSPL(double maxSPL); + void SetImpedance(double impedance); + void SetSoundAngleRotationMax(double soundAngleRotationMax); + void SetVerticalCoverageUp(double verticalCoverageUp); + void SetVerticalCoverageDown(double verticalCoverageDown); + void SetHorizontalCoverageLeft(double horizontalCoverageLeft); + void SetHorizontalCoverageRight(double horizontalCoverageRight); + + protected: + virtual TXString GetNodeName(); + virtual void OnPrintToFile(IXMLFileNodePtr pNode); + virtual void OnReadFromNode(const IXMLFileNodePtr& pNode); + virtual void OnErrorCheck(const IXMLFileNodePtr& pNode); + }; + typedef GdtfGeometrySpeaker* GdtfGeometrySpeakerPtr; + class GdtfGeometryMagnet : public GdtfGeometry { public: @@ -2913,6 +2979,7 @@ namespace SceneData GdtfGeometryPtr AddGeometryWiringObject( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); GdtfGeometryPtr AddGeometryInventory( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); GdtfGeometryPtr AddGeometryStructure( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); + GdtfGeometryPtr AddGeometrySpeaker( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); GdtfGeometryPtr AddGeometrySupport( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); GdtfGeometryPtr AddGeometryMagnet( const TXString& name, GdtfModelPtr refToModel, const VWTransformMatrix& ma); diff --git a/src/Implementation/CGdtfFixture.cpp b/src/Implementation/CGdtfFixture.cpp index e6a6e92b..ae20eab2 100755 --- a/src/Implementation/CGdtfFixture.cpp +++ b/src/Implementation/CGdtfFixture.cpp @@ -1040,6 +1040,7 @@ VectorworksMVR::VCOMError VectorworksMVR::CGdtfFixtureImpl::CreateGeometry(EGdtf case eGdtfGeometryInventory: gdtfGeometry = fFixtureObject->AddGeometryInventory( vwName, scModel, ma); break; case eGdtfGeometryStructure: gdtfGeometry = fFixtureObject->AddGeometryStructure( vwName, scModel, ma); break; case eGdtfGeometrySupport: gdtfGeometry = fFixtureObject->AddGeometrySupport( vwName, scModel, ma); break; + case eGdtfGeometrySpeaker: gdtfGeometry = fFixtureObject->AddGeometrySpeaker( vwName, scModel, ma); break; case eGdtfGeometryMagnet: gdtfGeometry = fFixtureObject->AddGeometryMagnet( vwName, scModel, ma); break; case eGdtfGeometry: gdtfGeometry = fFixtureObject->AddGeometry( vwName, scModel, ma); break; diff --git a/src/Implementation/CGdtfGeometry.cpp b/src/Implementation/CGdtfGeometry.cpp index abb6012f..cb805cd3 100644 --- a/src/Implementation/CGdtfGeometry.cpp +++ b/src/Implementation/CGdtfGeometry.cpp @@ -245,6 +245,7 @@ VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::CreateGeometry(EGdt case eGdtfGeometryInventory: gdtfGeometry = fGeometry->AddGeometryInventory( vwName, scModel, ma); break; case eGdtfGeometryStructure: gdtfGeometry = fGeometry->AddGeometryStructure( vwName, scModel, ma); break; case eGdtfGeometrySupport: gdtfGeometry = fGeometry->AddGeometrySupport( vwName, scModel, ma); break; + case eGdtfGeometrySpeaker: gdtfGeometry = fGeometry->AddGeometrySpeaker( vwName, scModel, ma); break; case eGdtfGeometryMagnet: gdtfGeometry = fGeometry->AddGeometryMagnet( vwName, scModel, ma); break; case eGdtfGeometry: gdtfGeometry = fGeometry->AddGeometry( vwName, scModel, ma); break; @@ -983,6 +984,90 @@ VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetTexture(MvrStrin 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(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(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(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(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(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(fGeometry); + if(!display) return kVCOMError_Failed; + + display->SetIsCurved(isCurved); + + return kVCOMError_NoError; +} + VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetCountLinkedDmxChannel(size_t& count, IGdtfDmxMode * forMode) { // Get Count @@ -2858,6 +2943,279 @@ VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetResistanceZZ(dou return kVCOMError_NoError; } +//--------------------------------------------------------------------------- +// Speaker + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetFrequencyMin(double& frequencyMin) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + frequencyMin = speaker->GetFrequencyMin(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetFrequencyMax(double& frequencyMax) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + frequencyMax = speaker->GetFrequencyMax(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetMaxSPL(double& maxSPL) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + maxSPL = speaker->GetMaxSPL(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetImpedance(double& impedance) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + impedance = speaker->GetImpedance(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetSoundAngleRotationMax(double& soundAngleRotationMax) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + soundAngleRotationMax = speaker->GetSoundAngleRotationMax(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetVerticalCoverageUp(double& verticalCoverageUp) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + verticalCoverageUp = speaker->GetVerticalCoverageUp(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetVerticalCoverageDown(double& verticalCoverageDown) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + verticalCoverageDown = speaker->GetVerticalCoverageDown(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetHorizontalCoverageLeft(double& horizontalCoverageLeft) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + horizontalCoverageLeft = speaker->GetHorizontalCoverageLeft(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::GetHorizontalCoverageRight(double& horizontalCoverageRight) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if (fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + horizontalCoverageRight = speaker->GetHorizontalCoverageRight(); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetFrequencyMin(double frequencyMin) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetFrequencyMin(frequencyMin); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetFrequencyMax(double frequencyMax) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetFrequencyMax(frequencyMax); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetMaxSPL(double maxSPL) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetMaxSPL(maxSPL); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetImpedance(double impedance) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetImpedance(impedance); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetSoundAngleRotationMax(double soundAngleRotationMax) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetSoundAngleRotationMax(soundAngleRotationMax); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetVerticalCoverageUp(double verticalCoverageUp) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetVerticalCoverageUp(verticalCoverageUp); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetVerticalCoverageDown(double verticalCoverageDown) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetVerticalCoverageDown(verticalCoverageDown); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetHorizontalCoverageLeft(double horizontalCoverageLeft) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetHorizontalCoverageLeft(horizontalCoverageLeft); + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CGdtfGeometryImpl::SetHorizontalCoverageRight(double horizontalCoverageRight) +{ + // Check Pointer + if(!fGeometry) return kVCOMError_NotInitialized; + + // Check if it is the right type + if(fGeometryType != EGdtfObjectType::eGdtfGeometrySpeaker) return kVCOMError_WrongGeometryType; + + SceneData::GdtfGeometrySpeakerPtr speaker = static_cast(fGeometry); + if(!speaker) {return kVCOMError_Failed;} + + speaker->SetHorizontalCoverageRight(horizontalCoverageRight); + return kVCOMError_NoError; +} + //--------------------------------------------------------------------------- void VectorworksMVR::CGdtfGeometryImpl::SetPointer(SceneData::GdtfGeometry* geometry) { @@ -2881,6 +3239,7 @@ void VectorworksMVR::CGdtfGeometryImpl::SetPointer(SceneData::GdtfGeometry* geom fGeometryType == EGdtfObjectType::eGdtfGeometryInventory || fGeometryType == EGdtfObjectType::eGdtfGeometryStructure || fGeometryType == EGdtfObjectType::eGdtfGeometrySupport || + fGeometryType == EGdtfObjectType::eGdtfGeometrySpeaker || fGeometryType == EGdtfObjectType::eGdtfGeometryMagnet); } diff --git a/src/Implementation/CGdtfGeometry.h b/src/Implementation/CGdtfGeometry.h index 24c168ed..adf35bc7 100644 --- a/src/Implementation/CGdtfGeometry.h +++ b/src/Implementation/CGdtfGeometry.h @@ -65,7 +65,14 @@ namespace VectorworksMVR // Display virtual MvrString VCOM_CALLTYPE GetTexture(); - virtual VCOMError VCOM_CALLTYPE SetTexture(MvrString texture); + 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 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); @@ -191,6 +198,27 @@ namespace VectorworksMVR virtual VCOMError VCOM_CALLTYPE SetResistanceYY(double resistanceYY); virtual VCOMError VCOM_CALLTYPE SetResistanceZZ(double resistanceZZ); + // Speaker + virtual VCOMError VCOM_CALLTYPE GetFrequencyMin(double& frequencyMin); + virtual VCOMError VCOM_CALLTYPE GetFrequencyMax(double& frequencyMax); + virtual VCOMError VCOM_CALLTYPE GetMaxSPL(double& maxSPL); + virtual VCOMError VCOM_CALLTYPE GetImpedance(double& impedance); + virtual VCOMError VCOM_CALLTYPE GetSoundAngleRotationMax(double& soundAngleRotationMax); + virtual VCOMError VCOM_CALLTYPE GetVerticalCoverageUp(double& verticalCoverageUp); + virtual VCOMError VCOM_CALLTYPE GetVerticalCoverageDown(double& verticalCoverageDown); + virtual VCOMError VCOM_CALLTYPE GetHorizontalCoverageLeft(double& horizontalCoverageLeft); + virtual VCOMError VCOM_CALLTYPE GetHorizontalCoverageRight(double& horizontalCoverageRight); + + virtual VCOMError VCOM_CALLTYPE SetFrequencyMin(double frequencyMin); + virtual VCOMError VCOM_CALLTYPE SetFrequencyMax(double frequencyMax); + virtual VCOMError VCOM_CALLTYPE SetMaxSPL(double maxSPL); + virtual VCOMError VCOM_CALLTYPE SetImpedance(double impedance); + virtual VCOMError VCOM_CALLTYPE SetSoundAngleRotationMax(double soundAngleRotationMax); + virtual VCOMError VCOM_CALLTYPE SetVerticalCoverageUp(double verticalCoverageUp); + virtual VCOMError VCOM_CALLTYPE SetVerticalCoverageDown(double verticalCoverageDown); + virtual VCOMError VCOM_CALLTYPE SetHorizontalCoverageLeft(double horizontalCoverageLeft); + virtual VCOMError VCOM_CALLTYPE SetHorizontalCoverageRight(double horizontalCoverageRight); + virtual VCOMError VCOM_CALLTYPE BindToObject(void* objAddr); virtual void* VCOM_CALLTYPE GetBoundObject(); diff --git a/src/Implementation/CMediaRessourceVectorImpl.cpp b/src/Implementation/CMediaRessourceVectorImpl.cpp index 7fa782e3..22389c76 100644 --- a/src/Implementation/CMediaRessourceVectorImpl.cpp +++ b/src/Implementation/CMediaRessourceVectorImpl.cpp @@ -976,6 +976,208 @@ VectorworksMVR::VCOMError VectorworksMVR::CMediaRessourceVectorImpl::CreateProje return kVCOMError_NoError; } +VectorworksMVR::VCOMError VectorworksMVR::CMediaRessourceVectorImpl::CreateListeningPlane(const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outlisteningPlane) +{ + //--------------------------------------------------------------------------- + // Read Container + CSceneObjImpl* pContainer = static_cast(addToContainer); + + ASSERTN(kEveryone, pContainer != nullptr); + if ( ! pContainer) { return kVCOMError_NoValidContainerObj; } + + + SceneData::SceneDataObjWithMatrixPtr obj = nullptr; + ESceneObjType type = ESceneObjType::Layer; + pContainer->GetPointer(obj, type); + + if( ! VectorworksMVR::MvrUtil::isContainerType(type)) { return kVCOMError_NoValidContainerObj; } + + SceneData::SceneDataGroupObjPtr group = static_cast(obj); + + ASSERTN(kEveryone, group != nullptr); + if ( ! group) { return kVCOMError_NoValidContainerObj; } + + //--------------------------------------------------------------------------- + // Create the obj + VWFC::Tools::VWUUID uuid (guid.a,guid.b,guid.c,guid.d); + TXString nameStr ( name ); + + VWTransformMatrix ma; + GdtfUtil::ConvertMatrix(offset, ma); + + SceneData::SceneDataListeningPlaneObjPtr ptr = fExchangeObj.CreateListeningPlane(uuid, ma, nameStr, group); + + //--------------------------------------------------------------------------- + // Initialize Object + CSceneObjImpl* pListeningPlane = nullptr; + + // Query Interface + if (VCOM_SUCCEEDED(VWQueryInterface(IID_SceneObject, (IVWUnknown**) & pListeningPlane))) + { + // Check Casting + CSceneObjImpl* pResultInterface = static_cast(pListeningPlane); + if (pResultInterface) + { + pResultInterface->SetPointer(ptr, GetExchangeObj()); + } + else + { + pResultInterface->Release(); + pResultInterface = nullptr; + return kVCOMError_NoInterface; + } + } + + //--------------------------------------------------------------------------- + // Check Incoming Object + if (*outlisteningPlane) + { + (*outlisteningPlane)->Release(); + *outlisteningPlane = NULL; + } + + //--------------------------------------------------------------------------- + // Set Out Value + *outlisteningPlane = pListeningPlane; + + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CMediaRessourceVectorImpl::CreateSpeaker(const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSpeaker) +{ + //--------------------------------------------------------------------------- + // Read Container + CSceneObjImpl* pContainer = static_cast(addToContainer); + + ASSERTN(kEveryone, pContainer != nullptr); + if ( ! pContainer) { return kVCOMError_NoValidContainerObj; } + + + SceneData::SceneDataObjWithMatrixPtr obj = nullptr; + ESceneObjType type = ESceneObjType::Layer; + pContainer->GetPointer(obj, type); + + if( ! VectorworksMVR::MvrUtil::isContainerType(type)) { return kVCOMError_NoValidContainerObj; } + + SceneData::SceneDataGroupObjPtr group = static_cast(obj); + + ASSERTN(kEveryone, group != nullptr); + if ( ! group) { return kVCOMError_NoValidContainerObj; } + + //--------------------------------------------------------------------------- + // Create the obj + VWFC::Tools::VWUUID uuid (guid.a,guid.b,guid.c,guid.d); + TXString nameStr ( name ); + + VWTransformMatrix ma; + GdtfUtil::ConvertMatrix(offset, ma); + + SceneData::SceneDataSpeakerObjPtr ptr = fExchangeObj.CreateSpeaker(uuid, ma, nameStr, group); + + //--------------------------------------------------------------------------- + // Initialize Object + CSceneObjImpl* pSpeaker = nullptr; + + // Query Interface + if (VCOM_SUCCEEDED(VWQueryInterface(IID_SceneObject, (IVWUnknown**) & pSpeaker))) + { + // Check Casting + CSceneObjImpl* pResultInterface = static_cast(pSpeaker); + if (pResultInterface) + { + pResultInterface->SetPointer(ptr, GetExchangeObj()); + } + else + { + pResultInterface->Release(); + pResultInterface = nullptr; + return kVCOMError_NoInterface; + } + } + + //--------------------------------------------------------------------------- + // Check Incoming Object + if (*outSpeaker) + { + (*outSpeaker)->Release(); + *outSpeaker = NULL; + } + + //--------------------------------------------------------------------------- + // Set Out Value + *outSpeaker = pSpeaker; + + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CMediaRessourceVectorImpl::CreateSpeakerBumper(const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSpeaker) +{ + //--------------------------------------------------------------------------- + // Read Container + CSceneObjImpl* pContainer = static_cast(addToContainer); + + ASSERTN(kEveryone, pContainer != nullptr); + if ( ! pContainer) { return kVCOMError_NoValidContainerObj; } + + + SceneData::SceneDataObjWithMatrixPtr obj = nullptr; + ESceneObjType type = ESceneObjType::Layer; + pContainer->GetPointer(obj, type); + + if( ! VectorworksMVR::MvrUtil::isContainerType(type)) { return kVCOMError_NoValidContainerObj; } + + SceneData::SceneDataGroupObjPtr group = static_cast(obj); + + ASSERTN(kEveryone, group != nullptr); + if ( ! group) { return kVCOMError_NoValidContainerObj; } + + //--------------------------------------------------------------------------- + // Create the obj + VWFC::Tools::VWUUID uuid (guid.a,guid.b,guid.c,guid.d); + TXString nameStr ( name ); + + VWTransformMatrix ma; + GdtfUtil::ConvertMatrix(offset, ma); + + SceneData::SceneDataSpeakerBumperObjPtr ptr = fExchangeObj.CreateSpeakerBumper(uuid, ma, nameStr, group); + + //--------------------------------------------------------------------------- + // Initialize Object + CSceneObjImpl* pSpeaker = nullptr; + + // Query Interface + if (VCOM_SUCCEEDED(VWQueryInterface(IID_SceneObject, (IVWUnknown**) & pSpeaker))) + { + // Check Casting + CSceneObjImpl* pResultInterface = static_cast(pSpeaker); + if (pResultInterface) + { + pResultInterface->SetPointer(ptr, GetExchangeObj()); + } + else + { + pResultInterface->Release(); + pResultInterface = nullptr; + return kVCOMError_NoInterface; + } + } + + //--------------------------------------------------------------------------- + // Check Incoming Object + if (*outSpeaker) + { + (*outSpeaker)->Release(); + *outSpeaker = NULL; + } + + //--------------------------------------------------------------------------- + // Set Out Value + *outSpeaker = pSpeaker; + + return kVCOMError_NoError; +} + + VectorworksMVR::VCOMError VectorworksMVR::CMediaRessourceVectorImpl::Close() { //------------------------------------------------------------------ diff --git a/src/Implementation/CMediaRessourceVectorImpl.h b/src/Implementation/CMediaRessourceVectorImpl.h index 4a5db374..0884ceae 100644 --- a/src/Implementation/CMediaRessourceVectorImpl.h +++ b/src/Implementation/CMediaRessourceVectorImpl.h @@ -55,17 +55,21 @@ namespace VectorworksMVR // Then you can generate all other objects - virtual VCOMError VCOM_CALLTYPE CreateLayerObject( const MvrUUID& guid, MvrString name, ISceneObj** outLayerObj); - virtual VCOMError VCOM_CALLTYPE CreateGroupObject( const MvrUUID& guid, const STransformMatrix& offset, ISceneObj* addToContainer, ISceneObj** outGroupObj); - virtual VCOMError VCOM_CALLTYPE CreateGroupObject( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outGroupObj); - virtual VCOMError VCOM_CALLTYPE CreateFixture( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outFixture); - virtual VCOMError VCOM_CALLTYPE CreateSceneObject( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSceneObj); - virtual VCOMError VCOM_CALLTYPE CreateFocusPoint( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outFocusPoint); - virtual VCOMError VCOM_CALLTYPE CreateTruss( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outTruss); - virtual VCOMError VCOM_CALLTYPE CreateSupport( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSupport); - virtual VCOMError VCOM_CALLTYPE CreateVideoScreen( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outVideoScreen); - virtual VCOMError VCOM_CALLTYPE CreateProjector( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outProjector); - + virtual VCOMError VCOM_CALLTYPE CreateLayerObject( const MvrUUID& guid, MvrString name, ISceneObj** outLayerObj); + virtual VCOMError VCOM_CALLTYPE CreateGroupObject( const MvrUUID& guid, const STransformMatrix& offset, ISceneObj* addToContainer, ISceneObj** outGroupObj); + virtual VCOMError VCOM_CALLTYPE CreateGroupObject( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outGroupObj); + virtual VCOMError VCOM_CALLTYPE CreateFixture( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outFixture); + virtual VCOMError VCOM_CALLTYPE CreateSceneObject( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSceneObj); + virtual VCOMError VCOM_CALLTYPE CreateFocusPoint( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outFocusPoint); + virtual VCOMError VCOM_CALLTYPE CreateTruss( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outTruss); + virtual VCOMError VCOM_CALLTYPE CreateSupport( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSupport); + virtual VCOMError VCOM_CALLTYPE CreateVideoScreen( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outVideoScreen); + virtual VCOMError VCOM_CALLTYPE CreateProjector( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outProjector); + virtual VCOMError VCOM_CALLTYPE CreateListeningPlane( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outListeningPlane); + virtual VCOMError VCOM_CALLTYPE CreateSpeaker( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSpeaker); + virtual VCOMError VCOM_CALLTYPE CreateSpeakerBumper( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSpeakerBumper); + + // Add the end call to write the file to disk virtual VCOMError VCOM_CALLTYPE Close(); diff --git a/src/Implementation/CSceneObjImpl.cpp b/src/Implementation/CSceneObjImpl.cpp index 1da2d4f1..60192619 100644 --- a/src/Implementation/CSceneObjImpl.cpp +++ b/src/Implementation/CSceneObjImpl.cpp @@ -1984,6 +1984,105 @@ VectorworksMVR::VCOMError VectorworksMVR::CSceneObjImpl::GetVideoScreenSource(IS return kVCOMError_NoError; } +// ------------------------------------------------------------------------------------------------------------------------------------------ +// Listening Plane +VectorworksMVR::VCOMError VectorworksMVR::CSceneObjImpl::SetAudioDescriptionFile(MvrString fileName) +{ + // Check if this is initialized + ASSERTN(kEveryone,fPtr); + if( ! fPtr) return kVCOMError_NotInitialized; + + // Check the type is right + ASSERTN(kEveryone,fType == ESceneObjType::ListeningPlane); + if( fType != ESceneObjType::ListeningPlane) return kVCOMError_Failed; + + if (fType == ESceneObjType::ListeningPlane) + { + SceneData::SceneDataListeningPlaneObjPtr listeningPlane = static_cast(fPtr); + if( ! listeningPlane) return kVCOMError_Failed; + listeningPlane->SetAudioDescriptionFile(fileName); + } + + + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CSceneObjImpl::GetAudioDescriptionFile( MvrString& outFileName ) +{ + // Check if this is initialized + ASSERTN( kEveryone, fPtr ); + if ( !fPtr ) return kVCOMError_NotInitialized; + + // Check the type is right + ASSERTN( kEveryone, fType == ESceneObjType::ListeningPlane); + if ( fType != ESceneObjType::ListeningPlane ) return kVCOMError_Failed; + + if (fType == ESceneObjType::ListeningPlane) + { + SceneData::SceneDataListeningPlaneObjPtr listeningPlane = static_cast( fPtr ); + if ( !listeningPlane ) return kVCOMError_Failed; + outFileName = listeningPlane->GetAudioDescriptionFile(); + } + + return kVCOMError_NoError; +} + +//------------------------------------------------------------------------------------------------------------------------------------------ +// Speaker and Speaker Bumper +VectorworksMVR::VCOMError VectorworksMVR::CSceneObjImpl::GetAngleToRelative( double& outAngleToRelative ) +{ + ASSERTN(kEveryone,fPtr); + if( !fPtr ) return kVCOMError_NotInitialized; + + if ( fType == ESceneObjType::Speaker ) + { + SceneData::SceneDataSpeakerObjPtr speaker = static_cast(fPtr); + if( ! speaker) return kVCOMError_Failed; + outAngleToRelative = speaker->GetAngleToRelative(); + } + else if ( fType == ESceneObjType::SpeakerBumper ) + { + SceneData::SceneDataSpeakerBumperObjPtr speakerBumper = static_cast( fPtr ); + if ( !speakerBumper ) return kVCOMError_Failed; + outAngleToRelative = speakerBumper->GetAngleToRelative(); + } + else + { + ASSERTN(kEveryone,fType == ESceneObjType::Speaker || fType == ESceneObjType::SpeakerBumper); + return kVCOMError_Failed; + } + + return kVCOMError_NoError; +} + +VectorworksMVR::VCOMError VectorworksMVR::CSceneObjImpl::SetAngleToRelative( double outAngleToRelative ) +{ + ASSERTN(kEveryone,fPtr); + if( ! fPtr) return kVCOMError_NotInitialized; + + if ( fType == ESceneObjType::Speaker ) + { + SceneData::SceneDataSpeakerObjPtr speaker = static_cast(fPtr); + if( ! speaker) return kVCOMError_Failed; + + speaker->SetAngleToRelative(outAngleToRelative); + } + else if ( fType == ESceneObjType::SpeakerBumper ) + { + SceneData::SceneDataSpeakerBumperObjPtr speakerBumper = static_cast( fPtr ); + if ( !speakerBumper ) return kVCOMError_Failed; + + speakerBumper->SetAngleToRelative( outAngleToRelative ); + } + else + { + ASSERTN( kEveryone, fType == ESceneObjType::Speaker || fType == ESceneObjType::SpeakerBumper ); + return kVCOMError_Failed; + } + + return kVCOMError_NoError; +} + //------------------------------------------------------------------------------------------------------------------------------------------ // Projector VectorworksMVR::VCOMError VectorworksMVR::CSceneObjImpl::SetProjectorSource(MvrString value, MvrString linkedGeometry, GdtfDefines::ESourceType type) @@ -2152,16 +2251,19 @@ void VectorworksMVR::CSceneObjImpl::SetPointer(SceneData::SceneDataObjWithMatrix switch (pointer->GetObjectType()) { - case SceneData::eLayer: fType = ESceneObjType::Layer; break; - case SceneData::eGroup: fType = ESceneObjType::Group; break; - case SceneData::eTruss: fType = ESceneObjType::Truss; break; - case SceneData::eSupport: fType = ESceneObjType::Support; break; - case SceneData::eFixture: fType = ESceneObjType::Fixture; break; - case SceneData::eFocusPoint: fType = ESceneObjType::FocusPoint; break; - case SceneData::eSceneObject: fType = ESceneObjType::SceneObj; break; - case SceneData::eVideoScreen: fType = ESceneObjType::VideoScreen; break; - case SceneData::eProjector: fType = ESceneObjType::Projector; break; - + case SceneData::eLayer: fType = ESceneObjType::Layer; break; + case SceneData::eGroup: fType = ESceneObjType::Group; break; + case SceneData::eTruss: fType = ESceneObjType::Truss; break; + case SceneData::eSupport: fType = ESceneObjType::Support; break; + case SceneData::eFixture: fType = ESceneObjType::Fixture; break; + case SceneData::eFocusPoint: fType = ESceneObjType::FocusPoint; break; + case SceneData::eSceneObject: fType = ESceneObjType::SceneObj; break; + case SceneData::eVideoScreen: fType = ESceneObjType::VideoScreen; break; + case SceneData::eProjector: fType = ESceneObjType::Projector; break; + case SceneData::eListeningPlane: fType = ESceneObjType::ListeningPlane; break; + case SceneData::eSpeaker: fType = ESceneObjType::Speaker; break; + case SceneData::eSpeakerBumper: fType = ESceneObjType::SpeakerBumper; break; + default: DSTOP((kEveryone, "Unexpected input!")); break; diff --git a/src/Implementation/CSceneObjImpl.h b/src/Implementation/CSceneObjImpl.h index 40aceba1..0580a209 100644 --- a/src/Implementation/CSceneObjImpl.h +++ b/src/Implementation/CSceneObjImpl.h @@ -107,11 +107,17 @@ namespace VectorworksMVR virtual VCOMError VCOM_CALLTYPE GetProjectorSource(ISource** outSource); virtual VCOMError VCOM_CALLTYPE SetScaleHandling(GdtfDefines::EScaleHandlingType scaleHandling); virtual VCOMError VCOM_CALLTYPE GetScaleHandling(GdtfDefines::EScaleHandlingType& outScaleHandling); + + // Speaker + virtual VCOMError VCOM_CALLTYPE GetAngleToRelative( double& outAngleToRelative ); + virtual VCOMError VCOM_CALLTYPE SetAngleToRelative( double angleToRelative ); virtual VCOMError VCOM_CALLTYPE GetConnectionCount(size_t& outConnections); virtual VCOMError VCOM_CALLTYPE GetConnectionAt(size_t at, IConnection** outConnection); virtual VCOMError VCOM_CALLTYPE CreateConnection(MvrString own, MvrString other, MvrUUID ToObject, IConnection** addedObj); + virtual VCOMError VCOM_CALLTYPE SetAudioDescriptionFile( MvrString fileName ); + virtual VCOMError VCOM_CALLTYPE GetAudioDescriptionFile( MvrString& outFileName ); // Implementation public: diff --git a/src/Include/GDTFPrefix.h b/src/Include/GDTFPrefix.h index 78192812..b0cd2d22 100644 --- a/src/Include/GDTFPrefix.h +++ b/src/Include/GDTFPrefix.h @@ -125,6 +125,7 @@ namespace VectorworksMVR eGdtfSubPhysicalUnit = 90, eGdtfGamut = 91, eGdtfDmxSubChannelSet = 92, + eGdtfGeometrySpeaker = 101, }; enum class EGdtfParsingError : Sint32 diff --git a/src/Include/IMediaRessourceVectorInterface.h b/src/Include/IMediaRessourceVectorInterface.h index e080a8d8..f9022bf8 100644 --- a/src/Include/IMediaRessourceVectorInterface.h +++ b/src/Include/IMediaRessourceVectorInterface.h @@ -327,6 +327,9 @@ namespace VectorworksMVR Fixture, Projector, Support, + ListeningPlane, + Speaker, + SpeakerBumper }; class DYNAMIC_ATTRIBUTE ISceneObj : public IVWUnknown @@ -404,6 +407,10 @@ namespace VectorworksMVR virtual VCOMError VCOM_CALLTYPE SetVideoScreenSource(MvrString value, MvrString linkedGeometry, GdtfDefines::ESourceType) = 0; virtual VCOMError VCOM_CALLTYPE GetVideoScreenSource(ISource** outSource) = 0; + // Listening Plane + virtual VCOMError VCOM_CALLTYPE SetAudioDescriptionFile(MvrString value) = 0; + virtual VCOMError VCOM_CALLTYPE GetAudioDescriptionFile(MvrString& outValue) = 0; + // Projector virtual VCOMError VCOM_CALLTYPE SetProjectorSource(MvrString value, MvrString linkedGeometry, GdtfDefines::ESourceType) = 0; virtual VCOMError VCOM_CALLTYPE GetProjectorSource(ISource** outSource) = 0; @@ -412,6 +419,11 @@ namespace VectorworksMVR virtual VCOMError VCOM_CALLTYPE GetConnectionCount(size_t& outConnections) = 0; virtual VCOMError VCOM_CALLTYPE GetConnectionAt(size_t at, IConnection** outConnection) = 0; virtual VCOMError VCOM_CALLTYPE CreateConnection(MvrString own, MvrString other, MvrUUID ToObject, IConnection** addedObj) = 0; + + // Speaker and Speaker Bumper + virtual VCOMError VCOM_CALLTYPE GetAngleToRelative( double& outAngleToRelative ) = 0; + virtual VCOMError VCOM_CALLTYPE SetAngleToRelative( double angleToRelative ) = 0; + // MVR 1.5 virtual VCOMError VCOM_CALLTYPE GetCustomCommandCount(size_t& outCount) = 0; virtual VCOMError VCOM_CALLTYPE GetCustomCommandAt(size_t at, ICustomCommand** outCustomCommand) = 0; @@ -450,16 +462,19 @@ namespace VectorworksMVR virtual VCOMError VCOM_CALLTYPE CreateMappingDefinitionObject( const MvrUUID& guid, MvrString name, IMappingDefinition** outMapDef) = 0; // Then you can generate all other objects - virtual VCOMError VCOM_CALLTYPE CreateLayerObject( const MvrUUID& guid, MvrString name, ISceneObj** outLayerObj) = 0; - virtual VCOMError VCOM_CALLTYPE CreateGroupObject( const MvrUUID& guid, const STransformMatrix& offset, ISceneObj* addToContainer, ISceneObj** outGroupObj) = 0; - virtual VCOMError VCOM_CALLTYPE CreateGroupObject( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outGroupObj) = 0; - virtual VCOMError VCOM_CALLTYPE CreateFixture( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outFixture) = 0; - virtual VCOMError VCOM_CALLTYPE CreateSceneObject( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSceneObj) = 0; - virtual VCOMError VCOM_CALLTYPE CreateFocusPoint( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outFocusPoint) = 0; - virtual VCOMError VCOM_CALLTYPE CreateVideoScreen( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outVideoScreen) = 0; - virtual VCOMError VCOM_CALLTYPE CreateTruss( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outTruss) = 0; - virtual VCOMError VCOM_CALLTYPE CreateSupport( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSupport) = 0; - virtual VCOMError VCOM_CALLTYPE CreateProjector( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outProjector) = 0; + virtual VCOMError VCOM_CALLTYPE CreateLayerObject( const MvrUUID& guid, MvrString name, ISceneObj** outLayerObj) = 0; + virtual VCOMError VCOM_CALLTYPE CreateGroupObject( const MvrUUID& guid, const STransformMatrix& offset, ISceneObj* addToContainer, ISceneObj** outGroupObj) = 0; + virtual VCOMError VCOM_CALLTYPE CreateGroupObject( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outGroupObj) = 0; + virtual VCOMError VCOM_CALLTYPE CreateFixture( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outFixture) = 0; + virtual VCOMError VCOM_CALLTYPE CreateSceneObject( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSceneObj) = 0; + virtual VCOMError VCOM_CALLTYPE CreateFocusPoint( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outFocusPoint) = 0; + virtual VCOMError VCOM_CALLTYPE CreateVideoScreen( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outVideoScreen) = 0; + virtual VCOMError VCOM_CALLTYPE CreateTruss( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outTruss) = 0; + virtual VCOMError VCOM_CALLTYPE CreateSupport( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSupport) = 0; + virtual VCOMError VCOM_CALLTYPE CreateProjector( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outProjector) = 0; + virtual VCOMError VCOM_CALLTYPE CreateListeningPlane( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outListeningPlane) = 0; + virtual VCOMError VCOM_CALLTYPE CreateSpeaker( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSpeaker) = 0; + virtual VCOMError VCOM_CALLTYPE CreateSpeakerBumper( const MvrUUID& guid, const STransformMatrix& offset, MvrString name, ISceneObj* addToContainer, ISceneObj** outSpeakerBumper) = 0; // Add the end call to write the file to disk virtual VCOMError VCOM_CALLTYPE Close() = 0; @@ -861,7 +876,14 @@ namespace VectorworksMVR // Display virtual MvrString VCOM_CALLTYPE GetTexture() = 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 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 @@ -987,6 +1009,27 @@ namespace VectorworksMVR virtual VCOMError VCOM_CALLTYPE SetResistanceXX(double resistanceXX) = 0; virtual VCOMError VCOM_CALLTYPE SetResistanceYY(double resistanceYY) = 0; virtual VCOMError VCOM_CALLTYPE SetResistanceZZ(double resistanceZZ) = 0; + + // Speaker + virtual VCOMError VCOM_CALLTYPE GetFrequencyMin(double& frequencyMin) = 0; + virtual VCOMError VCOM_CALLTYPE GetFrequencyMax(double& frequencyMax) = 0; + virtual VCOMError VCOM_CALLTYPE GetMaxSPL(double& maxSPL) = 0; + virtual VCOMError VCOM_CALLTYPE GetImpedance(double& impedance) = 0; + virtual VCOMError VCOM_CALLTYPE GetSoundAngleRotationMax(double& soundAngleRotationMax) = 0; + virtual VCOMError VCOM_CALLTYPE GetVerticalCoverageUp(double& verticalCoverageUp) = 0; + virtual VCOMError VCOM_CALLTYPE GetVerticalCoverageDown(double& verticalCoverageDown) = 0; + virtual VCOMError VCOM_CALLTYPE GetHorizontalCoverageLeft(double& horizontalCoverageLeft) = 0; + virtual VCOMError VCOM_CALLTYPE GetHorizontalCoverageRight(double& horizontalCoverageRight) = 0; + + virtual VCOMError VCOM_CALLTYPE SetFrequencyMin(double frequencyMin) = 0; + virtual VCOMError VCOM_CALLTYPE SetFrequencyMax(double frequencyMax) = 0; + virtual VCOMError VCOM_CALLTYPE SetMaxSPL(double maxSPL) = 0; + virtual VCOMError VCOM_CALLTYPE SetImpedance(double impedance) = 0; + virtual VCOMError VCOM_CALLTYPE SetSoundAngleRotationMax(double soundAngleRotationMax) = 0; + virtual VCOMError VCOM_CALLTYPE SetVerticalCoverageUp(double verticalCoverageUp) = 0; + virtual VCOMError VCOM_CALLTYPE SetVerticalCoverageDown(double verticalCoverageDown) = 0; + virtual VCOMError VCOM_CALLTYPE SetHorizontalCoverageLeft(double horizontalCoverageLeft) = 0; + virtual VCOMError VCOM_CALLTYPE SetHorizontalCoverageRight(double horizontalCoverageRight) = 0; }; typedef VCOMPtr IGdtfGeometryPtr; diff --git a/src/Prefix/CommonPrefix.h b/src/Prefix/CommonPrefix.h index b3585592..54fe941e 100644 --- a/src/Prefix/CommonPrefix.h +++ b/src/Prefix/CommonPrefix.h @@ -245,6 +245,12 @@ #define XML_Val_ProjectorObjectProjection "Projection" #define XML_Val_ProjectorObjectScaleHandling "ScaleHandling" +#define XML_Val_ListeningPlaneObjectNodeName "ListeningPlane" + +#define XML_Val_SpeakerObjectNodeName "Speaker" + +#define XML_Val_SpeakerBumperObjectNodeName "SpeakerBumper" + #define XML_Val_SymbolObjectNodeName "Symbol" #define XML_Val_GuidSymdefAttrName "symdef" @@ -452,6 +458,9 @@ const Sint32 kGDTF_CurrentMinorVersion = 2; #define XML_GDTF_DisplayNodeName "Display" #define XML_GDTF_DisplayTexture "Texture" +#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" @@ -520,6 +529,17 @@ const Sint32 kGDTF_CurrentMinorVersion = 2; #define XML_GDTF_SupportResistanceYY "ResistanceYY" #define XML_GDTF_SupportResistanceZZ "ResistanceZZ" +#define XML_GDTF_SpeakerNodeName "Speaker" +#define XML_GDTF_SpeakerFrequencyMin "FrequencyMin" +#define XML_GDTF_SpeakerFrequencyMax "FrequencyMax" +#define XML_GDTF_SpeakerMaxSPL "MaxSPL" +#define XML_GDTF_SpeakerImpedance "Impedance" +#define XML_GDTF_SpeakerSoundAngleRotationMax "SoundAngleRotationMax" +#define XML_GDTF_SpeakerVerticalCoverageUp "VerticalCoverageUp" +#define XML_GDTF_SpeakerVerticalCoverageDown "VerticalCoverageDown" +#define XML_GDTF_SpeakerHorizontalCoverageLeft "HorizontalCoverageLeft" +#define XML_GDTF_SpeakerHorizontalCoverageRight "HorizontalCoverageRight" + #define XML_GDTF_MagnetNodeName "Magnet" #define XML_GDTF_LampNodeName "Beam" diff --git a/src/SceneDataExchange.cpp b/src/SceneDataExchange.cpp index b231634f..56d311a6 100644 --- a/src/SceneDataExchange.cpp +++ b/src/SceneDataExchange.cpp @@ -2796,6 +2796,143 @@ void SceneDataProjectorObj::OnReadFromNode(const IXMLFileNodePtr& pNode, SceneDa } +// ---------------------------------------------------------------------------------------------------------------------------------- +// SceneDataListeningPlaneObj +SceneDataListeningPlaneObj::SceneDataListeningPlaneObj(const SceneDataGUID& guid) : SceneDataGroupObj(guid) +{ +} + +SceneDataListeningPlaneObj::~SceneDataListeningPlaneObj() +{ +} + +const TXString& SceneDataListeningPlaneObj::GetAudioDescriptionFile() const +{ + return fAudioDescriptionFile; +} + +void SceneDataListeningPlaneObj::SetAudioDescriptionFile( const TXString& value ) +{ + fAudioDescriptionFile = value; +} + +TXString SceneDataListeningPlaneObj::GetNodeName() +{ + return TXString(XML_Val_ListeningPlaneObjectNodeName); +} + +ESceneDataObjectType SceneDataListeningPlaneObj::GetObjectType() +{ + return ESceneDataObjectType::eListeningPlane; +} + +void SceneDataListeningPlaneObj::OnPrintToFile(IXMLFileNodePtr pNode, SceneDataExchange* exchange) +{ + SceneDataObjWithMatrix::OnPrintToFile( pNode, exchange ); + + pNode->SetNodeAttributeValue("AudioDescriptionFile", fAudioDescriptionFile); +} + +void SceneDataListeningPlaneObj::OnReadFromNode(const IXMLFileNodePtr& pNode, SceneDataExchange* exchange) +{ + SceneDataObjWithMatrix::OnReadFromNode( pNode, exchange ); + + pNode->GetNodeAttributeValue("AudioDescriptionFile", fAudioDescriptionFile); +} + +// ---------------------------------------------------------------------------------------------------------------------------------- +// SceneDataSpeakerObj +SceneDataSpeakerObj::SceneDataSpeakerObj(const SceneDataGUID& guid) :SceneDataGDTFSpecObj(guid) +{ + fAngleToRelative = 0.0; +} + +SceneDataSpeakerObj::~SceneDataSpeakerObj() +{ +} + +TXString SceneDataSpeakerObj::GetNodeName() +{ + return TXString(XML_Val_SpeakerObjectNodeName); +} + +double SceneDataSpeakerObj::GetAngleToRelative() +{ + return fAngleToRelative; +} + +void SceneDataSpeakerObj::SetAngleToRelative( double value ) +{ + fAngleToRelative = value; +} + +ESceneDataObjectType SceneDataSpeakerObj::GetObjectType() +{ + return ESceneDataObjectType::eSpeaker; +} + +void SceneDataSpeakerObj::OnPrintToFile(IXMLFileNodePtr pNode, SceneDataExchange* exchange) +{ + SceneDataGDTFSpecObj::OnPrintToFile( pNode, exchange ); + + pNode->SetNodeAttributeValue( "AngleToRelative", GdtfConverter::ConvertDouble( fAngleToRelative ) ); +} + +void SceneDataSpeakerObj::OnReadFromNode(const IXMLFileNodePtr& pNode, SceneDataExchange* exchange) +{ + SceneDataGDTFSpecObj::OnReadFromNode( pNode, exchange ); + + TXString value; + pNode->GetNodeAttributeValue("AngleToRelative", value); + GdtfConverter::ConvertDouble( value, pNode, fAngleToRelative ); +} + +// ---------------------------------------------------------------------------------------------------------------------------------- +// SceneDataSpeakerBumperObj +SceneDataSpeakerBumperObj::SceneDataSpeakerBumperObj(const SceneDataGUID& guid) :SceneDataGDTFSpecObj(guid) +{ + fAngleToRelative = 0.0; +} + +SceneDataSpeakerBumperObj::~SceneDataSpeakerBumperObj() +{ +} + +TXString SceneDataSpeakerBumperObj::GetNodeName() +{ + return TXString(XML_Val_SpeakerBumperObjectNodeName); +} + +ESceneDataObjectType SceneDataSpeakerBumperObj::GetObjectType() +{ + return ESceneDataObjectType::eSpeakerBumper; +} + +double SceneDataSpeakerBumperObj::GetAngleToRelative() +{ + return fAngleToRelative; +} + +void SceneDataSpeakerBumperObj::SetAngleToRelative( double value ) +{ + fAngleToRelative = value; +} + +void SceneDataSpeakerBumperObj::OnPrintToFile(IXMLFileNodePtr pNode, SceneDataExchange* exchange) +{ + SceneDataGDTFSpecObj::OnPrintToFile( pNode, exchange ); + + pNode->SetNodeAttributeValue( "AngleToRelative", GdtfConverter::ConvertDouble( fAngleToRelative ) ); +} + +void SceneDataSpeakerBumperObj::OnReadFromNode(const IXMLFileNodePtr& pNode, SceneDataExchange* exchange) +{ + SceneDataGDTFSpecObj::OnReadFromNode( pNode, exchange ); + + TXString value; + pNode->GetNodeAttributeValue("AngleToRelative", value); + GdtfConverter::ConvertDouble( value, pNode, fAngleToRelative ); +} // ---------------------------------------------------------------------------------------------------------------------------------- // SceneDataSymbolObj @@ -3444,6 +3581,75 @@ SceneDataProjectorObjPtr SceneDataExchange::ReadProjector(const SceneDataGUID& g return newProjectorObj; } +SceneDataListeningPlaneObjPtr SceneDataExchange::CreateListeningPlane(const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer) +{ + SceneDataListeningPlaneObjPtr newListeningPlaneObj = new SceneDataListeningPlaneObj(guid); + addToContainer->AddObject(newListeningPlaneObj); + + newListeningPlaneObj->setName(name); + newListeningPlaneObj->SetTransformMatrix(offset); + + return newListeningPlaneObj; +} + +SceneDataListeningPlaneObjPtr SceneDataExchange::ReadListeningPlane(const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer) +{ + if ( CheckAbort() ) return nullptr; + + SceneDataListeningPlaneObjPtr newListeningPlaneObj = new SceneDataListeningPlaneObj(guid); + addToContainer->AddObject(newListeningPlaneObj); + + newListeningPlaneObj->ReadFromNode(node, this); + + return newListeningPlaneObj; +} + +SceneDataSpeakerObjPtr SceneDataExchange::CreateSpeaker(const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer) +{ + SceneDataSpeakerObjPtr newSpeakerObj = new SceneDataSpeakerObj(guid); + addToContainer->AddObject(newSpeakerObj); + + newSpeakerObj->setName(name); + newSpeakerObj->SetTransformMatrix(offset); + + return newSpeakerObj; +} + +SceneDataSpeakerObjPtr SceneDataExchange::ReadSpeaker(const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer) +{ + if ( CheckAbort() ) return nullptr; + + SceneDataSpeakerObjPtr newSpeakerObj = new SceneDataSpeakerObj(guid); + addToContainer->AddObject(newSpeakerObj); + + newSpeakerObj->ReadFromNode(node, this); + + return newSpeakerObj; +} + +SceneDataSpeakerBumperObjPtr SceneDataExchange::CreateSpeakerBumper(const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer) +{ + SceneDataSpeakerBumperObjPtr newSpeakerBumperObj = new SceneDataSpeakerBumperObj(guid); + addToContainer->AddObject(newSpeakerBumperObj); + + newSpeakerBumperObj->setName(name); + newSpeakerBumperObj->SetTransformMatrix(offset); + + return newSpeakerBumperObj; +} + +SceneDataSpeakerBumperObjPtr SceneDataExchange::ReadSpeakerBumper(const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer) +{ + if ( CheckAbort() ) return nullptr; + + SceneDataSpeakerBumperObjPtr newSpeakerBumperObj = new SceneDataSpeakerBumperObj(guid); + addToContainer->AddObject(newSpeakerBumperObj); + + newSpeakerBumperObj->ReadFromNode(node, this); + + return newSpeakerBumperObj; +} + SceneDataSymbolObjPtr SceneDataExchange::CreateSymbol(const SceneDataGUID& guid, const VWTransformMatrix& offset, SceneDataSymDefObjPtr symDef) { SceneDataSymbolObjPtr newSymbolObj = new SceneDataSymbolObj(guid); @@ -3665,6 +3871,11 @@ bool SceneDataExchange::WriteXml(const IFolderIdentifierPtr& folder, IXMLFileIOB { symDef->PrintToFile( pAuxDataNode, this ); } + + for ( const auto& classes : fClasses ) + { + classes->PrintToFile( pAuxDataNode, this ); + } } @@ -4067,14 +4278,17 @@ void SceneDataExchange::ReadChildObjs(const IXMLFileNodePtr& node, SceneDataGrou { SceneDataObjWithMatrixPtr obj = nullptr; - if ( nodeName == XML_Val_FixtureNodeName) { obj = ReadFixture( SceneDataGUID(groupUuid),objNode, addToContainer); } - else if ( nodeName == XML_Val_SceneObjectNodeName) { obj = ReadSceneryObject( SceneDataGUID(groupUuid),objNode, addToContainer); } - else if ( nodeName == XML_Val_FocusPointObjectNodeName) { obj = ReadFocusPoint( SceneDataGUID(groupUuid),objNode, addToContainer); } - else if ( nodeName == XML_Val_TrussObjectNodeName) { obj = ReadTruss( SceneDataGUID(groupUuid),objNode, addToContainer); } - else if ( nodeName == XML_Val_VideoScreenObjectNodeName) { obj = ReadVideoScreen( SceneDataGUID(groupUuid),objNode, addToContainer); } - else if ( nodeName == XML_Val_SupportObjectNodeName) { obj = ReadSupport( SceneDataGUID(groupUuid),objNode, addToContainer); } - else if ( nodeName == XML_Val_ProjectorObjectNodeName) { obj = ReadProjector( SceneDataGUID(groupUuid),objNode, addToContainer); } - else if ( nodeName == XML_Val_GroupNodeName) { obj = ProcessGroup(objNode, addToContainer); } + if ( nodeName == XML_Val_FixtureNodeName) { obj = ReadFixture( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_SceneObjectNodeName) { obj = ReadSceneryObject( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_FocusPointObjectNodeName) { obj = ReadFocusPoint( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_TrussObjectNodeName) { obj = ReadTruss( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_VideoScreenObjectNodeName) { obj = ReadVideoScreen( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_SupportObjectNodeName) { obj = ReadSupport( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_ProjectorObjectNodeName) { obj = ReadProjector( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_ListeningPlaneObjectNodeName ) { obj = ReadListeningPlane( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_SpeakerObjectNodeName ) { obj = ReadSpeaker( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_SpeakerBumperObjectNodeName ) { obj = ReadSpeakerBumper( SceneDataGUID(groupUuid), objNode, addToContainer); } + else if ( nodeName == XML_Val_GroupNodeName) { obj = ProcessGroup(objNode, addToContainer); } auto grp = dynamic_cast(obj); if (grp) diff --git a/src/SceneDataExchange.h b/src/SceneDataExchange.h index afbacc24..de547549 100644 --- a/src/SceneDataExchange.h +++ b/src/SceneDataExchange.h @@ -47,6 +47,9 @@ namespace SceneData eVideoScreen = 7, eProjector = 8, eSupport = 9, + eListeningPlane = 10, + eSpeaker = 11, + eSpeakerBumper = 12, eSymDef = -1, eProviderObj = -2, ePosition = -3, @@ -937,6 +940,78 @@ namespace SceneData }; typedef SceneDataProjectorObj* SceneDataProjectorObjPtr; + // ---------------------------------------------------------------------------------------------------------------------------------- + // SceneDataListeningPlaneObj + class SceneDataListeningPlaneObj : public SceneDataGroupObj + { + + public: + SceneDataListeningPlaneObj(const SceneDataGUID& guid); + virtual ~SceneDataListeningPlaneObj(); + + virtual const TXString& GetAudioDescriptionFile() const; + virtual void SetAudioDescriptionFile(const TXString& value); + + private: + TXString fAudioDescriptionFile; + + virtual TXString GetNodeName(); + virtual ESceneDataObjectType GetObjectType(); + + virtual void OnPrintToFile(IXMLFileNodePtr pNode, SceneDataExchange* exchange); + virtual void OnReadFromNode(const IXMLFileNodePtr& pNode, SceneDataExchange* exchange); + + }; + typedef SceneDataListeningPlaneObj* SceneDataListeningPlaneObjPtr; + + // ---------------------------------------------------------------------------------------------------------------------------------- + // SceneDataSpeakerObj + class SceneDataSpeakerObj : public SceneDataGDTFSpecObj + { + + public: + SceneDataSpeakerObj(const SceneDataGUID& guid); + virtual ~SceneDataSpeakerObj(); + + virtual double GetAngleToRelative(); + virtual void SetAngleToRelative( double angleToRelative ); + + private: + double fAngleToRelative; + + virtual TXString GetNodeName(); + virtual ESceneDataObjectType GetObjectType(); + + virtual void OnPrintToFile(IXMLFileNodePtr pNode, SceneDataExchange* exchange); + virtual void OnReadFromNode(const IXMLFileNodePtr& pNode, SceneDataExchange* exchange); + + }; + typedef SceneDataSpeakerObj* SceneDataSpeakerObjPtr; + + // ---------------------------------------------------------------------------------------------------------------------------------- + // SceneDataSpeakerBumperObj + class SceneDataSpeakerBumperObj : public SceneDataGDTFSpecObj + { + + public: + SceneDataSpeakerBumperObj(const SceneDataGUID& guid); + virtual ~SceneDataSpeakerBumperObj(); + + virtual double GetAngleToRelative(); + virtual void SetAngleToRelative( double angleToRelative ); + + private: + double fAngleToRelative; + + virtual TXString GetNodeName(); + virtual ESceneDataObjectType GetObjectType(); + + virtual void OnPrintToFile(IXMLFileNodePtr pNode, SceneDataExchange* exchange); + virtual void OnReadFromNode(const IXMLFileNodePtr& pNode, SceneDataExchange* exchange); + + }; + typedef SceneDataSpeakerBumperObj* SceneDataSpeakerBumperObjPtr; + // ---------------------------------------------------------------------------------------------------------------------------------- // SceneDataSymbolObj class SceneDataSymbolObj : public SceneDataGeoInstanceObj @@ -1057,18 +1132,20 @@ namespace SceneData SceneDataMappingDefinitionObjPtr CreateMappingDefinitionObject(const SceneDataGUID& guid, const TXString& name); - SceneDataLayerObjPtr CreateLayerObject( const SceneDataGUID& guid, const TXString& name); - SceneDataGroupObjPtr CreateGroupObject( const SceneDataGUID& guid, const VWTransformMatrix& offset, SceneDataGroupObjPtr addToContainer); - SceneDataGroupObjPtr CreateGroupObject( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); - SceneDataFixtureObjPtr CreateFixture( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); - SceneDataSceneryObjPtr CreateSceneryObject(const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); - SceneDataFocusPointObjPtr CreateFocusPoint( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); - SceneDataTrussObjPtr CreateTruss( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); - SceneDataSupportObjPtr CreateSupport( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); - SceneDataVideoScreenObjPtr CreateVideoScreen( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); - SceneDataProjectorObjPtr CreateProjector( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); - - + SceneDataLayerObjPtr CreateLayerObject( const SceneDataGUID& guid, const TXString& name); + SceneDataGroupObjPtr CreateGroupObject( const SceneDataGUID& guid, const VWTransformMatrix& offset, SceneDataGroupObjPtr addToContainer); + SceneDataGroupObjPtr CreateGroupObject( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataFixtureObjPtr CreateFixture( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataSceneryObjPtr CreateSceneryObject( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataFocusPointObjPtr CreateFocusPoint( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataTrussObjPtr CreateTruss( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataSupportObjPtr CreateSupport( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataVideoScreenObjPtr CreateVideoScreen( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataProjectorObjPtr CreateProjector( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataListeningPlaneObjPtr CreateListeningPlane( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataSpeakerObjPtr CreateSpeaker( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + SceneDataSpeakerBumperObjPtr CreateSpeakerBumper( const SceneDataGUID& guid, const VWTransformMatrix& offset, const TXString& name, SceneDataGroupObjPtr addToContainer); + // --------------------------------------------------------------------------------------------------------------------- // Read calls private: @@ -1079,16 +1156,19 @@ namespace SceneData SceneDataMappingDefinitionObjPtr ReadMappingDefinitionObject(const IXMLFileNodePtr& node); - SceneDataLayerObjPtr ReadLayerObject( const SceneDataGUID& guid,const IXMLFileNodePtr& node); - SceneDataGroupObjPtr ReadGroupObject( const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); - SceneDataFixtureObjPtr ReadFixture( const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); - SceneDataSceneryObjPtr ReadSceneryObject( const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); - SceneDataFocusPointObjPtr ReadFocusPoint( const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); - SceneDataTrussObjPtr ReadTruss( const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); - SceneDataSupportObjPtr ReadSupport( const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); - SceneDataVideoScreenObjPtr ReadVideoScreen( const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); - SceneDataProjectorObjPtr ReadProjector( const SceneDataGUID& guid,const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); - + SceneDataLayerObjPtr ReadLayerObject( const SceneDataGUID& guid, const IXMLFileNodePtr& node); + SceneDataGroupObjPtr ReadGroupObject( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); + SceneDataFixtureObjPtr ReadFixture( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); + SceneDataSceneryObjPtr ReadSceneryObject( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); + SceneDataFocusPointObjPtr ReadFocusPoint( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); + SceneDataTrussObjPtr ReadTruss( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); + SceneDataSupportObjPtr ReadSupport( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); + SceneDataVideoScreenObjPtr ReadVideoScreen( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); + SceneDataProjectorObjPtr ReadProjector( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer); + SceneDataListeningPlaneObjPtr ReadListeningPlane( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer ); + SceneDataSpeakerObjPtr ReadSpeaker( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer ); + SceneDataSpeakerBumperObjPtr ReadSpeakerBumper( const SceneDataGUID& guid, const IXMLFileNodePtr& node, SceneDataGroupObjPtr addToContainer ); + // --------------------------------------------------------------------------------------------------------------------- // Write calls public: diff --git a/src/Utility.cpp b/src/Utility.cpp index ace1742c..caad0621 100644 --- a/src/Utility.cpp +++ b/src/Utility.cpp @@ -21,7 +21,10 @@ bool MvrUtil::isContainerType(ESceneObjType typ) || typ == ESceneObjType::SceneObj || typ == ESceneObjType::Truss || typ == ESceneObjType::VideoScreen - || typ == ESceneObjType::Support); + || typ == ESceneObjType::Support + || typ == ESceneObjType::Speaker + || typ == ESceneObjType::SpeakerBumper + ); ASSERTN(kEveryone, res); diff --git a/unittest/EmptyGeometryUnitTest.cpp b/unittest/EmptyGeometryUnitTest.cpp index a7bcd09f..7f0a72a9 100644 --- a/unittest/EmptyGeometryUnitTest.cpp +++ b/unittest/EmptyGeometryUnitTest.cpp @@ -13,7 +13,7 @@ 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) { } @@ -21,10 +21,20 @@ 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,10 @@ void GdtfEmptyModelTest::WriteFile(VectorworksMVR::IGdtfFixturePtr& fixture) IGdtfGeometryPtr geometry4; __checkVCOM(geometry1->CreateGeometry(EGdtfObjectType::eGdtfGeometryDisplay, "Geometry4", filledModel, STransformMatrix(), &geometry4)); __checkVCOM(geometry4->SetTexture("Texture.png")); + __checkVCOM(geometry4->SetWidth(4700)); + __checkVCOM(geometry4->SetHeight(2700)); + __checkVCOM(geometry4->SetIsCurved(false)); + // Magnet IGdtfGeometryPtr geometry5; @@ -200,6 +214,18 @@ void GdtfEmptyModelTest::ReadFile(VectorworksMVR::IGdtfFixturePtr& fixture) checkifEqual("Check Texture", geometry4->GetTexture(), "Texture.png"); + 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)); diff --git a/unittest/EmptyGeometryUnitTest.h b/unittest/EmptyGeometryUnitTest.h index f42025ea..a1c91007 100644 --- a/unittest/EmptyGeometryUnitTest.h +++ b/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); }; \ No newline at end of file diff --git a/unittest/Unittest.cpp b/unittest/Unittest.cpp index 2de1fc85..8a3055f6 100644 --- a/unittest/Unittest.cpp +++ b/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) diff --git a/unittest/Utility.cpp b/unittest/Utility.cpp index b0e302b8..4314d93f 100644 --- a/unittest/Utility.cpp +++ b/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