diff options
Diffstat (limited to 'libs/assimp/code/AssetLib/Ply/PlyParser.h')
| -rw-r--r-- | libs/assimp/code/AssetLib/Ply/PlyParser.h | 488 |
1 files changed, 488 insertions, 0 deletions
diff --git a/libs/assimp/code/AssetLib/Ply/PlyParser.h b/libs/assimp/code/AssetLib/Ply/PlyParser.h new file mode 100644 index 0000000..8634929 --- /dev/null +++ b/libs/assimp/code/AssetLib/Ply/PlyParser.h @@ -0,0 +1,488 @@ +/* +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 Defines the helper data structures for importing PLY files */ +#pragma once +#ifndef AI_PLYFILEHELPER_H_INC +#define AI_PLYFILEHELPER_H_INC + +#include <assimp/ParsingUtils.h> +#include <assimp/IOStreamBuffer.h> +#include <vector> + +namespace Assimp { + +//pre-declaration +class PLYImporter; + +// http://local.wasp.uwa.edu.au/~pbourke/dataformats/ply/ +// http://w3.impa.br/~lvelho/outgoing/sossai/old/ViHAP_D4.4.2_PLY_format_v1.1.pdf +// http://www.okino.com/conv/exp_ply.htm +namespace PLY { + +// --------------------------------------------------------------------------------- +/* +name type number of bytes +--------------------------------------- +char character 1 +uchar unsigned character 1 +short short integer 2 +ushort unsigned short integer 2 +int integer 4 +uint unsigned integer 4 +float single-precision float 4 +double double-precision float 8 + +int8 +int16 +uint8 ... forms are also used +*/ +enum EDataType { + EDT_Char = 0x0u, + EDT_UChar, + EDT_Short, + EDT_UShort, + EDT_Int, + EDT_UInt, + EDT_Float, + EDT_Double, + + // Marks invalid entries + EDT_INVALID +}; + +// --------------------------------------------------------------------------------- +/** \brief Specifies semantics for PLY element properties + * + * Semantics define the usage of a property, e.g. x coordinate +*/ +enum ESemantic { + //! vertex position x coordinate + EST_XCoord = 0x0u, + //! vertex position x coordinate + EST_YCoord, + //! vertex position x coordinate + EST_ZCoord, + + //! vertex normal x coordinate + EST_XNormal, + //! vertex normal y coordinate + EST_YNormal, + //! vertex normal z coordinate + EST_ZNormal, + + //! u texture coordinate + EST_UTextureCoord, + //! v texture coordinate + EST_VTextureCoord, + + //! vertex colors, red channel + EST_Red, + //! vertex colors, green channel + EST_Green, + //! vertex colors, blue channel + EST_Blue, + //! vertex colors, alpha channel + EST_Alpha, + + //! vertex index list + EST_VertexIndex, + + //! texture index + EST_TextureIndex, + + //! texture coordinates (stored as element of a face) + EST_TextureCoordinates, + + //! material index + EST_MaterialIndex, + + //! ambient color, red channel + EST_AmbientRed, + //! ambient color, green channel + EST_AmbientGreen, + //! ambient color, blue channel + EST_AmbientBlue, + //! ambient color, alpha channel + EST_AmbientAlpha, + + //! diffuse color, red channel + EST_DiffuseRed, + //! diffuse color, green channel + EST_DiffuseGreen, + //! diffuse color, blue channel + EST_DiffuseBlue, + //! diffuse color, alpha channel + EST_DiffuseAlpha, + + //! specular color, red channel + EST_SpecularRed, + //! specular color, green channel + EST_SpecularGreen, + //! specular color, blue channel + EST_SpecularBlue, + //! specular color, alpha channel + EST_SpecularAlpha, + + //! specular power for phong shading + EST_PhongPower, + + //! opacity between 0 and 1 + EST_Opacity, + + //! Marks invalid entries + EST_INVALID +}; + +// --------------------------------------------------------------------------------- +/** \brief Specifies semantics for PLY elements + * + * Semantics define the usage of an element, e.g. vertex or material +*/ +enum EElementSemantic { + //! The element is a vertex + EEST_Vertex = 0x0u, + + //! The element is a face description (index table) + EEST_Face, + + //! The element is a triangle-strip description (index table) + EEST_TriStrip, + + //! The element is an edge description (ignored) + EEST_Edge, + + //! The element is a material description + EEST_Material, + + //! texture path + EEST_TextureFile, + + //! Marks invalid entries + EEST_INVALID +}; + +// --------------------------------------------------------------------------------- +/** \brief Helper class for a property in a PLY file. + * + * This can e.g. be a part of the vertex declaration + */ +class Property { +public: + //! Default constructor + Property() AI_NO_EXCEPT + : eType (EDT_Int) + , Semantic() + , bIsList(false) + , eFirstType(EDT_UChar) { + // empty + } + + //! Data type of the property + EDataType eType; + + //! Semantical meaning of the property + ESemantic Semantic; + + //! Of the semantic of the property could not be parsed: + //! Contains the semantic specified in the file + std::string szName; + + //! Specifies whether the data type is a list where + //! the first element specifies the size of the list + bool bIsList; + EDataType eFirstType; + + // ------------------------------------------------------------------- + //! Parse a property from a string. The end of the + //! string is either '\n', '\r' or '\0'. Return value is false + //! if the input string is NOT a valid property (E.g. does + //! not start with the "property" keyword) + static bool ParseProperty(std::vector<char> &buffer, Property* pOut); + + // ------------------------------------------------------------------- + //! Parse a data type from a string + static EDataType ParseDataType(std::vector<char> &buffer); + + // ------------------------------------------------------------------- + //! Parse a semantic from a string + static ESemantic ParseSemantic(std::vector<char> &buffer); +}; + +// --------------------------------------------------------------------------------- +/** \brief Helper class for an element in a PLY file. + * + * This can e.g. be the vertex declaration. Elements contain a + * well-defined number of properties. + */ +class Element { +public: + //! Default constructor + Element() AI_NO_EXCEPT + : eSemantic (EEST_INVALID) + , NumOccur(0) { + // empty + } + + //! List of properties assigned to the element + //! std::vector to support operator[] + std::vector<Property> alProperties; + + //! Semantic of the element + EElementSemantic eSemantic; + + //! Of the semantic of the element could not be parsed: + //! Contains the semantic specified in the file + std::string szName; + + //! How many times will the element occur? + unsigned int NumOccur; + + + // ------------------------------------------------------------------- + //! Parse an element from a string. + //! The function will parse all properties contained in the + //! element, too. + static bool ParseElement(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, Element* pOut); + + // ------------------------------------------------------------------- + //! Parse a semantic from a string + static EElementSemantic ParseSemantic(std::vector<char> &buffer); +}; + +// --------------------------------------------------------------------------------- +/** \brief Instance of a property in a PLY file + */ +class PropertyInstance +{ +public: + + //! Default constructor + PropertyInstance() AI_NO_EXCEPT { + // empty + } + + union ValueUnion + { + + //! uInt32 representation of the property. All + // uint types are automatically converted to uint32 + uint32_t iUInt; + + //! Int32 representation of the property. All + // int types are automatically converted to int32 + int32_t iInt; + + //! Float32 representation of the property + float fFloat; + + //! Float64 representation of the property + double fDouble; + + }; + + // ------------------------------------------------------------------- + //! List of all values parsed. Contains only one value + // for non-list properties + std::vector<ValueUnion> avList; + + // ------------------------------------------------------------------- + //! Parse a property instance + static bool ParseInstance(const char* &pCur, + const Property* prop, PropertyInstance* p_pcOut); + + // ------------------------------------------------------------------- + //! Parse a property instance in binary format + static bool ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, + const char* &pCur, unsigned int &bufferSize, const Property* prop, PropertyInstance* p_pcOut, bool p_bBE); + + // ------------------------------------------------------------------- + //! Get the default value for a given data type + static ValueUnion DefaultValue(EDataType eType); + + // ------------------------------------------------------------------- + //! Parse a value + static bool ParseValue(const char* &pCur, EDataType eType, ValueUnion* out); + + // ------------------------------------------------------------------- + //! Parse a binary value + static bool ParseValueBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, + const char* &pCur, unsigned int &bufferSize, EDataType eType, ValueUnion* out, bool p_bBE); + + // ------------------------------------------------------------------- + //! Convert a property value to a given type TYPE + template <typename TYPE> + static TYPE ConvertTo(ValueUnion v, EDataType eType); +}; + +// --------------------------------------------------------------------------------- +/** \brief Class for an element instance in a PLY file + */ +class ElementInstance { +public: + //! Default constructor + ElementInstance() AI_NO_EXCEPT + : alProperties() { + // empty + } + + //! List of all parsed properties + std::vector< PropertyInstance > alProperties; + + // ------------------------------------------------------------------- + //! Parse an element instance + static bool ParseInstance(const char* &pCur, + const Element* pcElement, ElementInstance* p_pcOut); + + // ------------------------------------------------------------------- + //! Parse a binary element instance + static bool ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, + const char* &pCur, unsigned int &bufferSize, const Element* pcElement, ElementInstance* p_pcOut, bool p_bBE); +}; + +// --------------------------------------------------------------------------------- +/** \brief Class for an element instance list in a PLY file + */ +class ElementInstanceList +{ +public: + + //! Default constructor + ElementInstanceList() AI_NO_EXCEPT + : alInstances() { + // empty + } + + //! List of all element instances + std::vector< ElementInstance > alInstances; + + // ------------------------------------------------------------------- + //! Parse an element instance list + static bool ParseInstanceList(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, + const Element* pcElement, ElementInstanceList* p_pcOut, PLYImporter* loader); + + // ------------------------------------------------------------------- + //! Parse a binary element instance list + static bool ParseInstanceListBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, + const char* &pCur, unsigned int &bufferSize, const Element* pcElement, ElementInstanceList* p_pcOut, PLYImporter* loader, bool p_bBE); +}; +// --------------------------------------------------------------------------------- +/** \brief Class to represent the document object model of an ASCII or binary + * (both little and big-endian) PLY file + */ +class DOM +{ +public: + + //! Default constructor + DOM() AI_NO_EXCEPT + : alElements() + , alElementData() { + + } + + + //! Contains all elements of the file format + std::vector<Element> alElements; + //! Contains the real data of each element's instance list + std::vector<ElementInstanceList> alElementData; + + //! Parse the DOM for a PLY file. The input string is assumed + //! to be terminated with zero + static bool ParseInstance(IOStreamBuffer<char> &streamBuffer, DOM* p_pcOut, PLYImporter* loader); + static bool ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, DOM* p_pcOut, PLYImporter* loader, bool p_bBE); + + //! Skip all comment lines after this + static bool SkipComments(std::vector<char> &buffer); + + static bool SkipSpaces(std::vector<char> &buffer); + + static bool SkipLine(std::vector<char> &buffer); + + static bool TokenMatch(std::vector<char> &buffer, const char* token, unsigned int len); + + static bool SkipSpacesAndLineEnd(std::vector<char> &buffer); + +private: + + // ------------------------------------------------------------------- + //! Handle the file header and read all element descriptions + bool ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, bool p_bBE); + + // ------------------------------------------------------------------- + //! Read in all element instance lists + bool ParseElementInstanceLists(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLYImporter* loader); + + // ------------------------------------------------------------------- + //! Read in all element instance lists for a binary file format + bool ParseElementInstanceListsBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, const char* &pCur, unsigned int &bufferSize, PLYImporter* loader, bool p_bBE); +}; + +// --------------------------------------------------------------------------------- +template <typename TYPE> +inline TYPE PLY::PropertyInstance::ConvertTo( + PLY::PropertyInstance::ValueUnion v, PLY::EDataType eType) +{ + switch (eType) + { + case EDT_Float: + return (TYPE)v.fFloat; + case EDT_Double: + return (TYPE)v.fDouble; + + case EDT_UInt: + case EDT_UShort: + case EDT_UChar: + return (TYPE)v.iUInt; + + case EDT_Int: + case EDT_Short: + case EDT_Char: + return (TYPE)v.iInt; + default: ; + }; + return (TYPE)0; +} + +} // Namespace PLY +} // Namespace AssImp + +#endif // !! include guard |