KiCad PCB EDA Suite
WRL2SHAPE Class Reference

#include <vrml2_shape.h>

Inheritance diagram for WRL2SHAPE:
WRL2NODE

Public Member Functions

 WRL2SHAPE ()
 
 WRL2SHAPE (WRL2NODE *aParent)
 
virtual ~WRL2SHAPE ()
 
bool Read (WRLPROC &proc, WRL2BASE *aTopNode) override
 
bool AddRefNode (WRL2NODE *aNode) override
 
bool AddChildNode (WRL2NODE *aNode) override
 
SGNODETranslateToSG (SGNODE *aParent) override
 Produce a representation of the data using the intermediate scenegraph structures of the kicad_3dsg library. More...
 
bool isDangling (void) override
 Determine whether an object should be moved to a different parent during the VRML to SG* translation. More...
 
WRL2NODES GetNodeType (void) const
 
WRL2NODEGetParent (void) const
 
virtual bool SetParent (WRL2NODE *aParent, bool doUnlink=true)
 Set the parent WRL2NODE of this object. More...
 
virtual std::string GetName (void)
 
virtual bool SetName (const std::string &aName)
 
const char * GetNodeTypeName (WRL2NODES aNodeType) const
 
virtual WRL2NODEFindNode (const std::string &aNodeName, const WRL2NODE *aCaller)
 Search the tree of linked nodes and returns a reference to the first node found with the given name. More...
 
std::string GetError (void)
 
WRL2NODES getNodeTypeID (const std::string &aNodeName)
 
void addNodeRef (WRL2NODE *aNode)
 Add a pointer to a node which references but does not own this node. More...
 
void delNodeRef (WRL2NODE *aNode)
 Remove a pointer to a node which references but does not own this node. More...
 

Protected Attributes

WRL2NODEm_Parent
 
WRL2NODES m_Type
 
std::string m_Name
 
std::list< WRL2NODE * > m_BackPointers
 
std::list< WRL2NODE * > m_Children
 
std::list< WRL2NODE * > m_Refs
 
std::string m_error
 
SGNODEm_sgNode
 

Private Member Functions

bool checkNodeType (WRL2NODES aType)
 
void unlinkChildNode (const WRL2NODE *aNode) override
 Remove references to an owned child. More...
 
void unlinkRefNode (const WRL2NODE *aNode) override
 Remove pointers to a referenced node. More...
 

Private Attributes

WRL2NODEappearance
 
WRL2NODEgeometry
 

Detailed Description

Definition at line 38 of file vrml2_shape.h.

Constructor & Destructor Documentation

◆ WRL2SHAPE() [1/2]

WRL2SHAPE::WRL2SHAPE ( )

Definition at line 36 of file vrml2_shape.cpp.

36 : WRL2NODE()
37{
38 appearance = nullptr;
39 geometry = nullptr;
41}
WRL2NODES m_Type
Definition: vrml2_node.h:170
WRL2NODE * geometry
Definition: vrml2_shape.h:62
WRL2NODE * appearance
Definition: vrml2_shape.h:61

References appearance, geometry, WRL2NODE::m_Type, and WRL2_SHAPE.

◆ WRL2SHAPE() [2/2]

WRL2SHAPE::WRL2SHAPE ( WRL2NODE aParent)

Definition at line 44 of file vrml2_shape.cpp.

44 : WRL2NODE()
45{
46 appearance = nullptr;
47 geometry = nullptr;
49 m_Parent = aParent;
50
51 if( nullptr != m_Parent )
52 m_Parent->AddChildNode( this );
53}
WRL2NODE * m_Parent
Definition: vrml2_node.h:169
virtual bool AddChildNode(WRL2NODE *aNode)
Definition: vrml2_node.cpp:356

References WRL2NODE::AddChildNode(), appearance, geometry, WRL2NODE::m_Parent, WRL2NODE::m_Type, and WRL2_SHAPE.

◆ ~WRL2SHAPE()

WRL2SHAPE::~WRL2SHAPE ( )
virtual

Definition at line 56 of file vrml2_shape.cpp.

57{
58 wxLogTrace( traceVrmlPlugin,
59 wxT( " * [INFO] Destroying Shape node with %zu children, %zu"
60 "references, and %zu back pointers." ),
61 m_Children.size(), m_Refs.size(), m_BackPointers.size() );
62}
std::list< WRL2NODE * > m_BackPointers
Definition: vrml2_node.h:173
std::list< WRL2NODE * > m_Children
Definition: vrml2_node.h:174
std::list< WRL2NODE * > m_Refs
Definition: vrml2_node.h:175
const wxChar *const traceVrmlPlugin
Flag to enable VRML plugin trace output.
Definition: vrml.cpp:63

References WRL2NODE::m_BackPointers, WRL2NODE::m_Children, WRL2NODE::m_Refs, and traceVrmlPlugin.

Member Function Documentation

◆ AddChildNode()

bool WRL2SHAPE::AddChildNode ( WRL2NODE aNode)
overridevirtual

Reimplemented from WRL2NODE.

Definition at line 127 of file vrml2_shape.cpp.

128{
129 wxCHECK_MSG( aNode, false, wxT( "Invalid node." ) );
130
131 WRL2NODES type = aNode->GetNodeType();
132
133 if( !checkNodeType( type ) )
134 {
135 wxLogTrace( traceVrmlPlugin,
136 wxT( "%s:%s:%d\n"
137 " * [INFO] bad file format; unexpected child node '%s'." ),
138 __FILE__, __FUNCTION__, __LINE__, aNode->GetNodeTypeName( type ) );
139
140 return false;
141 }
142
143 if( WRL2NODES::WRL2_APPEARANCE == type )
144 {
145 if( nullptr != appearance )
146 {
147 wxLogTrace( traceVrmlPlugin,
148 wxT( "%s:%s:%d\n"
149 " * [INFO] bad file format; multiple appearance nodes." ),
150 __FILE__, __FUNCTION__, __LINE__ );
151
152 return false;
153 }
154
155 appearance = aNode;
156 return WRL2NODE::AddChildNode( aNode );
157 }
158
159 if( nullptr != geometry )
160 {
161 wxLogTrace( traceVrmlPlugin,
162 wxT( "%s:%s:%d\n"
163 " * [INFO] bad file format; multiple geometry nodes." ),
164 __FILE__, __FUNCTION__, __LINE__ );
165
166 return false;
167 }
168
169 geometry = aNode;
170 return WRL2NODE::AddChildNode( aNode );
171}
const char * GetNodeTypeName(WRL2NODES aNodeType) const
Definition: vrml2_node.cpp:273
WRL2NODES GetNodeType(void) const
Definition: vrml2_node.cpp:204
bool checkNodeType(WRL2NODES aType)
WRL2NODES
Definition: wrltypes.h:125

References WRL2NODE::AddChildNode(), appearance, checkNodeType(), geometry, WRL2NODE::GetNodeType(), WRL2NODE::GetNodeTypeName(), traceVrmlPlugin, and WRL2_APPEARANCE.

◆ addNodeRef()

void WRL2NODE::addNodeRef ( WRL2NODE aNode)
inherited

Add a pointer to a node which references but does not own this node.

Such back-pointers are required to ensure that invalidated references are removed when a node is deleted.

Parameters
aNodeis the node holding a reference to this object.

Definition at line 171 of file vrml2_node.cpp.

172{
173 // the parent node must never be added as a backpointer
174 if( aNode == m_Parent )
175 return;
176
177 std::list< WRL2NODE* >::iterator np =
178 std::find( m_BackPointers.begin(), m_BackPointers.end(), aNode );
179
180 if( np != m_BackPointers.end() )
181 return;
182
183 m_BackPointers.push_back( aNode );
184}

References WRL2NODE::m_BackPointers, and WRL2NODE::m_Parent.

Referenced by WRL2NODE::AddRefNode().

◆ AddRefNode()

bool WRL2SHAPE::AddRefNode ( WRL2NODE aNode)
overridevirtual

Reimplemented from WRL2NODE.

Definition at line 80 of file vrml2_shape.cpp.

81{
82 wxCHECK_MSG( aNode, false, wxT( "Invalid node." ) );
83
84 WRL2NODES type = aNode->GetNodeType();
85
86 if( !checkNodeType( type ) )
87 {
88 wxLogTrace( traceVrmlPlugin,
89 wxT( "%s:%s:%d\n"
90 " * [INFO] bad file format; unexpected child node '%s'." ),
91 __FILE__, __FUNCTION__, __LINE__, aNode->GetNodeTypeName( type ) );
92
93 return false;
94 }
95
96 if( WRL2NODES::WRL2_APPEARANCE == type )
97 {
98 if( nullptr != appearance )
99 {
100 wxLogTrace( traceVrmlPlugin,
101 wxT( "%s:%s:%d\n"
102 " * [INFO] bad file format; multiple appearance nodes." ),
103 __FILE__, __FUNCTION__, __LINE__ );
104
105 return false;
106 }
107
108 appearance = aNode;
109 return WRL2NODE::AddRefNode( aNode );
110 }
111
112 if( nullptr != geometry )
113 {
114 wxLogTrace( traceVrmlPlugin,
115 wxT( "%s:%s:%d\n"
116 " * [INFO] bad file format; multiple geometry nodes." ),
117 __FILE__, __FUNCTION__, __LINE__ );
118
119 return false;
120 }
121
122 geometry = aNode;
123 return WRL2NODE::AddRefNode( aNode );
124}
virtual bool AddRefNode(WRL2NODE *aNode)
Definition: vrml2_node.cpp:383

References WRL2NODE::AddRefNode(), appearance, checkNodeType(), geometry, WRL2NODE::GetNodeType(), WRL2NODE::GetNodeTypeName(), traceVrmlPlugin, and WRL2_APPEARANCE.

◆ checkNodeType()

bool WRL2SHAPE::checkNodeType ( WRL2NODES  aType)
private
Returns
true if the node type is an appearance or geometry class.

Definition at line 174 of file vrml2_shape.cpp.

175{
176 switch( aType )
177 {
189 break;
190
191 default:
192 return false;
193 break;
194 }
195
196 return true;
197}
@ WRL2_INDEXEDFACESET
@ WRL2_INDEXEDLINESET
@ WRL2_ELEVATIONGRID

References WRL2_APPEARANCE, WRL2_BOX, WRL2_CONE, WRL2_CYLINDER, WRL2_ELEVATIONGRID, WRL2_EXTRUSION, WRL2_INDEXEDFACESET, WRL2_INDEXEDLINESET, WRL2_POINTSET, WRL2_SPHERE, and WRL2_TEXT.

Referenced by AddChildNode(), and AddRefNode().

◆ delNodeRef()

void WRL2NODE::delNodeRef ( WRL2NODE aNode)
inherited

Remove a pointer to a node which references but does not own this node.

Parameters
aNodeis the node holding a reference to this object

Definition at line 187 of file vrml2_node.cpp.

188{
189 std::list< WRL2NODE* >::iterator np =
190 std::find( m_BackPointers.begin(), m_BackPointers.end(), aNode );
191
192 if( np != m_BackPointers.end() )
193 {
194 m_BackPointers.erase( np );
195 return;
196 }
197
198 wxLogTrace( traceVrmlPlugin, wxT( "%s:%s:%d\n"
199 " * [BUG] delNodeRef() did not find its target." ),
200 __FILE__, __FUNCTION__, __LINE__ );
201}

References WRL2NODE::m_BackPointers, and traceVrmlPlugin.

◆ FindNode()

WRL2NODE * WRL2NODE::FindNode ( const std::string &  aNodeName,
const WRL2NODE aCaller 
)
virtualinherited

Search the tree of linked nodes and returns a reference to the first node found with the given name.

The reference is then typically added to another node via AddRefNode().

Parameters
aNodeNameis the name of the node to search for.
aCalleris a pointer to the node invoking this function.
Returns
is a valid node pointer on success or NULL.

Definition at line 305 of file vrml2_node.cpp.

306{
307 if( aNodeName.empty() )
308 return nullptr;
309
310 if( !m_Name.compare( aNodeName ) )
311 return this;
312
313 std::list< WRL2NODE* >::iterator sLA = m_Children.begin();
314 std::list< WRL2NODE* >::iterator eLA = m_Children.end();
315
316 WRL2NODE* psg = nullptr;
317
318 while( sLA != eLA )
319 {
320 if( *sLA != aCaller )
321 {
322 psg = (*sLA)->FindNode( aNodeName, this );
323
324 if( nullptr != psg )
325 return psg;
326
327 }
328
329 ++sLA;
330 }
331
332 if( nullptr != m_Parent && aCaller != m_Parent )
333 return m_Parent->FindNode( aNodeName, this );
334
335 return nullptr;
336}
std::string m_Name
Definition: vrml2_node.h:171
virtual WRL2NODE * FindNode(const std::string &aNodeName, const WRL2NODE *aCaller)
Search the tree of linked nodes and returns a reference to the first node found with the given name.
Definition: vrml2_node.cpp:305

References WRL2NODE::FindNode(), WRL2NODE::m_Children, WRL2NODE::m_Name, and WRL2NODE::m_Parent.

Referenced by WRL2NODE::FindNode(), and WRL2BASE::implementUse().

◆ GetError()

std::string WRL2NODE::GetError ( void  )
inherited

Definition at line 299 of file vrml2_node.cpp.

300{
301 return m_error;
302}
std::string m_error
Definition: vrml2_node.h:176

References WRL2NODE::m_error.

◆ GetName()

std::string WRL2NODE::GetName ( void  )
virtualinherited

Reimplemented in WRL2BASE.

Definition at line 216 of file vrml2_node.cpp.

217{
218 return m_Name;
219}

References WRL2NODE::m_Name.

◆ GetNodeType()

◆ getNodeTypeID()

WRL2NODES WRL2NODE::getNodeTypeID ( const std::string &  aNodeName)
inherited
Returns
The ID based on the given aNodeName or WRL2_INVALID (WRL2_END) if no such node name exists.

Definition at line 288 of file vrml2_node.cpp.

289{
290 NODEMAP::iterator it = nodenames.find( aNodeName );
291
292 if( nodenames.end() != it )
293 return it->second;
294
296}
static NODEMAP nodenames
Definition: vrml2_node.cpp:43

References nodenames, and WRL2_INVALID.

Referenced by WRL2BASE::ReadNode().

◆ GetNodeTypeName()

const char * WRL2NODE::GetNodeTypeName ( WRL2NODES  aNodeType) const
inherited

Definition at line 273 of file vrml2_node.cpp.

274{
275 if( aNodeType < WRL2NODES::WRL2_BASE || aNodeType >= WRL2NODES::WRL2_END )
276 return "*INVALID_TYPE*";
277
278 if( aNodeType == WRL2NODES::WRL2_BASE )
279 return "*VIRTUAL_BASE*";
280
281 NODEMAP::iterator it = nodenames.begin();
282 advance( it, (static_cast<int>( aNodeType ) - static_cast<int>( WRL2NODES::WRL2_BEGIN ) ) );
283
284 return it->first.c_str();
285}

References nodenames, WRL2_BASE, WRL2_BEGIN, and WRL2_END.

Referenced by WRL2APPEARANCE::AddChildNode(), WRL2FACESET::AddChildNode(), WRL2LINESET::AddChildNode(), WRL2POINTSET::AddChildNode(), AddChildNode(), WRL2APPEARANCE::AddRefNode(), WRL2FACESET::AddRefNode(), WRL2LINESET::AddRefNode(), WRL2POINTSET::AddRefNode(), and AddRefNode().

◆ GetParent()

WRL2NODE * WRL2NODE::GetParent ( void  ) const
inherited

◆ isDangling()

bool WRL2SHAPE::isDangling ( void  )
overridevirtual

Determine whether an object should be moved to a different parent during the VRML to SG* translation.

Returns
true if the object does not have a parent which is a logical container for the object for example if a Shape has a parent which is a Base node.

Implements WRL2NODE.

Definition at line 65 of file vrml2_shape.cpp.

66{
67 // this node is dangling unless it has a parent of type:
68 // WRL2_TRANSFORM
69 // WRL2_SWITCH
70
71 if( nullptr == m_Parent
74 return true;
75
76 return false;
77}

References WRL2NODE::GetNodeType(), WRL2NODE::m_Parent, WRL2_SWITCH, and WRL2_TRANSFORM.

◆ Read()

bool WRL2SHAPE::Read ( WRLPROC proc,
WRL2BASE aTopNode 
)
overridevirtual

Implements WRL2NODE.

Definition at line 200 of file vrml2_shape.cpp.

201{
202 wxCHECK_MSG( aTopNode, false, wxT( "Invalid top node." ) );
203
204 char tok = proc.Peek();
205
206 if( proc.eof() )
207 {
208 wxLogTrace( traceVrmlPlugin, wxT( "%s:%s:%d\n"
209 " * [INFO] bad file format; unexpected eof %s." ),
210 __FILE__, __FUNCTION__, __LINE__, proc.GetFilePosition() );
211
212 return false;
213 }
214
215 if( '{' != tok )
216 {
217 wxLogTrace( traceVrmlPlugin,
218 wxT( "%s:%s:%d\n"
219 " * [INFO] bad file format; expecting '{' but got '%s' %s." ),
220 __FILE__, __FUNCTION__, __LINE__, tok, proc.GetFilePosition() );
221
222 return false;
223 }
224
225 proc.Pop();
226 std::string glob;
227
228 while( true )
229 {
230 if( proc.Peek() == '}' )
231 {
232 proc.Pop();
233 break;
234 }
235
236 if( !proc.ReadName( glob ) )
237 {
238 wxLogTrace( traceVrmlPlugin, wxT( "%s:%s:%d\n"
239 "%s" ),
240 __FILE__, __FUNCTION__, __LINE__ , proc.GetError() );
241
242 return false;
243 }
244
245 // expecting one of:
246 // appearance
247 // geometry
248 if( !glob.compare( "appearance" ) )
249 {
250 if( !aTopNode->ReadNode( proc, this, nullptr ) )
251 {
252 wxLogTrace( traceVrmlPlugin,
253 wxT( "%s:%s:%d\n"
254 " * [INFO] could not read appearance node information." ),
255 __FILE__, __FUNCTION__, __LINE__ );
256
257 return false;
258 }
259 }
260 else if( !glob.compare( "geometry" ) )
261 {
262 if( !aTopNode->ReadNode( proc, this, nullptr ) )
263 {
264 wxLogTrace( traceVrmlPlugin,
265 wxT( "%s:%s:%d\n"
266 " * [INFO] could not read geometry node information." ),
267 __FILE__, __FUNCTION__, __LINE__ );
268
269 return false;
270 }
271 }
272 else
273 {
274 wxLogTrace( traceVrmlPlugin,
275 wxT( "%s:%s:%d\n"
276 " * [INFO] invalid Shape %s.\n"
277 " * [INFO] file: '%s'\n" ),
278 __FILE__, __FUNCTION__, __LINE__, proc.GetFilePosition(),
279 proc.GetFileName() );
280
281 return false;
282 }
283 } // while( true ) -- reading contents of Shape{}
284
285 return true;
286}
bool ReadNode(WRLPROC &proc, WRL2NODE *aParent, WRL2NODE **aNode)
Definition: vrml2_base.cpp:277
void Pop(void)
Definition: wrlproc.cpp:2035
char Peek(void)
Definition: wrlproc.cpp:2007
std::string GetFileName(void)
Definition: wrlproc.cpp:1995
std::string GetError(void)
Definition: wrlproc.cpp:1960
bool eof(void)
Definition: wrlproc.cpp:1954
bool ReadName(std::string &aName)
Definition: wrlproc.cpp:289
std::string GetFilePosition() const
Definition: wrlproc.cpp:1982

References WRLPROC::eof(), WRLPROC::GetError(), WRLPROC::GetFileName(), WRLPROC::GetFilePosition(), WRLPROC::Peek(), WRLPROC::Pop(), WRLPROC::ReadName(), WRL2BASE::ReadNode(), and traceVrmlPlugin.

Referenced by WRL2BASE::readShape().

◆ SetName()

bool WRL2NODE::SetName ( const std::string &  aName)
virtualinherited

Reimplemented in WRL2BASE.

Definition at line 222 of file vrml2_node.cpp.

223{
224 if( aName.empty() )
225 return false;
226
227 std::set< std::string >::iterator item = badNames.find( aName );
228
229 if( item != badNames.end() )
230 {
231 wxLogTrace( traceVrmlPlugin,
232 wxT( "%s:%s:%d\n"
233 " * [INFO] invalid node name '%s' (matches restricted word)" ),
234 __FILE__, __FUNCTION__, __LINE__, *item );
235
236 return false;
237 }
238
239
240 if( isdigit( aName[0] ) )
241 {
242 wxLogTrace( traceVrmlPlugin, wxT( "%s:%s:%d\n"
243 " * [INFO] invalid node name '%s' (begins with digit)" ),
244 __FILE__, __FUNCTION__, __LINE__, aName );
245
246 return false;
247 }
248
249 // The characters '+' and '-' are not allowed in names as per the VRML2 specification;
250 // however many parsers accept them and many bad generators use them so the rules
251 // have been relaxed here.
252 // #define BAD_CHARS1 "\"\'#+,-.\\[]{}\x00\x01\x02\x03\x04\x05\x06\x09\x0A\x0B\x0C\x0D\x0E\x0F"
253 #define BAD_CHARS1 "\"\'#,.\\[]{}\x00\x01\x02\x03\x04\x05\x06\x09\x0A\x0B\x0C\x0D\x0E\x0F"
254 #define BAD_CHARS2 "\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"
255
256 if( std::string::npos != aName.find_first_of( BAD_CHARS1 )
257 || std::string::npos != aName.find_first_of( BAD_CHARS2 ) )
258 {
259 wxLogTrace( traceVrmlPlugin,
260 wxT( "%s:%s:%d\n"
261 " * [INFO] invalid node name '%s' (contains invalid character)" ),
262 __FILE__, __FUNCTION__, __LINE__, aName );
263
264 return false;
265 }
266
267 m_Name = aName;
268
269 return true;
270}
#define BAD_CHARS2
#define BAD_CHARS1
static std::set< std::string > badNames
Definition: vrml2_node.cpp:39

References BAD_CHARS1, BAD_CHARS2, badNames, WRL2NODE::m_Name, and traceVrmlPlugin.

Referenced by WRL2BASE::implementDef().

◆ SetParent()

bool WRL2NODE::SetParent ( WRL2NODE aParent,
bool  doUnlink = true 
)
virtualinherited

Set the parent WRL2NODE of this object.

Parameters
aParent[in] is the desired parent node.
doUnlinkindicates that the child must be unlinked from the parent
Returns
true if the operation succeeds of false if the given node is not allowed to be a parent to the derived object.

Reimplemented in WRL2BASE.

Definition at line 339 of file vrml2_node.cpp.

340{
341 if( aParent == m_Parent )
342 return true;
343
344 if( nullptr != m_Parent && doUnlink )
345 m_Parent->unlinkChildNode( this );
346
347 m_Parent = aParent;
348
349 if( nullptr != m_Parent )
350 m_Parent->AddChildNode( this );
351
352 return true;
353}
virtual void unlinkChildNode(const WRL2NODE *aNode)
Remove references to an owned child.
Definition: vrml2_node.cpp:407

References WRL2NODE::AddChildNode(), WRL2NODE::m_Parent, and WRL2NODE::unlinkChildNode().

Referenced by WRL2NODE::AddChildNode(), WRL2SWITCH::AddRefNode(), and WRL2TRANSFORM::AddRefNode().

◆ TranslateToSG()

SGNODE * WRL2SHAPE::TranslateToSG ( SGNODE aParent)
overridevirtual

Produce a representation of the data using the intermediate scenegraph structures of the kicad_3dsg library.

Parameters
aParentis a pointer to the parent SG node.
Returns
is non-NULL on success.

Implements WRL2NODE.

Definition at line 289 of file vrml2_shape.cpp.

290{
291 if( nullptr == geometry )
292 return nullptr;
293
294 WRL2NODES geomType = geometry->GetNodeType();
295
296 switch( geomType )
297 {
301 return nullptr;
302 break;
303
304 default:
305 break;
306 }
307
308 wxLogTrace( traceVrmlPlugin,
309 wxT( " * [INFO] Translating Shape with %zu children, %zu references, and"
310 "%zu back pointers." ),
311 m_Children.size(), m_Refs.size(), m_BackPointers.size() );
312
313 bool vcolors = false;
314
316 vcolors = ((WRL2FACESET*)geometry)->HasColors();
317
318 // if there is no appearance, make use of the per vertex colors if available
319 if( nullptr == appearance )
320 {
322 return nullptr;
323
324 if( !vcolors )
325 return nullptr;
326 }
327
328 S3D::SGTYPES ptype = S3D::GetSGNodeType( aParent );
329
330 wxCHECK_MSG( aParent && ( ptype == S3D::SGTYPE_TRANSFORM ), nullptr,
331 wxString::Format( wxT( "Shape does not have a Transform parent (parent "
332 "ID: %d)." ), ptype ) );
333
334 if( m_sgNode )
335 {
336 if( nullptr != aParent )
337 {
338 if( nullptr == S3D::GetSGNodeParent( m_sgNode )
339 && !S3D::AddSGNodeChild( aParent, m_sgNode ) )
340 {
341 return nullptr;
342 }
343 else if( aParent != S3D::GetSGNodeParent( m_sgNode )
344 && !S3D::AddSGNodeRef( aParent, m_sgNode ) )
345 {
346 return nullptr;
347 }
348 }
349
350 return m_sgNode;
351 }
352
353 IFSG_SHAPE shNode( aParent );
354
355 SGNODE* pShape = shNode.GetRawPtr();
356 SGNODE* pGeom = geometry->TranslateToSG( pShape );
357
358 if( nullptr == pGeom )
359 {
360 // this can happen if a VRML file contains
361 // empty point or index sets
362 shNode.Destroy();
363 return nullptr;
364 }
365
366 SGNODE* pApp = nullptr;
367
368 if( nullptr != appearance )
369 pApp = appearance->TranslateToSG( pShape );
370
371 if( nullptr != appearance && nullptr == pApp )
372 {
373 IFSG_FACESET tmp( false );
374 tmp.Attach( pGeom );
375 tmp.Destroy();
376 shNode.Destroy();
377 return nullptr;
378 }
379
380 m_sgNode = shNode.GetRawPtr();
381
382 return m_sgNode;
383}
IFSG_FACESET is the wrapper for the SGFACESET class.
Definition: ifsg_faceset.h:41
IFSG_SHAPE is the wrapper for the SGSHAPE class.
Definition: ifsg_shape.h:41
The base class of all Scene Graph nodes.
Definition: sg_node.h:75
SGNODE * m_sgNode
Definition: vrml2_node.h:178
virtual SGNODE * TranslateToSG(SGNODE *aParent)=0
Produce a representation of the data using the intermediate scenegraph structures of the kicad_3dsg l...
SGLIB_API S3D::SGTYPES GetSGNodeType(SGNODE *aNode)
Definition: ifsg_api.cpp:485
SGLIB_API SGNODE * GetSGNodeParent(SGNODE *aNode)
Definition: ifsg_api.cpp:494
SGTYPES
Definition: sg_types.h:35
@ SGTYPE_TRANSFORM
Definition: sg_types.h:36
SGLIB_API bool AddSGNodeChild(SGNODE *aParent, SGNODE *aChild)
Definition: ifsg_api.cpp:512
SGLIB_API bool AddSGNodeRef(SGNODE *aParent, SGNODE *aChild)
Definition: ifsg_api.cpp:503
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200

References S3D::AddSGNodeChild(), S3D::AddSGNodeRef(), appearance, IFSG_FACESET::Attach(), IFSG_NODE::Destroy(), Format(), geometry, WRL2NODE::GetNodeType(), IFSG_NODE::GetRawPtr(), S3D::GetSGNodeParent(), S3D::GetSGNodeType(), WRL2NODE::m_BackPointers, WRL2NODE::m_Children, WRL2NODE::m_Refs, WRL2NODE::m_sgNode, S3D::SGTYPE_TRANSFORM, traceVrmlPlugin, WRL2NODE::TranslateToSG(), WRL2_INDEXEDFACESET, WRL2_INDEXEDLINESET, WRL2_POINTSET, and WRL2_TEXT.

◆ unlinkChildNode()

void WRL2SHAPE::unlinkChildNode ( const WRL2NODE aNode)
overrideprivatevirtual

Remove references to an owned child.

It is invoked by the child upon destruction to ensure that the parent has no invalid references.

Parameters
aNodeis the child which is being deleted.

Reimplemented from WRL2NODE.

Definition at line 386 of file vrml2_shape.cpp.

387{
388 if( nullptr == aNode )
389 return;
390
391 if( aNode == appearance )
392 appearance = nullptr;
393 else if( aNode == geometry )
394 geometry = nullptr;
395
397}

References appearance, geometry, and WRL2NODE::unlinkChildNode().

◆ unlinkRefNode()

void WRL2SHAPE::unlinkRefNode ( const WRL2NODE aNode)
overrideprivatevirtual

Remove pointers to a referenced node.

It is invoked by the referenced node upon destruction to ensure that the referring node has no invalid references.

Parameters
aNodeis the node which is being deleted.

Reimplemented from WRL2NODE.

Definition at line 400 of file vrml2_shape.cpp.

401{
402 if( nullptr == aNode )
403 return;
404
405 if( aNode == appearance )
406 appearance = nullptr;
407 else if( aNode == geometry )
408 geometry = nullptr;
409
411}
virtual void unlinkRefNode(const WRL2NODE *aNode)
Remove pointers to a referenced node.
Definition: vrml2_node.cpp:425

References appearance, geometry, and WRL2NODE::unlinkRefNode().

Member Data Documentation

◆ appearance

WRL2NODE* WRL2SHAPE::appearance
private

◆ geometry

WRL2NODE* WRL2SHAPE::geometry
private

◆ m_BackPointers

◆ m_Children

◆ m_error

std::string WRL2NODE::m_error
protectedinherited

Definition at line 176 of file vrml2_node.h.

Referenced by WRL2NODE::GetError().

◆ m_Name

std::string WRL2NODE::m_Name
protectedinherited

Definition at line 171 of file vrml2_node.h.

Referenced by WRL2NODE::FindNode(), WRL2NODE::GetName(), and WRL2NODE::SetName().

◆ m_Parent

◆ m_Refs

◆ m_sgNode

◆ m_Type


The documentation for this class was generated from the following files: