VRUT::FHSWriter Class Reference

Class for writing FHS files. More...

#include <fhswriter.h>

List of all members.

Public Member Functions
	FHSWriter (wxBufferedOutputStream *_outputStream, const Scene *_scene)
	~FHSWriter ()
	Class destructor.
void	Write ()
	Write FHS stream.
Private Member Functions
void	WriteMatrix (const SceneNode *node, std::string tabs)
	Write node matrix.
void	WriteAssemblyBody (const SceneNode *node, std::string tabs)
	Write assembly body.
void	WriteAssembly (const SceneNode *node, std::string tabs)
	Write assembly.
void	WriteGeometry (const GeometryNode *node, std::string tabs)
	Write geometry.
void	WriteLight (const LightNode *node, std::string tabs)
	Write light.
Private Attributes
wxBufferedOutputStream *	outputStream
	Output stream.
const Scene *	scene
	Scene container to be saved.
TextWriter *	textWriter
	TextWriter support class.

---

Detailed Description

Class for writing FHS files.

Definition at line 23 of file fhswriter.h.

---

Constructor & Destructor Documentation

FHSWriter::FHSWriter	(	wxBufferedOutputStream *	_outputStream,
		const Scene *	_scene
	)

Class constructor

Parameters:

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

Definition at line 19 of file fhswriter.cpp.

                                                                                 : scene(_scene), outputStream(_outputStream)
{
       textWriter = new TextWriter(outputStream);
}

FHSWriter::~FHSWriter

(

)

Class destructor.

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

Definition at line 25 of file fhswriter.cpp.

{
       SAFE_DELETE(textWriter);
}

---

Member Function Documentation

void FHSWriter::WriteMatrix	(	const SceneNode *	node,
		std::string	tabs
	)			[private]

Write node matrix.

Definition at line 31 of file fhswriter.cpp.

{
       MATRIX transf(*(node->GetLocalTransMatrix()));
       if (transf.IsUnit())
              return;
       textWriter->Write((tabs+"MATRIX (").c_str())->Write(transf._m, 4, ", ");
       textWriter->Write((",\n"+tabs+"        ").c_str())->Write(&transf._m[4], 4, ", ");
       textWriter->Write((",\n"+tabs+"        ").c_str())->Write(&transf._m[8], 4, ", ");
       textWriter->Write((",\n"+tabs+"        ").c_str())->Write(&transf._m[12], 4, ", ")->Write(")\n");
}

void FHSWriter::WriteAssemblyBody	(	const SceneNode *	node,
		std::string	tabs
	)			[private]

Write assembly body.

Definition at line 42 of file fhswriter.cpp.

{
       const SceneNode::NodeIDList *children = node->GetChildren();
       for (SceneNode::NodeIDList::const_iterator it = children->begin() ; it != children->end(); it++)
       {
              const SceneNode * child = scene->GetNode(*it);
              switch (child->GetType())
              {
              case SceneNode::ASSEMBLY:
                     WriteAssembly(child, tabs);
                     break;
              case SceneNode::CAMERA:
                     break;
              case SceneNode::GEOMETRY:
                     WriteGeometry((GeometryNode*)child, tabs);
                     break;
              case SceneNode::LIGHT:
                     WriteLight((LightNode*)child, tabs);
                     break;
              default:
                     LOGERROR(wxT("not implemented ") + child->GetName());
              }
       }
}

void FHSWriter::WriteAssembly	(	const SceneNode *	node,
		std::string	tabs
	)			[private]

Write assembly.

Definition at line 67 of file fhswriter.cpp.

{
       textWriter->Write(tabs.c_str())->Write("ASSEMBLY \"")->Write(node->GetName())->Write("\"\n");
       if (!node->GetUid().IsEmpty())
              textWriter->Write(tabs.c_str())->Write("DESCX \"UID ")->Write(node->GetUid())->Write("\"\n");
       WriteMatrix(node, tabs);
       textWriter->Write(tabs.c_str())->Write("{\n");
       WriteAssemblyBody(node, tabs+"\t");
       textWriter->Write(tabs.c_str())->Write("}\n");
}

void FHSWriter::WriteGeometry	(	const GeometryNode *	node,
		std::string	tabs
	)			[private]

Write geometry.

Definition at line 78 of file fhswriter.cpp.

{
       textWriter->Write(tabs.c_str())->Write("GEOMETRY \"")->Write(node->GetName())->Write("\"\n");
       if (!node->GetUid().IsEmpty())
              textWriter->Write(tabs.c_str())->Write("DESCX \"UID ")->Write(node->GetUid())->Write("\"\n");
       if (node->GetMaterialID()!=MATERIAL_ID_NONE)
              textWriter->Write(tabs.c_str())->Write("USEMAT \"")->Write(scene->GetMaterial(node->GetMaterialID())->name)->Write("\"\n");

       WriteMatrix(node, tabs);

       const Geometry * geom = scene->GetGeometry(node->GetGeometryID());
       if (geom && geom->type == Geometry::GEOMETRY_TRIANGLE)
       {
              const GeometryTriangles * geometry = (GeometryTriangles *)geom;
              size_t indiceIndex = 0;
              size_t maxInd = geometry->indices.size();
              const std::vector<VECTOR3> * vertices = &geometry->vertices;
              const std::vector<VECTOR3> * normals = &geometry->normals;
              size_t normalsCount = normals->size();
              const std::vector<GeometryTriangles::TexCoord> * texCoords = &geometry->texCoords;
              size_t texCoordsCount = texCoords->size();
              const std::vector<GeometryTriangles::Indice> * indices = &geometry->indices;

              //write polypool
              textWriter->Write(tabs.c_str())->Write("POLYPOOL\n")->Write(tabs.c_str())->Write("{\n");
              for (size_t i=0; i<vertices->size(); i++)
              {
                     textWriter->Write(tabs.c_str())->Write("\tP=(")->Write(vertices->at(i)._v, 3, ", ");
                     if (i<normalsCount)
                            textWriter->Write(") N=(")->Write(normals->at(i)._v, 3, ", ");
                     if (i<texCoordsCount)
                            textWriter->Write(") T=(")->Write(texCoords->at(i)._v, 2, ", ");
                     textWriter->Write(")\n");
              }
              textWriter->Write(tabs.c_str())->Write("}\n")->Write(tabs.c_str())->Write("{\n");
              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() ? maxInd : endIndPrimType->first );
                     endInd = __min( endInd, maxInd );
                     textWriter->Write(tabs.c_str());
                     switch (indPrimType->second)
                     {
                     case GeometryTriangles::TRI_LIST:
                            textWriter->Write("\tTRIANGLES\n");
                            break;
                     case GeometryTriangles::QUADS:
                            textWriter->Write("\tQUADS\n");
                            break;
                     case GeometryTriangles::POLYGON:
                            textWriter->Write("\tPOLYGON\n");
                            break;
                     case GeometryTriangles::TRI_FAN:
                            textWriter->Write("\tTRIFAN\n");
                            break;
                     case GeometryTriangles::TRI_STRIP:
                            textWriter->Write("\tTRIANGLE_STRIP\n");
                            break;
                     case GeometryTriangles::LINES:
                            textWriter->Write("\tLINES\n");
                            break;
                     case GeometryTriangles::LINE_STRIP:
                            textWriter->Write("\tLINE_STRIP\n");
                            break;
                     case GeometryTriangles::POINTS:
                            textWriter->Write("\tPOINTS\n");
                            break;
                     default:
                            LOGERROR(wxT("<FHSWriter>Unknown primitive type"));
                     }
                     textWriter->Write(tabs.c_str())->Write("\t{\n")->Write(tabs.c_str())->Write("\t\t");
                     for ( ;       indiceIndex < endInd; indiceIndex++)
                     {
                            GeometryTriangles::Indice indice = indices->at(indiceIndex);
                            textWriter->Write("I");
                            if (indice < normalsCount)
                                   textWriter->Write("N");
                            if (indice < texCoordsCount)
                                   textWriter->Write("T");
                            textWriter->Write("=")->Write(indice);
                            if (indiceIndex < endInd-1)
                                   textWriter->Write(" ");
                     }
                     textWriter->Write("\n")->Write(tabs.c_str())->Write("\t}\n");
              }
              textWriter->Write(tabs.c_str())->Write("}\n");
       }
}

void FHSWriter::WriteLight	(	const LightNode *	node,
		std::string	tabs
	)			[private]

Write light.

Definition at line 168 of file fhswriter.cpp.

{
       textWriter->Write(tabs.c_str())->Write("LIGHT \"")->Write(node->GetName())->Write("\"\n");
       if (!node->GetUid().IsEmpty())
              textWriter->Write(tabs.c_str())->Write("DESCX \"UID ")->Write(node->GetUid())->Write("\"\n");
       WriteMatrix(node, tabs);
       const Light *light = node->GetLight();
       textWriter->Write(tabs.c_str())->Write("{\n");
       textWriter->Write(tabs.c_str())->Write("\tCOLOR (")->Write(light->diffuse._v, 3, ", ")->Write(")\n");

       switch (light->type)
       {
       case Light::OMNI:
              textWriter->Write(tabs.c_str())->Write("\tPOSITION (")->Write(light->position._v, 3, ", ")->Write(")\n");
              break;
       case Light::DIRECTIONAL:
              textWriter->Write(tabs.c_str())->Write("\tDIRECTION  (")->Write(light->direction._v, 3, ", ")->Write(")\n");
              break;
       case Light::SPOTLIGHT:
              textWriter->Write(tabs.c_str())->Write("\tPOSITION (")->Write(light->position._v, 3, ", ")->Write(")\n");
              textWriter->Write(tabs.c_str())->Write("\tDIRECTION (")->Write(light->direction._v, 3, ", ")->Write(")\n");
              textWriter->Write(tabs.c_str())->Write("\tSPOTLIGHT (")->Write(light->angle)->Write(", ")->Write(light->exponent)->Write(")\n");
              break;
       default:
              LOGERROR(wxString::Format(wxT("<FHSWriter>Unknown light type %i"),light->type));
              break;
       }
       textWriter->Write(tabs.c_str())->Write("}\n");
}

void FHSWriter::Write

(

)

Write FHS stream.

Definition at line 198 of file fhswriter.cpp.

{
       LOGVERBOSE(wxT("<FHSWriter>Inside FHSWriter::Write."));
       textWriter->Write("MODEL \"")->Write(scene->GetName())->Write("\"\nFHSVERSION 1100\nPOINTORDER COUNTERCLOCKWISE\n\n");

       //write materials
       const Scene::MaterialList * materials = scene->GetMaterials();

       for (Scene::MaterialList::const_iterator it = materials->begin(); it != materials->end(); it++)
       {
              if (*it==NULL)
                     continue;
              const Material * mat = *it;
              textWriter->Write("DEFMAT \"")->Write(mat->name);
              textWriter->Write("\"\n{\n\tAMBIENT (")->Write(mat->ambient._v, 3, ", ");
              textWriter->Write(")\n\tDIFFUSE (")->Write(mat->diffuse._v, 3, ", ");
              textWriter->Write(")\n\tSPECULAR (")->Write(mat->specular._v, 3, ", ");
              textWriter->Write(")\n\tSHININESS ")->Write(mat->shininess);
              textWriter->Write("\n\tEMISSION (")->Write(mat->emission._v, 3, ", ")->Write(")\n");
              if (mat->flags & Material::UNLIT)
                     textWriter->Write("\tUNLIT\n");
              if (mat->flags & Material::BLENDED)
              {
                     if (mat->diffuse.w!=1.0)
                     {
                            textWriter->Write("\tTRANSPARENCY ")->Write(1-mat->diffuse.w)->Write("\n");
                     }
                     const char *blendKeywords[]={"None", "Zero", "One", "SrcColor", "OneMinusSrcColor", "DstColor", "OneMinusDstColor", "SrcAlpha", "OneMinusSrcAlpha", "DstAlpha", ""};
                     const GLuint values[]={GL_ZERO, GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA};
                     int src=0, dst=0;
                     for (unsigned i=0; i<10/*sizeof(values)*/; i++)
                     {
                            if (values[i]==mat->texBlendSrc)
                                   src=i;
                            if (values[i]==mat->texBlendDst)
                                   dst=i;
                     }
                     if (src>0 || dst>0)
                     {
                            textWriter->Write("\tMATX \"BLENDFUNC ")->Write(blendKeywords[src])->Write(" ")->Write(blendKeywords[dst])->Write("\"\n");
                     }
              }
              if (!mat->uid.IsEmpty())
                     textWriter->Write("\tMATX \"UID ")->Write(mat->uid)->Write("\"\n");
              textWriter->Write("\tMATX \"DEPTHTEST ")->Write((mat->flags & Material::DEPTH_TEST_DISABLE) ? "0" : "1")->Write("\"\n");
              textWriter->Write("\tMATX \"DEPTHMASK ")->Write((mat->flags & Material::DEPTH_MASK_DISABLE) ? "0" : "1")->Write("\"\n");
              textWriter->Write("\tMATX \"DEPTHFUNC ")->Write((int)mat->depthFunc)->Write("\"\n");
              if (mat->flags & Material::DOUBLE_SIDED)
                     textWriter->Write("\tMATX \"DSIDED 1\"\n");
              if (mat->imageName.size())
              {
                     textWriter->Write("\tTEXTURE \"")->Write(wxFileName(mat->imageName).GetFullName())->Write("\"\n");
                     textWriter->Write("\tTEXWRAP ");
                     if (mat->texFlags & Material::TEX_UWRAP_REPEAT)
                            textWriter->Write("REPEAT ");
                     else //if (mat->texFlags & Material::TEX_UWRAP_CLAMP)
                            textWriter->Write("CLAMP ");
                     if (mat->texFlags & Material::TEX_VWRAP_REPEAT)
                            textWriter->Write("REPEAT");
                     else //if (mat->texFlags & Material::TEX_VWRAP_CLAMP)
                            textWriter->Write("CLAMP");
                     textWriter->Write("\n\tTEXFILTER ");
                     if (mat->texFlags & Material::TEX_MIN_FILTER_POINT)
                            textWriter->Write("POINT ");
                     else if (mat->texFlags & Material::TEX_MIN_FILTER_LINEAR)
                            textWriter->Write("LINEAR ");
                     else //if (mat->texFlags & Material::TEX_MIN_FILTER_MIPMAP)
                            textWriter->Write("MIPMAP ");
                     if (mat->texFlags & Material::TEX_MAG_FILTER_POINT)
                            textWriter->Write("POINT");
                     else //if (mat->texFlags & Material::TEX_MAG_FILTER_LINEAR)
                            textWriter->Write("LINEAR");
                     textWriter->Write("\n\tTEXQUALITY HIGH\n");
                     textWriter->Write("\tTEXBLEND ");
                     if (mat->texFlags & Material::TEX_ENV_MODULATE)
                            textWriter->Write("MODULATE");
                     else if (mat->texFlags & Material::TEX_ENV_REPLACE)
                            textWriter->Write("REPLACE");
                     else if (mat->texFlags & Material::TEX_ENV_DECAL)
                            textWriter->Write("DECAL");
                     else //if (mat->texFlags & Material::TEX_ENV_BLEND)
                            textWriter->Write("BLEND");
                     textWriter->Write("\n");
                     //TODO: use correct Eye and Object keywords
                     /*if (mat->texFlags & Material::TEX_GEN_FUNC_U_EYE)
                     textWriter->Write("\tMATX \"GENFUNC s Eye\" \n");
                     if (mat->texFlags & Material::TEX_GEN_FUNC_V_EYE)
                     textWriter->Write("\tMATX \"GENFUNC t Eye\" \n");
                     if (mat->texFlags & Material::TEX_GEN_FUNC_U_OBJECT)
                     textWriter->Write("\tMATX \"GENFUNC s Object\" \n");
                     if (mat->texFlags & Material::TEX_GEN_FUNC_V_OBJECT)
                     textWriter->Write("\tMATX \"GENFUNC t Object\" \n");*/
                     if (mat->texFlags & Material::TEX_GEN_FUNC_U_SPHERE)
                            textWriter->Write("\tMATX \"GENFUNC s Sphere\" \n");
                     if (mat->texFlags & Material::TEX_GEN_FUNC_V_SPHERE)
                            textWriter->Write("\tMATX \"GENFUNC t Sphere\" \n");
                     if (mat->flags & Material::INVERT_ALPHA)
                            textWriter->Write("\tMATX \"INVERTALPHA\" \n");
                     if (mat->texFlags & Material::TEX_IGNORE_COLORS)
                            textWriter->Write("\tMATX \"IGNORECOLORS\" \n");
                     if (mat->textureMix!=0)
                            textWriter->Write("\tMATX \"MIXTEXTURE ")->Write(mat->textureMix)->Write("\"\n");
              }
              if (mat->shader)
              {
                     textWriter->Write("\tMATX \"SHADERENABLE 1\"\n");
                     switch (mat->shader->type)
                     {
                     case ShaderProgram::LANG_GLSL:
                            textWriter->Write("\tMATX \"SHADERPROG GLSL VS '")->Write(wxFileName(mat->shader->vsFileName).GetFullName());
                            textWriter->Write("'\"\n\tMATX \"SHADERPROG GLSL FS '")->Write(wxFileName(mat->shader->fsFileName).GetFullName())->Write("'\"\n");
                            for (size_t i=0; i<mat->shader->paramList.size(); i++)
                            {
                                   textWriter->Write("\tMATX \"SHADERPARAM GLSL ")->Write(mat->shader->paramList[i].name);
                                   switch (mat->shader->paramList[i].type)
                                   {
                                   case ShaderParam::FLOAT1:
                                          textWriter->Write(" FLOAT ")->Write(mat->shader->paramList[i].fVals, 3, " ");
                                          break;
                                   case ShaderParam::FLOAT3:
                                          textWriter->Write(" FLOAT3 ")->Write(mat->shader->paramList[i].fVals, 3, " ");
                                          break;
                                   case ShaderParam::FLOAT4:
                                          textWriter->Write(" COLOR ")->Write(mat->shader->paramList[i].fVals, 4, " ");
                                          break;
                                   case ShaderParam::SAMPLER:
                                          textWriter->Write(" SAMPLER2D '")->Write(wxFileName(mat->shader->paramList[i].imageName).GetFullName().c_str())->Write("'");
                                          break;
                                   default:
                                          LOGERROR(wxString::Format(wxT("<FHSWrite>Shader param type %i not supported."), mat->shader->paramList[i].type));
                                   }
                                   textWriter->Write("\"\n");
                            }
                            break;
                     default:
                            LOGERROR(wxString::Format(wxT("<FHSWrite>Shader type %i not supported."), mat->shader->type));
                     }
              }
              textWriter->Write("}\n");
       }
       textWriter->Write("\n");
       //TODO
       // "MATX", "CLEARCOAT", "ACTIVATE", "DEACTIVATE", "CUBETEX", "LINEWIDTH"

       WriteAssemblyBody(scene->GetNode(scene->GetRootID()), "");
       outputStream->Sync();
}

---

Member Data Documentation

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

Output stream.

Definition at line 27 of file fhswriter.h.

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

Scene container to be saved.

Definition at line 29 of file fhswriter.h.

TextWriter* VRUT::FHSWriter::textWriter [private]

TextWriter support class.

Definition at line 31 of file fhswriter.h.

---

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

• /cygdrive/d/src/svn/vrut/trunk/core/src/base_modules/iofhs/fhswriter.h
• /cygdrive/d/src/svn/vrut/trunk/core/src/base_modules/iofhs/fhswriter.cpp