1 files changed, 520 insertions, 0 deletions
diff --git a/NvCloth/samples/external/assimp-4.1.0/code/D3MFOpcPackage.cpp b/NvCloth/samples/external/assimp-4.1.0/code/D3MFOpcPackage.cpp
new file mode 100644
index 0000000..49143fe
--- /dev/null
+++ b/NvCloth/samples/external/assimp-4.1.0/code/D3MFOpcPackage.cpp
@@ -0,0 +1,520 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2017, 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_3MF_IMPORTER
+
+#include "D3MFOpcPackage.h"
+#include "Exceptional.h"
+
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/ai_assert.h>
+
+#include <cstdlib>
+#include <memory>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <cassert>
+#include <contrib/unzip/unzip.h>
+#include "3MFXmlTags.h"
+
+namespace Assimp {
+
+namespace D3MF {
+
+class IOSystem2Unzip {
+public:
+    static voidpf open(voidpf opaque, const char* filename, int mode);
+    static uLong read(voidpf opaque, voidpf stream, void* buf, uLong size);
+    static uLong write(voidpf opaque, voidpf stream, const void* buf, uLong size);
+    static long tell(voidpf opaque, voidpf stream);
+    static long seek(voidpf opaque, voidpf stream, uLong offset, int origin);
+    static int close(voidpf opaque, voidpf stream);
+    static int testerror(voidpf opaque, voidpf stream);
+    static zlib_filefunc_def get(IOSystem* pIOHandler);
+};
+
+voidpf IOSystem2Unzip::open(voidpf opaque, const char* filename, int mode) {
+    IOSystem* io_system = reinterpret_cast<IOSystem*>(opaque);
+
+    const char* mode_fopen = NULL;
+    if((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) {
+        mode_fopen = "rb";
+    } else {
+        if(mode & ZLIB_FILEFUNC_MODE_EXISTING) {
+            mode_fopen = "r+b";
+        } else {
+            if(mode & ZLIB_FILEFUNC_MODE_CREATE) {
+                mode_fopen = "wb";
+            }
+        }
+    }
+
+    return (voidpf) io_system->Open(filename, mode_fopen);
+}
+
+uLong IOSystem2Unzip::read(voidpf /*opaque*/, voidpf stream, void* buf, uLong size) {
+    IOStream* io_stream = (IOStream*) stream;
+
+    return static_cast<uLong>(io_stream->Read(buf, 1, size));
+}
+
+uLong IOSystem2Unzip::write(voidpf /*opaque*/, voidpf stream, const void* buf, uLong size) {
+    IOStream* io_stream = (IOStream*) stream;
+
+    return static_cast<uLong>(io_stream->Write(buf, 1, size));
+}
+
+long IOSystem2Unzip::tell(voidpf /*opaque*/, voidpf stream) {
+    IOStream* io_stream = (IOStream*) stream;
+
+    return static_cast<long>(io_stream->Tell());
+}
+
+long IOSystem2Unzip::seek(voidpf /*opaque*/, voidpf stream, uLong offset, int origin) {
+    IOStream* io_stream = (IOStream*) stream;
+
+    aiOrigin assimp_origin;
+    switch (origin) {
+        default:
+        case ZLIB_FILEFUNC_SEEK_CUR:
+            assimp_origin = aiOrigin_CUR;
+            break;
+        case ZLIB_FILEFUNC_SEEK_END:
+            assimp_origin = aiOrigin_END;
+            break;
+        case ZLIB_FILEFUNC_SEEK_SET:
+            assimp_origin = aiOrigin_SET;
+            break;
+    }
+
+    return (io_stream->Seek(offset, assimp_origin) == aiReturn_SUCCESS ? 0 : -1);
+}
+
+int IOSystem2Unzip::close(voidpf opaque, voidpf stream) {
+    IOSystem* io_system = (IOSystem*) opaque;
+    IOStream* io_stream = (IOStream*) stream;
+
+    io_system->Close(io_stream);
+
+    return 0;
+}
+
+int IOSystem2Unzip::testerror(voidpf /*opaque*/, voidpf /*stream*/) {
+    return 0;
+}
+
+zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) {
+    zlib_filefunc_def mapping;
+
+    mapping.zopen_file = open;
+    mapping.zread_file = read;
+    mapping.zwrite_file = write;
+    mapping.ztell_file = tell;
+    mapping.zseek_file = seek;
+    mapping.zclose_file = close;
+    mapping.zerror_file = testerror;
+    mapping.opaque = reinterpret_cast<voidpf>(pIOHandler);
+
+    return mapping;
+}
+
+class ZipFile : public IOStream {
+    friend class D3MFZipArchive;
+
+public:
+    explicit ZipFile(size_t size);
+    virtual ~ZipFile();
+    size_t Read(void* pvBuffer, size_t pSize, size_t pCount );
+    size_t Write(const void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/);
+    size_t FileSize() const;
+    aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/);
+    size_t Tell() const;
+    void Flush();
+
+private:
+    void *m_Buffer;
+    size_t m_Size;
+};
+
+ZipFile::ZipFile(size_t size)
+: m_Buffer( nullptr )
+, m_Size(size) {
+    ai_assert(m_Size != 0);
+    m_Buffer = ::malloc(m_Size);
+}
+
+ZipFile::~ZipFile() {
+    ::free(m_Buffer);
+    m_Buffer = NULL;
+}
+
+size_t ZipFile::Read(void* pvBuffer, size_t pSize, size_t pCount) {
+    const size_t size = pSize * pCount;
+    ai_assert(size <= m_Size);
+
+    std::memcpy(pvBuffer, m_Buffer, size);
+
+    return size;
+}
+
+size_t ZipFile::Write(const void* pvBuffer, size_t size, size_t pCount ) {
+    const size_t size_to_write( size * pCount );
+    if ( 0 == size_to_write ) {
+        return 0U;
+    }
+    return 0U;
+}
+
+size_t ZipFile::FileSize() const {
+    return m_Size;
+}
+
+aiReturn ZipFile::Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
+    return aiReturn_FAILURE;
+}
+
+size_t ZipFile::Tell() const {
+    return 0;
+}
+
+void ZipFile::Flush() {
+    // empty
+}
+
+class D3MFZipArchive : public IOSystem {
+public:
+    static const unsigned int FileNameSize = 256;
+
+    D3MFZipArchive(IOSystem* pIOHandler, const std::string & rFile);
+    ~D3MFZipArchive();
+    bool Exists(const char* pFile) const;
+    char getOsSeparator() const;
+    IOStream* Open(const char* pFile, const char* pMode = "rb");
+    void Close(IOStream* pFile);
+    bool isOpen() const;
+    void getFileList(std::vector<std::string> &rFileList);
+
+private:
+    bool mapArchive();
+
+private:
+    unzFile m_ZipFileHandle;
+    std::map<std::string, ZipFile*> m_ArchiveMap;
+};
+
+// ------------------------------------------------------------------------------------------------
+//  Constructor.
+D3MFZipArchive::D3MFZipArchive(IOSystem* pIOHandler, const std::string& rFile)
+: m_ZipFileHandle(NULL)
+, m_ArchiveMap() {
+    if (! rFile.empty()) {                
+        zlib_filefunc_def mapping = IOSystem2Unzip::get(pIOHandler);            
+
+        m_ZipFileHandle = unzOpen2(rFile.c_str(), &mapping);
+        if(m_ZipFileHandle != NULL) {            
+            mapArchive();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Destructor.
+D3MFZipArchive::~D3MFZipArchive() {
+    for(auto &file : m_ArchiveMap) {
+        delete file.second;
+    }
+    m_ArchiveMap.clear();
+
+    if(m_ZipFileHandle != NULL) {
+        unzClose(m_ZipFileHandle);
+        m_ZipFileHandle = NULL;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true, if the archive is already open.
+bool D3MFZipArchive::isOpen() const {
+    return (m_ZipFileHandle != NULL);
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true, if the filename is part of the archive.
+bool D3MFZipArchive::Exists(const char* pFile) const {
+    ai_assert(pFile != NULL);
+
+    bool exist = false;
+
+    if (pFile != NULL) {
+        std::string rFile(pFile);
+        std::map<std::string, ZipFile*>::const_iterator it = m_ArchiveMap.find(rFile);
+
+        if(it != m_ArchiveMap.end()) {
+            exist = true;
+        }
+    }
+
+    return exist;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns the separator delimiter.
+char D3MFZipArchive::getOsSeparator() const {
+#ifndef _WIN32
+    return '/';
+#else
+    return '\\';
+#endif
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Opens a file, which is part of the archive.
+IOStream *D3MFZipArchive::Open(const char* pFile, const char* /*pMode*/) {
+    ai_assert(pFile != NULL);
+
+    IOStream* result = NULL;
+
+    std::map<std::string, ZipFile*>::iterator it = m_ArchiveMap.find(pFile);
+
+    if(it != m_ArchiveMap.end()) {
+        result = static_cast<IOStream*>(it->second);
+    }
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Close a filestream.
+void D3MFZipArchive::Close(IOStream *pFile) {
+    (void)(pFile);
+    ai_assert(pFile != NULL);
+
+    // We don't do anything in case the file would be opened again in the future
+}
+// ------------------------------------------------------------------------------------------------
+//  Returns the file-list of the archive.
+void D3MFZipArchive::getFileList(std::vector<std::string> &rFileList) {
+    rFileList.clear();
+
+    for(const auto &file : m_ArchiveMap) {
+        rFileList.push_back(file.first);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Maps the archive content.
+bool D3MFZipArchive::mapArchive() {
+    bool success = false;
+
+    if(m_ZipFileHandle != NULL) {
+        if(m_ArchiveMap.empty()) {
+            //  At first ensure file is already open
+            if(unzGoToFirstFile(m_ZipFileHandle) == UNZ_OK) {
+                // Loop over all files
+                do {
+                    char filename[FileNameSize];
+                    unz_file_info fileInfo;
+
+                    if(unzGetCurrentFileInfo(m_ZipFileHandle, &fileInfo, filename, FileNameSize, NULL, 0, NULL, 0) == UNZ_OK) {
+                        // The file has EXACTLY the size of uncompressed_size. In C
+                        // you need to mark the last character with '\0', so add
+                        // another character
+                        if(fileInfo.uncompressed_size != 0 && unzOpenCurrentFile(m_ZipFileHandle) == UNZ_OK) {
+                            std::pair<std::map<std::string, ZipFile*>::iterator, bool> result = m_ArchiveMap.insert(std::make_pair(filename, new ZipFile(fileInfo.uncompressed_size)));
+
+                            if(unzReadCurrentFile(m_ZipFileHandle, result.first->second->m_Buffer, fileInfo.uncompressed_size) == (long int) fileInfo.uncompressed_size) {
+                                if(unzCloseCurrentFile(m_ZipFileHandle) == UNZ_OK) {
+                                    // Nothing to do anymore...
+                                }
+                            }
+                        }
+                    }
+                } while(unzGoToNextFile(m_ZipFileHandle) != UNZ_END_OF_LIST_OF_FILE);
+            }
+        }
+
+        success = true;
+    }
+
+    return success;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+typedef std::shared_ptr<OpcPackageRelationship> OpcPackageRelationshipPtr;
+
+class OpcPackageRelationshipReader {
+public:
+    OpcPackageRelationshipReader(XmlReader* xmlReader) {        
+        while(xmlReader->read()) {
+            if(xmlReader->getNodeType() == irr::io::EXN_ELEMENT &&
+               xmlReader->getNodeName() == XmlTag::RELS_RELATIONSHIP_CONTAINER)
+            {
+                ParseRootNode(xmlReader);
+            }
+        }
+    }
+
+    void ParseRootNode(XmlReader* xmlReader)
+    {       
+        ParseAttributes(xmlReader);
+
+        while(xmlReader->read())
+        {
+            if(xmlReader->getNodeType() == irr::io::EXN_ELEMENT &&
+               xmlReader->getNodeName() == XmlTag::RELS_RELATIONSHIP_NODE)
+            {
+                ParseChildNode(xmlReader);
+            }
+        }
+    }
+
+    void ParseAttributes(XmlReader*) {
+        // empty
+    }
+
+    bool validateRels( OpcPackageRelationshipPtr &relPtr ) {
+        if ( relPtr->id.empty() || relPtr->type.empty() || relPtr->target.empty() ) {
+            return false;
+        }
+        return true;
+    }
+
+    void ParseChildNode(XmlReader* xmlReader) {        
+        OpcPackageRelationshipPtr relPtr(new OpcPackageRelationship());
+
+        relPtr->id = xmlReader->getAttributeValueSafe(XmlTag::RELS_ATTRIB_ID.c_str());
+        relPtr->type = xmlReader->getAttributeValueSafe(XmlTag::RELS_ATTRIB_TYPE.c_str());
+        relPtr->target = xmlReader->getAttributeValueSafe(XmlTag::RELS_ATTRIB_TARGET.c_str());
+        if ( validateRels( relPtr ) ) {
+            m_relationShips.push_back( relPtr );
+        }
+    }
+
+    std::vector<OpcPackageRelationshipPtr> m_relationShips;
+};
+// ------------------------------------------------------------------------------------------------
+
+D3MFOpcPackage::D3MFOpcPackage(IOSystem* pIOHandler, const std::string& rFile)
+: mRootStream(nullptr)
+, mZipArchive() {    
+    mZipArchive.reset( new D3MF::D3MFZipArchive( pIOHandler, rFile ) );    
+    if(!mZipArchive->isOpen()) {
+        throw DeadlyImportError("Failed to open file " + rFile+ ".");
+    }
+
+    std::vector<std::string> fileList;
+    mZipArchive->getFileList(fileList);
+
+    for (auto& file: fileList) {
+        if(file == D3MF::XmlTag::ROOT_RELATIONSHIPS_ARCHIVE) {
+            //PkgRelationshipReader pkgRelReader(file, archive);
+            ai_assert(mZipArchive->Exists(file.c_str()));
+
+            IOStream *fileStream = mZipArchive->Open(file.c_str());
+
+            ai_assert(fileStream != nullptr);
+
+            std::string rootFile = ReadPackageRootRelationship(fileStream);
+            if ( rootFile.size() > 0 && rootFile[ 0 ] == '/' ) {
+                rootFile = rootFile.substr( 1 );
+                if ( rootFile[ 0 ] == '/' ) {
+                    // deal with zipbug
+                    rootFile = rootFile.substr( 1 );
+                }
+            }
+
+            DefaultLogger::get()->debug(rootFile);
+
+            mRootStream = mZipArchive->Open(rootFile.c_str());
+            ai_assert( mRootStream != nullptr );
+            if ( nullptr == mRootStream ) {
+                throw DeadlyExportError( "Cannot open rootfile in archive : " + rootFile );
+            }
+
+        //    const size_t size = zipArchive->FileSize();
+        //    m_Data.resize( size );
+
+        //    const size_t readSize = pMapFile->Read( &m_Data[0], sizeof( char ), size );
+        //    if ( readSize != size )
+        //    {
+        //        m_Data.clear();
+        //        return false;
+        //    }
+            mZipArchive->Close( fileStream );
+
+        } else if( file == D3MF::XmlTag::CONTENT_TYPES_ARCHIVE) {
+
+        }
+    }
+}
+
+D3MFOpcPackage::~D3MFOpcPackage() {
+    // empty
+}
+
+IOStream* D3MFOpcPackage::RootStream() const {
+    return mRootStream;
+}
+
+std::string D3MFOpcPackage::ReadPackageRootRelationship(IOStream* stream) {
+    std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(stream));
+    std::unique_ptr<XmlReader> xml(irr::io::createIrrXMLReader(xmlStream.get()));
+
+    OpcPackageRelationshipReader reader(xml.get());
+
+    auto itr = std::find_if(reader.m_relationShips.begin(), reader.m_relationShips.end(), [](const OpcPackageRelationshipPtr& rel){
+        return rel->type == XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
+    });
+
+    if(itr == reader.m_relationShips.end())
+        throw DeadlyImportError("Cannot find " + XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE);
+
+    return (*itr)->target;
+}
+
+} // Namespace D3MF
+
+} // Namespace Assimp
+
+#endif //ASSIMP_BUILD_NO_3MF_IMPORTER