void CourseContentsList::SetFromGameState()
{
RemoveAllChildren();
if( GAMESTATE->GetMasterPlayerNumber() == PlayerNumber_Invalid )
return;
const Trail *pMasterTrail = GAMESTATE->m_pCurTrail[GAMESTATE->GetMasterPlayerNumber()];
if( pMasterTrail == NULL )
return;
unsigned uNumEntriesToShow = pMasterTrail->m_vEntries.size();
CLAMP( uNumEntriesToShow, 0, m_vpDisplay.size() );
for( int i=0; i<(int)uNumEntriesToShow; i++ )
{
Actor *pDisplay = m_vpDisplay[i];
SetItemFromGameState( pDisplay, i );
this->AddChild( pDisplay );
}
bool bLoop = pMasterTrail->m_vEntries.size() > uNumEntriesToShow;
this->SetLoop( bLoop );
this->Load2();
this->SetTransformFromHeight( m_vpDisplay[0]->GetUnzoomedHeight() );
this->EnableMask( m_vpDisplay[0]->GetUnzoomedWidth(), m_vpDisplay[0]->GetUnzoomedHeight() );
if( bLoop )
{
SetPauseCountdownSeconds( 1.5f );
this->SetDestinationItem( m_vpDisplay.size()+1 ); // loop forever
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CLTWnd::Term
//
// PURPOSE: Termination
//
// ----------------------------------------------------------------------- //
void CLTWnd::Term()
{
// Sanity Check
if(!m_bInitialized)
return;
// All children should die... uh... I mean all of our child windows should be removed.
RemoveAllChildren();
// Delete the surface if necessary
if(m_bDeleteSurfOnTerm)
{
FreeAllSurfaces();
}
// If we've got the capture, release it
if(s_pWndCapture == this)
s_pWndCapture = NULL;
if(s_pWndActive == this)
s_pWndActive = NULL;
if(s_pMainWnd == this)
s_pMainWnd = NULL;
m_nWidth = m_nSurfWidth = m_nHeight = m_nSurfHeight = 0;
m_bInitialized = FALSE;
}
LandscapeRegion::~LandscapeRegion()
{
RemoveAllChildren();
m_pLandscape->SetBody( NULL );
m_pLandscape->SetEffectInstance( NULL );
m_pLandscape->SetMesh( NULL );
WorldFn->SelectMemory( TEXT("Outdoor") );
Delete( m_pLandscape );
m_pLandscape = NULL;
WorldFn->UnSelectMemory();
PhysicsFn->DestroyBody( m_pLandscapeBody );
m_pLandscapeBody = NULL;
PhysicsFn->DestroyShape( m_pLandscapeShape );
m_pLandscapeShape = NULL;
WorldFn->SelectMemory( TEXT("Outdoor") );
Delete( m_pLandscapeMesh );
m_pLandscapeMesh = NULL;
WorldFn->UnSelectMemory();
GraphicsFn->DestroyEffectInstance( m_pLandscapeEffectInstance );
m_pLandscapeEffectInstance = NULL;
}
void DomNode::SetText(const char* txt) {
if (Children.size() != 1 || Children[0]->GetTag() != TagText) {
RemoveAllChildren();
AddChild(TagText);
}
Children[0]->SetText(txt);
}
void MultiFuncSelectorWidget::UpdateButtons()
{
RemoveAllChildren();
for (int i = 0; i < MFUNC_MAX; ++i) {
Add(m_buttons[i], 36.0f + 36.0f * float(i), 0.0);
}
}
void COXLayoutManager::Detach()
{
ASSERT(m_pContainerWnd);
RemoveAllChildren();
m_pContainerWnd = NULL;
UnsubclassContainer();
}
void MoveableObject::RemoveAllChildrenRecursive()
{
for( auto& child : m_Children )
{
child->RemoveAllChildrenRecursive();
}
RemoveAllChildren();
}
//------------------------------------------------------------------
//------------------------------------------------------------------
void Entity::Reset()
{
RemoveAllComponents();
RemoveAllChildren();
RemoveFromParent();
m_name = std::string();
m_transform.Reset();
}
void COXLayoutManager::Attach(CWnd* pContainerWnd)
{
ASSERT(m_pContainerWnd == NULL);
ASSERT(pContainerWnd);
RemoveAllChildren();
m_pContainerWnd = pContainerWnd;
VERIFY(SubclassContainer(pContainerWnd));
}
Node::~Node()
{
RemoveAllChildren();
RemoveAllComponents();
// Remove from the scene
if (scene_)
scene_->NodeRemoved(this);
}
std::shared_ptr<touchmind::model::node::NodeModel> touchmind::model::node::NodeModel::DeepCopy() {
auto src(shared_from_this());
auto dest = NodeModel::Create(*src.get());
dest->RemoveAllChildren();
_DeepCopy(src, dest);
return dest;
}
void Collider::BreakChain()
{
for(auto child : children)
{
child->ApplySpace(glm::one<glm::mat4>());
}
RemoveAllChildren();
this->ApplySpace(glm::one<glm::mat4>());
parent->removeChild(this);
}
void _DeepCopy(std::shared_ptr<touchmind::model::node::NodeModel> srcParent,
std::shared_ptr<touchmind::model::node::NodeModel> destParent) {
for (size_t i = 0; i < srcParent->GetActualChildrenCount(); ++i) {
auto srcChild = srcParent->GetChild(i);
auto destChild = touchmind::model::node::NodeModel::Create(*srcChild.get());
destChild->RemoveAllChildren();
destParent->AddChild(destChild);
_DeepCopy(srcChild, destChild);
}
}
UiWidget::~UiWidget()
{
for(unsigned int i = 0; i < m_Animations.size(); ++i)
{
delete m_Animations[i];
}
ScriptManager::getSingleton().RemoveEntity(ScriptManager::UI, m_PathName);
RemoveAllChildren();
}
/*
=====================
GameNode::~GameNode
=====================
*/
GameNode::~GameNode() {
if (!willDelete) {
PrepareDeletion();
}
RemoveAllChildren();
UnlistenFrame();
UnlistenInput();
UnlistenController();
}
void EditorLightNode::Update(float32 timeElapsed)
{
Light * parent = (Light*)GetParent();
if(type != parent->GetType())
{
RemoveAllChildren();
type = parent->GetType();
SceneNode * lightDrawNode = scene->GetRootNode(GetSceneFile())->Clone();
AddNode(lightDrawNode);
SafeRelease(lightDrawNode);
}
}
/*
=====================
GameNode::PrepareDeletion
=====================
*/
void GameNode::PrepareDeletion() {
if (GetParentLayer()) {
GetParentLayer()->RemoveLight(this);
GetParentLayer()->RemoveShadowCaster(this);
}
if (shadowShape) {
delete shadowShape;
}
RemoveAllChildren();
UnlistenInput();
UnlistenController();
parent = NULL;
willDelete = true;
}
bool Node::LoadXML(const XMLElement& source, SceneResolver& resolver, bool readChildren, bool rewriteIDs, CreateMode mode)
{
// Remove all children and components first in case this is not a fresh load
RemoveAllChildren();
RemoveAllComponents();
if (!Serializable::LoadXML(source))
return false;
XMLElement compElem = source.GetChild("component");
while (compElem)
{
String typeName = compElem.GetAttribute("type");
unsigned compID = compElem.GetInt("id");
Component* newComponent = CreateComponent(ShortStringHash(typeName),
(mode == REPLICATED && compID < FIRST_LOCAL_ID) ? REPLICATED : LOCAL, rewriteIDs ? 0 : compID);
if (newComponent)
{
resolver.AddComponent(compID, newComponent);
if (!newComponent->LoadXML(compElem))
return false;
}
compElem = compElem.GetNext("component");
}
if (!readChildren)
return true;
XMLElement childElem = source.GetChild("node");
while (childElem)
{
unsigned nodeID = childElem.GetInt("id");
Node* newNode = CreateChild(rewriteIDs ? 0 : nodeID, (mode == REPLICATED && nodeID < FIRST_LOCAL_ID) ? REPLICATED :
LOCAL);
resolver.AddNode(nodeID, newNode);
if (!newNode->LoadXML(childElem, resolver, readChildren, rewriteIDs, mode))
return false;
childElem = childElem.GetNext("node");
}
return true;
}
bool Node::Load(Deserializer& source, SceneResolver& resolver, bool readChildren, bool rewriteIDs, CreateMode mode)
{
// Remove all children and components first in case this is not a fresh load
RemoveAllChildren();
RemoveAllComponents();
// ID has been read at the parent level
if (!Serializable::Load(source))
return false;
unsigned numComponents = source.ReadVLE();
for (unsigned i = 0; i < numComponents; ++i)
{
VectorBuffer compBuffer(source, source.ReadVLE());
ShortStringHash compType = compBuffer.ReadShortStringHash();
unsigned compID = compBuffer.ReadUInt();
Component* newComponent = CreateComponent(compType,
(mode == REPLICATED && compID < FIRST_LOCAL_ID) ? REPLICATED : LOCAL, rewriteIDs ? 0 : compID);
if (newComponent)
{
resolver.AddComponent(compID, newComponent);
if (!newComponent->Load(compBuffer))
return false;
}
}
if (!readChildren)
return true;
unsigned numChildren = source.ReadVLE();
for (unsigned i = 0; i < numChildren; ++i)
{
unsigned nodeID = source.ReadUInt();
Node* newNode = CreateChild(rewriteIDs ? 0 : nodeID, (mode == REPLICATED && nodeID < FIRST_LOCAL_ID) ? REPLICATED :
LOCAL);
resolver.AddNode(nodeID, newNode);
if (!newNode->Load(source, resolver, readChildren, rewriteIDs, mode))
return false;
}
return true;
}
// Moves all children to be under control of the widget.
void ElementFormControlSelect::OnUpdate()
{
ElementFormControl::OnUpdate();
// Move any child elements into the widget (except for the three functional elements).
for(int child_index = 0;child_index<GetNumChildren();++child_index)
{
Core::Element* child = GetChild(child_index);
// Check for a value attribute.
Rocket::Core::String attribute_value = child->GetAttribute<Rocket::Core::String>("value", "");
// Pull the inner RML and add the option.
Rocket::Core::String rml;
child->GetInnerRML(rml);
widget->AddOption(rml, attribute_value, -1, child->GetAttribute("selected") != NULL, child->GetAttribute("unselectable") == NULL);
}
RemoveAllChildren();
}
Scene::~Scene()
{
for (Vector<AnimatedMesh*>::iterator t = animatedMeshes.begin(); t != animatedMeshes.end(); ++t)
{
AnimatedMesh * obj = *t;
obj->Release();
}
animatedMeshes.clear();
for (Vector<Camera*>::iterator t = cameras.begin(); t != cameras.end(); ++t)
{
Camera * obj = *t;
obj->Release();
}
cameras.clear();
SafeRelease(currentCamera);
SafeRelease(clipCamera);
for (Map<String, ProxyNode*>::iterator it = rootNodes.begin(); it != rootNodes.end(); ++it)
{
SafeRelease(it->second);
}
rootNodes.clear();
// Children should be removed first because they should unregister themselves in managers
RemoveAllChildren();
SafeRelease(imposterManager);
transformSystem = 0;
renderUpdateSystem = 0;
lodSystem = 0;
uint32 size = (uint32)systems.size();
for (uint32 k = 0; k < size; ++k)
SafeDelete(systems[k]);
systems.clear();
SafeDelete(eventSystem);
SafeDelete(renderSystem);
}
void ReferenceNode::Update(float32 timeElapsed)
{
if(nodeToAdd)
{
AddNode(nodeToAdd);
SafeRelease(nodeToAdd);
}
if(scene->IsReferenceNodeSuffixChanged())
{
RemoveAllChildren();
String newFileName = FileSystem::Instance()->ReplaceExtension(customProperties->GetString("reference.path"), Format("_%s.sc2", scene->GetReferenceNodeSuffix().c_str()));
SceneNode * node = scene->GetRootNode(newFileName);
if(node)
{
nodeToAdd = node->Clone();
}
else
{
SceneNode * node = scene->GetRootNode(customProperties->GetString("reference.path"));
nodeToAdd = node->Clone();
}
}
}
COXLayoutManager::~COXLayoutManager()
{
RemoveAllChildren();
UnsubclassContainer();
}
ValueNodeContainer::~ValueNodeContainer()
{
RemoveAllChildren();
}
void ActorFrame::TransferChildren( ActorFrame *pTo )
{
FOREACH( Actor*, m_SubActors, i )
pTo->AddChild( *i );
RemoveAllChildren();
}
//-------------------------------------------------------------
//-------------------------------------------------------------
Entity::~Entity()
{
RemoveAllComponents();
RemoveAllChildren();
}
String DomNode::Parse(const char* src) {
RemoveAllChildren();
return ParseAppend(src);
}
Actor::~Actor()
{
mGame.GetTime().ClearAllTimers(this);
RemoveAllChildren();
RemoveAllComponents();
}
Scene::~Scene()
{
SceneCache::Instance()->RemoveScene(this);
for (Vector<AnimatedMesh*>::iterator t = animatedMeshes.begin(); t != animatedMeshes.end(); ++t)
{
AnimatedMesh * obj = *t;
obj->Release();
}
animatedMeshes.clear();
for (Vector<Camera*>::iterator t = cameras.begin(); t != cameras.end(); ++t)
{
Camera * obj = *t;
obj->Release();
}
cameras.clear();
SafeRelease(mainCamera);
SafeRelease(drawCamera);
for (ProxyNodeMap::iterator it = rootNodes.begin(); it != rootNodes.end(); ++it)
{
SafeRelease(it->second);
}
rootNodes.clear();
// Children should be removed first because they should unregister themselves in managers
RemoveAllChildren();
SafeRelease(imposterManager);
SafeRelease(sceneGlobalMaterial);
transformSystem = 0;
renderUpdateSystem = 0;
lodSystem = 0;
debugRenderSystem = 0;
particleEffectSystem = 0;
updatableSystem = 0;
lightUpdateSystem = 0;
switchSystem = 0;
soundSystem = 0;
actionSystem = 0;
skyboxSystem = 0;
staticOcclusionSystem = 0;
materialSystem = 0;
speedTreeUpdateSystem = 0;
foliageSystem = 0;
windSystem = 0;
waveSystem = 0;
uint32 size = (uint32)systems.size();
for (uint32 k = 0; k < size; ++k)
SafeDelete(systems[k]);
systems.clear();
systemsToProcess.clear();
SafeDelete(eventSystem);
SafeDelete(renderSystem);
}
CBaseContainerNode::~CBaseContainerNode()
{
RemoveAllChildren();
pNodeView->OnContainerRemoved( this );
}
