btBoolean btWorld::CreateFromFile(const char *filename){	FILE *fp = NULL;		btErrorLog::GetPtr()->Printf("Loading level:  %s", filename);	// Check if the .bsp file could be opened	if((fp = fopen(filename, "rb")) == NULL)	{ 		//m_pApp->Log("BSP File could not be opened: %s", strFileName);		btErrorLog::GetPtr()->Printf("Could not open map %s!!", filename);		return BT_FALSE;	}	// Initialize the header and lump structures	BSP_HEADER header;	// Read in the header	// This is a really cool chunk of info that	// Tells us where to find all the good stuff	// in the file. Kind of like a "Table of Contents"	fread(&header, 1, sizeof(BSP_HEADER), fp);	m_EntityString = new char[header.entries[lEntities].length / sizeof(char)];	//allocate the space needed for our data structures 	m_NumVerts = header.entries[lVertcies].length / sizeof(BSP_VERTEX);	m_pVerts = new BSP_VERTEX[m_NumVerts];	m_NumFaces = header.entries[lFaces].length / sizeof(BSP_FACE);	//m_Faces = new BSP_FACE[m_NumFaces];	m_Faces.resize(m_NumFaces);	m_NumIndices = header.entries[lIndices].length / sizeof(BSP_INDEX);	m_pIndices = new BSP_INDEX[m_NumIndices];	m_NumTextures = header.entries[lTextures].length / sizeof(BSP_TEXTURE);	m_Textures = new BSP_TEXTURE [m_NumTextures];	m_Materials.resize(m_NumTextures);	for (size_t k = 0; k < m_NumTextures; k++)		m_Materials[k] = NULL;	// Now this part is kinda messy. In reality, I should be setting this	// up so that we never have to seek backwards in the file, BUUUUUTTT...	// since this isn't a commercial project, and we're not too concerned	// about load times we're just gonna let it slide for now.		// Seek to the position of the entities	fseek(fp, header.entries[lEntities].offset, SEEK_SET);	// Read in the entity string	fread(m_EntityString, header.entries[lEntities].length, sizeof(char), fp);	// Log them to file//	btErrorLog::GetPtr()->Printf("%s\n", m_EntityString);	// Seek to the position in the file that stores the vertex information	fseek(fp, header.entries[lVertcies].offset, SEEK_SET);		// Read in the vertex information 	fread(m_pVerts, m_NumVerts, sizeof(BSP_VERTEX), fp);	// Seek to the position in the file that stores the index information	fseek(fp, header.entries[lIndices].offset, SEEK_SET);		// Read in the index information 	fread(m_pIndices, m_NumIndices, sizeof(BSP_INDEX), fp);	// Seek to the position in the file that stores the face information	fseek(fp, header.entries[lFaces].offset, SEEK_SET);	// Read in all the face information	for (u32 i = 0; i < m_NumFaces; i++)		fread(&m_Faces, 1, sizeof(BSP_FACE), fp);	// Seek to the position in the file that stores the texture information	fseek(fp, header.entries[lTextures].offset, SEEK_SET);	// Read in all the texture information	fread(m_Textures, m_NumTextures, sizeof(BSP_TEXTURE), fp);	// Close the file	fclose(fp);	IbtEngine *engine = btEngine_GetSingleton();	// First, we're going to go through all of the textures	// All we're given is file path (not even an extension!)	// So we're going to first locate the file, and then load	// it into a DirectX texture.	for(u32 i = 0; i < m_NumTextures; i++)	{		char								normalmapname[64];		ZeroMemory(normalmapname, 64);		strcpy(normalmapname, m_Textures.name);		strcat(normalmapname, "_n");		// Find the texture path/extension		FindTextureExtension(m_Textures.name);		FindTextureExtension(normalmapname);		// Load the texture based off of what we found.		//if(FAILED(D3DXCreateTextureFromFile( m_pDevice, m_pTextures.name,        //                           &m_pTextureMaps )))		m_Materials = engine->CreateMaterial();		if (!m_Materials->SetTextureLayer(0, IbtMaterial::LAYER_BASE, m_Textures.name))		{			//m_pApp->Log("Texture not Found: %s", m_pTextures.name);			// If the texture can't be loaded, simply make it NULL.			//m_pTextureMaps = NULL;			btErrorLog::GetPtr()->Printf("Could not create material %s!!", m_Textures.name);			BT_SAFE_RELEASE(m_Materials);			if (m_Materials != NULL)				btErrorLog::GetPtr()->Printf("Material #%d is not NULL!!", i);		}		else			btErrorLog::GetPtr()->Printf("Loaded texture:  %s", m_Textures.name);		FILE	*test = NULL;		if ((test = fopen(normalmapname, "rb")) != NULL)		{			btErrorLog::GetPtr()->Printf("Adding bump map to %s", m_Textures.name);			fclose(test);			if (!m_Materials->SetTextureLayer(1, IbtMaterial::LAYER_BUMPMAP, normalmapname))				continue;		}	}	HRESULT									hres;	// Occlusion Culling stuff	hres = m_pDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, &m_pOccluder);	if (FAILED(hres))	{		btErrorLog::GetPtr()->Printf("Could not create occluder!!");		return BT_FALSE;	}	D3DDISPLAYMODE					mode;	hres = m_pDevice->GetDisplayMode(0, &mode);	if (FAILED(hres))	{		btErrorLog::GetPtr()->Printf("Could not get display mode!!");		return BT_FALSE;	}	hres = D3DXCreateTexture(m_pDevice, 320, 240, 1, D3DUSAGE_RENDERTARGET, D3DFMT_UNKNOWN, D3DPOOL_DEFAULT, &m_pOccluderTexture);	if (FAILED(hres))	{		btErrorLog::GetPtr()->Printf("Could not create occluder texture!!");		return BT_FALSE;	}	D3DSURFACE_DESC					desc;	m_pOccluderTexture->GetSurfaceLevel(0, &m_pOccluderSurface);	m_pOccluderSurface->GetDesc(&desc);	hres = D3DXCreateRenderToSurface(m_pDevice, desc.Width, desc.Height, desc.Format, TRUE, D3DFMT_D16, &m_pOccluderRender);	if (FAILED(hres))	{		btErrorLog::GetPtr()->Printf("Could not create occluder!!");		return BT_FALSE;	}	// Create Vertex Buffer. I shouldn't need to explain this.	// The only thing to notice is that we're creating exactly	// enough space for all of our Vertices, yet we're using a	// different struct than what we read the verts into.	// (We read them into a BSP_VERTEX, and are creating space	// for a BSP_CUSTOM_VERTEX)	m_pDevice->CreateVertexBuffer( m_NumVerts * sizeof(BSP_CUSTOM_VERTEX), 0,								   BSP_CUSTOM_VERTEX_FVF, D3DPOOL_DEFAULT, &m_pVB, NULL );	BSP_CUSTOM_VERTEX *pVertices = NULL;	// Again, no explanation needed, right? Typical DirectX stuff.	m_pVB->Lock(0, m_NumVerts * sizeof(BSP_CUSTOM_VERTEX), (VOID**) &pVertices, 0);		// Now, at this point it would be simply LOVELY if we could 	// simply do this:	//	// memcpy(pVertices, m_pVerts, numVerts * sizeof(BSP_VERTEX));	//	// However, no such luck here, since there's a slight 	// Quirk in how DirectX processes it's vertices. You see,	// The information inside the vertex had to be in a 	// particular order for DirectX to draw it correctly. In	// this case that order is: 	//	// Position->Normal->Color->Texture1->Texture2	//	// DirectX is happy with this, and all is right in the world.	// However, the BSP file says differently! It's data comes to	// you in THIS order:	//	// Position->Texture1->Texture2->Normal->Color	//	// Feed this to DirectX and it will puke random red triangles 	// all over your screen. (Trust me, I've tried!)	// SO, what this means is that instead of a nice and easy memcopy	// we get to loop through each vert like so:	for(i = 0; i < m_NumVerts; i++)	{		pVertices.x = m_pVerts.position[0];		pVertices.y = m_pVerts.position[2];		pVertices.z = m_pVerts.position[1];		pVertices.nx = m_pVerts.normal[0];		pVertices.ny = m_pVerts.normal[2];		pVertices.nz = m_pVerts.normal[1];						pVertices.color = D3DCOLOR_RGBA(m_pVerts.color[0],m_pVerts.color[1],										   m_pVerts.color[2],m_pVerts.color[3]);		pVertices.tu = m_pVerts.texcoord[0];		pVertices.tv = m_pVerts.texcoord[1];		pVertices.lu = m_pVerts.lightmap[0];		pVertices.lv = m_pVerts.lightmap[1];	}	m_pVB->Unlock();		// Create Index Buffer	// NOTICE: This has been altered from past tutorials since we had several	// complaints that it wasn't working on older cards. Now it will check	// the caps for the Index Buffer Type and create the proper buffer accordingly.	D3DCAPS9 DevCaps;	((btEngine*)engine)->GetCaps(&DevCaps);	if(DevCaps.MaxVertexIndex > 0x0000FFFF)	{		m_pDevice->CreateIndexBuffer( m_NumIndices * sizeof(BSP_INDEX), 0,									D3DFMT_INDEX32, D3DPOOL_DEFAULT, &m_pIB, NULL );				BSP_INDEX *pIndices = NULL;					m_pIB->Lock(0, m_NumIndices * sizeof(BSP_INDEX), (VOID**) &pIndices, 0);				// Ah, now HERE we have the luxury of a memcpy, because, well		// a number is a number. And there was much rejoicing!		memcpy(pIndices, m_pIndices, m_NumIndices * sizeof(BSP_INDEX));		m_pIB->Unlock();	}	else	{		//m_pApp->Log("Hardware does not support 32 Bit Indcies. Forcing to 16 Bit");				m_pDevice->CreateIndexBuffer( m_NumIndices * sizeof(BSP_INDEX), 0,									D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_pIB, NULL );				SHORT *pIndices = NULL;					m_pIB->Lock(0, m_NumIndices * sizeof(SHORT), (VOID**) &pIndices, 0);				for(i = 0; i < m_NumIndices; i++)		{			pIndices = (SHORT) m_pIndices;		}		m_pIB->Unlock();	}	// Sort faces by texture	std::sort(m_Faces.begin(), m_Faces.end(), FaceSortFunctor());	// Create vertex declaration	hres = m_pDevice->CreateVertexDeclaration(g_VDecl, &m_pVDecl);	if (FAILED(hres))	{		btErrorLog::GetPtr()->Printf("Could not create vertex declaration!!");		return BT_FALSE;	}		btErrorLog::GetPtr()->Printf("Num Faces:  %d", m_NumFaces);	btErrorLog::GetPtr()->Printf("Num Vertices:  %d", m_NumVerts);	btErrorLog::GetPtr()->Printf("Level %s loaded successfully...", filename);	//And we're done building the level! Was that too hard?	return BT_TRUE;}