VRUT::VRMLWriter Class Reference

Class for export scene to VRML file. More...

#include <vrmlwriter.h>

List of all members.

Public Member Functions
	VRMLWriter (wxBufferedOutputStream *_outputStream, const Scene *_scene, const wxString &_fname)
	~VRMLWriter ()
	Class destructor.
void	Write (bool hFlag, bool _extraCams)
	Write VRML stream.
Private Member Functions
void	ExportFileInfo ()
void	ExportWorldInfo ()
void	ExportNode1 (const SceneNode *node, wxString *tabs)
void	ExportNode2 (const SceneNode *node, wxString *tabs, bool det)
void	ExportGeometry (const SceneNode *node, wxString *tabs, bool det)
void	ExportIndexedFaceSet (const SceneNode *node, wxString *tabs, bool det, bool outputTexCoord)
void	ExportIndexedLineSet (const SceneNode *node, wxString *tabs)
void	ExportPointSet (const SceneNode *node, wxString *tabs)
bool	ExportAppearance (const SceneNode *node, wxString *tabs)
void	ExportCamera (const SceneNode *node, wxString *tabs)
void	ExportCameras ()
void	ExportGeneralLight (const SceneNode *node, wxString *tabs)
void	ExportOmniLight (const Light *light, const SceneNode *node, wxString *tabs)
void	ExportDirectionalLight (const Light *light, const SceneNode *node, wxString *tabs)
void	ExportSpotLight (const Light *light, const SceneNode *node, wxString *tabs)
bool	ExportTransform (const SceneNode *node, wxString *tabs, bool det)
void	AngAxisFromQa (const Quat &q, float *ang, vector3 &axis)
Private Attributes
wxBufferedOutputStream *	outputStream
	Output stream.
const Scene *	scene
	Scene container to be saved.
const wxString	fname
TextWriter *	tw
float	maxBoundDistance
int	mode
bool	ccw
bool	extraCams

---

Detailed Description

Class for export scene to VRML file.

Definition at line 26 of file vrmlwriter.h.

---

Constructor & Destructor Documentation

VRMLWriter::VRMLWriter	(	wxBufferedOutputStream *	_outputStream,
		const Scene *	_scene,
		const wxString &	_fname
	)

Class constructor

Parameters:

[in]	_outputStream	Stream to write data to
[in]	_scene	Scene to save

Definition at line 65 of file vrmlwriter.cpp.

       : scene(_scene), outputStream(_outputStream), fname(_fname)
{
       tw = new TextWriter(outputStream);
       maxBoundDistance = 0.0f;
       mode = 1;     // 0 - standard VRML, 1 - extended VRML
       ccw = true;
       extraCams = false;
}

VRMLWriter::~VRMLWriter

(

)

Class destructor.

Is called by wxWidgets itself on wxApp end but it doesn't work in dynamic library

Definition at line 76 of file vrmlwriter.cpp.

{
       delete tw;
}

---

Member Function Documentation

void VRMLWriter::Write	(	bool	hFlag,
		bool	_extraCams
	)

Write VRML stream.

Definition at line 83 of file vrmlwriter.cpp.

{
       if(hFlag) mode = 1;
       else mode = 0;
       extraCams = _extraCams;

       ccw = true;
       wxString tabs = wxT("");

       tw->SetOutputStream(outputStream);
       LOGVERBOSE(wxT("<VRMLWriter>Inside VRMLWriter::Write."));

       if (!scene->GetBVH())
       {
              LOGERROR(wxT("<VRMLWriter>Cannot initialize BVH, maxBoundDistance = 10000 forced."));
              maxBoundDistance = 10000;
       }
       else
       {
              VECTOR3 maxbound = scene->GetBVH()->GetRoot()->GetAABB()->MaxBound;
              VECTOR3 minbound = scene->GetBVH()->GetRoot()->GetAABB()->MinBound;
              maxBoundDistance = sqrt((maxbound.x-minbound.x)*(maxbound.x-minbound.x) + 
                     (maxbound.y-minbound.y)*(maxbound.y-minbound.y) + (maxbound.z-minbound.z)*(maxbound.z-minbound.z));
       }


       ExportFileInfo();
       ExportWorldInfo();


       const SceneNode::NodeIDList *children = scene->GetNode(scene->GetRootID())->GetChildren();
       for (SceneNode::NodeIDList::const_iterator it = children->begin() ; it != children->end(); it++)
       {
              const SceneNode * child = scene->GetNode(*it);
              //first expansion of the root node - exports cameras and lights
              ExportNode1(child, &tabs);
       }

       if(extraCams)
       {
              ExportCameras();
       }

       for (SceneNode::NodeIDList::const_iterator it = children->begin() ; it != children->end(); it++)
       {
              const SceneNode * child = scene->GetNode(*it);
              //second expansion of the root node - exports geometry
              ExportNode2(child, &tabs, true);
       }
       outputStream->Sync();
}

void VRMLWriter::ExportFileInfo

(

)

[private]

Definition at line 136 of file vrmlwriter.cpp.

{
       if(mode == 0) tw->Write("#VRML V2.0 utf8\n\n");
       else tw->Write("#VRML V2.0 utf8 VRUTexporter\n\n");
       tw->Write("#Produced by VRUT VRML97 exporter\n");
       tw->Write("#Date: ")->Write(wxDateTime::Now().FormatDate())->Write("\n\n");
}

void VRMLWriter::ExportWorldInfo

(

)

[private]

Definition at line 145 of file vrmlwriter.cpp.

{
       tw->Write("WorldInfo {\n");
       tw->Write("\ttitle \"\"\n");              //TO DO, if necessary
       tw->Write("\tinfo \"\"\n");        //TO DO, if necessary
       tw->Write("}\n\n");

       tw->Write("#file ")->Write(fname)->Write("\n\n");
}

void VRMLWriter::ExportNode1	(	const SceneNode *	node,
		wxString *	tabs
	)			[private]

Definition at line 156 of file vrmlwriter.cpp.

{
       if (node->IsOfType(SceneNode::ASSEMBLY))
       {
              //probably nothing to export 
       }
       else if (node->IsOfType(SceneNode::GEOMETRY))
       {             
              //nothing
       }
       else if (node->IsOfType(SceneNode::CAMERA))
       {
              //export camera
              ExportCamera(node, tabs);
       }
       else if (node->IsOfType(SceneNode::LIGHT))
       {
              //export light
              ExportGeneralLight(node, tabs);
       }
       else
       {
              LOGERROR(wxT("<VRMLWriter>Unknown node type"));
              return;
       }

       const SceneNode::NodeIDList *children = node->GetChildren();
       for (SceneNode::NodeIDList::const_iterator it = children->begin() ; it != children->end(); it++)
       {
              const SceneNode * child = scene->GetNode(*it);
              ExportNode1(child, tabs);
       }
}

void VRMLWriter::ExportNode2	(	const SceneNode *	node,
		wxString *	tabs,
		bool	det
	)			[private]

Definition at line 191 of file vrmlwriter.cpp.

{
       const SceneNode::NodeIDList *children = node->GetChildren();
       if(!children)
       { 
              return;
       }
       bool hasChildren = !children->empty();

       //node is camera or light && node has no children => node is useless
       if ((node->IsOfType(SceneNode::CAMERA) || node->IsOfType(SceneNode::LIGHT)) && !hasChildren)
       {
              return;
       }

       //create VRML Transform node
       tw->Write(*tabs)->Write("DEF ");
       if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());
       tw->Write(" Transform {\n");

       tabs->Append(wxT("\t"));

       //transformation of current node 
       bool det1 = ExportTransform(node, tabs, det);


       tw->Write(*tabs)->Write("children [\n");

       tabs->Append(wxT("\t"));


       //geometry node
       if (node->IsOfType(SceneNode::GEOMETRY))
       {
              //export geometry
              ExportGeometry(node, tabs, det);
       }

       for (SceneNode::NodeIDList::const_iterator it = children->begin() ; it != children->end(); it++)
       {
              const SceneNode * child = scene->GetNode(*it);
              ExportNode2(child, tabs, det1);
       }

       tabs->RemoveLast();
       tw->Write(*tabs)->Write("]\n");
       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");
}

void VRMLWriter::ExportGeometry	(	const SceneNode *	node,
		wxString *	tabs,
		bool	det
	)			[private]

Definition at line 244 of file vrmlwriter.cpp.

{      
       const GeometryNode * geomNode = (const GeometryNode *)node;
       const Geometry * geom = scene->GetGeometry(geomNode->GetGeometryID());
       const GeometryTriangles * geometry = (GeometryTriangles *)geom;
       GeometryTriangles::TriDescList::const_iterator indPrimType = geometry->triDescList.begin();

       tw->Write(*tabs)->Write("Shape {\n");

       tabs->Append(wxT("\t"));
       
       bool outputTexCoord = ExportAppearance(node, tabs);

       if(indPrimType == geometry->triDescList.end())
       {      
              tabs->RemoveLast();
              tw->Write(*tabs)->Write("}\n");
              return;
       }      
       switch (indPrimType->second)
       {
       case GeometryTriangles::POLYGON:
       case GeometryTriangles::QUADS:
       case GeometryTriangles::TRI_FAN:
       case GeometryTriangles::TRI_LIST:
       case GeometryTriangles::TRI_STRIP:
              ExportIndexedFaceSet(node, tabs, det, outputTexCoord);
              break;
       case GeometryTriangles::LINE_STRIP:
       case GeometryTriangles::LINES:
              ExportIndexedLineSet(node, tabs);
              break;
       case GeometryTriangles::POINTS:
              ExportPointSet(node, tabs);
              break;
       default:
              LOGERROR(wxT("<VRMLWriter>Unknown node type"));
       }

       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");
}

void VRMLWriter::ExportIndexedFaceSet	(	const SceneNode *	node,
		wxString *	tabs,
		bool	det,
		bool	outputTexCoord
	)			[private]

Definition at line 288 of file vrmlwriter.cpp.

{
       const GeometryNode * geomNode = (const GeometryNode *)node;
       const Geometry * geom = scene->GetGeometry(geomNode->GetGeometryID());
       const Material * material = scene->GetMaterial(geomNode->GetMaterialID());

       if (!geom || geom->type != Geometry::GEOMETRY_TRIANGLE)
       {
              return;
       }
       //else

       const GeometryTriangles * geometry = (GeometryTriangles *)geom;
       const std::vector<VECTOR3> * vertices = &geometry->vertices;
       const std::vector<VECTOR3> * normals = &geometry->normals;
       const std::vector<GeometryTriangles::TexCoord> * texCoords = &geometry->texCoords;
       const std::vector<GeometryTriangles::Indice> * indices = &geometry->indices;
       
       std::vector<int> indicesToWrite;
       size_t texCoordsCount = texCoords->size();
       size_t indSize = geometry->indices.size();
       size_t indiceIndex = 0;
       int modTabs = 0;

       tw->Write(*tabs)->Write("geometry ");
/*     if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());*/
       tw->Write(" IndexedFaceSet {\n");
       
       tabs->Append(wxT("\t"));

       if(det == true)
       {
              tw->Write(*tabs)->Write("ccw TRUE\n");
              if (material && (material->flags & Material::DOUBLE_SIDED))
                     tw->Write(*tabs)->Write("solid FALSE\n");
              else tw->Write(*tabs)->Write("solid TRUE\n");
       }
       else {
              //tw->Write("ccw FALSE\n");
              //tw->Write(*tabs)->Write("ccw TRUE\n");
              //tw->Write(*tabs)->Write("solid FALSE\n");
              tw->Write(*tabs)->Write("ccw FALSE\n");
              if (material && (material->flags & Material::DOUBLE_SIDED))
                     tw->Write(*tabs)->Write("solid FALSE\n");
              else tw->Write(*tabs)->Write("solid TRUE\n");
       }
       tw->Write(*tabs)->Write("convex TRUE\n");                      //implicitly TRUE
/*     tw->Write(*tabs);
       tw->Write("colorPerVertex FALSE\n");             //implicitly FALSE
       tw->Write(*tabs);
       tw->Write("color NULL\n");                       //implicitly no color (object has only material)
       tw->Write(*tabs);
       tw->Write("colorIndex []\n");                    //empty array*/

//COORD begin
       tw->Write(*tabs)->Write("coord ");
/*     if(node->GetName().size() > 0)
              tw->Write(VRMLName((const char*)node->GetName().mb_str(wxConvUTF8)));
       else tw->Write(node->GetID());*/
       tw->Write(" Coordinate {\n");

       tabs->Append(wxT("\t"));
       
       tw->Write(*tabs)->Write("point [");

       tabs->Append(wxT("\t"));
       
       for (size_t i=0; i<vertices->size()-1; i++)
       {
              if((i%8) == 0)
                     tw->Write("\n")->Write(*tabs);
#ifdef MIRROR_BY_VERTICES
              vector3 tmp;
              if(det) tmp = vertices->at(i);
              else tmp = -vertices->at(i);
#else
              vector3 tmp = vertices->at(i);
#endif
              tw->Write(tmp._v, 3, " ")->Write(", ");
       }
       if (vertices->size()>0)
       {
#ifdef MIRROR_BY_VERTICES
              vector3 tmp;
              if(det) tmp = vertices->at(vertices->size()-1);
              else tmp = -vertices->at(vertices->size()-1);
#else
              vector3 tmp = vertices->at(vertices->size()-1);
#endif
              tw->Write(tmp._v, 3, " ")->Write("\n");
       }

       tabs->RemoveLast();  
       tw->Write(*tabs)->Write("]\n");
       
       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");

       tw->Write(*tabs)->Write("coordIndex [");
       tabs->Append(wxT("\t"));

       bool ccw_ts = true;
       bool comma = false;
       for (GeometryTriangles::TriDescList::const_iterator indPrimType = geometry->triDescList.begin();
              indPrimType != geometry->triDescList.end(); indPrimType++)
       {
              GeometryTriangles::TriDescList::const_iterator endIndPrimType = indPrimType + 1;
              size_t endInd = ( endIndPrimType == geometry->triDescList.end() ? indSize : endIndPrimType->first );
              endInd = __min( endInd, indSize );
              modTabs = 0;
              ccw_ts = true;
              if(comma == false) comma = true;
              else {
                     tw->Write(", ");
              }
              switch (indPrimType->second)
              {
              case GeometryTriangles::TRI_LIST:
              //     tw->Write("\t#TRIANGLES\n");
                     if(indiceIndex+2 >= endInd)
                     {
                            comma = false;
                            break;
                     }
                     if(mode == 1) 
                     {
                            tw->Write("\n")->Write(*tabs)->Write("#TL");
                     }
                     while (indiceIndex+2 < endInd)
                     {
                            if((modTabs++)%4 == 0)
                            {
                                   tw->Write("\n")->Write(*tabs);
                            }
                            GeometryTriangles::Indice indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice)->Write(", ");
                            indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice)->Write(", ");
                            indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice);
                            if (indiceIndex < endInd)
                                   tw->Write(", -1, ");
                            else tw->Write(", -1");
                            indicesToWrite.push_back(-1);
                     }
                     break;
              case GeometryTriangles::QUADS:
              //     tw->Write("\t#QUADS\n");
                     if(indiceIndex+3 >= endInd)
                     {
                            comma = false;
                            break;
                     }
                     if(mode == 1) 
                     {
                            tw->Write("\n")->Write(*tabs)->Write("#QU");
                     }
                     while (indiceIndex+3 < endInd)
                     {
                            if((modTabs++)%4 == 0)
                            {
                                   tw->Write("\n")->Write(*tabs);
                            }
                            GeometryTriangles::Indice indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice)->Write(", ");
                            indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice)->Write(", ");
                            indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice)->Write(", ");
                            indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice);
                            if (indiceIndex < endInd)
                                   tw->Write(", -1, ");
                            else tw->Write(", -1");
                            indicesToWrite.push_back(-1);
                     }
                     break;
              case GeometryTriangles::POLYGON:
                     //tw->Write("\t#POLYGON");
                     if(indiceIndex >= endInd)
                     {
                            comma = false;
                            break;
                     }
                     if(mode == 1) 
                     {
                            tw->Write("\n")->Write(*tabs)->Write("#PO");
                     }
                     while (indiceIndex < endInd)
                     {
                            if((modTabs++)%4 == 0)
                            {
                                   tw->Write("\n")->Write(*tabs);
                            }
                            GeometryTriangles::Indice indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice)->Write(", ");
                     }
                     tw->Write("-1");
                     indicesToWrite.push_back(-1);
                     break;
              case GeometryTriangles::TRI_FAN:
              //     tw->Write("\t#TRIFAN\n");
                     if (indiceIndex > endInd-1)
                     {
                            comma = false;
                            break;
                     }{
                     if(mode == 1) 
                     {
                            tw->Write("\n")->Write(*tabs)->Write("#TF");
                     }
                     GeometryTriangles::Indice indice0 = indices->at(indiceIndex++);
                     indiceIndex++;
                     while (indiceIndex < endInd)
                     {
                            indiceIndex--;
                            if((modTabs++)%4 == 0)
                            {
                                   tw->Write("\n")->Write(*tabs);
                            }
                            indicesToWrite.push_back(indice0);
                            tw->Write(indice0)->Write(", ");
                            GeometryTriangles::Indice indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice)->Write(", ");
                            indice = indices->at(indiceIndex++);
                            indicesToWrite.push_back(indice);
                            tw->Write(indice);
                            if (indiceIndex < endInd)
                                   tw->Write(", -1, ");
                            else tw->Write(", -1");
                            indicesToWrite.push_back(-1);
                     }
                     }
                     break;
              case GeometryTriangles::TRI_STRIP:
              //     tw->Write("\t#TRIANGLE_STRIP\n");
                     if (indiceIndex > endInd-2)
                     {
                            comma = false;
                            break;
                     }
                     if(mode == 1) 
                     {
                            tw->Write("\n")->Write(*tabs)->Write("#TS");
                     }
                     indiceIndex += 2;
                     while (indiceIndex < endInd)
                     {
                            if(ccw_ts)
                            {
                                   indiceIndex -= 2;
                                   if((modTabs++)%4 == 0)
                                   {
                                          tw->Write("\n")->Write(*tabs);
                                   }
                                   GeometryTriangles::Indice indice = indices->at(indiceIndex++);
                                   indicesToWrite.push_back(indice);
                                   tw->Write(indice)->Write(", ");
                                   indice = indices->at(indiceIndex++);
                                   indicesToWrite.push_back(indice);
                                   tw->Write(indice)->Write(", ");
                                   indice = indices->at(indiceIndex++);
                                   indicesToWrite.push_back(indice);
                                   tw->Write(indice);
                                   if (indiceIndex < endInd)
                                          tw->Write(", -1, ");
                                   else tw->Write(", -1");
                                   indicesToWrite.push_back(-1);
                                   ccw_ts = false;
                            } else {
                                   indiceIndex -= 1;
                                   if((modTabs++)%4 == 0)
                                   {
                                          tw->Write("\n")->Write(*tabs);
                                   }
                                   GeometryTriangles::Indice indice = indices->at(indiceIndex--);
                                   indicesToWrite.push_back(indice);
                                   tw->Write(indice)->Write(", ");
                                   indice = indices->at(indiceIndex++);
                                   indiceIndex++;
                                   indicesToWrite.push_back(indice);
                                   tw->Write(indice)->Write(", ");
                                   indice = indices->at(indiceIndex++);
                                   indicesToWrite.push_back(indice);
                                   tw->Write(indice);
                                   if (indiceIndex < endInd)
                                          tw->Write(", -1, ");
                                   else tw->Write(", -1");
                                   indicesToWrite.push_back(-1);
                                   ccw_ts = true;
                            }
                     }
                     break;
              case GeometryTriangles::LINES:
                     LOGERROR(wxT("<VRMLWriter>Line type within face primitive type"));
                     break;
              case GeometryTriangles::LINE_STRIP:
                     LOGERROR(wxT("<VRMLWriter>Line type within face primitive type"));
                     break;
              case GeometryTriangles::POINTS:
                     LOGERROR(wxT("<VRMLWriter>Point type within face primitive type"));
                     break;
              default:
                     LOGERROR(wxT("<VRMLWriter>Unknown node type"));
              }
       }


       tabs->RemoveLast();

       tw->Write("\n")->Write(*tabs)->Write("]\n");
//COORD end

//TEX BEGIN
       if (texCoords->size()>0 && outputTexCoord)
       {
              tw->Write(*tabs)->Write("texCoord ");
       /*     if(node->GetName().size() > 0)
              tw->Write(VRMLName((const char*)node->GetName().mb_str(wxConvUTF8)));
              else tw->Write(node->GetID());*/
              tw->Write(" TextureCoordinate {\n");

              tabs->Append(wxT("\t"));
              tw->Write(*tabs)->Write("point [");
              tabs->Append(wxT("\t"));
              
              for (size_t i=0; i<texCoords->size()-1; i++)
              {
                     if((i%12) == 0)
                            tw->Write("\n")->Write(*tabs);
                     tw->Write(texCoords->at(i)._v, 2, " ")->Write(", ");
              }
              if (texCoords->size()>0)
                     tw->Write(texCoords->at(texCoords->size()-1)._v, 2, " ")->Write("\n");

              tabs->RemoveLast();
              tw->Write(*tabs)->Write("]\n");
              tabs->RemoveLast();
              tw->Write(*tabs)->Write("}\n");
              tw->Write(*tabs)->Write("texCoordIndex [");

              tabs->Append(wxT("\t"));

              if(indicesToWrite.size()>0 && texCoordsCount>0)
                     tw->Write(indicesToWrite.at(0));
              size_t endInd = __min(texCoordsCount, indicesToWrite.size());
              for(size_t it = 1; it < endInd; it++)
              {
                     tw->Write(", ");
                     if((it%24) == 0)
                            tw->Write("\n")->Write(*tabs);
                     tw->Write(indicesToWrite.at(it));
              }
              
              tabs->RemoveLast();
              tw->Write("\n")->Write(*tabs)->Write("]\n");
       }
//TEX END


//NORMALS begin
       tw->Write(*tabs)->Write("normalPerVertex TRUE\n");
       
       size_t normalsCount = normals->size();
       
       if (normalsCount > 0)
       {
              tw->Write(*tabs)->Write("normal ");
/*            if(node->GetName().size() > 0)
                     tw->Write(VRMLName((const char*)node->GetName().mb_str(wxConvUTF8)));
              else tw->Write(node->GetID());*/
              tw->Write(" Normal {\n");

              tabs->Append(wxT("\t"));           
              tw->Write(*tabs)->Write("vector [");
              tabs->Append(wxT("\t"));           

              for (size_t i=0; i<normalsCount-1; i++)
              {
                     if((i%8) == 0)
                            tw->Write("\n")->Write(*tabs);
                     tw->Write(normals->at(i)._v, 3, " ")->Write(", ");
              }
              tw->Write(normals->at(normalsCount-1)._v, 3, " ")->Write("\n");

              tabs->RemoveLast();
              tw->Write(*tabs)->Write("]\n");
              tabs->RemoveLast();
              tw->Write(*tabs)->Write("}\n");
              tw->Write(*tabs)->Write("normalIndex [");

              tabs->Append(wxT("\t"));
              modTabs = 0;
              indiceIndex = 0;

              if(indicesToWrite.size()>0)
                     tw->Write(indicesToWrite.at(0));
              for(size_t it = 1; it < indicesToWrite.size(); it++)
              {
                     tw->Write(", ");
                     if((it%24) == 0)
                            tw->Write("\n")->Write(*tabs);
                     tw->Write(indicesToWrite.at(it));
              }

              tabs->RemoveLast();
              tw->Write("\n")->Write(*tabs)->Write("]\n");
       }
//NORMALS end
       
       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");

}

void VRMLWriter::ExportIndexedLineSet	(	const SceneNode *	node,
		wxString *	tabs
	)			[private]

Definition at line 715 of file vrmlwriter.cpp.

{
       const GeometryNode * geomNode = (const GeometryNode *)node;
       const Geometry * geom = scene->GetGeometry(geomNode->GetGeometryID());
       const Material * material = scene->GetMaterial(geomNode->GetMaterialID());
       if (!geom || geom->type != Geometry::GEOMETRY_TRIANGLE)
       {
              return;
       }
       //else
       const GeometryTriangles * geometry = (GeometryTriangles *)geom;
       const std::vector<VECTOR3> * vertices = &geometry->vertices;
       const std::vector<GeometryTriangles::Indice> * indices = &geometry->indices;
       
//     std::vector<int> indicesToWrite;
       size_t indSize = geometry->indices.size();
       size_t indiceIndex = 0;
       int modTabs = 0;

       tw->Write(*tabs)->Write("geometry ");
/*     if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());*/
       tw->Write(" IndexedLineSet {\n");
       tabs->Append(wxT("\t"));

//COORD begin
       tw->Write(*tabs)->Write("coord ");
/*     if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());*/
       tw->Write(" Coordinate {\n");

       tabs->Append(wxT("\t"));    
       tw->Write(*tabs)->Write("point [");
       tabs->Append(wxT("\t"));    

       for (size_t i=0; i<vertices->size()-1; i++)
       {
              if((i%8) == 0)
                     tw->Write("\n")->Write(*tabs);
              tw->Write(vertices->at(i)._v, 3, " ")->Write(", ");
       }
       if (vertices->size()>0)
              tw->Write(vertices->at(vertices->size()-1)._v, 3, " ")->Write("\n");

       tabs->RemoveLast();
       tw->Write(*tabs)->Write("]\n");
       
       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");
       tw->Write(*tabs)->Write("coordIndex [\n");

       tabs->Append(wxT("\t"));
       bool ccw_ts = true;
       bool comma = false;
       for (GeometryTriangles::TriDescList::const_iterator indPrimType = geometry->triDescList.begin();
              indPrimType != geometry->triDescList.end(); indPrimType++)
       {
              GeometryTriangles::TriDescList::const_iterator endIndPrimType = indPrimType + 1;
              size_t endInd = ( endIndPrimType == geometry->triDescList.end() ? indSize : endIndPrimType->first );
              endInd = __min( endInd, indSize );
              modTabs = 0;
              ccw_ts = true;
              if(comma == false) comma = true;
              else {
                     tw->Write(", ");
              }
              switch (indPrimType->second)
              {
              case GeometryTriangles::TRI_LIST:
              case GeometryTriangles::QUADS:
              case GeometryTriangles::POLYGON:
              case GeometryTriangles::TRI_FAN:
              case GeometryTriangles::TRI_STRIP:
                     LOGERROR(wxT("<VRMLWriter>Face type within line primitive type"));
                     break;
              case GeometryTriangles::LINES:
                     if(indiceIndex+1 >= endInd)
                     {
                            comma = false;
                            break;
                     }
                     if(mode == 1) 
                     {
                            tw->Write("\n")->Write(*tabs)->Write("#LI");
                     }
                     while (indiceIndex+1 < endInd)
                     {
                            if((modTabs++)%8 == 0)
                            {
                                   tw->Write("\n")->Write(*tabs);
                            }
                            GeometryTriangles::Indice indice = indices->at(indiceIndex++);
                            tw->Write(indice)->Write(", ");
                            indice = indices->at(indiceIndex++);
                            tw->Write(indice);
                            if (indiceIndex < endInd)
                                   tw->Write(", -1, ");
                            else tw->Write(", -1");
                     }
                     break;
              case GeometryTriangles::LINE_STRIP:
                     if(indiceIndex+1 >= endInd)
                     {
                            comma = false;
                            break;
                     }
                     if(mode == 1) 
                     {
                            tw->Write("\n")->Write(*tabs)->Write("#LS");
                     }
                     while (indiceIndex < endInd)
                     {
                            if((modTabs++)%16 == 0)
                            {
                                   tw->Write("\n")->Write(*tabs);
                            }
                            GeometryTriangles::Indice indice = indices->at(indiceIndex++);
                            tw->Write(indice)->Write(", ");
                     }
                     tw->Write("-1");
                     break;
              case GeometryTriangles::POINTS:
                     LOGERROR(wxT("<VRMLWriter>Point type within line primitive type"));
                     break;
              default:
                     LOGERROR(wxT("<VRMLWriter>Unknown node type"));
              }
       }


       tabs->RemoveLast();
       tw->Write("\n")->Write(*tabs)->Write("]\n");
//COORD end

       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");
}

void VRMLWriter::ExportPointSet	(	const SceneNode *	node,
		wxString *	tabs
	)			[private]

Definition at line 856 of file vrmlwriter.cpp.

{
       const GeometryNode * geomNode = (const GeometryNode *)node;
       const Geometry * geom = scene->GetGeometry(geomNode->GetGeometryID());
       const Material * material = scene->GetMaterial(geomNode->GetMaterialID());
       if (!geom || geom->type != Geometry::GEOMETRY_TRIANGLE)
       {
              return;
       }
       //else
       const GeometryTriangles * geometry = (GeometryTriangles *)geom;
       const std::vector<VECTOR3> * vertices = &geometry->vertices;
       const std::vector<GeometryTriangles::Indice> * indices = &geometry->indices;
       
//     std::vector<int> indicesToWrite;
       size_t indSize = geometry->indices.size();
       size_t indiceIndex = 0;
       int modTabs = 0;

       tw->Write(*tabs)->Write("geometry ");
/*     if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());*/
       tw->Write(" PointSet {\n");
       
       tabs->Append(wxT("\t"));
/*     tw->Write(*tabs)->Write("coord DEF COORD");
       if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());*/
       tw->Write(" Coordinate {\n");

       tabs->Append(wxT("\t"));
       tw->Write(*tabs)->Write("point [");
       tabs->Append(wxT("\t"));
       
       for (size_t i=0; i<vertices->size()-1; i++)
       {
              if((i%8) == 0)
                     tw->Write("\n")->Write(*tabs);
              tw->Write(vertices->at(i)._v, 3, " ")->Write(", ");
       }
       if (vertices->size()>0)
              tw->Write(vertices->at(vertices->size()-1)._v, 3, " ")->Write("\n");

       tabs->RemoveLast();
       tw->Write(*tabs)->Write("]\n");
       
       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");

       //COLOR for each point - TO DO

       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");
}

bool VRMLWriter::ExportAppearance	(	const SceneNode *	node,
		wxString *	tabs
	)			[private]

!texture..!!

!!CHYBA PRI IMPORTU - '\' NAVIC

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Definition at line 914 of file vrmlwriter.cpp.

{
       bool outputTexCoord = true;
       const GeometryNode * geomNode = (const GeometryNode *)node;
       const Geometry * geom = scene->GetGeometry(geomNode->GetGeometryID());
       const Material * material = scene->GetMaterial(geomNode->GetMaterialID());

       if(!material) return false;

       tw->Write(*tabs)->Write("appearance ");
/*     if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());*/
       tw->Write(" Appearance {\n");

       tabs->Append(wxT("\t"));

       tw->Write(*tabs)->Write("material ");     
/*     if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());*/
       tw->Write(" Material {\n");

       //IF material exists
       if (material)
       {
              tabs->Append(wxT("\t"));

              vector3 diffuseColor = vector3(material->diffuse.x, material->diffuse.y, material->diffuse.z);
              vector3 specularColor = vector3(material->specular.x, material->specular.y, material->specular.z);
              vector3 emissiveColor = vector3(material->emission.x, material->emission.y, material->emission.z);
              tw->Write(*tabs)->Write("diffuseColor ")->Write(diffuseColor._v, 3, " ")->Write("\n");
              tw->Write(*tabs)->Write("ambientIntensity 0.2\n");      //TO DO
              tw->Write(*tabs)->Write("specularColor ")->Write(specularColor._v, 3, " ")->Write("\n");
              tw->Write(*tabs)->Write("emissiveColor ")->Write(emissiveColor._v, 3, " ")->Write("\n");
              tw->Write(*tabs)->Write("shininess ")->Write(material->shininess)->Write("\n");
              if (material->flags & Material::BLENDED)
              {
                     tw->Write(*tabs)->Write("transparency ")->Write(1 - material->diffuse.w)->Write("\n");
              }
              tabs->RemoveLast();
       }
       //ENDIF

       tw->Write(*tabs)->Write("}\n");


       if (material->imageName.size())
       {
              tw->Write(*tabs)->Write("texture ");
       /*     if(node->GetName().size() > 0)
                     tw->Write(VRMLName(node->GetName()));
              else tw->Write(node->GetID());*/
              tw->Write(" ImageTexture {\n");

              
//            tw->Write(*tabs)->Write(wxString::Format(wxT("\turl \"%s\"\n"), wxFileName(material->imageName).GetFullName().c_str()));
/*            if(material->imageName.find_first_of(wxFileName(material->imageName).GetPathSeparator()) == 0)
              {
                     wxString texName = material->imageName.After(wxFileName(material->imageName).GetPathSeparator());
                     while(texName.find_first_of(wxFileName(material->imageName).GetPathSeparator()) == 0)
                     {
                            texName = texName.After(wxFileName(material->imageName).GetPathSeparator());
                     }
                     tw->Write(*tabs)->Write("\turl \"")->Write(texName)->Write("\"\n");
              }
              else tw->Write(*tabs)->Write("\turl \"")->Write(material->imageName)->Write("\"\n");*/

              wxString texName = material->imageName;                 

              //zatim to resim takhle!!!!!!!!!!!!!!!!!!!!!!!
              texName = texName.After(wxFileName(texName).GetPathSeparator());

              wxString VRMLPath = fname;
              wxString texturePath = wxString();

              const wxChar * dot = new wxChar('.');

              //replace all '/' with path separators
              const wxChar * slash = new wxChar('/');
              const wxChar * pathSep = new wxChar(wxFileName(texName).GetPathSeparator());
              size_t rep1 = texName.Replace(wxString(*slash),wxString(*pathSep));
              size_t rep2 = VRMLPath.Replace(wxString(*slash),wxString(*pathSep));


              if(texName.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
              {
                     texName = texName.AfterFirst(wxFileName(texName).GetPathSeparator());
                     while(texName.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
                     {
                            texName = texName.AfterFirst(wxFileName(texName).GetPathSeparator());
                     }
              }
              //first char '.' and then PathSeparator(s)
              else if(texName.find_first_of(*dot) == 0)
              {
                     texName = texName.AfterFirst(*dot);
                     if(texName.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
                     {
                            texName = texName.AfterFirst(wxFileName(texName).GetPathSeparator());
                            while(texName.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
                            {
                                   texName = texName.AfterFirst(wxFileName(texName).GetPathSeparator());
                            }
                     }
              }

              if(VRMLPath.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
              {
                     VRMLPath = VRMLPath.AfterFirst(wxFileName(texName).GetPathSeparator());
                     while(VRMLPath.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
                     {
                            VRMLPath = VRMLPath.AfterFirst(wxFileName(texName).GetPathSeparator());
                     }
              }
              //first char '.' and then PathSeparator(s)
              else if(VRMLPath.find_first_of(*dot) == 0)
              {
                     VRMLPath = VRMLPath.After(*dot);
                     if(VRMLPath.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
                     {
                            VRMLPath = VRMLPath.After(wxFileName(texName).GetPathSeparator());
                            while(VRMLPath.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
                            {
                                   VRMLPath = VRMLPath.After(wxFileName(texName).GetPathSeparator());
                            }
                     }
              }


              if(texName.find_last_of(wxFileName(texName).GetPathSeparator()) > 0)
              {
                     texturePath = texName.BeforeLast(wxFileName(texName).GetPathSeparator());
              }

              if(VRMLPath.find_last_of(wxFileName(VRMLPath).GetPathSeparator()) > 0)
              {
                     VRMLPath = VRMLPath.BeforeLast(wxFileName(VRMLPath).GetPathSeparator());
              } else {
                     VRMLPath = wxString();
              }

              //texture's position relative to VRML file
              wxString texFileName;
              if(VRMLPath.empty())
              {
                     //VRML soubor je ve VRUT rootu
                     texFileName = texturePath;
                     texFileName = texFileName.Append(wxString(*pathSep));
                     texFileName = texFileName.Append(wxFileName(texName).GetFullName());
              } else {
                     if(VRMLPath == texturePath)
                     {
                            //VRML soubor a textura jsou v jednom adresari, ktery je podadresarem VRUT rootu
                            texFileName = wxFileName(texName).GetFullName();
                     } else if(texturePath.Contains(VRMLPath))
                     {
                            //textura je v podadresari adresare s VRML souborem, ten je v podadresari VRUT rootu
                            texFileName = VRMLPath.BeforeFirst(texturePath.at(texturePath.First(VRMLPath)));
                            texFileName = texFileName.append(texturePath.substr(texturePath.First(VRMLPath)+(int)VRMLPath.Len()));
                            if(texFileName.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
                            {
                                   texFileName = texFileName.AfterFirst(wxFileName(texName).GetPathSeparator());
                            }
                            texFileName = texFileName.Append(wxString(*pathSep));
                            texFileName = texFileName.Append(wxFileName(texName).GetFullName());
                     } else if(VRMLPath.Contains(texturePath))
                     {
                            //textura je v nadadresari adresare s VRML souborem, oba jsou podadresari VRUT rootu
                            wxString temp = VRMLPath.substr(VRMLPath.First(texturePath)+(int)texturePath.Len());
                            if(temp.find_first_of(wxFileName(texName).GetPathSeparator()) == 0)
                            {
                                   temp = temp.AfterFirst(wxFileName(texName).GetPathSeparator());
                            }
                            int num = (int)temp.Replace(wxString(*pathSep),wxString(*pathSep));
                            if(!temp.IsEmpty()) 
                            {
                                   texFileName = texFileName.Append(wxString::FromAscii(".."));
                                   texFileName = texFileName.Append(wxString(*pathSep));
                            }
                            for(int i = 0; i < num; i++) {
                                   texFileName = texFileName.Append(wxString::FromAscii(".."));
                                   texFileName = texFileName.Append(wxString(*pathSep));
                            }
                            texFileName = texFileName.Append(wxFileName(texName).GetFullName());
                     }
                     else {
                            //TO DO
                            int size = (int)VRMLPath.length();
                            int pos = 0;
                            if((int)texturePath.length() < size) size = (int)texturePath.length();
                            for(int i = 0; i < size; i++) {
                                   if(VRMLPath.at(i) != texturePath.at(i))
                                   {
                                          pos = i;
                                          break;
                                   }
                            }
                            wxString tempVRMLPath = VRMLPath.substr(pos);
                            wxString tempTexturePath = texturePath.substr(pos);
                            int num = (int)tempVRMLPath.Replace(wxString(*pathSep),wxString(*pathSep));
                            if(!tempVRMLPath.IsEmpty()) 
                            {
                                   texFileName = texFileName.Append(wxString::FromAscii(".."));
                                   texFileName = texFileName.Append(wxString(*pathSep));
                            }
                            for(int i = 0; i < num; i++) {
                                   texFileName = texFileName.Append(wxString::FromAscii(".."));
                                   texFileName = texFileName.Append(wxString(*pathSep));
                            }
                            texFileName = texFileName.Append(tempTexturePath);
                            texFileName = texFileName.Append(wxString(*pathSep));
                            texFileName = texFileName.Append(wxFileName(texName).GetFullName());
                     }
              }



              //write image name (including path)
              tw->Write(*tabs)->Write("\turl \"")->Write(texFileName)->Write("\"\n");
//            tw->Write(*tabs)->Write("\ttexPath \"")->Write(texturePath)->Write("\"\n");
//            tw->Write(*tabs)->Write("\tVRMLPath \"")->Write(VRMLPath)->Write("\"\n");

              tw->Write(*tabs)->Write("\trepeatS ");
//            if (material->texFlags & Material::TEX_UWRAP_REPEAT)
                     tw->Write(" TRUE\n");
//            else //if (material->texFlags & Material::TEX_UWRAP_CLAMP)
//                   tw->Write(" FALSE\n");
              tw->Write(*tabs)->Write("\trepeatT ");
//            if (material->texFlags & Material::TEX_VWRAP_REPEAT)
                     tw->Write(" TRUE\n");
//            else //if (material->texFlags & Material::TEX_VWRAP_CLAMP)
//                   tw->Write(" FALSE\n");
              tw->Write(*tabs)->Write("}\n");

              if ((material->texFlags & Material::TEX_GEN_FUNC_U_SPHERE) || (material->texFlags & Material::TEX_GEN_FUNC_V_SPHERE))
                     outputTexCoord = false;
       }      

/*
       tw->Write(*tabs);
       tw->Write("textureTransforml DEF TEXTURETRANSFORM");
       tw->Write(node->GetID());
       //tw->Write(node->GetName().mb_str());
       tw->Write(" TextureTransform {\n");
       


       tw->Write(*tabs);
       tw->Write("}\n");
*/
       tabs->RemoveLast();
       tw->Write(*tabs)->Write("}\n");

       return outputTexCoord;
}

void VRMLWriter::ExportCamera	(	const SceneNode *	node,
		wxString *	tabs
	)			[private]

Definition at line 1174 of file vrmlwriter.cpp.

{
       scene->UpdateTransformation(node->GetID());
       const MATRIX * m = node->GetWorldTransMatrix();
       vector3 position = m->ExtractTranslation();
       AffineParts parts;   
       Quat q;
    float ang;
       vector3 axis;
       vector4 rotation;
       float matToDecomp[4][4];
       for(int i=0,j=0; i<3; i++)
       {
              matToDecomp[0][i] = m->_m[j++];
              matToDecomp[1][i] = m->_m[j++];
              matToDecomp[2][i] = m->_m[j++];
              matToDecomp[3][i] = m->_m[j++];
       }

       decomp_affine(matToDecomp, &parts);
    
       q = parts.q;
    AngAxisFromQa(q, &ang, axis);
       rotation = vector4(axis.x, axis.y, axis.z, ang);        //-ang?

       Camera * camera = (Camera *) node;
       float FOV = (camera->GetFOV()*M_PI)/180;
       tw->Write("DEF VIEWPOINT");
       if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       /*else*/ tw->Write(node->GetID());
       tw->Write(" Viewpoint {\n");
       tw->Write("\tposition ")->Write(position._v, 3, " ");   
       tw->Write("\n\torientation ")->Write(rotation._v, 4, " ");     
       tw->Write("\n\tfieldOfView ")->Write(FOV);
       tw->Write("\n\tdescription \"")->Write(node->GetID())->Write("\"");
       tw->Write("\n}\n\n");
}

void VRMLWriter::ExportCameras

(

)

[private]

Definition at line 1214 of file vrmlwriter.cpp.

{      
       if (!scene->GetBVH())
       {
              LOGERROR(wxT("<VRMLWriter>Cannot initialize BVH, extra cameras not created."));
              return;
       }
       VECTOR3 minBound = scene->GetBVH()->GetRoot()->GetAABB()->MinBound;
       VECTOR3 maxBound = scene->GetBVH()->GetRoot()->GetAABB()->MaxBound;
       VECTOR3 tmpMin = minBound;
       VECTOR3 tmpMax = maxBound;
       float tmpDist1 = 0.0f;
       float tmpDist2 = 0.0f;
       float FOV = (45.0f*M_PI)/180;
       VECTOR3 position;
       VECTOR4 rotation;

       //Z direction
       tmpMin.z = maxBound.z;
       tmpDist1 = sqrtf((tmpMax.x-tmpMin.x)*(tmpMax.x-tmpMin.x) + (tmpMax.y-tmpMin.y)*(tmpMax.y-tmpMin.y));
       tmpDist2 = (tmpDist1/2)*tan((45.0f*M_PI)/180)*1.5f;
       position = VECTOR3(((tmpMax.x-tmpMin.x)/2)+tmpMin.x, ((tmpMax.y-tmpMin.y)/2)+tmpMin.y, tmpMax.z+tmpDist2);
       tw->Write("DEF VIEWPOINT_ZDIR");
       tw->Write(" Viewpoint {\n");
       tw->Write("\tposition ")->Write(position._v, 3, " ");          
       tw->Write("\n\tfieldOfView ")->Write(FOV);
       tw->Write("\n\tdescription \"ZDIR\"");
       tw->Write("\n}\n\n");

       //X direction
       tmpMin = minBound;
       tmpMax = maxBound;
       tmpMin.x = tmpMax.x;
       tmpDist1 = sqrtf((tmpMax.z-tmpMin.z)*(tmpMax.z-tmpMin.z) + (tmpMax.y-tmpMin.y)*(tmpMax.y-tmpMin.y));
       tmpDist2 = (tmpDist1/2)*tan((45.0f*M_PI)/180)*1.5f;
       position.x = tmpMax.x+tmpDist2;
       position.y = ((tmpMax.y-tmpMin.y)/2)+tmpMin.y;
       position.z = ((tmpMax.z-tmpMin.z)/2)+tmpMin.z;
       rotation = VECTOR4(0.0f, 1.0f, 0.0f, M_PI/2);
       tw->Write("DEF VIEWPOINT_XDIR");
       tw->Write(" Viewpoint {\n");
       tw->Write("\tposition ")->Write(position._v, 3, " ");   
       tw->Write("\n\torientation ")->Write(rotation._v, 4, " ");     
       tw->Write("\n\tfieldOfView ")->Write(FOV);
       tw->Write("\n\tdescription \"XDIR\"");
       tw->Write("\n}\n\n");

       //Y direction
       tmpMin = minBound;
       tmpMax = maxBound;
       tmpMin.y = tmpMax.y;
       tmpDist1 = sqrtf((tmpMax.z-tmpMin.z)*(tmpMax.z-tmpMin.z) + (tmpMax.x-tmpMin.x)*(tmpMax.x-tmpMin.x));
       tmpDist2 = (tmpDist1/2)*tan((45.0f*M_PI)/180)*1.5f;
       position.x = ((tmpMax.x-tmpMin.x)/2)+tmpMin.x;
       position.y = tmpMax.y+tmpDist2;
       position.z = ((tmpMax.z-tmpMin.z)/2)+tmpMin.z;
       rotation = VECTOR4(-1.0f, 0.0f, 0.0f, M_PI/2);
       tw->Write("DEF VIEWPOINT_YDIR");
       tw->Write(" Viewpoint {\n");
       tw->Write("\tposition ")->Write(position._v, 3, " ");   
       tw->Write("\n\torientation ")->Write(rotation._v, 4, " ");     
       tw->Write("\n\tfieldOfView ")->Write(FOV);
       tw->Write("\n\tdescription \"YDIR\"");
       tw->Write("\n}\n\n");

       //-Z direction
       tmpMin = minBound;
       tmpMax = maxBound;
       tmpMax.z = tmpMin.z;
       tmpDist1 = sqrtf((tmpMax.x-tmpMin.x)*(tmpMax.x-tmpMin.x) + (tmpMax.y-tmpMin.y)*(tmpMax.y-tmpMin.y));
       tmpDist2 = (tmpDist1/2)*tan((45.0f*M_PI)/180)*1.5f;
       position.x = ((tmpMax.x-tmpMin.x)/2)+tmpMin.x;
       position.y = ((tmpMax.y-tmpMin.y)/2)+tmpMin.y;
       position.z = tmpMax.z-tmpDist2;
       rotation = VECTOR4(0.0f, 1.0f, 0.0f, M_PI);
       tw->Write("DEF VIEWPOINT__ZDIR");
       tw->Write(" Viewpoint {\n");
       tw->Write("\tposition ")->Write(position._v, 3, " ");   
       tw->Write("\n\torientation ")->Write(rotation._v, 4, " ");            
       tw->Write("\n\tfieldOfView ")->Write(FOV);
       tw->Write("\n\tdescription \"_ZDIR\"");
       tw->Write("\n}\n\n");

       //-X direction
       tmpMin = minBound;
       tmpMax = maxBound;
       tmpMax.x = tmpMin.x;
       tmpDist1 = sqrtf((tmpMax.z-tmpMin.z)*(tmpMax.z-tmpMin.z) + (tmpMax.y-tmpMin.y)*(tmpMax.y-tmpMin.y));
       tmpDist2 = (tmpDist1/2)*tan((45.0f*M_PI)/180)*1.5f;
       position.x = tmpMax.x-tmpDist2;
       position.y = ((tmpMax.y-tmpMin.y)/2)+tmpMin.y;
       position.z = ((tmpMax.z-tmpMin.z)/2)+tmpMin.z;
       rotation = VECTOR4(0.0f, -1.0f, 0.0f, M_PI/2);
       tw->Write("DEF VIEWPOINT__XDIR");
       tw->Write(" Viewpoint {\n");
       tw->Write("\tposition ")->Write(position._v, 3, " ");   
       tw->Write("\n\torientation ")->Write(rotation._v, 4, " ");     
       tw->Write("\n\tfieldOfView ")->Write(FOV);
       tw->Write("\n\tdescription \"_XDIR\"");
       tw->Write("\n}\n\n");

       //-Y direction
       tmpMin = minBound;
       tmpMax = maxBound;
       tmpMax.y = tmpMin.y;
       tmpDist1 = sqrtf((tmpMax.z-tmpMin.z)*(tmpMax.z-tmpMin.z) + (tmpMax.x-tmpMin.x)*(tmpMax.x-tmpMin.x));
       tmpDist2 = (tmpDist1/2)*tan((45.0f*M_PI)/180)*1.5f;
       position.x = ((tmpMax.x-tmpMin.x)/2)+tmpMin.x;
       position.y = tmpMax.y-tmpDist2;
       position.z = ((tmpMax.z-tmpMin.z)/2)+tmpMin.z;
       rotation = VECTOR4(1.0f, 0.0f, 0.0f, M_PI/2);
       tw->Write("DEF VIEWPOINT__YDIR");
       tw->Write(" Viewpoint {\n");
       tw->Write("\tposition ")->Write(position._v, 3, " ");   
       tw->Write("\n\torientation ")->Write(rotation._v, 4, " ");     
       tw->Write("\n\tfieldOfView ")->Write(FOV);
       tw->Write("\n\tdescription \"_YDIR\"");
       tw->Write("\n}\n\n");

}

void VRMLWriter::ExportGeneralLight	(	const SceneNode *	node,
		wxString *	tabs
	)			[private]

Definition at line 1336 of file vrmlwriter.cpp.

{
       scene->UpdateTransformation(node->GetID());
       const Light * light = ((LightNode *) node)->GetLight();
       switch(light->type) {
       case Light::OMNI:
              ExportOmniLight(light, node, tabs);
              break;
       case Light::DIRECTIONAL:
              ExportDirectionalLight(light, node, tabs);
              break;
       case Light::SPOTLIGHT:
              ExportSpotLight(light, node, tabs);
              break;
       case Light::UNKNOWN:
              LOGERROR(wxT("<VRMLWriter>Unknown light type"));
              break;
       default:
              LOGERROR(wxT("<VRMLWriter>Unexpected light type"));
              return;
       }
}

void VRMLWriter::ExportOmniLight	(	const Light *	light,
		const SceneNode *	node,
		wxString *	tabs
	)			[private]

Definition at line 1361 of file vrmlwriter.cpp.

{
       tw->Write("DEF ");
       if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());
       tw->Write(" PointLight {\n");
       tw->Write("\ton TRUE\n\tintensity ")->Write(1);  //is intensity attribute of Light node?
       vector3 diffuse_light = vector3(light->diffuse.x, light->diffuse.y, light->diffuse.z);
       tw->Write("\n\tcolor ")->Write(diffuse_light._v, 3, " ");
       tw->Write("\n\tlocation ")->Write(light->position._v, 3, " ");
       tw->Write("\n\tradius ")->Write(maxBoundDistance);
       tw->Write("\n\tattenuation 1 0 0\n");     //implicitly no attenuation
       tw->Write("}\n\n");
}

void VRMLWriter::ExportDirectionalLight	(	const Light *	light,
		const SceneNode *	node,
		wxString *	tabs
	)			[private]

Definition at line 1378 of file vrmlwriter.cpp.

{
       tw->Write("DEF ");
       if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());
       tw->Write(" DirectionalLight {\n");
       tw->Write("\ton TRUE\n\tintensity ")->Write(1);  //is intensity attribute of Light node?
       vector3 diffuse_light = vector3(light->diffuse.x, light->diffuse.y, light->diffuse.z);
       tw->Write("\n\tcolor ")->Write(diffuse_light._v, 3, " ");
       tw->Write("\n\tdirection ")->Write(light->direction._v, 3, " ");             
       tw->Write("\n}\n\n");
}

void VRMLWriter::ExportSpotLight	(	const Light *	light,
		const SceneNode *	node,
		wxString *	tabs
	)			[private]

Definition at line 1393 of file vrmlwriter.cpp.

{
       tw->Write("DEF ");
       if(node->GetName().size() > 0)
              tw->Write(VRMLName(node->GetName()));
       else tw->Write(node->GetID());
       tw->Write(" SpotLight {\n");
       tw->Write("\ton TRUE\n");
       tw->Write("\tintensity ")->Write(1);             //is intensity attribute of Light node?
       vector3 diffuse_light = vector3(light->diffuse.x, light->diffuse.y, light->diffuse.z);
       tw->Write("\n\tcolor ")->Write(diffuse_light._v, 3, " ");
       tw->Write("\n\tlocation ")->Write(light->position._v, 3, " "); 
       tw->Write("\n\tdirection ")->Write(light->direction._v, 3, " ");
       //tw->Write("\n\tbeamWidth ");     //what is angle???????????
       //tw->Write(light->angle);
       //tw->Write("\n\tcutOffAngle ");   //what is exponent???????
       //tw->Write(light->exponent);
       tw->Write("\n\tradius ")->Write(maxBoundDistance);
       tw->Write("\n\tattenuation 1 0 0\n");     //implicitly no attenuation
       tw->Write("}\n\n");
}

bool VRMLWriter::ExportTransform	(	const SceneNode *	node,
		wxString *	tabs,
		bool	det
	)			[private]

Definition at line 1416 of file vrmlwriter.cpp.

{
       //firstly, we have to update transformation
       scene->UpdateTransformation(node->GetID());

       const MATRIX * m = node->GetLocalTransMatrix();
//     vector3 translation = m->ExtractTranslation();
       AffineParts parts;   
       Quat q;
    float ang;
       vector3 axis, scale;
       vector4 scaleOrientation, rotation;
       float matToDecomp[4][4];
/*     for(int i=0,j=0; i<4; i++)
       {
              matToDecomp[i][0] = m->_m[j++];
              matToDecomp[i][1] = m->_m[j++];
              matToDecomp[i][2] = m->_m[j++];
              matToDecomp[i][3] = m->_m[j++];
       }*/

       for(int i=0,j=0; i<4; i++)
       {
              matToDecomp[0][i] = m->_m[j++];
              matToDecomp[1][i] = m->_m[j++];
              matToDecomp[2][i] = m->_m[j++];
              matToDecomp[3][i] = m->_m[j++];
       }

       decomp_affine(matToDecomp, &parts);
    
       vector3 translation = vector3(parts.t.x, parts.t.y, parts.t.z);
       q = parts.q;
    AngAxisFromQa(q, &ang, axis);
       rotation = vector4(axis.x, axis.y, axis.z, ang);        //-ang?

       q = parts.u;
    AngAxisFromQa(q, &ang, axis);
       scale = vector3(parts.k.x, parts.k.y, parts.k.z);
       scaleOrientation = vector4(axis.x, axis.y, axis.z, ang);              //-ang?

#ifndef MIRROR_BY_VERTICES
       if(parts.f < 0.0f) scale = -scale;                             //mirror by scale
#else
       if(!det) translation = -translation;
#endif
       
       if(translation != vector3(0.0f, 0.0f, 0.0f))
              tw->Write(*tabs)->Write("translation ")->Write(translation._v, 3, " ")->Write("\n");
       if((rotation.w != 0.0f) || (rotation.w != -0.0f))
              tw->Write(*tabs)->Write("rotation ")->Write(rotation._v, 4, " ")->Write("\n");
       if(scale != vector3(1.0f, 1.0f, 1.0f))
              tw->Write(*tabs)->Write("scale ")->Write(scale._v, 3, " ")->Write("\n");
       if(scaleOrientation.w != 0.0f && scaleOrientation.w != -0.0f)
              tw->Write(*tabs)->Write("scaleOrientation ")->Write(scaleOrientation._v, 4, " ")->Write("\n");

       return parts.f > 0.0f;
}

void VRMLWriter::AngAxisFromQa	(	const Quat &	q,
		float *	ang,
		vector3 &	axis
	)			[private]

Definition at line 1476 of file vrmlwriter.cpp.

                                                                       {
       double omega, s, x, y, z, w, l, c;
       x = (double)q.x;     
       y = (double)q.y;     
       z = (double)q.z;     
       w = (double)q.w;     
       l =  sqrt(x*x + y*y + z*z + w*w);
       if (l == 0.0) {
              w = 1.0;      
              y = z = x = 0.0;
              }
       else { 
              c = 1.0/l;
              x *= c;
              y *= c;
              z *= c;
              w *= c;
              }
       omega = acos(w);
       *ang = (float)(2.0*omega);
       s = sin(omega);      
       if (fabs(s) > 0.000001f)
    {
        axis.x = (float)(x / s);
              axis.y = (float)(y / s);
              axis.z = (float)(z / s);
    }
       else
        axis = vector3(0,0,0);
}

---

Member Data Documentation

wxBufferedOutputStream* VRUT::VRMLWriter::outputStream [private]

Output stream.

Definition at line 30 of file vrmlwriter.h.

const Scene* VRUT::VRMLWriter::scene [private]

Scene container to be saved.

Definition at line 32 of file vrmlwriter.h.

const wxString VRUT::VRMLWriter::fname [private]

Definition at line 33 of file vrmlwriter.h.

TextWriter* VRUT::VRMLWriter::tw [private]

Definition at line 34 of file vrmlwriter.h.

float VRUT::VRMLWriter::maxBoundDistance [private]

Definition at line 35 of file vrmlwriter.h.

int VRUT::VRMLWriter::mode [private]

Definition at line 36 of file vrmlwriter.h.

bool VRUT::VRMLWriter::ccw [private]

Definition at line 37 of file vrmlwriter.h.

bool VRUT::VRMLWriter::extraCams [private]

Definition at line 38 of file vrmlwriter.h.

---

The documentation for this class was generated from the following files:

• /cygdrive/d/src/svn/vrut/trunk/modules/iovrml/vrmlwriter.h
• /cygdrive/d/src/svn/vrut/trunk/modules/iovrml/vrmlwriter.cpp