| /* |
| Open Asset Import Library (assimp) |
| ---------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, assimp team |
| All rights reserved. |
| |
| Redistribution and use of this software in source and binary forms, |
| with or without modification, are permitted provided that the |
| following conditions are met: |
| |
| * Redistributions of source code must retain the above |
| copyright notice, this list of conditions and the |
| following disclaimer. |
| |
| * Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the |
| following disclaimer in the documentation and/or other |
| materials provided with the distribution. |
| |
| * Neither the name of the assimp team, nor the names of its |
| contributors may be used to endorse or promote products |
| derived from this software without specific prior |
| written permission of the assimp team. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| ---------------------------------------------------------------------- |
| */ |
| |
| /** @file COBLoader.cpp |
| * @brief Implementation of the TrueSpace COB/SCN importer class. |
| */ |
| |
| |
| #ifndef ASSIMP_BUILD_NO_COB_IMPORTER |
| #include "COBLoader.h" |
| #include "COBScene.h" |
| |
| #include "StreamReader.h" |
| #include "ParsingUtils.h" |
| #include "fast_atof.h" |
| |
| #include "LineSplitter.h" |
| #include "TinyFormatter.h" |
| #include <memory> |
| #include <assimp/IOSystem.hpp> |
| #include <assimp/DefaultLogger.hpp> |
| #include <assimp/scene.h> |
| #include <assimp/importerdesc.h> |
| |
| using namespace Assimp; |
| using namespace Assimp::COB; |
| using namespace Assimp::Formatter; |
| |
| |
| static const float units[] = { |
| 1000.f, |
| 100.f, |
| 1.f, |
| 0.001f, |
| 1.f/0.0254f, |
| 1.f/0.3048f, |
| 1.f/0.9144f, |
| 1.f/1609.344f |
| }; |
| |
| static const aiImporterDesc desc = { |
| "TrueSpace Object Importer", |
| "", |
| "", |
| "little-endian files only", |
| aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour, |
| 0, |
| 0, |
| 0, |
| 0, |
| "cob scn" |
| }; |
| |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Constructor to be privately used by Importer |
| COBImporter::COBImporter() |
| {} |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Destructor, private as well |
| COBImporter::~COBImporter() |
| {} |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Returns whether the class can handle the format of the given file. |
| bool COBImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const |
| { |
| const std::string& extension = GetExtension(pFile); |
| if (extension == "cob" || extension == "scn") { |
| return true; |
| } |
| |
| else if ((!extension.length() || checkSig) && pIOHandler) { |
| const char* tokens[] = {"Caligary"}; |
| return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1); |
| } |
| return false; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Loader meta information |
| const aiImporterDesc* COBImporter::GetInfo () const |
| { |
| return &desc; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Setup configuration properties for the loader |
| void COBImporter::SetupProperties(const Importer* /*pImp*/) |
| { |
| // nothing to be done for the moment |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| /*static*/ AI_WONT_RETURN void COBImporter::ThrowException(const std::string& msg) |
| { |
| throw DeadlyImportError("COB: "+msg); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Imports the given file into the given scene structure. |
| void COBImporter::InternReadFile( const std::string& pFile, |
| aiScene* pScene, IOSystem* pIOHandler) |
| { |
| COB::Scene scene; |
| std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) ); |
| |
| // check header |
| char head[32]; |
| stream->CopyAndAdvance(head,32); |
| if (strncmp(head,"Caligari ",9)) { |
| ThrowException("Could not found magic id: `Caligari`"); |
| } |
| |
| DefaultLogger::get()->info("File format tag: "+std::string(head+9,6)); |
| if (head[16]!='L') { |
| ThrowException("File is big-endian, which is not supported"); |
| } |
| |
| // load data into intermediate structures |
| if (head[15]=='A') { |
| ReadAsciiFile(scene, stream.get()); |
| } |
| else { |
| ReadBinaryFile(scene, stream.get()); |
| } |
| if(scene.nodes.empty()) { |
| ThrowException("No nodes loaded"); |
| } |
| |
| // sort faces by material indices |
| for(std::shared_ptr< Node >& n : scene.nodes) { |
| if (n->type == Node::TYPE_MESH) { |
| Mesh& mesh = (Mesh&)(*n.get()); |
| for(Face& f : mesh.faces) { |
| mesh.temp_map[f.material].push_back(&f); |
| } |
| } |
| } |
| |
| // count meshes |
| for(std::shared_ptr< Node >& n : scene.nodes) { |
| if (n->type == Node::TYPE_MESH) { |
| Mesh& mesh = (Mesh&)(*n.get()); |
| if (mesh.vertex_positions.size() && mesh.texture_coords.size()) { |
| pScene->mNumMeshes += static_cast<unsigned int>(mesh.temp_map.size()); |
| } |
| } |
| } |
| pScene->mMeshes = new aiMesh*[pScene->mNumMeshes](); |
| pScene->mMaterials = new aiMaterial*[pScene->mNumMeshes](); |
| pScene->mNumMeshes = 0; |
| |
| // count lights and cameras |
| for(std::shared_ptr< Node >& n : scene.nodes) { |
| if (n->type == Node::TYPE_LIGHT) { |
| ++pScene->mNumLights; |
| } |
| else if (n->type == Node::TYPE_CAMERA) { |
| ++pScene->mNumCameras; |
| } |
| } |
| |
| if (pScene->mNumLights) { |
| pScene->mLights = new aiLight*[pScene->mNumLights](); |
| } |
| if (pScene->mNumCameras) { |
| pScene->mCameras = new aiCamera*[pScene->mNumCameras](); |
| } |
| pScene->mNumLights = pScene->mNumCameras = 0; |
| |
| // resolve parents by their IDs and build the output graph |
| std::unique_ptr<Node> root(new Group()); |
| for(size_t n = 0; n < scene.nodes.size(); ++n) { |
| const Node& nn = *scene.nodes[n].get(); |
| if(nn.parent_id==0) { |
| root->temp_children.push_back(&nn); |
| } |
| |
| for(size_t m = n; m < scene.nodes.size(); ++m) { |
| const Node& mm = *scene.nodes[m].get(); |
| if (mm.parent_id == nn.id) { |
| nn.temp_children.push_back(&mm); |
| } |
| } |
| } |
| |
| pScene->mRootNode = BuildNodes(*root.get(),scene,pScene); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void ConvertTexture(std::shared_ptr< Texture > tex, aiMaterial* out, aiTextureType type) |
| { |
| const aiString path( tex->path ); |
| out->AddProperty(&path,AI_MATKEY_TEXTURE(type,0)); |
| out->AddProperty(&tex->transform,1,AI_MATKEY_UVTRANSFORM(type,0)); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill) |
| { |
| aiNode* nd = new aiNode(); |
| nd->mName.Set(root.name); |
| nd->mTransformation = root.transform; |
| |
| // Note to everybody believing Voodoo is appropriate here: |
| // I know polymorphism, run as fast as you can ;-) |
| if (Node::TYPE_MESH == root.type) { |
| const Mesh& ndmesh = (const Mesh&)(root); |
| if (ndmesh.vertex_positions.size() && ndmesh.texture_coords.size()) { |
| |
| typedef std::pair<unsigned int,Mesh::FaceRefList> Entry; |
| for(const Entry& reflist : ndmesh.temp_map) { |
| { // create mesh |
| size_t n = 0; |
| for(Face* f : reflist.second) { |
| n += f->indices.size(); |
| } |
| if (!n) { |
| continue; |
| } |
| aiMesh* outmesh = fill->mMeshes[fill->mNumMeshes++] = new aiMesh(); |
| ++nd->mNumMeshes; |
| |
| outmesh->mVertices = new aiVector3D[n]; |
| outmesh->mTextureCoords[0] = new aiVector3D[n]; |
| |
| outmesh->mFaces = new aiFace[reflist.second.size()](); |
| for(Face* f : reflist.second) { |
| if (f->indices.empty()) { |
| continue; |
| } |
| |
| aiFace& fout = outmesh->mFaces[outmesh->mNumFaces++]; |
| fout.mIndices = new unsigned int[f->indices.size()]; |
| |
| for(VertexIndex& v : f->indices) { |
| if (v.pos_idx >= ndmesh.vertex_positions.size()) { |
| ThrowException("Position index out of range"); |
| } |
| if (v.uv_idx >= ndmesh.texture_coords.size()) { |
| ThrowException("UV index out of range"); |
| } |
| outmesh->mVertices[outmesh->mNumVertices] = ndmesh.vertex_positions[ v.pos_idx ]; |
| outmesh->mTextureCoords[0][outmesh->mNumVertices] = aiVector3D( |
| ndmesh.texture_coords[ v.uv_idx ].x, |
| ndmesh.texture_coords[ v.uv_idx ].y, |
| 0.f |
| ); |
| |
| fout.mIndices[fout.mNumIndices++] = outmesh->mNumVertices++; |
| } |
| } |
| outmesh->mMaterialIndex = fill->mNumMaterials; |
| }{ // create material |
| const Material* min = NULL; |
| for(const Material& m : scin.materials) { |
| if (m.parent_id == ndmesh.id && m.matnum == reflist.first) { |
| min = &m; |
| break; |
| } |
| } |
| std::unique_ptr<const Material> defmat; |
| if(!min) { |
| DefaultLogger::get()->debug(format()<<"Could not resolve material index " |
| <<reflist.first<<" - creating default material for this slot"); |
| |
| defmat.reset(min=new Material()); |
| } |
| |
| aiMaterial* mat = new aiMaterial(); |
| fill->mMaterials[fill->mNumMaterials++] = mat; |
| |
| const aiString s(format("#mat_")<<fill->mNumMeshes<<"_"<<min->matnum); |
| mat->AddProperty(&s,AI_MATKEY_NAME); |
| |
| if(int tmp = ndmesh.draw_flags & Mesh::WIRED ? 1 : 0) { |
| mat->AddProperty(&tmp,1,AI_MATKEY_ENABLE_WIREFRAME); |
| } |
| |
| { int shader; |
| switch(min->shader) |
| { |
| case Material::FLAT: |
| shader = aiShadingMode_Gouraud; |
| break; |
| |
| case Material::PHONG: |
| shader = aiShadingMode_Phong; |
| break; |
| |
| case Material::METAL: |
| shader = aiShadingMode_CookTorrance; |
| break; |
| |
| default: |
| ai_assert(false); // shouldn't be here |
| } |
| mat->AddProperty(&shader,1,AI_MATKEY_SHADING_MODEL); |
| if(shader != aiShadingMode_Gouraud) { |
| mat->AddProperty(&min->exp,1,AI_MATKEY_SHININESS); |
| } |
| } |
| |
| mat->AddProperty(&min->ior,1,AI_MATKEY_REFRACTI); |
| mat->AddProperty(&min->rgb,1,AI_MATKEY_COLOR_DIFFUSE); |
| |
| aiColor3D c = aiColor3D(min->rgb)*min->ks; |
| mat->AddProperty(&c,1,AI_MATKEY_COLOR_SPECULAR); |
| |
| c = aiColor3D(min->rgb)*min->ka; |
| mat->AddProperty(&c,1,AI_MATKEY_COLOR_AMBIENT); |
| |
| // convert textures if some exist. |
| if(min->tex_color) { |
| ConvertTexture(min->tex_color,mat,aiTextureType_DIFFUSE); |
| } |
| if(min->tex_env) { |
| ConvertTexture(min->tex_env ,mat,aiTextureType_UNKNOWN); |
| } |
| if(min->tex_bump) { |
| ConvertTexture(min->tex_bump ,mat,aiTextureType_HEIGHT); |
| } |
| } |
| } |
| } |
| } |
| else if (Node::TYPE_LIGHT == root.type) { |
| const Light& ndlight = (const Light&)(root); |
| aiLight* outlight = fill->mLights[fill->mNumLights++] = new aiLight(); |
| |
| outlight->mName.Set(ndlight.name); |
| outlight->mColorDiffuse = outlight->mColorAmbient = outlight->mColorSpecular = ndlight.color; |
| |
| outlight->mAngleOuterCone = AI_DEG_TO_RAD(ndlight.angle); |
| outlight->mAngleInnerCone = AI_DEG_TO_RAD(ndlight.inner_angle); |
| |
| // XXX |
| outlight->mType = ndlight.ltype==Light::SPOT ? aiLightSource_SPOT : aiLightSource_DIRECTIONAL; |
| } |
| else if (Node::TYPE_CAMERA == root.type) { |
| const Camera& ndcam = (const Camera&)(root); |
| aiCamera* outcam = fill->mCameras[fill->mNumCameras++] = new aiCamera(); |
| |
| outcam->mName.Set(ndcam.name); |
| } |
| |
| // add meshes |
| if (nd->mNumMeshes) { // mMeshes must be NULL if count is 0 |
| nd->mMeshes = new unsigned int[nd->mNumMeshes]; |
| for(unsigned int i = 0; i < nd->mNumMeshes;++i) { |
| nd->mMeshes[i] = fill->mNumMeshes-i-1; |
| } |
| } |
| |
| // add children recursively |
| nd->mChildren = new aiNode*[root.temp_children.size()](); |
| for(const Node* n : root.temp_children) { |
| (nd->mChildren[nd->mNumChildren++] = BuildNodes(*n,scin,fill))->mParent = nd; |
| } |
| |
| return nd; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Read an ASCII file into the given scene data structure |
| void COBImporter::ReadAsciiFile(Scene& out, StreamReaderLE* stream) |
| { |
| ChunkInfo ci; |
| for(LineSplitter splitter(*stream);splitter;++splitter) { |
| |
| // add all chunks to be recognized here. /else ../ omitted intentionally. |
| if (splitter.match_start("PolH ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadPolH_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("BitM ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadBitM_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("Mat1 ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadMat1_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("Grou ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadGrou_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("Lght ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadLght_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("Came ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadCame_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("Bone ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadBone_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("Chan ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadChan_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("Unit ")) { |
| ReadChunkInfo_Ascii(ci,splitter); |
| ReadUnit_Ascii(out,splitter,ci); |
| } |
| if (splitter.match_start("END ")) { |
| // we don't need this, but I guess there is a reason this |
| // chunk has been implemented into COB for. |
| return; |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadChunkInfo_Ascii(ChunkInfo& out, const LineSplitter& splitter) |
| { |
| const char* all_tokens[8]; |
| splitter.get_tokens(all_tokens); |
| |
| out.version = (all_tokens[1][1]-'0')*100+(all_tokens[1][3]-'0')*10+(all_tokens[1][4]-'0'); |
| out.id = strtoul10(all_tokens[3]); |
| out.parent_id = strtoul10(all_tokens[5]); |
| out.size = strtol10(all_tokens[7]); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::UnsupportedChunk_Ascii(LineSplitter& splitter, const ChunkInfo& nfo, const char* name) |
| { |
| const std::string error = format("Encountered unsupported chunk: ") << name << |
| " [version: "<<nfo.version<<", size: "<<nfo.size<<"]"; |
| |
| // we can recover if the chunk size was specified. |
| if(nfo.size != static_cast<unsigned int>(-1)) { |
| DefaultLogger::get()->error(error); |
| |
| // (HACK) - our current position in the stream is the beginning of the |
| // head line of the next chunk. That's fine, but the caller is going |
| // to call ++ on `splitter`, which we need to swallow to avoid |
| // missing the next line. |
| splitter.get_stream().IncPtr(nfo.size); |
| splitter.swallow_next_increment(); |
| } |
| else ThrowException(error); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::LogWarn_Ascii(const LineSplitter& splitter, const format& message) { |
| LogWarn_Ascii(message << " [at line "<< splitter.get_index()<<"]"); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::LogError_Ascii(const LineSplitter& splitter, const format& message) { |
| LogError_Ascii(message << " [at line "<< splitter.get_index()<<"]"); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::LogInfo_Ascii(const LineSplitter& splitter, const format& message) { |
| LogInfo_Ascii(message << " [at line "<< splitter.get_index()<<"]"); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::LogDebug_Ascii(const LineSplitter& splitter, const format& message) { |
| LogDebug_Ascii(message << " [at line "<< splitter.get_index()<<"]"); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::LogWarn_Ascii(const Formatter::format& message) { |
| DefaultLogger::get()->warn(std::string("COB: ")+=message); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::LogError_Ascii(const Formatter::format& message) { |
| DefaultLogger::get()->error(std::string("COB: ")+=message); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::LogInfo_Ascii(const Formatter::format& message) { |
| DefaultLogger::get()->info(std::string("COB: ")+=message); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::LogDebug_Ascii(const Formatter::format& message) { |
| DefaultLogger::get()->debug(std::string("COB: ")+=message); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadBasicNodeInfo_Ascii(Node& msh, LineSplitter& splitter, const ChunkInfo& /*nfo*/) |
| { |
| for(;splitter;++splitter) { |
| if (splitter.match_start("Name")) { |
| msh.name = std::string(splitter[1]); |
| |
| // make nice names by merging the dupe count |
| std::replace(msh.name.begin(),msh.name.end(), |
| ',','_'); |
| } |
| else if (splitter.match_start("Transform")) { |
| for(unsigned int y = 0; y < 4 && ++splitter; ++y) { |
| const char* s = splitter->c_str(); |
| for(unsigned int x = 0; x < 4; ++x) { |
| SkipSpaces(&s); |
| msh.transform[y][x] = fast_atof(&s); |
| } |
| } |
| // we need the transform chunk, so we won't return until we have it. |
| return; |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| template <typename T> |
| void COBImporter::ReadFloat3Tuple_Ascii(T& fill, const char** in) |
| { |
| const char* rgb = *in; |
| for(unsigned int i = 0; i < 3; ++i) { |
| SkipSpaces(&rgb); |
| if (*rgb == ',')++rgb; |
| SkipSpaces(&rgb); |
| |
| fill[i] = fast_atof(&rgb); |
| } |
| *in = rgb; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadMat1_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 8) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"Mat1"); |
| } |
| |
| ++splitter; |
| if (!splitter.match_start("mat# ")) { |
| LogWarn_Ascii(splitter,format()<< |
| "Expected `mat#` line in `Mat1` chunk "<<nfo.id); |
| return; |
| } |
| |
| out.materials.push_back(Material()); |
| Material& mat = out.materials.back(); |
| mat = nfo; |
| |
| mat.matnum = strtoul10(splitter[1]); |
| ++splitter; |
| |
| if (!splitter.match_start("shader: ")) { |
| LogWarn_Ascii(splitter,format()<< |
| "Expected `mat#` line in `Mat1` chunk "<<nfo.id); |
| return; |
| } |
| std::string shader = std::string(splitter[1]); |
| shader = shader.substr(0,shader.find_first_of(" \t")); |
| |
| if (shader == "metal") { |
| mat.shader = Material::METAL; |
| } |
| else if (shader == "phong") { |
| mat.shader = Material::PHONG; |
| } |
| else if (shader != "flat") { |
| LogWarn_Ascii(splitter,format()<< |
| "Unknown value for `shader` in `Mat1` chunk "<<nfo.id); |
| } |
| |
| ++splitter; |
| if (!splitter.match_start("rgb ")) { |
| LogWarn_Ascii(splitter,format()<< |
| "Expected `rgb` line in `Mat1` chunk "<<nfo.id); |
| } |
| |
| const char* rgb = splitter[1]; |
| ReadFloat3Tuple_Ascii(mat.rgb,&rgb); |
| |
| ++splitter; |
| if (!splitter.match_start("alpha ")) { |
| LogWarn_Ascii(splitter,format()<< |
| "Expected `alpha` line in `Mat1` chunk "<<nfo.id); |
| } |
| |
| const char* tokens[10]; |
| splitter.get_tokens(tokens); |
| |
| mat.alpha = fast_atof( tokens[1] ); |
| mat.ka = fast_atof( tokens[3] ); |
| mat.ks = fast_atof( tokens[5] ); |
| mat.exp = fast_atof( tokens[7] ); |
| mat.ior = fast_atof( tokens[9] ); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadUnit_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 1) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"Unit"); |
| } |
| ++splitter; |
| if (!splitter.match_start("Units ")) { |
| LogWarn_Ascii(splitter,format()<< |
| "Expected `Units` line in `Unit` chunk "<<nfo.id); |
| return; |
| } |
| |
| // parent chunks preceede their childs, so we should have the |
| // corresponding chunk already. |
| for(std::shared_ptr< Node >& nd : out.nodes) { |
| if (nd->id == nfo.parent_id) { |
| const unsigned int t=strtoul10(splitter[1]); |
| |
| nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?( |
| LogWarn_Ascii(splitter,format()<<t<<" is not a valid value for `Units` attribute in `Unit chunk` "<<nfo.id) |
| ,1.f):units[t]; |
| return; |
| } |
| } |
| LogWarn_Ascii(splitter,format()<<"`Unit` chunk "<<nfo.id<<" is a child of " |
| <<nfo.parent_id<<" which does not exist"); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadChan_Ascii(Scene& /*out*/, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 8) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"Chan"); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadLght_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 8) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"Lght"); |
| } |
| |
| out.nodes.push_back(std::shared_ptr<Light>(new Light())); |
| Light& msh = (Light&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Ascii(msh,++splitter,nfo); |
| |
| if (splitter.match_start("Infinite ")) { |
| msh.ltype = Light::INFINITE; |
| } |
| else if (splitter.match_start("Local ")) { |
| msh.ltype = Light::LOCAL; |
| } |
| else if (splitter.match_start("Spot ")) { |
| msh.ltype = Light::SPOT; |
| } |
| else { |
| LogWarn_Ascii(splitter,format()<< |
| "Unknown kind of light source in `Lght` chunk "<<nfo.id<<" : "<<*splitter); |
| msh.ltype = Light::SPOT; |
| } |
| |
| ++splitter; |
| if (!splitter.match_start("color ")) { |
| LogWarn_Ascii(splitter,format()<< |
| "Expected `color` line in `Lght` chunk "<<nfo.id); |
| } |
| |
| const char* rgb = splitter[1]; |
| ReadFloat3Tuple_Ascii(msh.color ,&rgb); |
| |
| SkipSpaces(&rgb); |
| if (strncmp(rgb,"cone angle",10)) { |
| LogWarn_Ascii(splitter,format()<< |
| "Expected `cone angle` entity in `color` line in `Lght` chunk "<<nfo.id); |
| } |
| SkipSpaces(rgb+10,&rgb); |
| msh.angle = fast_atof(&rgb); |
| |
| SkipSpaces(&rgb); |
| if (strncmp(rgb,"inner angle",11)) { |
| LogWarn_Ascii(splitter,format()<< |
| "Expected `inner angle` entity in `color` line in `Lght` chunk "<<nfo.id); |
| } |
| SkipSpaces(rgb+11,&rgb); |
| msh.inner_angle = fast_atof(&rgb); |
| |
| // skip the rest for we can't handle this kind of physically-based lighting information. |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadCame_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 2) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"Came"); |
| } |
| |
| out.nodes.push_back(std::shared_ptr<Camera>(new Camera())); |
| Camera& msh = (Camera&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Ascii(msh,++splitter,nfo); |
| |
| // skip the next line, we don't know this differenciation between a |
| // standard camera and a panoramic camera. |
| ++splitter; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadBone_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 5) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"Bone"); |
| } |
| |
| out.nodes.push_back(std::shared_ptr<Bone>(new Bone())); |
| Bone& msh = (Bone&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Ascii(msh,++splitter,nfo); |
| |
| // TODO |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadGrou_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 1) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"Grou"); |
| } |
| |
| out.nodes.push_back(std::shared_ptr<Group>(new Group())); |
| Group& msh = (Group&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Ascii(msh,++splitter,nfo); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 8) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"PolH"); |
| } |
| |
| out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh())); |
| Mesh& msh = (Mesh&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Ascii(msh,++splitter,nfo); |
| |
| // the chunk has a fixed order of components, but some are not interesting of us so |
| // we're just looking for keywords in arbitrary order. The end of the chunk is |
| // either the last `Face` or the `DrawFlags` attribute, depending on the format ver. |
| for(;splitter;++splitter) { |
| if (splitter.match_start("World Vertices")) { |
| const unsigned int cnt = strtoul10(splitter[2]); |
| msh.vertex_positions.resize(cnt); |
| |
| for(unsigned int cur = 0;cur < cnt && ++splitter;++cur) { |
| const char* s = splitter->c_str(); |
| |
| aiVector3D& v = msh.vertex_positions[cur]; |
| |
| SkipSpaces(&s); |
| v.x = fast_atof(&s); |
| SkipSpaces(&s); |
| v.y = fast_atof(&s); |
| SkipSpaces(&s); |
| v.z = fast_atof(&s); |
| } |
| } |
| else if (splitter.match_start("Texture Vertices")) { |
| const unsigned int cnt = strtoul10(splitter[2]); |
| msh.texture_coords.resize(cnt); |
| |
| for(unsigned int cur = 0;cur < cnt && ++splitter;++cur) { |
| const char* s = splitter->c_str(); |
| |
| aiVector2D& v = msh.texture_coords[cur]; |
| |
| SkipSpaces(&s); |
| v.x = fast_atof(&s); |
| SkipSpaces(&s); |
| v.y = fast_atof(&s); |
| } |
| } |
| else if (splitter.match_start("Faces")) { |
| const unsigned int cnt = strtoul10(splitter[1]); |
| msh.faces.reserve(cnt); |
| |
| for(unsigned int cur = 0; cur < cnt && ++splitter ;++cur) { |
| if (splitter.match_start("Hole")) { |
| LogWarn_Ascii(splitter,"Skipping unsupported `Hole` line"); |
| continue; |
| } |
| |
| if (!splitter.match_start("Face")) { |
| ThrowException("Expected Face line"); |
| } |
| |
| msh.faces.push_back(Face()); |
| Face& face = msh.faces.back(); |
| |
| face.indices.resize(strtoul10(splitter[2])); |
| face.flags = strtoul10(splitter[4]); |
| face.material = strtoul10(splitter[6]); |
| |
| const char* s = (++splitter)->c_str(); |
| for(size_t i = 0; i < face.indices.size(); ++i) { |
| if(!SkipSpaces(&s)) { |
| ThrowException("Expected EOL token in Face entry"); |
| } |
| if ('<' != *s++) { |
| ThrowException("Expected < token in Face entry"); |
| } |
| face.indices[i].pos_idx = strtoul10(s,&s); |
| if (',' != *s++) { |
| ThrowException("Expected , token in Face entry"); |
| } |
| face.indices[i].uv_idx = strtoul10(s,&s); |
| if ('>' != *s++) { |
| ThrowException("Expected < token in Face entry"); |
| } |
| } |
| } |
| if (nfo.version <= 4) { |
| break; |
| } |
| } |
| else if (splitter.match_start("DrawFlags")) { |
| msh.draw_flags = strtoul10(splitter[1]); |
| break; |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadBitM_Ascii(Scene& /*out*/, LineSplitter& splitter, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 1) { |
| return UnsupportedChunk_Ascii(splitter,nfo,"BitM"); |
| } |
| /* |
| "\nThumbNailHdrSize %ld" |
| "\nThumbHeader: %02hx 02hx %02hx " |
| "\nColorBufSize %ld" |
| "\nColorBufZipSize %ld" |
| "\nZippedThumbnail: %02hx 02hx %02hx " |
| */ |
| |
| const unsigned int head = strtoul10((++splitter)[1]); |
| if (head != sizeof(Bitmap::BitmapHeader)) { |
| LogWarn_Ascii(splitter,"Unexpected ThumbNailHdrSize, skipping this chunk"); |
| return; |
| } |
| |
| /*union { |
| Bitmap::BitmapHeader data; |
| char opaq[sizeof Bitmap::BitmapHeader()]; |
| };*/ |
| // ReadHexOctets(opaq,head,(++splitter)[1]); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadString_Binary(std::string& out, StreamReaderLE& reader) |
| { |
| out.resize( reader.GetI2()); |
| for(char& c : out) { |
| c = reader.GetI1(); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadBasicNodeInfo_Binary(Node& msh, StreamReaderLE& reader, const ChunkInfo& /*nfo*/) |
| { |
| const unsigned int dupes = reader.GetI2(); |
| ReadString_Binary(msh.name,reader); |
| |
| msh.name = format(msh.name)<<'_'<<dupes; |
| |
| // skip local axes for the moment |
| reader.IncPtr(48); |
| |
| msh.transform = aiMatrix4x4(); |
| for(unsigned int y = 0; y < 3; ++y) { |
| for(unsigned int x =0; x < 4; ++x) { |
| msh.transform[y][x] = reader.GetF4(); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::UnsupportedChunk_Binary( StreamReaderLE& reader, const ChunkInfo& nfo, const char* name) |
| { |
| const std::string error = format("Encountered unsupported chunk: ") << name << |
| " [version: "<<nfo.version<<", size: "<<nfo.size<<"]"; |
| |
| // we can recover if the chunk size was specified. |
| if(nfo.size != static_cast<unsigned int>(-1)) { |
| DefaultLogger::get()->error(error); |
| reader.IncPtr(nfo.size); |
| } |
| else ThrowException(error); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // tiny utility guard to aid me at staying within chunk boundaries. |
| class chunk_guard { |
| public: |
| chunk_guard(const COB::ChunkInfo& nfo, StreamReaderLE& reader) |
| : nfo(nfo) |
| , reader(reader) |
| , cur(reader.GetCurrentPos()) { |
| } |
| |
| ~chunk_guard() { |
| // don't do anything if the size is not given |
| if(nfo.size != static_cast<unsigned int>(-1)) { |
| try { |
| reader.IncPtr( static_cast< int >( nfo.size ) - reader.GetCurrentPos() + cur ); |
| } catch ( DeadlyImportError e ) { |
| // out of limit so correct the value |
| reader.IncPtr( reader.GetReadLimit() ); |
| } |
| } |
| } |
| |
| private: |
| |
| const COB::ChunkInfo& nfo; |
| StreamReaderLE& reader; |
| long cur; |
| }; |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadBinaryFile(Scene& out, StreamReaderLE* reader) |
| { |
| while(1) { |
| std::string type; |
| type += reader -> GetI1() |
| ,type += reader -> GetI1() |
| ,type += reader -> GetI1() |
| ,type += reader -> GetI1() |
| ; |
| |
| ChunkInfo nfo; |
| nfo.version = reader -> GetI2()*10; |
| nfo.version += reader -> GetI2(); |
| |
| nfo.id = reader->GetI4(); |
| nfo.parent_id = reader->GetI4(); |
| nfo.size = reader->GetI4(); |
| |
| if (type == "PolH") { |
| ReadPolH_Binary(out,*reader,nfo); |
| } |
| else if (type == "BitM") { |
| ReadBitM_Binary(out,*reader,nfo); |
| } |
| else if (type == "Grou") { |
| ReadGrou_Binary(out,*reader,nfo); |
| } |
| else if (type == "Lght") { |
| ReadLght_Binary(out,*reader,nfo); |
| } |
| else if (type == "Came") { |
| ReadCame_Binary(out,*reader,nfo); |
| } |
| else if (type == "Mat1") { |
| ReadMat1_Binary(out,*reader,nfo); |
| } |
| /* else if (type == "Bone") { |
| ReadBone_Binary(out,*reader,nfo); |
| } |
| else if (type == "Chan") { |
| ReadChan_Binary(out,*reader,nfo); |
| }*/ |
| else if (type == "Unit") { |
| ReadUnit_Binary(out,*reader,nfo); |
| } |
| else if (type == "OLay") { |
| // ignore layer index silently. |
| if(nfo.size != static_cast<unsigned int>(-1) ) { |
| reader->IncPtr(nfo.size); |
| } |
| else return UnsupportedChunk_Binary(*reader,nfo,type.c_str()); |
| } |
| else if (type == "END ") { |
| return; |
| } |
| else UnsupportedChunk_Binary(*reader,nfo,type.c_str()); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadPolH_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 8) { |
| return UnsupportedChunk_Binary(reader,nfo,"PolH"); |
| } |
| const chunk_guard cn(nfo,reader); |
| |
| out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh())); |
| Mesh& msh = (Mesh&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Binary(msh,reader,nfo); |
| |
| msh.vertex_positions.resize(reader.GetI4()); |
| for(aiVector3D& v : msh.vertex_positions) { |
| v.x = reader.GetF4(); |
| v.y = reader.GetF4(); |
| v.z = reader.GetF4(); |
| } |
| |
| msh.texture_coords.resize(reader.GetI4()); |
| for(aiVector2D& v : msh.texture_coords) { |
| v.x = reader.GetF4(); |
| v.y = reader.GetF4(); |
| } |
| |
| const size_t numf = reader.GetI4(); |
| msh.faces.reserve(numf); |
| for(size_t i = 0; i < numf; ++i) { |
| // XXX backface culling flag is 0x10 in flags |
| |
| // hole? |
| bool hole; |
| if ((hole = (reader.GetI1() & 0x08) != 0)) { |
| // XXX Basically this should just work fine - then triangulator |
| // should output properly triangulated data even for polygons |
| // with holes. Test data specific to COB is needed to confirm it. |
| if (msh.faces.empty()) { |
| ThrowException(format("A hole is the first entity in the `PolH` chunk with id ") << nfo.id); |
| } |
| } |
| else msh.faces.push_back(Face()); |
| Face& f = msh.faces.back(); |
| |
| const size_t num = reader.GetI2(); |
| f.indices.reserve(f.indices.size() + num); |
| |
| if(!hole) { |
| f.material = reader.GetI2(); |
| f.flags = 0; |
| } |
| |
| for(size_t x = 0; x < num; ++x) { |
| f.indices.push_back(VertexIndex()); |
| |
| VertexIndex& v = f.indices.back(); |
| v.pos_idx = reader.GetI4(); |
| v.uv_idx = reader.GetI4(); |
| } |
| |
| if(hole) { |
| std::reverse(f.indices.rbegin(),f.indices.rbegin()+num); |
| } |
| } |
| if (nfo.version>4) { |
| msh.draw_flags = reader.GetI4(); |
| } |
| nfo.version>5 && nfo.version<8 ? reader.GetI4() : 0; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadBitM_Binary(COB::Scene& /*out*/, StreamReaderLE& reader, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 1) { |
| return UnsupportedChunk_Binary(reader,nfo,"BitM"); |
| } |
| |
| const chunk_guard cn(nfo,reader); |
| |
| const uint32_t len = reader.GetI4(); |
| reader.IncPtr(len); |
| |
| reader.GetI4(); |
| reader.IncPtr(reader.GetI4()); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 8) { |
| return UnsupportedChunk_Binary(reader,nfo,"Mat1"); |
| } |
| |
| const chunk_guard cn(nfo,reader); |
| |
| out.materials.push_back(Material()); |
| Material& mat = out.materials.back(); |
| mat = nfo; |
| |
| mat.matnum = reader.GetI2(); |
| switch(reader.GetI1()) { |
| case 'f': |
| mat.type = Material::FLAT; |
| break; |
| case 'p': |
| mat.type = Material::PHONG; |
| break; |
| case 'm': |
| mat.type = Material::METAL; |
| break; |
| default: |
| LogError_Ascii(format("Unrecognized shader type in `Mat1` chunk with id ")<<nfo.id); |
| mat.type = Material::FLAT; |
| } |
| |
| switch(reader.GetI1()) { |
| case 'f': |
| mat.autofacet = Material::FACETED; |
| break; |
| case 'a': |
| mat.autofacet = Material::AUTOFACETED; |
| break; |
| case 's': |
| mat.autofacet = Material::SMOOTH; |
| break; |
| default: |
| LogError_Ascii(format("Unrecognized faceting mode in `Mat1` chunk with id ")<<nfo.id); |
| mat.autofacet = Material::FACETED; |
| } |
| mat.autofacet_angle = static_cast<float>(reader.GetI1()); |
| |
| mat.rgb.r = reader.GetF4(); |
| mat.rgb.g = reader.GetF4(); |
| mat.rgb.b = reader.GetF4(); |
| |
| mat.alpha = reader.GetF4(); |
| mat.ka = reader.GetF4(); |
| mat.ks = reader.GetF4(); |
| mat.exp = reader.GetF4(); |
| mat.ior = reader.GetF4(); |
| |
| char id[2]; |
| id[0] = reader.GetI1(),id[1] = reader.GetI1(); |
| |
| if (id[0] == 'e' && id[1] == ':') { |
| mat.tex_env.reset(new Texture()); |
| |
| reader.GetI1(); |
| ReadString_Binary(mat.tex_env->path,reader); |
| |
| // advance to next texture-id |
| id[0] = reader.GetI1(),id[1] = reader.GetI1(); |
| } |
| |
| if (id[0] == 't' && id[1] == ':') { |
| mat.tex_color.reset(new Texture()); |
| |
| reader.GetI1(); |
| ReadString_Binary(mat.tex_color->path,reader); |
| |
| mat.tex_color->transform.mTranslation.x = reader.GetF4(); |
| mat.tex_color->transform.mTranslation.y = reader.GetF4(); |
| |
| mat.tex_color->transform.mScaling.x = reader.GetF4(); |
| mat.tex_color->transform.mScaling.y = reader.GetF4(); |
| |
| // advance to next texture-id |
| id[0] = reader.GetI1(),id[1] = reader.GetI1(); |
| } |
| |
| if (id[0] == 'b' && id[1] == ':') { |
| mat.tex_bump.reset(new Texture()); |
| |
| reader.GetI1(); |
| ReadString_Binary(mat.tex_bump->path,reader); |
| |
| mat.tex_bump->transform.mTranslation.x = reader.GetF4(); |
| mat.tex_bump->transform.mTranslation.y = reader.GetF4(); |
| |
| mat.tex_bump->transform.mScaling.x = reader.GetF4(); |
| mat.tex_bump->transform.mScaling.y = reader.GetF4(); |
| |
| // skip amplitude for I don't know its purpose. |
| reader.GetF4(); |
| } |
| reader.IncPtr(-2); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadCame_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 2) { |
| return UnsupportedChunk_Binary(reader,nfo,"Came"); |
| } |
| |
| const chunk_guard cn(nfo,reader); |
| |
| out.nodes.push_back(std::shared_ptr<Camera>(new Camera())); |
| Camera& msh = (Camera&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Binary(msh,reader,nfo); |
| |
| // the rest is not interesting for us, so we skip over it. |
| if(nfo.version > 1) { |
| if (reader.GetI2()==512) { |
| reader.IncPtr(42); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadLght_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 2) { |
| return UnsupportedChunk_Binary(reader,nfo,"Lght"); |
| } |
| |
| const chunk_guard cn(nfo,reader); |
| |
| out.nodes.push_back(std::shared_ptr<Light>(new Light())); |
| Light& msh = (Light&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Binary(msh,reader,nfo); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadGrou_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 2) { |
| return UnsupportedChunk_Binary(reader,nfo,"Grou"); |
| } |
| |
| const chunk_guard cn(nfo,reader); |
| |
| out.nodes.push_back(std::shared_ptr<Group>(new Group())); |
| Group& msh = (Group&)(*out.nodes.back().get()); |
| msh = nfo; |
| |
| ReadBasicNodeInfo_Binary(msh,reader,nfo); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void COBImporter::ReadUnit_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo) |
| { |
| if(nfo.version > 1) { |
| return UnsupportedChunk_Binary(reader,nfo,"Unit"); |
| } |
| |
| const chunk_guard cn(nfo,reader); |
| |
| // parent chunks preceede their childs, so we should have the |
| // corresponding chunk already. |
| for(std::shared_ptr< Node >& nd : out.nodes) { |
| if (nd->id == nfo.parent_id) { |
| const unsigned int t=reader.GetI2(); |
| nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?( |
| LogWarn_Ascii(format()<<t<<" is not a valid value for `Units` attribute in `Unit chunk` "<<nfo.id) |
| ,1.f):units[t]; |
| |
| return; |
| } |
| } |
| LogWarn_Ascii(format()<<"`Unit` chunk "<<nfo.id<<" is a child of " |
| <<nfo.parent_id<<" which does not exist"); |
| } |
| |
| |
| #endif |
