replace opengexparser by using openddl-parser.
Signed-off-by: Kim Kulling <kim.kulling@googlemail.com>
This commit is contained in:
+1
-3
@@ -353,8 +353,6 @@ SOURCE_GROUP( Ogre FILES ${Ogre_SRCS})
|
||||
SET( OpenGEX_SRCS
|
||||
OpenGEXImporter.cpp
|
||||
OpenGEXImporter.h
|
||||
OpenGEXParser.cpp
|
||||
OpenGEXParser.h
|
||||
OpenGEXStructs.h
|
||||
)
|
||||
SOURCE_GROUP( OpenGEX FILES ${OpenGEX_SRCS})
|
||||
@@ -729,7 +727,7 @@ SET( assimp_src
|
||||
|
||||
ADD_LIBRARY( assimp ${assimp_src} )
|
||||
|
||||
TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES})
|
||||
TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES} )
|
||||
|
||||
if(ANDROID AND ASSIMP_ANDROID_JNIIOSYSTEM)
|
||||
set(ASSIMP_ANDROID_JNIIOSYSTEM_PATH port/AndroidJNI)
|
||||
|
||||
+44
-44
@@ -178,130 +178,130 @@ namespace Assimp {
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void GetImporterInstanceList(std::vector< BaseImporter* >& out)
|
||||
{
|
||||
// ----------------------------------------------------------------------------
|
||||
// Add an instance of each worker class here
|
||||
// (register_new_importers_here)
|
||||
// ----------------------------------------------------------------------------
|
||||
out.reserve(64);
|
||||
// ----------------------------------------------------------------------------
|
||||
// Add an instance of each worker class here
|
||||
// (register_new_importers_here)
|
||||
// ----------------------------------------------------------------------------
|
||||
out.reserve(64);
|
||||
#if (!defined ASSIMP_BUILD_NO_X_IMPORTER)
|
||||
out.push_back( new XFileImporter());
|
||||
out.push_back( new XFileImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_OBJ_IMPORTER)
|
||||
out.push_back( new ObjFileImporter());
|
||||
out.push_back( new ObjFileImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
|
||||
out.push_back( new Discreet3DSImporter());
|
||||
out.push_back( new Discreet3DSImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_MD3_IMPORTER)
|
||||
out.push_back( new MD3Importer());
|
||||
out.push_back( new MD3Importer());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_MD2_IMPORTER)
|
||||
out.push_back( new MD2Importer());
|
||||
out.push_back( new MD2Importer());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_PLY_IMPORTER)
|
||||
out.push_back( new PLYImporter());
|
||||
out.push_back( new PLYImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_MDL_IMPORTER)
|
||||
out.push_back( new MDLImporter());
|
||||
out.push_back( new MDLImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_ASE_IMPORTER)
|
||||
out.push_back( new ASEImporter());
|
||||
out.push_back( new ASEImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_HMP_IMPORTER)
|
||||
out.push_back( new HMPImporter());
|
||||
out.push_back( new HMPImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_SMD_IMPORTER)
|
||||
out.push_back( new SMDImporter());
|
||||
out.push_back( new SMDImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_MDC_IMPORTER)
|
||||
out.push_back( new MDCImporter());
|
||||
out.push_back( new MDCImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_MD5_IMPORTER)
|
||||
out.push_back( new MD5Importer());
|
||||
out.push_back( new MD5Importer());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_STL_IMPORTER)
|
||||
out.push_back( new STLImporter());
|
||||
out.push_back( new STLImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_LWO_IMPORTER)
|
||||
out.push_back( new LWOImporter());
|
||||
out.push_back( new LWOImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_DXF_IMPORTER)
|
||||
out.push_back( new DXFImporter());
|
||||
out.push_back( new DXFImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_NFF_IMPORTER)
|
||||
out.push_back( new NFFImporter());
|
||||
out.push_back( new NFFImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_RAW_IMPORTER)
|
||||
out.push_back( new RAWImporter());
|
||||
out.push_back( new RAWImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_OFF_IMPORTER)
|
||||
out.push_back( new OFFImporter());
|
||||
out.push_back( new OFFImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_AC_IMPORTER)
|
||||
out.push_back( new AC3DImporter());
|
||||
out.push_back( new AC3DImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_BVH_IMPORTER)
|
||||
out.push_back( new BVHLoader());
|
||||
out.push_back( new BVHLoader());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_IRRMESH_IMPORTER)
|
||||
out.push_back( new IRRMeshImporter());
|
||||
out.push_back( new IRRMeshImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_IRR_IMPORTER)
|
||||
out.push_back( new IRRImporter());
|
||||
out.push_back( new IRRImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_Q3D_IMPORTER)
|
||||
out.push_back( new Q3DImporter());
|
||||
out.push_back( new Q3DImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_B3D_IMPORTER)
|
||||
out.push_back( new B3DImporter());
|
||||
out.push_back( new B3DImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_COLLADA_IMPORTER)
|
||||
out.push_back( new ColladaLoader());
|
||||
out.push_back( new ColladaLoader());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_TERRAGEN_IMPORTER)
|
||||
out.push_back( new TerragenImporter());
|
||||
out.push_back( new TerragenImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_CSM_IMPORTER)
|
||||
out.push_back( new CSMImporter());
|
||||
out.push_back( new CSMImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_3D_IMPORTER)
|
||||
out.push_back( new UnrealImporter());
|
||||
out.push_back( new UnrealImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_LWS_IMPORTER)
|
||||
out.push_back( new LWSImporter());
|
||||
out.push_back( new LWSImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_OGRE_IMPORTER)
|
||||
out.push_back( new Ogre::OgreImporter());
|
||||
out.push_back( new Ogre::OgreImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_OPEMGEX_IMPORTER )
|
||||
out.push_back( new OpenGEX::OpenGEXImporter() );
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_MS3D_IMPORTER)
|
||||
out.push_back( new MS3DImporter());
|
||||
out.push_back( new MS3DImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_COB_IMPORTER)
|
||||
out.push_back( new COBImporter());
|
||||
out.push_back( new COBImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_BLEND_IMPORTER)
|
||||
out.push_back( new BlenderImporter());
|
||||
out.push_back( new BlenderImporter());
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_Q3BSP_IMPORTER)
|
||||
out.push_back( new Q3BSPFileImporter() );
|
||||
out.push_back( new Q3BSPFileImporter() );
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_NDO_IMPORTER)
|
||||
out.push_back( new NDOImporter() );
|
||||
out.push_back( new NDOImporter() );
|
||||
#endif
|
||||
#if (!defined ASSIMP_BUILD_NO_IFC_IMPORTER)
|
||||
out.push_back( new IFCImporter() );
|
||||
out.push_back( new IFCImporter() );
|
||||
#endif
|
||||
#if ( !defined ASSIMP_BUILD_NO_XGL_IMPORTER )
|
||||
out.push_back( new XGLImporter() );
|
||||
out.push_back( new XGLImporter() );
|
||||
#endif
|
||||
#if ( !defined ASSIMP_BUILD_NO_FBX_IMPORTER )
|
||||
out.push_back( new FBXImporter() );
|
||||
out.push_back( new FBXImporter() );
|
||||
#endif
|
||||
#if ( !defined ASSIMP_BUILD_NO_ASSBIN_IMPORTER )
|
||||
out.push_back( new AssbinImporter() );
|
||||
out.push_back( new AssbinImporter() );
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@@ -41,9 +41,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#include "AssimpPCH.h"
|
||||
#include "OpenGEXImporter.h"
|
||||
#include "OpenGEXParser.h"
|
||||
#include "DefaultIOSystem.h"
|
||||
|
||||
#include <openddlparser/OpenDDLParser.h>
|
||||
|
||||
#include <vector>
|
||||
|
||||
static const aiImporterDesc desc = {
|
||||
@@ -62,6 +63,8 @@ static const aiImporterDesc desc = {
|
||||
namespace Assimp {
|
||||
namespace OpenGEX {
|
||||
|
||||
USE_ODDLPARSER_NS
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
OpenGEXImporter::OpenGEXImporter() {
|
||||
|
||||
@@ -95,8 +98,14 @@ void OpenGEXImporter::InternReadFile( const std::string &filename, aiScene *pSce
|
||||
|
||||
std::vector<char> buffer;
|
||||
TextFileToBuffer( file, buffer );
|
||||
OpenGEXParser myParser( buffer );
|
||||
myParser.parse();
|
||||
|
||||
OpenDDLParser myParser;
|
||||
myParser.setBuffer( &buffer[ 0 ], buffer.size() );
|
||||
bool success( myParser.parse() );
|
||||
if( success ) {
|
||||
Context *ctx = myParser.getContext();
|
||||
importMetric( ctx );
|
||||
}
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
@@ -109,6 +118,28 @@ void OpenGEXImporter::SetupProperties( const Importer *pImp ) {
|
||||
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::importMetric( Context *ctx ) {
|
||||
if( NULL == ctx || NULL == ctx->getProperties() ) {
|
||||
return;
|
||||
}
|
||||
|
||||
Property *prop = ctx->getProperties();
|
||||
while( NULL != prop ) {
|
||||
prop = prop->m_next;
|
||||
}
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::ParseGeoObject() {
|
||||
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXImporter::ParseMaterial() {
|
||||
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
|
||||
} // Namespace OpenGEX
|
||||
|
||||
@@ -44,6 +44,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#include "BaseImporter.h"
|
||||
|
||||
|
||||
namespace ODDLParser {
|
||||
struct Context;
|
||||
}
|
||||
|
||||
namespace Assimp {
|
||||
namespace OpenGEX {
|
||||
|
||||
@@ -72,7 +77,7 @@ public:
|
||||
virtual void SetupProperties( const Importer *pImp );
|
||||
|
||||
protected:
|
||||
void ParseMetric();
|
||||
void importMetric( ODDLParser::Context *ctx );
|
||||
void ParseGeoObject();
|
||||
void ParseMaterial();
|
||||
};
|
||||
|
||||
@@ -1,409 +0,0 @@
|
||||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2014, 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.
|
||||
|
||||
----------------------------------------------------------------------
|
||||
*/
|
||||
#include "AssimpPCH.h"
|
||||
#ifndef ASSIMP_BUILD_NO_OPEMGEX_IMPORTER
|
||||
|
||||
#include "OpenGEXParser.h"
|
||||
#include "OpenGEXStructs.h"
|
||||
#include "ParsingUtils.h"
|
||||
#include "fast_atof.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
namespace Assimp {
|
||||
namespace OpenGEX {
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
static const std::string Metric = "Metric";
|
||||
static const std::string GeometryNode = "GeometryNode";
|
||||
static const std::string GeometryObject = "GeometryObject";
|
||||
static const std::string Material = "Material";
|
||||
static const size_t NumObjects = 4;
|
||||
static const std::string RootNodes[ NumObjects ] = {
|
||||
Metric,
|
||||
GeometryNode,
|
||||
GeometryObject,
|
||||
Material
|
||||
};
|
||||
|
||||
static const size_t NumSeparator = 4;
|
||||
static const std::string Separator[ NumSeparator ] = {
|
||||
"(", ")", "{", "}"
|
||||
};
|
||||
|
||||
|
||||
static const size_t NumToken = 8;
|
||||
static const std::string Token[ NumToken ] = {
|
||||
RootNodes[ 0 ],
|
||||
RootNodes[ 1 ],
|
||||
RootNodes[ 2 ],
|
||||
RootNodes[ 3 ],
|
||||
Separator[ 0 ],
|
||||
Separator[ 1 ],
|
||||
Separator[ 2 ],
|
||||
Separator[ 3 ]
|
||||
};
|
||||
|
||||
static bool isSeparator( char in ) {
|
||||
return ( in == '(' || in == ')' || in == '{' || in == '}' );
|
||||
}
|
||||
|
||||
static bool containsNode( const char *bufferPtr, size_t size, const std::string *nodes,
|
||||
size_t numNodes, std::string &tokenFound ) {
|
||||
tokenFound = "";
|
||||
if( 0 == numNodes ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool found( false );
|
||||
for( size_t i = 0; i < numNodes; ++i ) {
|
||||
if( TokenMatch( bufferPtr, nodes[ i ].c_str(), nodes[ i ].size() ) ) {
|
||||
tokenFound = nodes[ i ];
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
static OpenGEXParser::TokenType getTokenTypeByName( const char *in ) {
|
||||
ai_assert( NULL != in );
|
||||
|
||||
OpenGEXParser::TokenType type( OpenGEXParser::None );
|
||||
for( size_t i = 0; i < NumToken; ++i ) {
|
||||
if( TokenMatch( in, Token[ i ].c_str(), Token[ i ].size() ) ) {
|
||||
type = static_cast<OpenGEXParser::TokenType>( i+1 );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
static void removeQuotes( std::string &attribName ) {
|
||||
std::string tmp;
|
||||
for( unsigned int i = 0; i < attribName.size(); ++i ) {
|
||||
if( attribName[ i ] != '\"' ) {
|
||||
tmp += attribName[ i ];
|
||||
}
|
||||
}
|
||||
attribName = tmp;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
OpenGEXParser::OpenGEXParser( const std::vector<char> &buffer )
|
||||
: m_buffer( buffer )
|
||||
, m_index( 0 )
|
||||
, m_buffersize( buffer.size() )
|
||||
, m_nodeTypeStack() {
|
||||
// empty
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
OpenGEXParser::~OpenGEXParser() {
|
||||
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXParser::parse() {
|
||||
while( parseNextNode() ) {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
std::string OpenGEXParser::getNextToken() {
|
||||
std::string token;
|
||||
while( m_index < m_buffersize && IsSpace( m_buffer[ m_index ] ) ) {
|
||||
m_index++;
|
||||
}
|
||||
|
||||
while( m_index < m_buffersize && !IsSpace( m_buffer[ m_index ] ) && !isSeparator( m_buffer[ m_index ] ) ) {
|
||||
token += m_buffer[ m_index ];
|
||||
m_index++;
|
||||
}
|
||||
|
||||
if( token == "//" ) {
|
||||
skipComments();
|
||||
token = getNextToken();
|
||||
}
|
||||
|
||||
if( token.empty() ) {
|
||||
if( isSeparator( m_buffer[ m_index ] ) ) {
|
||||
token += m_buffer[ m_index ];
|
||||
m_index++;
|
||||
}
|
||||
}
|
||||
|
||||
return token;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::skipComments() {
|
||||
bool skipped( false );
|
||||
if( strncmp( &m_buffer[ m_index ], "//", 2 ) == 0) {
|
||||
while( !IsLineEnd( m_buffer[ m_index ] ) ) {
|
||||
++m_index;
|
||||
}
|
||||
skipped = true;
|
||||
}
|
||||
|
||||
return skipped;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
void OpenGEXParser::readUntilEndOfLine() {
|
||||
while( !IsLineEnd( m_buffer[ m_index ] ) ) {
|
||||
++m_index;
|
||||
}
|
||||
++m_index;
|
||||
if( IsLineEnd( m_buffer[ m_index ] ) ) {
|
||||
++m_index;
|
||||
}
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::parseNextNode() {
|
||||
std::string token( getNextToken() );
|
||||
std::string rootNodeName, nodeType;
|
||||
if( containsNode( token.c_str(), token.size(), RootNodes, NumObjects, rootNodeName ) ) {
|
||||
m_nodeTypeStack.push_back( getTokenTypeByName( rootNodeName.c_str() ) );
|
||||
if( !getNodeHeader( nodeType ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if( !getNodeData( nodeType ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
readUntilEndOfLine();
|
||||
|
||||
m_nodeTypeStack.pop_back();
|
||||
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::getNodeHeader( std::string &name ) {
|
||||
bool success( false );
|
||||
TokenType tokenType( m_nodeTypeStack.back() );
|
||||
if( tokenType == MetricNode ) {
|
||||
if( getMetricAttributeKey( name ) ) {
|
||||
success = true;
|
||||
}
|
||||
} else if( tokenType == GeometryNode ) {
|
||||
|
||||
} else if( tokenType == GeometryObject ) {
|
||||
|
||||
} else if( tokenType == Material ) {
|
||||
|
||||
} else {
|
||||
DefaultLogger::get()->warn( "Unknown token type in file." );
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::getBracketOpen() {
|
||||
const std::string token( getNextToken() );
|
||||
if( "{" == token ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::getBracketClose() {
|
||||
const std::string token( getNextToken() );
|
||||
if( "}" == token ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::getStringData( std::string &data ) {
|
||||
if( !getBracketOpen() ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if( !getBracketClose() ) {
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::getFloatData( size_t num, float *data ) {
|
||||
ai_assert( NULL != data );
|
||||
|
||||
std::string tk;
|
||||
tk = getNextToken();
|
||||
|
||||
if( !getBracketOpen() ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ok( true );
|
||||
size_t dataIdx( 0 );
|
||||
for( unsigned int i = 0; i < num; ++i ) {
|
||||
data[ dataIdx ] = fast_atof( &m_buffer[ m_index ] );
|
||||
++dataIdx;
|
||||
tk = getNextToken();
|
||||
if( tk == "," ) {
|
||||
if( i >= ( num - 1 ) ) {
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if( !getBracketClose() ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::getNodeData( const std::string &nodeType ) {
|
||||
bool success( false );
|
||||
|
||||
if( !getBracketOpen() ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const TokenType type( m_nodeTypeStack.back() );
|
||||
if( type == MetricNode ) {
|
||||
success = onMetricNode( nodeType );
|
||||
} else if( type == GeometryNode ) {
|
||||
success = onGeometryNode();
|
||||
} else if( type == GeometryObject ) {
|
||||
success = onGeometryObject();
|
||||
} else if( type == Material ) {
|
||||
success = onMaterial();
|
||||
} else {
|
||||
DefaultLogger::get()->warn( "Unknown token type in file." );
|
||||
}
|
||||
|
||||
if( !getBracketClose() ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::getMetricAttributeKey( std::string &attribName ) {
|
||||
bool ok( false );
|
||||
attribName = "";
|
||||
std::string token( getNextToken() );
|
||||
if( token[ 0 ] == '(' ) {
|
||||
// get attribute
|
||||
token = getNextToken();
|
||||
if( "key" == token ) {
|
||||
std::string equal = getNextToken();
|
||||
attribName = getNextToken();
|
||||
token = getNextToken();
|
||||
if( token[ 0 ] == ')' ) {
|
||||
ok = true;
|
||||
removeQuotes( attribName );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::onMetricNode( const std::string &attribName ) {
|
||||
float value( 0.0f );
|
||||
bool success( true );
|
||||
if( "distance" == attribName ) {
|
||||
if( getFloatData( 1, &value ) ) {
|
||||
m_model.m_metrics.m_distance = value;
|
||||
}
|
||||
} else if( "angle" == attribName ) {
|
||||
if( getFloatData( 1, &value ) ) {
|
||||
m_model.m_metrics.m_angle = value;
|
||||
}
|
||||
} else if( "time" == attribName ) {
|
||||
if( getFloatData( 1, &value ) ) {
|
||||
m_model.m_metrics.m_time = value;
|
||||
}
|
||||
} else if( "up" == attribName ) {
|
||||
std::string up;
|
||||
if( getStringData( up ) ) {
|
||||
m_model.m_metrics.m_up = up;
|
||||
}
|
||||
} else {
|
||||
success = false;
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::onGeometryNode() {
|
||||
return true;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::onGeometryObject() {
|
||||
return true;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
bool OpenGEXParser::onMaterial() {
|
||||
return true;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------
|
||||
|
||||
} // Namespace OpenGEX
|
||||
} // Namespace Assimp
|
||||
|
||||
#endif ASSIMP_BUILD_NO_OPEMGEX_IMPORTER
|
||||
@@ -1,121 +0,0 @@
|
||||
/*
|
||||
Open Asset Import Library (assimp)
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2014, 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.
|
||||
|
||||
----------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef ASSIMP_OPENGEX_OPENGEXPARSER_H_INC
|
||||
#define ASSIMP_OPENGEX_OPENGEXPARSER_H_INC
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_OPEMGEX_IMPORTER
|
||||
|
||||
#include <vector>
|
||||
#include <map>
|
||||
|
||||
namespace Assimp {
|
||||
namespace OpenGEX {
|
||||
|
||||
struct OpenGEXModel {
|
||||
struct Metrics {
|
||||
float m_distance;
|
||||
float m_angle;
|
||||
float m_time;
|
||||
std::string m_up;
|
||||
|
||||
Metrics()
|
||||
: m_distance( 0.0f )
|
||||
, m_angle( 0.0f )
|
||||
, m_time( 0.0f )
|
||||
, m_up() {
|
||||
// empty
|
||||
}
|
||||
} m_metrics;
|
||||
};
|
||||
|
||||
class OpenGEXParser {
|
||||
public:
|
||||
enum TokenType {
|
||||
None = 0,
|
||||
MetricNode,
|
||||
GeometryNode,
|
||||
GeometryObject,
|
||||
Material,
|
||||
BracketIn,
|
||||
BracketOut,
|
||||
CurlyBracketIn,
|
||||
CurlyBracketOut,
|
||||
};
|
||||
|
||||
public:
|
||||
OpenGEXParser( const std::vector<char> &buffer );
|
||||
~OpenGEXParser();
|
||||
void parse();
|
||||
|
||||
protected:
|
||||
std::string getNextToken();
|
||||
bool skipComments();
|
||||
void readUntilEndOfLine();
|
||||
bool parseNextNode();
|
||||
bool getNodeHeader( std::string &name );
|
||||
bool getBracketOpen();
|
||||
bool getBracketClose();
|
||||
bool getStringData( std::string &data );
|
||||
bool getFloatData( size_t num, float *data );
|
||||
bool getNodeData( const std::string &nodeType );
|
||||
bool getMetricAttributeKey( std::string &attribName );
|
||||
bool onMetricNode( const std::string &attribName );
|
||||
bool onGeometryNode();
|
||||
bool onGeometryObject();
|
||||
bool onMaterial();
|
||||
|
||||
private:
|
||||
OpenGEXParser( const OpenGEXParser & );
|
||||
OpenGEXParser &operator = ( const OpenGEXParser & );
|
||||
|
||||
private:
|
||||
const std::vector<char> &m_buffer;
|
||||
std::vector<TokenType> m_nodeTypeStack;
|
||||
OpenGEXModel m_model;
|
||||
size_t m_index;
|
||||
size_t m_buffersize;
|
||||
};
|
||||
|
||||
} // Namespace openGEX
|
||||
} // Namespace Assimp
|
||||
|
||||
#endif // ASSIMP_BUILD_NO_OPEMGEX_IMPORTER
|
||||
|
||||
#endif // ASSIMP_OPENGEX_OPENGEXPARSER_H_INC
|
||||
Reference in New Issue
Block a user