//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLR_I_L_TMesh::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
#if defined(TRACE_ENABLED) && defined(MLR_TRACE)
Unregister_Object(MLR_I_L_TMesh_Clip);
delete MLR_I_L_TMesh_Clip;
#endif
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLRTexturePool::TerminateClass()
{
if (MLRTexturePool::Instance)
{
Unregister_Object(MLRTexturePool::Instance);
delete MLRTexturePool::Instance;
}
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLR_Terrain2::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
Unregister_Object(detailTexCoords);
delete detailTexCoords;
#if defined(TRACE_ENABLED) && defined(MLR_TRACE)
Unregister_Object(MLR_Terrain2_Clip);
delete MLR_Terrain2_Clip;
#endif
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLRIndexedPolyMesh::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
Unregister_Object(AllocatedMemory);
delete AllocatedMemory;
AllocatedMemory = NULL;
#if defined(TRACE_ENABLED) && defined(MLR_TRACE)
Unregister_Object(MLRIndexedPolyMesh_Clip);
delete MLRIndexedPolyMesh_Clip;
#endif
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLRIndexedPrimitive::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//------------------------------------------------------------------------------
//
void
gosFX::ParticleCloud::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLRSorter::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLRAmbientLight::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//------------------------------------------------------------------------------
//
void
gosFX::PointCloud::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = nullptr;
}
//
//#############################################################################
// DeletePlugs
//#############################################################################
//
void
SocketIterator::DeletePlugs(bool defeat_release_node)
{
Check_Object(this);
Plug *plug;
Node *save_release_node = NULL;
if (defeat_release_node)
{
Check_Object(socket);
save_release_node = socket->GetReleaseNode();
socket->SetReleaseNode(NULL);
}
First();
while ((plug = ReadAndNextPlug()) != NULL)
{
Unregister_Object(plug);
delete plug;
}
if (defeat_release_node)
{
Check_Object(socket);
socket->SetReleaseNode(save_release_node);
}
}
//------------------------------------------------------------------------------
//
void
gosFX::Effect::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLRNGonCloud::TerminateClass()
{
Unregister_Object(clipPerVertex);
delete clipPerVertex;
Unregister_Object(clipExtraCoords);
delete clipExtraCoords;
Unregister_Object(clipExtraColors);
delete clipExtraColors;
Unregister_Object(clipExtraLength);
delete clipExtraLength;
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLRLightMap::TerminateClass()
{
clipBuffer[1].Destroy();
clipBuffer[0].Destroy();
Unregister_Pointer(clipBuffer);
delete [] clipBuffer;
Unregister_Object(transformedCoords);
delete transformedCoords;
Unregister_Object(clipExtraCoords);
delete clipExtraCoords;
Unregister_Object(clipExtraColors);
delete clipExtraColors;
Unregister_Object(clipExtraTexCoords);
delete clipExtraTexCoords;
Unregister_Object(clippingStates);
delete clippingStates;
stream->Rewind();
unsigned char *ptr = (unsigned char *)stream->GetPointer();
Unregister_Object(stream);
delete stream;
stream = NULL;
Unregister_Pointer(ptr);
delete [] ptr;
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//
//###########################################################################
//###########################################################################
//
void
HashIterator::DeleteSortedChainIterator()
{
if (vchainIterator != NULL)
{
Unregister_Object(vchainIterator);
delete vchainIterator;
vchainIterator = NULL;
}
}
void
DetachReference()
{
Check_Object(this);
Verify(referenceCount > 0);
if((--referenceCount) == 0)
{
Unregister_Object(this);
delete this;
}
}
inline void
MStringRepresentation::DecrementReferenceCount()
{
Check_Object(this);
Verify(referenceCount > 0);
if (--referenceCount == 0)
{
Unregister_Object(this);
delete this;
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
Plug::TerminateClass()
{
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
Check_Pointer(ConnectionEngineHeap);
gos_DestroyMemoryHeap(ConnectionEngineHeap);
ConnectionEngineHeap = NULL;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MLRTexturePool::~MLRTexturePool()
{
int i;
for(i=0;i<MLRState::TextureMask;i++)
{
if(textureArray[i] != NULL)
{
Unregister_Object(textureArray[i]);
delete textureArray[i];
textureArray[i] = NULL;
}
}
Unregister_Object(imagePool);
delete imagePool;
Unregister_Pointer(freeHandle);
delete [] freeHandle;
}
template <class V> void
TableEntryOf<V>::operator delete(void *where)
{
Check_Object(allocatedMemory);
allocatedMemory->Delete(where);
if (--allocationCount == 0)
{
Unregister_Object(allocatedMemory);
delete allocatedMemory;
allocatedMemory = NULL;
}
Verify(allocationCount >= 0);
}
//
//###########################################################################
// ~Plug
//###########################################################################
//
Plug::~Plug()
{
Check_Object(this);
Link *link = linkHead;
while (link)
{
Check_Object(link);
Link *next = link->nextLink;
Unregister_Object(link);
delete link;
link = next;
}
}
template <class V> void
TreeNodeOf<V>::operator delete(PVOID where)
{
Check_Object(allocatedMemory);
allocatedMemory->Delete(where);
if(--allocationCount == 0)
{
Unregister_Object(allocatedMemory);
delete allocatedMemory;
allocatedMemory = nullptr;
}
Verify(allocationCount >= 0);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
MLRIndexedTriangleCloud::TerminateClass()
{
Unregister_Pointer(clipExtraIndex);
delete clipExtraIndex;
Unregister_Pointer(clipExtraTexCoords);
delete clipExtraTexCoords;
Unregister_Pointer(visibleIndexedVertices);
delete visibleIndexedVertices;
Unregister_Object(DefaultData);
delete DefaultData;
DefaultData = NULL;
}
//
//###########################################################################
// Remove
//###########################################################################
//
void
PlugIterator::Remove()
{
Check_Object(this);
Link *old_link;
Check_Object(currentLink);
old_link = currentLink;
currentLink = currentLink->nextLink;
Unregister_Object(old_link);
delete old_link;
}
//
//#############################################################################
// RemoveSocket
//#############################################################################
//
void
Plug::RemoveSocket(Socket *socket)
{
Check_Object(this);
Check_Object(socket);
Link *link;
for (link = linkHead; link != NULL; link = link->nextLink)
{
Check_Object(link);
if (link->GetSocket() == socket)
{
Unregister_Object(link);
delete link;
return;
}
}
}
//
//###########################################################################
// ~Hash
//###########################################################################
//
Hash::~Hash()
{
Check_Object(this);
int i;
for (i = 0; i < hashTableSize; i++)
{
Check_Pointer(hashTable);
Verify_Index(i);
if (hashTable[i] != NULL)
{
Unregister_Object(hashTable[i]);
delete hashTable[i];
}
}
Unregister_Pointer(hashTable);
delete[] hashTable;
hashTable = NULL;
hashTableSize = 0;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void MLRTexturePool::Stop (void)
{
Verify(gos_GetCurrentHeap() == Heap);
int i;
for(i=0;i<MLRState::TextureMask;i++)
{
if(textureArray[i] != NULL)
{
Unregister_Object(textureArray[i]);
delete textureArray[i];
textureArray[i] = NULL;
}
}
Unregister_Pointer(freeHandle);
delete [] freeHandle;
}
//------------------------------------------------------------------------------
//
bool gosFX::Effect::Execute(ExecuteInfo *info)
{
Check_Object(this);
Check_Pointer(info);
Verify(IsExecuted());
gos_PushCurrentHeap(Heap);
//
//-----------------------------------------------------
// If a new seed is provided, override the current seed
//-----------------------------------------------------
//
if (info->m_seed != -1.0f)
{
Verify(info->m_seed>=0.0f && info->m_seed<1.0f);
m_seed = info->m_seed;
}
//
//--------------------------------------------
// Figure out the new age and clear the bounds
//--------------------------------------------
//
Stuff::Scalar age =
m_age + static_cast<Stuff::Scalar>(info->m_time - m_lastRan) * m_ageRate;
Verify(age >= 0.0f && age >= m_age);
*info->m_bounds = Stuff::OBB::Identity;
//
//--------------------------------
// Update the effectToWorld matrix
//--------------------------------
//
Check_Object(info->m_parentToWorld);
m_localToWorld.Multiply(m_localToParent, *info->m_parentToWorld);
//
//--------------------------------------------------
// Check to see if the top event needs to be handled
//--------------------------------------------------
//
Check_Object(m_specification);
Event *event;
while ((event = m_event.GetCurrent()) != NULL)
{
Check_Object(event);
if (event->m_time > m_age)
break;
//
//-------------------------------------------------------------
// This event needs to go, so spawn and bump the effect pointer
//-------------------------------------------------------------
//
unsigned flags = ExecuteFlag;
if ((event->m_flags&SimulationModeMask) == ParentSimulationMode)
{
Verify((m_flags&SimulationModeMask) != ParentSimulationMode);
flags |= m_flags&SimulationModeMask;
}
else
flags |= event->m_flags&SimulationModeMask;
Effect* effect =
EffectLibrary::Instance->MakeEffect(
event->m_effectID,
flags
);
Register_Object(effect);
m_children.Add(effect);
m_event.Next();
//
//---------------------------------------------
// Now set the info for starting the new effect
//---------------------------------------------
//
effect->m_localToParent = event->m_localToParent;
Stuff::Scalar min_seed =
m_specification->m_minimumChildSeed.ComputeValue(m_age, m_seed);
Stuff::Scalar seed_range =
m_specification->m_maximumChildSeed.ComputeValue(m_age, m_seed) - min_seed;
Stuff::Scalar seed =
Stuff::Random::GetFraction()*seed_range + min_seed;
Clamp(seed, 0.0f, 1.0f);
ExecuteInfo
local_info(
info->m_time,
&m_localToWorld,
NULL,
seed
);
effect->Start(&local_info);
}
//
//------------------------------------------------------------
// Execute all the children. If any of them finish, kill them
//------------------------------------------------------------
//
Stuff::ChainIteratorOf<gosFX::Effect*> children(&m_children);
gosFX::Effect *child;
Stuff::OBB child_obb = Stuff::OBB::Identity;
ExecuteInfo
child_info(
info->m_time,
&m_localToWorld,
&child_obb
);
child_info.m_bounds = &child_obb;
while ((child = children.ReadAndNext()) != NULL)
{
Check_Object(child);
if (!child->Execute(&child_info))
{
Unregister_Object(child);
delete child;
}
//
//--------------------------------------------------------------
// Merge the bounding sphere of the child into the bounds of the
// parent
//--------------------------------------------------------------
//
Stuff::OBB parent_bounds;
parent_bounds.Multiply(child_obb, m_localToParent);
info->m_bounds->Union(*info->m_bounds, parent_bounds);
}
Check_Object(info->m_bounds);
//
//----------------------------------------------------------------------
// Set the new time, then if we have run the course of the effect, start
// over if we loop, otherwise wait for our children to finish before
// killing ourselves
//----------------------------------------------------------------------
//
m_lastRan = info->m_time;
m_age = age;
if (m_age >= 1.0f)
{
if (IsLooped())
Start(info);
else if (HasFinished())
Kill();
}
//
//----------------------------------
// Tell our parent if we need to die
//----------------------------------
//
gos_PopCurrentHeap();
return IsExecuted();
}
//
//###########################################################################
// RunTest
//###########################################################################
//
bool
TreeTestNode::RunTest()
{
TreeTestPlug *testPlug1, *testPlug2;
int values[TEST_COUNT];
int i, j;
// Time startTicks;
/*
* Generate unique values, shuffle them
*/
for (i = 0; i < TEST_COUNT; i++) {
values[i] = i;
}
for (i = 0; i < TEST_COUNT; i++) {
int tmp;
j = i + Random::GetLessThan(TEST_COUNT - i);
tmp = values[j];
values[j] = values[i];
values[i] = tmp;
}
//
//--------------------------------------------------------------------
// Stress tests
//--------------------------------------------------------------------
//
/*
* Create plugs and add to both sockets
*/
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new TreeTestPlug(values[i]);
Register_Object(testPlug1);
tree1.AddValue(testPlug1, values[i]);
tree2.AddValue(testPlug1, values[i]);
}
TestOrder();
/*
* Find
*/
{
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = tree1.Find(i);
testPlug2 = tree2.Find(i);
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
Test_Assumption( testPlug1 == testPlug2 );
}
}
/*
* Test_Assumption first and last
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
iterator1.First();
iterator2.First();
testPlug1 = iterator1.GetCurrent();
testPlug2 = iterator2.GetCurrent();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1 == iterator1.GetNth(0) );
Test_Assumption( testPlug1 == iterator2.GetNth(0) );
}
/*
* Test_Assumption next and prev
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.GetCurrent()) != NULL)
{
testPlug2 = iterator2.GetCurrent();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
iterator1.Next();
iterator2.Next();
i++;
}
Test_Assumption( i == TEST_COUNT );
}
/*
* Test_Assumption read next and read prev
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
{
testPlug2 = iterator2.ReadAndNext();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
i++;
}
Test_Assumption( i == TEST_COUNT );
}
/*
* Test_Assumption nth
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = iterator1.GetNth(i);
testPlug2 = iterator2.GetNth(i);
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
}
}
/*
* Test_Assumption Remove
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.GetCurrent()) != NULL)
{
Test_Assumption( testPlug1->value == i );
iterator1.Remove();
testPlug2 = iterator2.GetNth(0);
Test_Assumption( testPlug2->value == i );
Test_Assumption( testPlug1 == testPlug2 );
Unregister_Object(testPlug2);
delete testPlug2;
i++;
TestOrder();
}
Test_Assumption( i == TEST_COUNT );
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
}
/*
* Test_Assumption random deletion
*/
/*
* Add plugs to both sockets
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new TreeTestPlug(values[i]);
Register_Object( testPlug1 );
tree1.AddValue(testPlug1, values[i]);
tree2.AddValue(testPlug1, values[i]);
TestOrder();
}
TestOrder();
}
/*
* Perform random deletion
*/
{
int size, index;
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while((size = iterator1.GetSize()) != 0)
{
index = Random::GetLessThan(size);
testPlug1 = iterator1.GetNth(index);
iterator1.Remove();
testPlug2 = iterator2.GetNth(index);
Test_Assumption( testPlug1 == testPlug2 );
Unregister_Object( testPlug2 );
delete(testPlug2);
i++;
TestOrder();
}
Test_Assumption( i == TEST_COUNT );
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
}
return true;
}
//------------------------------------------------------------------------------
//
gosFX::PointCloud::~PointCloud()
{
Unregister_Object(m_cloudImplementation);
delete m_cloudImplementation;
}
//------------------------------------------------------------------------------
//
gosFX::CardCloud::~CardCloud()
{
Unregister_Object(m_cloudImplementation);
delete m_cloudImplementation;
}
