From ce11924423498f6aca1e825e2a8d17f46d5eae71 Mon Sep 17 00:00:00 2001 From: Jannik-Hm Date: Thu, 19 Feb 2026 23:19:47 +0100 Subject: [PATCH 1/7] added meshModel struct --- pkg/types/meshmodel.go | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 pkg/types/meshmodel.go diff --git a/pkg/types/meshmodel.go b/pkg/types/meshmodel.go new file mode 100644 index 0000000..05ecfbf --- /dev/null +++ b/pkg/types/meshmodel.go @@ -0,0 +1,17 @@ +package Types + +import "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" + +type MeshModel struct { + Mesh MeshTypes.Mesh + GeometryType GeometryType + GeometryPtr GeometryModel +} + +func (obj *MeshModel) Copy() MeshModel { + return MeshModel{ + Mesh: obj.Mesh.Copy(), + GeometryType: obj.GeometryType, + GeometryPtr: obj.GeometryPtr, + } +} From be1274d58ecc70ac26eea9109d112c6b78ca376a Mon Sep 17 00:00:00 2001 From: Jannik-Hm Date: Thu, 19 Feb 2026 23:20:28 +0100 Subject: [PATCH 2/7] reworked mesh generation + switched from GeometryBase struct embedding to interface --- internal/types/gdtfxml/geometry.go | 206 ++-- pkg/types/geometry.go | 1551 ++++++++++++++++++++++++---- 2 files changed, 1450 insertions(+), 307 deletions(-) diff --git a/internal/types/gdtfxml/geometry.go b/internal/types/gdtfxml/geometry.go index 00c5012..5930ddd 100644 --- a/internal/types/gdtfxml/geometry.go +++ b/internal/types/gdtfxml/geometry.go @@ -55,14 +55,12 @@ type Geometry struct { func (geometry Geometry) Parse() Types.Geometry { return Types.Geometry{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -75,14 +73,12 @@ type Axis struct { func (geometry Axis) Parse() Types.Axis { return Types.Axis{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -95,14 +91,12 @@ type FilterBeam struct { func (geometry FilterBeam) Parse() Types.FilterBeam { return Types.FilterBeam{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -115,14 +109,12 @@ type FilterColor struct { func (geometry FilterColor) Parse() Types.FilterColor { return Types.FilterColor{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -135,14 +127,12 @@ type FilterGobo struct { func (geometry FilterGobo) Parse() Types.FilterGobo { return Types.FilterGobo{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -155,14 +145,12 @@ type FilterShaper struct { func (geometry FilterShaper) Parse() Types.FilterShaper { return Types.FilterShaper{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -187,14 +175,12 @@ type Beam struct { func (geometry Beam) Parse() Types.Beam { return Types.Beam{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), LampType: geometry.LampType, PowerConsumption: geometry.PowerConsumption, LuminousFlux: geometry.LuminousFlux, @@ -221,14 +207,12 @@ type MediaServerLayer struct { func (geometry MediaServerLayer) Parse() Types.MediaServerLayer { return Types.MediaServerLayer{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -241,14 +225,12 @@ type MediaServerCamera struct { func (geometry MediaServerCamera) Parse() Types.MediaServerCamera { return Types.MediaServerCamera{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -261,14 +243,12 @@ type MediaServerMaster struct { func (geometry MediaServerMaster) Parse() Types.MediaServerMaster { return Types.MediaServerMaster{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -282,14 +262,12 @@ type Display struct { func (geometry Display) Parse() Types.Display { return Types.Display{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } @@ -347,14 +325,12 @@ type Laser struct { func (geometry Laser) Parse() Types.Laser { return Types.Laser{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), ColorType: geometry.ColorType, Color: geometry.Color, OutputStrength: geometry.OutputStrength, @@ -406,14 +382,12 @@ type WiringObject struct { func (geometry WiringObject) Parse() Types.WiringObject { return Types.WiringObject{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), ConnectorType: geometry.ConnectorType, ComponentType: geometry.ComponentType, SignalType: geometry.SignalType, @@ -461,15 +435,13 @@ type Inventory struct { func (geometry Inventory) Parse() Types.Inventory { return Types.Inventory{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, - Count: geometry.Count, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), + Count: geometry.Count, } } @@ -488,14 +460,12 @@ type Structure struct { func (geometry Structure) Parse() Types.Structure { return Types.Structure{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), LinkedGeometry: geometry.LinkedGeometry, // TODO: add pointer? -> find a sample StructureType: geometry.StructureType, CrossSectionType: geometry.CrossSectionType, @@ -529,14 +499,12 @@ type Support struct { func (geometry Support) Parse() Types.Support { return Types.Support{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), SupportType: geometry.SupportType, RopeCrossSection: geometry.RopeCrossSection, RopeOffset: Types.Vector3(geometry.RopeOffset), @@ -564,13 +532,11 @@ type Magnet struct { func (geometry Magnet) Parse() Types.Magnet { return Types.Magnet{ - GeometryBase: Types.GeometryBase{ - Name: geometry.Name, - Model: Types.NodeReference[Types.Model]{ - String: geometry.Model, - }, - Position: Types.Matrix(geometry.Position), - Geometries: geometry.Geometries.Parse(), + Name: geometry.Name, + Model: Types.NodeReference[Types.Model]{ + String: geometry.Model, }, + Position: Types.Matrix(geometry.Position), + Geometries: geometry.Geometries.Parse(), } } diff --git a/pkg/types/geometry.go b/pkg/types/geometry.go index ef930b3..367dbc8 100644 --- a/pkg/types/geometry.go +++ b/pkg/types/geometry.go @@ -7,57 +7,118 @@ import ( "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" ) +type GeometryType int + +const ( + GeometryTypeGeometry = iota + GeometryTypeAxis + GeometryTypeFilterBeam + GeometryTypeFilterColor + GeometryTypeFilterGobo + GeometryTypeFilterShaper + GeometryTypeBeam + GeometryTypeMediaServerLayer + GeometryTypeMediaServerCamera + GeometryTypeMediaServerMaster + GeometryTypeDisplay + GeometryTypeGeometryReference + GeometryTypeLaser + GeometryTypeWiringObject + GeometryTypeInventory + GeometryTypeStructure + GeometryTypeSupport + GeometryTypeMagnet +) + type GeometryNodeReference struct { - Ptr any + Ptr GeometryModel Type string } -type GeometryBase struct { - Name string - Model NodeReference[Model] - Position Matrix - Geometries +type GeometryModel interface { + GetName() string + GetNamePtr() *string + SetName(string) + + GetModel() NodeReference[Model] + GetModelPtr() *NodeReference[Model] + SetModel(NodeReference[Model]) + + GetPosition() Matrix + GetPositionPtr() *Matrix + SetPosition(Matrix) + + GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel +} + +type GeometryModelWithChildGeometries interface { + GetName() string + GetNamePtr() *string + SetName(string) + + GetModel() NodeReference[Model] + GetModelPtr() *NodeReference[Model] + SetModel(NodeReference[Model]) + + GetPosition() Matrix + GetPositionPtr() *Matrix + SetPosition(Matrix) + + GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel + + GetGeometries() Geometries + GetGeometriesPtr() *Geometries + SetGeometries(Geometries) } -func (obj *GeometryBase) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { - newParentPrefix := strings.Trim(parentPrefix+"."+obj.Name, ".") +func CreateGeometryWithChildsReferencePointer(obj GeometryModelWithChildGeometries, refPointers *ReferencePointers, parentPrefix string) { + newParentPrefix := strings.Trim(parentPrefix+"."+obj.GetName(), ".") refPointers.Geometries[newParentPrefix] = &GeometryNodeReference{ Ptr: obj, Type: reflect.TypeOf(obj).String(), } - obj.Geometries.CreateGeometryReferencePointer(refPointers, newParentPrefix) + obj.GetGeometriesPtr().CreateGeometryReferencePointer(refPointers, newParentPrefix) } -func (obj *GeometryBase) ResolveReference(refPointers *ReferencePointers) { - obj.Model.Ptr = refPointers.Models[obj.Model.String] - obj.Geometries.ResolveReference(refPointers) +func ResolveGeometryWithChildsReference(obj GeometryModelWithChildGeometries, refPointers *ReferencePointers) { + obj.GetModelPtr().Ptr = refPointers.Models[obj.GetModel().String] + obj.GetGeometriesPtr().ResolveReference(refPointers) } -type MeshGenerator interface { - GenerateMesh(parentTransformation MeshTypes.Matrix) *MeshTypes.Mesh -} +// type MeshGenerator interface { +// GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) +// } -func (obj *GeometryBase) GenerateMesh(parentTransformation MeshTypes.Matrix) *MeshTypes.Mesh { - var mesh1 MeshTypes.Mesh - localTransformation := obj.Position.toMeshMatrix() +func GenerateMesh(obj GeometryModel, parentTransformation MeshTypes.Matrix, modelList []MeshModel, geometryType GeometryType) ([]MeshModel, MeshTypes.Matrix) { + var mesh MeshTypes.Mesh + localTransformation := obj.GetPosition().toMeshMatrix() transformation := parentTransformation.Mul(localTransformation) - if obj.Model.Ptr != nil && obj.Model.Ptr.Mesh != nil { - mesh1 = obj.Model.Ptr.Mesh.Copy() - mesh1.RotateAndTranslate(transformation) + if obj.GetModel().Ptr != nil && obj.GetModel().Ptr.Mesh != nil { + mesh = obj.GetModel().Ptr.Mesh.Copy() + mesh.RotateAndTranslate(transformation) } - mesh2 := obj.Geometries.GenerateMesh(transformation) - return mesh1.Add(mesh2) + modelList = append(modelList, MeshModel{ + Mesh: mesh, + GeometryType: geometryType, + GeometryPtr: obj, + }) + return modelList, transformation +} + +func GenerateMeshWithChildren(obj GeometryModelWithChildGeometries, parentTransformation MeshTypes.Matrix, modelList []MeshModel, geometryType GeometryType) []MeshModel { + modelList, transformation := GenerateMesh(obj, parentTransformation, modelList, geometryType) + modelList = obj.GetGeometriesPtr().GenerateMesh(transformation, modelList) + return modelList } -func GenerateMeshes[T MeshGenerator](source *[]T, parentTransformation MeshTypes.Matrix) *MeshTypes.Mesh { - mesh := &MeshTypes.Mesh{} +func GenerateMeshes[T GeometryModel](source *[]T, parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { if source == nil { - return mesh + return modelList } for i := range *source { - mesh.Add((*source)[i].GenerateMesh(parentTransformation)) + modelList = (*source)[i].GenerateMesh(parentTransformation, modelList) } - return mesh + return modelList } type Geometries struct { @@ -125,221 +186,1337 @@ func (obj *Geometries) ResolveReference(refPointers *ReferencePointers) { ResolveReferences(refPointers, &obj.MagnetList) } -func (obj *Geometries) GenerateMesh(parentTransformation MeshTypes.Matrix) *MeshTypes.Mesh { - mesh := GenerateMeshes(&obj.GeometryList, parentTransformation) - mesh.Add(GenerateMeshes(&obj.AxisList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.FilterBeamList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.FilterColorList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.FilterGoboList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.FilterShaperList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.BeamList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.MediaServerLayerList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.MediaServerCameraList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.MediaServerMasterList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.DisplayList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.LaserList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.GeometryReferenceList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.WiringObjectList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.InventoryList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.StructureList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.SupportList, parentTransformation)) - mesh.Add(GenerateMeshes(&obj.MagnetList, parentTransformation)) - return mesh +func (obj *Geometries) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshes(&obj.GeometryList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.AxisList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.FilterBeamList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.FilterColorList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.FilterGoboList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.FilterShaperList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.BeamList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.MediaServerLayerList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.MediaServerCameraList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.MediaServerMasterList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.DisplayList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.LaserList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.GeometryReferenceList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.WiringObjectList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.InventoryList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.StructureList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.SupportList, parentTransformation, modelList) + modelList = GenerateMeshes(&obj.MagnetList, parentTransformation, modelList) + return modelList } type Geometry struct { - GeometryBase + Name string + Model NodeReference[Model] + Position Matrix + Geometries +} + +func (obj *Geometry) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Geometry) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Geometry) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Geometry) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Geometry) GetName() string { + return obj.Name +} + +func (obj *Geometry) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Geometry) GetPosition() Matrix { + return obj.Position +} + +func (obj *Geometry) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Geometry) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Geometry) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Geometry) SetName(name string) { + obj.Name = name +} + +func (obj *Geometry) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Geometry) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Geometry) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Geometry) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeGeometry) + return modelList } type Axis struct { - GeometryBase + Name string + Model NodeReference[Model] + Position Matrix + Geometries +} + +func (obj *Axis) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Axis) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Axis) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Axis) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Axis) GetName() string { + return obj.Name +} + +func (obj *Axis) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Axis) GetPosition() Matrix { + return obj.Position +} + +func (obj *Axis) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Axis) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Axis) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Axis) SetName(name string) { + obj.Name = name +} + +func (obj *Axis) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Axis) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Axis) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Axis) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeAxis) + return modelList } type FilterBeam struct { - GeometryBase + Name string + Model NodeReference[Model] + Position Matrix + Geometries +} + +func (obj *FilterBeam) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *FilterBeam) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *FilterBeam) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *FilterBeam) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *FilterBeam) GetName() string { + return obj.Name +} + +func (obj *FilterBeam) GetNamePtr() *string { + return &obj.Name +} + +func (obj *FilterBeam) GetPosition() Matrix { + return obj.Position +} + +func (obj *FilterBeam) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *FilterBeam) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *FilterBeam) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *FilterBeam) SetName(name string) { + obj.Name = name +} + +func (obj *FilterBeam) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *FilterBeam) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *FilterBeam) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *FilterBeam) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeFilterBeam) + return modelList } type FilterColor struct { - GeometryBase + Name string + Model NodeReference[Model] + Position Matrix + Geometries } -type FilterGobo struct { - GeometryBase +func (obj *FilterColor) GetGeometries() Geometries { + return obj.Geometries } -type FilterShaper struct { - GeometryBase +func (obj *FilterColor) GetGeometriesPtr() *Geometries { + return &obj.Geometries } -type Beam struct { - GeometryBase - LampType string - PowerConsumption float32 - LuminousFlux float32 - ColorTemperature float32 - BeamAngle float32 - FieldAngle float32 - ThrowRatio float32 - RectangleRatio float32 - BeamRadius float32 - BeamType string - CRI uint - EmitterSpectrum NodeReference[Emitter] +func (obj *FilterColor) GetModel() NodeReference[Model] { + return obj.Model } -func (obj *Beam) ResolveReference(refPointers *ReferencePointers) { - obj.EmitterSpectrum.Ptr = refPointers.Emitters[obj.EmitterSpectrum.String] - obj.GeometryBase.ResolveReference(refPointers) +func (obj *FilterColor) GetModelPtr() *NodeReference[Model] { + return &obj.Model } -type MediaServerLayer struct { - GeometryBase +func (obj *FilterColor) GetName() string { + return obj.Name } -type MediaServerCamera struct { - GeometryBase +func (obj *FilterColor) GetNamePtr() *string { + return &obj.Name } -type MediaServerMaster struct { - GeometryBase +func (obj *FilterColor) GetPosition() Matrix { + return obj.Position } -type Display struct { - GeometryBase - Texture FileReference +func (obj *FilterColor) GetPositionPtr() *Matrix { + return &obj.Position } -type GeometryReference struct { - Name string - Model NodeReference[Model] - Position Matrix - GeometryRef NodeReference[GeometryNodeReference] // only top level geometries allowed to be referenced - Breaks []*Break - // do we need to link a parent for this Geometry Type? +func (obj *FilterColor) SetGeometries(geometries Geometries) { + obj.Geometries = geometries } -func (obj *GeometryReference) ResolveReference(refPointers *ReferencePointers) { - obj.GeometryRef.Ptr = refPointers.Geometries[obj.GeometryRef.String] - obj.Model.Ptr = refPointers.Models[obj.Model.String] +func (obj *FilterColor) SetModel(model NodeReference[Model]) { + obj.Model = model } -func (obj *GeometryReference) GenerateMesh(parentTransformation MeshTypes.Matrix) *MeshTypes.Mesh { - var mesh *MeshTypes.Mesh - localTransformation := obj.Position.toMeshMatrix() - transformation := parentTransformation.Mul(localTransformation) - // if own model, replace parent mesh - if obj.Model.Ptr != nil { - temp := obj.Model.Ptr.Mesh.Copy() - mesh = &temp - geometries := obj.GeometryRef.Ptr.Ptr.(Geometries) - mesh.Add(geometries.GenerateMesh(transformation)) - } else { - ptr := obj.GeometryRef.Ptr.Ptr.(MeshGenerator) - mesh = ptr.GenerateMesh(transformation) - } - return mesh +func (obj *FilterColor) SetName(name string) { + obj.Name = name } -type Break struct { - DMXOffset DMXAddress - DMXBreak uint +func (obj *FilterColor) SetPosition(matrix Matrix) { + obj.Position = matrix } -type Laser struct { - GeometryBase - ColorType string // enum - Color float32 // Required if ColorType is “SingleWaveLength”; Unit:nm (nanometers) - OutputStrength float32 - Emitter NodeReference[Emitter] - BeamDiameter float32 - BeamDivergenceMin float32 - BeamDivergenceMax float32 - ScanAnglePan float32 - ScanAngleTilt float32 - ScanSpeed float32 - Protocols []*LaserProtocol +func (obj *FilterColor) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) } -func (obj *Laser) ResolveReference(refPointers *ReferencePointers) { - obj.Emitter.Ptr = refPointers.Emitters[obj.Emitter.String] - obj.GeometryBase.ResolveReference(refPointers) +func (obj *FilterColor) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) } -type LaserProtocol struct { - Name string +func (obj *FilterColor) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeFilterColor) + return modelList } -type WiringObject struct { - GeometryBase - ConnectorType string - ComponentType string //enum - SignalType string - PinCount int - ElectricalPayLoad float32 - VoltageRangeMax float32 - VoltageRangeMin float32 - FrequencyRangeMax float32 - FrequencyRangeMin float32 - MaxPayLoad float32 - Voltage float32 - SignalLayer int - CosPhi float32 - FuseCurrent float32 // in ampere - FuseRating string //enum - Orientation string //enum - WireGroup string - PinPatches []*PinPatch +type FilterGobo struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries } -func (obj *WiringObject) ResolveReference(refPointers *ReferencePointers) { - ResolveReferences(refPointers, &obj.PinPatches) - obj.GeometryBase.ResolveReference(refPointers) +func (obj *FilterGobo) GetGeometries() Geometries { + return obj.Geometries } -type PinPatch struct { - ToWiringObject NodeReference[WiringObject] - FromPin int - ToPin int +func (obj *FilterGobo) GetGeometriesPtr() *Geometries { + return &obj.Geometries } -func (obj *PinPatch) ResolveReference(refPointers *ReferencePointers) { - obj.ToWiringObject.Ptr = refPointers.WiringObjects[obj.ToWiringObject.String] +func (obj *FilterGobo) GetModel() NodeReference[Model] { + return obj.Model } -type Inventory struct { - GeometryBase - Count int +func (obj *FilterGobo) GetModelPtr() *NodeReference[Model] { + return &obj.Model } -type Structure struct { - GeometryBase - LinkedGeometry string // for now (analyse if this can be a NodeReference instead) - StructureType string // enum - CrossSectionType string // enum - CrossSectionHeight float32 - CrossSectionWallThickness float32 - TrussCrossSection string +func (obj *FilterGobo) GetName() string { + return obj.Name } -type Support struct { - GeometryBase - SupportType string //enum - RopeCrossSection string - RopeOffset Vector3 - CapacityX float32 - CapacityY float32 - CapacityZ float32 - CapacityXX float32 - CapacityYY float32 - CapacityZZ float32 - ResistanceX float32 - ResistanceY float32 - ResistanceZ float32 - ResistanceXX float32 - ResistanceYY float32 - ResistanceZZ float32 +func (obj *FilterGobo) GetNamePtr() *string { + return &obj.Name } -type Magnet struct { - GeometryBase +func (obj *FilterGobo) GetPosition() Matrix { + return obj.Position +} + +func (obj *FilterGobo) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *FilterGobo) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *FilterGobo) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *FilterGobo) SetName(name string) { + obj.Name = name +} + +func (obj *FilterGobo) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *FilterGobo) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *FilterGobo) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *FilterGobo) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeFilterGobo) + return modelList +} + +type FilterShaper struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries +} + +func (obj *FilterShaper) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *FilterShaper) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *FilterShaper) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *FilterShaper) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *FilterShaper) GetName() string { + return obj.Name +} + +func (obj *FilterShaper) GetNamePtr() *string { + return &obj.Name +} + +func (obj *FilterShaper) GetPosition() Matrix { + return obj.Position +} + +func (obj *FilterShaper) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *FilterShaper) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *FilterShaper) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *FilterShaper) SetName(name string) { + obj.Name = name +} + +func (obj *FilterShaper) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *FilterShaper) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *FilterShaper) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *FilterShaper) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeFilterShaper) + return modelList +} + +type Beam struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries + LampType string + PowerConsumption float32 + LuminousFlux float32 + ColorTemperature float32 + BeamAngle float32 + FieldAngle float32 + ThrowRatio float32 + RectangleRatio float32 + BeamRadius float32 + BeamType string + CRI uint + EmitterSpectrum NodeReference[Emitter] +} + +func (obj *Beam) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Beam) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Beam) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Beam) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Beam) GetName() string { + return obj.Name +} + +func (obj *Beam) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Beam) GetPosition() Matrix { + return obj.Position +} + +func (obj *Beam) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Beam) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Beam) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Beam) SetName(name string) { + obj.Name = name +} + +func (obj *Beam) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Beam) ResolveReference(refPointers *ReferencePointers) { + obj.EmitterSpectrum.Ptr = refPointers.Emitters[obj.EmitterSpectrum.String] + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Beam) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Beam) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeBeam) + return modelList +} + +type MediaServerLayer struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries +} + +func (obj *MediaServerLayer) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *MediaServerLayer) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *MediaServerLayer) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *MediaServerLayer) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *MediaServerLayer) GetName() string { + return obj.Name +} + +func (obj *MediaServerLayer) GetNamePtr() *string { + return &obj.Name +} + +func (obj *MediaServerLayer) GetPosition() Matrix { + return obj.Position +} + +func (obj *MediaServerLayer) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *MediaServerLayer) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *MediaServerLayer) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *MediaServerLayer) SetName(name string) { + obj.Name = name +} + +func (obj *MediaServerLayer) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *MediaServerLayer) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *MediaServerLayer) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *MediaServerLayer) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeMediaServerLayer) + return modelList +} + +type MediaServerCamera struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries +} + +func (obj *MediaServerCamera) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *MediaServerCamera) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *MediaServerCamera) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *MediaServerCamera) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *MediaServerCamera) GetName() string { + return obj.Name +} + +func (obj *MediaServerCamera) GetNamePtr() *string { + return &obj.Name +} + +func (obj *MediaServerCamera) GetPosition() Matrix { + return obj.Position +} + +func (obj *MediaServerCamera) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *MediaServerCamera) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *MediaServerCamera) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *MediaServerCamera) SetName(name string) { + obj.Name = name +} + +func (obj *MediaServerCamera) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *MediaServerCamera) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *MediaServerCamera) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *MediaServerCamera) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeMediaServerCamera) + return modelList +} + +type MediaServerMaster struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries +} + +func (obj *MediaServerMaster) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *MediaServerMaster) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *MediaServerMaster) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *MediaServerMaster) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *MediaServerMaster) GetName() string { + return obj.Name +} + +func (obj *MediaServerMaster) GetNamePtr() *string { + return &obj.Name +} + +func (obj *MediaServerMaster) GetPosition() Matrix { + return obj.Position +} + +func (obj *MediaServerMaster) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *MediaServerMaster) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *MediaServerMaster) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *MediaServerMaster) SetName(name string) { + obj.Name = name +} + +func (obj *MediaServerMaster) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *MediaServerMaster) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *MediaServerMaster) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *MediaServerMaster) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeMediaServerMaster) + return modelList +} + +type Display struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries + Texture FileReference +} + +func (obj *Display) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Display) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Display) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Display) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Display) GetName() string { + return obj.Name +} + +func (obj *Display) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Display) GetPosition() Matrix { + return obj.Position +} + +func (obj *Display) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Display) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Display) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Display) SetName(name string) { + obj.Name = name +} + +func (obj *Display) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Display) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Display) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Display) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeDisplay) + return modelList +} + +type GeometryReference struct { + Name string + Model NodeReference[Model] + Position Matrix + GeometryRef NodeReference[GeometryNodeReference] // only top level geometries allowed to be referenced + Breaks []*Break + // do we need to link a parent for this Geometry Type? +} + +func (obj *GeometryReference) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *GeometryReference) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *GeometryReference) GetName() string { + return obj.Name +} + +func (obj *GeometryReference) GetNamePtr() *string { + return &obj.Name +} + +func (obj *GeometryReference) GetPosition() Matrix { + return obj.Position +} + +func (obj *GeometryReference) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *GeometryReference) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *GeometryReference) SetName(name string) { + obj.Name = name +} + +func (obj *GeometryReference) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *GeometryReference) ResolveReference(refPointers *ReferencePointers) { + obj.GeometryRef.Ptr = refPointers.Geometries[obj.GeometryRef.String] + obj.Model.Ptr = refPointers.Models[obj.Model.String] +} + +// func (obj *GeometryReference) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { +// CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +// } + +func (obj *GeometryReference) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + // var mesh *MeshTypes.Mesh + localTransformation := obj.Position.toMeshMatrix() + transformation := parentTransformation.Mul(localTransformation) + // if own model, replace parent mesh + modelList, _ = GenerateMesh(obj, transformation, modelList, GeometryTypeGeometryReference) + return modelList + // if obj.Model.Ptr != nil { + // // temp := obj.Model.Ptr.Mesh.Copy() + // // mesh = &temp + // // geometries := obj.GeometryRef.Ptr.Ptr + // } else { + // ptr := obj.GeometryRef.Ptr.Ptr + // mesh := ptr.GenerateMesh(transformation) + // } +} + +type Break struct { + DMXOffset DMXAddress + DMXBreak uint +} + +type Laser struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries + ColorType string // enum + Color float32 // Required if ColorType is “SingleWaveLength”; Unit:nm (nanometers) + OutputStrength float32 + Emitter NodeReference[Emitter] + BeamDiameter float32 + BeamDivergenceMin float32 + BeamDivergenceMax float32 + ScanAnglePan float32 + ScanAngleTilt float32 + ScanSpeed float32 + Protocols []*LaserProtocol +} + +func (obj *Laser) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Laser) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Laser) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Laser) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Laser) GetName() string { + return obj.Name +} + +func (obj *Laser) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Laser) GetPosition() Matrix { + return obj.Position +} + +func (obj *Laser) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Laser) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Laser) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Laser) SetName(name string) { + obj.Name = name +} + +func (obj *Laser) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Laser) ResolveReference(refPointers *ReferencePointers) { + obj.Emitter.Ptr = refPointers.Emitters[obj.Emitter.String] + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Laser) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Laser) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeLaser) + return modelList +} + +type LaserProtocol struct { + Name string +} + +type WiringObject struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries + ConnectorType string + ComponentType string //enum + SignalType string + PinCount int + ElectricalPayLoad float32 + VoltageRangeMax float32 + VoltageRangeMin float32 + FrequencyRangeMax float32 + FrequencyRangeMin float32 + MaxPayLoad float32 + Voltage float32 + SignalLayer int + CosPhi float32 + FuseCurrent float32 // in ampere + FuseRating string //enum + Orientation string //enum + WireGroup string + PinPatches []*PinPatch +} + +func (obj *WiringObject) ResolveReference(refPointers *ReferencePointers) { + ResolveReferences(refPointers, &obj.PinPatches) + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *WiringObject) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *WiringObject) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *WiringObject) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *WiringObject) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *WiringObject) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *WiringObject) GetName() string { + return obj.Name +} + +func (obj *WiringObject) GetNamePtr() *string { + return &obj.Name +} + +func (obj *WiringObject) GetPosition() Matrix { + return obj.Position +} + +func (obj *WiringObject) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *WiringObject) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *WiringObject) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *WiringObject) SetName(name string) { + obj.Name = name +} + +func (obj *WiringObject) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *WiringObject) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeWiringObject) + return modelList +} + +type PinPatch struct { + ToWiringObject NodeReference[WiringObject] + FromPin int + ToPin int +} + +func (obj *PinPatch) ResolveReference(refPointers *ReferencePointers) { + obj.ToWiringObject.Ptr = refPointers.WiringObjects[obj.ToWiringObject.String] +} + +type Inventory struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries + Count int +} + +func (obj *Inventory) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Inventory) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Inventory) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Inventory) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Inventory) GetName() string { + return obj.Name +} + +func (obj *Inventory) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Inventory) GetPosition() Matrix { + return obj.Position +} + +func (obj *Inventory) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Inventory) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Inventory) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Inventory) SetName(name string) { + obj.Name = name +} + +func (obj *Inventory) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Inventory) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Inventory) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Inventory) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeInventory) + return modelList +} + +type Structure struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries + LinkedGeometry string // for now (analyse if this can be a NodeReference instead) + StructureType string // enum + CrossSectionType string // enum + CrossSectionHeight float32 + CrossSectionWallThickness float32 + TrussCrossSection string +} + +func (obj *Structure) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Structure) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Structure) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Structure) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Structure) GetName() string { + return obj.Name +} + +func (obj *Structure) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Structure) GetPosition() Matrix { + return obj.Position +} + +func (obj *Structure) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Structure) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Structure) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Structure) SetName(name string) { + obj.Name = name +} + +func (obj *Structure) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Structure) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Structure) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Structure) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeStructure) + return modelList +} + +type Support struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries + SupportType string //enum + RopeCrossSection string + RopeOffset Vector3 + CapacityX float32 + CapacityY float32 + CapacityZ float32 + CapacityXX float32 + CapacityYY float32 + CapacityZZ float32 + ResistanceX float32 + ResistanceY float32 + ResistanceZ float32 + ResistanceXX float32 + ResistanceYY float32 + ResistanceZZ float32 +} + +func (obj *Support) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Support) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Support) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Support) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Support) GetName() string { + return obj.Name +} + +func (obj *Support) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Support) GetPosition() Matrix { + return obj.Position +} + +func (obj *Support) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Support) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Support) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Support) SetName(name string) { + obj.Name = name +} + +func (obj *Support) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Support) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Support) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Support) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeSupport) + return modelList +} + +type Magnet struct { + Name string + Model NodeReference[Model] + Position Matrix + Geometries +} + +func (obj *Magnet) GetGeometries() Geometries { + return obj.Geometries +} + +func (obj *Magnet) GetGeometriesPtr() *Geometries { + return &obj.Geometries +} + +func (obj *Magnet) GetModel() NodeReference[Model] { + return obj.Model +} + +func (obj *Magnet) GetModelPtr() *NodeReference[Model] { + return &obj.Model +} + +func (obj *Magnet) GetName() string { + return obj.Name +} + +func (obj *Magnet) GetNamePtr() *string { + return &obj.Name +} + +func (obj *Magnet) GetPosition() Matrix { + return obj.Position +} + +func (obj *Magnet) GetPositionPtr() *Matrix { + return &obj.Position +} + +func (obj *Magnet) SetGeometries(geometries Geometries) { + obj.Geometries = geometries +} + +func (obj *Magnet) SetModel(model NodeReference[Model]) { + obj.Model = model +} + +func (obj *Magnet) SetName(name string) { + obj.Name = name +} + +func (obj *Magnet) SetPosition(matrix Matrix) { + obj.Position = matrix +} + +func (obj *Magnet) ResolveReference(refPointers *ReferencePointers) { + ResolveGeometryWithChildsReference(obj, refPointers) +} + +func (obj *Magnet) CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string) { + CreateGeometryWithChildsReferencePointer(obj, refPointers, parentPrefix) +} + +func (obj *Magnet) GenerateMesh(parentTransformation MeshTypes.Matrix, modelList []MeshModel) []MeshModel { + modelList = GenerateMeshWithChildren(obj, parentTransformation, modelList, GeometryTypeMagnet) + return modelList } From 6a21317dea8c717baaba3373b31616ca6327c1e1 Mon Sep 17 00:00:00 2001 From: Jannik-Hm Date: Thu, 19 Feb 2026 23:21:04 +0100 Subject: [PATCH 3/7] update mesh build functions (breaking change) --- pkg/types/dmxmode.go | 1 + pkg/types/gdtf.go | 5 +++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/pkg/types/dmxmode.go b/pkg/types/dmxmode.go index 92ae32f..f522ec2 100644 --- a/pkg/types/dmxmode.go +++ b/pkg/types/dmxmode.go @@ -7,6 +7,7 @@ type DMXMode struct { DMXChannels []*DMXChannel Relations []*Relation FTMacros []*FTMacro + MeshModels []MeshModel } func (obj *DMXMode) CreateReferencePointer(refPointers *ReferencePointers) { diff --git a/pkg/types/gdtf.go b/pkg/types/gdtf.go index db36e7c..cc887c6 100644 --- a/pkg/types/gdtf.go +++ b/pkg/types/gdtf.go @@ -20,10 +20,11 @@ func (obj *GDTF) ResolveReference(refPointers *ReferencePointers) { } // Assemble a mesh based on entire geometry -func (obj *GDTF) BuildMesh(dmxMode string) (*MeshTypes.Mesh, error) { +func (obj *GDTF) BuildMesh(dmxMode string) ([]MeshModel, error) { mode := obj.FixtureType.DMXModes[dmxMode] if mode == nil { return nil, fmt.Errorf("unknown DMX Mode '%s' in Fixture %s", dmxMode, obj.FixtureType.Name) } - return obj.FixtureType.DMXModes[dmxMode].Geometry.Ptr.Ptr.(MeshGenerator).GenerateMesh(MeshTypes.IdentityMatrix()), nil + obj.FixtureType.DMXModes[dmxMode].MeshModels = obj.FixtureType.DMXModes[dmxMode].Geometry.Ptr.Ptr.GenerateMesh(MeshTypes.IdentityMatrix(), obj.FixtureType.DMXModes[dmxMode].MeshModels) + return obj.FixtureType.DMXModes[dmxMode].MeshModels, nil } From 566b908441e564b6ff0ba242bebb79a8af34b11e Mon Sep 17 00:00:00 2001 From: Jannik-Hm Date: Thu, 19 Feb 2026 23:21:23 +0100 Subject: [PATCH 4/7] update example --- examples/parse-gdtf.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/examples/parse-gdtf.go b/examples/parse-gdtf.go index 506179b..53be994 100644 --- a/examples/parse-gdtf.go +++ b/examples/parse-gdtf.go @@ -6,6 +6,7 @@ import ( "os" GDTFMeshReader "github.com/Patch2PDF/GDTF-Mesh-Reader" + "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" GDTFParser "github.com/Patch2PDF/GDTF-Parser" STL "github.com/Patch2PDF/GDTF-Parser/examples/stl" ) @@ -25,11 +26,15 @@ func main() { fmt.Printf("%+v\n", *gdtf) // build gdtf model (by dmx mode) - mesh, err := gdtf.BuildMesh("32Ch") + models, err := gdtf.BuildMesh("32Ch") if err != nil { log.Fatal(err) } // write mesh as STL + mesh := &MeshTypes.Mesh{} + for _, entry := range models { + mesh.Add(&entry.Mesh) + } f, _ := os.Create("Test.stl") STL.WriteBinary(f, mesh) f.Close() From b10e2a91f1d4a5dba24c57454d1020db29bb34e8 Mon Sep 17 00:00:00 2001 From: Jannik-Hm Date: Fri, 20 Feb 2026 16:39:53 +0100 Subject: [PATCH 5/7] small adjustment to meshmodel copy func --- pkg/types/meshmodel.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/types/meshmodel.go b/pkg/types/meshmodel.go index 05ecfbf..f066930 100644 --- a/pkg/types/meshmodel.go +++ b/pkg/types/meshmodel.go @@ -8,7 +8,7 @@ type MeshModel struct { GeometryPtr GeometryModel } -func (obj *MeshModel) Copy() MeshModel { +func (obj MeshModel) Copy() MeshModel { return MeshModel{ Mesh: obj.Mesh.Copy(), GeometryType: obj.GeometryType, From f49a099e58f5e36180831f3375531a0cd402a61e Mon Sep 17 00:00:00 2001 From: Jannik-Hm Date: Sat, 21 Feb 2026 16:15:45 +0100 Subject: [PATCH 6/7] bump mesh reader module --- examples/parse-gdtf.go | 4 ++-- examples/stl/stl-writer.go | 4 ++-- gdtf-parser.go | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- pkg/types/gdtf.go | 2 +- pkg/types/general.go | 2 +- pkg/types/geometry.go | 2 +- pkg/types/meshmodel.go | 2 +- pkg/types/model.go | 2 +- 10 files changed, 14 insertions(+), 14 deletions(-) diff --git a/examples/parse-gdtf.go b/examples/parse-gdtf.go index 53be994..d448e69 100644 --- a/examples/parse-gdtf.go +++ b/examples/parse-gdtf.go @@ -5,8 +5,8 @@ import ( "log" "os" - GDTFMeshReader "github.com/Patch2PDF/GDTF-Mesh-Reader" - "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" + GDTFMeshReader "github.com/Patch2PDF/GDTF-Mesh-Reader/v2" + "github.com/Patch2PDF/GDTF-Mesh-Reader/v2/pkg/MeshTypes" GDTFParser "github.com/Patch2PDF/GDTF-Parser" STL "github.com/Patch2PDF/GDTF-Parser/examples/stl" ) diff --git a/examples/stl/stl-writer.go b/examples/stl/stl-writer.go index 8085bc0..ce9fc18 100644 --- a/examples/stl/stl-writer.go +++ b/examples/stl/stl-writer.go @@ -4,11 +4,11 @@ import ( "encoding/binary" "io" - "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" + "github.com/Patch2PDF/GDTF-Mesh-Reader/v2/pkg/MeshTypes" ) // helper for `WriteBinary` -func computeNormal(t *MeshTypes.Triangle) MeshTypes.Vector { +func computeNormal(t MeshTypes.Triangle) MeshTypes.Vector { // edge vectors a := t.V1.Position.Sub(t.V0.Position) diff --git a/gdtf-parser.go b/gdtf-parser.go index 838e6e3..62554ab 100644 --- a/gdtf-parser.go +++ b/gdtf-parser.go @@ -11,8 +11,8 @@ import ( "log" "path/filepath" - GDTFMeshReader "github.com/Patch2PDF/GDTF-Mesh-Reader" - "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" + GDTFMeshReader "github.com/Patch2PDF/GDTF-Mesh-Reader/v2" + "github.com/Patch2PDF/GDTF-Mesh-Reader/v2/pkg/MeshTypes" XMLTypes "github.com/Patch2PDF/GDTF-Parser/internal/types/gdtfxml" Types "github.com/Patch2PDF/GDTF-Parser/pkg/types" ) diff --git a/go.mod b/go.mod index 523a02c..90ec2ef 100644 --- a/go.mod +++ b/go.mod @@ -2,7 +2,7 @@ module github.com/Patch2PDF/GDTF-Parser go 1.25.4 -require github.com/Patch2PDF/GDTF-Mesh-Reader v1.1.2 +require github.com/Patch2PDF/GDTF-Mesh-Reader/v2 v2.0.1 require ( github.com/google/go-cmp v0.7.0 diff --git a/go.sum b/go.sum index 3352e8d..914bddd 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,5 @@ -github.com/Patch2PDF/GDTF-Mesh-Reader v1.1.2 h1:4LHeQjH+cwRoXuv+O4X9YoJaZAO/DihGGN5t3jVIFFk= -github.com/Patch2PDF/GDTF-Mesh-Reader v1.1.2/go.mod h1:4Uipj5UA1HhD3v032aSnEFlpItN80UY5zKB15mIeVwQ= +github.com/Patch2PDF/GDTF-Mesh-Reader/v2 v2.0.1 h1:xc6xxlDRv9s19um206MW6lYsZU7sXOfHgROuo7PxTZg= +github.com/Patch2PDF/GDTF-Mesh-Reader/v2 v2.0.1/go.mod h1:zAcGHlYdE75hdFo624nQfQHTzw9+NfPJT8Eo2mB1lI8= github.com/go-test/deep v1.0.1 h1:UQhStjbkDClarlmv0am7OXXO4/GaPdCGiUiMTvi28sg= github.com/go-test/deep v1.0.1/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= diff --git a/pkg/types/gdtf.go b/pkg/types/gdtf.go index cc887c6..99c207d 100644 --- a/pkg/types/gdtf.go +++ b/pkg/types/gdtf.go @@ -3,7 +3,7 @@ package Types import ( "fmt" - "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" + "github.com/Patch2PDF/GDTF-Mesh-Reader/v2/pkg/MeshTypes" ) type GDTF struct { diff --git a/pkg/types/general.go b/pkg/types/general.go index 831f443..ff3d88c 100644 --- a/pkg/types/general.go +++ b/pkg/types/general.go @@ -1,6 +1,6 @@ package Types -import "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" +import "github.com/Patch2PDF/GDTF-Mesh-Reader/v2/pkg/MeshTypes" // TODO: DMXValue Type // see gdtf https://www.gdtf.eu/gdtf/file-spec/file-format-definition/#attrtype-dmxvalue diff --git a/pkg/types/geometry.go b/pkg/types/geometry.go index 367dbc8..f96e6b9 100644 --- a/pkg/types/geometry.go +++ b/pkg/types/geometry.go @@ -4,7 +4,7 @@ import ( "reflect" "strings" - "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" + "github.com/Patch2PDF/GDTF-Mesh-Reader/v2/pkg/MeshTypes" ) type GeometryType int diff --git a/pkg/types/meshmodel.go b/pkg/types/meshmodel.go index f066930..8b0c9d3 100644 --- a/pkg/types/meshmodel.go +++ b/pkg/types/meshmodel.go @@ -1,6 +1,6 @@ package Types -import "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" +import "github.com/Patch2PDF/GDTF-Mesh-Reader/v2/pkg/MeshTypes" type MeshModel struct { Mesh MeshTypes.Mesh diff --git a/pkg/types/model.go b/pkg/types/model.go index 23741fb..8021470 100644 --- a/pkg/types/model.go +++ b/pkg/types/model.go @@ -1,6 +1,6 @@ package Types -import "github.com/Patch2PDF/GDTF-Mesh-Reader/pkg/MeshTypes" +import "github.com/Patch2PDF/GDTF-Mesh-Reader/v2/pkg/MeshTypes" type Model struct { Name string From 77e4dfea06a28e9190db2129fffdba2f8b7dffb8 Mon Sep 17 00:00:00 2001 From: Jannik-Hm Date: Sat, 21 Feb 2026 16:17:17 +0100 Subject: [PATCH 7/7] added check if mesh already exists for given dmx mode in mesh builder --- pkg/types/gdtf.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pkg/types/gdtf.go b/pkg/types/gdtf.go index 99c207d..c78d2ac 100644 --- a/pkg/types/gdtf.go +++ b/pkg/types/gdtf.go @@ -25,6 +25,9 @@ func (obj *GDTF) BuildMesh(dmxMode string) ([]MeshModel, error) { if mode == nil { return nil, fmt.Errorf("unknown DMX Mode '%s' in Fixture %s", dmxMode, obj.FixtureType.Name) } + if len(obj.FixtureType.DMXModes[dmxMode].MeshModels) != 0 { + return obj.FixtureType.DMXModes[dmxMode].MeshModels, nil + } obj.FixtureType.DMXModes[dmxMode].MeshModels = obj.FixtureType.DMXModes[dmxMode].Geometry.Ptr.Ptr.GenerateMesh(MeshTypes.IdentityMatrix(), obj.FixtureType.DMXModes[dmxMode].MeshModels) return obj.FixtureType.DMXModes[dmxMode].MeshModels, nil }