开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
modelfile.cpp
资源名称：celestia-1.6.0.tar.gz　[点击查看]
上传用户：center1979
上传日期：2022-07-26
资源大小：50633k
文件大小：47k
源码类别：

OpenGL

开发平台：

Visual C++

modelfile.cpp：源码内容
  1. // modelfile.cpp
  2. //
  3. // Copyright (C) 2004, Chris Laurel <claurel@shatters.net>
  4. //
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  10. #include "modelfile.h"
  11. #include "tokenizer.h"
  12. #include "texmanager.h"
  13. #include <celutil/bytes.h>
  14. #include <cstring>
  15. #include <cassert>
  16. #include <cmath>
  17. #include <cstdio>
  19. using namespace std;
  23. // Material default values
  24. static Color DefaultDiffuse(0.0f, 0.0f, 0.0f);
  25. static Color DefaultSpecular(0.0f, 0.0f, 0.0f);
  26. static Color DefaultEmissive(0.0f, 0.0f, 0.0f);
  27. static float DefaultSpecularPower = 1.0f;
  28. static float DefaultOpacity = 1.0f;
  29. static Mesh::BlendMode DefaultBlend = Mesh::NormalBlend;
  32. /*!
  33. This is an approximate Backus Naur form for the contents of ASCII cmod
  34. files. For brevity, the categories &lt;unsigned_int&gt; and &lt;float&gt; aren't
  35. defined here--they have the obvious definitions.
  36. code
  37. <modelfile>           ::= <header> <model>
  39. <header>              ::= #celmodel__ascii
  41. <model>               ::= { <material_definition> } { <mesh_definition> }
  43. <material_definition> ::= material
  44.                           { <material_attribute> }
  45.                           end_material
  47. <texture_semantic>    ::= texture0       |
  48.                           normalmap      |
  49.                           specularmap    |
  50.                           emissivemap
  52. <texture>             ::= <texture_semantic> <string>
  54. <material_attribute>  ::= diffuse <color>   |
  55.                           specular <color>  |
  56.                           emissive <color>  |
  57.                           specpower <float> |
  58.                           opacity <float>   |
  59.                           blend <blendmode> |
  60.                           <texture>
  62. <color>               ::= <float> <float> <float>
  64. <string>              ::= """ { letter } """
  66. <blendmode>           ::= normal | add | premultiplied
  68. <mesh_definition>     ::= mesh
  69.                           <vertex_description>
  70.                           <vertex_pool>
  71.                           { <prim_group> }
  72.                           end_mesh
  74. <vertex_description>  ::= vertexdesc
  75.                           { <vertex_attribute> }
  76.                           end_vertexdesc
  78. <vertex_attribute>    ::= <vertex_semantic> <vertex_format>
  80. <vertex_semantic>     ::= position | normal | color0 | color1 | tangent |
  81.                           texcoord0 | texcoord1 | texcoord2 | texcoord3 |
  82.                           pointsize
  84. <vertex_format>       ::= f1 | f2 | f3 | f4 | ub4
  86. <vertex_pool>         ::= vertices <count>
  87.                           { <float> }
  89. <count>               ::= <unsigned_int>
  91. <prim_group>          ::= <prim_group_type> <material_index> <count>
  92.                           { <unsigned_int> }
  94. <prim_group_type>     ::= trilist | tristrip | trifan |
  95.                           linelist | linestrip | points |
  96.                           sprites
  98. <material_index>      :: <unsigned_int> | -1
  99. endcode
  100. */
  101. class AsciiModelLoader : public ModelLoader
  102. {
  103. public:
  104.     AsciiModelLoader(istream& _in);
  105.     ~AsciiModelLoader();
  107.     virtual Model* load();
  108.     virtual void reportError(const string&);
  110.     Mesh::Material*          loadMaterial();
  111.     Mesh::VertexDescription* loadVertexDescription();
  112.     Mesh*                    loadMesh();
  113.     char*                    loadVertices(const Mesh::VertexDescription& vertexDesc,
  114.                                           uint32& vertexCount);
  116. private:
  117.     Tokenizer tok;
  118. };
  121. class AsciiModelWriter : public ModelWriter
  122. {
  123. public:
  124.     AsciiModelWriter(ostream&);
  125.     ~AsciiModelWriter();
  127.     virtual bool write(const Model&);
  129. private:
  130.     void writeMesh(const Mesh&);
  131.     void writeMaterial(const Mesh::Material&);
  132.     void writeGroup(const Mesh::PrimitiveGroup&);
  133.     void writeVertexDescription(const Mesh::VertexDescription&);
  134.     void writeVertices(const void* vertexData,
  135.                        uint32 nVertices,
  136.                        uint32 stride,
  137.                        const Mesh::VertexDescription& desc);
  139.     ostream& out;
  140. };
  143. class BinaryModelLoader : public ModelLoader
  144. {
  145. public:
  146.     BinaryModelLoader(istream& _in);
  147.     ~BinaryModelLoader();
  149.     virtual Model* load();
  150.     virtual void reportError(const string&);
  152.     Mesh::Material*          loadMaterial();
  153.     Mesh::VertexDescription* loadVertexDescription();
  154.     Mesh*                    loadMesh();
  155.     char*                    loadVertices(const Mesh::VertexDescription& vertexDesc,
  156.                                           uint32& vertexCount);
  158. private:
  159.     istream& in;
  160. };
  163. class BinaryModelWriter : public ModelWriter
  164. {
  165. public:
  166.     BinaryModelWriter(ostream&);
  167.     ~BinaryModelWriter();
  169.     virtual bool write(const Model&);
  171. private:
  172.     void writeMesh(const Mesh&);
  173.     void writeMaterial(const Mesh::Material&);
  174.     void writeGroup(const Mesh::PrimitiveGroup&);
  175.     void writeVertexDescription(const Mesh::VertexDescription&);
  176.     void writeVertices(const void* vertexData,
  177.                        uint32 nVertices,
  178.                        uint32 stride,
  179.                        const Mesh::VertexDescription& desc);
  181.     ostream& out;
  182. };
  185. ModelLoader::ModelLoader()
  186. {
  187. }
  190. ModelLoader::~ModelLoader()
  191. {
  192. }
  195. void
  196. ModelLoader::reportError(const string& msg)
  197. {
  198.     errorMessage = msg;
  199. }
  202. const string&
  203. ModelLoader::getErrorMessage() const
  204. {
  205.     return errorMessage;
  206. }
  209. void
  210. ModelLoader::setTexturePath(const string& _texPath)
  211. {
  212.     texPath = _texPath;
  213. }
  216. const string&
  217. ModelLoader::getTexturePath() const
  218. {
  219.     return texPath;
  220. }
  223. Model* LoadModel(istream& in)
  224. {
  225.     return LoadModel(in, "");
  226. }
  229. Model* LoadModel(istream& in, const string& texPath)
  230. {
  231.     ModelLoader* loader = ModelLoader::OpenModel(in);
  232.     if (loader == NULL)
  233.         return NULL;
  235.     loader->setTexturePath(texPath);
  237.     Model* model = loader->load();
  238.     if (model == NULL)
  239.         cerr << "Error in model file: " << loader->getErrorMessage() << 'n';
  241.     delete loader;
  243.     return model;
  244. }
  247. ModelLoader*
  248. ModelLoader::OpenModel(istream& in)
  249. {
  250.     char header[CEL_MODEL_HEADER_LENGTH + 1];
  251.     memset(header, '', sizeof(header));
  253.     in.read(header, CEL_MODEL_HEADER_LENGTH);
  254.     if (strcmp(header, CEL_MODEL_HEADER_ASCII) == 0)
  255.     {
  256.         return new AsciiModelLoader(in);
  257.     }
  258.     else if (strcmp(header, CEL_MODEL_HEADER_BINARY) == 0)
  259.     {
  260.         return new BinaryModelLoader(in);
  261.     }
  262.     else
  263.     {
  264.         cerr << "Model file has invalid header.n";
  265.         return NULL;
  266.     }
  267. }
  270. bool SaveModelAscii(const Model* model, std::ostream& out)
  271. {
  272.     if (model == NULL)
  273.         return false;
  275.     AsciiModelWriter(out).write(*model);
  277.     return true;
  278. }
  281. bool SaveModelBinary(const Model* model, std::ostream& out)
  282. {
  283.     if (model == NULL)
  284.         return false;
  286.     BinaryModelWriter(out).write(*model);
  288.     return true;
  289. }
  292. AsciiModelLoader::AsciiModelLoader(istream& _in) :
  293.     tok(&_in)
  294. {
  295. }
  298. AsciiModelLoader::~AsciiModelLoader()
  299. {
  300. }
  303. void
  304. AsciiModelLoader::reportError(const string& msg)
  305. {
  306.     char buf[32];
  307.     sprintf(buf, " (line %d)", tok.getLineNumber());
  308.     ModelLoader::reportError(msg + string(buf));
  309. }
  312. Mesh::Material*
  313. AsciiModelLoader::loadMaterial()
  314. {
  315.     if (tok.nextToken() != Tokenizer::TokenName ||
  316.         tok.getNameValue() != "material")
  317.     {
  318.         reportError("Material definition expected");
  319.         return NULL;
  320.     }
  322.     Mesh::Material* material = new Mesh::Material();
  324.     material->diffuse = DefaultDiffuse;
  325.     material->specular = DefaultSpecular;
  326.     material->emissive = DefaultEmissive;
  327.     material->specularPower = DefaultSpecularPower;
  328.     material->opacity = DefaultOpacity;
  330.     while (tok.nextToken() == Tokenizer::TokenName &&
  331.            tok.getNameValue() != "end_material")
  332.     {
  333.         string property = tok.getNameValue();
  334.         Mesh::TextureSemantic texType = Mesh::parseTextureSemantic(property);
  336.         if (texType != Mesh::InvalidTextureSemantic)
  337.         {
  338.             if (tok.nextToken() != Tokenizer::TokenString)
  339.             {
  340.                 reportError("Texture name expected");
  341.                 delete material;
  342.                 return NULL;
  343.             }
  345.             ResourceHandle tex = GetTextureManager()->getHandle(TextureInfo(tok.getStringValue(), getTexturePath(), TextureInfo::WrapTexture));
  347.             material->maps[texType] = tex;
  348.         }
  349.         else if (property == "blend")
  350.         {
  351.             Mesh::BlendMode blendMode = Mesh::InvalidBlend;
  353.             if (tok.nextToken() == Tokenizer::TokenName)
  354.             {
  355.                 string blendModeName = tok.getNameValue();
  356.                 if (blendModeName == "normal")
  357.                     blendMode = Mesh::NormalBlend;
  358.                 else if (blendModeName == "add")
  359.                     blendMode = Mesh::AdditiveBlend;
  360.                 else if (blendModeName == "premultiplied")
  361.                     blendMode = Mesh::PremultipliedAlphaBlend;
  362.             }
  364.             if (blendMode == Mesh::InvalidBlend)
  365.             {
  366.                 reportError("Bad blend mode in material");
  367.                 delete material;
  368.                 return NULL;
  369.             }
  371.             material->blend = blendMode;
  372.         }
  373.         else
  374.         {
  375.             // All non-texture material properties are 3-vectors except
  376.             // specular power and opacity
  377.             double data[3];
  378.             int nValues = 3;
  379.             if (property == "specpower" || property == "opacity")
  380.                 nValues = 1;
  382.             for (int i = 0; i < nValues; i++)
  383.             {
  384.                 if (tok.nextToken() != Tokenizer::TokenNumber)
  385.                 {
  386.                     reportError("Bad property value in material");
  387.                     delete material;
  388.                     return NULL;
  389.                 }
  390.                 data[i] = tok.getNumberValue();
  391.             }
  393.             Color colorVal;
  394.             if (nValues == 3)
  395.                 colorVal = Color((float) data[0], (float) data[1], (float) data[2]);
  397.             if (property == "diffuse")
  398.                 material->diffuse = colorVal;
  399.             else if (property == "specular")
  400.                 material->specular = colorVal;
  401.             else if (property == "emissive")
  402.                 material->emissive = colorVal;
  403.             else if (property == "opacity")
  404.                 material->opacity = (float) data[0];
  405.             else if (property == "specpower")
  406.                 material->specularPower = (float) data[0];
  407.         }
  408.     }
  410.     if (tok.getTokenType() != Tokenizer::TokenName)
  411.     {
  412.         delete material;
  413.         return NULL;
  414.     }
  415.     else
  416.     {
  417.         return material;
  418.     }
  419. }
  422. Mesh::VertexDescription*
  423. AsciiModelLoader::loadVertexDescription()
  424. {
  425.     if (tok.nextToken() != Tokenizer::TokenName ||
  426.         tok.getNameValue() != "vertexdesc")
  427.     {
  428.         reportError("Vertex description expected");
  429.         return NULL;
  430.     }
  432.     int maxAttributes = 16;
  433.     int nAttributes = 0;
  434.     uint32 offset = 0;
  435.     Mesh::VertexAttribute* attributes = new Mesh::VertexAttribute[maxAttributes];
  437.     while (tok.nextToken() == Tokenizer::TokenName &&
  438.            tok.getNameValue() != "end_vertexdesc")
  439.     {
  440.         string semanticName;
  441.         string formatName;
  442.         bool valid = false;
  444.         if (nAttributes == maxAttributes)
  445.         {
  446.             // TODO: Should eliminate the attribute limit, though no real vertex
  447.             // will ever exceed it.
  448.             reportError("Attribute limit exceeded in vertex description");
  449.             delete[] attributes;
  450.             return NULL;
  451.         }
  453.         semanticName = tok.getNameValue();
  455.         if (tok.nextToken() == Tokenizer::TokenName)
  456.         {
  457.             formatName = tok.getNameValue();
  458.             valid = true;
  459.         }
  461.         if (!valid)
  462.         {
  463.             reportError("Invalid vertex description");
  464.             delete[] attributes;
  465.             return NULL;
  466.         }
  468.         Mesh::VertexAttributeSemantic semantic =
  469.             Mesh::parseVertexAttributeSemantic(semanticName);
  470.         if (semantic == Mesh::InvalidSemantic)
  471.         {
  472.             reportError(string("Invalid vertex attribute semantic '") +
  473.                         semanticName + "'");
  474.             delete[] attributes;
  475.             return NULL;
  476.         }
  478.         Mesh::VertexAttributeFormat format =
  479.             Mesh::parseVertexAttributeFormat(formatName);
  480.         if (format == Mesh::InvalidFormat)
  481.         {
  482.             reportError(string("Invalid vertex attribute format '") +
  483.                         formatName + "'");
  484.             delete[] attributes;
  485.             return NULL;
  486.         }
  488.         attributes[nAttributes].semantic = semantic;
  489.         attributes[nAttributes].format = format;
  490.         attributes[nAttributes].offset = offset;
  492.         offset += Mesh::getVertexAttributeSize(format);
  493.         nAttributes++;
  494.     }
  496.     if (tok.getTokenType() != Tokenizer::TokenName)
  497.     {
  498.         reportError("Invalid vertex description");
  499.         delete[] attributes;
  500.         return NULL;
  501.     }
  503.     if (nAttributes == 0)
  504.     {
  505.         reportError("Vertex definitition cannot be empty");
  506.         delete[] attributes;
  507.         return NULL;
  508.     }
  510.     Mesh::VertexDescription *vertexDesc =
  511.         new Mesh::VertexDescription(offset, nAttributes, attributes);
  512.     delete[] attributes;
  513.     return vertexDesc;
  514. }
  517. char*
  518. AsciiModelLoader::loadVertices(const Mesh::VertexDescription& vertexDesc,
  519.                                uint32& vertexCount)
  520. {
  521.     if (tok.nextToken() != Tokenizer::TokenName ||
  522.         tok.getNameValue() != "vertices")
  523.     {
  524.         reportError("Vertex data expected");
  525.         return NULL;
  526.     }
  528.     if (tok.nextToken() != Tokenizer::TokenNumber)
  529.     {
  530.         reportError("Vertex count expected");
  531.         return NULL;
  532.     }
  534.     double num = tok.getNumberValue();
  535.     if (num != floor(num) || num <= 0.0)
  536.     {
  537.         reportError("Bad vertex count for mesh");
  538.         return NULL;
  539.     }
  541.     vertexCount = (uint32) num;
  542.     uint32 vertexDataSize = vertexDesc.stride * vertexCount;
  543.     char* vertexData = new char[vertexDataSize];
  544.     if (vertexData == NULL)
  545.     {
  546.         reportError("Not enough memory to hold vertex data");
  547.         return NULL;
  548.     }
  550.     uint32 offset = 0;
  551.     double data[4];
  552.     for (uint32 i = 0; i < vertexCount; i++, offset += vertexDesc.stride)
  553.     {
  554.         assert(offset < vertexDataSize);
  555.         for (uint32 attr = 0; attr < vertexDesc.nAttributes; attr++)
  556.         {
  557.             Mesh::VertexAttributeFormat fmt = vertexDesc.attributes[attr].format;
  558.             /*uint32 nBytes = Mesh::getVertexAttributeSize(fmt);    Unused*/
  559.             int readCount = 0;
  560.             switch (fmt)
  561.             {
  562.             case Mesh::Float1:
  563.                 readCount = 1;
  564.                 break;
  565.             case Mesh::Float2:
  566.                 readCount = 2;
  567.                 break;
  568.             case Mesh::Float3:
  569.                 readCount = 3;
  570.                 break;
  571.             case Mesh::Float4:
  572.             case Mesh::UByte4:
  573.                 readCount = 4;
  574.                 break;
  575.             default:
  576.                 assert(0);
  577.                 delete[] vertexData;
  578.                 return NULL;
  579.             }
  581.             for (int j = 0; j < readCount; j++)
  582.             {
  583.                 if (tok.nextToken() != Tokenizer::TokenNumber)
  584.                 {
  585.                     reportError("Error in vertex data");
  586.                     data[j] = 0.0;
  587.                 }
  588.                 else
  589.                 {
  590.                     data[j] = tok.getNumberValue();
  591.                 }
  592.                 // TODO: range check unsigned byte values
  593.             }
  595.             uint32 base = offset + vertexDesc.attributes[attr].offset;
  596.             if (fmt == Mesh::UByte4)
  597.             {
  598.                 for (int k = 0; k < readCount; k++)
  599.                 {
  600.                     reinterpret_cast<unsigned char*>(vertexData + base)[k] =
  601.                         (unsigned char) (data[k]);
  602.                 }
  603.             }
  604.             else
  605.             {
  606.                 for (int k = 0; k < readCount; k++)
  607.                     reinterpret_cast<float*>(vertexData + base)[k] = (float) data[k];
  608.             }
  609.         }
  610.     }
  612.     return vertexData;
  613. }
  616. Mesh*
  617. AsciiModelLoader::loadMesh()
  618. {
  619.     if (tok.nextToken() != Tokenizer::TokenName ||
  620.         tok.getNameValue() != "mesh")
  621.     {
  622.         reportError("Mesh definition expected");
  623.         return NULL;
  624.     }
  626.     Mesh::VertexDescription* vertexDesc = loadVertexDescription();
  627.     if (vertexDesc == NULL)
  628.         return NULL;
  630.     uint32 vertexCount = 0;
  631.     char* vertexData = loadVertices(*vertexDesc, vertexCount);
  632.     if (vertexData == NULL)
  633.     {
  634.         delete vertexDesc;
  635.         return NULL;
  636.     }
  638.     Mesh* mesh = new Mesh();
  639.     mesh->setVertexDescription(*vertexDesc);
  640.     mesh->setVertices(vertexCount, vertexData);
  641.     delete vertexDesc;
  643.     while (tok.nextToken() == Tokenizer::TokenName &&
  644.            tok.getNameValue() != "end_mesh")
  645.     {
  646.         Mesh::PrimitiveGroupType type =
  647.             Mesh::parsePrimitiveGroupType(tok.getNameValue());
  648.         if (type == Mesh::InvalidPrimitiveGroupType)
  649.         {
  650.             reportError("Bad primitive group type: " + tok.getNameValue());
  651.             delete mesh;
  652.             return NULL;
  653.         }
  655.         if (tok.nextToken() != Tokenizer::TokenNumber)
  656.         {
  657.             reportError("Material index expected in primitive group");
  658.             delete mesh;
  659.             return NULL;
  660.         }
  662.         uint32 materialIndex;
  663.         if (tok.getNumberValue() == -1.0)
  664.             materialIndex = ~0u;
  665.         else
  666.             materialIndex = (uint32) tok.getNumberValue();
  668.         if (tok.nextToken() != Tokenizer::TokenNumber)
  669.         {
  670.             reportError("Index count expected in primitive group");
  671.             delete mesh;
  672.             return NULL;
  673.         }
  675.         uint32 indexCount = (uint32) tok.getNumberValue();
  677.         uint32* indices = new uint32[indexCount];
  678.         if (indices == NULL)
  679.         {
  680.             reportError("Not enough memory to hold indices");
  681.             delete mesh;
  682.             return NULL;
  683.         }
  685.         for (uint32 i = 0; i < indexCount; i++)
  686.         {
  687.             if (tok.nextToken() != Tokenizer::TokenNumber)
  688.             {
  689.                 reportError("Incomplete index list in primitive group");
  690.                 delete indices;
  691.                 delete mesh;
  692.                 return NULL;
  693.             }
  695.             uint32 index = (uint32) tok.getNumberValue();
  696.             if (index >= vertexCount)
  697.             {
  698.                 reportError("Index out of range");
  699.                 delete indices;
  700.                 delete mesh;
  701.                 return NULL;
  702.             }
  704.             indices[i] = index;
  705.         }
  707.         mesh->addGroup(type, materialIndex, indexCount, indices);
  708.     }
  710.     return mesh;
  711. }
  714. Model*
  715. AsciiModelLoader::load()
  716. {
  717.     Model* model = new Model();
  718.     bool seenMeshes = false;
  720.     if (model == NULL)
  721.     {
  722.         reportError("Unable to allocate memory for model");
  723.         return NULL;
  724.     }
  726.     // Parse material and mesh definitions
  727.     for (;;)
  728.     {
  729.         Tokenizer::TokenType ttype = tok.nextToken();
  731.         if (ttype == Tokenizer::TokenEnd)
  732.         {
  733.             break;
  734.         }
  735.         else if (ttype == Tokenizer::TokenName)
  736.         {
  737.             string name = tok.getNameValue();
  738.             tok.pushBack();
  740.             if (name == "material")
  741.             {
  742.                 if (seenMeshes)
  743.                 {
  744.                     reportError("Materials must be defined before meshes");
  745.                     delete model;
  746.                     return NULL;
  747.                 }
  749.                 Mesh::Material* material = loadMaterial();
  750.                 if (material == NULL)
  751.                 {
  752.                     delete model;
  753.                     return NULL;
  754.                 }
  756.                 model->addMaterial(material);
  757.             }
  758.             else if (name == "mesh")
  759.             {
  760.                 seenMeshes = true;
  762.                 Mesh* mesh = loadMesh();
  763.                 if (mesh == NULL)
  764.                 {
  765.                     delete model;
  766.                     return NULL;
  767.                 }
  769.                 model->addMesh(mesh);
  770.             }
  771.             else
  772.             {
  773.                 reportError(string("Error: Unknown block type ") + name);
  774.                 delete model;
  775.                 return NULL;
  776.             }
  777.         }
  778.         else
  779.         {
  780.             reportError("Block name expected");
  781.             return NULL;
  782.         }
  783.     }
  785.     return model;
  786. }
  790. AsciiModelWriter::AsciiModelWriter(ostream& _out) :
  791.     out(_out)
  792. {
  793. }
  796. AsciiModelWriter::~AsciiModelWriter()
  797. {
  798. }
  801. bool
  802. AsciiModelWriter::write(const Model& model)
  803. {
  804.     out << CEL_MODEL_HEADER_ASCII << "nn";
  806.     for (uint32 matIndex = 0; model.getMaterial(matIndex); matIndex++)
  807.     {
  808.         writeMaterial(*model.getMaterial(matIndex));
  809.         out << 'n';
  810.     }
  812.     for (uint32 meshIndex = 0; model.getMesh(meshIndex); meshIndex++)
  813.     {
  814.         writeMesh(*model.getMesh(meshIndex));
  815.         out << 'n';
  816.     }
  818.     return true;
  819. }
  822. void
  823. AsciiModelWriter::writeGroup(const Mesh::PrimitiveGroup& group)
  824. {
  825.     switch (group.prim)
  826.     {
  827.     case Mesh::TriList:
  828.         out << "trilist"; break;
  829.     case Mesh::TriStrip:
  830.         out << "tristrip"; break;
  831.     case Mesh::TriFan:
  832.         out << "trifan"; break;
  833.     case Mesh::LineList:
  834.         out << "linelist"; break;
  835.     case Mesh::LineStrip:
  836.         out << "linestrip"; break;
  837.     case Mesh::PointList:
  838.         out << "points"; break;
  839.     case Mesh::SpriteList:
  840.         out << "sprites"; break;
  841.     default:
  842.         return;
  843.     }
  845.     out << ' ' << group.materialIndex << ' ' << group.nIndices << 'n';
  847.     // Print the indices, twelve per line
  848.     for (uint32 i = 0; i < group.nIndices; i++)
  849.     {
  850.         out << group.indices[i];
  851.         if (i % 12 == 11 || i == group.nIndices - 1)
  852.             out << 'n';
  853.         else
  854.             out << ' ';
  855.     }
  856. }
  859. void
  860. AsciiModelWriter::writeMesh(const Mesh& mesh)
  861. {
  862.     out << "meshn";
  864.     if (!mesh.getName().empty())
  865.         out << "# " << mesh.getName() << 'n';
  867.     writeVertexDescription(mesh.getVertexDescription());
  868.     out << 'n';
  870.     writeVertices(mesh.getVertexData(),
  871.                   mesh.getVertexCount(),
  872.                   mesh.getVertexStride(),
  873.                   mesh.getVertexDescription());
  874.     out << 'n';
  876.     for (uint32 groupIndex = 0; mesh.getGroup(groupIndex); groupIndex++)
  877.     {
  878.         writeGroup(*mesh.getGroup(groupIndex));
  879.         out << 'n';
  880.     }
  882.     out << "end_meshn";
  883. }
  886. void
  887. AsciiModelWriter::writeVertices(const void* vertexData,
  888.                                 uint32 nVertices,
  889.                                 uint32 stride,
  890.                                 const Mesh::VertexDescription& desc)
  891. {
  892.     const unsigned char* vertex = reinterpret_cast<const unsigned char*>(vertexData);
  894.     out << "vertices " << nVertices << 'n';
  895.     for (uint32 i = 0; i < nVertices; i++, vertex += stride)
  896.     {
  897.         for (uint32 attr = 0; attr < desc.nAttributes; attr++)
  898.         {
  899.             const unsigned char* ubdata = vertex + desc.attributes[attr].offset;
  900.             const float* fdata = reinterpret_cast<const float*>(ubdata);
  902.             switch (desc.attributes[attr].format)
  903.             {
  904.             case Mesh::Float1:
  905.                 out << fdata[0];
  906.                 break;
  907.             case Mesh::Float2:
  908.                 out << fdata[0] << ' ' << fdata[1];
  909.                 break;
  910.             case Mesh::Float3:
  911.                 out << fdata[0] << ' ' << fdata[1] << ' ' << fdata[2];
  912.                 break;
  913.             case Mesh::Float4:
  914.                 out << fdata[0] << ' ' << fdata[1] << ' ' <<
  915.                        fdata[2] << ' ' << fdata[3];
  916.                 break;
  917.             case Mesh::UByte4:
  918.                 out << (int) ubdata[0] << ' ' << (int) ubdata[1] << ' ' <<
  919.                        (int) ubdata[2] << ' ' << (int) ubdata[3];
  920.                 break;
  921.             default:
  922.                 assert(0);
  923.                 break;
  924.             }
  926.             out << ' ';
  927.         }
  929.         out << 'n';
  930.     }
  931. }
  934. void
  935. AsciiModelWriter::writeVertexDescription(const Mesh::VertexDescription& desc)
  936. {
  937.     out << "vertexdescn";
  938.     for (uint32 attr = 0; attr < desc.nAttributes; attr++)
  939.     {
  940.         // We should never have a vertex description with invalid
  941.         // fields . . .
  943.         switch (desc.attributes[attr].semantic)
  944.         {
  945.         case Mesh::Position:
  946.             out << "position";
  947.             break;
  948.         case Mesh::Color0:
  949.             out << "color0";
  950.             break;
  951.         case Mesh::Color1:
  952.             out << "color1";
  953.             break;
  954.         case Mesh::Normal:
  955.             out << "normal";
  956.             break;
  957.         case Mesh::Tangent:
  958.             out << "tangent";
  959.             break;
  960.         case Mesh::Texture0:
  961.             out << "texcoord0";
  962.             break;
  963.         case Mesh::Texture1:
  964.             out << "texcoord1";
  965.             break;
  966.         case Mesh::Texture2:
  967.             out << "texcoord2";
  968.             break;
  969.         case Mesh::Texture3:
  970.             out << "texcoord3";
  971.             break;
  972.         case Mesh::PointSize:
  973.             out << "pointsize";
  974.             break;
  975.         default:
  976.             assert(0);
  977.             break;
  978.         }
  980.         out << ' ';
  982.         switch (desc.attributes[attr].format)
  983.         {
  984.         case Mesh::Float1:
  985.             out << "f1";
  986.             break;
  987.         case Mesh::Float2:
  988.             out << "f2";
  989.             break;
  990.         case Mesh::Float3:
  991.             out << "f3";
  992.             break;
  993.         case Mesh::Float4:
  994.             out << "f4";
  995.             break;
  996.         case Mesh::UByte4:
  997.             out << "ub4";
  998.             break;
  999.         default:
  1000.             assert(0);
  1001.             break;
  1002.         }
  1004.         out << 'n';
  1005.     }
  1006.     out << "end_vertexdescn";
  1007. }
  1010. void
  1011. AsciiModelWriter::writeMaterial(const Mesh::Material& material)
  1012. {
  1013.     out << "materialn";
  1014.     if (material.diffuse != DefaultDiffuse)
  1015.     {
  1016.         out << "diffuse " <<
  1017.             material.diffuse.red() << ' ' <<
  1018.             material.diffuse.green() << ' ' <<
  1019.             material.diffuse.blue() << 'n';
  1020.     }
  1022.     if (material.emissive != DefaultEmissive)
  1023.     {
  1024.         out << "emissive " <<
  1025.             material.emissive.red() << ' ' <<
  1026.             material.emissive.green() << ' ' <<
  1027.             material.emissive.blue() << 'n';
  1028.     }
  1030.     if (material.specular != DefaultSpecular)
  1031.     {
  1032.         out << "specular " <<
  1033.             material.specular.red() << ' ' <<
  1034.             material.specular.green() << ' ' <<
  1035.             material.specular.blue() << 'n';
  1036.     }
  1038.     if (material.specularPower != DefaultSpecularPower)
  1039.         out << "specpower " << material.specularPower << 'n';
  1041.     if (material.opacity != DefaultOpacity)
  1042.         out << "opacity " << material.opacity << 'n';
  1044.     if (material.blend != DefaultBlend)
  1045.     {
  1046.         out << "blend ";
  1047.         switch (material.blend)
  1048.         {
  1049.         case Mesh::NormalBlend:
  1050.             out << "normal";
  1051.             break;
  1052.         case Mesh::AdditiveBlend:
  1053.             out << "add";
  1054.             break;
  1055.         case Mesh::PremultipliedAlphaBlend:
  1056.             out << "premultiplied";
  1057.             break;
  1058.         default:
  1059.             assert(0);
  1060.             break;
  1061.         }
  1062.         out << "n";
  1063.     }
  1065.     for (int i = 0; i < Mesh::TextureSemanticMax; i++)
  1066.     {
  1067.         const TextureInfo* texInfo = GetTextureManager()->getResourceInfo(material.maps[i]);
  1068.         if (texInfo != NULL)
  1069.         {
  1070.             switch (Mesh::TextureSemantic(i))
  1071.             {
  1072.             case Mesh::DiffuseMap:
  1073.                 out << "texture0";
  1074.                 break;
  1075.             case Mesh::NormalMap:
  1076.                 out << "normalmap";
  1077.                 break;
  1078.             case Mesh::SpecularMap:
  1079.                 out << "specularmap";
  1080.                 break;
  1081.             case Mesh::EmissiveMap:
  1082.                 out << "emissivemap";
  1083.                 break;
  1084.             default:
  1085.                 assert(0);
  1086.             }
  1088.             out << " "" << texInfo->source << ""n";
  1089.         }
  1090.     }
  1092. #if 0
  1093.     if (material.maps[Mesh::DiffuseMap] != InvalidResource)
  1094.     {
  1095.         const TextureInfo* texInfo = GetTextureManager()->getResourceInfo(material.tex0);
  1096.         if (texInfo != NULL)
  1097.             out << "texture0 "" << texInfo->source << ""n";
  1098.     }
  1100.     if (material.tex1 != InvalidResource)
  1101.     {
  1102.         const TextureInfo* texInfo = GetTextureManager()->getResourceInfo(material.tex1);
  1103.         if (texInfo != NULL)
  1104.             out << "texture1 "" << texInfo->source << ""n";
  1105.     }
  1106. #endif
  1109.     out << "end_materialn";
  1110. }
  1113. /***** Binary loader *****/
  1115. BinaryModelLoader::BinaryModelLoader(istream& _in) :
  1116.     in(_in)
  1117. {
  1118. }
  1121. BinaryModelLoader::~BinaryModelLoader()
  1122. {
  1123. }
  1126. void
  1127. BinaryModelLoader::reportError(const string& msg)
  1128. {
  1129.     char buf[32];
  1130.     sprintf(buf, " (offset %d)", 0);
  1131.     ModelLoader::reportError(msg + string(buf));
  1132. }
  1135. // Read a big-endian 32-bit unsigned integer
  1136. static int32 readUint(istream& in)
  1137. {
  1138.     int32 ret;
  1139.     in.read((char*) &ret, sizeof(int32));
  1140.     LE_TO_CPU_INT32(ret, ret);
  1141.     return (uint32) ret;
  1142. }
  1145. static float readFloat(istream& in)
  1146. {
  1147.     float f;
  1148.     in.read((char*) &f, sizeof(float));
  1149.     LE_TO_CPU_FLOAT(f, f);
  1150.     return f;
  1151. }
  1154. static int16 readInt16(istream& in)
  1155. {
  1156.     int16 ret;
  1157.     in.read((char *) &ret, sizeof(int16));
  1158.     LE_TO_CPU_INT16(ret, ret);
  1159.     return ret;
  1160. }
  1163. static ModelFileToken readToken(istream& in)
  1164. {
  1165.     return (ModelFileToken) readInt16(in);
  1166. }
  1169. static ModelFileType readType(istream& in)
  1170. {
  1171.     return (ModelFileType) readInt16(in);
  1172. }
  1175. static bool readTypeFloat1(istream& in, float& f)
  1176. {
  1177.     if (readType(in) != CMOD_Float1)
  1178.         return false;
  1179.     f = readFloat(in);
  1180.     return true;
  1181. }
  1184. static bool readTypeColor(istream& in, Color& c)
  1185. {
  1186.     if (readType(in) != CMOD_Color)
  1187.         return false;
  1189.     float r = readFloat(in);
  1190.     float g = readFloat(in);
  1191.     float b = readFloat(in);
  1192.     c = Color(r, g, b);
  1194.     return true;
  1195. }
  1198. static bool readTypeString(istream& in, string& s)
  1199. {
  1200.     if (readType(in) != CMOD_String)
  1201.         return false;
  1203.     uint16 len;
  1204.     in.read((char*) &len, sizeof(uint16));
  1205.     LE_TO_CPU_INT16(len, len);
  1207.     if (len == 0)
  1208.     {
  1209.         s = "";
  1210.     }
  1211.     else
  1212.     {
  1213.         char* buf = new char[len];
  1214.         in.read(buf, len);
  1215.         s = string(buf, len);
  1216.         delete[] buf;
  1217.     }
  1219.     return true;
  1220. }
  1223. static bool ignoreValue(istream& in)
  1224. {
  1225.     ModelFileType type = readType(in);
  1226.     int size = 0;
  1228.     switch (type)
  1229.     {
  1230.     case CMOD_Float1:
  1231.         size = 4;
  1232.         break;
  1233.     case CMOD_Float2:
  1234.         size = 8;
  1235.         break;
  1236.     case CMOD_Float3:
  1237.         size = 12;
  1238.         break;
  1239.     case CMOD_Float4:
  1240.         size = 16;
  1241.         break;
  1242.     case CMOD_Uint32:
  1243.         size = 4;
  1244.         break;
  1245.     case CMOD_Color:
  1246.         size = 12;
  1247.         break;
  1248.     case CMOD_String:
  1249.         {
  1250.             uint16 len;
  1251.             in.read((char*) &len, sizeof(uint16));
  1252.             LE_TO_CPU_INT16(len, len);
  1253.             size = len;
  1254.         }
  1255.         break;
  1257.     default:
  1258.         return false;
  1259.     }
  1261.     in.ignore(size);
  1263.     return true;
  1264. }
  1267. Model*
  1268. BinaryModelLoader::load()
  1269. {
  1270.     Model* model = new Model();
  1271.     bool seenMeshes = false;
  1273.     if (model == NULL)
  1274.     {
  1275.         reportError("Unable to allocate memory for model");
  1276.         return NULL;
  1277.     }
  1279.     // Parse material and mesh definitions
  1280.     for (;;)
  1281.     {
  1282.         ModelFileToken tok = readToken(in);
  1284.         if (in.eof())
  1285.         {
  1286.             break;
  1287.         }
  1288.         else if (tok == CMOD_Material)
  1289.         {
  1290.             if (seenMeshes)
  1291.             {
  1292.                 reportError("Materials must be defined before meshes");
  1293.                 delete model;
  1294.                 return NULL;
  1295.             }
  1297.             Mesh::Material* material = loadMaterial();
  1298.             if (material == NULL)
  1299.             {
  1300.                 delete model;
  1301.                 return NULL;
  1302.             }
  1304.             model->addMaterial(material);
  1305.         }
  1306.         else if (tok == CMOD_Mesh)
  1307.         {
  1308.             seenMeshes = true;
  1310.             Mesh* mesh = loadMesh();
  1311.             if (mesh == NULL)
  1312.             {
  1313.                 delete model;
  1314.                 return NULL;
  1315.             }
  1317.             model->addMesh(mesh);
  1318.         }
  1319.         else
  1320.         {
  1321.             reportError("Error: Unknown block type in model");
  1322.             delete model;
  1323.             return NULL;
  1324.         }
  1325.     }
  1327.     return model;
  1328. }
  1331. Mesh::Material*
  1332. BinaryModelLoader::loadMaterial()
  1333. {
  1334.     Mesh::Material* material = new Mesh::Material();
  1336.     material->diffuse = DefaultDiffuse;
  1337.     material->specular = DefaultSpecular;
  1338.     material->emissive = DefaultEmissive;
  1339.     material->specularPower = DefaultSpecularPower;
  1340.     material->opacity = DefaultOpacity;
  1342.     for (;;)
  1343.     {
  1344.         ModelFileToken tok = readToken(in);
  1345.         switch (tok)
  1346.         {
  1347.         case CMOD_Diffuse:
  1348.             if (!readTypeColor(in, material->diffuse))
  1349.             {
  1350.                 reportError("Incorrect type for diffuse color");
  1351.                 delete material;
  1352.                 return NULL;
  1353.             }
  1354.             break;
  1356.         case CMOD_Specular:
  1357.             if (!readTypeColor(in, material->specular))
  1358.             {
  1359.                 reportError("Incorrect type for specular color");
  1360.                 delete material;
  1361.                 return NULL;
  1362.             }
  1363.             break;
  1365.         case CMOD_Emissive:
  1366.             if (!readTypeColor(in, material->emissive))
  1367.             {
  1368.                 reportError("Incorrect type for emissive color");
  1369.                 delete material;
  1370.                 return NULL;
  1371.             }
  1372.             break;
  1374.         case CMOD_SpecularPower:
  1375.             if (!readTypeFloat1(in, material->specularPower))
  1376.             {
  1377.                 reportError("Float expected for specularPower");
  1378.                 delete material;
  1379.                 return NULL;
  1380.             }
  1381.             break;
  1383.         case CMOD_Opacity:
  1384.             if (!readTypeFloat1(in, material->opacity))
  1385.             {
  1386.                 reportError("Float expected for opacity");
  1387.                 delete material;
  1388.                 return NULL;
  1389.             }
  1390.             break;
  1392.         case CMOD_Blend:
  1393.             {
  1394.                 int16 blendMode = readInt16(in);
  1395.                 if (blendMode < 0 || blendMode >= Mesh::BlendMax)
  1396.                 {
  1397.                     reportError("Bad blend mode");
  1398.                     delete material;
  1399.                     return NULL;
  1400.                 }
  1401.                 material->blend = (Mesh::BlendMode) blendMode;
  1402.             }
  1403.             break;
  1405.         case CMOD_Texture:
  1406.             {
  1407.                 int16 texType = readInt16(in);
  1408.                 if (texType < 0 || texType >= Mesh::TextureSemanticMax)
  1409.                 {
  1410.                     reportError("Bad texture type");
  1411.                     delete material;
  1412.                     return NULL;
  1413.                 }
  1415.                 string texfile;
  1416.                 if (!readTypeString(in, texfile))
  1417.                 {
  1418.                     reportError("String expected for texture filename");
  1419.                     delete material;
  1420.                     return NULL;
  1421.                 }
  1423.                 if (texfile.empty())
  1424.                 {
  1425.                     reportError("Zero length texture name in material definition");
  1426.                     delete material;
  1427.                     return NULL;
  1428.                 }
  1430.                 ResourceHandle tex = GetTextureManager()->getHandle(TextureInfo(texfile, getTexturePath(), TextureInfo::WrapTexture));
  1432.                 material->maps[texType] = tex;
  1433.             }
  1434.             break;
  1436.         case CMOD_EndMaterial:
  1437.             return material;
  1439.         default:
  1440.             // Skip unrecognized tokens
  1441.             if (!ignoreValue(in))
  1442.             {
  1443.                 delete material;
  1444.                 return NULL;
  1445.             }
  1446.         } // switch
  1447.     } // for
  1448. }
  1451. Mesh::VertexDescription*
  1452. BinaryModelLoader::loadVertexDescription()
  1453. {
  1454.     if (readToken(in) != CMOD_VertexDesc)
  1455.     {
  1456.         reportError("Vertex description expected");
  1457.         return NULL;
  1458.     }
  1460.     int maxAttributes = 16;
  1461.     int nAttributes = 0;
  1462.     uint32 offset = 0;
  1463.     Mesh::VertexAttribute* attributes = new Mesh::VertexAttribute[maxAttributes];
  1465.     for (;;)
  1466.     {
  1467.         int16 tok = readInt16(in);
  1469.         if (tok == CMOD_EndVertexDesc)
  1470.         {
  1471.             break;
  1472.         }
  1473.         else if (tok >= 0 && tok < Mesh::SemanticMax)
  1474.         {
  1475.             int16 fmt = readInt16(in);
  1476.             if (fmt < 0 || fmt >= Mesh::FormatMax)
  1477.             {
  1478.                 reportError("Invalid vertex attribute type");
  1479.                 delete[] attributes;
  1480.                 return NULL;
  1481.             }
  1482.             else
  1483.             {
  1484.                 if (nAttributes == maxAttributes)
  1485.                 {
  1486.                     reportError("Too many attributes in vertex description");
  1487.                     delete[] attributes;
  1488.                     return NULL;
  1489.                 }
  1491.                 attributes[nAttributes].semantic =
  1492.                     static_cast<Mesh::VertexAttributeSemantic>(tok);
  1493.                 attributes[nAttributes].format =
  1494.                     static_cast<Mesh::VertexAttributeFormat>(fmt);
  1495.                 attributes[nAttributes].offset = offset;
  1497.                 offset += Mesh::getVertexAttributeSize(attributes[nAttributes].format);
  1498.                 nAttributes++;
  1499.             }
  1500.         }
  1501.         else
  1502.         {
  1503.             reportError("Invalid semantic in vertex description");
  1504.             delete[] attributes;
  1505.             return NULL;
  1506.         }
  1507.     }
  1509.     if (nAttributes == 0)
  1510.     {
  1511.         reportError("Vertex definitition cannot be empty");
  1512.         delete[] attributes;
  1513.         return NULL;
  1514.     }
  1516.     Mesh::VertexDescription *vertexDesc =
  1517.         new Mesh::VertexDescription(offset, nAttributes, attributes);
  1518.     delete[] attributes;
  1519.     return vertexDesc;
  1520. }
  1523. Mesh*
  1524. BinaryModelLoader::loadMesh()
  1525. {
  1526.     Mesh::VertexDescription* vertexDesc = loadVertexDescription();
  1527.     if (vertexDesc == NULL)
  1528.         return NULL;
  1530.     uint32 vertexCount = 0;
  1531.     char* vertexData = loadVertices(*vertexDesc, vertexCount);
  1532.     if (vertexData == NULL)
  1533.     {
  1534.         delete vertexDesc;
  1535.         return NULL;
  1536.     }
  1538.     Mesh* mesh = new Mesh();
  1539.     mesh->setVertexDescription(*vertexDesc);
  1540.     mesh->setVertices(vertexCount, vertexData);
  1541.     delete vertexDesc;
  1543.     for (;;)
  1544.     {
  1545.         int16 tok = readInt16(in);
  1547.         if (tok == CMOD_EndMesh)
  1548.         {
  1549.             break;
  1550.         }
  1551.         else if (tok < 0 || tok >= Mesh::PrimitiveTypeMax)
  1552.         {
  1553.             reportError("Bad primitive group type");
  1554.             delete mesh;
  1555.             return NULL;
  1556.         }
  1558.         Mesh::PrimitiveGroupType type =
  1559.             static_cast<Mesh::PrimitiveGroupType>(tok);
  1560.         uint32 materialIndex = readUint(in);
  1561.         uint32 indexCount = readUint(in);
  1563.         uint32* indices = new uint32[indexCount];
  1564.         if (indices == NULL)
  1565.         {
  1566.             reportError("Not enough memory to hold indices");
  1567.             delete mesh;
  1568.             return NULL;
  1569.         }
  1571.         for (uint32 i = 0; i < indexCount; i++)
  1572.         {
  1573.             uint32 index = readUint(in);
  1574.             if (index >= vertexCount)
  1575.             {
  1576.                 reportError("Index out of range");
  1577.                 delete indices;
  1578.                 delete mesh;
  1579.                 return NULL;
  1580.             }
  1582.             indices[i] = index;
  1583.         }
  1585.         mesh->addGroup(type, materialIndex, indexCount, indices);
  1586.     }
  1588.     return mesh;
  1589. }
  1592. char*
  1593. BinaryModelLoader::loadVertices(const Mesh::VertexDescription& vertexDesc,
  1594.                                 uint32& vertexCount)
  1595. {
  1596.     if (readToken(in) != CMOD_Vertices)
  1597.     {
  1598.         reportError("Vertex data expected");
  1599.         return NULL;
  1600.     }
  1602.     vertexCount = readUint(in);
  1603.     uint32 vertexDataSize = vertexDesc.stride * vertexCount;
  1604.     char* vertexData = new char[vertexDataSize];
  1605.     if (vertexData == NULL)
  1606.     {
  1607.         reportError("Not enough memory to hold vertex data");
  1608.         return NULL;
  1609.     }
  1611.     uint32 offset = 0;
  1613.     for (uint32 i = 0; i < vertexCount; i++, offset += vertexDesc.stride)
  1614.     {
  1615.         assert(offset < vertexDataSize);
  1616.         for (uint32 attr = 0; attr < vertexDesc.nAttributes; attr++)
  1617.         {
  1618.             uint32 base = offset + vertexDesc.attributes[attr].offset;
  1619.             Mesh::VertexAttributeFormat fmt = vertexDesc.attributes[attr].format;
  1620.             /*int readCount = 0;    Unused*/
  1621.             switch (fmt)
  1622.             {
  1623.             case Mesh::Float1:
  1624.                 reinterpret_cast<float*>(vertexData + base)[0] = readFloat(in);
  1625.                 break;
  1626.             case Mesh::Float2:
  1627.                 reinterpret_cast<float*>(vertexData + base)[0] = readFloat(in);
  1628.                 reinterpret_cast<float*>(vertexData + base)[1] = readFloat(in);
  1629.                 break;
  1630.             case Mesh::Float3:
  1631.                 reinterpret_cast<float*>(vertexData + base)[0] = readFloat(in);
  1632.                 reinterpret_cast<float*>(vertexData + base)[1] = readFloat(in);
  1633.                 reinterpret_cast<float*>(vertexData + base)[2] = readFloat(in);
  1634.                 break;
  1635.             case Mesh::Float4:
  1636.                 reinterpret_cast<float*>(vertexData + base)[0] = readFloat(in);
  1637.                 reinterpret_cast<float*>(vertexData + base)[1] = readFloat(in);
  1638.                 reinterpret_cast<float*>(vertexData + base)[2] = readFloat(in);
  1639.                 reinterpret_cast<float*>(vertexData + base)[3] = readFloat(in);
  1640.                 break;
  1641.             case Mesh::UByte4:
  1642.                 in.get(reinterpret_cast<char*>(vertexData + base), 4);
  1643.                 break;
  1644.             default:
  1645.                 assert(0);
  1646.                 delete[] vertexData;
  1647.                 return NULL;
  1648.             }
  1649.         }
  1650.     }
  1652.     return vertexData;
  1653. }
  1657. /***** Binary writer *****/
  1659. BinaryModelWriter::BinaryModelWriter(ostream& _out) :
  1660.     out(_out)
  1661. {
  1662. }
  1665. BinaryModelWriter::~BinaryModelWriter()
  1666. {
  1667. }
  1670. // Utility functions for writing binary values to a file
  1671. static void writeUint(ostream& out, uint32 val)
  1672. {
  1673.     LE_TO_CPU_INT32(val, val);
  1674.     out.write(reinterpret_cast<char*>(&val), sizeof(uint32));
  1675. }
  1677. static void writeFloat(ostream& out, float val)
  1678. {
  1679.     LE_TO_CPU_FLOAT(val, val);
  1680.     out.write(reinterpret_cast<char*>(&val), sizeof(float));
  1681. }
  1683. static void writeInt16(ostream& out, int16 val)
  1684. {
  1685.     LE_TO_CPU_INT16(val, val);
  1686.     out.write(reinterpret_cast<char*>(&val), sizeof(int16));
  1687. }
  1689. static void writeToken(ostream& out, ModelFileToken val)
  1690. {
  1691.     writeInt16(out, static_cast<int16>(val));
  1692. }
  1694. static void writeType(ostream& out, ModelFileType val)
  1695. {
  1696.     writeInt16(out, static_cast<int16>(val));
  1697. }
  1700. static void writeTypeFloat1(ostream& out, float f)
  1701. {
  1702.     writeType(out, CMOD_Float1);
  1703.     writeFloat(out, f);
  1704. }
  1707. static void writeTypeColor(ostream& out, const Color& c)
  1708. {
  1709.     writeType(out, CMOD_Color);
  1710.     writeFloat(out, c.red());
  1711.     writeFloat(out, c.green());
  1712.     writeFloat(out, c.blue());
  1713. }
  1716. static void writeTypeString(ostream& out, const string& s)
  1717. {
  1718.     writeType(out, CMOD_String);
  1719.     writeInt16(out, static_cast<int16>(s.length()));
  1720.     out.write(s.c_str(), s.length());
  1721. }
  1724. bool
  1725. BinaryModelWriter::write(const Model& model)
  1726. {
  1727.     out << CEL_MODEL_HEADER_BINARY;
  1729.     for (uint32 matIndex = 0; model.getMaterial(matIndex); matIndex++)
  1730.         writeMaterial(*model.getMaterial(matIndex));
  1732.     for (uint32 meshIndex = 0; model.getMesh(meshIndex); meshIndex++)
  1733.         writeMesh(*model.getMesh(meshIndex));
  1735.     return true;
  1736. }
  1739. void
  1740. BinaryModelWriter::writeGroup(const Mesh::PrimitiveGroup& group)
  1741. {
  1742.     writeInt16(out, static_cast<int16>(group.prim));
  1743.     writeUint(out, group.materialIndex);
  1744.     writeUint(out, group.nIndices);
  1746.     // Print the indices, twelve per line
  1747.     for (uint32 i = 0; i < group.nIndices; i++)
  1748.         writeUint(out, group.indices[i]);
  1749. }
  1752. void
  1753. BinaryModelWriter::writeMesh(const Mesh& mesh)
  1754. {
  1755.     writeToken(out, CMOD_Mesh);
  1757.     writeVertexDescription(mesh.getVertexDescription());
  1759.     writeVertices(mesh.getVertexData(),
  1760.                   mesh.getVertexCount(),
  1761.                   mesh.getVertexStride(),
  1762.                   mesh.getVertexDescription());
  1764.     for (uint32 groupIndex = 0; mesh.getGroup(groupIndex); groupIndex++)
  1765.         writeGroup(*mesh.getGroup(groupIndex));
  1767.     writeToken(out, CMOD_EndMesh);
  1768. }
  1771. void
  1772. BinaryModelWriter::writeVertices(const void* vertexData,
  1773.                                  uint32 nVertices,
  1774.                                  uint32 stride,
  1775.                                  const Mesh::VertexDescription& desc)
  1776. {
  1777.     const char* vertex = reinterpret_cast<const char*>(vertexData);
  1779.     writeToken(out, CMOD_Vertices);
  1780.     writeUint(out, nVertices);
  1782.     for (uint32 i = 0; i < nVertices; i++, vertex += stride)
  1783.     {
  1784.         for (uint32 attr = 0; attr < desc.nAttributes; attr++)
  1785.         {
  1786.             const char* cdata = vertex + desc.attributes[attr].offset;
  1787.             const float* fdata = reinterpret_cast<const float*>(cdata);
  1789.             switch (desc.attributes[attr].format)
  1790.             {
  1791.             case Mesh::Float1:
  1792.                 writeFloat(out, fdata[0]);
  1793.                 break;
  1794.             case Mesh::Float2:
  1795.                 writeFloat(out, fdata[0]);
  1796.                 writeFloat(out, fdata[1]);
  1797.                 break;
  1798.             case Mesh::Float3:
  1799.                 writeFloat(out, fdata[0]);
  1800.                 writeFloat(out, fdata[1]);
  1801.                 writeFloat(out, fdata[2]);
  1802.                 break;
  1803.             case Mesh::Float4:
  1804.                 writeFloat(out, fdata[0]);
  1805.                 writeFloat(out, fdata[1]);
  1806.                 writeFloat(out, fdata[2]);
  1807.                 writeFloat(out, fdata[3]);
  1808.                 break;
  1809.             case Mesh::UByte4:
  1810.                 out.write(cdata, 4);
  1811.                 break;
  1812.             default:
  1813.                 assert(0);
  1814.                 break;
  1815.             }
  1816.         }
  1817.     }
  1818. }
  1821. void
  1822. BinaryModelWriter::writeVertexDescription(const Mesh::VertexDescription& desc)
  1823. {
  1824.     writeToken(out, CMOD_VertexDesc);
  1826.     for (uint32 attr = 0; attr < desc.nAttributes; attr++)
  1827.     {
  1828.         writeInt16(out, static_cast<int16>(desc.attributes[attr].semantic));
  1829.         writeInt16(out, static_cast<int16>(desc.attributes[attr].format));
  1830.     }
  1832.     writeToken(out, CMOD_EndVertexDesc);
  1833. }
  1836. void
  1837. BinaryModelWriter::writeMaterial(const Mesh::Material& material)
  1838. {
  1839.     writeToken(out, CMOD_Material);
  1841.     if (material.diffuse != DefaultDiffuse)
  1842.     {
  1843.         writeToken(out, CMOD_Diffuse);
  1844.         writeTypeColor(out, material.diffuse);
  1845.     }
  1847.     if (material.emissive != DefaultEmissive)
  1848.     {
  1849.         writeToken(out, CMOD_Emissive);
  1850.         writeTypeColor(out, material.emissive);
  1851.     }
  1853.     if (material.specular != DefaultSpecular)
  1854.     {
  1855.         writeToken(out, CMOD_Specular);
  1856.         writeTypeColor(out, material.specular);
  1857.     }
  1859.     if (material.specularPower != DefaultSpecularPower)
  1860.     {
  1861.         writeToken(out, CMOD_SpecularPower);
  1862.         writeTypeFloat1(out, material.specularPower);
  1863.     }
  1865.     if (material.opacity != DefaultOpacity)
  1866.     {
  1867.         writeToken(out, CMOD_Opacity);
  1868.         writeTypeFloat1(out, material.opacity);
  1869.     }
  1871.     if (material.blend != DefaultBlend)
  1872.     {
  1873.         writeToken(out, CMOD_Blend);
  1874.         writeInt16(out, (int16) material.blend);
  1875.     }
  1877.     for (int i = 0; i < Mesh::TextureSemanticMax; i++)
  1878.     {
  1879.         if (material.maps[i] != InvalidResource)
  1880.         {
  1881.             const TextureInfo* texInfo = GetTextureManager()->getResourceInfo(material.maps[i]);
  1882.             if (texInfo != NULL)
  1883.             {
  1884.                 writeToken(out, CMOD_Texture);
  1885.                 writeInt16(out, (int16) i);
  1886.                 writeTypeString(out, texInfo->source);
  1887.             }
  1888.         }
  1889.     }
  1890. #if 0
  1891.     if (material.tex1 != InvalidResource)
  1892.     {
  1893.         const TextureInfo* texInfo = GetTextureManager()->getResourceInfo(material.tex1);
  1894.         if (texInfo != NULL)
  1895.         {
  1896.             writeToken(out, CMOD_Texture1);
  1897.             writeTypeString(out, texInfo->source);
  1898.         }
  1899.     }
  1900. #endif
  1902.     writeToken(out, CMOD_EndMaterial);
  1903. }