Skip to content

Implementing Listening Obj and Speaker GDTF type into MVR #150

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
adragnevVW wants to merge 7 commits into
base: alpha
Choose a base branch
from
Open

Implementing Listening Obj and Speaker GDTF type into MVR #150

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
623ff52
Implementing Listening Obj type into MVR
adragnevVW May 12, 2026
0916358
Update IMediaRessourceVectorInterface.h
adragnevVW May 12, 2026
7aa3323
Adding Listening Obj type
adragnevVW May 13, 2026
4a3f30f
Adding heat map data property
adragnevVW May 15, 2026
304d951
Updating the windows workflow version
adragnevVW Jun 17, 2026
76660bf
Adding speaker GDTF support
adragnevVW Jun 23, 2026
985dfe2
Adding MVR Support for Speaker
adragnevVW Jun 23, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion .github/workflows/artifact.yml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,7 @@ on:
type: choice
options:
- ubuntu-22.04
- windows-latest
- windows-2022
- macos-14

jobs:
Expand Down
217 changes: 217 additions & 0 deletions src/GDTFManager.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down Expand Up @@ -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 */ }
Expand Down Expand Up @@ -4306,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)
Expand Down Expand Up @@ -9713,6 +9920,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!")); }

Expand Down Expand Up @@ -10093,6 +10301,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);
Expand Down
54 changes: 54 additions & 0 deletions src/GDTFManager.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand Down Expand Up @@ -1329,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:
Expand Down Expand Up @@ -2926,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);

Expand Down
1 change: 1 addition & 0 deletions src/Implementation/CGdtfFixture.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Expand Down
Loading
Loading