nuclear@0: /*
nuclear@0: ---------------------------------------------------------------------------
nuclear@0: Open Asset Import Library (assimp)
nuclear@0: ---------------------------------------------------------------------------
nuclear@0: 
nuclear@0: Copyright (c) 2006-2012, assimp team
nuclear@0: 
nuclear@0: All rights reserved.
nuclear@0: 
nuclear@0: Redistribution and use of this software in source and binary forms, 
nuclear@0: with or without modification, are permitted provided that the following 
nuclear@0: conditions are met:
nuclear@0: 
nuclear@0: * Redistributions of source code must retain the above
nuclear@0:   copyright notice, this list of conditions and the
nuclear@0:   following disclaimer.
nuclear@0: 
nuclear@0: * Redistributions in binary form must reproduce the above
nuclear@0:   copyright notice, this list of conditions and the
nuclear@0:   following disclaimer in the documentation and/or other
nuclear@0:   materials provided with the distribution.
nuclear@0: 
nuclear@0: * Neither the name of the assimp team, nor the names of its
nuclear@0:   contributors may be used to endorse or promote products
nuclear@0:   derived from this software without specific prior
nuclear@0:   written permission of the assimp team.
nuclear@0: 
nuclear@0: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
nuclear@0: "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
nuclear@0: LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
nuclear@0: A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
nuclear@0: OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
nuclear@0: SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
nuclear@0: LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
nuclear@0: DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
nuclear@0: THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
nuclear@0: (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
nuclear@0: OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
nuclear@0: ---------------------------------------------------------------------------
nuclear@0: */
nuclear@0: 
nuclear@0: /** @file Implementation of the MDL importer class */
nuclear@0: 
nuclear@0: #include "AssimpPCH.h"
nuclear@0: #ifndef ASSIMP_BUILD_NO_HMP_IMPORTER
nuclear@0: 
nuclear@0: // internal headers
nuclear@0: #include "HMPLoader.h"
nuclear@0: #include "MD2FileData.h"
nuclear@0: 
nuclear@0: using namespace Assimp;
nuclear@0: 
nuclear@0: static const aiImporterDesc desc = {
nuclear@0: 	"3D GameStudio Heightmap (HMP) Importer",
nuclear@0: 	"",
nuclear@0: 	"",
nuclear@0: 	"",
nuclear@0: 	aiImporterFlags_SupportBinaryFlavour,
nuclear@0: 	0,
nuclear@0: 	0,
nuclear@0: 	0,
nuclear@0: 	0,
nuclear@0: 	"hmp" 
nuclear@0: };
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------
nuclear@0: // Constructor to be privately used by Importer
nuclear@0: HMPImporter::HMPImporter()
nuclear@0: {
nuclear@0: 	// nothing to do here
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------
nuclear@0: // Destructor, private as well 
nuclear@0: HMPImporter::~HMPImporter()
nuclear@0: {
nuclear@0: 	// nothing to do here
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------
nuclear@0: // Returns whether the class can handle the format of the given file. 
nuclear@0: bool HMPImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const
nuclear@0: {
nuclear@0: 	const std::string extension = GetExtension(pFile);
nuclear@0: 	if (extension == "hmp" )
nuclear@0: 		return true;
nuclear@0: 
nuclear@0: 	// if check for extension is not enough, check for the magic tokens 
nuclear@0: 	if (!extension.length() || cs) {
nuclear@0: 		uint32_t tokens[3]; 
nuclear@0: 		tokens[0] = AI_HMP_MAGIC_NUMBER_LE_4;
nuclear@0: 		tokens[1] = AI_HMP_MAGIC_NUMBER_LE_5;
nuclear@0: 		tokens[2] = AI_HMP_MAGIC_NUMBER_LE_7;
nuclear@0: 		return CheckMagicToken(pIOHandler,pFile,tokens,3,0);
nuclear@0: 	}
nuclear@0: 	return false;
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------
nuclear@0: // Get list of all file extensions that are handled by this loader
nuclear@0: const aiImporterDesc* HMPImporter::GetInfo () const
nuclear@0: {
nuclear@0: 	return &desc;
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------
nuclear@0: // Imports the given file into the given scene structure. 
nuclear@0: void HMPImporter::InternReadFile( const std::string& pFile, 
nuclear@0: 								 aiScene* _pScene, IOSystem* _pIOHandler)
nuclear@0: {
nuclear@0: 	pScene     = _pScene;
nuclear@0: 	pIOHandler = _pIOHandler;
nuclear@0: 	boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
nuclear@0: 
nuclear@0: 	// Check whether we can read from the file
nuclear@0: 	if( file.get() == NULL)
nuclear@0: 		throw DeadlyImportError( "Failed to open HMP file " + pFile + ".");
nuclear@0: 
nuclear@0: 	// Check whether the HMP file is large enough to contain
nuclear@0: 	// at least the file header
nuclear@0: 	const size_t fileSize = file->FileSize();
nuclear@0: 	if( fileSize < 50)
nuclear@0: 		throw DeadlyImportError( "HMP File is too small.");
nuclear@0: 
nuclear@0: 	// Allocate storage and copy the contents of the file to a memory buffer
nuclear@0: 	std::vector<uint8_t> buffer(fileSize);
nuclear@0: 	mBuffer = &buffer[0];
nuclear@0: 	file->Read( (void*)mBuffer, 1, fileSize);
nuclear@0: 	iFileSize = (unsigned int)fileSize;
nuclear@0: 
nuclear@0: 	// Determine the file subtype and call the appropriate member function
nuclear@0: 	const uint32_t iMagic = *((uint32_t*)this->mBuffer);
nuclear@0: 
nuclear@0: 	// HMP4 format
nuclear@0: 	if (AI_HMP_MAGIC_NUMBER_LE_4 == iMagic ||
nuclear@0: 		AI_HMP_MAGIC_NUMBER_BE_4 == iMagic)
nuclear@0: 	{
nuclear@0: 		DefaultLogger::get()->debug("HMP subtype: 3D GameStudio A4, magic word is HMP4");
nuclear@0: 		InternReadFile_HMP4();
nuclear@0: 	}
nuclear@0: 	// HMP5 format
nuclear@0: 	else if (AI_HMP_MAGIC_NUMBER_LE_5 == iMagic ||
nuclear@0: 			 AI_HMP_MAGIC_NUMBER_BE_5 == iMagic)
nuclear@0: 	{
nuclear@0: 		DefaultLogger::get()->debug("HMP subtype: 3D GameStudio A5, magic word is HMP5");
nuclear@0: 		InternReadFile_HMP5();
nuclear@0: 	}
nuclear@0: 	// HMP7 format
nuclear@0: 	else if (AI_HMP_MAGIC_NUMBER_LE_7 == iMagic ||
nuclear@0: 			 AI_HMP_MAGIC_NUMBER_BE_7 == iMagic)
nuclear@0: 	{
nuclear@0: 		DefaultLogger::get()->debug("HMP subtype: 3D GameStudio A7, magic word is HMP7");
nuclear@0: 		InternReadFile_HMP7();
nuclear@0: 	}
nuclear@0: 	else
nuclear@0: 	{
nuclear@0: 		// Print the magic word to the logger
nuclear@0: 		char szBuffer[5];
nuclear@0: 		szBuffer[0] = ((char*)&iMagic)[0];
nuclear@0: 		szBuffer[1] = ((char*)&iMagic)[1];
nuclear@0: 		szBuffer[2] = ((char*)&iMagic)[2];
nuclear@0: 		szBuffer[3] = ((char*)&iMagic)[3];
nuclear@0: 		szBuffer[4] = '\0';
nuclear@0: 
nuclear@0: 		// We're definitely unable to load this file
nuclear@0: 		throw DeadlyImportError( "Unknown HMP subformat " + pFile +
nuclear@0: 			". Magic word (" + szBuffer + ") is not known");
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// Set the AI_SCENE_FLAGS_TERRAIN bit
nuclear@0: 	pScene->mFlags |= AI_SCENE_FLAGS_TERRAIN;
nuclear@0: 
nuclear@0: 	// File buffer destructs automatically now
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------ 
nuclear@0: void HMPImporter::ValidateHeader_HMP457( )
nuclear@0: {
nuclear@0: 	const HMP::Header_HMP5* const pcHeader = (const HMP::Header_HMP5*)mBuffer;
nuclear@0: 
nuclear@0: 	if (120 > iFileSize)
nuclear@0: 	{
nuclear@0: 		throw DeadlyImportError("HMP file is too small (header size is "
nuclear@0: 			"120 bytes, this file is smaller)");
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	if (!pcHeader->ftrisize_x || !pcHeader->ftrisize_y)
nuclear@0: 		throw DeadlyImportError("Size of triangles in either  x or y direction is zero");
nuclear@0: 	
nuclear@0: 	if(pcHeader->fnumverts_x < 1.0f || (pcHeader->numverts/pcHeader->fnumverts_x) < 1.0f)
nuclear@0: 		throw DeadlyImportError("Number of triangles in either x or y direction is zero");
nuclear@0: 	
nuclear@0: 	if(!pcHeader->numframes)
nuclear@0: 		throw DeadlyImportError("There are no frames. At least one should be there");
nuclear@0: 
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------ 
nuclear@0: void HMPImporter::InternReadFile_HMP4( )
nuclear@0: {
nuclear@0: 	throw DeadlyImportError("HMP4 is currently not supported");
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------ 
nuclear@0: void HMPImporter::InternReadFile_HMP5( )
nuclear@0: {
nuclear@0: 	// read the file header and skip everything to byte 84
nuclear@0: 	const HMP::Header_HMP5* pcHeader = (const HMP::Header_HMP5*)mBuffer;
nuclear@0: 	const unsigned char* szCurrent = (const unsigned char*)(mBuffer+84);
nuclear@0: 	ValidateHeader_HMP457();
nuclear@0: 
nuclear@0: 	// generate an output mesh
nuclear@0: 	pScene->mNumMeshes = 1;
nuclear@0: 	pScene->mMeshes = new aiMesh*[1];
nuclear@0: 	aiMesh* pcMesh = pScene->mMeshes[0] = new aiMesh();
nuclear@0: 
nuclear@0: 	pcMesh->mMaterialIndex = 0;
nuclear@0: 	pcMesh->mVertices = new aiVector3D[pcHeader->numverts];
nuclear@0: 	pcMesh->mNormals = new aiVector3D[pcHeader->numverts];
nuclear@0: 
nuclear@0: 	const unsigned int height = (unsigned int)(pcHeader->numverts / pcHeader->fnumverts_x);
nuclear@0: 	const unsigned int width =  (unsigned int)pcHeader->fnumverts_x;
nuclear@0: 
nuclear@0: 	// generate/load a material for the terrain
nuclear@0: 	CreateMaterial(szCurrent,&szCurrent);
nuclear@0: 
nuclear@0: 	// goto offset 120, I don't know why ...
nuclear@0: 	// (fixme) is this the frame header? I assume yes since it starts with 2. 
nuclear@0: 	szCurrent += 36;
nuclear@0: 	SizeCheck(szCurrent + sizeof(const HMP::Vertex_HMP7)*height*width);
nuclear@0: 
nuclear@0: 	// now load all vertices from the file
nuclear@0: 	aiVector3D* pcVertOut = pcMesh->mVertices;
nuclear@0: 	aiVector3D* pcNorOut = pcMesh->mNormals;
nuclear@0: 	const HMP::Vertex_HMP5* src = (const HMP::Vertex_HMP5*) szCurrent;
nuclear@0: 	for (unsigned int y = 0; y < height;++y)
nuclear@0: 	{
nuclear@0: 		for (unsigned int x = 0; x < width;++x)
nuclear@0: 		{
nuclear@0: 			pcVertOut->x = x * pcHeader->ftrisize_x;
nuclear@0: 			pcVertOut->y = y * pcHeader->ftrisize_y;
nuclear@0: 			pcVertOut->z = (((float)src->z / 0xffff)-0.5f) * pcHeader->ftrisize_x * 8.0f; 
nuclear@0: 			MD2::LookupNormalIndex(src->normals162index, *pcNorOut );
nuclear@0: 			++pcVertOut;++pcNorOut;++src;
nuclear@0: 		}
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// generate texture coordinates if necessary
nuclear@0: 	if (pcHeader->numskins)
nuclear@0: 		GenerateTextureCoords(width,height);
nuclear@0: 
nuclear@0: 	// now build a list of faces
nuclear@0: 	CreateOutputFaceList(width,height);	
nuclear@0: 
nuclear@0: 	// there is no nodegraph in HMP files. Simply assign the one mesh
nuclear@0: 	// (no, not the one ring) to the root node
nuclear@0: 	pScene->mRootNode = new aiNode();
nuclear@0: 	pScene->mRootNode->mName.Set("terrain_root");
nuclear@0: 	pScene->mRootNode->mNumMeshes = 1;
nuclear@0: 	pScene->mRootNode->mMeshes = new unsigned int[1];
nuclear@0: 	pScene->mRootNode->mMeshes[0] = 0;
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------ 
nuclear@0: void HMPImporter::InternReadFile_HMP7( )
nuclear@0: {
nuclear@0: 	// read the file header and skip everything to byte 84
nuclear@0: 	const HMP::Header_HMP5* const pcHeader = (const HMP::Header_HMP5*)mBuffer;
nuclear@0: 	const unsigned char* szCurrent = (const unsigned char*)(mBuffer+84);
nuclear@0: 	ValidateHeader_HMP457();
nuclear@0: 
nuclear@0: 	// generate an output mesh
nuclear@0: 	pScene->mNumMeshes = 1;
nuclear@0: 	pScene->mMeshes = new aiMesh*[1];
nuclear@0: 	aiMesh* pcMesh = pScene->mMeshes[0] = new aiMesh();
nuclear@0: 
nuclear@0: 	pcMesh->mMaterialIndex = 0;
nuclear@0: 	pcMesh->mVertices = new aiVector3D[pcHeader->numverts];
nuclear@0: 	pcMesh->mNormals = new aiVector3D[pcHeader->numverts];
nuclear@0: 
nuclear@0: 	const unsigned int height = (unsigned int)(pcHeader->numverts / pcHeader->fnumverts_x);
nuclear@0: 	const unsigned int width = (unsigned int)pcHeader->fnumverts_x;
nuclear@0: 
nuclear@0: 	// generate/load a material for the terrain
nuclear@0: 	CreateMaterial(szCurrent,&szCurrent);
nuclear@0: 
nuclear@0: 	// goto offset 120, I don't know why ...
nuclear@0: 	// (fixme) is this the frame header? I assume yes since it starts with 2. 
nuclear@0: 	szCurrent += 36;
nuclear@0: 
nuclear@0: 	SizeCheck(szCurrent + sizeof(const HMP::Vertex_HMP7)*height*width);
nuclear@0: 
nuclear@0: 	// now load all vertices from the file
nuclear@0: 	aiVector3D* pcVertOut = pcMesh->mVertices;
nuclear@0: 	aiVector3D* pcNorOut = pcMesh->mNormals;
nuclear@0: 	const HMP::Vertex_HMP7* src = (const HMP::Vertex_HMP7*) szCurrent;
nuclear@0: 	for (unsigned int y = 0; y < height;++y)
nuclear@0: 	{
nuclear@0: 		for (unsigned int x = 0; x < width;++x)
nuclear@0: 		{
nuclear@0: 			pcVertOut->x = x * pcHeader->ftrisize_x;
nuclear@0: 			pcVertOut->y = y * pcHeader->ftrisize_y;
nuclear@0: 
nuclear@0: 			// FIXME: What exctly is the correct scaling factor to use?
nuclear@0: 			// possibly pcHeader->scale_origin[2] in combination with a
nuclear@0: 			// signed interpretation of src->z?
nuclear@0: 			pcVertOut->z = (((float)src->z / 0xffff)-0.5f) * pcHeader->ftrisize_x * 8.0f; 
nuclear@0: 
nuclear@0: 			pcNorOut->x = ((float)src->normal_x / 0x80 ); // * pcHeader->scale_origin[0];
nuclear@0: 			pcNorOut->y = ((float)src->normal_y / 0x80 ); // * pcHeader->scale_origin[1];
nuclear@0: 			pcNorOut->z = 1.0f;
nuclear@0: 			pcNorOut->Normalize();
nuclear@0: 			
nuclear@0: 			++pcVertOut;++pcNorOut;++src;
nuclear@0: 		}
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// generate texture coordinates if necessary
nuclear@0: 	if (pcHeader->numskins)GenerateTextureCoords(width,height);
nuclear@0: 
nuclear@0: 	// now build a list of faces
nuclear@0: 	CreateOutputFaceList(width,height);	
nuclear@0: 
nuclear@0: 	// there is no nodegraph in HMP files. Simply assign the one mesh
nuclear@0: 	// (no, not the One Ring) to the root node
nuclear@0: 	pScene->mRootNode = new aiNode();
nuclear@0: 	pScene->mRootNode->mName.Set("terrain_root");
nuclear@0: 	pScene->mRootNode->mNumMeshes = 1;
nuclear@0: 	pScene->mRootNode->mMeshes = new unsigned int[1];
nuclear@0: 	pScene->mRootNode->mMeshes[0] = 0;
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------ 
nuclear@0: void HMPImporter::CreateMaterial(const unsigned char* szCurrent,
nuclear@0: 	const unsigned char** szCurrentOut)
nuclear@0: {
nuclear@0: 	aiMesh* const pcMesh = pScene->mMeshes[0];
nuclear@0: 	const HMP::Header_HMP5* const pcHeader = (const HMP::Header_HMP5*)mBuffer;
nuclear@0: 
nuclear@0: 	// we don't need to generate texture coordinates if
nuclear@0: 	// we have no textures in the file ...
nuclear@0: 	if (pcHeader->numskins)
nuclear@0: 	{
nuclear@0: 		pcMesh->mTextureCoords[0] = new aiVector3D[pcHeader->numverts];
nuclear@0: 		pcMesh->mNumUVComponents[0] = 2;
nuclear@0: 
nuclear@0: 		// now read the first skin and skip all others
nuclear@0: 		ReadFirstSkin(pcHeader->numskins,szCurrent,&szCurrent);
nuclear@0: 	}
nuclear@0: 	else
nuclear@0: 	{
nuclear@0: 		// generate a default material
nuclear@0: 		const int iMode = (int)aiShadingMode_Gouraud;
nuclear@0: 		aiMaterial* pcHelper = new aiMaterial();
nuclear@0: 		pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
nuclear@0: 
nuclear@0: 		aiColor3D clr;
nuclear@0: 		clr.b = clr.g = clr.r = 0.6f;
nuclear@0: 		pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
nuclear@0: 		pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
nuclear@0: 
nuclear@0: 		clr.b = clr.g = clr.r = 0.05f;
nuclear@0: 		pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
nuclear@0: 
nuclear@0: 		aiString szName;
nuclear@0: 		szName.Set(AI_DEFAULT_MATERIAL_NAME);
nuclear@0: 		pcHelper->AddProperty(&szName,AI_MATKEY_NAME);
nuclear@0: 
nuclear@0: 		// add the material to the scene
nuclear@0: 		pScene->mNumMaterials = 1;
nuclear@0: 		pScene->mMaterials = new aiMaterial*[1];
nuclear@0: 		pScene->mMaterials[0] = pcHelper;
nuclear@0: 	}
nuclear@0: 	*szCurrentOut = szCurrent;
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------ 
nuclear@0: void HMPImporter::CreateOutputFaceList(unsigned int width,unsigned int height)
nuclear@0: {
nuclear@0: 	aiMesh* const pcMesh = this->pScene->mMeshes[0];
nuclear@0: 
nuclear@0: 	// Allocate enough storage
nuclear@0: 	pcMesh->mNumFaces = (width-1) * (height-1);
nuclear@0: 	pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
nuclear@0: 
nuclear@0: 	pcMesh->mNumVertices   = pcMesh->mNumFaces*4;
nuclear@0: 	aiVector3D* pcVertices = new aiVector3D[pcMesh->mNumVertices];
nuclear@0: 	aiVector3D* pcNormals  = new aiVector3D[pcMesh->mNumVertices];
nuclear@0: 
nuclear@0: 	aiFace* pcFaceOut(pcMesh->mFaces);
nuclear@0: 	aiVector3D* pcVertOut = pcVertices;
nuclear@0: 	aiVector3D* pcNorOut = pcNormals;
nuclear@0: 
nuclear@0: 	aiVector3D* pcUVs = pcMesh->mTextureCoords[0] ? new aiVector3D[pcMesh->mNumVertices] : NULL;
nuclear@0: 	aiVector3D* pcUVOut(pcUVs);
nuclear@0: 
nuclear@0: 	// Build the terrain square
nuclear@0: 	unsigned int iCurrent = 0;
nuclear@0: 	for (unsigned int y = 0; y < height-1;++y)	{
nuclear@0: 		for (unsigned int x = 0; x < width-1;++x,++pcFaceOut)	{
nuclear@0: 			pcFaceOut->mNumIndices = 4;
nuclear@0: 			pcFaceOut->mIndices = new unsigned int[4];
nuclear@0: 
nuclear@0: 			*pcVertOut++ = pcMesh->mVertices[y*width+x];
nuclear@0: 			*pcVertOut++ = pcMesh->mVertices[(y+1)*width+x];
nuclear@0: 			*pcVertOut++ = pcMesh->mVertices[(y+1)*width+x+1];
nuclear@0: 			*pcVertOut++ = pcMesh->mVertices[y*width+x+1];
nuclear@0: 			
nuclear@0: 
nuclear@0: 			*pcNorOut++ = pcMesh->mNormals[y*width+x];
nuclear@0: 			*pcNorOut++ = pcMesh->mNormals[(y+1)*width+x];
nuclear@0: 			*pcNorOut++ = pcMesh->mNormals[(y+1)*width+x+1];
nuclear@0: 			*pcNorOut++ = pcMesh->mNormals[y*width+x+1];
nuclear@0: 
nuclear@0: 			if (pcMesh->mTextureCoords[0])
nuclear@0: 			{
nuclear@0: 				*pcUVOut++ = pcMesh->mTextureCoords[0][y*width+x];
nuclear@0: 				*pcUVOut++ = pcMesh->mTextureCoords[0][(y+1)*width+x];
nuclear@0: 				*pcUVOut++ = pcMesh->mTextureCoords[0][(y+1)*width+x+1];
nuclear@0: 				*pcUVOut++ = pcMesh->mTextureCoords[0][y*width+x+1];
nuclear@0: 			}
nuclear@0: 			
nuclear@0: 			for (unsigned int i = 0; i < 4;++i)
nuclear@0: 				pcFaceOut->mIndices[i] = iCurrent++;
nuclear@0: 		}
nuclear@0: 	}
nuclear@0: 	delete[] pcMesh->mVertices;
nuclear@0: 	pcMesh->mVertices = pcVertices;
nuclear@0: 
nuclear@0: 	delete[] pcMesh->mNormals;
nuclear@0: 	pcMesh->mNormals = pcNormals;
nuclear@0: 
nuclear@0: 	if (pcMesh->mTextureCoords[0])
nuclear@0: 	{
nuclear@0: 		delete[] pcMesh->mTextureCoords[0];
nuclear@0: 		pcMesh->mTextureCoords[0] = pcUVs;
nuclear@0: 	}
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------ 
nuclear@0: void HMPImporter::ReadFirstSkin(unsigned int iNumSkins, const unsigned char* szCursor,
nuclear@0: 	const unsigned char** szCursorOut)
nuclear@0: {
nuclear@0: 	ai_assert(0 != iNumSkins && NULL != szCursor);
nuclear@0: 
nuclear@0: 	// read the type of the skin ...
nuclear@0: 	// sometimes we need to skip 12 bytes here, I don't know why ...
nuclear@0: 	uint32_t iType = *((uint32_t*)szCursor);szCursor += sizeof(uint32_t);
nuclear@0: 	if (0 == iType)
nuclear@0: 	{
nuclear@0: 		szCursor += sizeof(uint32_t) * 2;
nuclear@0: 		iType = *((uint32_t*)szCursor);szCursor += sizeof(uint32_t);
nuclear@0: 		if (!iType)
nuclear@0: 			throw DeadlyImportError("Unable to read HMP7 skin chunk");
nuclear@0: 		
nuclear@0: 	}
nuclear@0: 	// read width and height
nuclear@0: 	uint32_t iWidth  = *((uint32_t*)szCursor); szCursor += sizeof(uint32_t);
nuclear@0: 	uint32_t iHeight = *((uint32_t*)szCursor); szCursor += sizeof(uint32_t);
nuclear@0: 
nuclear@0: 	// allocate an output material
nuclear@0: 	aiMaterial* pcMat = new aiMaterial();
nuclear@0: 
nuclear@0: 	// read the skin, this works exactly as for MDL7
nuclear@0: 	ParseSkinLump_3DGS_MDL7(szCursor,&szCursor,
nuclear@0: 		pcMat,iType,iWidth,iHeight);
nuclear@0: 
nuclear@0: 	// now we need to skip any other skins ... 
nuclear@0: 	for (unsigned int i = 1; i< iNumSkins;++i)
nuclear@0: 	{
nuclear@0: 		iType   = *((uint32_t*)szCursor);   szCursor += sizeof(uint32_t);
nuclear@0: 		iWidth  = *((uint32_t*)szCursor);   szCursor += sizeof(uint32_t);
nuclear@0: 		iHeight = *((uint32_t*)szCursor);   szCursor += sizeof(uint32_t);
nuclear@0: 
nuclear@0: 		SkipSkinLump_3DGS_MDL7(szCursor,&szCursor,iType,iWidth,iHeight);
nuclear@0: 		SizeCheck(szCursor);
nuclear@0: 	}
nuclear@0: 
nuclear@0: 	// setup the material ...
nuclear@0: 	pScene->mNumMaterials = 1;
nuclear@0: 	pScene->mMaterials = new aiMaterial*[1];
nuclear@0: 	pScene->mMaterials[0] = pcMat;
nuclear@0: 
nuclear@0: 	*szCursorOut = szCursor;
nuclear@0: }
nuclear@0: 
nuclear@0: // ------------------------------------------------------------------------------------------------ 
nuclear@0: // Generate proepr texture coords
nuclear@0: void HMPImporter::GenerateTextureCoords(
nuclear@0: 	const unsigned int width, const unsigned int height)
nuclear@0: {
nuclear@0: 	ai_assert(NULL != pScene->mMeshes && NULL != pScene->mMeshes[0] &&
nuclear@0: 		      NULL != pScene->mMeshes[0]->mTextureCoords[0]);
nuclear@0: 
nuclear@0: 	aiVector3D* uv = pScene->mMeshes[0]->mTextureCoords[0];
nuclear@0: 
nuclear@0: 	const float fY = (1.0f / height) + (1.0f / height) / (height-1);
nuclear@0: 	const float fX = (1.0f / width) + (1.0f / width) / (width-1);
nuclear@0: 
nuclear@0: 	for (unsigned int y = 0; y < height;++y)	{
nuclear@0: 		for (unsigned int x = 0; x < width;++x,++uv)	{
nuclear@0: 			uv->y = fY*y;
nuclear@0: 			uv->x = fX*x;
nuclear@0: 			uv->z = 0.0f;
nuclear@0: 		}
nuclear@0: 	}
nuclear@0: }
nuclear@0: 
nuclear@0: #endif // !! ASSIMP_BUILD_NO_HMP_IMPORTER