Context Navigation

source: trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp @ 462

Revision 462, 33.0 KB checked in by mattausch, 19 years ago (diff)
worked on vsp kd view cells

Rev	Line
[162]	1	#include <stack>
	2	#include "common.h"
	3	#include "SceneGraph.h"
	4	#include "X3dExporter.h"
	5	#include "Mesh.h"
	6	#include "KdTree.h"
[242]	7	#include "ViewCellBsp.h"
	8	#include "ViewCell.h"
[260]	9	#include "Polygon3.h"
[386]	10	#include "VssRay.h"
[418]	11	#include "VspKdTree.h"
[434]	12	#include "VssTree.h"
[449]	13	#include "VspBspTree.h"
[450]	14	#include "RssTree.h"
[162]	15
[449]	16
[162]	17	X3dExporter::X3dExporter(const string filename):Exporter(filename)
	18	{
	19	stream.open(mFilename.c_str());
	20	stream<<"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"<<endl;
	21	stream<<"<X3D>"<<endl;
	22	stream<<"<Scene>"<<endl;
	23
	24	}
	25
	26	X3dExporter::~X3dExporter()
	27	{
	28	stream<<"</Scene>"<<endl;
	29	stream<<"</X3D>"<<endl;
	30	stream.close();
	31	}
	32
[176]	33
[386]	34	// bool
	35	// X3dExporter::ExportRays(const vector<Ray> &rays,
	36	// const float length,
	37	// const RgbColor &color)
	38	// {
	39	// vector<Ray>::const_iterator ri = rays.begin();
	40	// stream<<"<Shape>"<<endl;
	41	// stream<<"<Appearance>"<<endl;
	42	// stream<<"<Material ambientColor=\""<<color.r<<" "<<color.g<<" "<<color.b<<
	43	// "\" />"<<endl;
	44	// stream<<"</Appearance>"<<endl;
	45
	46	// stream<<"<IndexedLineSet coordIndex=\""<<endl;
	47
	48	// int index = 0;
	49	// for (; ri != rays.end(); ri++) {
	50	// stream<<index<<" "<<index+1<<" -1\n";
	51	// index+=2;
	52	// }
	53
	54	// stream<<"\" >"<<endl;
	55
	56	// stream<<"<Coordinate point=\""<<endl;
	57
	58	// ri = rays.begin();
	59	// for (; ri != rays.end(); ri++) {
	60	// Vector3 a = (*ri).GetLoc();
	61
	62	// Vector3 b;
	63	// if (length < 0)
	64	// b = (ri).GetLoc() - length(*ri).GetDir();
	65	// else
	66	// if ((*ri).intersections.size()==0)
	67	// b = (ri).GetLoc() + length(*ri).GetDir();
	68	// else
	69	// b = (ri).Extrap((ri).intersections[0].mT);
	70
	71	// stream<<a.x<<" "<<a.y<<" "<<a.z<<" ,";
	72	// stream<<b.x<<" "<<b.y<<" "<<b.z<<" ,\n";
	73	// }
	74
	75	// stream<<"\" >"<<endl;
	76	// stream<<"</Coordinate>"<<endl;
	77	// stream<<"</IndexedLineSet>"<<endl;
	78	// stream<<"</Shape>"<<endl;
	79	// return true;
	80	// }
	81
	82
[162]	83	bool
[386]	84	X3dExporter::ExportRays(const RayContainer &rays,
[444]	85	const float length,
	86	const RgbColor &color)
[162]	87	{
[386]	88	RayContainer::const_iterator ri = rays.begin();
	89
[162]	90	stream<<"<Shape>"<<endl;
[176]	91	stream<<"<Appearance>"<<endl;
[427]	92	stream<<"<Material diffuseColor=\""<<color.r<<" "<<color.g<<" "<<color.b<<
[176]	93	"\" />"<<endl;
	94	stream<<"</Appearance>"<<endl;
	95
[209]	96	stream<<"<IndexedLineSet coordIndex=\""<<endl;
[162]	97
	98	int index = 0;
	99	for (; ri != rays.end(); ri++) {
	100	stream<<index<<" "<<index+1<<" -1\n";
	101	index+=2;
	102	}
	103
	104	stream<<"\" >"<<endl;
	105
	106	stream<<"<Coordinate point=\""<<endl;
	107
	108	ri = rays.begin();
	109	for (; ri != rays.end(); ri++) {
[386]	110	Vector3 a = (*ri)->GetLoc();
[162]	111
[176]	112	Vector3 b;
	113	if (length < 0)
[386]	114	b = (ri)->GetLoc() - length(*ri)->GetDir();
[176]	115	else
[386]	116	if ((*ri)->intersections.size()==0)
	117	b = (ri)->GetLoc() + length(*ri)->GetDir();
[176]	118	else
[386]	119	b = (ri)->Extrap((ri)->intersections[0].mT);
[176]	120
[162]	121	stream<<a.x<<" "<<a.y<<" "<<a.z<<" ,";
	122	stream<<b.x<<" "<<b.y<<" "<<b.z<<" ,\n";
	123	}
	124
	125	stream<<"\" >"<<endl;
	126	stream<<"</Coordinate>"<<endl;
	127	stream<<"</IndexedLineSet>"<<endl;
	128	stream<<"</Shape>"<<endl;
[386]	129
[162]	130	return true;
	131	}
	132
[349]	133	bool
[386]	134	X3dExporter::ExportRays(const VssRayContainer &rays,
[444]	135	const RgbColor &color)
[349]	136	{
[386]	137	VssRayContainer::const_iterator ri = rays.begin();
[349]	138
	139	stream<<"<Shape>"<<endl;
	140	stream<<"<Appearance>"<<endl;
[427]	141	stream<<"<Material diffuseColor=\""<<color.r<<" "<<color.g<<" "<<color.b<<
[349]	142	"\" />"<<endl;
	143	stream<<"</Appearance>"<<endl;
	144
	145	stream<<"<IndexedLineSet coordIndex=\""<<endl;
	146
	147	int index = 0;
	148	for (; ri != rays.end(); ri++) {
	149	stream<<index<<" "<<index+1<<" -1\n";
	150	index+=2;
	151	}
	152
	153	stream<<"\" >"<<endl;
	154
	155	stream<<"<Coordinate point=\""<<endl;
	156
	157	ri = rays.begin();
	158	for (; ri != rays.end(); ri++) {
[444]	159	const Vector3 a = (*ri)->GetOrigin();
	160	const Vector3 b = (ri)->mTerminationObject ? (ri)->GetTermination() : a + 1000 * Normalize((*ri)->GetDir());
[426]	161
[349]	162	stream<<a.x<<" "<<a.y<<" "<<a.z<<" ,";
[444]	163	stream<<b.x<<" "<<b.y<<" "<<b.z<<" ,\n";
[349]	164	}
	165
	166	stream<<"\" >"<<endl;
	167	stream<<"</Coordinate>"<<endl;
	168	stream<<"</IndexedLineSet>"<<endl;
	169	stream<<"</Shape>"<<endl;
[386]	170
[349]	171	return true;
	172	}
	173
[162]	174	void
	175	X3dExporter::ExportSceneNode(SceneGraphNode *node)
	176	{
	177	stream<<"<Group>"<<endl;
	178
	179	SceneGraphNodeContainer::iterator ni = node->mChildren.begin();
	180	for (; ni != node->mChildren.end(); ni++)
	181	ExportSceneNode(*ni);
	182
	183
[176]	184	ObjectContainer::const_iterator mi = node->mGeometry.begin();
[162]	185	for (; mi != node->mGeometry.end(); mi++) {
	186	// export the transform...
[176]	187	ExportIntersectable(*mi);
[162]	188	}
	189
	190	stream<<"</Group>"<<endl;
	191
	192	}
[176]	193	void
	194	X3dExporter::ExportIntersectable(Intersectable *object)
	195	{
	196	switch (object->Type()) {
	197	case Intersectable::MESH_INSTANCE:
	198	case Intersectable::TRANSFORMED_MESH_INSTANCE:
	199	ExportMeshInstance((MeshInstance *)object);
[242]	200	break;
[308]	201	case Intersectable::VIEW_CELL:
[242]	202	ExportViewCell((ViewCell *)object);
[176]	203	break;
	204	default:
	205	cerr<<"Sorry the export for object not yet defined"<<endl;
	206	break;
	207	}
	208	}
[162]	209
	210	void
[176]	211	X3dExporter::ExportMeshInstance(MeshInstance *object)
	212	{
	213	// $$JB$$
[312]	214	// in the future check whether the mesh was not already exported
[176]	215	// and use a reference to the that mesh instead
	216	ExportMesh(object->GetMesh());
	217	}
	218
[313]	219	void
	220	X3dExporter::ExportViewCells(const ViewCellContainer &viewCells)
[261]	221	{
[313]	222	ViewCellContainer::const_iterator it, it_end = viewCells.end();
[261]	223
[313]	224	for (it = viewCells.begin(); it != it_end; ++ it)
[261]	225	ExportViewCell(*it);
	226	}
[313]	227
[373]	228	void
[379]	229	X3dExporter::ExportBspViewCellPartition(const BspTree &tree, const int maxPvs)
[373]	230	{
	231	ViewCellContainer viewCells;
	232	tree.CollectViewCells(viewCells);
	233
	234	ViewCellContainer::const_iterator it, it_end = viewCells.end();
	235
[380]	236	if (maxPvs > 0)
[379]	237	mUseForcedMaterial = true;
	238
[373]	239	for (it = viewCells.begin(); it != it_end; ++ it)
	240	{
[379]	241	if (maxPvs > 0)
[380]	242	{
	243	mForcedMaterial.mDiffuseColor.b = 1.0f;
	244	float importance = (float)(*it)->GetPvs().GetSize() / (float)maxPvs;
[379]	245
[380]	246	mForcedMaterial.mDiffuseColor.r = importance;
	247	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	248	}
	249
[373]	250	if ((*it)->GetMesh())
	251	ExportViewCell(*it);
	252	else
	253	{
	254	PolygonContainer cell;
	255	tree.ConstructGeometry(dynamic_cast<BspViewCell >(it), cell);
[379]	256
[373]	257	ExportPolygons(cell);
	258	}
	259	}
	260	}
	261
	262	void
[396]	263	X3dExporter::ExportBspLeaves(const BspTree &tree, const int maxPvs)
[373]	264	{
[396]	265	stack<pair<BspNode , BspNodeGeometry > > tStack;
	266	ViewCell::NewMail();
[373]	267
[396]	268	BspNodeGeometry *geom = new BspNodeGeometry();
	269	tree.ConstructGeometry(tree.GetRoot(), *geom);
[373]	270
[396]	271	tStack.push(pair<BspNode , BspNodeGeometry >(tree.GetRoot(), geom));
	272
	273	if (maxPvs > 0)
	274	mUseForcedMaterial = true;
	275
	276	while (!tStack.empty())
[373]	277	{
[396]	278	BspNode *node = tStack.top().first;
	279	BspNodeGeometry *cell = tStack.top().second;
	280	tStack.pop();
	281
	282	if (!node->IsLeaf())
	283	{
	284	BspInterior interior = dynamic_cast<BspInterior >(node);
	285
	286	BspNodeGeometry *front = new BspNodeGeometry();
	287	BspNodeGeometry *back = new BspNodeGeometry();
	288
[449]	289	cell->SplitGeometry(*front,
	290	*back,
	291	interior->GetPlane(),
	292	tree.GetBoundingBox(),
	293	tree.GetEpsilon());
[396]	294
	295	tStack.push(pair<BspNode , BspNodeGeometry >(interior->GetFront(), front));
	296	tStack.push(pair<BspNode , BspNodeGeometry >(interior->GetBack(), back));
	297	}
	298	else
	299	{
	300	if (maxPvs > 0)
	301	{
	302	BspLeaf leaf = dynamic_cast<BspLeaf >(node);
	303
	304	mForcedMaterial.mDiffuseColor.b = 1.0f;
	305	float importance = (float)leaf->GetViewCell()->GetPvs().GetSize() / (float)maxPvs;
	306
	307	mForcedMaterial.mDiffuseColor.r = importance;
	308	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	309	}
	310
	311	ExportPolygons(cell->mPolys);
	312	}
	313
	314	DEL_PTR(cell);
[373]	315	}
	316	}
	317
[176]	318	void
[261]	319	X3dExporter::ExportViewCell(ViewCell *viewCell)
[242]	320	{
[261]	321	if (viewCell->GetMesh())
	322	ExportMesh(viewCell->GetMesh());
[242]	323	}
	324
	325	void
[162]	326	X3dExporter::ExportMesh(Mesh *mesh)
	327	{
	328
	329	stream<<"<Shape>"<<endl;
	330	stream<<"<Appearance>"<<endl;
[176]	331
[162]	332	// $$ tmp -> random material
	333
	334	float r, g, b;
	335
[176]	336	if (mUseForcedMaterial) {
	337	r = mForcedMaterial.mDiffuseColor.r;
	338	g = mForcedMaterial.mDiffuseColor.g;
	339	b = mForcedMaterial.mDiffuseColor.b;
	340
	341	} else
	342	if (mesh->mMaterial) {
	343	r = mesh->mMaterial->mDiffuseColor.r;
	344	g = mesh->mMaterial->mDiffuseColor.g;
	345	b = mesh->mMaterial->mDiffuseColor.b;
	346	} else {
	347	r = RandomValue(0.5, 1.0);
	348	g = RandomValue(0.5, 1.0);
	349	b = RandomValue(0.5, 1.0);
	350	}
[162]	351	stream<<"<Material diffuseColor=\""<<r<<" "<<g<<" "<<b<<
	352	"\" specularColor=\"0.0 0.0 0.0\"/>"<<endl;
	353	stream<<"</Appearance>"<<endl;
	354
	355
[191]	356	if (mWireframe)
[427]	357	stream<<"<IndexedLineSet coordIndex=\""<<endl;
[162]	358	else
	359	stream<<"<IndexedFaceSet ccw=\"TRUE\" coordIndex=\""<<endl;
	360
	361	FaceContainer::const_iterator fi = mesh->mFaces.begin();
	362
	363	int index = 0;
	364
	365	for (; fi != mesh->mFaces.end(); fi++) {
	366	Face face = fi;
	367	VertexIndexContainer::const_iterator vi = face->mVertexIndices.begin();
	368	for (; vi != face->mVertexIndices.end(); vi++)
	369	stream<<*vi<<" ";
[378]	370	if (mWireframe) // final line to finish polygon
	371	stream << (*face->mVertexIndices.begin()) << " ";
	372
[162]	373	stream<<"-1"<<endl;
	374	}
	375	stream<<"\" >"<<endl;
	376
	377	stream<<"<Coordinate point=\""<<endl;
	378
	379	VertexContainer::const_iterator vi = mesh->mVertices.begin();
	380	for (; vi != mesh->mVertices.end(); vi++) {
	381	stream<<(vi).x<<" "<<(vi).y<<" "<<(*vi).z;
	382	stream<<","<<endl;
	383	}
	384
	385	stream<<"\" >"<<endl;
	386	stream<<"</Coordinate>"<<endl;
	387
[191]	388	if (mWireframe)
[162]	389	stream<<"</IndexedLineSet>"<<endl;
	390	else
	391	stream<<"</IndexedFaceSet>"<<endl;
	392
	393	stream<<"</Shape>"<<endl;
	394
	395	}
	396
[242]	397
	398	void X3dExporter::ExportPolygon(Polygon3 *poly)
	399	{
	400	stream << "<Shape>" << endl;
	401	stream << "<Appearance>" << endl;
	402
	403	// $$ tmp -> random material
	404
	405	float r, g, b;
	406
	407	if (mUseForcedMaterial)
	408	{
	409	r = mForcedMaterial.mDiffuseColor.r;
	410	g = mForcedMaterial.mDiffuseColor.g;
	411	b = mForcedMaterial.mDiffuseColor.b;
	412	}
	413	else if (poly->mMaterial)
	414	{
	415	r = poly->mMaterial->mDiffuseColor.r;
	416	g = poly->mMaterial->mDiffuseColor.g;
	417	b = poly->mMaterial->mDiffuseColor.b;
	418	} else
	419	{
	420	r = RandomValue(0.5, 1.0);
	421	g = RandomValue(0.5, 1.0);
	422	b = RandomValue(0.5, 1.0);
	423	}
	424
	425	stream << "<Material diffuseColor=\"" << r << " " << g << " " << b
	426	<< "\" specularColor=\"0.0 0.0 0.0\"/>" << endl;
	427
	428	stream << "</Appearance>" << endl;
	429
	430
[262]	431	//-- create and write indices
[242]	432	if (mWireframe)
	433	stream << "<IndexedLineSet ccw=\"TRUE\" coordIndex=\"" << endl;
	434	else
	435	stream << "<IndexedFaceSet ccw=\"TRUE\" coordIndex=\"" << endl;
	436
[262]	437	int index = 0;
	438
	439	VertexContainer::const_iterator vi;
	440
[333]	441	for (index = 0; index < (int)poly->mVertices.size(); ++ index)
[318]	442	stream << index << " ";
	443
	444	if (mWireframe) // final line to finish polygon
	445	stream << "0 ";
	446
[262]	447	stream << "-1" << endl;
	448	stream << "\" >" << endl;
	449
[242]	450	stream << "<Coordinate point=\"" << endl;
	451
[262]	452	for (vi = poly->mVertices.begin(); vi != poly->mVertices.end(); ++vi)
[242]	453	{
	454	stream << (vi).x << " " << (vi).y << " " << (*vi).z;
	455	stream << "," << endl;
	456	}
	457
[262]	458	stream << "\" >" << endl;
	459	stream << "</Coordinate>" << endl;
[242]	460
	461	if (mWireframe)
	462	stream << "</IndexedLineSet>" << endl;
	463	else
	464	stream << "</IndexedFaceSet>" << endl;
	465
	466	stream << "</Shape>" << endl;
	467	}
	468
[313]	469	void X3dExporter::ExportPolygons(const PolygonContainer &polys)
[263]	470	{
[318]	471	stream << "<Shape>" << endl;
[263]	472	stream << "<Appearance>" << endl;
	473
	474	// $$ tmp -> random material
	475
	476	float r, g, b;
[242]	477
[263]	478	if (mUseForcedMaterial)
	479	{
	480	r = mForcedMaterial.mDiffuseColor.r;
	481	g = mForcedMaterial.mDiffuseColor.g;
	482	b = mForcedMaterial.mDiffuseColor.b;
	483	}
	484	else
	485	{
	486	r = RandomValue(0.5, 1.0);
	487	g = RandomValue(0.5, 1.0);
	488	b = RandomValue(0.5, 1.0);
	489	}
	490
	491	stream << "<Material diffuseColor=\"" << r << " " << g << " " << b
	492	<< "\" specularColor=\"0.0 0.0 0.0\"/>" << endl;
	493
	494	stream << "</Appearance>" << endl;
	495
	496
	497	//-- create and write indices
	498	if (mWireframe)
	499	stream << "<IndexedLineSet ccw=\"TRUE\" coordIndex=\"" << endl;
	500	else
	501	stream << "<IndexedFaceSet ccw=\"TRUE\" coordIndex=\"" << endl;
	502
	503	int index = 0;
	504
	505	PolygonContainer::const_iterator pit;
	506
	507	VertexContainer::const_iterator vi;
	508
[313]	509	for (pit = polys.begin(); pit != polys.end(); ++pit)
[263]	510	{
	511	Polygon3 poly = pit;
[318]	512	int startIdx = index;
[263]	513	for (vi = poly->mVertices.begin(); vi != poly->mVertices.end(); ++vi)
	514	{
	515	stream << index ++ << " ";
	516	}
[318]	517
	518	stream << startIdx << " ";// finish line
[263]	519	stream << "-1" << endl;
	520	}
	521
	522	stream << "\" >" << endl;
	523
	524	stream << "<Coordinate point=\"" << endl;
[318]	525	for (pit = polys.begin(); pit != polys.end(); ++ pit)
[263]	526	{
	527	Polygon3 poly = pit;
	528	for (vi = poly->mVertices.begin(); vi != poly->mVertices.end(); ++vi)
	529	{
	530	stream << (vi).x << " " << (vi).y << " " << (*vi).z;
	531	stream << "," << endl;
	532	}
	533	}
	534	stream << "\" >" << endl;
	535	stream << "</Coordinate>" << endl;
	536
	537	if (mWireframe)
	538	stream << "</IndexedLineSet>" << endl;
	539	else
	540	stream << "</IndexedFaceSet>" << endl;
	541
	542	stream << "</Shape>" << endl;
	543	}
	544
[162]	545	bool
	546	X3dExporter::ExportBox(const AxisAlignedBox3 &box)
	547	{
	548	Mesh *mesh = new Mesh;
	549	// add 6 vertices of the box
[289]	550	int index = (int)mesh->mVertices.size();
[162]	551	for (int i=0; i < 8; i++) {
	552	Vector3 v;
	553	box.GetVertex(i, v);
	554	mesh->mVertices.push_back(v);
	555	}
	556
	557	mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
	558	mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
	559	mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );
	560
	561	mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
	562	mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
	563	mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );
	564
	565	ExportMesh(mesh);
	566	delete mesh;
	567	return true;
	568	}
	569
	570	bool
[242]	571	X3dExporter::ExportBspTree(const BspTree &tree)
[162]	572	{
[242]	573	if (mExportRayDensity)
	574	{
[263]	575	return ExportBspTreeRayDensity(tree);
[242]	576	}
	577
[264]	578	bool savedWireframe = mWireframe;
	579
	580	SetWireframe();
	581
[396]	582	ExportBox(tree.GetBoundingBox());
	583
[264]	584	if (!savedWireframe)
	585	SetFilled();
	586
[373]	587	// export view cells
	588	ExportBspViewCellPartition(tree);
[289]	589
[263]	590	return true;
[242]	591	}
	592
[425]	593	bool X3dExporter::ExportVspKdTree(const VspKdTree &tree, const int maxPvs)
[418]	594	{
[462]	595	stack<VspKdNode *> tStack;
[418]	596
[422]	597	tStack.push(tree.GetRoot());
	598
[425]	599	//Mesh *mesh = new Mesh;
[418]	600
[425]	601	if (maxPvs > 0)
	602	mUseForcedMaterial = true;
	603
[422]	604	while (!tStack.empty())
	605	{
[462]	606	VspKdNode *node = tStack.top();
[418]	607
[422]	608	tStack.pop();
[418]	609
[426]	610	if (node->IsLeaf())
	611	{
	612	AxisAlignedBox3 box = tree.GetBBox(node);
[425]	613
[426]	614	Mesh *mesh = new Mesh;
[425]	615
[426]	616	// add 6 vertices of the box
	617	int index = (int)mesh->mVertices.size();
[418]	618
[426]	619	for (int i=0; i < 8; ++ i)
	620	{
	621	Vector3 v;
	622	box.GetVertex(i, v);
	623	mesh->mVertices.push_back(v);
	624	}
[418]	625
[426]	626	mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
	627	mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
	628	mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );
[418]	629
[426]	630	mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
	631	mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
	632	mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );
[425]	633
[426]	634	if (maxPvs > 0)
	635	{
[462]	636	VspKdLeaf leaf = dynamic_cast<VspKdLeaf >(node);
[425]	637
[426]	638	mForcedMaterial.mDiffuseColor.b = 1.0f;
	639
	640	leaf->UpdatePvsSize();
	641
	642	const float importance = (float)leaf->GetPvsSize() / (float)maxPvs;
	643	mForcedMaterial.mDiffuseColor.r = importance;
	644	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	645	}
[425]	646
[426]	647	ExportMesh(mesh);
	648	DEL_PTR(mesh);
	649	}
	650	else
[422]	651	{
[462]	652	VspKdInterior interior = dynamic_cast<VspKdInterior >(node);
[422]	653	tStack.push(interior->GetFront());
	654	tStack.push(interior->GetBack());
	655	}
	656	}
[418]	657
[425]	658	//ExportMesh(mesh);
	659	//DEL_PTR(mesh);
[418]	660
[422]	661	return true;
[418]	662	}
	663
[462]	664	bool X3dExporter::ExportVspKdTreeViewCells(const VspKdTree &tree, const int maxPvs)
	665	{
	666	ViewCellContainer vc;
	667
	668	//if (maxPvs > 0)
	669	mUseForcedMaterial = true;
	670
	671	tree.CollectViewCells(vc);
	672
	673	ViewCellContainer::const_iterator it, it_end = vc.end();
	674
	675	for (it = vc.begin(); it != it_end; ++ it)
	676	{
	677	VspKdViewCell viewCell = dynamic_cast<VspKdViewCell >(*it);
	678
	679	if (maxPvs > 0)
	680	{
	681	mForcedMaterial.mDiffuseColor.b = 1.0f;
	682
	683	const float importance = (float)viewCell->GetPvs().GetSize() / (float)maxPvs;
	684	mForcedMaterial.mDiffuseColor.r = importance;
	685	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	686	}
	687	else
	688	mForcedMaterial = RandomMaterial();
	689
	690	ExportVspKdTreeViewCell(tree, *viewCell);
	691	}
	692
	693	return true;
	694	}
	695
	696	bool X3dExporter::ExportVspKdTreeViewCell(const VspKdTree &tree, const VspKdViewCell &vc)
	697	{
	698	vector<VspKdLeaf *>::const_iterator it, it_end = vc.mVspKdLeaves.end();
	699
	700	for (it = vc.mVspKdLeaves.begin(); it != it_end; ++ it)
	701	ExportBox(tree.GetBBox(*it));
	702
	703	return true;
	704	}
	705
[242]	706	bool X3dExporter::ExportKdTree(const KdTree &tree)
	707	{
	708	if (mExportRayDensity) {
[191]	709	return ExportKdTreeRayDensity(tree);
	710	}
	711
[162]	712	stack<KdNode *> tStack;
	713
	714	tStack.push(tree.GetRoot());
	715
	716	Mesh *mesh = new Mesh;
	717
	718	while (!tStack.empty()) {
	719	KdNode *node = tStack.top();
	720	tStack.pop();
	721	AxisAlignedBox3 box = tree.GetBox(node);
	722	// add 6 vertices of the box
[289]	723	int index = (int)mesh->mVertices.size();
[162]	724	for (int i=0; i < 8; i++) {
	725	Vector3 v;
	726	box.GetVertex(i, v);
	727	mesh->mVertices.push_back(v);
	728	}
	729	mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
	730	mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
	731	mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );
	732
	733	mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
	734	mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
	735	mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );
	736
	737	if (!node->IsLeaf()) {
	738	KdInterior interior = (KdInterior )node;
	739	tStack.push(interior->mFront);
	740	tStack.push(interior->mBack);
	741	}
	742	}
	743
	744	ExportMesh(mesh);
	745	delete mesh;
	746	return true;
[242]	747	// TODO
	748	return true;
[162]	749	}
	750
	751
[434]	752	void
	753	X3dExporter::AddBoxToMesh(const AxisAlignedBox3 &box,
	754	Mesh *mesh)
	755	{
	756	// add 6 vertices of the box
	757	int index = (int)mesh->mVertices.size();
	758
	759	for (int i=0; i < 8; i++) {
	760	Vector3 v;
	761	box.GetVertex(i, v);
	762	mesh->mVertices.push_back(v);
	763	}
	764
	765	mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
	766	mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
	767	mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );
	768
	769	mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
	770	mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
	771	mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );
	772
	773	}
	774
[191]	775	bool
[438]	776	X3dExporter::ExportVssTree(const VssTree &tree
	777	)
[434]	778	{
	779	stack<VssTreeNode *> tStack;
	780
	781	tStack.push(tree.GetRoot());
	782
	783	Mesh *mesh = new Mesh;
	784	VssRayContainer rays;
	785
	786	while (!tStack.empty()) {
	787
	788	VssTreeNode *node = tStack.top();
	789	tStack.pop();
	790
	791
	792	if (!node->IsLeaf()) {
	793	VssTreeInterior interior = (VssTreeInterior )node;
	794	tStack.push(interior->front);
	795	tStack.push(interior->back);
	796	} else {
	797	VssTreeLeaf leaf = (VssTreeLeaf )node;
	798	AxisAlignedBox3 box;
	799	box = tree.GetBBox(leaf);
	800	AddBoxToMesh(box, mesh);
	801
	802	if (tree.ValidLeaf(leaf)) {
	803
	804	Vector3 origin = box.Center();
	805	box = tree.GetDirBBox(leaf);
	806	VssRay *ray;
	807
	808	const indices[][2] = {{0,0}, {0,1}, {1,1}, {1,0}};
	809	MeshInstance dummy(mesh);
	810	for (int i=0; i < 4; i++) {
	811	// Vector3 v = box.GetVertex(indices[i][0], indices[i][1], 0);
	812	Vector3 v = box.Center();
	813
	814	Vector3 direction = VssRay::GetDirection(v.x, v.y);
[438]	815	if (Magnitude(direction) > Limits::Small)
	816	direction.Normalize();
	817	else
	818	direction = Vector3(0, 1, 0);
[435]	819	float k = 100.0f*leaf->GetImportance();
[434]	820	// get 4 corners of the ray directions
	821
	822	ray = new VssRay(origin, origin + (direction*k), NULL, &dummy);
	823	rays.push_back(ray);
	824	}
	825	}
	826	}
	827	}
	828
	829	ExportMesh(mesh);
[438]	830	ExportRays(rays);
	831	CLEAR_CONTAINER(rays);
[434]	832	delete mesh;
	833	return true;
	834	}
	835
	836	bool
[438]	837	X3dExporter::ExportVssTree2(const VssTree &tree,
	838	const Vector3 direction
	839	)
	840	{
	841	stack<VssTreeNode *> tStack;
	842
	843
	844	mUseForcedMaterial = true;
	845
	846	Vector3 dirParam;
	847
	848	dirParam.x = VssRay::GetDirParam(0, Normalize(direction));
	849	dirParam.y = VssRay::GetDirParam(1, Normalize(direction));
	850
	851	float maxImportance = 0.0f;
	852	tStack.push(tree.GetRoot());
	853	while (!tStack.empty()) {
	854
	855	VssTreeNode *node = tStack.top();
	856	tStack.pop();
	857
	858	if (!node->IsLeaf()) {
	859	VssTreeInterior interior = (VssTreeInterior )node;
	860	if (interior->axis < 3) {
	861	tStack.push(interior->front);
	862	tStack.push(interior->back);
	863	} else {
	864	if (dirParam[interior->axis-3] < interior->position)
	865	tStack.push(interior->back);
	866	else
	867	tStack.push(interior->front);
	868	}
	869	} else {
	870	VssTreeLeaf leaf = (VssTreeLeaf )node;
	871	if (tree.ValidLeaf(leaf)) {
	872	float i = leaf->GetImportance();
	873	if (i > maxImportance)
	874	maxImportance = i;
	875	}
	876	}
	877	}
	878
	879	tStack.push(tree.GetRoot());
	880	while (!tStack.empty()) {
	881
	882	VssTreeNode *node = tStack.top();
	883	tStack.pop();
	884
	885
	886	if (!node->IsLeaf()) {
	887	VssTreeInterior interior = (VssTreeInterior )node;
	888	if (interior->axis < 3) {
	889	tStack.push(interior->front);
	890	tStack.push(interior->back);
	891	} else {
	892	if (dirParam[interior->axis-3] < interior->position)
	893	tStack.push(interior->back);
	894	else
	895	tStack.push(interior->front);
	896	}
	897	} else {
	898	VssTreeLeaf leaf = (VssTreeLeaf )node;
	899	if (tree.ValidLeaf(leaf)) {
	900	AxisAlignedBox3 box;
	901	box = tree.GetBBox(leaf);
	902	Mesh *mesh = new Mesh;
	903	AddBoxToMesh(box, mesh);
	904
	905	// get 4 corners of the ray directions
	906
	907	mForcedMaterial.mDiffuseColor.b = 1.0f;
	908	mForcedMaterial.mDiffuseColor.r = leaf->GetImportance()/maxImportance;
	909	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	910
	911	ExportMesh(mesh);
	912	delete mesh;
	913	}
	914	}
	915	}
	916
	917	mUseForcedMaterial = false;
	918
	919	return true;
	920	}
	921
	922	bool
[263]	923	X3dExporter::ExportBspTreeRayDensity(const BspTree &tree)
	924	{
[311]	925	stack<BspNode *> tStack;
	926
	927	tStack.push(tree.GetRoot());
	928
	929	bool fm = mUseForcedMaterial;
	930
	931	mUseForcedMaterial = true;
	932
	933	mForcedMaterial.mDiffuseColor.g = 1.0f;
	934	mForcedMaterial.mDiffuseColor.b = 1.0f;
	935
	936	while (!tStack.empty())
	937	{
	938	BspNode *node = tStack.top();
	939	tStack.pop();
	940
	941	if (node->IsLeaf())
	942	{
	943	ViewCell vc = dynamic_cast<BspLeaf >(node)->GetViewCell();
	944
	945	// set the mesh material according to the ray density
	946	if (vc->mPassingRays.mRays)
	947	{
[313]	948	float importance =
[438]	949	vc->mPassingRays.mContributions / (float)vc->mPassingRays.mRays;
	950
[311]	951	mForcedMaterial.mDiffuseColor.r = importance;
	952	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	953	ExportViewCell(vc);
[438]	954	}
[311]	955	} else
	956	{
	957	BspInterior interior = (BspInterior )node;
	958	tStack.push(interior->GetFront());
	959	tStack.push(interior->GetBack());
	960	}
	961	}
	962
	963	// restore the state of forced material
	964	mUseForcedMaterial = fm;
	965
[263]	966	return true;
	967	}
	968
	969	bool
[191]	970	X3dExporter::ExportKdTreeRayDensity(const KdTree &tree)
	971	{
	972	stack<KdNode *> tStack;
	973
	974	tStack.push(tree.GetRoot());
	975
	976	bool fm = mUseForcedMaterial;
	977	mUseForcedMaterial = true;
	978	mForcedMaterial.mDiffuseColor.g = 1.0f;
	979	mForcedMaterial.mDiffuseColor.b = 1.0f;
	980	while (!tStack.empty()) {
	981	KdNode *node = tStack.top();
	982	tStack.pop();
	983	if (node->IsLeaf()) {
	984	AxisAlignedBox3 box = tree.GetBox(node);
	985	Mesh *mesh = new Mesh;
	986
	987	// add 6 vertices of the box
[289]	988	int index = (int)mesh->mVertices.size();
[191]	989	for (int i=0; i < 8; i++) {
	990	Vector3 v;
	991	box.GetVertex(i, v);
	992	mesh->mVertices.push_back(v);
	993	}
	994	mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
	995	mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
	996	mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );
	997
	998	mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
	999	mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
	1000	mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );
	1001
	1002
	1003	// set the mesh material according to the ray density
	1004	KdLeaf leaf = (KdLeaf ) node;
	1005	if (leaf->mPassingRays.mRays) {
	1006	float importance = leaf->mPassingRays.mContributions/(float)leaf->mPassingRays.mRays;
	1007	// float importance = leaf->mPassingRays.mContributions/1000.0f;
	1008	// float importance = leaf->mPassingRays.mRays/1000.0f;
	1009	///(float)leaf->mPassingRays.mRays;
	1010	// mForcedMaterial.mDiffuseColor.r = log10(leaf->mPassingRays.mRays)/3.0f;
	1011	mForcedMaterial.mDiffuseColor.r = importance;
	1012	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	1013	ExportMesh(mesh);
	1014	}
	1015	delete mesh;
	1016	} else {
	1017	KdInterior interior = (KdInterior )node;
	1018	tStack.push(interior->mFront);
	1019	tStack.push(interior->mBack);
	1020	}
	1021	}
	1022	// restore the state of forced material
	1023	mUseForcedMaterial = fm;
	1024	return true;
	1025	}
[312]	1026
[329]	1027
[312]	1028	struct BspSplitData
	1029	{
[372]	1030	/// the current node
	1031	BspNode *mNode;
	1032
[449]	1033	vector<Plane3> mPlanes;
[372]	1034	vector<bool> mSides;
	1035	bool mIsFront;
[383]	1036	int mDepth;
[372]	1037
[313]	1038	BspSplitData(BspNode *node):
[383]	1039	mNode(node), mIsFront(false), mDepth(0)
[372]	1040	{};
[383]	1041
[312]	1042	BspSplitData(BspNode *node,
[449]	1043	vector<Plane3> planes,
[329]	1044	vector<bool> sides,
[383]	1045	const bool isFront,
	1046	const int depth):
	1047	mNode(node), mPlanes(planes), mSides(sides),
	1048	mIsFront(isFront), mDepth(depth)
[312]	1049	{};
	1050	};
	1051
[383]	1052	void X3dExporter::ExportLeavesGeometry(const BspTree &tree,
	1053	const vector<BspLeaf *> &leaves)
[360]	1054	{
	1055	vector<BspLeaf *>::const_iterator it, it_end = leaves.end();
	1056
	1057	for (it = leaves.begin(); it != it_end; ++ it)
	1058	{
	1059	PolygonContainer cell;
	1060	tree.ConstructGeometry(*it, cell);
	1061
	1062	ExportPolygons(cell);
	1063
	1064	CLEAR_CONTAINER(cell);
	1065	}
	1066	}
	1067
[449]	1068	void X3dExporter::ExportBspNodeSplits(BspNode *root,
	1069	const AxisAlignedBox3 &box,
	1070	const bool exportDepth,
	1071	const bool epsilon)
[372]	1072	{
	1073	std::stack<BspSplitData> tStack;
	1074
[449]	1075	BspSplitData tData(root);
[372]	1076	tStack.push(tData);
	1077
	1078	PolygonContainer polys;
[383]	1079	vector <int> depths;
[372]	1080
[383]	1081	int maxDepth = 0;
	1082
[372]	1083	while (!tStack.empty())
	1084	{
	1085	// filter polygons donw the tree
	1086	BspSplitData tData = tStack.top();
	1087	tStack.pop();
	1088
[383]	1089	if (tData.mNode->IsLeaf())
[372]	1090	{
[383]	1091	if (tData.mDepth > maxDepth)
	1092	maxDepth = tData.mDepth;
	1093	}
	1094	else
	1095	{
[372]	1096	BspInterior interior = dynamic_cast<BspInterior >(tData.mNode);
	1097
[383]	1098	// add current side of split plane
[449]	1099	if (tData.mNode != root)
[383]	1100	tData.mSides.push_back(tData.mIsFront);
[372]	1101
	1102	// bounded plane is added to the polygons
[383]	1103	Polygon3 *planePoly =
[449]	1104	box.CrossSection(interior->GetPlane());
[372]	1105
	1106	// do all the splits with the previous planes
	1107	for (int i = 0; i < (int)tData.mPlanes.size(); ++ i)
[436]	1108	{
[449]	1109	if (planePoly->ClassifyPlane(tData.mPlanes[i], epsilon)
	1110	== Polygon3::SPLIT)
[372]	1111	{
	1112	Polygon3 *frontPoly = new Polygon3();
	1113	Polygon3 *backPoly = new Polygon3();
	1114
[449]	1115	planePoly->Split(tData.mPlanes[i],
	1116	*frontPoly,
	1117	*backPoly,
	1118	epsilon);
	1119
[372]	1120	DEL_PTR(planePoly);
	1121
	1122	if(tData.mSides[i] == true)
	1123	{
	1124	planePoly = frontPoly;
	1125	DEL_PTR(backPoly);
	1126	}
	1127	else
	1128	{
	1129	planePoly = backPoly;
	1130	DEL_PTR(frontPoly);
	1131	}
	1132	}
	1133	}
	1134
	1135	tData.mPlanes.push_back(interior->GetPlane()); // add plane to split planes
	1136
[449]	1137	if (planePoly->Valid(epsilon))
[383]	1138	{
[372]	1139	polys.push_back(planePoly);
[383]	1140	depths.push_back(tData.mDepth);
	1141	}
[372]	1142	else
	1143	DEL_PTR(planePoly);
	1144
	1145	// push the children on the stack
[383]	1146	tStack.push(BspSplitData(interior->GetFront(), tData.mPlanes,
	1147	tData.mSides, true, tData.mDepth + 1));
	1148	tStack.push(BspSplitData(interior->GetBack(), tData.mPlanes,
	1149	tData.mSides, false, tData.mDepth + 1));
[372]	1150	}
[383]	1151	}
	1152
	1153	if (maxDepth > 0)
	1154	{
	1155	mUseForcedMaterial = true;
	1156
	1157	for (int i = 0; i < (int)polys.size(); ++ i)
	1158	{
	1159	mForcedMaterial.mDiffuseColor.b = 1.0f;
	1160	float importance = (float)depths[i]/ (float)maxDepth;
	1161
	1162	mForcedMaterial.mDiffuseColor.r = importance;
	1163	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	1164
	1165	ExportPolygon(polys[i]);
	1166	}
	1167	}
	1168	else
	1169	{
	1170	ExportPolygons(polys);
	1171	}
	1172
[372]	1173	CLEAR_CONTAINER(polys);
	1174	}
	1175
[449]	1176	void X3dExporter::ExportBspSplits(const BspTree &tree,
	1177	const bool exportDepth)
	1178	{
	1179	ExportBspNodeSplits(tree.GetRoot(),
	1180	tree.GetBoundingBox(),
	1181	exportDepth,
	1182	tree.GetEpsilon());
	1183	}
	1184
	1185	void X3dExporter::ExportBspSplits(const VspBspTree &tree,
	1186	const bool exportDepth)
	1187	{
	1188	ExportBspNodeSplits(tree.GetRoot(),
	1189	tree.GetBoundingBox(),
	1190	exportDepth,
	1191	tree.GetEpsilon());
	1192	}
	1193
[372]	1194	void X3dExporter::ExportBspSplitPlanes(const BspTree &tree)
	1195	{
	1196	std::stack<BspNode *> tStack;
	1197
	1198	tStack.push(tree.GetRoot());
	1199
	1200	PolygonContainer polys;
	1201
	1202	while (!tStack.empty())
	1203	{
	1204	// filter polygons donw the tree
	1205	BspNode *node = tStack.top();
	1206	tStack.pop();
	1207
	1208	if (!node->IsLeaf())
	1209	{
	1210	BspInterior interior = dynamic_cast<BspInterior >(node);
	1211
	1212	// bounded plane is added to the polygons
[449]	1213	polys.push_back(tree.GetBoundingBox().CrossSection(interior->GetPlane()));
[372]	1214
	1215	// push the children on the stack
	1216	tStack.push(interior->GetBack());
	1217	tStack.push(interior->GetFront());
	1218	}
	1219	}
	1220
	1221	ExportPolygons(polys);
	1222	CLEAR_CONTAINER(polys);
	1223	}
[440]	1224
	1225
[449]	1226	void X3dExporter::ExportGeometry(const ObjectContainer &objects)
[440]	1227	{
[449]	1228	for (int j = 0; j < objects.size(); ++ j)
	1229	ExportIntersectable(objects[j]);
[440]	1230	}
[449]	1231
	1232	void X3dExporter::ExportBspViewCellPartition(const VspBspTree &tree,
	1233	const int maxPvs)
	1234	{
	1235	ViewCellContainer viewCells;
	1236	tree.CollectViewCells(viewCells);
	1237
	1238	ViewCellContainer::const_iterator it, it_end = viewCells.end();
	1239
	1240	if (maxPvs > 0)
	1241	mUseForcedMaterial = true;
	1242
	1243	for (it = viewCells.begin(); it != it_end; ++ it)
	1244	{
	1245	if (maxPvs > 0)
	1246	{
	1247	mForcedMaterial.mDiffuseColor.b = 1.0f;
	1248	float importance = (float)(*it)->GetPvs().GetSize() / (float)maxPvs;
	1249
	1250	mForcedMaterial.mDiffuseColor.r = importance;
	1251	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	1252	}
	1253
	1254	if ((*it)->GetMesh())
	1255	ExportViewCell(*it);
	1256	else
	1257	{
	1258	PolygonContainer cell;
	1259	tree.ConstructGeometry(dynamic_cast<BspViewCell >(it), cell);
	1260
	1261	ExportPolygons(cell);
	1262	}
	1263	}
[450]	1264	}
	1265
	1266
	1267	bool
	1268	X3dExporter::ExportRssTree2(const RssTree &tree,
	1269	const Vector3 direction
	1270	)
	1271	{
	1272	stack<RssTreeNode *> tStack;
	1273
	1274
	1275	mUseForcedMaterial = true;
	1276
	1277	Vector3 dirParam;
	1278
	1279	dirParam.x = VssRay::GetDirParam(0, Normalize(direction));
	1280	dirParam.y = VssRay::GetDirParam(1, Normalize(direction));
	1281
	1282	float maxImportance = 0.0f;
	1283	tStack.push(tree.GetRoot());
	1284	while (!tStack.empty()) {
	1285
	1286	RssTreeNode *node = tStack.top();
	1287	tStack.pop();
	1288
	1289	if (!node->IsLeaf()) {
	1290	RssTreeInterior interior = (RssTreeInterior )node;
	1291	if (interior->axis < 3) {
	1292	tStack.push(interior->front);
	1293	tStack.push(interior->back);
	1294	} else {
	1295	if (dirParam[interior->axis-3] < interior->position)
	1296	tStack.push(interior->back);
	1297	else
	1298	tStack.push(interior->front);
	1299	}
	1300	} else {
	1301	RssTreeLeaf leaf = (RssTreeLeaf )node;
	1302	if (tree.ValidLeaf(leaf)) {
	1303	float i = leaf->GetImportance();
	1304	if (i > maxImportance)
	1305	maxImportance = i;
	1306	}
	1307	}
	1308	}
	1309
	1310	tStack.push(tree.GetRoot());
	1311	while (!tStack.empty()) {
	1312
	1313	RssTreeNode *node = tStack.top();
	1314	tStack.pop();
	1315
	1316
	1317	if (!node->IsLeaf()) {
	1318	RssTreeInterior interior = (RssTreeInterior )node;
	1319	if (interior->axis < 3) {
	1320	tStack.push(interior->front);
	1321	tStack.push(interior->back);
	1322	} else {
	1323	if (dirParam[interior->axis-3] < interior->position)
	1324	tStack.push(interior->back);
	1325	else
	1326	tStack.push(interior->front);
	1327	}
	1328	} else {
	1329	RssTreeLeaf leaf = (RssTreeLeaf )node;
	1330	if (tree.ValidLeaf(leaf)) {
	1331	AxisAlignedBox3 box;
	1332	box = tree.GetShrankedBBox(leaf);
	1333	Mesh *mesh = new Mesh;
	1334	AddBoxToMesh(box, mesh);
	1335
	1336	// get 4 corners of the ray directions
	1337
	1338	mForcedMaterial.mDiffuseColor.b = 1.0f;
	1339	mForcedMaterial.mDiffuseColor.r = leaf->GetImportance()/maxImportance;
	1340	mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
	1341
	1342	ExportMesh(mesh);
	1343	delete mesh;
	1344	}
	1345	}
	1346	}
	1347
	1348	mUseForcedMaterial = false;
	1349
	1350	return true;
	1351	}
[459]	1352
	1353
	1354	void
	1355	X3dExporter::ExportViewpoint(const Vector3 &point,
	1356	const Vector3 &direction)
	1357	{
	1358	stream<<"<Viewpoint "<<endl;
	1359
	1360	stream<<"position=\""<<point.x<<" "<<point.y<<" "<<point.z<<"\""<<endl;
	1361	// stream<<"orientation "<<direction.x<<direction.y<<direction.z<<endl;
	1362
	1363	stream<<">"<<endl;
	1364	stream<<"</Viewpoint>"<<endl;
	1365
	1366	}

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

Download in other formats: