diff options
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/Ply/PlyParser.cpp')
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/Ply/PlyParser.cpp | 963 |
1 files changed, 0 insertions, 963 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/Ply/PlyParser.cpp b/src/mesh/assimp-master/code/AssetLib/Ply/PlyParser.cpp deleted file mode 100644 index df93d5a..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Ply/PlyParser.cpp +++ /dev/null @@ -1,963 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2022, 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 Implementation of the PLY parser class */ - -#ifndef ASSIMP_BUILD_NO_PLY_IMPORTER - -#include "PlyLoader.h" -#include <assimp/ByteSwapper.h> -#include <assimp/fast_atof.h> -#include <assimp/DefaultLogger.hpp> - -using namespace Assimp; - -// ------------------------------------------------------------------------------------------------ -PLY::EDataType PLY::Property::ParseDataType(std::vector<char> &buffer) { - ai_assert(!buffer.empty()); - - PLY::EDataType eOut = PLY::EDT_INVALID; - - if (PLY::DOM::TokenMatch(buffer, "char", 4) || - PLY::DOM::TokenMatch(buffer, "int8", 4)) { - eOut = PLY::EDT_Char; - } else if (PLY::DOM::TokenMatch(buffer, "uchar", 5) || - PLY::DOM::TokenMatch(buffer, "uint8", 5)) { - eOut = PLY::EDT_UChar; - } else if (PLY::DOM::TokenMatch(buffer, "short", 5) || - PLY::DOM::TokenMatch(buffer, "int16", 5)) { - eOut = PLY::EDT_Short; - } else if (PLY::DOM::TokenMatch(buffer, "ushort", 6) || - PLY::DOM::TokenMatch(buffer, "uint16", 6)) { - eOut = PLY::EDT_UShort; - } else if (PLY::DOM::TokenMatch(buffer, "int32", 5) || PLY::DOM::TokenMatch(buffer, "int", 3)) { - eOut = PLY::EDT_Int; - } else if (PLY::DOM::TokenMatch(buffer, "uint32", 6) || PLY::DOM::TokenMatch(buffer, "uint", 4)) { - eOut = PLY::EDT_UInt; - } else if (PLY::DOM::TokenMatch(buffer, "float", 5) || PLY::DOM::TokenMatch(buffer, "float32", 7)) { - eOut = PLY::EDT_Float; - } else if (PLY::DOM::TokenMatch(buffer, "double64", 8) || PLY::DOM::TokenMatch(buffer, "double", 6) || - PLY::DOM::TokenMatch(buffer, "float64", 7)) { - eOut = PLY::EDT_Double; - } - if (PLY::EDT_INVALID == eOut) { - ASSIMP_LOG_INFO("Found unknown data type in PLY file. This is OK"); - } - - return eOut; -} - -// ------------------------------------------------------------------------------------------------ -PLY::ESemantic PLY::Property::ParseSemantic(std::vector<char> &buffer) { - ai_assert(!buffer.empty()); - - PLY::ESemantic eOut = PLY::EST_INVALID; - if (PLY::DOM::TokenMatch(buffer, "red", 3)) { - eOut = PLY::EST_Red; - } else if (PLY::DOM::TokenMatch(buffer, "green", 5)) { - eOut = PLY::EST_Green; - } else if (PLY::DOM::TokenMatch(buffer, "blue", 4)) { - eOut = PLY::EST_Blue; - } else if (PLY::DOM::TokenMatch(buffer, "alpha", 5)) { - eOut = PLY::EST_Alpha; - } else if (PLY::DOM::TokenMatch(buffer, "vertex_index", 12) || PLY::DOM::TokenMatch(buffer, "vertex_indices", 14)) { - eOut = PLY::EST_VertexIndex; - } else if (PLY::DOM::TokenMatch(buffer, "texcoord", 8)) // Manage uv coords on faces - { - eOut = PLY::EST_TextureCoordinates; - } else if (PLY::DOM::TokenMatch(buffer, "material_index", 14)) { - eOut = PLY::EST_MaterialIndex; - } else if (PLY::DOM::TokenMatch(buffer, "ambient_red", 11)) { - eOut = PLY::EST_AmbientRed; - } else if (PLY::DOM::TokenMatch(buffer, "ambient_green", 13)) { - eOut = PLY::EST_AmbientGreen; - } else if (PLY::DOM::TokenMatch(buffer, "ambient_blue", 12)) { - eOut = PLY::EST_AmbientBlue; - } else if (PLY::DOM::TokenMatch(buffer, "ambient_alpha", 13)) { - eOut = PLY::EST_AmbientAlpha; - } else if (PLY::DOM::TokenMatch(buffer, "diffuse_red", 11)) { - eOut = PLY::EST_DiffuseRed; - } else if (PLY::DOM::TokenMatch(buffer, "diffuse_green", 13)) { - eOut = PLY::EST_DiffuseGreen; - } else if (PLY::DOM::TokenMatch(buffer, "diffuse_blue", 12)) { - eOut = PLY::EST_DiffuseBlue; - } else if (PLY::DOM::TokenMatch(buffer, "diffuse_alpha", 13)) { - eOut = PLY::EST_DiffuseAlpha; - } else if (PLY::DOM::TokenMatch(buffer, "specular_red", 12)) { - eOut = PLY::EST_SpecularRed; - } else if (PLY::DOM::TokenMatch(buffer, "specular_green", 14)) { - eOut = PLY::EST_SpecularGreen; - } else if (PLY::DOM::TokenMatch(buffer, "specular_blue", 13)) { - eOut = PLY::EST_SpecularBlue; - } else if (PLY::DOM::TokenMatch(buffer, "specular_alpha", 14)) { - eOut = PLY::EST_SpecularAlpha; - } else if (PLY::DOM::TokenMatch(buffer, "opacity", 7)) { - eOut = PLY::EST_Opacity; - } else if (PLY::DOM::TokenMatch(buffer, "specular_power", 14)) { - eOut = PLY::EST_PhongPower; - } else if (PLY::DOM::TokenMatch(buffer, "r", 1)) { - eOut = PLY::EST_Red; - } else if (PLY::DOM::TokenMatch(buffer, "g", 1)) { - eOut = PLY::EST_Green; - } else if (PLY::DOM::TokenMatch(buffer, "b", 1)) { - eOut = PLY::EST_Blue; - } - - // NOTE: Blender3D exports texture coordinates as s,t tuples - else if (PLY::DOM::TokenMatch(buffer, "u", 1) || PLY::DOM::TokenMatch(buffer, "s", 1) || PLY::DOM::TokenMatch(buffer, "tx", 2) || PLY::DOM::TokenMatch(buffer, "texture_u", 9)) { - eOut = PLY::EST_UTextureCoord; - } else if (PLY::DOM::TokenMatch(buffer, "v", 1) || PLY::DOM::TokenMatch(buffer, "t", 1) || PLY::DOM::TokenMatch(buffer, "ty", 2) || PLY::DOM::TokenMatch(buffer, "texture_v", 9)) { - eOut = PLY::EST_VTextureCoord; - } else if (PLY::DOM::TokenMatch(buffer, "x", 1)) { - eOut = PLY::EST_XCoord; - } else if (PLY::DOM::TokenMatch(buffer, "y", 1)) { - eOut = PLY::EST_YCoord; - } else if (PLY::DOM::TokenMatch(buffer, "z", 1)) { - eOut = PLY::EST_ZCoord; - } else if (PLY::DOM::TokenMatch(buffer, "nx", 2)) { - eOut = PLY::EST_XNormal; - } else if (PLY::DOM::TokenMatch(buffer, "ny", 2)) { - eOut = PLY::EST_YNormal; - } else if (PLY::DOM::TokenMatch(buffer, "nz", 2)) { - eOut = PLY::EST_ZNormal; - } else { - ASSIMP_LOG_INFO("Found unknown property semantic in file. This is ok"); - PLY::DOM::SkipLine(buffer); - } - return eOut; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::Property::ParseProperty(std::vector<char> &buffer, PLY::Property *pOut) { - ai_assert(!buffer.empty()); - - // Forms supported: - // "property float x" - // "property list uchar int vertex_index" - - // skip leading spaces - if (!PLY::DOM::SkipSpaces(buffer)) { - return false; - } - - // skip the "property" string at the beginning - if (!PLY::DOM::TokenMatch(buffer, "property", 8)) { - // seems not to be a valid property entry - return false; - } - // get next word - if (!PLY::DOM::SkipSpaces(buffer)) { - return false; - } - if (PLY::DOM::TokenMatch(buffer, "list", 4)) { - pOut->bIsList = true; - - // seems to be a list. - if (EDT_INVALID == (pOut->eFirstType = PLY::Property::ParseDataType(buffer))) { - // unable to parse list size data type - PLY::DOM::SkipLine(buffer); - return false; - } - if (!PLY::DOM::SkipSpaces(buffer)) return false; - if (EDT_INVALID == (pOut->eType = PLY::Property::ParseDataType(buffer))) { - // unable to parse list data type - PLY::DOM::SkipLine(buffer); - return false; - } - } else { - if (EDT_INVALID == (pOut->eType = PLY::Property::ParseDataType(buffer))) { - // unable to parse data type. Skip the property - PLY::DOM::SkipLine(buffer); - return false; - } - } - - if (!PLY::DOM::SkipSpaces(buffer)) - return false; - - pOut->Semantic = PLY::Property::ParseSemantic(buffer); - - if (PLY::EST_INVALID == pOut->Semantic) { - ASSIMP_LOG_INFO("Found unknown semantic in PLY file. This is OK"); - std::string(&buffer[0], &buffer[0] + strlen(&buffer[0])); - } - - PLY::DOM::SkipSpacesAndLineEnd(buffer); - return true; -} - -// ------------------------------------------------------------------------------------------------ -PLY::EElementSemantic PLY::Element::ParseSemantic(std::vector<char> &buffer) { - ai_assert(!buffer.empty()); - - PLY::EElementSemantic eOut = PLY::EEST_INVALID; - if (PLY::DOM::TokenMatch(buffer, "vertex", 6)) { - eOut = PLY::EEST_Vertex; - } else if (PLY::DOM::TokenMatch(buffer, "face", 4)) { - eOut = PLY::EEST_Face; - } else if (PLY::DOM::TokenMatch(buffer, "tristrips", 9)) { - eOut = PLY::EEST_TriStrip; - } -#if 0 - // TODO: maybe implement this? - else if (PLY::DOM::TokenMatch(buffer,"range_grid",10)) - { - eOut = PLY::EEST_Face; - } -#endif - else if (PLY::DOM::TokenMatch(buffer, "edge", 4)) { - eOut = PLY::EEST_Edge; - } else if (PLY::DOM::TokenMatch(buffer, "material", 8)) { - eOut = PLY::EEST_Material; - } else if (PLY::DOM::TokenMatch(buffer, "TextureFile", 11)) { - eOut = PLY::EEST_TextureFile; - } - - return eOut; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::Element::ParseElement(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLY::Element *pOut) { - ai_assert(nullptr != pOut); - // Example format: "element vertex 8" - - // skip leading spaces - if (!PLY::DOM::SkipSpaces(buffer)) { - return false; - } - - // skip the "element" string at the beginning - if (!PLY::DOM::TokenMatch(buffer, "element", 7) && !PLY::DOM::TokenMatch(buffer, "comment", 7)) { - // seems not to be a valid property entry - return false; - } - // get next word - if (!PLY::DOM::SkipSpaces(buffer)) - return false; - - // parse the semantic of the element - pOut->eSemantic = PLY::Element::ParseSemantic(buffer); - if (PLY::EEST_INVALID == pOut->eSemantic) { - // if the exact semantic can't be determined, just store - // the original string identifier - pOut->szName = std::string(&buffer[0], &buffer[0] + strlen(&buffer[0])); - } - - if (!PLY::DOM::SkipSpaces(buffer)) - return false; - - if (PLY::EEST_TextureFile == pOut->eSemantic) { - char *endPos = &buffer[0] + (strlen(&buffer[0]) - 1); - pOut->szName = std::string(&buffer[0], endPos); - - // go to the next line - PLY::DOM::SkipSpacesAndLineEnd(buffer); - - return true; - } - - //parse the number of occurrences of this element - const char *pCur = (char *)&buffer[0]; - pOut->NumOccur = strtoul10(pCur, &pCur); - - // go to the next line - PLY::DOM::SkipSpacesAndLineEnd(buffer); - - // now parse all properties of the element - while (true) { - streamBuffer.getNextLine(buffer); - pCur = (char *)&buffer[0]; - - // skip all comments - PLY::DOM::SkipComments(buffer); - - PLY::Property prop; - if (!PLY::Property::ParseProperty(buffer, &prop)) - break; - - pOut->alProperties.push_back(prop); - } - - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::DOM::SkipSpaces(std::vector<char> &buffer) { - const char *pCur = buffer.empty() ? nullptr : (char *)&buffer[0]; - bool ret = false; - if (pCur) { - const char *szCur = pCur; - ret = Assimp::SkipSpaces(pCur, &pCur); - - uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur; - buffer.erase(buffer.begin(), buffer.begin() + iDiff); - return ret; - } - - return ret; -} - -bool PLY::DOM::SkipLine(std::vector<char> &buffer) { - const char *pCur = buffer.empty() ? nullptr : (char *)&buffer[0]; - bool ret = false; - if (pCur) { - const char *szCur = pCur; - ret = Assimp::SkipLine(pCur, &pCur); - - uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur; - buffer.erase(buffer.begin(), buffer.begin() + iDiff); - return ret; - } - - return ret; -} - -bool PLY::DOM::TokenMatch(std::vector<char> &buffer, const char *token, unsigned int len) { - const char *pCur = buffer.empty() ? nullptr : (char *)&buffer[0]; - bool ret = false; - if (pCur) { - const char *szCur = pCur; - ret = Assimp::TokenMatch(pCur, token, len); - - uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur; - buffer.erase(buffer.begin(), buffer.begin() + iDiff); - return ret; - } - - return ret; -} - -bool PLY::DOM::SkipSpacesAndLineEnd(std::vector<char> &buffer) { - const char *pCur = buffer.empty() ? nullptr : (char *)&buffer[0]; - bool ret = false; - if (pCur) { - const char *szCur = pCur; - ret = Assimp::SkipSpacesAndLineEnd(pCur, &pCur); - - uintptr_t iDiff = (uintptr_t)pCur - (uintptr_t)szCur; - buffer.erase(buffer.begin(), buffer.begin() + iDiff); - return ret; - } - - return ret; -} - -bool PLY::DOM::SkipComments(std::vector<char> &buffer) { - ai_assert(!buffer.empty()); - - std::vector<char> nbuffer = buffer; - // skip spaces - if (!SkipSpaces(nbuffer)) { - return false; - } - - if (TokenMatch(nbuffer, "comment", 7)) { - if (!SkipSpaces(nbuffer)) - SkipLine(nbuffer); - - if (!TokenMatch(nbuffer, "TextureFile", 11)) { - SkipLine(nbuffer); - buffer = nbuffer; - return true; - } - - return true; - } - - return false; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, bool isBinary) { - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseHeader() begin"); - - // parse all elements - while (!buffer.empty()) { - // skip all comments - PLY::DOM::SkipComments(buffer); - - PLY::Element out; - if (PLY::Element::ParseElement(streamBuffer, buffer, &out)) { - // add the element to the list of elements - alElements.push_back(out); - } else if (TokenMatch(buffer, "end_header", 10)) { //checks for /n ending, if it doesn't end with /r/n - // we have reached the end of the header - break; - } else { - // ignore unknown header elements - streamBuffer.getNextLine(buffer); - } - } - - if (!isBinary) // it would occur an error, if binary data start with values as space or line end. - SkipSpacesAndLineEnd(buffer); - - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseHeader() succeeded"); - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::DOM::ParseElementInstanceLists(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLYImporter *loader) { - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseElementInstanceLists() begin"); - alElementData.resize(alElements.size()); - - std::vector<PLY::Element>::const_iterator i = alElements.begin(); - std::vector<PLY::ElementInstanceList>::iterator a = alElementData.begin(); - - // parse all element instances - //construct vertices and faces - for (; i != alElements.end(); ++i, ++a) { - if ((*i).eSemantic == EEST_Vertex || (*i).eSemantic == EEST_Face || (*i).eSemantic == EEST_TriStrip) { - PLY::ElementInstanceList::ParseInstanceList(streamBuffer, buffer, &(*i), nullptr, loader); - } else { - (*a).alInstances.resize((*i).NumOccur); - PLY::ElementInstanceList::ParseInstanceList(streamBuffer, buffer, &(*i), &(*a), nullptr); - } - } - - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseElementInstanceLists() succeeded"); - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::DOM::ParseElementInstanceListsBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, - const char *&pCur, - unsigned int &bufferSize, - PLYImporter *loader, - bool p_bBE) { - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseElementInstanceListsBinary() begin"); - alElementData.resize(alElements.size()); - - std::vector<PLY::Element>::const_iterator i = alElements.begin(); - std::vector<PLY::ElementInstanceList>::iterator a = alElementData.begin(); - - // parse all element instances - for (; i != alElements.end(); ++i, ++a) { - if ((*i).eSemantic == EEST_Vertex || (*i).eSemantic == EEST_Face || (*i).eSemantic == EEST_TriStrip) { - PLY::ElementInstanceList::ParseInstanceListBinary(streamBuffer, buffer, pCur, bufferSize, &(*i), nullptr, loader, p_bBE); - } else { - (*a).alInstances.resize((*i).NumOccur); - PLY::ElementInstanceList::ParseInstanceListBinary(streamBuffer, buffer, pCur, bufferSize, &(*i), &(*a), nullptr, p_bBE); - } - } - - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseElementInstanceListsBinary() succeeded"); - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::DOM::ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, DOM *p_pcOut, PLYImporter *loader, bool p_bBE) { - ai_assert(nullptr != p_pcOut); - ai_assert(nullptr != loader); - - std::vector<char> buffer; - streamBuffer.getNextLine(buffer); - - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstanceBinary() begin"); - - if (!p_pcOut->ParseHeader(streamBuffer, buffer, true)) { - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstanceBinary() failure"); - return false; - } - - streamBuffer.getNextBlock(buffer); - - // remove first char if it's /n in case of file with /r/n - if (((char *)&buffer[0])[0] == '\n') - buffer.erase(buffer.begin(), buffer.begin() + 1); - - unsigned int bufferSize = static_cast<unsigned int>(buffer.size()); - const char *pCur = (char *)&buffer[0]; - if (!p_pcOut->ParseElementInstanceListsBinary(streamBuffer, buffer, pCur, bufferSize, loader, p_bBE)) { - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstanceBinary() failure"); - return false; - } - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstanceBinary() succeeded"); - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::DOM::ParseInstance(IOStreamBuffer<char> &streamBuffer, DOM *p_pcOut, PLYImporter *loader) { - ai_assert(nullptr != p_pcOut); - ai_assert(nullptr != loader); - - std::vector<char> buffer; - streamBuffer.getNextLine(buffer); - - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstance() begin"); - - if (!p_pcOut->ParseHeader(streamBuffer, buffer, false)) { - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstance() failure"); - return false; - } - - //get next line after header - streamBuffer.getNextLine(buffer); - if (!p_pcOut->ParseElementInstanceLists(streamBuffer, buffer, loader)) { - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstance() failure"); - return false; - } - ASSIMP_LOG_VERBOSE_DEBUG("PLY::DOM::ParseInstance() succeeded"); - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::ElementInstanceList::ParseInstanceList( - IOStreamBuffer<char> &streamBuffer, - std::vector<char> &buffer, - const PLY::Element *pcElement, - PLY::ElementInstanceList *p_pcOut, - PLYImporter *loader) { - ai_assert(nullptr != pcElement); - - // parse all elements - if (EEST_INVALID == pcElement->eSemantic || pcElement->alProperties.empty()) { - // if the element has an unknown semantic we can skip all lines - // However, there could be comments - for (unsigned int i = 0; i < pcElement->NumOccur; ++i) { - PLY::DOM::SkipComments(buffer); - PLY::DOM::SkipLine(buffer); - streamBuffer.getNextLine(buffer); - } - } else { - const char *pCur = (const char *)&buffer[0]; - // be sure to have enough storage - for (unsigned int i = 0; i < pcElement->NumOccur; ++i) { - if (p_pcOut) - PLY::ElementInstance::ParseInstance(pCur, pcElement, &p_pcOut->alInstances[i]); - else { - ElementInstance elt; - PLY::ElementInstance::ParseInstance(pCur, pcElement, &elt); - - // Create vertex or face - if (pcElement->eSemantic == EEST_Vertex) { - //call loader instance from here - loader->LoadVertex(pcElement, &elt, i); - } else if (pcElement->eSemantic == EEST_Face) { - //call loader instance from here - loader->LoadFace(pcElement, &elt, i); - } else if (pcElement->eSemantic == EEST_TriStrip) { - //call loader instance from here - loader->LoadFace(pcElement, &elt, i); - } - } - - streamBuffer.getNextLine(buffer); - pCur = (buffer.empty()) ? nullptr : (const char *)&buffer[0]; - } - } - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::ElementInstanceList::ParseInstanceListBinary( - IOStreamBuffer<char> &streamBuffer, - std::vector<char> &buffer, - const char *&pCur, - unsigned int &bufferSize, - const PLY::Element *pcElement, - PLY::ElementInstanceList *p_pcOut, - PLYImporter *loader, - bool p_bBE /* = false */) { - ai_assert(nullptr != pcElement); - - // we can add special handling code for unknown element semantics since - // we can't skip it as a whole block (we don't know its exact size - // due to the fact that lists could be contained in the property list - // of the unknown element) - for (unsigned int i = 0; i < pcElement->NumOccur; ++i) { - if (p_pcOut) - PLY::ElementInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, pcElement, &p_pcOut->alInstances[i], p_bBE); - else { - ElementInstance elt; - PLY::ElementInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, pcElement, &elt, p_bBE); - - // Create vertex or face - if (pcElement->eSemantic == EEST_Vertex) { - //call loader instance from here - loader->LoadVertex(pcElement, &elt, i); - } else if (pcElement->eSemantic == EEST_Face) { - //call loader instance from here - loader->LoadFace(pcElement, &elt, i); - } else if (pcElement->eSemantic == EEST_TriStrip) { - //call loader instance from here - loader->LoadFace(pcElement, &elt, i); - } - } - } - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::ElementInstance::ParseInstance(const char *&pCur, - const PLY::Element *pcElement, - PLY::ElementInstance *p_pcOut) { - ai_assert(nullptr != pcElement); - ai_assert(nullptr != p_pcOut); - - // allocate enough storage - p_pcOut->alProperties.resize(pcElement->alProperties.size()); - - std::vector<PLY::PropertyInstance>::iterator i = p_pcOut->alProperties.begin(); - std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin(); - for (; i != p_pcOut->alProperties.end(); ++i, ++a) { - if (!(PLY::PropertyInstance::ParseInstance(pCur, &(*a), &(*i)))) { - ASSIMP_LOG_WARN("Unable to parse property instance. " - "Skipping this element instance"); - - PLY::PropertyInstance::ValueUnion v = PLY::PropertyInstance::DefaultValue((*a).eType); - (*i).avList.push_back(v); - } - } - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::ElementInstance::ParseInstanceBinary( - IOStreamBuffer<char> &streamBuffer, - std::vector<char> &buffer, - const char *&pCur, - unsigned int &bufferSize, - const PLY::Element *pcElement, - PLY::ElementInstance *p_pcOut, - bool p_bBE /* = false */) { - ai_assert(nullptr != pcElement); - ai_assert(nullptr != p_pcOut); - - // allocate enough storage - p_pcOut->alProperties.resize(pcElement->alProperties.size()); - - std::vector<PLY::PropertyInstance>::iterator i = p_pcOut->alProperties.begin(); - std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin(); - for (; i != p_pcOut->alProperties.end(); ++i, ++a) { - if (!(PLY::PropertyInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, &(*a), &(*i), p_bBE))) { - ASSIMP_LOG_WARN("Unable to parse binary property instance. " - "Skipping this element instance"); - - (*i).avList.push_back(PLY::PropertyInstance::DefaultValue((*a).eType)); - } - } - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::PropertyInstance::ParseInstance(const char *&pCur, - const PLY::Property *prop, PLY::PropertyInstance *p_pcOut) { - ai_assert(nullptr != prop); - ai_assert(nullptr != p_pcOut); - - // skip spaces at the beginning - if (!SkipSpaces(&pCur)) { - return false; - } - - if (prop->bIsList) { - // parse the number of elements in the list - PLY::PropertyInstance::ValueUnion v; - PLY::PropertyInstance::ParseValue(pCur, prop->eFirstType, &v); - - // convert to unsigned int - unsigned int iNum = PLY::PropertyInstance::ConvertTo<unsigned int>(v, prop->eFirstType); - - // parse all list elements - p_pcOut->avList.resize(iNum); - for (unsigned int i = 0; i < iNum; ++i) { - if (!SkipSpaces(&pCur)) - return false; - - PLY::PropertyInstance::ParseValue(pCur, prop->eType, &p_pcOut->avList[i]); - } - } else { - // parse the property - PLY::PropertyInstance::ValueUnion v; - - PLY::PropertyInstance::ParseValue(pCur, prop->eType, &v); - p_pcOut->avList.push_back(v); - } - SkipSpacesAndLineEnd(&pCur); - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::PropertyInstance::ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, - const char *&pCur, - unsigned int &bufferSize, - const PLY::Property *prop, - PLY::PropertyInstance *p_pcOut, - bool p_bBE) { - ai_assert(nullptr != prop); - ai_assert(nullptr != p_pcOut); - - // parse all elements - if (prop->bIsList) { - // parse the number of elements in the list - PLY::PropertyInstance::ValueUnion v; - PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eFirstType, &v, p_bBE); - - // convert to unsigned int - unsigned int iNum = PLY::PropertyInstance::ConvertTo<unsigned int>(v, prop->eFirstType); - - // parse all list elements - p_pcOut->avList.resize(iNum); - for (unsigned int i = 0; i < iNum; ++i) { - PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eType, &p_pcOut->avList[i], p_bBE); - } - } else { - // parse the property - PLY::PropertyInstance::ValueUnion v; - PLY::PropertyInstance::ParseValueBinary(streamBuffer, buffer, pCur, bufferSize, prop->eType, &v, p_bBE); - p_pcOut->avList.push_back(v); - } - return true; -} - -// ------------------------------------------------------------------------------------------------ -PLY::PropertyInstance::ValueUnion PLY::PropertyInstance::DefaultValue(PLY::EDataType eType) { - PLY::PropertyInstance::ValueUnion out; - - switch (eType) { - case EDT_Float: - out.fFloat = 0.f; - return out; - - case EDT_Double: - out.fDouble = 0.; - return out; - - default:; - }; - out.iUInt = 0; - return out; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::PropertyInstance::ParseValue(const char *&pCur, - PLY::EDataType eType, - PLY::PropertyInstance::ValueUnion *out) { - ai_assert(nullptr != pCur); - ai_assert(nullptr != out); - - //calc element size - bool ret = true; - switch (eType) { - case EDT_UInt: - case EDT_UShort: - case EDT_UChar: - - out->iUInt = (uint32_t)strtoul10(pCur, &pCur); - break; - - case EDT_Int: - case EDT_Short: - case EDT_Char: - - out->iInt = (int32_t)strtol10(pCur, &pCur); - break; - - case EDT_Float: - // technically this should cast to float, but people tend to use float descriptors for double data - // this is the best way to not risk losing precision on import and it doesn't hurt to do this - ai_real f; - pCur = fast_atoreal_move<ai_real>(pCur, f); - out->fFloat = (ai_real)f; - break; - - case EDT_Double: - double d; - pCur = fast_atoreal_move<double>(pCur, d); - out->fDouble = (double)d; - break; - - case EDT_INVALID: - default: - ret = false; - break; - } - - return ret; -} - -// ------------------------------------------------------------------------------------------------ -bool PLY::PropertyInstance::ParseValueBinary(IOStreamBuffer<char> &streamBuffer, - std::vector<char> &buffer, - const char *&pCur, - unsigned int &bufferSize, - PLY::EDataType eType, - PLY::PropertyInstance::ValueUnion *out, - bool p_bBE) { - ai_assert(nullptr != out); - - //calc element size - unsigned int lsize = 0; - switch (eType) { - case EDT_Char: - case EDT_UChar: - lsize = 1; - break; - - case EDT_UShort: - case EDT_Short: - lsize = 2; - break; - - case EDT_UInt: - case EDT_Int: - case EDT_Float: - lsize = 4; - break; - - case EDT_Double: - lsize = 8; - break; - - case EDT_INVALID: - default: - break; - } - - //read the next file block if needed - if (bufferSize < lsize) { - std::vector<char> nbuffer; - if (streamBuffer.getNextBlock(nbuffer)) { - //concat buffer contents - buffer = std::vector<char>(buffer.end() - bufferSize, buffer.end()); - buffer.insert(buffer.end(), nbuffer.begin(), nbuffer.end()); - nbuffer.clear(); - bufferSize = static_cast<unsigned int>(buffer.size()); - pCur = (char *)&buffer[0]; - } else { - throw DeadlyImportError("Invalid .ply file: File corrupted"); - } - } - - bool ret = true; - switch (eType) { - case EDT_UInt: { - uint32_t t; - memcpy(&t, pCur, sizeof(uint32_t)); - pCur += sizeof(uint32_t); - - // Swap endianness - if (p_bBE) ByteSwap::Swap(&t); - out->iUInt = t; - break; - } - - case EDT_UShort: { - uint16_t t; - memcpy(&t, pCur, sizeof(uint16_t)); - pCur += sizeof(uint16_t); - - // Swap endianness - if (p_bBE) ByteSwap::Swap(&t); - out->iUInt = t; - break; - } - - case EDT_UChar: { - uint8_t t; - memcpy(&t, pCur, sizeof(uint8_t)); - pCur += sizeof(uint8_t); - out->iUInt = t; - break; - } - - case EDT_Int: { - int32_t t; - memcpy(&t, pCur, sizeof(int32_t)); - pCur += sizeof(int32_t); - - // Swap endianness - if (p_bBE) ByteSwap::Swap(&t); - out->iInt = t; - break; - } - - case EDT_Short: { - int16_t t; - memcpy(&t, pCur, sizeof(int16_t)); - pCur += sizeof(int16_t); - - // Swap endianness - if (p_bBE) ByteSwap::Swap(&t); - out->iInt = t; - break; - } - - case EDT_Char: { - int8_t t; - memcpy(&t, pCur, sizeof(int8_t)); - pCur += sizeof(int8_t); - out->iInt = t; - break; - } - - case EDT_Float: { - float t; - memcpy(&t, pCur, sizeof(float)); - pCur += sizeof(float); - - // Swap endianness - if (p_bBE) ByteSwap::Swap(&t); - out->fFloat = t; - break; - } - case EDT_Double: { - double t; - memcpy(&t, pCur, sizeof(double)); - pCur += sizeof(double); - - // Swap endianness - if (p_bBE) ByteSwap::Swap(&t); - out->fDouble = t; - break; - } - default: - ret = false; - } - - bufferSize -= lsize; - - return ret; -} - -#endif // !! ASSIMP_BUILD_NO_PLY_IMPORTER |