Initiual commit: AssetImporter source moved from ZFXCE repository to its own repository. PLease do not use the ZFXCE repo any more.
git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@1 67173fc5-114c-0410-ac8e-9d2fd5bffc1f
This commit is contained in:
kimmi
483
code/PlyParser.h
Normal file
483
code/PlyParser.h
Normal file
@@ -0,0 +1,483 @@
|
||||
/** @file Defines the helper data structures for importing PLY files */
|
||||
#ifndef AI_PLYFILEHELPER_H_INC
|
||||
#define AI_PLYFILEHELPER_H_INC
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <sstream>
|
||||
|
||||
#include "../include/aiTypes.h"
|
||||
#include "../include/aiMesh.h"
|
||||
#include "../include/aiAnim.h"
|
||||
|
||||
namespace Assimp
|
||||
{
|
||||
|
||||
// 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,
|
||||
|
||||
//! 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 tristrip description (index table)
|
||||
EEST_TriStrip,
|
||||
|
||||
//! The element is an edge description (ignored)
|
||||
EEST_Edge,
|
||||
|
||||
//! The element is a material description
|
||||
EEST_Material,
|
||||
|
||||
//! 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()
|
||||
: eType (EDT_Int), bIsList(false), eFirstType(EDT_UChar)
|
||||
{}
|
||||
|
||||
//! 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 valie is false
|
||||
//! if the input string is NOT a valid property (E.g. does
|
||||
//! not start with the "property" keyword)
|
||||
static bool ParseProperty (const char* p_szIn, const char** p_szOut,
|
||||
Property* pOut);
|
||||
|
||||
//! Parse a data type from a string
|
||||
static EDataType ParseDataType(const char* p_szIn,const char** p_szOut);
|
||||
|
||||
//! Parse a semantic from a string
|
||||
static ESemantic ParseSemantic(const char* p_szIn,const char** p_szOut);
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
/** \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()
|
||||
: NumOccur(0), eSemantic (EEST_INVALID)
|
||||
{}
|
||||
|
||||
//! 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 (const char* p_szIn, const char** p_szOut,
|
||||
Element* pOut);
|
||||
|
||||
//! Parse a semantic from a string
|
||||
static EElementSemantic ParseSemantic(const char* p_szIn,
|
||||
const char** p_szOut);
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
/** \brief Instance of a property in a PLY file
|
||||
*/
|
||||
class PropertyInstance
|
||||
{
|
||||
public:
|
||||
|
||||
//! Default constructor
|
||||
PropertyInstance ()
|
||||
{}
|
||||
|
||||
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 propertys
|
||||
std::list<ValueUnion> avList;
|
||||
|
||||
//! Parse a property instance
|
||||
static bool ParseInstance (const char* p_szIn,const char** p_szOut,
|
||||
const Property* prop, PropertyInstance* p_pcOut);
|
||||
|
||||
//! Parse a property instance in binary format
|
||||
static bool ParseInstanceBinary (const char* p_szIn,const char** p_szOut,
|
||||
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* p_szIn,const char** p_szOut,
|
||||
EDataType eType,ValueUnion* out);
|
||||
|
||||
//! Parse a binary value
|
||||
static bool ParseValueBinary(const char* p_szIn,const char** p_szOut,
|
||||
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 ()
|
||||
{}
|
||||
|
||||
//! List of all parsed properties
|
||||
std::vector< PropertyInstance > alProperties;
|
||||
|
||||
//! Parse an element instance
|
||||
static bool ParseInstance (const char* p_szIn,const char** p_szOut,
|
||||
const Element* pcElement, ElementInstance* p_pcOut);
|
||||
|
||||
//! Parse a binary element instance
|
||||
static bool ParseInstanceBinary (const char* p_szIn,const char** p_szOut,
|
||||
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 ()
|
||||
{}
|
||||
|
||||
ElementInstanceList (const Element* pc)
|
||||
{
|
||||
alInstances.reserve(pc->NumOccur);
|
||||
}
|
||||
|
||||
//! List of all element instances
|
||||
std::vector< ElementInstance > alInstances;
|
||||
|
||||
//! Parse an element instance list
|
||||
static bool ParseInstanceList (const char* p_szIn,const char** p_szOut,
|
||||
const Element* pcElement, ElementInstanceList* p_pcOut);
|
||||
|
||||
//! Parse a binary element instance list
|
||||
static bool ParseInstanceListBinary (const char* p_szIn,const char** p_szOut,
|
||||
const Element* pcElement, ElementInstanceList* p_pcOut,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()
|
||||
{}
|
||||
|
||||
|
||||
std::vector<Element> alElements;
|
||||
std::vector<ElementInstanceList> alElementData;
|
||||
|
||||
//! Parse the DOM for a PLY file. The input string is assumed
|
||||
//! to be terminated with zero
|
||||
static bool ParseInstance (const char* p_szIn,DOM* p_pcOut);
|
||||
static bool ParseInstanceBinary (const char* p_szIn,
|
||||
DOM* p_pcOut,bool p_bBE);
|
||||
|
||||
//! Skip all comment lines after this
|
||||
static bool SkipComments (const char* p_szIn,const char** p_szOut);
|
||||
|
||||
private:
|
||||
|
||||
//! Handle the file header and read all element descriptions
|
||||
bool ParseHeader (const char* p_szIn,const char** p_szOut);
|
||||
|
||||
//! Read in all element instance lists
|
||||
bool ParseElementInstanceLists (const char* p_szIn,const char** p_szOut);
|
||||
|
||||
//! Read in all element instance lists for a binary file format
|
||||
bool ParseElementInstanceListsBinary (const char* p_szIn,
|
||||
const char** p_szOut,bool p_bBE);
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
/** \brief Helper class to represent a loaded face
|
||||
*/
|
||||
class Face
|
||||
{
|
||||
public:
|
||||
|
||||
Face()
|
||||
: iMaterialIndex(0xFFFFFFFF)
|
||||
{
|
||||
// set all indices to zero by default
|
||||
mIndices.resize(3,0);
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
//! List of vertex indices
|
||||
std::vector<unsigned int> mIndices;
|
||||
|
||||
//! Material index
|
||||
unsigned int iMaterialIndex;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
template <typename TYPE>
|
||||
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;
|
||||
};
|
||||
return (TYPE)0;
|
||||
}
|
||||
// ---------------------------------------------------------------------------------
|
||||
inline bool IsSpace( const char in)
|
||||
{
|
||||
return (in == ' ' || in == '\t');
|
||||
}
|
||||
// ---------------------------------------------------------------------------------
|
||||
inline bool IsLineEnd( const char in)
|
||||
{
|
||||
return (in == '\r' || in == '\n' || in == '\0');
|
||||
}
|
||||
// ---------------------------------------------------------------------------------
|
||||
inline bool IsSpaceOrNewLine( const char in)
|
||||
{
|
||||
return IsSpace(in) || IsLineEnd(in);
|
||||
}
|
||||
// ---------------------------------------------------------------------------------
|
||||
inline bool SkipSpaces( const char* in, const char** out)
|
||||
{
|
||||
while (*in == ' ' || *in == '\t')in++;
|
||||
*out = in;
|
||||
return !IsLineEnd(*in);
|
||||
}
|
||||
// ---------------------------------------------------------------------------------
|
||||
inline bool SkipLine( const char* in, const char** out)
|
||||
{
|
||||
while (*in != '\r' && *in != '\n' && *in != '\0')in++;
|
||||
|
||||
if (*in == '\0')
|
||||
{
|
||||
*out = in;
|
||||
return false;
|
||||
}
|
||||
in++;
|
||||
*out = in;
|
||||
return true;
|
||||
}
|
||||
// ---------------------------------------------------------------------------------
|
||||
inline void SkipSpacesAndLineEnd( const char* in, const char** out)
|
||||
{
|
||||
while (*in == ' ' || *in == '\t' || *in == '\r' || *in == '\n')in++;
|
||||
*out = in;
|
||||
}
|
||||
|
||||
};
|
||||
};
|
||||
|
||||
#endif // !! include guard
|
||||
Reference in New Issue
Block a user