AsciiModelLoader Class Reference

Inheritance diagram for AsciiModelLoader:

Collaboration diagram for AsciiModelLoader:

List of all members.

Public Member Functions
	AsciiModelLoader (istream &_in)
virtual Model *	load ()
Mesh::Material *	loadMaterial ()
Mesh *	loadMesh ()
Mesh::VertexDescription *	loadVertexDescription ()
char *	loadVertices (const Mesh::VertexDescription &vertexDesc, uint32 &vertexCount)
virtual void	reportError (const string &)
	~AsciiModelLoader ()
Private Attributes
Tokenizer	tok

---

Detailed Description

This is an approximate Backus Naur form for the contents of ASCII cmod files. For brevity, the categories <unsigned_int> and <float> aren't defined here--they have the obvious definitions.

<modelfile>           ::= <header> <model>

<header>              ::= #celmodel__ascii

<model>               ::= { <material_definition> } { <mesh_definition> }

<material_definition> ::= material
                          { <material_attribute> }
                          end_material

<texture_semantic>    ::= texture0       |
                          normalmap      |
                          specularmap    |
                          emissivemap

<texture>             ::= <texture_semantic> <string>

<material_attribute>  ::= diffuse <color>   |
                          specular <color>  |
                          emissive <color>  |
                          specpower <float> |
                          opacity <float>   |
                          <texture>

<color>               ::= <float> <float> <float>

<string>              ::= """ { letter } """

<mesh_definition>     ::= mesh
                          <vertex_description>
                          <vertex_pool>
                          { <prim_group> }
                          end_mesh

<vertex_description>  ::= vertexdesc
                          { <vertex_attribute> }
                          end_vertexdesc

<vertex_attribute>    ::= <vertex_semantic> <vertex_format>

<vertex_semantic>     ::= position | normal | color0 | color1 | tangent |
                          texcoord0 | texcoord1 | texcoord2 | texcoord3

<vertex_format>       ::= f1 | f2 | f3 | f4 | ub4

<vertex_pool>         ::= vertices <count>
                          { <float> }

<count>               ::= <unsigned_int>

<prim_group>          ::= <prim_group_type> <material_index> <count>
                          { <unsigned_int> }

<prim_group_type>     ::= trilist | tristrip | trifan |
                          linelist | linestrip | points

<material_index>      :: <unsigned_int> | -1

Definition at line 95 of file modelfile.cpp.

---

Constructor & Destructor Documentation

AsciiModelLoader::AsciiModelLoader (  istream &  _in  )

Definition at line 286 of file modelfile.cpp. : tok(&_in) { }

AsciiModelLoader::~AsciiModelLoader (   )

Definition at line 292 of file modelfile.cpp. { }

---

Member Function Documentation

Model * AsciiModelLoader::load (   )  [virtual]

Implements ModelLoader. Definition at line 676 of file modelfile.cpp. References Model::addMaterial(), Model::addMesh(), Tokenizer::getNameValue(), loadMaterial(), loadMesh(), Tokenizer::nextToken(), Tokenizer::pushBack(), reportError(), and tok. { Model* model = new Model(); bool seenMeshes = false; if (model == NULL) { reportError("Unable to allocate memory for model"); return NULL; } // Parse material and mesh definitions for (;;) { Tokenizer::TokenType ttype = tok.nextToken(); if (ttype == Tokenizer::TokenEnd) { break; } else if (ttype == Tokenizer::TokenName) { string name = tok.getNameValue(); tok.pushBack(); if (name == "material") { if (seenMeshes) { reportError("Materials must be defined before meshes"); delete model; return NULL; } Mesh::Material* material = loadMaterial(); if (material == NULL) { delete model; return NULL; } model->addMaterial(material); } else if (name == "mesh") { seenMeshes = true; Mesh* mesh = loadMesh(); if (mesh == NULL) { delete model; return NULL; } model->addMesh(mesh); } else { reportError(string("Error: Unknown block type ") + name); delete model; return NULL; } } else { reportError("Block name expected"); return NULL; } } return model; }

Mesh::Material * AsciiModelLoader::loadMaterial (   )

Definition at line 307 of file modelfile.cpp. References DefaultDiffuse(), DefaultEmissive(), DefaultOpacity, DefaultSpecular(), DefaultSpecularPower, Mesh::Material::diffuse, Mesh::Material::emissive, ResourceManager< T >::getHandle(), Tokenizer::getNameValue(), Tokenizer::getNumberValue(), Tokenizer::getStringValue(), GetTextureManager(), ModelLoader::getTexturePath(), Tokenizer::getTokenType(), Mesh::Material::maps, Tokenizer::nextToken(), Mesh::Material::opacity, Mesh::parseTextureSemantic(), reportError(), Mesh::Material::specular, Mesh::Material::specularPower, and tok. Referenced by load(). { if (tok.nextToken() != Tokenizer::TokenName || tok.getNameValue() != "material") { reportError("Material definition expected"); return NULL; } Mesh::Material* material = new Mesh::Material(); material->diffuse = DefaultDiffuse; material->specular = DefaultSpecular; material->emissive = DefaultEmissive; material->specularPower = DefaultSpecularPower; material->opacity = DefaultOpacity; while (tok.nextToken() == Tokenizer::TokenName && tok.getNameValue() != "end_material") { string property = tok.getNameValue(); Mesh::TextureSemantic texType = Mesh::parseTextureSemantic(property); if (texType != Mesh::InvalidTextureSemantic) { if (tok.nextToken() != Tokenizer::TokenString) { reportError("Texture name expected"); delete material; return NULL; } ResourceHandle tex = GetTextureManager()->getHandle(TextureInfo(tok.getStringValue(), getTexturePath(), TextureInfo::WrapTexture)); material->maps[texType] = tex; } else { // All non-texture material properties are 3-vectors except // specular power and opacity double data[3]; int nValues = 3; if (property == "specpower" || property == "opacity") nValues = 1; for (int i = 0; i < nValues; i++) { if (tok.nextToken() != Tokenizer::TokenNumber) { reportError("Bad property value in material"); delete material; return NULL; } data[i] = tok.getNumberValue(); } Color colorVal; if (nValues == 3) colorVal = Color((float) data[0], (float) data[1], (float) data[2]); if (property == "diffuse") material->diffuse = colorVal; else if (property == "specular") material->specular = colorVal; else if (property == "emissive") material->emissive = colorVal; else if (property == "opacity") material->opacity = (float) data[0]; else if (property == "specpower") material->specularPower = (float) data[0]; } } if (tok.getTokenType() != Tokenizer::TokenName) { delete material; return NULL; } else { return material; } }

Mesh * AsciiModelLoader::loadMesh (   )

Definition at line 582 of file modelfile.cpp. References Mesh::addGroup(), Tokenizer::getNameValue(), Tokenizer::getNumberValue(), loadVertexDescription(), loadVertices(), Tokenizer::nextToken(), Mesh::parsePrimitiveGroupType(), reportError(), Mesh::setVertexDescription(), Mesh::setVertices(), and tok. Referenced by load(). { if (tok.nextToken() != Tokenizer::TokenName || tok.getNameValue() != "mesh") { reportError("Mesh definition expected"); return NULL; } Mesh::VertexDescription* vertexDesc = loadVertexDescription(); if (vertexDesc == NULL) return NULL; uint32 vertexCount = 0; char* vertexData = loadVertices(*vertexDesc, vertexCount); if (vertexData == NULL) return NULL; Mesh* mesh = new Mesh(); mesh->setVertexDescription(*vertexDesc); mesh->setVertices(vertexCount, vertexData); while (tok.nextToken() == Tokenizer::TokenName && tok.getNameValue() != "end_mesh") { Mesh::PrimitiveGroupType type = Mesh::parsePrimitiveGroupType(tok.getNameValue()); if (type == Mesh::InvalidPrimitiveGroupType) { reportError("Bad primitive group type: " + tok.getNameValue()); delete mesh; return NULL; } if (tok.nextToken() != Tokenizer::TokenNumber) { reportError("Material index expected in primitive group"); delete mesh; return NULL; } uint32 materialIndex; if (tok.getNumberValue() == -1.0) materialIndex = ~0; else materialIndex = (uint32) tok.getNumberValue(); if (tok.nextToken() != Tokenizer::TokenNumber) { reportError("Index count expected in primitive group"); delete mesh; return NULL; } uint32 indexCount = (uint32) tok.getNumberValue(); uint32* indices = new uint32[indexCount]; if (indices == NULL) { reportError("Not enough memory to hold indices"); delete mesh; return NULL; } for (uint32 i = 0; i < indexCount; i++) { if (tok.nextToken() != Tokenizer::TokenNumber) { reportError("Incomplete index list in primitive group"); delete indices; delete mesh; return NULL; } uint32 index = (uint32) tok.getNumberValue(); if (index >= vertexCount) { reportError("Index out of range"); delete indices; delete mesh; return NULL; } indices[i] = index; } mesh->addGroup(type, materialIndex, indexCount, indices); } return mesh; }

Mesh::VertexDescription * AsciiModelLoader::loadVertexDescription (   )

Definition at line 393 of file modelfile.cpp. References Mesh::VertexAttribute::format, Tokenizer::getNameValue(), Tokenizer::getTokenType(), Mesh::getVertexAttributeSize(), Tokenizer::nextToken(), Mesh::VertexAttribute::offset, Mesh::parseVertexAttributeFormat(), Mesh::parseVertexAttributeSemantic(), reportError(), Mesh::VertexAttribute::semantic, and tok. Referenced by loadMesh(). { if (tok.nextToken() != Tokenizer::TokenName || tok.getNameValue() != "vertexdesc") { reportError("Vertex description expected"); return NULL; } int maxAttributes = 16; int nAttributes = 0; uint32 offset = 0; Mesh::VertexAttribute* attributes = new Mesh::VertexAttribute[maxAttributes]; while (tok.nextToken() == Tokenizer::TokenName && tok.getNameValue() != "end_vertexdesc") { string semanticName; string formatName; bool valid = false; if (nAttributes == maxAttributes) { // TODO: Should eliminate the attribute limit, though no real vertex // will ever exceed it. reportError("Attribute limit exceeded in vertex description"); delete[] attributes; return NULL; } semanticName = tok.getNameValue(); if (tok.nextToken() == Tokenizer::TokenName) { formatName = tok.getNameValue(); valid = true; } if (!valid) { reportError("Invalid vertex description"); delete[] attributes; return NULL; } Mesh::VertexAttributeSemantic semantic = Mesh::parseVertexAttributeSemantic(semanticName); if (semantic == Mesh::InvalidSemantic) { reportError(string("Invalid vertex attribute semantic '") + semanticName + "'"); delete[] attributes; return NULL; } Mesh::VertexAttributeFormat format = Mesh::parseVertexAttributeFormat(formatName); if (format == Mesh::InvalidFormat) { reportError(string("Invalid vertex attribute format '") + formatName + "'"); delete[] attributes; return NULL; } attributes[nAttributes].semantic = semantic; attributes[nAttributes].format = format; attributes[nAttributes].offset = offset; offset += Mesh::getVertexAttributeSize(format); nAttributes++; } if (tok.getTokenType() != Tokenizer::TokenName) { reportError("Invalid vertex description"); delete[] attributes; return NULL; } if (nAttributes == 0) { reportError("Vertex definitition cannot be empty"); delete[] attributes; return NULL; } return new Mesh::VertexDescription(offset, nAttributes, attributes); }

char * AsciiModelLoader::loadVertices (  const Mesh::VertexDescription &  vertexDesc, uint32 &  vertexCount )

Definition at line 485 of file modelfile.cpp. References Tokenizer::getNameValue(), Tokenizer::getNumberValue(), Mesh::getVertexAttributeSize(), Tokenizer::nextToken(), reportError(), and tok. Referenced by loadMesh(). { if (tok.nextToken() != Tokenizer::TokenName || tok.getNameValue() != "vertices") { reportError("Vertex data expected"); return NULL; } if (tok.nextToken() != Tokenizer::TokenNumber) { reportError("Vertex count expected"); return NULL; } double num = tok.getNumberValue(); if (num != floor(num) || num <= 0.0) { reportError("Bad vertex count for mesh"); return NULL; } vertexCount = (uint32) num; uint32 vertexDataSize = vertexDesc.stride * vertexCount; char* vertexData = new char[vertexDataSize]; if (vertexData == NULL) { reportError("Not enough memory to hold vertex data"); return NULL; } uint32 offset = 0; double data[4]; for (uint32 i = 0; i < vertexCount; i++, offset += vertexDesc.stride) { assert(offset < vertexDataSize); for (uint32 attr = 0; attr < vertexDesc.nAttributes; attr++) { Mesh::VertexAttributeFormat fmt = vertexDesc.attributes[attr].format; uint32 nBytes = Mesh::getVertexAttributeSize(fmt); int readCount = 0; switch (fmt) { case Mesh::Float1: readCount = 1; break; case Mesh::Float2: readCount = 2; break; case Mesh::Float3: readCount = 3; break; case Mesh::Float4: case Mesh::UByte4: readCount = 4; break; default: assert(0); delete[] vertexData; return NULL; } for (int j = 0; j < readCount; j++) { if (tok.nextToken() != Tokenizer::TokenNumber) { reportError("Error in vertex data"); delete[] vertexData; } data[j] = tok.getNumberValue(); // TODO: range check unsigned byte values } uint32 base = offset + vertexDesc.attributes[attr].offset; if (fmt == Mesh::UByte4) { for (int k = 0; k < readCount; k++) { reinterpret_cast<unsigned char*>(vertexData + base)[k] = (unsigned char) (data[k]); } } else { for (int k = 0; k < readCount; k++) reinterpret_cast<float*>(vertexData + base)[k] = (float) data[k]; } } } return vertexData; }

void AsciiModelLoader::reportError (  const string &   )  [virtual]

Definition at line 298 of file modelfile.cpp. References Tokenizer::getLineNumber(), ModelLoader::reportError(), and tok. Referenced by load(), loadMaterial(), loadMesh(), loadVertexDescription(), and loadVertices(). { char buf[32]; sprintf(buf, " (line %d)", tok.getLineNumber()); ModelLoader::reportError(msg + string(buf)); }

---

Member Data Documentation

Tokenizer AsciiModelLoader::tok [private]

Definition at line 111 of file modelfile.cpp. Referenced by load(), loadMaterial(), loadMesh(), loadVertexDescription(), loadVertices(), and reportError().

---

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

• src/celengine/modelfile.cpp

---