void BSPTree::Release()
{
SafeDeleteArray( m_paNode );
SafeDeleteArray( m_paPlane );
m_NumNodes = 0;
m_NumPlanes = 0;
}
bool Init_Lang ( const wchar_t * szFileName )
{
const int MAX_BUFFER_SIZE = 102400;
HANDLE hFile = CreateFile ( szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
if ( hFile == INVALID_HANDLE_VALUE )
return false;
ULARGE_INTEGER uSize;
uSize.LowPart = GetFileSize ( hFile, &uSize.HighPart );
if ( uSize.LowPart == 0xFFFFFFFF )
return false;
int iSize = (int) uSize.QuadPart;
if ( iSize > MAX_BUFFER_SIZE )
return false;
if ( ( iSize % 2 ) != 0 )
return false;
int iBufferSize = iSize / 2;
wchar_t * pBuffer = new wchar_t [iBufferSize + 1];
DWORD uSizeRead = 0;
ReadFile ( hFile, pBuffer, iSize, &uSizeRead, NULL );
CloseHandle ( hFile );
if ( uSizeRead != iSize )
{
SafeDeleteArray ( pBuffer );
return false;
}
pBuffer [iBufferSize] = L'\0';
wchar_t * pStart = pBuffer;
while ( *pStart )
{
while ( *pStart && _X_iswspace ( *pStart ) )
++pStart;
wchar_t * pLineStart = pStart;
while ( *pStart && *pStart != L'\n' )
++pStart;
int nChars = pStart - pLineStart - ( *pStart ? 1 : 0 );
wchar_t * szAllocated = new wchar_t [nChars + 1];
CopyConvert ( pLineStart, szAllocated, nChars );
g_dStrings.Add ( szAllocated );
}
SafeDeleteArray ( pBuffer );
if ( g_dStrings.Length () != T_TOTAL )
return false;
return true;
}
void NMaterialInstance::PrepareInstanceForShader(Shader * _shader)
{
if (shader == _shader)return;
shader = _shader;
/*
TODO: rethink how to prepare instances for particular shaders of material.
*/
SafeDeleteArray(uniforms);
SafeDeleteArray(uniformData);
uniformCount = shader->GetUniformCount();
uniforms = new UniformInfo[uniformCount];
memset(uniforms, 0, sizeof(UniformInfo) * uniformCount);
uint32 uniformDataSize = 0;
for (uint32 uniformIndex = 0; uniformIndex < uniformCount; ++uniformIndex)
{
Shader::eUniformType uniformType = shader->GetUniformType(uniformIndex);
uint32 size = shader->GetUniformTypeSize(uniformType) * shader->GetUniformArraySize(uniformIndex) + 4;
uniforms[uniformIndex].shift = uniformDataSize;
uniforms[uniformIndex].arraySize = shader->GetUniformArraySize(uniformIndex);
uniformDataSize += size;
}
uniformData = new uint8[uniformDataSize];
for (uint32 uniformIndex = 0; uniformIndex < uniformCount; ++uniformIndex)
{
//Shader::eUniformType uniformType = shader->GetUniformType(uniformIndex);
const String & uniformName = shader->GetUniformName(uniformIndex);
//Logger::Debug("Find uniform: %s", uniformName.c_str());
if ((uniformName == "texture[0]") || (uniformName == "texture"))
{
uint32 textureIndexes[8] = {0, 1, 2, 3, 4, 5, 6, 7};
SetUniformData(uniformIndex, textureIndexes, 4 * shader->GetUniformArraySize(uniformIndex));
}else if ((uniformName == "lightIntensity[0]") || (uniformName == "lightIntensity"))
{
float32 lightIntensity[8] = {500, 500, 500, 500, 100, 100, 100, 100};
SetUniformData(uniformIndex, lightIntensity, 4 * shader->GetUniformArraySize(uniformIndex));
}else if ((uniformName == "lightPosition[0]") || (uniformName == "lightPosition"))
{
Vector3 lightPosition[8] = {
Vector3(0.0f, 0.0f, 0.0f),
Vector3(0.0f, 0.0f, 0.0f),
Vector3(0.0f, 0.0f, 0.0f),
Vector3(0.0f, 0.0f, 0.0f),
Vector3(0.0f, 0.0f, 0.0f),
Vector3(0.0f, 0.0f, 0.0f),
Vector3(0.0f, 0.0f, 0.0f),
Vector3(0.0f, 0.0f, 0.0f),
};
SetUniformData(uniformIndex, lightPosition, 12 * shader->GetUniformArraySize(uniformIndex));
}else
{
uniforms[uniformIndex].flags |= SKIP_UNIFORM;
}
}
}
//----------------------------------------------------------------------------------------------------
void Mesh::Destroy()
{
SafeDeleteArray(mpVertices);
SafeDeleteArray(mpIndices);
mNumVertices = 0;
mNumIndices = 0;
}
//**************************************************
//khởi tạo danh sách điểm và chỉ mục
//**************************************************
void HQPolygon3D::Set(const HQVector4 *_pPoints, hq_int32 _numP, const hq_uint32 *_pIndices, hq_int32 _numI){
HQ_DECL_STACK_2VECTOR4(e0,e1);
SafeDeleteArray(pPoints);
SafeDeleteArray(pIndices);
numP=_numP;
numI=_numI;
pPoints=HQVector4::NewArray(numP);
pIndices=new hq_uint32[numI];
memcpy(pPoints,_pPoints,numP*sizeof(HQVector4));
memcpy(pIndices,_pIndices,numI*sizeof(hq_uint32));
HQVector4Sub(&pPoints[pIndices[1]], &pPoints[pIndices[0]], &e0);
for(hq_int32 i=2;i<numI;++i){
HQVector4Sub(&pPoints[pIndices[i]], &pPoints[pIndices[0]], &e1);
hq_float32 angle=fabs(e1.AngleWith(e0));
if(angle>0.0f+EPSILON&&angle<HQPiFamily::PI-EPSILON)//kiểm tra vector song song
break;
}
plane.N.Cross(e0,e1);
plane.N.Normalize();
plane.D=-(plane.N * pPoints[pIndices[0]]);
this->CalBoundingBox();
}
bool Database::run()
{
SetThreadName("Database Execute Thread");
ThreadRunning = true;
char * query = queries_queue.pop();
DatabaseConnection * con = GetFreeConnection();
while(query)
{
_SendQuery( con, query, false );
SafeDeleteArray(query);
if(m_threadRunning == true)
break;
query = queries_queue.pop();
}
con->Busy.Release();
if(queries_queue.get_size() > 0)
{
// execute all the remaining queries
query = queries_queue.pop_nowait();
while(query)
{
DatabaseConnection * con = GetFreeConnection();
_SendQuery( con, query, false );
con->Busy.Release();
SafeDeleteArray(query);
query=queries_queue.pop_nowait();
}
}
ThreadRunning = false;
return false;
}
GraphicsFontDefinition::~GraphicsFontDefinition()
{
SafeDeleteArray(characterTable);
SafeDeleteArray(characterPreShift);
SafeDeleteArray(characterWidthTable);
SafeDeleteArray(kerningBaseShift);
SafeDeleteArray(kerningTable);
}
FeaturePyramid::~FeaturePyramid()
{
SafeDeleteArray(prevLevels);
SafeDeleteArray(currLevels);
SafeDeleteArray(currLevelsBuffer);
delete pFeatureReader;
}
BoneAnimation::~BoneAnimation()
{
for (int32 bi = 0; bi < boneCount; ++bi)
{
SafeDeleteArray(keys[bi]);
}
SafeDeleteArray(keys);
}
MainEngine::~MainEngine()
{
SafeDeleteArray(m_pColorImageRGB);
SafeDeleteArray(m_pColorImageRGBBuffer);
delete m_pImageSourceEngine;
delete m_pTrackingEngine;
}
MySQLQueryResult::~MySQLQueryResult()
{
mysql_free_result(mResult);
SafeDeleteArray(mCurrentRow);
//#ifdef ENABLE_FIELD_NAMES
SafeDeleteArray(mFieldExtendedInfo);
//#endif//ENABLE_FIELD_NAMES
}
void PolygonGroup::Load(KeyedArchive * keyedArchive, SceneFileV2 * sceneFile)
{
DataNode::Load(keyedArchive, sceneFile);
vertexFormat = keyedArchive->GetInt32("vertexFormat");
vertexStride = GetVertexSize(vertexFormat);
vertexCount = keyedArchive->GetInt32("vertexCount");
indexCount = keyedArchive->GetInt32("indexCount");
textureCoordCount = keyedArchive->GetInt32("textureCoordCount");
primitiveType = (ePrimitiveType)keyedArchive->GetInt32("primitiveType");
cubeTextureCoordCount = keyedArchive->GetInt32("cubeTextureCoordCount");
int32 formatPacking = keyedArchive->GetInt32("packing");
if (formatPacking == PACKING_NONE)
{
int size = keyedArchive->GetByteArraySize("vertices");
if (size != vertexCount * vertexStride)
{
Logger::Error("PolygonGroup::Load - Something is going wrong, size of vertex array is incorrect");
return;
}
SafeDeleteArray(meshData);
meshData = new uint8[vertexCount * vertexStride];
const uint8 * archiveData = keyedArchive->GetByteArray("vertices");
memcpy(meshData, archiveData, size);
}
indexFormat = keyedArchive->GetInt32("indexFormat");
if (indexFormat == EIF_16)
{
int size = keyedArchive->GetByteArraySize("indices");
if (size != indexCount * INDEX_FORMAT_SIZE[indexFormat])
{
Logger::Error("PolygonGroup::Load - Something is going wrong, size of index array is incorrect");
return;
}
SafeDeleteArray(indexArray);
indexArray = new int16[indexCount];
const uint8 * archiveData = keyedArchive->GetByteArray("indices");
memcpy(indexArray, archiveData, indexCount * INDEX_FORMAT_SIZE[indexFormat]);
}
SafeDeleteArray(textureCoordArray);
textureCoordArray = new Vector2*[textureCoordCount];
SafeDeleteArray(cubeTextureCoordArray);
if(cubeTextureCoordCount)
{
cubeTextureCoordArray = new Vector3*[cubeTextureCoordCount];
}
SafeRelease(renderDataObject);
renderDataObject = new RenderDataObject();
UpdateDataPointersAndStreams();
RecalcAABBox();
BuildBuffers();
}
//______________________________________________________________________________
ROMETree::~ROMETree()
{
#if 0 /* this class does not own it */
SafeDeleteArray(fTree);
SafeDeleteArray(fFile);
#endif
SafeDeleteArray(fBranchActive);
SafeDeleteArray(fBranchRead);
}
/////////////////////////////////////////////////////////////////////////////
//
// Free()
//
void CwaTexture::Free(void)
{
m_Width = 0;
m_Height = 0;
m_Pitch = 0;
SafeDeleteArray(m_pTexels);
SafeDeleteArray(m_pPalette);
}
int PangaeaTracking::OnExit()
{
for(int i = 0; i < arg_num; ++i)
SafeDeleteArray(argv_char[i]);
SafeDeleteArray(argv_char);
return 0;
}
// Destructor.
HeapAllocator::~HeapAllocator()
{
SafeDeleteArray( m_pIndex );
SafeDeleteArray( m_pPool );
m_NextIndex = 0;
m_NumRestBlocks = 0;
m_Depth = 0;
m_Size = 0;
}
ParametricShape::~ParametricShape()
{
SafeDeleteArray( m_TabVertices );
SafeDeleteArray( m_TabColors );
for( unsigned int i = 0; i < m_TabIndices.size(); ++i )
{
SafeDeleteArray( m_TabIndices[i] );
}
}
void CVolume3D::_free(void)
{
SafeDeleteArray(m_pDensityVolume);
SafeDeleteArray(m_pGradientVolume);
m_nx=m_ny=m_nz=0;
//===========================
uninstallDensityVolumeOnGPU();
uninstallGradientVolumeOnGPU();
}
void PolygonGroup::ReleaseData()
{
SafeRelease(renderDataObject);
SafeDeleteArray(jointCountArray);
SafeDeleteArray(meshData);
SafeDeleteArray(indexArray);
SafeDeleteArray(textureCoordArray);
SafeDeleteArray(cubeTextureCoordArray);
}
void Mesh::Destroy()
{
SafeDeleteArray(mVertices);
SafeDeleteArray(mIndices);
SafeDeleteArray(mTextures);
mNumVertices = 0;
mNumIndices = 0;
mNumTextures = 0;
}
void CC3d1inIOControl::_readConnectivity(FILE *fp)
{
int i, id, matid, t0;
int x0, y0, z0, w0, x1, y1, z1, w1;
const char group3[]="GROUP 3";
Vector4i *p4;
Vector8i *p8;
//malloc buffer for element id
SafeDeleteArray(m_pElement);
SafeDeleteArray(m_pElementObjectID);
m_pElement = new Vector8i[m_nElement];
assert(m_pElement!=NULL);
m_pElementObjectID = new int [m_nElement];
assert(m_pElementObjectID!=NULL);
for (i=0; i<_CIA3D_MAX_OBJECT_COUNT; i++)
m_nObjectElementCount[i] = 0;
//read the elements;
SEEK_GROUPn(fp, group3);
for (i=0; i<m_nElement; i++){
fscanf(fp, "%d %d %d", &id, &t0, &matid);
#ifdef _DEBUG
if (id==2502){
int asga=1;
}
#endif
m_pElementObjectID[i]= (--matid); //set element matid
m_nObjectElementCount[matid]++; //count the element for this material
const int nodecount = m_nObjectType[matid];
switch(nodecount){
case 4:
fscanf(fp, "%d %d %d %d", &x0, &y0, &z0, &w0);
x0--, y0--, z0--, w0--;
p4 = (Vector4i*)(&m_pElement[i]);
*p4 = Vector4i(x0, y0, z0, w0);
break;
case 8:
fscanf(fp, "%d %d %d %d %d %d %d %d", &x0, &y0, &z0, &w0, &x1, &y1, &z1, &w1);
x0--, y0--; z0--, w0--;
x1--, y1--; z1--, w1--;
p8 = &m_pElement[i];
*p8 = Vector8i(x0,y0,z0,w0,x1,y1,z1,w1);
break;
default:
printf("Element type (%d nodes) is not supported!\n", nodecount);
assert(0);
}
}
}
AAIConfig::~AAIConfig(void)
{
for(int i = 0; i < SIDES; i++)
{
SafeDeleteArray(START_UNITS[i]);
SafeDeleteArray(SIDE_NAMES[i]);
}
SafeDeleteArray(START_UNITS);
SafeDeleteArray(SIDE_NAMES);
}
Shader::~Shader()
{
SafeDeleteArray(attributeNames);
//SafeDeleteArray(uniforms);
SafeDeleteArray(uniformOffsets);
SafeDeleteArray(uniformData);
SafeRelease(vertexShaderData);
SafeRelease(fragmentShaderData);
DeleteShaders();
}
CDlgTemplate::~CDlgTemplate()
{
SafeDeleteArray(m_dlgTmpl.pData);
for (DataIter iter = m_vecItemTmpl.begin();
iter != m_vecItemTmpl.end();
++iter)
{
SafeDeleteArray(iter->pData);
}
m_vecItemTmpl.clear();
SafeDeleteArray(m_pBuf);
}
bool LibDxtHelper::DecompressImageToRGBA(const Image & image, Vector<Image*> &imageSet, bool forseSoftwareConvertation)
{
if(!(image.format >= FORMAT_DXT1 && image.format <= FORMAT_DXT5NM) )
{
Logger::Error("[LibDxtHelper::DecompressImageToRGBA] Wrong copression format (%d).", image.format);
return false;
}
nvtt::Format innerComprFormat = NvttHelper::GetNVTTFormatByPixelFormat(image.format);
if(nvtt::Format_BC5 == innerComprFormat)
{ //bc5 is unsupported, used to determinate fail in search
Logger::Error("[LibDxtHelper::DecompressImageToRGBA] Can't work with nvtt::Format_BC5.");
return false;
}
InputOptions inputOptions;
inputOptions.setTextureLayout(TextureType_2D, image.width, image.height);
inputOptions.setMipmapGeneration(false);
CompressionOptions compressionOptions;
compressionOptions.setFormat(innerComprFormat);
if(FORMAT_DXT1NM == image.format)
{
compressionOptions.setColorWeights(1, 1, 0);
}
else if (FORMAT_DXT5NM == image.format)
{
inputOptions.setNormalMap(true);
}
uint32 headerSize = DX10HEADER_SIZE;
uint8* imageHeaderBuffer = new uint8[headerSize];
uint32 realHeaderSize = nvtt::Decompressor::getHeader(imageHeaderBuffer, headerSize, inputOptions, compressionOptions);
nvtt::Decompressor dec;
uint8* compressedImageBuffer = new uint8[realHeaderSize + image.dataSize];
memcpy(compressedImageBuffer, imageHeaderBuffer, realHeaderSize);
memcpy(compressedImageBuffer + realHeaderSize, image.data, image.dataSize);
SafeDeleteArray(imageHeaderBuffer);
bool retValue = NvttHelper::InitDecompressor(dec, compressedImageBuffer, realHeaderSize + image.dataSize);
if(retValue)
{
retValue = NvttHelper::ReadDxtFile(dec, imageSet, forseSoftwareConvertation);
}
SafeDeleteArray(compressedImageBuffer);
return retValue;
}
SimpleString& SimpleString::operator+=( const SimpleString& String )
{
uint NewLength = m_Length + String.m_Length;
char* NewString = Allocate( NewLength + 1 );
memcpy( NewString, m_String, m_Length );
memcpy( NewString + m_Length, String.m_String, String.m_Length );
NewString[ NewLength ] = '\0';
SafeDeleteArray( m_String );
Initialize( NewString );
SafeDeleteArray( NewString );
return *this;
}
//=============================================================================
// destructor
//=============================================================================
MeshCylinder::~MeshCylinder(void)
{
//relase vertex buffer
SafeRelease(direct3dvertexbuffer9_);
SafeRelease(direct3dindexbuffer9_);
SafeDeleteArray(indexs_);
}
void StringManager::Init(const char* filePath)
{
SafeDelete(instance);
instance = new StringManager();
char* buffer = NULL;
int length = 0;
ReadFileToMemory(filePath, "rt", &buffer, &length);
if (length <= 0)
{
return;
}
tinyxml2::XMLDocument doc;
doc.Parse(buffer);
SafeDeleteArray(buffer);
if (doc.ErrorID() != 0)
{
return;
}
tinyxml2::XMLElement* root = doc.FirstChildElement("data-set");
tinyxml2::XMLElement* recordXML = root->FirstChildElement("record");
while (recordXML)
{
StringRecord* record = new StringRecord();
const char* ID = recordXML->FirstChildElement("ID")->GetText();
const char* EN = recordXML->FirstChildElement("EN")->GetText();
const char* VN = recordXML->FirstChildElement("VN")->GetText();
SafeCopyCHAR(&record->ID, ID);
SafeCopyCHAR(&record->EN, EN);
SafeCopyCHAR(&record->VN, VN);
instance->stringMap[ID] = record;
recordXML = recordXML->NextSiblingElement("record");
}
}
DBQueryResult::~DBQueryResult()
{
SafeDeleteArray( mFields );
if( NULL != mResult )
mysql_free_result( mResult );
}
MapilVoid Archiver::Save( const MapilChar* pFileName )
{
Open( pFileName, FILE_OPEN_WRITE_MODE );
std::basic_ofstream < MapilChar > fOut( m_ArchiveName.c_str(), std::ios::binary | std::ios::out );
MapilInt32 offset = 0;
for( MapilInt32 i = 0; i < m_FileTotal; ++i ){
std::basic_ifstream < MapilChar > fIn( m_FileName[ i ], std::ios::binary | std::ios::in );
m_FileSize.push_back( GetDataSize( &fIn ) );
m_FilePos.push_back( offset );
offset += m_FileSize[ i ];
MapilChar* pData = new MapilChar [ m_FileSize[ i ] ];
fIn.read( pData, m_FileSize[ i ] );
// Copy data.
fOut.write( pData, m_FileSize[ i ] );
SafeDeleteArray( pData );
fIn.close();
}
// Setup the file information.
SaveInt( &fOut, m_FileTotal );
for( MapilInt32 i = 0; i < m_FileTotal; ++i ){
SaveInt( &fOut, m_FilePos[ i ] );
SaveInt( &fOut, strlen( m_FileName[ i ] ) );
fOut.write( m_FileName[ i ], strlen( m_FileName[ i ] ) );
SaveInt( &fOut, m_FileSize[ i ] );
}
SaveInt( &fOut, offset );
fOut.close();
}
