304 lines
10 KiB
C++
304 lines
10 KiB
C++
/*
|
|
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_BUILD_NO_OPEMGEX_IMPORTER
|
|
|
|
#include "AssimpPCH.h"
|
|
#include "OpenGEXImporter.h"
|
|
#include "DefaultIOSystem.h"
|
|
|
|
#include <openddlparser/OpenDDLParser.h>
|
|
|
|
#include <vector>
|
|
|
|
static const aiImporterDesc desc = {
|
|
"Open Game Engine Exchange",
|
|
"",
|
|
"",
|
|
"",
|
|
aiImporterFlags_SupportTextFlavour,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"ogex"
|
|
};
|
|
|
|
namespace Grammar {
|
|
static const char *MetricType = "Metric";
|
|
static const char *Metric_DistanceType = "distance";
|
|
static const char *Metric_AngleType = "angle";
|
|
static const char *Metric_TimeType = "time";
|
|
static const char *Metric_UpType = "up";
|
|
static const char *NameType = "Name";
|
|
static const char *ObjectRefType = "ObjectRef";
|
|
static const char *MaterialRefType = "MaterialRef";
|
|
static const char *MetricKeyType = "key";
|
|
static const char *GeometryNodeType = "GeometryNode";
|
|
static const char *GeometryObjectType = "GeometryObject";
|
|
static const char *TransformType = "Transform";
|
|
static const char *MeshType = "Mesh";
|
|
static const char *VertexArrayType = "VertexArray";
|
|
static const char *IndexArrayType = "IndexArray";
|
|
static const char *MaterialType = "Material";
|
|
static const char *ColorType = "Color";
|
|
static const char *TextureType = "Texture";
|
|
|
|
enum TokenType {
|
|
NoneType = -1,
|
|
MetricToken,
|
|
NameToken,
|
|
ObjectRefToken,
|
|
MaterialRefToken,
|
|
MetricKeyToken,
|
|
GeometryNodeToken,
|
|
GeometryObjectToken,
|
|
TransformToken,
|
|
MeshToken,
|
|
VertexArrayToken,
|
|
IndexArrayToken,
|
|
MaterialToken,
|
|
ColorToken,
|
|
TextureToken
|
|
};
|
|
|
|
static const char *ValidMetricToken[ 4 ] = {
|
|
Metric_DistanceType,
|
|
Metric_AngleType,
|
|
Metric_TimeType,
|
|
Metric_UpType
|
|
};
|
|
|
|
static int isValidMetricType( const char *token ) {
|
|
if( NULL == token ) {
|
|
return false;
|
|
}
|
|
|
|
int idx( -1 );
|
|
for( size_t i = 0; i < 4; i++ ) {
|
|
if( 0 == strncmp( ValidMetricToken[ i ], token, strlen( token ) ) ) {
|
|
idx = (int) i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
static TokenType matchTokenType( const char *tokenType ) {
|
|
if( 0 == strncmp( MetricType, tokenType, strlen( tokenType ) ) ) {
|
|
return MetricToken;
|
|
} else if( 0 == strncmp( NameType, tokenType, strlen( tokenType ) ) ) {
|
|
return NameToken;
|
|
} else if( 0 == strncmp( ObjectRefType, tokenType, strlen( tokenType ) ) ) {
|
|
return ObjectRefToken;
|
|
} else if( 0 == strncmp( MaterialRefType, tokenType, strlen( tokenType ) ) ) {
|
|
return MaterialRefToken;
|
|
} else if( 0 == strncmp( MetricKeyType, tokenType, strlen( tokenType ) ) ) {
|
|
return MetricKeyToken;
|
|
} else if( 0 == strncmp( GeometryNodeType, tokenType, strlen( tokenType ) ) ) {
|
|
return GeometryNodeToken;
|
|
} else if( 0 == strncmp( GeometryObjectType, tokenType, strlen( tokenType ) ) ) {
|
|
return GeometryObjectToken;
|
|
} else if( 0 == strncmp( TransformType, tokenType, strlen( tokenType ) ) ) {
|
|
return TransformToken;
|
|
} else if( 0 == strncmp( MeshType, tokenType, strlen( tokenType ) ) ) {
|
|
return MeshToken;
|
|
} else if( 0 == strncmp( VertexArrayType, tokenType, strlen( tokenType ) ) ) {
|
|
return VertexArrayToken;
|
|
} else if( 0 == strncmp( IndexArrayType, tokenType, strlen( tokenType ) ) ) {
|
|
return IndexArrayToken;
|
|
} else if( 0 == strncmp( MaterialType, tokenType, strlen( tokenType ) ) ) {
|
|
return MaterialToken;
|
|
} else if( 0 == strncmp( ColorType, tokenType, strlen( tokenType ) ) ) {
|
|
return ColorToken;
|
|
} else if( 0 == strncmp( TextureType, tokenType, strlen( tokenType ) ) ) {
|
|
return TextureToken;
|
|
}
|
|
|
|
return NoneType;
|
|
}
|
|
|
|
} // Namespace Grammar
|
|
|
|
namespace Assimp {
|
|
namespace OpenGEX {
|
|
|
|
USE_ODDLPARSER_NS
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
OpenGEXImporter::OpenGEXImporter()
|
|
: m_ctx( NULL ) {
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
OpenGEXImporter::~OpenGEXImporter() {
|
|
m_ctx = NULL;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
bool OpenGEXImporter::CanRead( const std::string &file, IOSystem *pIOHandler, bool checkSig ) const {
|
|
bool canRead( false );
|
|
if( !checkSig ) {
|
|
canRead = SimpleExtensionCheck( file, "ogex" );
|
|
} else {
|
|
static const char *token[] = { "Metric", "GeometryNode", "VertexArray (attrib", "IndexArray" };
|
|
canRead = BaseImporter::SearchFileHeaderForToken( pIOHandler, file, token, 4 );
|
|
}
|
|
|
|
return canRead;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
void OpenGEXImporter::InternReadFile( const std::string &filename, aiScene *pScene, IOSystem *pIOHandler ) {
|
|
// open source file
|
|
IOStream *file = pIOHandler->Open( filename, "rb" );
|
|
if( !file ) {
|
|
throw DeadlyImportError( "Failed to open file " + filename );
|
|
}
|
|
|
|
std::vector<char> buffer;
|
|
TextFileToBuffer( file, buffer );
|
|
|
|
OpenDDLParser myParser;
|
|
myParser.setBuffer( &buffer[ 0 ], buffer.size() );
|
|
bool success( myParser.parse() );
|
|
if( success ) {
|
|
m_ctx = myParser.getContext();
|
|
handleNodes( m_ctx->m_root );
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
const aiImporterDesc *OpenGEXImporter::GetInfo() const {
|
|
return &desc;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
void OpenGEXImporter::SetupProperties( const Importer *pImp ) {
|
|
if( NULL == pImp ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
void OpenGEXImporter::handleNodes( DDLNode *node ) {
|
|
if( NULL == node ) {
|
|
return;
|
|
}
|
|
|
|
DDLNode::DllNodeList childs = node->getChildNodeList();
|
|
for( DDLNode::DllNodeList::iterator it = childs.begin(); it != childs.end(); it++ ) {
|
|
Grammar::TokenType tokenType( Grammar::matchTokenType( ( *it )->getType().c_str() ) );
|
|
switch( tokenType ) {
|
|
case Grammar::MetricToken:
|
|
importMetric( *it );
|
|
break;
|
|
|
|
case Grammar::NameToken:
|
|
case Grammar::ObjectRefToken:
|
|
case Grammar::MaterialRefToken:
|
|
case Grammar::MetricKeyToken:
|
|
case Grammar::GeometryNodeToken:
|
|
case Grammar::GeometryObjectToken:
|
|
case Grammar::TransformToken:
|
|
case Grammar::MeshToken:
|
|
case Grammar::VertexArrayToken:
|
|
case Grammar::IndexArrayToken:
|
|
case Grammar::MaterialToken:
|
|
case Grammar::ColorToken:
|
|
case Grammar::TextureToken:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
void OpenGEXImporter::importMetric( DDLNode *node ) {
|
|
if( NULL == node || NULL == m_ctx ) {
|
|
return;
|
|
}
|
|
|
|
if( m_ctx->m_root != node->getParent() ) {
|
|
return;
|
|
}
|
|
|
|
Property *prop( node->getProperties() );
|
|
while( NULL != prop ) {
|
|
if( NULL != prop->m_id ) {
|
|
if( Value::ddl_string == prop->m_primData->m_type ) {
|
|
std::string valName( (char*) prop->m_primData->m_data );
|
|
int type( Grammar::isValidMetricType( valName.c_str() ) );
|
|
if( -1 != type ) {
|
|
Value *val( node->getValue() );
|
|
if( NULL != val ) {
|
|
if( Value::ddl_float == val->m_type ) {
|
|
m_metrics[ type ].m_floatValue = val->getFloat();
|
|
} else if( Value::ddl_int32 == val->m_type ) {
|
|
m_metrics[ type ].m_floatValue = val->getInt32();
|
|
} else {
|
|
throw DeadlyImportError( "OpenGEX: invalid data type for Metric node." );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
prop = prop->m_next;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
void OpenGEXImporter::ParseGeoObject() {
|
|
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
void OpenGEXImporter::ParseMaterial() {
|
|
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
|
|
} // Namespace OpenGEX
|
|
} // Namespace Assimp
|
|
|
|
#endif // ASSIMP_BUILD_NO_OPEMGEX_IMPORTER
|