WIP of assimp integration.

Engine/lib/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp

@@ -0,0 +1,212 @@
+/*-----------------------------------------------------------------------------------------------
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Kim Kulling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+-----------------------------------------------------------------------------------------------*/
+#include <openddlparser/OpenDDLCommon.h>
+#include <openddlparser/DDLNode.h>
+#include <openddlparser/Value.h>
+
+BEGIN_ODDLPARSER_NS
+
+Text::Text( const char *buffer, size_t numChars )
+: m_capacity( 0 )
+, m_len( 0 )
+, m_buffer( ddl_nullptr ) {
+    set( buffer, numChars );
+}
+
+Text::~Text() {
+    clear();
+}
+
+void Text::clear() {
+    delete[] m_buffer;
+    m_buffer = ddl_nullptr;
+    m_capacity = 0;
+    m_len = 0;
+}
+
+void Text::set( const char *buffer, size_t numChars ) {
+    clear();
+    if( numChars > 0 ) {
+        m_len = numChars;
+        m_capacity = m_len + 1;
+        m_buffer = new char[ m_capacity ];
+        strncpy( m_buffer, buffer, numChars );
+        m_buffer[ numChars ] = '\0';
+    }
+}
+
+bool Text::operator == ( const std::string &name ) const {
+    if( m_len != name.size() ) {
+        return false;
+    }
+    const int res( strncmp( m_buffer, name.c_str(), name.size() ) );
+
+    return ( 0 == res );
+}
+
+bool Text::operator == ( const Text &rhs ) const {
+    if( m_len != rhs.m_len ) {
+        return false;
+    }
+
+    const int res( strncmp( m_buffer, rhs.m_buffer, m_len ) );
+
+    return ( 0 == res );
+}
+
+Name::Name( NameType type, Text *id )
+: m_type( type )
+, m_id( id ) {
+    // empty
+}
+
+Name::~Name() {
+    delete m_id;
+    m_id = ddl_nullptr;
+}
+
+Name::Name( const Name &name ){
+    m_type=name.m_type;
+    m_id=new Text(name.m_id->m_buffer,name.m_id->m_len);
+}
+
+
+
+    Reference::Reference()
+: m_numRefs( 0 )
+, m_referencedName( ddl_nullptr ) {
+    // empty
+}
+
+Reference::Reference( size_t numrefs, Name **names )
+: m_numRefs( numrefs )
+, m_referencedName( ddl_nullptr ) {
+    if ( numrefs > 0 ) {
+        m_referencedName = new Name *[ numrefs ];
+        for ( size_t i = 0; i < numrefs; i++ ) {
+            m_referencedName[ i ] = names[i];
+        }
+    }
+}
+Reference::Reference(const Reference &ref) {
+    m_numRefs=ref.m_numRefs;
+    if(m_numRefs!=0){
+        m_referencedName = new Name*[m_numRefs];
+        for ( size_t i = 0; i < m_numRefs; i++ ) {
+            m_referencedName[i] = new Name(*ref.m_referencedName[i]);
+        }
+    }
+}
+
+Reference::~Reference() {
+    for( size_t i = 0; i < m_numRefs; i++ ) {
+        delete m_referencedName[ i ];
+    }
+    m_numRefs = 0;
+    delete [] m_referencedName;
+    m_referencedName = ddl_nullptr;
+}
+
+size_t Reference::sizeInBytes() {
+    if ( 0 == m_numRefs ) {
+        return 0;
+    }
+
+    size_t size( 0 );
+    for ( size_t i = 0; i < m_numRefs; i++ ) {
+        Name *name( m_referencedName[ i ] );
+        if ( ddl_nullptr != name ) {
+            size += name->m_id->m_len;
+        }
+    }
+
+    return size;
+}
+
+Property::Property( Text *id )
+: m_key( id )
+, m_value( ddl_nullptr )
+, m_ref( ddl_nullptr )
+, m_next( ddl_nullptr ) {
+    // empty
+}
+
+Property::~Property() {
+    delete m_key;
+    if(m_value!=ddl_nullptr)
+        delete m_value;
+    if(m_ref!=ddl_nullptr)
+        delete(m_ref);
+    if(m_next!=ddl_nullptr)
+        delete m_next;
+}
+
+DataArrayList::DataArrayList()
+: m_numItems( 0 )
+, m_dataList( ddl_nullptr )
+, m_next( ddl_nullptr )
+, m_refs(ddl_nullptr)
+, m_numRefs(0){
+    // empty
+}
+
+DataArrayList::~DataArrayList() {
+    delete m_dataList;
+    if(m_next!=ddl_nullptr)
+        delete m_next;
+    if(m_refs!=ddl_nullptr)
+        delete m_refs;
+}
+
+size_t DataArrayList::size() {
+    size_t result( 0 );
+    if ( ddl_nullptr == m_next ) {
+        if ( m_dataList != ddl_nullptr ) {
+            result = 1;
+        }
+        return result;
+    }
+
+    DataArrayList *n( m_next );
+    while( ddl_nullptr != n ) {
+        result++;
+        n = n->m_next;
+    }
+    return result;
+}
+
+Context::Context()
+: m_root( ddl_nullptr ) {
+    // empty
+}
+
+Context::~Context() {
+    clear();
+}
+
+void Context::clear() {
+    delete m_root;
+    m_root = ddl_nullptr;
+}
+
+END_ODDLPARSER_NS