CDTestFramework, OPCODE, ICE redistributed under the ZLib License, with permission of Pierre Terdiman
Added Bullet SAP/MultiSAP support by Erwin Coumans (BulletSAPCompleteBoxPruningTest.*) AABB tree broadphase by Nathanael Presson (btDbvt.*, DbvtTest.*)
This commit is contained in:
erwin.coumans
361
Extras/CDTestFramework/Opcode/Ice/IceContainer.cpp
Normal file
361
Extras/CDTestFramework/Opcode/Ice/IceContainer.cpp
Normal file
@@ -0,0 +1,361 @@
|
||||
/*
|
||||
* ICE / OPCODE - Optimized Collision Detection
|
||||
* http://www.codercorner.com/Opcode.htm
|
||||
*
|
||||
* Copyright (c) 2001-2008 Pierre Terdiman, pierre@codercorner.com
|
||||
|
||||
This software is provided 'as-is', without any express or implied warranty.
|
||||
In no event will the authors be held liable for any damages arising from the use of this software.
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it freely,
|
||||
subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Contains a simple container class.
|
||||
* \file IceContainer.cpp
|
||||
* \author Pierre Terdiman
|
||||
* \date February, 5, 2000
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Contains a list of 32-bits values.
|
||||
* Use this class when you need to store an unknown number of values. The list is automatically
|
||||
* resized and can contains 32-bits entities (dwords or floats)
|
||||
*
|
||||
* \class Container
|
||||
* \author Pierre Terdiman
|
||||
* \version 1.0
|
||||
* \date 08.15.98
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Precompiled Header
|
||||
#include "Stdafx.h"
|
||||
|
||||
using namespace IceCore;
|
||||
|
||||
// Static members
|
||||
#ifdef CONTAINER_STATS
|
||||
udword Container::mNbContainers = 0;
|
||||
udword Container::mUsedRam = 0;
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Constructor. No entries allocated there.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
Container::Container() : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(2.0f)
|
||||
{
|
||||
#ifdef CONTAINER_STATS
|
||||
mNbContainers++;
|
||||
mUsedRam+=sizeof(Container);
|
||||
#endif
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Constructor. Also allocates a given number of entries.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
Container::Container(udword size, float growth_factor) : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(growth_factor)
|
||||
{
|
||||
#ifdef CONTAINER_STATS
|
||||
mNbContainers++;
|
||||
mUsedRam+=sizeof(Container);
|
||||
#endif
|
||||
SetSize(size);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Copy constructor.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
Container::Container(const Container& object) : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(2.0f)
|
||||
{
|
||||
#ifdef CONTAINER_STATS
|
||||
mNbContainers++;
|
||||
mUsedRam+=sizeof(Container);
|
||||
#endif
|
||||
*this = object;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Destructor. Frees everything and leaves.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
Container::~Container()
|
||||
{
|
||||
Empty();
|
||||
#ifdef CONTAINER_STATS
|
||||
mNbContainers--;
|
||||
mUsedRam-=GetUsedRam();
|
||||
#endif
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Clears the container. All stored values are deleted, and it frees used ram.
|
||||
* \see Reset()
|
||||
* \return Self-Reference
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
Container& Container::Empty()
|
||||
{
|
||||
#ifdef CONTAINER_STATS
|
||||
mUsedRam-=mMaxNbEntries*sizeof(udword);
|
||||
#endif
|
||||
DELETEARRAY(mEntries);
|
||||
mCurNbEntries = mMaxNbEntries = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Resizes the container.
|
||||
* \param needed [in] assume the container can be added at least "needed" values
|
||||
* \return true if success.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool Container::Resize(udword needed)
|
||||
{
|
||||
#ifdef CONTAINER_STATS
|
||||
// Subtract previous amount of bytes
|
||||
mUsedRam-=mMaxNbEntries*sizeof(udword);
|
||||
#endif
|
||||
|
||||
// Get more entries
|
||||
mMaxNbEntries = mMaxNbEntries ? udword(float(mMaxNbEntries)*mGrowthFactor) : 2; // Default nb Entries = 2
|
||||
if(mMaxNbEntries<mCurNbEntries + needed) mMaxNbEntries = mCurNbEntries + needed;
|
||||
|
||||
// Get some bytes for new entries
|
||||
udword* NewEntries = new udword[mMaxNbEntries];
|
||||
CHECKALLOC(NewEntries);
|
||||
|
||||
#ifdef CONTAINER_STATS
|
||||
// Add current amount of bytes
|
||||
mUsedRam+=mMaxNbEntries*sizeof(udword);
|
||||
#endif
|
||||
|
||||
// Copy old data if needed
|
||||
if(mCurNbEntries) CopyMemory(NewEntries, mEntries, mCurNbEntries*sizeof(udword));
|
||||
|
||||
// Delete old data
|
||||
DELETEARRAY(mEntries);
|
||||
|
||||
// Assign new pointer
|
||||
mEntries = NewEntries;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Sets the initial size of the container. If it already contains something, it's discarded.
|
||||
* \param nb [in] Number of entries
|
||||
* \return true if success
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool Container::SetSize(udword nb)
|
||||
{
|
||||
// Make sure it's empty
|
||||
Empty();
|
||||
|
||||
// Checkings
|
||||
if(!nb) return false;
|
||||
|
||||
// Initialize for nb entries
|
||||
mMaxNbEntries = nb;
|
||||
|
||||
// Get some bytes for new entries
|
||||
mEntries = new udword[mMaxNbEntries];
|
||||
CHECKALLOC(mEntries);
|
||||
|
||||
#ifdef CONTAINER_STATS
|
||||
// Add current amount of bytes
|
||||
mUsedRam+=mMaxNbEntries*sizeof(udword);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Refits the container and get rid of unused bytes.
|
||||
* \return true if success
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool Container::Refit()
|
||||
{
|
||||
#ifdef CONTAINER_STATS
|
||||
// Subtract previous amount of bytes
|
||||
mUsedRam-=mMaxNbEntries*sizeof(udword);
|
||||
#endif
|
||||
|
||||
// Get just enough entries
|
||||
mMaxNbEntries = mCurNbEntries;
|
||||
if(!mMaxNbEntries) return false;
|
||||
|
||||
// Get just enough bytes
|
||||
udword* NewEntries = new udword[mMaxNbEntries];
|
||||
CHECKALLOC(NewEntries);
|
||||
|
||||
#ifdef CONTAINER_STATS
|
||||
// Add current amount of bytes
|
||||
mUsedRam+=mMaxNbEntries*sizeof(udword);
|
||||
#endif
|
||||
|
||||
// Copy old data
|
||||
CopyMemory(NewEntries, mEntries, mCurNbEntries*sizeof(udword));
|
||||
|
||||
// Delete old data
|
||||
DELETEARRAY(mEntries);
|
||||
|
||||
// Assign new pointer
|
||||
mEntries = NewEntries;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Checks whether the container already contains a given value.
|
||||
* \param entry [in] the value to look for in the container
|
||||
* \param location [out] a possible pointer to store the entry location
|
||||
* \see Add(udword entry)
|
||||
* \see Add(float entry)
|
||||
* \see Empty()
|
||||
* \return true if the value has been found in the container, else false.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool Container::Contains(udword entry, udword* location) const
|
||||
{
|
||||
// Look for the entry
|
||||
for(udword i=0;i<mCurNbEntries;i++)
|
||||
{
|
||||
if(mEntries[i]==entry)
|
||||
{
|
||||
if(location) *location = i;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Deletes an entry. If the container contains such an entry, it's removed.
|
||||
* \param entry [in] the value to delete.
|
||||
* \return true if the value has been found in the container, else false.
|
||||
* \warning This method is arbitrary slow (O(n)) and should be used carefully. Insertion order is not preserved.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool Container::Delete(udword entry)
|
||||
{
|
||||
// Look for the entry
|
||||
for(udword i=0;i<mCurNbEntries;i++)
|
||||
{
|
||||
if(mEntries[i]==entry)
|
||||
{
|
||||
// Entry has been found at index i. The strategy is to copy the last current entry at index i, and decrement the current number of entries.
|
||||
DeleteIndex(i);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Deletes an entry, preserving the insertion order. If the container contains such an entry, it's removed.
|
||||
* \param entry [in] the value to delete.
|
||||
* \return true if the value has been found in the container, else false.
|
||||
* \warning This method is arbitrary slow (O(n)) and should be used carefully.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool Container::DeleteKeepingOrder(udword entry)
|
||||
{
|
||||
// Look for the entry
|
||||
for(udword i=0;i<mCurNbEntries;i++)
|
||||
{
|
||||
if(mEntries[i]==entry)
|
||||
{
|
||||
// Entry has been found at index i.
|
||||
// Shift entries to preserve order. You really should use a linked list instead.
|
||||
mCurNbEntries--;
|
||||
for(udword j=i;j<mCurNbEntries;j++)
|
||||
{
|
||||
mEntries[j] = mEntries[j+1];
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Gets the next entry, starting from input one.
|
||||
* \param entry [in/out] On input, the entry to look for. On output, the next entry
|
||||
* \param find_mode [in] wrap/clamp
|
||||
* \return Self-Reference
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
Container& Container::FindNext(udword& entry, FindMode find_mode)
|
||||
{
|
||||
udword Location;
|
||||
if(Contains(entry, &Location))
|
||||
{
|
||||
Location++;
|
||||
if(Location==mCurNbEntries) Location = find_mode==FIND_WRAP ? 0 : mCurNbEntries-1;
|
||||
entry = mEntries[Location];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Gets the previous entry, starting from input one.
|
||||
* \param entry [in/out] On input, the entry to look for. On output, the previous entry
|
||||
* \param find_mode [in] wrap/clamp
|
||||
* \return Self-Reference
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
Container& Container::FindPrev(udword& entry, FindMode find_mode)
|
||||
{
|
||||
udword Location;
|
||||
if(Contains(entry, &Location))
|
||||
{
|
||||
Location--;
|
||||
if(Location==0xffffffff) Location = find_mode==FIND_WRAP ? mCurNbEntries-1 : 0;
|
||||
entry = mEntries[Location];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Gets the ram used by the container.
|
||||
* \return the ram used in bytes.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
udword Container::GetUsedRam() const
|
||||
{
|
||||
return sizeof(Container) + mMaxNbEntries * sizeof(udword);
|
||||
}
|
||||
|
||||
void Container::operator=(const Container& object)
|
||||
{
|
||||
SetSize(object.GetNbEntries());
|
||||
CopyMemory(mEntries, object.GetEntries(), mMaxNbEntries*sizeof(udword));
|
||||
mCurNbEntries = mMaxNbEntries;
|
||||
}
|
||||
Reference in New Issue
Block a user