assimp.assimp/code/ValidateDataStructure.cpp

/*
---------------------------------------------------------------------------
Open Asset Import Library (ASSIMP)
---------------------------------------------------------------------------

Copyright (c) 2006-2008, ASSIMP Development Team

All rights reserved.

Redistribution and use of this software in source and binary forms, 
with or without modification, are permitted provided that the following 
conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the ASSIMP team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the ASSIMP Development Team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/

/** @file Implementation of the post processing step to validate 
 * the data structure returned by Assimp
 */
#include <vector>
#include <assert.h>

#include "ValidateDataStructure.h"
#include "BaseImporter.h"
#include "StringComparison.h"
#include "fast_atof.h"

#include "../include/DefaultLogger.h"
#include "../include/aiPostProcess.h"
#include "../include/aiMesh.h"
#include "../include/aiScene.h"
#include "../include/aiAssert.h"

#include <stdarg.h>

using namespace Assimp;

// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
ValidateDSProcess::ValidateDSProcess()
{
	// nothing to do here
}

// ------------------------------------------------------------------------------------------------
// Destructor, private as well
ValidateDSProcess::~ValidateDSProcess()
{
	// nothing to do here
}

// ------------------------------------------------------------------------------------------------
// Returns whether the processing step is present in the given flag field.
bool ValidateDSProcess::IsActive( unsigned int pFlags) const
{
	return (pFlags & aiProcess_ValidateDataStructure) != 0;
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::ReportError(const char* msg,...)
{
	ai_assert(NULL != msg);

	va_list args;
	va_start(args,msg);

	char szBuffer[3000];

	int iLen;
#if _MSC_VER >= 1400
	iLen = vsprintf_s(szBuffer,msg,args);
#else
	iLen = vsprintf(szBuffer,msg,args);
#endif

	if (0 >= iLen)
	{
		// :-) should not happen ...
		throw new ImportErrorException("Idiot ... learn coding!");
	}
	va_end(args);
	throw new ImportErrorException("Validation failed: " + std::string(szBuffer,iLen));
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::ReportWarning(const char* msg,...)
{
	ai_assert(NULL != msg);

	va_list args;
	va_start(args,msg);

	char szBuffer[3000];

	int iLen;
#if _MSC_VER >= 1400
	iLen = vsprintf_s(szBuffer,msg,args);
#else
	iLen = vsprintf(szBuffer,msg,args);
#endif

	if (0 >= iLen)
	{
		// :-) should not happen ...
		throw new ImportErrorException("Idiot ... learn coding!");
	}
	va_end(args);
	DefaultLogger::get()->warn("Validation failed: " + std::string(szBuffer,iLen));
}
// ------------------------------------------------------------------------------------------------
// Executes the post processing step on the given imported data.
void ValidateDSProcess::Execute( aiScene* pScene)
{
	this->mScene = pScene;
	DefaultLogger::get()->debug("ValidateDataStructureProcess begin");

	// validate all meshes
	if (pScene->mNumMeshes)
	{
		if (!pScene->mMeshes)
		{
			this->ReportError("aiScene::mMeshes is NULL (aiScene::mNumMeshes is %i)",
				pScene->mNumMeshes);
		}
		for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
		{
			if (!pScene->mMeshes[i])
			{
				this->ReportError("aiScene::mMeshes[%i] is NULL (aiScene::mNumMeshes is %i)",
					i,pScene->mNumMeshes);
			}
			this->Validate(pScene->mMeshes[i]);
		}
	}
	else this->ReportError("aiScene::mNumMeshes is 0. At least one mesh must be there");

	// validate all animations
	if (pScene->mNumAnimations)
	{
		if (!pScene->mAnimations)
		{
			this->ReportError("aiScene::mAnimations is NULL (aiScene::mNumAnimations is %i)",
				pScene->mNumAnimations);
		}
		for (unsigned int i = 0; i < pScene->mNumAnimations;++i)
		{
			if (!pScene->mAnimations[i])
			{
				this->ReportError("aiScene::mAnimations[%i] is NULL (aiScene::mNumAnimations is %i)",
					i,pScene->mNumAnimations);
			}
			this->Validate(pScene->mAnimations[i]);

			// check whether there are duplicate animation names
			for (unsigned int a = i+1; a < pScene->mNumAnimations;++a)
			{
				if (pScene->mAnimations[i]->mName == pScene->mAnimations[a]->mName)
				{
					this->ReportError("aiScene::mAnimations[%i] has the same name as "
						"aiScene::mAnimations[%i]",i,a);
				}
			}
		}
	}

	// validate all textures
	if (pScene->mNumTextures)
	{
		if (!pScene->mTextures)
		{
			this->ReportError("aiScene::mTextures is NULL (aiScene::mNumTextures is %i)",
				pScene->mNumTextures);
		}
		for (unsigned int i = 0; i < pScene->mNumTextures;++i)
		{
			if (!pScene->mTextures[i])
			{
				this->ReportError("aiScene::mTextures[%i] is NULL (aiScene::mNumTextures is %i)",
					i,pScene->mNumTextures);
			}
			this->Validate(pScene->mTextures[i]);
		}
	}

	// validate all materials
	if (pScene->mNumMaterials)
	{
		if (!pScene->mMaterials)
		{
			this->ReportError("aiScene::mMaterials is NULL (aiScene::mNumMaterials is %i)",
				pScene->mNumMaterials);
		}
		for (unsigned int i = 0; i < pScene->mNumMaterials;++i)
		{
			if (!pScene->mMaterials[i])
			{
				this->ReportError("aiScene::mMaterials[%i] is NULL (aiScene::mNumMaterials is %i)",
					i,pScene->mNumMaterials);
			}
			this->Validate(pScene->mMaterials[i]);
		}
	}
	else this->ReportError("aiScene::mNumMaterials is 0. At least one material must be there.");

	// validate the node graph of the scene
	this->Validate(pScene->mRootNode);

	DefaultLogger::get()->debug("ValidateDataStructureProcess end");
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::Validate( const aiMesh* pMesh)
{
	// validate the material index of the mesh
	if (pMesh->mMaterialIndex >= this->mScene->mNumMaterials)
	{
		this->ReportError("aiMesh::mMaterialIndex is invalid (value: %i maximum: %i)",
			pMesh->mMaterialIndex,this->mScene->mNumMaterials-1);
	}

	// positions must always be there ...
	if (!pMesh->mNumVertices || !pMesh->mVertices)
	{
		this->ReportError("The mesh contains no vertices");
	}

	// faces, too
	if (!pMesh->mNumFaces || !pMesh->mFaces)
	{
		this->ReportError("The mesh contains no faces");
	}

	// now check whether the face indexing layout is correct:
	// unique vertices, pseudo-indexed.
	std::vector<bool> abRefList;
	abRefList.resize(pMesh->mNumVertices,false);
	for (unsigned int i = 0; i < pMesh->mNumFaces;++i)
	{
		aiFace& face = pMesh->mFaces[i];
		if (!face.mIndices)this->ReportError("aiMesh::mFaces[%i].mIndices is NULL",i);
		if (face.mNumIndices < 3)this->ReportError(
			"aiMesh::mFaces[%i].mIndices is not a triangle or polygon",i);

		for (unsigned int a = 0; a < face.mNumIndices;++a)
		{
			if (face.mIndices[a] >= pMesh->mNumVertices)
			{
				this->ReportError("aiMesh::mFaces[%i]::mIndices[%a] is out of range",i,a);
			}
			if (abRefList[face.mIndices[a]])
			{
				this->ReportError("aiMesh::mVertices[%i] is referenced twice - second "
					"time by aiMesh::mFaces[%i]::mIndices[%i]",face.mIndices[a],i,a);
			}
			abRefList[face.mIndices[a]] = true;
		}
	}
	abRefList.clear();

	// texture channel 2 may not be set if channel 1 is zero ...
	{
	unsigned int i = 0;
	for (;i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
	{
		if (!pMesh->HasTextureCoords(i))break;
	}
	for (;i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
		if (pMesh->HasTextureCoords(i))
		{
			this->ReportError("Texture coordinate channel %i is existing, "
				"although the previous channel was NULL.",i);
		}
	}
	// the same for the vertex colors
	{
	unsigned int i = 0;
	for (;i < AI_MAX_NUMBER_OF_COLOR_SETS;++i)
	{
		if (!pMesh->HasVertexColors(i))break;
	}
	for (;i < AI_MAX_NUMBER_OF_COLOR_SETS;++i)
		if (pMesh->HasVertexColors(i))
		{
			this->ReportError("Vertex color channel %i is existing, "
				"although the previous channel was NULL.",i);
		}
	}

	// now validate all bones
	if (pMesh->HasBones())
	{
		if (!pMesh->mBones)
		{
			this->ReportError("aiMesh::mBones is NULL (aiMesh::mNumBones is %i)",
				pMesh->mNumBones);
		}

		// check whether there are duplicate bone names
		for (unsigned int i = 0; i < pMesh->mNumBones;++i)
		{
			if (!pMesh->mBones[i])
			{
				this->ReportError("aiMesh::mBones[%i] is NULL (aiMesh::mNumBones is %i)",
					i,pMesh->mNumBones);
			}
			this->Validate(pMesh,pMesh->mBones[i]);

			for (unsigned int a = i+1; a < pMesh->mNumBones;++a)
			{
				if (pMesh->mBones[i]->mName == pMesh->mBones[a]->mName)
				{
					this->ReportError("aiMesh::mBones[%i] has the same name as "
						"aiMesh::mBones[%i]",i,a);
				}
			}
		}
	}
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::Validate( const aiMesh* pMesh,
	const aiBone* pBone)
{
	// check whether all vertices affected by this bone are valid
	for (unsigned int i = 0; i < pBone->mNumWeights;++i)
	{
		if (pBone->mWeights[i].mVertexId > pMesh->mNumVertices)
		{
			this->ReportError("aiBone::mWeights[%i].mVertexId is out of range",i);
		}
		else if (!pBone->mWeights[i].mWeight || pBone->mWeights[i].mWeight > 1.0f)
		{
			this->ReportWarning("aiBone::mWeights[%i].mWeight has an invalid value",i);
		}
	}
	// TODO: check whether all bone weights for a vertex sum to 1.0 ...
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::Validate( const aiAnimation* pAnimation)
{
	// validate all materials
	if (pAnimation->mNumBones)
	{
		if (!pAnimation->mBones)
		{
			this->ReportError("aiAnimation::mBones is NULL (aiAnimation::mNumBones is %i)",
				pAnimation->mBones);
		}
		for (unsigned int i = 0; i < pAnimation->mNumBones;++i)
		{
			if (!pAnimation->mBones[i])
			{
				this->ReportError("aiAnimation::mBones[%i] is NULL (aiAnimation::mNumBones is %i)",
					i,pAnimation->mNumBones);
			}
			this->Validate(pAnimation, pAnimation->mBones[i]);
		}
	}
	else this->ReportError("aiAnimation::mNumBones is 0. At least one bone animation channel must be there.");
	if (!pAnimation->mDuration)this->ReportError("aiAnimation::mDuration is zero");
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
	const char* szType)
{
	ai_assert(NULL != szType);

	// search all keys of the material ...
	// textures must be specified with rising indices (e.g. diffuse #2 may not be
	// specified if diffuse #1 is not there ...)

	// "$tex.file.<szType>[<index>]"
	char szBaseBuf[512];
	int iLen;
#if _MSC_VER >= 1400
	iLen = ::sprintf_s(szBaseBuf,"$tex.file.%s",szType);
#else
	iLen = ::sprintf(szBaseBuf,"$tex.file.%s",szType);
#endif
	if (0 >= iLen)return;

	int iNumIndices = 0;
	int iIndex = -1;
	for (unsigned int i = 0; i < pMaterial->mNumProperties;++i)
	{
		aiMaterialProperty* prop = pMaterial->mProperties[i];
		if (0 == ASSIMP_strincmp( prop->mKey->data, szBaseBuf, iLen ))
		{
			const char* sz = &prop->mKey->data[iLen];
			if (*sz)
			{
				++sz;
				iIndex = std::max(iIndex, (int)strtol10(sz,NULL));
				++iNumIndices;
			}

			if (aiPTI_String != prop->mType)
				this->ReportError("Material property %s is expected to be a string",prop->mKey);
		}
	}
	if (iIndex +1 != iNumIndices)
	{
		this->ReportError("%s #%i is set, but there are only %i %s textures",
			szType,iIndex,iNumIndices,szType);
	}

	// now check whether all UV indices are valid ...
#if _MSC_VER >= 1400
	iLen = ::sprintf_s(szBaseBuf,"$tex.uvw.%s",szType);
#else
	iLen = ::sprintf(szBaseBuf,"$tex.uvw.%s",szType);
#endif
	if (0 >= iLen)return;
	
	for (unsigned int i = 0; i < pMaterial->mNumProperties;++i)
	{
		aiMaterialProperty* prop = pMaterial->mProperties[i];
		if (0 == ASSIMP_strincmp( prop->mKey->data, szBaseBuf, iLen ))
		{
			if (aiPTI_Integer != prop->mType || sizeof(int) > prop->mDataLength)
				this->ReportError("Material property %s is expected to be an integer",prop->mKey);

			const char* sz = &prop->mKey->data[iLen];
			if (*sz)
			{
				++sz;
				iIndex = strtol10(sz,NULL);

				// ignore UV indices for texture channel that are not there ...
				if (iIndex >= iNumIndices)
				{
					// get the value
					iIndex = *((unsigned int*)prop->mData);

					// check whether there is a mesh using this material
					// which has not enough UV channels ...
					for (unsigned int a = 0; a < this->mScene->mNumMeshes;++a)
					{
						aiMesh* mesh = this->mScene->mMeshes[a];
						if(mesh->mMaterialIndex == iIndex)
						{
							int iChannels = 0;
							while (mesh->HasTextureCoords(iChannels++));
							if (iIndex >= iChannels)
							{
								this->ReportError("Invalid UV index: %i (key %s). Mesh %i has only %i UV channels",
									iIndex,prop->mKey,a,iChannels);
							}
						}
					}
				}
			}
		}
	}
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::Validate( const aiMaterial* pMaterial)
{
	// check whether there are material keys that are obviously not legal
	for (unsigned int i = 0; i < pMaterial->mNumProperties;++i)
	{
		aiMaterialProperty* prop = pMaterial->mProperties[i];
		if (!prop)
		{
			this->ReportError("aiMaterial::mProperties[%i] is NULL (aiMaterial::mNumProperties is %i)",
				i,pMaterial->mNumProperties);
		}
		if (!prop->mDataLength || !prop->mData)
		{
			this->ReportError("aiMaterial::mProperties[%i].mDataLength or "
				"aiMaterial::mProperties[%i].mData is 0",i,i);
		}
		// TODO: check whether there is a key with an unknown name ...
	}

	float fTemp;
	int iShading;
	if (AI_SUCCESS == aiGetMaterialInteger( pMaterial,AI_MATKEY_SHADING_MODEL,&iShading))
	{
		switch ((aiShadingMode)iShading)
		{
		case aiShadingMode_Blinn:
		case aiShadingMode_CookTorrance:
		case aiShadingMode_Phong:

			if (AI_SUCCESS != aiGetMaterialFloat(pMaterial,AI_MATKEY_SHININESS,&fTemp))
			{
				this->ReportWarning("A specular shading model is specified but there is no "
					"AI_MATKEY_SHININESS key");
			}
			if (AI_SUCCESS == aiGetMaterialFloat(pMaterial,AI_MATKEY_SHININESS_STRENGTH,&fTemp) && !fTemp)
			{
				this->ReportWarning("A specular shading model is specified but the value of the "
					"AI_MATKEY_SHININESS_STRENGTH key is 0.0");
			}
			break;
		};
	}


	// check whether there are invalid texture keys
	SearchForInvalidTextures(pMaterial,"diffuse");
	SearchForInvalidTextures(pMaterial,"specular");
	SearchForInvalidTextures(pMaterial,"ambient");
	SearchForInvalidTextures(pMaterial,"emissive");
	SearchForInvalidTextures(pMaterial,"opacity");
	SearchForInvalidTextures(pMaterial,"shininess");
	SearchForInvalidTextures(pMaterial,"normals");
	SearchForInvalidTextures(pMaterial,"height");
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::Validate( const aiTexture* pTexture)
{
	// the data section may NEVER be NULL
	if (!pTexture->pcData)
	{
		this->ReportError("aiTexture::pcData is NULL");
	}
	if (pTexture->mHeight)
	{
		if (!pTexture->mWidth)this->ReportError("aiTexture::mWidth is zero "
			"(aiTexture::mHeight is %i, uncompressed texture)",pTexture->mHeight);
	}
	else 
	{
		if (!pTexture->mWidth)this->ReportError("aiTexture::mWidth is zero (compressed texture)");
		if ('.' == pTexture->achFormatHint[0])
		{
			char szTemp[5];
			szTemp[0] = pTexture->achFormatHint[0];
			szTemp[1] = pTexture->achFormatHint[1];
			szTemp[2] = pTexture->achFormatHint[2];
			szTemp[3] = pTexture->achFormatHint[3];
			szTemp[4] = '\0';

			this->ReportWarning("aiTexture::achFormatHint should contain a file extension "
				"without a leading dot (format hint: %s).",szTemp);
		}
	}
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::Validate( const aiAnimation* pAnimation,
	 const aiBoneAnim* pBoneAnim)
{
	// check whether there is a bone with this name ...
	unsigned int i = 0;
	for (; i < this->mScene->mNumMeshes;++i)
	{
		aiMesh* mesh = this->mScene->mMeshes[i];
		for (unsigned int a = 0; a < mesh->mNumBones;++a)
		{
			if (mesh->mBones[a]->mName == pBoneAnim->mBoneName)
				break;
		}
	}
	if (i == this->mScene->mNumMeshes)
	{
		this->ReportWarning("aiBoneAnim::mBoneName is %s. However, no bone with this name was found",
			pBoneAnim->mBoneName.data);
	}
	if (!pBoneAnim->mNumPositionKeys && !pBoneAnim->mNumRotationKeys && !pBoneAnim->mNumScalingKeys)
	{
		this->ReportWarning("A bone animation channel has no keys");
	}

	// otherwise check whether one of the keys exceeds the total duration of the animation
	if (pBoneAnim->mNumPositionKeys)
	{
		if (!pBoneAnim->mPositionKeys)
		{
			this->ReportError("aiBoneAnim::mPositionKeys is NULL (aiBoneAnim::mNumPositionKeys is %i)",
				pBoneAnim->mNumPositionKeys);
		}
		for (unsigned int i = 0; i < pBoneAnim->mNumPositionKeys;++i)
		{
			if (pBoneAnim->mPositionKeys[i].mTime > pAnimation->mDuration)
			{
				this->ReportError("aiBoneAnim::mPositionKeys[%i].mTime (%.5f) is larger "
					"than aiAnimation::mDuration (which is %.5f)",i,
					(float)pBoneAnim->mPositionKeys[i].mTime,
					(float)pAnimation->mDuration);
			}
		}
	}
	// rotation keys
	if (pBoneAnim->mNumRotationKeys)
	{
		if (!pBoneAnim->mRotationKeys)
		{
			this->ReportError("aiBoneAnim::mRotationKeys is NULL (aiBoneAnim::mNumRotationKeys is %i)",
				pBoneAnim->mNumRotationKeys);
		}
		for (unsigned int i = 0; i < pBoneAnim->mNumRotationKeys;++i)
		{
			if (pBoneAnim->mRotationKeys[i].mTime > pAnimation->mDuration)
			{
				this->ReportError("aiBoneAnim::mRotationKeys[%i].mTime (%.5f) is larger "
					"than aiAnimation::mDuration (which is %.5f)",i,
					(float)pBoneAnim->mRotationKeys[i].mTime,
					(float)pAnimation->mDuration);
			}
		}
	}
	// scaling keys
	if (pBoneAnim->mNumScalingKeys)
	{
		if (!pBoneAnim->mScalingKeys)
		{
			this->ReportError("aiBoneAnim::mScalingKeys is NULL (aiBoneAnim::mNumScalingKeys is %i)",
				pBoneAnim->mNumScalingKeys);
		}
		for (unsigned int i = 0; i < pBoneAnim->mNumScalingKeys;++i)
		{
			if (pBoneAnim->mScalingKeys[i].mTime > pAnimation->mDuration)
			{
				this->ReportError("aiBoneAnim::mScalingKeys[%i].mTime (%.5f) is larger "
					"than aiAnimation::mDuration (which is %.5f)",i,
					(float)pBoneAnim->mScalingKeys[i].mTime,
					(float)pAnimation->mDuration);
			}
		}
	}
}
// ------------------------------------------------------------------------------------------------
void ValidateDSProcess::Validate( const aiNode* pNode)
{
	if (!pNode)this->ReportError("A node of the scenegraph is NULL");
	if (pNode != this->mScene->mRootNode && !pNode->mParent)
		this->ReportError("A node has no valid parent (aiNode::mParent is NULL)");

	// validate all meshes
	if (pNode->mNumMeshes)
	{
		if (!pNode->mMeshes)
		{
			this->ReportError("aiNode::mMeshes is NULL (aiNode::mNumMeshes is %i)",
				pNode->mNumMeshes);
		}
		std::vector<bool> abHadMesh;
		abHadMesh.resize(this->mScene->mNumMeshes,false);
		for (unsigned int i = 0; i < pNode->mNumMeshes;++i)
		{
			if (pNode->mMeshes[i] >= this->mScene->mNumMeshes)
			{
				this->ReportError("aiNode::mMeshes[%i] is out of range (maximum is %i)",
					pNode->mMeshes[i],this->mScene->mNumMeshes-1);
			}
			if (abHadMesh[pNode->mMeshes[i]])
			{
				this->ReportError("aiNode::mMeshes[%i] is already referenced by this node (value: %i)",
					i,pNode->mMeshes[i]);
			}
			abHadMesh[pNode->mMeshes[i]] = true;
		}
	}
	if (pNode->mNumChildren)
	{
		if (!pNode->mChildren)
		{
			this->ReportError("aiNode::mChildren is NULL (aiNode::mNumChildren is %i)",
				pNode->mNumChildren);
		}
		for (unsigned int i = 0; i < pNode->mNumChildren;++i)
		{
			this->Validate(pNode->mChildren[i]);
		}
	}
}