Context Navigation

Mesh.cpp @ 2498

Revision 2498, 23.5 KB checked in by szirmay, 17 years ago (diff)

Rev	Line
[2197]	1	#include "dxstdafx.h"
	2	#include ".\mesh.h"
	3	#include "SubMesh.h"
	4	#include "PathMapEffect.h"
	5	#include "TriangleMesh.h"
	6	#include "MeshExploder.h"
	7	#include "L.h"
	8	#include "FlexVertex.h"
	9	#include "xmlParser.h"
	10	#include <vector>
	11	#include <fstream>
	12
	13	Mesh::Mesh(PathMapEffect* pathMapEffect,
	14	DWORD fileFormat,
	15	LPCWSTR xFileName,
	16	LPCWSTR ogreFileName,
	17	int prmAtlasSize,
	18	const char* name,
	19	unsigned int nDesiredPartitions,
	20	bool generateUV,
[2304]	21	bool generateTBN,
	22	unsigned int originalAtlasTexCoordIndex)
[2197]	23	{
	24	this->pathMapEffect = pathMapEffect;
	25	LPDIRECT3DDEVICE9 device = pathMapEffect->device;
	26
	27	this->prmAtlasSize = prmAtlasSize;
	28	strcpy(this->name, name);
	29
	30	if(ogreFileName)
	31	wcscpy(this->ogreFileName, ogreFileName);
	32	else
	33	this->ogreFileName[0] = 0;
	34
	35	LPD3DXBUFFER materialBuffer, shaderBuffer;
	36	DWORD nSubsets;
	37
	38	HRESULT hr = S_FALSE;
	39
	40	wchar_t** materialNames;
	41
	42
	43	if(fileFormat == OgreXMLMesh)
	44	{
	45	hr = loadMeshFromOgreXML( xFileName,
	46	0,
	47	device,
	48	&materialBuffer, //material
	49	&shaderBuffer, //shadrr
	50	&nSubsets,
	51	pathMapEffect->xMaterials,
	52	materialNames,
	53	&mesh);
	54	}
	55	else
	56	{
	57	hr = D3DXLoadMeshFromX( xFileName,
	58	D3DXMESH_MANAGED,
	59	device,
	60	NULL, //adjacency
	61	&materialBuffer, //material
	62	&shaderBuffer, //shader
	63	&nSubsets,
	64	&mesh);
[2498]	65	materialNames = new wchar_t*[nSubsets+1];
	66	materialNames[nSubsets] = NULL;
	67	for(int mi=0; mi<nSubsets; mi++)
	68	materialNames[mi] = L::cloneW(L"noname");
[2197]	69	}
	70	if(hr != S_OK)
	71	{
	72	MessageBox(NULL, xFileName, L"Could not load mesh file!", MB_OK);
	73	return;
	74	}
	75
[2469]	76	//add a texcoord set for prm
[2197]	77	DWORD fvf = mesh->GetFVF();
	78	fvf \|= D3DFVF_NORMAL;
	79	DWORD nTexCoords = fvf & D3DFVF_TEXCOUNT_MASK;
[2469]	80	if(generateUV \|\| (originalAtlasTexCoordIndex == 0 && nTexCoords == D3DFVF_TEX1))
	81	{
	82	nTexCoords += D3DFVF_TEX1;
	83	fvf &= ~D3DFVF_TEXCOUNT_MASK;
	84	fvf \|= nTexCoords;
	85	fvf \|= D3DFVF_TEXCOORDSIZE2(nTexCoords / D3DFVF_TEX1);
[2304]	86	setVertexFormat(fvf);
[2469]	87	}
[2197]	88
	89	if(generateTBN)
	90	computeTangentFrame();
	91	mesh->OptimizeInplace(D3DXMESHOPT_ATTRSORT, NULL, NULL, NULL, NULL);
	92
	93	D3DXMATERIAL* materialArray = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();
	94	D3DXEFFECTINSTANCE* shaderArray = (D3DXEFFECTINSTANCE*)shaderBuffer->GetBufferPointer();
	95
	96	if(nDesiredPartitions != 1 \|\| generateUV)
	97	{
	98	//check is this already exists, load if it does
	99	char sname[256];
	100	sprintf(sname, "%s/%s.x", LC::c-pathMapEffect->meshDirectory, name);
	101
	102	LPD3DXMESH processedMesh;
	103	LPD3DXBUFFER processedMaterialBuffer;
	104	LPD3DXBUFFER processedShaderBuffer;
	105	HRESULT processedMeshExists S_FALSE;
	106	if(!pathMapEffect->SEGMENTMESHES)
	107	{
	108	processedMeshExists = D3DXLoadMeshFromX(
	109	L::l+sname,
	110	D3DXMESH_MANAGED,
	111	device,
	112	NULL, //adjacency
	113	&processedMaterialBuffer, //material
	114	&processedShaderBuffer, //shader
	115	&nSubsets,
	116	&processedMesh);
	117	}
	118
	119	if(processedMeshExists == S_OK)
	120	{
	121	mesh->Release();
	122	materialBuffer->Release();
	123	shaderBuffer->Release();
	124	mesh = processedMesh;
	125	materialBuffer = processedMaterialBuffer;
	126	shaderBuffer = processedShaderBuffer;
	127	materialArray = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();
	128	shaderArray = (D3DXEFFECTINSTANCE*)shaderBuffer->GetBufferPointer();
	129	}
	130	else
	131	{
	132	MeshExploder mex(device, mesh, materialArray, materialNames, shaderArray, nDesiredPartitions);
	133	mex.explode();
	134
[2469]	135	// mex.saveFragMeshes();
[2197]	136
[2304]	137	mex.generateAtlas(prmAtlasSize);
[2197]	138	mex.merge();
	139	mex.saveComposedMesh(name);
	140	mex.saveComposedMeshToOgreXML(name);
	141
	142	mesh->Release();
	143	materialArray = mex.composedMaterials;
	144	shaderArray = mex.composedShaders;
	145	mesh = mex.composedMesh;
[2304]	146
	147	originalAtlasTexCoordIndex = (mesh->GetFVF() & D3DFVF_TEXCOUNT_MASK) / D3DFVF_TEX1 - 1;
[2197]	148	}
	149	}
[2304]	150	trimMesh(originalAtlasTexCoordIndex);
[2197]	151
	152	for(int dili=0; materialNames[dili]; dili++)
	153	delete [] materialNames[dili];
	154	delete [] materialNames;
	155
	156	nSubsets = nDesiredPartitions;
	157
	158	//create #subset submeshes
	159	for(int iSubset=0; iSubset<nSubsets; iSubset++)
	160	{
	161	SubMesh* subMesh = new SubMesh(this, iSubset, materialArray[iSubset]);
	162	subMeshes.push_back(subMesh);
	163	//set submesh textures from material and shader properties
	164	D3DXEFFECTDEFAULT* paramArray = shaderArray[iSubset].pDefaults;
	165	int nParams = shaderArray[iSubset].NumDefaults;
	166	for(int iParams=0; iParams < nParams; iParams++)
	167	{
	168	float bumpScale = 1.0;
	169	char bumpFileName[256]; bumpFileName[0] = '\0';
	170	if(strcmp(paramArray[iParams].pParamName, "bumpFileName") == 0)
	171	{
	172	strcpy(bumpFileName, paramArray[iParams].pParamName);
	173	}
	174	if(strcmp(paramArray[iParams].pParamName, "bumpScale") == 0)
	175	{
	176	bumpScale = (float)paramArray[iParams].pValue;
	177	}
	178	subMesh->loadBumpMap(bumpFileName, bumpScale);
	179	}
	180	}
	181
	182
	183	mesh->OptimizeInplace(D3DXMESHOPT_ATTRSORT, NULL, NULL, NULL, NULL);
	184	DWORD nAttributes;
	185	mesh->GetAttributeTable(NULL, &nAttributes);
	186	D3DXATTRIBUTERANGE* subsetRanges = new D3DXATTRIBUTERANGE[nAttributes];
	187	mesh->GetAttributeTable(subsetRanges, &nAttributes);
	188
	189	std::vector<SubMesh*>::iterator iSubMesh = subMeshes.begin();
	190	int i =0;
	191	while(iSubMesh != subMeshes.end())
	192	{
	193	(iSubMesh)->buildRayTraceMesh(subsetRanges[i].FaceStart3, subsetRanges[i].FaceCount*3);
	194	iSubMesh++;
	195	i++;
	196	}
	197	delete subsetRanges;
	198
	199	materialBuffer->Release();
	200	shaderBuffer->Release();
	201
	202	buildEdgeVertexBuffer();
	203	}
	204
	205	Mesh::~Mesh(void)
	206	{
	207	std::vector<SubMesh*>::iterator i = subMeshes.begin();
	208	while(i != subMeshes.end())
	209	{
	210	delete *i;
	211	i++;
	212	}
	213	mesh->Release();
	214	if(edgeVertexBuffer)
	215	edgeVertexBuffer->Release();
	216	}
	217
	218
	219	HRESULT Mesh::setVertexFormat(DWORD fvf)
	220	{
	221	LPDIRECT3DDEVICE9 device = pathMapEffect->device;
	222	LPD3DXMESH tempMesh;
	223
	224	//clone the mesh to the appropriate format
	225	HRESULT hr = mesh->CloneMeshFVF( mesh->GetOptions(),
	226	fvf ,
	227	device, &tempMesh );
	228	if(hr == S_OK)
	229	{
	230	//forget he old mesh
	231	mesh->Release();
	232	//use the cloned mesh
	233	mesh = tempMesh;
	234	}
	235	return hr;
	236	}
	237
	238	HRESULT Mesh::partitionMesh(unsigned int nDesiredPartitions, LPD3DXBUFFER& partitioningBuffer, unsigned int& nPartitions)
	239	{
	240	LPD3DXMESH tempMesh;
	241
	242	LPD3DXBUFFER partitionResultAdjacency;
	243	float maxStretchApplied;
	244
	245	HRESULT hr;
	246	/* hr = D3DXUVAtlasPartition(
	247	mesh, //LPD3DXMESH pMesh,
	248	nDesiredPartitions, //UINT dwMaxChartNumber,
	249	1.0f, //FLOAT fMaxStretch,
	250	1, //DWORD dwTextureIndex,
	251	NULL, //CONST DWORD * pdwAdjacency,
	252	NULL, //CONST CHAR * pcFalseEdges,
	253	NULL, //FLOAT * pfIMTArray,
	254	NULL, //LPD3DXUVATLASCB pCallback,
	255	0.1f, //FLOAT fCallbackFrequency,
	256	NULL, //LPVOID pUserContent,
	257	&tempMesh, //LPD3DXMESH * ppMeshOut,
	258	&partitioningBuffer, //LPD3DXBUFFER ppFacePartitioning,
	259	NULL, //LPD3DXBUFFER * ppVertexRemapArray,
	260	&partitionResultAdjacency, //LPD3DXBUFFER * ppPartitionResultAdjacency,
	261	&maxStretchApplied, //FLOAT * pfMaxStretchOut,
	262	&nPartitions //UINT * pdwNumChartsOut
	263	);*/
	264
	265	if(hr == S_OK)
	266	{
	267	//forget he old mesh
	268	mesh->Release();
	269	mesh = tempMesh;
	270	}
	271	else
	272	return hr;
	273	partitionResultAdjacency->Release();
	274
	275	return S_OK;
	276	}
	277
	278	HRESULT Mesh::computeTangentFrame()
	279	{
	280	LPD3DXMESH tempMesh;
	281	HRESULT hr =
	282	D3DXComputeTangentFrameEx(
	283	mesh, // ID3DXMesh * pMesh,
	284	D3DDECLUSAGE_TEXCOORD, // DWORD dwTextureInSemantic,
	285	0, // DWORD dwTextureInIndex,
	286	D3DDECLUSAGE_TEXCOORD, // DWORD dwUPartialOutSemantic,
	287	2, // DWORD dwUPartialOutIndex,
	288	D3DDECLUSAGE_TEXCOORD, // DWORD dwVPartialOutSemantic,
	289	3, // DWORD dwVPartialOutIndex,
	290	D3DDECLUSAGE_NORMAL, // DWORD dwNormalOutSemantic,
	291	0, // DWORD dwNormalOutIndex,
	292	(D3DXTANGENT_WRAP_UV
	293	// \| D3DXTANGENT_DONT_ORTHOGONALIZE \| D3DXTANGENT_DONT_NORMALIZE_PARTIALS)
	294	)& !( D3DXTANGENT_CALCULATE_NORMALS ), // DWORD dwOptions,
	295	NULL, // CONST DWORD * pdwAdjacency,
	296	0.2, // FLOAT fPartialEdgeThreshold,
	297	0.0, // FLOAT fSingularPointThreshold,
	298	0.2, // FLOAT fNormalEdgeThreshold,
	299	&tempMesh, // ID3DXMesh ** ppMeshOut,
	300	NULL // ID3DXBuffer ** ppVertexMapping
	301	);
	302
	303	if(hr == S_OK)
	304	{
	305	//forget he old mesh
	306	mesh->Release();
	307	mesh = tempMesh;
	308	}
	309	else
	310	return hr;
	311
	312	LPDIRECT3DVERTEXBUFFER9 vertexBuffer;
	313	mesh->GetVertexBuffer(&vertexBuffer);
	314	FlexVertexArray vertexData(mesh->GetNumBytesPerVertex());
[2304]	315	D3DVERTEXELEMENT9 elem[64]; mesh->GetDeclaration(elem); vertexData.setFormat(elem);
[2197]	316	vertexBuffer->Lock(0,mesh->GetNumVertices()*mesh->GetNumBytesPerVertex(),vertexData.getDataPointerReference(),0);
	317
	318	for(unsigned int u=0; u < mesh->GetNumVertices(); u++ )
	319	vertexData[u].tex1() = (vertexData[u].tex1() * (prmAtlasSize - 4) + D3DXVECTOR2(2.0,2.0)) / (float)prmAtlasSize;
	320
	321	vertexBuffer->Unlock();
	322	vertexBuffer->Release();
	323
	324	return hr;
	325	}
	326
	327	void Mesh::buildEdgeVertexBuffer()
	328	{
	329	LPDIRECT3DDEVICE9 device = pathMapEffect->device;
	330
	331	LPD3DXMESH pMesh = this->mesh;
	332	DWORD* pAdj = new DWORD[3 * pMesh->GetNumFaces()];
	333	for(int r=0; r<pMesh->GetNumFaces()*3; r++)
	334	pAdj[r] = 0xffff;
	335	pMesh->ConvertPointRepsToAdjacency(NULL, pAdj);
	336
	337	LPDIRECT3DVERTEXBUFFER9 vertexBuffer;
	338	pMesh->GetVertexBuffer(&vertexBuffer);
	339	FlexVertexArray vertexData(mesh->GetNumBytesPerVertex());
[2304]	340	D3DVERTEXELEMENT9 elem[64]; mesh->GetDeclaration(elem); vertexData.setFormat(elem);
[2197]	341	vertexBuffer->Lock(0,pMesh->GetNumVertices()*pMesh->GetNumBytesPerVertex(),vertexData.getDataPointerReference(),0);
	342	LPDIRECT3DINDEXBUFFER9 indexBuffer;
	343	pMesh->GetIndexBuffer(&indexBuffer);
	344	unsigned short* indexData;
	345	indexBuffer->Lock(0,pMesh->GetNumFaces()3sizeof(unsigned short),(void**)&indexData,0);
	346
	347	DWORD* attributeArray;
	348	mesh->LockAttributeBuffer(0, &attributeArray);
	349
	350	int countEdges = 0;
	351	for(int u=0; u<pMesh->GetNumFaces(); u++)
	352	for(int t=0; t<3; t++)
	353	if(pAdj[u * 3 + t] >= pMesh->GetNumFaces())
	354	countEdges++;
	355
	356	if(countEdges == 0)
	357	{
	358	edgeVertexBuffer = NULL;
	359	nEdges = 0;
	360	vertexBuffer->Unlock();
	361	indexBuffer->Unlock();
	362	SAFE_RELEASE(vertexBuffer);
	363	SAFE_RELEASE(indexBuffer);
	364	return;
	365	}
	366
	367	device->CreateVertexBuffer(2 * countEdges * pMesh->GetNumBytesPerVertex(),
	368	D3DUSAGE_WRITEONLY, pMesh->GetFVF(), D3DPOOL_DEFAULT,
	369	&edgeVertexBuffer, NULL);
	370	FlexVertexArray pevData(mesh->GetNumBytesPerVertex());
	371	edgeVertexBuffer->Lock(0, 0, pevData.getDataPointerReference(), 0);
	372
	373	int DBLATLASSIZE = prmAtlasSize * 2;
	374	int ATLASSIZE = prmAtlasSize;
	375
[2469]	376	bool firstSub = true;
	377	std::vector<SubMesh*>::iterator iSubMesh = subMeshes.begin();
[2197]	378	DWORD prevAttribute = 0xffffffff;
	379
	380	int iEdge = 0;
	381	for(int u=0; u<pMesh->GetNumFaces(); u++)
	382	{
	383	if(attributeArray[u] != prevAttribute)
	384	{
	385	prevAttribute = attributeArray[u];
[2469]	386	if(firstSub)
	387	firstSub = false;
	388	else
	389	iSubMesh++;
[2197]	390	(*iSubMesh)->edgeStartIndex = iEdge;
	391	(*iSubMesh)->edgeCount = 0;
	392	}
	393	for(int t=0; t<3; t++)
	394	{
	395	if(pAdj[u * 3 + t] >= pMesh->GetNumFaces())
	396	{
	397	unsigned short edge0 = indexData[u * 3 + t];
	398	unsigned short edge1 = indexData[u * 3 + (t+1)%3];
	399	unsigned short inner = indexData[u * 3 + (t+2)%3];
	400
	401	//push vertex edge0, edge1
	402	//pevData[iEdge * 2] = vertexData[edge0];
	403	//pevData[iEdge * 2 + 1] = vertexData[edge1];
	404	pevData.assign(iEdge * 2, vertexData[edge0]);
	405	pevData.assign(iEdge * 2 + 1, vertexData[edge1]);
	406
	407	D3DXVECTOR2 ediff = vertexData[edge1].tex1() - vertexData[edge0].tex1();
	408	if(fabsf(ediff.x) > fabsf(ediff.y))
	409	{
	410	if(vertexData[inner].tex1().y <= vertexData[edge0].tex1().y +
	411	(vertexData[inner].tex1().x - vertexData[edge0].tex1().x) *
	412	(vertexData[edge1].tex1().y - vertexData[edge0].tex1().y) /
	413	(vertexData[edge1].tex1().x - vertexData[edge0].tex1().x))
	414	{
	415	pevData[iEdge * 2].tex1().y += 1.0/DBLATLASSIZE;
	416	pevData[iEdge * 2 + 1].tex1().y += 1.0/DBLATLASSIZE;
	417	}
	418	else
	419	{
	420	pevData[iEdge * 2].tex1().y -= 1.0/DBLATLASSIZE;
	421	pevData[iEdge * 2 + 1].tex1().y -= 1.0/DBLATLASSIZE;
	422	}
	423	D3DXVECTOR2 edgeDirUnitExt(1.0f, (vertexData[edge1].tex1().y - vertexData[edge0].tex1().y) /
	424	(vertexData[edge1].tex1().x - vertexData[edge0].tex1().x));
	425	edgeDirUnitExt *= 1.0/ATLASSIZE;
	426	if(vertexData[edge1].tex1().x > vertexData[edge0].tex1().x)
	427	{
	428	pevData[iEdge * 2].tex1() -= edgeDirUnitExt;
	429	pevData[iEdge * 2 + 1].tex1() += edgeDirUnitExt;
	430	}
	431	else
	432	{
	433	pevData[iEdge * 2].tex1() += edgeDirUnitExt;
	434	pevData[iEdge * 2 + 1].tex1() -= edgeDirUnitExt;
	435	}
	436	}
	437	else
	438	{
	439	if(vertexData[inner].tex1().x <= vertexData[edge0].tex1().x +
	440	(vertexData[inner].tex1().y - vertexData[edge0].tex1().y) *
	441	(vertexData[edge1].tex1().x - vertexData[edge0].tex1().x) /
	442	(vertexData[edge1].tex1().y - vertexData[edge0].tex1().y))
	443	{
	444	pevData[iEdge * 2].tex1().x += 1.0/DBLATLASSIZE;
	445	pevData[iEdge * 2 + 1].tex1().x += 1.0/DBLATLASSIZE;
	446	}
	447	else
	448	{
	449	pevData[iEdge * 2].tex1().x -= 1.0/DBLATLASSIZE;
	450	pevData[iEdge * 2 + 1].tex1().x -= 1.0/DBLATLASSIZE;
	451	}
	452	D3DXVECTOR2 edgeDirUnitExt((vertexData[edge1].tex1().x - vertexData[edge0].tex1().x) /
	453	(vertexData[edge1].tex1().y - vertexData[edge0].tex1().y), 1.0f);
	454	edgeDirUnitExt *= 1.0/ATLASSIZE;
	455	if(vertexData[edge1].tex1().y > vertexData[edge0].tex1().y)
	456	{
	457	pevData[iEdge * 2].tex1() -= edgeDirUnitExt;
	458	pevData[iEdge * 2 + 1].tex1() += edgeDirUnitExt;
	459	}
	460	else
	461	{
	462	pevData[iEdge * 2].tex1() += edgeDirUnitExt;
	463	pevData[iEdge * 2 + 1].tex1() -= edgeDirUnitExt;
	464	}
	465	}
	466
	467	iEdge++;
	468	(*iSubMesh)->edgeCount++;
	469	}
	470	}
	471	}
	472	nEdges = iEdge;
	473
	474	edgeVertexBuffer->Unlock();
	475	vertexBuffer->Unlock();
	476	indexBuffer->Unlock();
	477	SAFE_RELEASE(vertexBuffer);
	478	SAFE_RELEASE(indexBuffer);
	479	mesh->UnlockAttributeBuffer();
	480
	481	delete pAdj;
	482	}
	483
	484	void Mesh::saveMesh()
	485	{
	486	D3DXMATERIAL * materials = new D3DXMATERIAL[subMeshes.size()];
	487	D3DXEFFECTINSTANCE * shaders = new D3DXEFFECTINSTANCE[subMeshes.size()];
	488
	489	std::vector<SubMesh*>::iterator iSubMesh = subMeshes.begin();
	490	int i =0;
	491	while(iSubMesh != subMeshes.end())
	492	{
	493	materials[i] = (*iSubMesh)->material;
	494	addShaderString(shaders[i], "bumpFileName", (*iSubMesh)->bumpFileName);
	495	iSubMesh++;
	496	i++;
	497	}
	498
	499	char sname[256];
	500	printf(sname, "%s_partitioned.x", name);
	501	D3DXSaveMeshToX(L::l+sname, //LPCTSTR pFilename,
	502	mesh, //LPD3DXMESH pMesh,
	503	NULL, //CONST DWORD * pAdjacency,
	504	materials, //CONST D3DXMATERIAL * pMaterials,
	505	shaders, //CONST D3DXEFFECTINSTANCE * pEffectInstances,
	506	subMeshes.size(), //DWORD NumMaterials,
	507	D3DXF_FILEFORMAT_TEXT //DWORD Format
	508	);
	509
	510	delete materials;
	511	delete shaders;
	512	}
	513
	514	void Mesh::addShaderString(D3DXEFFECTINSTANCE& e, LPCSTR name, LPCSTR value)
	515	{
	516	for(int i=0; i<e.NumDefaults; i++)
	517	{
	518	if(strcmp(e.pDefaults[i].pParamName, name) == 0)
	519	{
	520	delete e.pDefaults[i].pValue;
	521	e.pDefaults[i].Type = D3DXEDT_STRING;
	522	e.pDefaults[i].NumBytes = strlen(name) + 1;
	523	e.pDefaults[i].pValue = new char[e.pDefaults[i].NumBytes];
	524	strcpy((LPSTR)e.pDefaults[i].pValue, value);
	525	return;
	526	}
	527	}
	528	D3DXEFFECTDEFAULT* oldDefaults = e.pDefaults;
	529	D3DXEFFECTDEFAULT* newDefaults = new D3DXEFFECTDEFAULT[e.NumDefaults+1];
	530
	531	for(int u=0; u<e.NumDefaults; u++)
	532	{
	533	newDefaults[u] = oldDefaults[u];
	534	}
	535	delete oldDefaults;
[2469]	536	e.pDefaults = newDefaults;
[2197]	537
	538	newDefaults[e.NumDefaults].Type = D3DXEDT_STRING;
	539	newDefaults[e.NumDefaults].NumBytes = strlen(name) + 1;
[2469]	540	newDefaults[e.NumDefaults].pValue = new char[e.pDefaults[e.NumDefaults].NumBytes];
[2197]	541	strcpy((LPSTR)newDefaults[e.NumDefaults].pValue, value);
	542	newDefaults[e.NumDefaults].pParamName = new char[strlen(name)+1];
	543	strcpy((LPSTR)newDefaults[e.NumDefaults].pParamName, name);
	544	e.NumDefaults++;
	545	}
	546
	547	const char* Mesh::getName()
	548	{
	549	return name;
	550	}
	551
	552	HRESULT Mesh::loadMeshFromOgreXML(
	553	LPCWSTR filename,
	554	DWORD options,
	555	LPDIRECT3DDEVICE9 device,
	556	LPD3DXBUFFER *materialBuffer,
	557	LPD3DXBUFFER *shaderBuffer,
	558	DWORD *nMaterials,
	559	XMLNode& xMaterials,
	560	wchar_t**& materialNames,
	561	LPD3DXMESH *ppMesh)
	562	{
	563
	564	XMLNode xMainNode=XMLNode::openFileHelper(filename, L"mesh");
	565
	566	DWORD nVertices = _wtoi( xMainNode/L"sharedGeometry"\|L"vertexCount" );
	567
	568	XMLNode xSubmeshesNode = xMainNode/L"submeshes";
	569
	570	DWORD nSubMeshes = xSubmeshesNode.nChildNode(L"submesh");
	571
	572	DWORD nFaces = 0;
	573	for(int u=0; u < nSubMeshes; u++)
	574	{
	575	nFaces += _wtoi(xSubmeshesNode.getChildNode(L"submesh", u)/L"faces"\|L"count");
	576	}
	577
	578	DWORD fvf = 0;
	579
	580	XMLNode xVertexBufferNode = xMainNode/L"sharedGeometry"/L"vertexbuffer";
	581
	582	if( wcscmp( xVertexBufferNode\|L"positions", L"true" ) == 0)
	583	fvf \|= D3DFVF_XYZ;
	584	if( wcscmp( xVertexBufferNode\|L"normals", L"true" ) == 0)
	585	fvf \|= D3DFVF_NORMAL;
	586	if( wcscmp( xVertexBufferNode\|L"colours_diffuse", L"true" ) == 0)
	587	fvf \|= D3DFVF_DIFFUSE;
	588	if( wcscmp( xVertexBufferNode\|L"colours_specular", L"true" ) == 0)
	589	fvf \|= D3DFVF_SPECULAR;
	590
	591	DWORD nTexCoords = _wtoi( xVertexBufferNode\|L"texture_coords" );
	592	fvf \|= D3DFVF_TEX1 * nTexCoords;
	593
	594	HRESULT hr = D3DXCreateMeshFVF(
	595	nFaces, //DWORD NumFaces,
	596	nVertices, //DWORD NumVertices,
	597	options, //DWORD Options,
	598	fvf, //DWORD FVF,
	599	device,
	600	ppMesh); //LPD3DXMESH* ppMesh);
	601
	602	LPD3DXMESH pMesh = *ppMesh;
	603
	604	LPDIRECT3DVERTEXBUFFER9 vertexBuffer;
	605	pMesh->GetVertexBuffer(&vertexBuffer);
	606	FlexVertexArray vertexData(pMesh->GetNumBytesPerVertex());
[2304]	607	D3DVERTEXELEMENT9 elem[64]; pMesh->GetDeclaration(elem); vertexData.setFormat(elem);
[2197]	608	vertexBuffer->Lock(0,pMesh->GetNumVertices()*pMesh->GetNumBytesPerVertex(),vertexData.getDataPointerReference(),0);
	609	LPDIRECT3DINDEXBUFFER9 indexBuffer;
	610	pMesh->GetIndexBuffer(&indexBuffer);
	611	unsigned short* indexData;
	612	indexBuffer->Lock(0,pMesh->GetNumFaces()3sizeof(unsigned short),(void**)&indexData,0);
	613	DWORD* attributeArray;
	614	pMesh->LockAttributeBuffer(0, &attributeArray);
	615
	616	for(int ivi=0; ivi < nVertices; ivi++)
	617	{
	618	XMLNode xVertexNode = xVertexBufferNode.getChildNode(L"vertex", ivi);
	619	XMLNode xVertexPositionNode = xVertexNode/L"position";
	620	D3DXVECTOR3 dvipos(
	621	_wtof( xVertexPositionNode\|L"x" ),
	622	_wtof( xVertexPositionNode\|L"y" ),
	623	_wtof( xVertexPositionNode\|L"z" )
	624	);
	625	vertexData[ivi].pos() = dvipos;
	626
	627	XMLNode xVertexNormalNode = xVertexNode/L"normal";
	628	D3DXVECTOR3 dvinormal(
	629	_wtof( xVertexNormalNode\|L"x" ),
	630	_wtof( xVertexNormalNode\|L"y" ),
	631	_wtof( xVertexNormalNode\|L"z" )
	632	);
	633	vertexData[ivi].normal() = dvinormal;
	634
	635	for(int tuxi=0; tuxi < nTexCoords; tuxi++)
	636	{
	637	XMLNode xVertexTexNode = xVertexNode.getChildNode(L"texcoord", tuxi);
	638	D3DXVECTOR2 dvitex(
	639	_wtof( xVertexTexNode\|L"u" ),
	640	_wtof( xVertexTexNode\|L"v" )
	641	);
	642	vertexData[ivi].tex(tuxi) = dvitex;
	643	}
	644	}
	645
	646	D3DXCreateBuffer(sizeof(D3DXMATERIAL) * nSubMeshes, materialBuffer);
	647	D3DXCreateBuffer(sizeof(D3DXEFFECTINSTANCE) * nSubMeshes, shaderBuffer);
	648
	649	D3DXMATERIAL* materialArray = (D3DXMATERIAL)(materialBuffer)->GetBufferPointer();
	650	D3DXEFFECTINSTANCE* shaderArray = (D3DXEFFECTINSTANCE)(shaderBuffer)->GetBufferPointer();
	651
	652	*nMaterials = nSubMeshes;
	653
	654	materialNames = new wchar_t*[nSubMeshes+1];
	655	materialNames[nSubMeshes] = NULL;
	656
	657	unsigned int indexBufferFiller = 0;
	658	for(int fifi=0; fifi < nSubMeshes; fifi++)
	659	{
	660	attributeArray[indexBufferFiller/3] = fifi;
	661
	662	XMLNode xSubMeshNode = xSubmeshesNode.getChildNode(L"submesh", fifi);
	663
	664	D3DXMATERIAL mat;
	665	mat.pTextureFilename = LC::c.clone(
	666	(
	667	xMaterials.getChildNodeWithAttribute(L"material", L"name",
	668	xSubMeshNode\|L"material")\|L"texture"
	669	));
	670
	671	materialNames[fifi] = L::cloneW( xSubMeshNode\|L"material" );
	672	materialArray[fifi] = mat;
	673
	674	D3DXEFFECTINSTANCE efi;
	675	efi.NumDefaults = 0;
	676	efi.pDefaults = NULL;
	677	efi.pEffectFilename = NULL;
	678	shaderArray[fifi] = efi;
	679
	680	XMLNode xSubMeshFacesNode = xSubMeshNode/L"faces";
	681	unsigned int nSubMeshFaces = _wtoi( xSubMeshFacesNode\|L"count" );
	682	for(int fido=0; fido<nSubMeshFaces; fido++)
	683	{
	684	XMLNode xFaceNode = xSubMeshFacesNode.getChildNode(L"face", fido);
	685	indexData[indexBufferFiller++] = _wtoi( xFaceNode\|L"v1" );
	686	indexData[indexBufferFiller++] = _wtoi( xFaceNode\|L"v2" );
	687	indexData[indexBufferFiller++] = _wtoi( xFaceNode\|L"v3" );
	688	}
	689	}
	690
	691	vertexBuffer->Unlock();
	692	indexBuffer->Unlock();
	693	vertexBuffer->Release();
	694	indexBuffer->Release();
	695	pMesh->UnlockAttributeBuffer();
	696
	697	return S_OK;
	698	}
	699
	700	const DWORD Mesh::DirectXMesh(0);
	701	const DWORD Mesh::OgreXMLMesh(1);
	702
	703	void Mesh::saveSceneInfo(std::ofstream& psf)
	704	{
	705	psf << "mesh " << name << '\n';
	706	psf << "{\n";
	707	psf << "\togrefile " << LC::c-ogreFileName << '\n';
	708	psf << "\tpathmapresolution " << prmAtlasSize << '\n';
	709	psf << "\tdivide 1\n";
	710	psf << "}\n";
[2304]	711	}
	712
	713	void Mesh::trimMesh(unsigned int originalAtlasTexCoordIndex)
	714	{
	715	// DWORD fvf = mesh->GetFVF();
	716	// DWORD nTexCoords = (fvf & D3DFVF_TEXCOUNT_MASK) / D3DFVF_TEX1;
	717
	718	D3DVERTEXELEMENT9 elem[64]; mesh->GetDeclaration(elem);
	719
	720	D3DVERTEXELEMENT9* pElem = &elem[0];
	721	DWORD maxTexOffs = 0;
	722	DWORD maxTexId = 0;
	723	while(pElem->Type != D3DDECLTYPE_UNUSED)
	724	{
	725	if(pElem->Usage == D3DDECLUSAGE_TEXCOORD)
	726	if(pElem->UsageIndex > maxTexId)
	727	{
	728	maxTexId = pElem->UsageIndex;
	729	maxTexOffs = pElem->Offset;
	730	}
	731	pElem++;
	732	}
	733
	734	D3DVERTEXELEMENT9 pathMapMeshDecl[5] =
	735	{ {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
	736	{0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
	737	{0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
	738	{0, 32 /maxTexOffs/,
	739	D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
	740	D3DDECL_END() };
	741
[2469]	742	// mesh->UpdateSemantics(pathMapMeshDecl);
[2304]	743
	744	LPDIRECT3DVERTEXBUFFER9 svertexBuffer;
	745	mesh->GetVertexBuffer(&svertexBuffer);
	746	FlexVertexArray svertexData(mesh->GetNumBytesPerVertex());
	747	svertexData.setFormat(elem);
	748	svertexBuffer->Lock(0, mesh->GetNumVertices() * mesh->GetNumBytesPerVertex(), svertexData.getDataPointerReference(),0);
	749
	750	for(int gh=0; gh < mesh->GetNumVertices(); gh++)
	751	svertexData[gh].tex(1) = svertexData[gh].tex(originalAtlasTexCoordIndex);
	752
	753	svertexBuffer->Unlock();
	754	svertexBuffer->Release();
	755
	756	/* LPDIRECT3DDEVICE9 device = pathMapEffect->device;
	757	LPD3DXMESH tempMesh;
	758
	759	//clone the mesh to the appropriate format
	760	HRESULT hr = mesh->CloneMesh(mesh->GetOptions(), pathMapMeshDecl,
	761	device, &tempMesh );
	762	if(hr == S_OK)
	763	{
	764	LPDIRECT3DVERTEXBUFFER9 svertexBuffer;
	765	mesh->GetVertexBuffer(&svertexBuffer);
	766	FlexVertexArray svertexData(mesh->GetNumBytesPerVertex());
	767	D3DVERTEXELEMENT9 elem[64]; mesh->GetDeclaration(elem); svertexData.setFormat(elem);
	768	svertexBuffer->Lock(0, mesh->GetNumVertices() * mesh->GetNumBytesPerVertex(), svertexData.getDataPointerReference(),0);
	769
	770	LPDIRECT3DVERTEXBUFFER9 vertexBuffer;
	771	tempMesh->GetVertexBuffer(&vertexBuffer);
	772	FlexVertexArray vertexData(tempMesh->GetNumBytesPerVertex());
	773	vertexData.setFormat(pathMapMeshDecl);
	774	vertexBuffer->Lock(0,tempMesh->GetNumVertices()*tempMesh->GetNumBytesPerVertex(),vertexData.getDataPointerReference(),0);
	775
	776	for(int qu=0; qu<mesh->GetNumVertices(); qu++)
	777	{
	778	vertexData[qu].tex(1) = svertexData[qu].tex(originalAtlasTexCoordIndex);
	779	}
	780
	781	svertexBuffer->Unlock();
	782	vertexBuffer->Unlock();
	783	svertexBuffer->Release();
	784	vertexBuffer->Release();
	785
	786	//forget he old mesh
	787	mesh->Release();
	788	//use the cloned mesh
	789	mesh = tempMesh;
	790
	791	}*/
[2197]	792	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: GTP/trunk/App/Demos/Illum/pathmap/Mesh.cpp @ 2498

Download in other formats: