SGFACESET Class Reference

Define an indexed face set for a scenegraph. More...

#include <sg_faceset.h>

Inheritance diagram for SGFACESET:

Public Member Functions
	SGFACESET (SGNODE *aParent)
virtual	~SGFACESET ()
virtual bool	SetParent (SGNODE *aParent, bool notify=true) override
	Set the parent SGNODE of this object. More...
SGNODE *	FindNode (const char *aNodeName, const SGNODE *aCaller) override
	Search the tree of linked nodes and return a reference to the first node found with the given name. More...
bool	AddRefNode (SGNODE *aNode) override
bool	AddChildNode (SGNODE *aNode) override
bool	CalcNormals (SGNODE **aPtr)
void	ReNameNodes (void) override
	Rename a node and all its child nodes in preparation for write operations. More...
bool	WriteVRML (std::ostream &aFile, bool aReuseFlag) override
	Writes this node's data to a VRML file. More...
bool	WriteCache (std::ostream &aFile, SGNODE *parentNode) override
	Write this node's data to a binary cache file. More...
bool	ReadCache (std::istream &aFile, SGNODE *parentNode) override
	Reads binary format data from a cache file. More...
void	GatherCoordIndices (std::vector< int > &aIndexList)
	Add all internal coordinate indices to the given list in preparation for a normals calculation. More...
void	unlinkChildNode (const SGNODE *aNode) override
	Remove references to an owned child. More...
void	unlinkRefNode (const SGNODE *aNode) override
	Remove pointers to a referenced node. More...
bool	validate (void)
S3D::SGTYPES	GetNodeType (void) const noexcept
	Return the type of this node instance. More...
SGNODE *	GetParent (void) const noexcept
	Returns a pointer to the parent SGNODE of this object or NULL if the object has no parent (ie. More...
bool	SwapParent (SGNODE *aNewParent)
	Swap the ownership with the given parent. More...
const char *	GetName (void)
void	SetName (const char *aName)
const char *	GetNodeTypeName (S3D::SGTYPES aNodeType) const noexcept
void	AssociateWrapper (SGNODE **aWrapperRef) noexcept
	Associate this object with a handle to itself. More...
void	DisassociateWrapper (SGNODE **aWrapperRef) noexcept
	Remove the association between an IFSG* wrapper object and this object. More...
void	ResetNodeIndex (void) noexcept
	Reset the global SG* node indices in preparation for write operations. More...
void	addNodeRef (SGNODE *aNode)
	Add a pointer to a node which references this node, but does not own. More...
void	delNodeRef (const SGNODE *aNode)
	Remove a pointer to a node which references this node, but does not own. More...
bool	isWritten (void) noexcept
	Return true if the object had already been written to a cache file or VRML file. More...

Public Attributes
SGCOLORS *	m_Colors
SGCOORDS *	m_Coords
SGCOORDINDEX *	m_CoordIndices
SGNORMALS *	m_Normals
SGCOLORS *	m_RColors
SGCOORDS *	m_RCoords
SGNORMALS *	m_RNormals

Protected Attributes
std::list< SGNODE * >	m_BackPointers
	nodes which hold a reference to this. More...
SGNODE *	m_Parent
	Pointer to parent node; may be NULL for top level transform. More...
S3D::SGTYPES	m_SGtype
	Type of Scene Graph node. More...
std::string	m_Name
	name to use for referencing the entity by name. More...
bool	m_written
	Set to true when the object has been written after a ReNameNodes(). More...

Private Member Functions
void	unlinkNode (const SGNODE *aNode, bool isChild)
bool	addNode (SGNODE *aNode, bool isChild)

Private Attributes
bool	valid
bool	validated
SGNODE **	m_Association
	Handle to the instance held by a wrapper. More...

Detailed Description

Define an indexed face set for a scenegraph.

Definition at line 46 of file sg_faceset.h.

Constructor & Destructor Documentation

SGFACESET()

SGFACESET::SGFACESET

(

SGNODE *

aParent

)

Definition at line 38 of file sg_faceset.cpp.

 : SGNODE( aParent )
{
 m_SGtype = S3D::SGTYPE_FACESET;
 m_Colors = nullptr;
 m_Coords = nullptr;
 m_CoordIndices = nullptr;
 m_Normals = nullptr;
 m_RColors = nullptr;
 m_RCoords = nullptr;
 m_RNormals = nullptr;
 valid = false;
 validated = false;
 
 if( nullptr != aParent && S3D::SGTYPE_SHAPE != aParent->GetNodeType() )
 {
 m_Parent = nullptr;
 
 wxLogTrace( MASK_3D_SG,
 wxT( "%s:%s:%d * [BUG] inappropriate parent to SGFACESET (type %s)" ),
 __FILE__, __FUNCTION__, __LINE__,
 aParent->GetNodeType() );
 }
 else if( nullptr != aParent && S3D::SGTYPE_SHAPE == aParent->GetNodeType() )
 {
  m_Parent->AddChildNode( this );
 }
}

References SGNODE::AddChildNode(), SGNODE::GetNodeType(), m_Colors, m_CoordIndices, m_Coords, m_Normals, SGNODE::m_Parent, m_RColors, m_RCoords, m_RNormals, SGNODE::m_SGtype, S3D::SGTYPE_FACESET, S3D::SGTYPE_SHAPE, valid, and validated.

~SGFACESET()

SGFACESET::~SGFACESET ( )

virtual

Definition at line 67 of file sg_faceset.cpp.

{
 // drop references
 if( m_RColors )
 {
 m_RColors->delNodeRef( this );
 m_RColors = nullptr;
 }
 
 if( m_RCoords )
 {
 m_RCoords->delNodeRef( this );
 m_RCoords = nullptr;
 }
 
 if( m_RNormals )
 {
 m_RNormals->delNodeRef( this );
 m_RNormals = nullptr;
 }
 
 // delete owned objects
 if( m_Colors )
 {
 m_Colors->SetParent( nullptr, false );
 delete m_Colors;
 m_Colors = nullptr;
 }
 
 if( m_Coords )
 {
 m_Coords->SetParent( nullptr, false );
 delete m_Coords;
 m_Coords = nullptr;
 }
 
 if( m_Normals )
 {
 m_Normals->SetParent( nullptr, false );
 delete m_Normals;
 m_Normals = nullptr;
 }
 
 if( m_CoordIndices )
 {
 m_CoordIndices->SetParent( nullptr, false );
 delete m_CoordIndices;
 m_CoordIndices = nullptr;
 }
}

References SGNODE::delNodeRef(), m_Colors, m_CoordIndices, m_Coords, m_Normals, m_RColors, m_RCoords, m_RNormals, SGCOLORS::SetParent(), SGCOORDS::SetParent(), SGINDEX::SetParent(), and SGNORMALS::SetParent().

Member Function Documentation

AddChildNode()

bool SGFACESET::AddChildNode ( SGNODE *  aNode )

overridevirtual

Implements SGNODE.

Definition at line 407 of file sg_faceset.cpp.

{
 return addNode( aNode, true );
}

References addNode().

addNode()

bool SGFACESET::addNode ( SGNODE *  aNode, bool  isChild  )

private

Definition at line 275 of file sg_faceset.cpp.

{
 wxCHECK( aNode, false );
 
 valid = false;
 validated = false;
 
 if( S3D::SGTYPE_COLORS == aNode->GetNodeType() )
 {
 if( m_Colors || m_RColors )
 {
 if( aNode != m_Colors && aNode != m_RColors )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [BUG] assigning multiple Colors nodes" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 return false;
 }
 
 return true;
 }
 
 if( isChild )
 {
 m_Colors = (SGCOLORS*)aNode;
 m_Colors->SetParent( this );
 }
 else
 {
 m_RColors = (SGCOLORS*)aNode;
 m_RColors->addNodeRef( this );
 }
 
 return true;
 }
 
 if( S3D::SGTYPE_COORDS == aNode->GetNodeType() )
 {
 if( m_Coords || m_RCoords )
 {
 if( aNode != m_Coords && aNode != m_RCoords )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [BUG] assigning multiple Colors nodes" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 return false;
 }
 
 return true;
 }
 
 if( isChild )
 {
 m_Coords = (SGCOORDS*)aNode;
 m_Coords->SetParent( this );
 }
 else
 {
 m_RCoords = (SGCOORDS*)aNode;
 m_RCoords->addNodeRef( this );
 }
 
 return true;
 }
 
 if( S3D::SGTYPE_NORMALS == aNode->GetNodeType() )
 {
 if( m_Normals || m_RNormals )
 {
 if( aNode != m_Normals && aNode != m_RNormals )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [BUG] assigning multiple Normals nodes" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 return false;
 }
 
 return true;
 }
 
 if( isChild )
 {
 m_Normals = (SGNORMALS*)aNode;
 m_Normals->SetParent( this );
 }
 else
 {
 m_RNormals = (SGNORMALS*)aNode;
 m_RNormals->addNodeRef( this );
 }
 
 return true;
 }
 
 if( S3D::SGTYPE_COORDINDEX == aNode->GetNodeType() )
 {
 if( m_CoordIndices )
 {
 if( aNode != m_CoordIndices )
 {
 wxLogTrace( MASK_3D_SG,
 wxT( "%s:%s:%d * [BUG] assigning multiple CoordIndex nodes" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 return false;
 }
 
 return true;
 }
 
 m_CoordIndices = (SGCOORDINDEX*)aNode;
 m_CoordIndices->SetParent( this );
 
 return true;
 }
 
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [BUG] object type '%s' is not a valid type for "
 "this object '%d'" ),
 __FILE__, __FUNCTION__, __LINE__,
 aNode->GetName(),
 aNode->GetNodeType() );
 
 return false;
}

References SGNODE::addNodeRef(), SGNODE::GetName(), SGNODE::GetNodeType(), m_Colors, m_CoordIndices, m_Coords, m_Normals, m_RColors, m_RCoords, m_RNormals, SGCOLORS::SetParent(), SGCOORDS::SetParent(), SGINDEX::SetParent(), SGNORMALS::SetParent(), S3D::SGTYPE_COLORS, S3D::SGTYPE_COORDINDEX, S3D::SGTYPE_COORDS, S3D::SGTYPE_NORMALS, valid, and validated.

Referenced by AddChildNode(), and AddRefNode().

addNodeRef()

void SGNODE::addNodeRef ( SGNODE *  aNode )

inherited

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

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

Parameters

aNode

is the node holding a reference to this object.

Definition at line 170 of file sg_node.cpp.

{
 if( nullptr == aNode )
 return;
 
 std::list< SGNODE* >::iterator np =
 std::find( m_BackPointers.begin(), m_BackPointers.end(), aNode );
 
 if( np != m_BackPointers.end() )
 return;
 
 m_BackPointers.push_back( aNode );
}

References SGNODE::m_BackPointers.

Referenced by addNode(), SGSHAPE::addNode(), ReadCache(), and SGSHAPE::ReadCache().

AddRefNode()

bool SGFACESET::AddRefNode ( SGNODE *  aNode )

overridevirtual

Implements SGNODE.

Definition at line 401 of file sg_faceset.cpp.

{
 return addNode( aNode, false );
}

References addNode().

AssociateWrapper()

void SGNODE::AssociateWrapper ( SGNODE **  aWrapperRef )

noexceptinherited

Associate this object with a handle to itself.

The handle is typically held by an IFSG* wrapper and the pointer which it refers to is set to NULL upon destruction of this object. This mechanism provides a scheme by which a wrapper can be notified of the destruction of the object which it wraps.

Definition at line 207 of file sg_node.cpp.

{
 wxCHECK( aWrapperRef && *aWrapperRef == this, /* void */ );
 
 // if there is an existing association then break it and emit a warning
 // just in case the behavior is undesired
 if( m_Association )
 {
 *m_Association = nullptr;
 
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [WARNING] association being broken with "
 "previous wrapper" ),
 __FILE__, __FUNCTION__, __LINE__ );
 }
 
 m_Association = aWrapperRef;
}

Referenced by S3D::AssociateSGNodeWrapper(), IFSG_APPEARANCE::Attach(), IFSG_COLORS::Attach(), IFSG_COORDINDEX::Attach(), IFSG_COORDS::Attach(), IFSG_FACESET::Attach(), IFSG_NORMALS::Attach(), IFSG_SHAPE::Attach(), IFSG_TRANSFORM::Attach(), IFSG_APPEARANCE::IFSG_APPEARANCE(), IFSG_COLORS::IFSG_COLORS(), IFSG_COORDINDEX::IFSG_COORDINDEX(), IFSG_COORDS::IFSG_COORDS(), IFSG_FACESET::IFSG_FACESET(), IFSG_NORMALS::IFSG_NORMALS(), IFSG_SHAPE::IFSG_SHAPE(), IFSG_TRANSFORM::IFSG_TRANSFORM(), IFSG_APPEARANCE::NewNode(), IFSG_COLORS::NewNode(), IFSG_COORDINDEX::NewNode(), IFSG_COORDS::NewNode(), IFSG_FACESET::NewNode(), IFSG_NORMALS::NewNode(), IFSG_SHAPE::NewNode(), and IFSG_TRANSFORM::NewNode().

CalcNormals()

bool SGFACESET::CalcNormals

(

SGNODE **

aPtr

)

Definition at line 975 of file sg_faceset.cpp.

{
 SGCOORDS* coords = m_Coords;
 
 if( m_RCoords )
 coords = m_RCoords;
 
 if( nullptr == coords || coords->coords.empty() )
 return false;
 
 if( m_Normals && !m_Normals->norms.empty( ) )
 return true;
 
 if( m_RNormals && !m_RNormals->norms.empty( ) )
 return true;
 
 return coords->CalcNormals( this, aPtr );
}

References SGCOORDS::CalcNormals(), SGCOORDS::coords, m_Coords, m_Normals, m_RCoords, m_RNormals, and SGNORMALS::norms.

delNodeRef()

void SGNODE::delNodeRef ( const SGNODE *  aNode )

inherited

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

Parameters

aNode

is the node holding a reference to this object.

Definition at line 185 of file sg_node.cpp.

{
 if( nullptr == aNode )
 return;
 
 std::list< SGNODE* >::iterator np =
 std::find( m_BackPointers.begin(), m_BackPointers.end(), aNode );
 
 if( np != m_BackPointers.end() )
 {
 m_BackPointers.erase( np );
 return;
 }
 
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [BUG] delNodeRef() did not find its target, this "
 "node type %d, referenced node type %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 m_SGtype,
  aNode->GetNodeType() );
}

References SGNODE::GetNodeType(), SGNODE::m_BackPointers, and SGNODE::m_SGtype.

Referenced by unlinkNode(), SGSHAPE::unlinkNode(), ~SGFACESET(), and SGSHAPE::~SGSHAPE().

DisassociateWrapper()

void SGNODE::DisassociateWrapper ( SGNODE **  aWrapperRef )

noexceptinherited

Remove the association between an IFSG* wrapper object and this object.

Definition at line 225 of file sg_node.cpp.

{
 if( !m_Association )
 return;
 
 wxCHECK( aWrapperRef, /* void */ );
 
 wxCHECK( *aWrapperRef == *m_Association && aWrapperRef == m_Association, /* void */ );
 
 m_Association = nullptr;
}

Referenced by IFSG_APPEARANCE::Attach(), IFSG_COLORS::Attach(), IFSG_COORDINDEX::Attach(), IFSG_COORDS::Attach(), IFSG_FACESET::Attach(), IFSG_NORMALS::Attach(), IFSG_SHAPE::Attach(), IFSG_TRANSFORM::Attach(), IFSG_NODE::Destroy(), IFSG_APPEARANCE::NewNode(), IFSG_COLORS::NewNode(), IFSG_COORDINDEX::NewNode(), IFSG_COORDS::NewNode(), IFSG_FACESET::NewNode(), IFSG_NORMALS::NewNode(), IFSG_SHAPE::NewNode(), IFSG_TRANSFORM::NewNode(), and IFSG_NODE::~IFSG_NODE().

FindNode()

SGNODE * SGFACESET::FindNode ( const char *  aNodeName, const SGNODE *  aCaller  )

overridevirtual

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

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

Parameters

aNodeName	is the name of the node to search for.
aCaller	is a pointer to the node invoking this function.

Returns

is a valid node pointer on success, otherwise NULL.

Implements SGNODE.

Definition at line 149 of file sg_faceset.cpp.

{
 if( nullptr == aNodeName || 0 == aNodeName[0] )
 return nullptr;
 
 if( !m_Name.compare( aNodeName ) )
 return this;
 
 SGNODE* np = nullptr;
 
 if( m_Colors )
 {
 np = m_Colors->FindNode( aNodeName, this );
 
 if( np )
 return np;
 }
 
 if( m_Coords )
 {
 np = m_Coords->FindNode( aNodeName, this );
 
 if( np )
 return np;
 }
 
 if( m_CoordIndices )
 {
 np = m_CoordIndices->FindNode( aNodeName, this );
 
 if( np )
 return np;
 }
 
 if( m_Normals )
 {
 np = m_Normals->FindNode( aNodeName, this );
 
 if( np )
 return np;
 }
 
 // query the parent if appropriate
 if( aCaller == m_Parent || nullptr == m_Parent )
 return nullptr;
 
 return m_Parent->FindNode( aNodeName, this );
}

References SGCOLORS::FindNode(), SGCOORDS::FindNode(), SGINDEX::FindNode(), SGNORMALS::FindNode(), SGNODE::FindNode(), m_Colors, m_CoordIndices, m_Coords, SGNODE::m_Name, m_Normals, and SGNODE::m_Parent.

Referenced by SGSHAPE::FindNode(), and ReadCache().

GatherCoordIndices()

void SGFACESET::GatherCoordIndices

(

std::vector< int > &

aIndexList

)

Add all internal coordinate indices to the given list in preparation for a normals calculation.

Definition at line 968 of file sg_faceset.cpp.

{
 if( m_CoordIndices )
 m_CoordIndices->GatherCoordIndices( aIndexList );
}

References SGCOORDINDEX::GatherCoordIndices(), and m_CoordIndices.

Referenced by SGCOORDS::CalcNormals().

GetName()

const char * SGNODE::GetName ( void  )

inherited

Definition at line 146 of file sg_node.cpp.

{
 if( m_Name.empty() )
 getNodeName( m_SGtype, m_Name );
 
 return m_Name.c_str();
}

References getNodeName(), SGNODE::m_Name, and SGNODE::m_SGtype.

Referenced by SCENEGRAPH::addNode(), addNode(), SGSHAPE::addNode(), IFSG_NODE::GetName(), SCENEGRAPH::ReNameNodes(), SGAPPEARANCE::ReNameNodes(), SGCOLORS::ReNameNodes(), SGCOORDS::ReNameNodes(), ReNameNodes(), SGINDEX::ReNameNodes(), SGNORMALS::ReNameNodes(), SGSHAPE::ReNameNodes(), SCENEGRAPH::WriteCache(), SGAPPEARANCE::WriteCache(), SGCOLORS::WriteCache(), SGCOORDS::WriteCache(), WriteCache(), SGINDEX::WriteCache(), SGNORMALS::WriteCache(), SGSHAPE::WriteCache(), SCENEGRAPH::WriteVRML(), SGAPPEARANCE::WriteVRML(), SGCOLORS::WriteVRML(), SGCOORDS::WriteVRML(), WriteVRML(), SGNORMALS::WriteVRML(), and SGSHAPE::WriteVRML().

GetNodeType()

S3D::SGTYPES SGNODE::GetNodeType ( void  ) const

noexceptinherited

Return the type of this node instance.

Definition at line 104 of file sg_node.cpp.

{
 return m_SGtype;
}

Referenced by SCENEGRAPH::addNode(), addNode(), SGSHAPE::addNode(), IFSG_APPEARANCE::Attach(), IFSG_COLORS::Attach(), IFSG_COORDINDEX::Attach(), IFSG_COORDS::Attach(), IFSG_FACESET::Attach(), IFSG_NORMALS::Attach(), IFSG_SHAPE::Attach(), IFSG_TRANSFORM::Attach(), SGNODE::delNodeRef(), S3D::GetMatIndex(), S3D::GetModel(), IFSG_NODE::GetNodeType(), S3D::GetSGNodeType(), IFSG_APPEARANCE::NewNode(), IFSG_COLORS::NewNode(), IFSG_COORDINDEX::NewNode(), IFSG_COORDS::NewNode(), IFSG_FACESET::NewNode(), IFSG_NORMALS::NewNode(), IFSG_SHAPE::NewNode(), IFSG_TRANSFORM::NewNode(), SCENEGRAPH::ReadCache(), ReadCache(), SGSHAPE::ReadCache(), SCENEGRAPH::SCENEGRAPH(), SCENEGRAPH::SetParent(), SGAPPEARANCE::SetParent(), SGCOLORS::SetParent(), SGCOORDS::SetParent(), SetParent(), SGINDEX::SetParent(), SGNORMALS::SetParent(), SGSHAPE::SetParent(), SGAPPEARANCE::SGAPPEARANCE(), SGCOLORS::SGCOLORS(), SGCOORDINDEX::SGCOORDINDEX(), SGCOORDS::SGCOORDS(), SGFACESET(), SGINDEX::SGINDEX(), SGNORMALS::SGNORMALS(), SGSHAPE::SGSHAPE(), SGNODE::SwapParent(), SCENEGRAPH::unlinkNode(), and S3D::WriteVRML().

GetNodeTypeName()

const char * SGNODE::GetNodeTypeName ( S3D::SGTYPES  aNodeType ) const

noexceptinherited

Definition at line 164 of file sg_node.cpp.

{
 return node_names[aNodeType].c_str();
}

References node_names.

Referenced by IFSG_NODE::GetNodeTypeName(), IFSG_APPEARANCE::NewNode(), IFSG_COLORS::NewNode(), IFSG_COORDINDEX::NewNode(), IFSG_COORDS::NewNode(), IFSG_FACESET::NewNode(), IFSG_NORMALS::NewNode(), IFSG_SHAPE::NewNode(), and IFSG_TRANSFORM::NewNode().

GetParent()

SGNODE * SGNODE::GetParent ( void  ) const

noexceptinherited

Returns a pointer to the parent SGNODE of this object or NULL if the object has no parent (ie.

top level transform).

Definition at line 110 of file sg_node.cpp.

{
 return m_Parent;
}

Referenced by IFSG_NODE::GetParent(), S3D::GetSGNodeParent(), IFSG_APPEARANCE::NewNode(), IFSG_COLORS::NewNode(), IFSG_COORDINDEX::NewNode(), IFSG_COORDS::NewNode(), IFSG_FACESET::NewNode(), IFSG_NORMALS::NewNode(), IFSG_SHAPE::NewNode(), IFSG_TRANSFORM::NewNode(), SCENEGRAPH::WriteCache(), SGAPPEARANCE::WriteCache(), SGCOLORS::WriteCache(), SGCOORDS::WriteCache(), WriteCache(), SGINDEX::WriteCache(), SGNORMALS::WriteCache(), and SGSHAPE::WriteCache().

isWritten()

bool SGNODE::isWritten ( void  )

inlinenoexceptinherited

Return true if the object had already been written to a cache file or VRML file.

For internal use only.

Definition at line 220 of file sg_node.h.

 {
 return m_written;
 }

References SGNODE::m_written.

Referenced by SCENEGRAPH::WriteCache(), WriteCache(), and SGSHAPE::WriteCache().

ReadCache()

bool SGFACESET::ReadCache ( std::istream &  aFile, SGNODE *  parentNode  )

overridevirtual

Reads binary format data from a cache file.

To read a cache file, open the file for reading and invoke this function from a new SCENEGRAPH node.

Implements SGNODE.

Definition at line 601 of file sg_faceset.cpp.

{
 if( m_Coords || m_RCoords || m_CoordIndices || m_Colors || m_RColors || m_Normals
 || m_RNormals )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [BUG] non-empty node" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 return false;
 }
 
 #define NITEMS 7
 bool items[NITEMS];
 
 for( int i = 0; i < NITEMS; ++i )
 aFile.read( (char*) &items[i], sizeof( bool ) );
 
 if( ( items[0] && items[1] ) || ( items[3] && items[4] ) || ( items[5] && items[6] ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; multiple item definitions "
 "at position %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<int>( aFile.tellg() ) );
 
 return false;
 }
 
 std::string name;
 
 if( items[0] )
 {
 if( S3D::SGTYPE_COORDS != S3D::ReadTag( aFile, name ) )
 {
  wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; bad child coords tag at "
 "position %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<int>( aFile.tellg() ) );
 
 return false;
 }
 
 m_Coords = new SGCOORDS( this );
 m_Coords->SetName( name.c_str() );
 
 if( !m_Coords->ReadCache( aFile, this ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; corrupt data while "
 "reading coords '%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 }
 
 if( items[1] )
 {
 if( S3D::SGTYPE_COORDS != S3D::ReadTag( aFile, name ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; bad ref coords tag at "
 "position %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<int>( aFile.tellg() ) );
 
 return false;
 }
 
 SGNODE* np = FindNode( name.c_str(), this );
 
 if( !np )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; cannot find ref "
 "coords '%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 
 if( S3D::SGTYPE_COORDS != np->GetNodeType() )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; type is not SGCOORDS "
 "'%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 
 m_RCoords = (SGCOORDS*)np;
 m_RCoords->addNodeRef( this );
 }
 
 if( items[2] )
 {
 if( S3D::SGTYPE_COORDINDEX != S3D::ReadTag( aFile, name ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; bad coord index tag at "
 "position %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<int>( aFile.tellg() ) );
 
 return false;
 }
 
 m_CoordIndices = new SGCOORDINDEX( this );
 m_CoordIndices->SetName( name.c_str() );
 
 if( !m_CoordIndices->ReadCache( aFile, this ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data while reading coord "
 "index '%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 }
 
 if( items[3] )
 {
 if( S3D::SGTYPE_NORMALS != S3D::ReadTag( aFile, name ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; bad child normals tag "
 "at position %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<int>( aFile.tellg() ) );
 
 return false;
 }
 
 m_Normals = new SGNORMALS( this );
 m_Normals->SetName( name.c_str() );
 
 if( !m_Normals->ReadCache( aFile, this ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data while reading normals "
 "'%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 }
 
 if( items[4] )
 {
 if( S3D::SGTYPE_NORMALS != S3D::ReadTag( aFile, name ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; bad ref normals tag at "
 "position %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<int>( aFile.tellg() ) );
 
 return false;
 }
 
 SGNODE* np = FindNode( name.c_str(), this );
 
 if( !np )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt: cannot find ref normals "
 "'%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 
 if( S3D::SGTYPE_NORMALS != np->GetNodeType() )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt: type is not SGNORMALS '%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 
 m_RNormals = (SGNORMALS*)np;
 m_RNormals->addNodeRef( this );
 }
 
 if( items[5] )
 {
 if( S3D::SGTYPE_COLORS != S3D::ReadTag( aFile, name ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; bad child colors tag "
 "at position %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<int>( aFile.tellg() ) );
 
 return false;
 }
 
 m_Colors = new SGCOLORS( this );
 m_Colors->SetName( name.c_str() );
 
 if( !m_Colors->ReadCache( aFile, this ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data while reading colors "
 "'%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 }
 
 if( items[6] )
 {
 if( S3D::SGTYPE_COLORS != S3D::ReadTag( aFile, name ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data; bad ref colors tag at "
 "position %d" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<int>( aFile.tellg() ) );
 
 return false;
 }
 
 SGNODE* np = FindNode( name.c_str(), this );
 
 if( !np )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data: cannot find ref colors "
 "'%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
  name );
 
 return false;
 }
 
 if( S3D::SGTYPE_COLORS != np->GetNodeType() )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] corrupt data: type is not SGCOLORS "
 "'%s'" ),
 __FILE__, __FUNCTION__, __LINE__,
 name );
 
 return false;
 }
 
 m_RColors = (SGCOLORS*)np;
 m_RColors->addNodeRef( this );
 }
 
 if( aFile.fail() )
 return false;
 
 return true;
}

References SGNODE::addNodeRef(), FindNode(), SGNODE::GetNodeType(), m_Colors, m_CoordIndices, m_Coords, m_Normals, m_RColors, m_RCoords, m_RNormals, name, NITEMS, SGCOLORS::ReadCache(), SGCOORDS::ReadCache(), SGINDEX::ReadCache(), SGNORMALS::ReadCache(), S3D::ReadTag(), SGNODE::SetName(), S3D::SGTYPE_COLORS, S3D::SGTYPE_COORDINDEX, S3D::SGTYPE_COORDS, and S3D::SGTYPE_NORMALS.

Referenced by SGSHAPE::ReadCache().

ReNameNodes()

void SGFACESET::ReNameNodes ( void  )

overridevirtual

Rename a node and all its child nodes in preparation for write operations.

Implements SGNODE.

Definition at line 413 of file sg_faceset.cpp.

{
 m_written = false;
 
 // rename this node
 m_Name.clear();
 GetName();
 
 // rename all Colors and Indices
 if( m_Colors )
 m_Colors->ReNameNodes();
 
 // rename all Coordinates and Indices
 if( m_Coords )
 m_Coords->ReNameNodes();
 
 if( m_CoordIndices )
 m_CoordIndices->ReNameNodes();
 
 // rename all Normals and Indices
 if( m_Normals )
 m_Normals->ReNameNodes();
}

References SGNODE::GetName(), m_Colors, m_CoordIndices, m_Coords, SGNODE::m_Name, m_Normals, SGNODE::m_written, SGCOLORS::ReNameNodes(), SGCOORDS::ReNameNodes(), SGINDEX::ReNameNodes(), and SGNORMALS::ReNameNodes().

Referenced by SGSHAPE::ReNameNodes().

ResetNodeIndex()

void SGNODE::ResetNodeIndex ( void  )

noexceptinherited

Reset the global SG* node indices in preparation for write operations.

Definition at line 238 of file sg_node.cpp.

{
 for( int i = 0; i < (int)S3D::SGTYPE_END; ++i )
 node_counts[i] = 1;
}

References node_counts, and S3D::SGTYPE_END.

Referenced by S3D::ResetNodeIndex(), SCENEGRAPH::WriteCache(), and S3D::WriteVRML().

SetName()

void SGNODE::SetName ( const char *  aName )

inherited

Definition at line 155 of file sg_node.cpp.

{
 if( nullptr == aName || 0 == aName[0] )
 getNodeName( m_SGtype, m_Name );
 else
 m_Name = aName;
}

References getNodeName(), SGNODE::m_Name, and SGNODE::m_SGtype.

Referenced by SCENEGRAPH::ReadCache(), ReadCache(), SGSHAPE::ReadCache(), and IFSG_NODE::SetName().

SetParent()

bool SGFACESET::SetParent ( SGNODE *  aParent, bool  notify = true  )

overridevirtual

Set the parent SGNODE of this object.

Parameters

aParent

[in] is the desired parent node

Returns

true if the operation succeeds; false if the given node is not allowed to be a parent to the derived object.

Implements SGNODE.

Definition at line 119 of file sg_faceset.cpp.

{
 if( nullptr != m_Parent )
 {
 if( aParent == m_Parent )
 return true;
 
 // handle the change in parents
 if( notify )
 m_Parent->unlinkChildNode( this );
 
 m_Parent = nullptr;
 
 if( nullptr == aParent )
 return true;
 }
 
 // only a SGSHAPE may be parent to a SGFACESET
 if( nullptr != aParent && S3D::SGTYPE_SHAPE != aParent->GetNodeType() )
 return false;
 
 m_Parent = aParent;
 
 if( m_Parent )
 m_Parent->AddChildNode( this );
 
 return true;
}

References SGNODE::AddChildNode(), SGNODE::GetNodeType(), SGNODE::m_Parent, S3D::SGTYPE_SHAPE, and SGNODE::unlinkChildNode().

Referenced by SGSHAPE::addNode(), and SGSHAPE::~SGSHAPE().

SwapParent()

bool SGNODE::SwapParent ( SGNODE *  aNewParent )

inherited

Swap the ownership with the given parent.

This operation may be required when reordering nodes for optimization.

Parameters

aNewParent

will become the new parent to the object; it must be the same type as the parent of this instance.

Definition at line 116 of file sg_node.cpp.

{
 if( aNewParent == m_Parent )
 return true;
 
 if( nullptr == aNewParent )
 return false;
 
 if( nullptr == m_Parent )
 {
 if( aNewParent->AddChildNode( this ) )
 return true;
 
 return false;
 }
 
 if( aNewParent->GetNodeType() != m_Parent->GetNodeType() )
 return false;
 
 SGNODE* oldParent = m_Parent;
 m_Parent->unlinkChildNode( this );
 m_Parent = nullptr;
 aNewParent->unlinkRefNode( this );
 aNewParent->AddChildNode( this );
 oldParent->AddRefNode( this );
 
 return true;
}

References SGNODE::AddChildNode(), SGNODE::AddRefNode(), SGNODE::GetNodeType(), SGNODE::m_Parent, SGNODE::unlinkChildNode(), and SGNODE::unlinkRefNode().

Referenced by WriteCache(), and SGSHAPE::WriteCache().

unlinkChildNode()

void SGFACESET::unlinkChildNode ( const SGNODE *  aNode )

overridevirtual

Remove references to an owned child.

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

Parameters

aNode

is the child which is being deleted.

Implements SGNODE.

Definition at line 262 of file sg_faceset.cpp.

{
 unlinkNode( aNode, true );
}

References unlinkNode().

unlinkNode()

void SGFACESET::unlinkNode ( const SGNODE *  aNode, bool  isChild  )

private

Definition at line 199 of file sg_faceset.cpp.

{
 if( nullptr == aNode )
 return;
 
 valid = false;
 validated = false;
 
 if( isChild )
 {
 if( aNode == m_Colors )
 {
 m_Colors = nullptr;
 return;
 }
 
 if( aNode == m_Coords )
 {
 m_Coords = nullptr;
 return;
 }
 
 if( aNode == m_Normals )
 {
 m_Normals = nullptr;
 return;
 }
 
 if( aNode == m_CoordIndices )
 {
 m_CoordIndices = nullptr;
 return;
 }
 }
 else
 {
 if( aNode == m_RColors )
 {
 delNodeRef( this );
 m_RColors = nullptr;
 return;
 }
 
 if( aNode == m_RCoords )
 {
 delNodeRef( this );
 m_RCoords = nullptr;
 return;
 }
 
 if( aNode == m_RNormals )
 {
 delNodeRef( this );
 m_RNormals = nullptr;
 return;
 }
 }
 
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [BUG] unlinkNode() did not find its target" ),
 __FILE__, __FUNCTION__, __LINE__ );
}

References SGNODE::delNodeRef(), m_Colors, m_CoordIndices, m_Coords, m_Normals, m_RColors, m_RCoords, m_RNormals, valid, and validated.

Referenced by unlinkChildNode(), and unlinkRefNode().

unlinkRefNode()

void SGFACESET::unlinkRefNode ( const SGNODE *  aNode )

overridevirtual

Remove pointers to a referenced node.

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

Parameters

aNode

is the node which is being deleted.

Implements SGNODE.

Definition at line 268 of file sg_faceset.cpp.

{
 unlinkNode( aNode, false );
}

References unlinkNode().

validate()

bool SGFACESET::validate

(

void

)

Definition at line 854 of file sg_faceset.cpp.

{
 // verify the integrity of this object's data
 if( validated )
 return valid;
 
 // ensure we have at least coordinates and their normals
 if( ( nullptr == m_Coords && nullptr == m_RCoords )
 || ( nullptr == m_Normals && nullptr == m_RNormals )
 || ( nullptr == m_CoordIndices ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] bad model; no vertices, vertex indices, "
 "or normals" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 validated = true;
 valid = false;
 return false;
 }
 
 // check that there are >3 vertices
 SGCOORDS* coords = m_Coords;
 
 if( nullptr == coords )
 coords = m_RCoords;
 
 size_t nCoords = 0;
 SGPOINT* lCoords = nullptr;
 coords->GetCoordsList( nCoords, lCoords );
 
 if( nCoords < 3 )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] bad model; fewer than 3 vertices" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 validated = true;
 valid = false;
 return false;
 }
 
 // check that nVertices is divisible by 3 (facets are triangles)
 size_t nCIdx = 0;
 int* lCIdx = nullptr;
 m_CoordIndices->GetIndices( nCIdx, lCIdx );
 
 if( nCIdx < 3 || ( nCIdx % 3 > 0 ) )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] bad model; no vertex indices or not "
 "multiple of 3" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 validated = true;
 valid = false;
 return false;
 }
 
 // check that vertex[n] >= 0 and < nVertices
 for( size_t i = 0; i < nCIdx; ++i )
 {
 if( lCIdx[i] < 0 || lCIdx[i] >= (int)nCoords )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] bad model; vertex index out of "
 "bounds" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 validated = true;
 valid = false;
 return false;
 }
 }
 
 // check that there are as many normals as vertices
 size_t nNorms = 0;
 SGVECTOR* lNorms = nullptr;
 SGNORMALS* pNorms = m_Normals;
 
 if( nullptr == pNorms )
 pNorms = m_RNormals;
 
 pNorms->GetNormalList( nNorms, lNorms );
 
 if( nNorms != nCoords )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] bad model; number of normals (%ul) does "
 "not match number of vertices (%ul)" ),
 __FILE__, __FUNCTION__, __LINE__,
 static_cast<unsigned long>( nNorms ),
 static_cast<unsigned long>( nCoords ) );
 
 validated = true;
 valid = false;
 return false;
 }
 
 // if there are colors then ensure there are as many colors as vertices
 SGCOLORS* pColors = m_Colors;
 
 if( nullptr == pColors )
 pColors = m_RColors;
 
 if( nullptr != pColors )
 {
 // we must have at least as many colors as vertices
 size_t nColor = 0;
 SGCOLOR* pColor = nullptr;
 pColors->GetColorList( nColor, pColor );
 }
 
 validated = true;
 valid = true;
 return true;
}

References SGCOLORS::GetColorList(), SGCOORDS::GetCoordsList(), SGINDEX::GetIndices(), SGNORMALS::GetNormalList(), m_Colors, m_CoordIndices, m_Coords, m_Normals, m_RColors, m_RCoords, m_RNormals, valid, and validated.

Referenced by SGSHAPE::Prepare().

WriteCache()

bool SGFACESET::WriteCache ( std::ostream &  aFile, SGNODE *  parentNode  )

overridevirtual

Write this node's data to a binary cache file.

The data includes all data of children and references to children. If this function is invoked by the user, parentNode must be set to NULL in order to ensure coherent data.

Implements SGNODE.

Definition at line 493 of file sg_faceset.cpp.

{
 if( nullptr == parentNode )
 {
 wxCHECK( m_Parent, false );
 
 SGNODE* np = m_Parent;
 
 while( nullptr != np->GetParent() )
 np = np->GetParent();
 
 if( np->WriteCache( aFile, nullptr ) )
 {
 m_written = true;
 return true;
 }
 
 return false;
 }
 
 wxCHECK( parentNode == m_Parent, false );
 
 if( !aFile.good() )
 {
 wxLogTrace( MASK_3D_SG, wxT( "%s:%s:%d * [INFO] bad stream" ),
 __FILE__, __FUNCTION__, __LINE__ );
 
 return false;
 }
 
 // check if any references are unwritten and swap parents if so
 if( nullptr != m_RCoords && !m_RCoords->isWritten() )
 m_RCoords->SwapParent( this );
 
 if( nullptr != m_RNormals && !m_RNormals->isWritten() )
 m_RNormals->SwapParent( this );
 
 if( nullptr != m_RColors && !m_RColors->isWritten() )
 m_RColors->SwapParent( this );
 
 aFile << "[" << GetName() << "]";
 #define NITEMS 7
 bool items[NITEMS];
 int i;
 
 for( i = 0; i < NITEMS; ++i )
 items[i] = 0;
 
 i = 0;
 if( nullptr != m_Coords )
 items[i] = true;
 
 ++i;
 if( nullptr != m_RCoords )
 items[i] = true;
 
 ++i;
 if( nullptr != m_CoordIndices )
 items[i] = true;
 
 ++i;
 if( nullptr != m_Normals )
 items[i] = true;
 
 ++i;
 if( nullptr != m_RNormals )
 items[i] = true;
 
 ++i;
 if( nullptr != m_Colors )
 items[i] = true;
 
 ++i;
 if( nullptr != m_RColors )
 items[i] = true;
 
 for( int jj = 0; jj < NITEMS; ++jj )
 aFile.write( (char*) &items[jj], sizeof( bool ) );
 
 if( items[0] )
 m_Coords->WriteCache( aFile, this );
 
 if( items[1] )
 aFile << "[" << m_RCoords->GetName() << "]";
 
 if( items[2] )
 m_CoordIndices->WriteCache( aFile, this );
 
 if( items[3] )
 m_Normals->WriteCache( aFile, this );
 
 if( items[4] )
 aFile << "[" << m_RNormals->GetName() << "]";
 
 if( items[5] )
 m_Colors->WriteCache( aFile, this );
 
 if( items[6] )
 aFile << "[" << m_RColors->GetName() << "]";
 
 if( aFile.fail() )
 return false;
 
 m_written = true;
 return true;
}

References SGNODE::GetName(), SGNODE::GetParent(), SGNODE::isWritten(), m_Colors, m_CoordIndices, m_Coords, m_Normals, SGNODE::m_Parent, m_RColors, m_RCoords, m_RNormals, SGNODE::m_written, NITEMS, SGNODE::SwapParent(), SGCOLORS::WriteCache(), SGCOORDS::WriteCache(), SGINDEX::WriteCache(), SGNORMALS::WriteCache(), and SGNODE::WriteCache().

Referenced by SGSHAPE::WriteCache().

WriteVRML()

bool SGFACESET::WriteVRML ( std::ostream &  aFile, bool  aReuseFlag  )

overridevirtual

Writes this node's data to a VRML file.

This includes all data of child and referenced nodes.

Implements SGNODE.

Definition at line 438 of file sg_faceset.cpp.

{
 if( ( nullptr == m_Coords && nullptr == m_RCoords ) || ( nullptr == m_CoordIndices ) )
 {
 return false;
 }
 
 if( aReuseFlag )
 {
 if( !m_written )
 {
 aFile << " geometry DEF " << GetName() << " IndexedFaceSet {\n";
 m_written = true;
 }
 else
 {
 aFile << "USE " << GetName() << "\n";
 return true;
 }
 }
 else
 {
 aFile << " geometry IndexedFaceSet {\n";
 }
 
 if( m_Coords )
 m_Coords->WriteVRML( aFile, aReuseFlag );
 
 if( m_RCoords )
 m_RCoords->WriteVRML( aFile, aReuseFlag );
 
 if( m_CoordIndices )
 m_CoordIndices->WriteVRML( aFile, aReuseFlag );
 
 if( m_Normals || m_RNormals )
 aFile << " normalPerVertex TRUE\n";
 
 if( m_Normals )
 m_Normals->WriteVRML( aFile, aReuseFlag );
 
 if( m_RNormals )
 m_RNormals->WriteVRML( aFile, aReuseFlag );
 
 if( m_Colors )
 m_Colors->WriteVRML( aFile, aReuseFlag );
 
 if( m_RColors )
 m_RColors->WriteVRML( aFile, aReuseFlag );
 
 aFile << "}\n";
 
 return true;
}

References SGNODE::GetName(), m_Colors, m_CoordIndices, m_Coords, m_Normals, m_RColors, m_RCoords, m_RNormals, SGNODE::m_written, SGCOLORS::WriteVRML(), SGCOORDS::WriteVRML(), SGINDEX::WriteVRML(), and SGNORMALS::WriteVRML().

Referenced by SGSHAPE::WriteVRML().

Member Data Documentation

m_Association

SGNODE** SGNODE::m_Association

privateinherited

Handle to the instance held by a wrapper.

Definition at line 233 of file sg_node.h.

Referenced by SGNODE::SGNODE(), and SGNODE::~SGNODE().

m_BackPointers

std::list< SGNODE* > SGNODE::m_BackPointers

protectedinherited

nodes which hold a reference to this.

Definition at line 226 of file sg_node.h.

Referenced by SGNODE::addNodeRef(), SGCOORDS::CalcNormals(), SGNODE::delNodeRef(), and SGNODE::~SGNODE().

m_Colors

SGCOLORS* SGFACESET::m_Colors

Definition at line 79 of file sg_faceset.h.

Referenced by addNode(), FindNode(), SGSHAPE::Prepare(), ReadCache(), ReNameNodes(), SGFACESET(), unlinkNode(), validate(), WriteCache(), WriteVRML(), and ~SGFACESET().

m_CoordIndices

SGCOORDINDEX* SGFACESET::m_CoordIndices

Definition at line 81 of file sg_faceset.h.

Referenced by addNode(), FindNode(), GatherCoordIndices(), SGSHAPE::Prepare(), ReadCache(), ReNameNodes(), SGFACESET(), unlinkNode(), validate(), WriteCache(), WriteVRML(), and ~SGFACESET().

m_Coords

SGCOORDS* SGFACESET::m_Coords

Definition at line 80 of file sg_faceset.h.

Referenced by addNode(), CalcNormals(), FindNode(), SGSHAPE::Prepare(), ReadCache(), ReNameNodes(), SGFACESET(), unlinkNode(), validate(), WriteCache(), WriteVRML(), and ~SGFACESET().

m_Name

std::string SGNODE::m_Name

protectedinherited

name to use for referencing the entity by name.

Definition at line 229 of file sg_node.h.

Referenced by SCENEGRAPH::FindNode(), FindNode(), SGSHAPE::FindNode(), SGNODE::GetName(), SCENEGRAPH::ReadCache(), SCENEGRAPH::ReNameNodes(), SGAPPEARANCE::ReNameNodes(), SGCOLORS::ReNameNodes(), SGCOORDS::ReNameNodes(), ReNameNodes(), SGINDEX::ReNameNodes(), SGNORMALS::ReNameNodes(), SGSHAPE::ReNameNodes(), and SGNODE::SetName().

m_Normals

SGNORMALS* SGFACESET::m_Normals

Definition at line 82 of file sg_faceset.h.

Referenced by addNode(), SGCOORDS::CalcNormals(), CalcNormals(), FindNode(), SGSHAPE::Prepare(), ReadCache(), ReNameNodes(), SGFACESET(), unlinkNode(), validate(), WriteCache(), WriteVRML(), and ~SGFACESET().

m_Parent

SGNODE* SGNODE::m_Parent

protectedinherited

Pointer to parent node; may be NULL for top level transform.

Definition at line 227 of file sg_node.h.

Referenced by SGCOORDS::CalcNormals(), SCENEGRAPH::FindNode(), FindNode(), SGSHAPE::FindNode(), SCENEGRAPH::SCENEGRAPH(), SCENEGRAPH::SetParent(), SGAPPEARANCE::SetParent(), SGCOLORS::SetParent(), SGCOORDS::SetParent(), SetParent(), SGINDEX::SetParent(), SGNORMALS::SetParent(), SGSHAPE::SetParent(), SGAPPEARANCE::SGAPPEARANCE(), SGCOLORS::SGCOLORS(), SGCOORDINDEX::SGCOORDINDEX(), SGCOORDS::SGCOORDS(), SGFACESET(), SGINDEX::SGINDEX(), SGNODE::SGNODE(), SGNORMALS::SGNORMALS(), SGSHAPE::SGSHAPE(), SGNODE::SwapParent(), SCENEGRAPH::WriteCache(), SGAPPEARANCE::WriteCache(), SGCOLORS::WriteCache(), SGCOORDS::WriteCache(), WriteCache(), SGINDEX::WriteCache(), SGNORMALS::WriteCache(), SGSHAPE::WriteCache(), and SGNODE::~SGNODE().

m_RColors

SGCOLORS* SGFACESET::m_RColors

Definition at line 85 of file sg_faceset.h.

Referenced by addNode(), SGSHAPE::Prepare(), ReadCache(), SGFACESET(), unlinkNode(), validate(), WriteCache(), WriteVRML(), and ~SGFACESET().

m_RCoords

SGCOORDS* SGFACESET::m_RCoords

Definition at line 86 of file sg_faceset.h.

Referenced by addNode(), CalcNormals(), SGSHAPE::Prepare(), ReadCache(), SGFACESET(), unlinkNode(), validate(), WriteCache(), WriteVRML(), and ~SGFACESET().

m_RNormals

SGNORMALS* SGFACESET::m_RNormals

Definition at line 87 of file sg_faceset.h.

Referenced by addNode(), CalcNormals(), SGSHAPE::Prepare(), ReadCache(), SGFACESET(), unlinkNode(), validate(), WriteCache(), WriteVRML(), and ~SGFACESET().

m_SGtype

S3D::SGTYPES SGNODE::m_SGtype

protectedinherited

Type of Scene Graph node.

Definition at line 228 of file sg_node.h.

Referenced by SGNODE::delNodeRef(), SGNODE::GetName(), SCENEGRAPH::SCENEGRAPH(), SGNODE::SetName(), SGAPPEARANCE::SGAPPEARANCE(), SGCOLORS::SGCOLORS(), SGCOORDINDEX::SGCOORDINDEX(), SGCOORDS::SGCOORDS(), SGFACESET(), SGNODE::SGNODE(), SGNORMALS::SGNORMALS(), SGSHAPE::SGSHAPE(), and SGINDEX::WriteVRML().

m_written

bool SGNODE::m_written

protectedinherited

Set to true when the object has been written after a ReNameNodes().

Definition at line 230 of file sg_node.h.

Referenced by SGNODE::isWritten(), SCENEGRAPH::ReNameNodes(), SGAPPEARANCE::ReNameNodes(), SGCOLORS::ReNameNodes(), SGCOORDS::ReNameNodes(), ReNameNodes(), SGINDEX::ReNameNodes(), SGNORMALS::ReNameNodes(), SGSHAPE::ReNameNodes(), SGNODE::SGNODE(), SCENEGRAPH::WriteCache(), SGAPPEARANCE::WriteCache(), SGCOLORS::WriteCache(), SGCOORDS::WriteCache(), WriteCache(), SGINDEX::WriteCache(), SGNORMALS::WriteCache(), SGSHAPE::WriteCache(), SCENEGRAPH::WriteVRML(), SGAPPEARANCE::WriteVRML(), SGCOLORS::WriteVRML(), SGCOORDS::WriteVRML(), WriteVRML(), SGNORMALS::WriteVRML(), and SGSHAPE::WriteVRML().

valid

bool SGFACESET::valid

private

Definition at line 90 of file sg_faceset.h.

Referenced by addNode(), SGFACESET(), unlinkNode(), and validate().

validated

bool SGFACESET::validated

private

Definition at line 91 of file sg_faceset.h.

Referenced by addNode(), SGFACESET(), unlinkNode(), and validate().

---

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

• sg_faceset.h
• sg_faceset.cpp