diff options
Diffstat (limited to 'src/3rdparty/assimp/code/AssbinExporter.cpp')
| -rw-r--r-- | src/3rdparty/assimp/code/AssbinExporter.cpp | 822 |
1 files changed, 0 insertions, 822 deletions
diff --git a/src/3rdparty/assimp/code/AssbinExporter.cpp b/src/3rdparty/assimp/code/AssbinExporter.cpp deleted file mode 100644 index bcac2e08f..000000000 --- a/src/3rdparty/assimp/code/AssbinExporter.cpp +++ /dev/null @@ -1,822 +0,0 @@ -/* -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. - ----------------------------------------------------------------------- -*/ -/** @file AssbinExporter.cpp - * ASSBIN exporter main code - */ -#include "assbin_chunks.h" -#include <assimp/version.h> -#include <assimp/IOStream.hpp> -#include <assimp/IOSystem.hpp> -#include <assimp/Exporter.hpp> -#include "ProcessHelper.h" -#include "Exceptional.h" - -#ifdef ASSIMP_BUILD_NO_OWN_ZLIB -# include <zlib.h> -#else -# include "../contrib/zlib/zlib.h" -#endif - -#include <time.h> - - -#ifndef ASSIMP_BUILD_NO_EXPORT -#ifndef ASSIMP_BUILD_NO_ASSBIN_EXPORTER - -using namespace Assimp; - -namespace Assimp { - -template <typename T> -size_t Write(IOStream * stream, const T& v) -{ - return stream->Write( &v, sizeof(T), 1 ); -} - - -// ----------------------------------------------------------------------------------- -// Serialize an aiString -template <> -inline size_t Write<aiString>(IOStream * stream, const aiString& s) -{ - const size_t s2 = (uint32_t)s.length; - stream->Write(&s,4,1); - stream->Write(s.data,s2,1); - return s2+4; -} - -// ----------------------------------------------------------------------------------- -// Serialize an unsigned int as uint32_t -template <> -inline size_t Write<unsigned int>(IOStream * stream, const unsigned int& w) -{ - const uint32_t t = (uint32_t)w; - if (w > t) { - // this shouldn't happen, integers in Assimp data structures never exceed 2^32 - throw new DeadlyExportError("loss of data due to 64 -> 32 bit integer conversion"); - } - - stream->Write(&t,4,1); - return 4; -} - -// ----------------------------------------------------------------------------------- -// Serialize an unsigned int as uint16_t -template <> -inline size_t Write<uint16_t>(IOStream * stream, const uint16_t& w) -{ - static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2"); - stream->Write(&w,2,1); - return 2; -} - -// ----------------------------------------------------------------------------------- -// Serialize a float -template <> -inline size_t Write<float>(IOStream * stream, const float& f) -{ - static_assert(sizeof(float)==4, "sizeof(float)==4"); - stream->Write(&f,4,1); - return 4; -} - -// ----------------------------------------------------------------------------------- -// Serialize a double -template <> -inline size_t Write<double>(IOStream * stream, const double& f) -{ - static_assert(sizeof(double)==8, "sizeof(double)==8"); - stream->Write(&f,8,1); - return 8; -} - -// ----------------------------------------------------------------------------------- -// Serialize a vec3 -template <> -inline size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v) -{ - size_t t = Write<float>(stream,v.x); - t += Write<float>(stream,v.y); - t += Write<float>(stream,v.z); - return t; -} - -// ----------------------------------------------------------------------------------- -// Serialize a color value -template <> -inline size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v) -{ - size_t t = Write<float>(stream,v.r); - t += Write<float>(stream,v.g); - t += Write<float>(stream,v.b); - return t; -} - -// ----------------------------------------------------------------------------------- -// Serialize a color value -template <> -inline size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v) -{ - size_t t = Write<float>(stream,v.r); - t += Write<float>(stream,v.g); - t += Write<float>(stream,v.b); - t += Write<float>(stream,v.a); - return t; -} - -// ----------------------------------------------------------------------------------- -// Serialize a quaternion -template <> -inline size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v) -{ - size_t t = Write<float>(stream,v.w); - t += Write<float>(stream,v.x); - t += Write<float>(stream,v.y); - t += Write<float>(stream,v.z); - ai_assert(t == 16); - return 16; -} - - -// ----------------------------------------------------------------------------------- -// Serialize a vertex weight -template <> -inline size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v) -{ - size_t t = Write<unsigned int>(stream,v.mVertexId); - return t+Write<float>(stream,v.mWeight); -} - -// ----------------------------------------------------------------------------------- -// Serialize a mat4x4 -template <> -inline size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m) -{ - for (unsigned int i = 0; i < 4;++i) { - for (unsigned int i2 = 0; i2 < 4;++i2) { - Write<float>(stream,m[i][i2]); - } - } - return 64; -} - -// ----------------------------------------------------------------------------------- -// Serialize an aiVectorKey -template <> -inline size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v) -{ - const size_t t = Write<double>(stream,v.mTime); - return t + Write<aiVector3D>(stream,v.mValue); -} - -// ----------------------------------------------------------------------------------- -// Serialize an aiQuatKey -template <> -inline size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v) -{ - const size_t t = Write<double>(stream,v.mTime); - return t + Write<aiQuaternion>(stream,v.mValue); -} - -template <typename T> -inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size) -{ - T minc,maxc; - ArrayBounds(in,size,minc,maxc); - - const size_t t = Write<T>(stream,minc); - return t + Write<T>(stream,maxc); -} - -// We use this to write out non-byte arrays so that we write using the specializations. -// This way we avoid writing out extra bytes that potentially come from struct alignment. -template <typename T> -inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size) -{ - size_t n = 0; - for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]); - return n; -} - - // ---------------------------------------------------------------------------------- - /** @class AssbinChunkWriter - * @brief Chunk writer mechanism for the .assbin file structure - * - * This is a standard in-memory IOStream (most of the code is based on BlobIOStream), - * the difference being that this takes another IOStream as a "container" in the - * constructor, and when it is destroyed, it appends the magic number, the chunk size, - * and the chunk contents to the container stream. This allows relatively easy chunk - * chunk construction, even recursively. - */ - class AssbinChunkWriter : public IOStream - { - private: - - uint8_t* buffer; - uint32_t magic; - IOStream * container; - size_t cur_size, cursor, initial; - - private: - // ------------------------------------------------------------------- - void Grow(size_t need = 0) - { - size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) )); - - const uint8_t* const old = buffer; - buffer = new uint8_t[new_size]; - - if (old) { - memcpy(buffer,old,cur_size); - delete[] old; - } - - cur_size = new_size; - } - - public: - - AssbinChunkWriter( IOStream * container, uint32_t magic, size_t initial = 4096) - : buffer(NULL), magic(magic), container(container), cur_size(0), cursor(0), initial(initial) - { - } - - virtual ~AssbinChunkWriter() - { - if (container) { - container->Write( &magic, sizeof(uint32_t), 1 ); - container->Write( &cursor, sizeof(uint32_t), 1 ); - container->Write( buffer, 1, cursor ); - } - if (buffer) delete[] buffer; - } - - void * GetBufferPointer() { return buffer; } - - // ------------------------------------------------------------------- - virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) { return 0; } - virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) { return aiReturn_FAILURE; } - virtual size_t Tell() const { return cursor; } - virtual void Flush() { } - - virtual size_t FileSize() const - { - return cursor; - } - - // ------------------------------------------------------------------- - virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) - { - pSize *= pCount; - if (cursor + pSize > cur_size) { - Grow(cursor + pSize); - } - - memcpy(buffer+cursor, pvBuffer, pSize); - cursor += pSize; - - return pCount; - } - - }; - - // ---------------------------------------------------------------------------------- - /** @class AssbinExport - * @brief Assbin exporter class - * - * This class performs the .assbin exporting, and is responsible for the file layout. - */ - class AssbinExport - { - private: - bool shortened; - bool compressed; - - protected: - - // ----------------------------------------------------------------------------------- - void WriteBinaryNode( IOStream * container, const aiNode* node) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODE ); - - unsigned int nb_metadata = (node->mMetaData != NULL ? node->mMetaData->mNumProperties : 0); - - Write<aiString>(&chunk,node->mName); - Write<aiMatrix4x4>(&chunk,node->mTransformation); - Write<unsigned int>(&chunk,node->mNumChildren); - Write<unsigned int>(&chunk,node->mNumMeshes); - Write<unsigned int>(&chunk,nb_metadata); - - for (unsigned int i = 0; i < node->mNumMeshes;++i) { - Write<unsigned int>(&chunk,node->mMeshes[i]); - } - - for (unsigned int i = 0; i < node->mNumChildren;++i) { - WriteBinaryNode( &chunk, node->mChildren[i] ); - } - - for (unsigned int i = 0; i < nb_metadata; ++i) { - const aiString& key = node->mMetaData->mKeys[i]; - aiMetadataType type = node->mMetaData->mValues[i].mType; - void* value = node->mMetaData->mValues[i].mData; - - Write<aiString>(&chunk, key); - Write<uint16_t>(&chunk, type); - - switch (type) { - case AI_BOOL: - Write<bool>(&chunk, *((bool*) value)); - break; - case AI_INT32: - Write<int32_t>(&chunk, *((int32_t*) value)); - break; - case AI_UINT64: - Write<uint64_t>(&chunk, *((uint64_t*) value)); - break; - case AI_FLOAT: - Write<float>(&chunk, *((float*) value)); - break; - case AI_DOUBLE: - Write<double>(&chunk, *((double*) value)); - break; - case AI_AISTRING: - Write<aiString>(&chunk, *((aiString*) value)); - break; - case AI_AIVECTOR3D: - Write<aiVector3D>(&chunk, *((aiVector3D*) value)); - break; -#ifdef SWIG - case FORCE_32BIT: -#endif // SWIG - default: - break; - } - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryTexture(IOStream * container, const aiTexture* tex) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AITEXTURE ); - - Write<unsigned int>(&chunk,tex->mWidth); - Write<unsigned int>(&chunk,tex->mHeight); - chunk.Write( tex->achFormatHint, sizeof(char), 4 ); - - if(!shortened) { - if (!tex->mHeight) { - chunk.Write(tex->pcData,1,tex->mWidth); - } - else { - chunk.Write(tex->pcData,1,tex->mWidth*tex->mHeight*4); - } - } - - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryBone(IOStream * container, const aiBone* b) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIBONE ); - - Write<aiString>(&chunk,b->mName); - Write<unsigned int>(&chunk,b->mNumWeights); - Write<aiMatrix4x4>(&chunk,b->mOffsetMatrix); - - // for the moment we write dumb min/max values for the bones, too. - // maybe I'll add a better, hash-like solution later - if (shortened) { - WriteBounds(&chunk,b->mWeights,b->mNumWeights); - } // else write as usual - else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights); - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryMesh(IOStream * container, const aiMesh* mesh) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMESH ); - - Write<unsigned int>(&chunk,mesh->mPrimitiveTypes); - Write<unsigned int>(&chunk,mesh->mNumVertices); - Write<unsigned int>(&chunk,mesh->mNumFaces); - Write<unsigned int>(&chunk,mesh->mNumBones); - Write<unsigned int>(&chunk,mesh->mMaterialIndex); - - // first of all, write bits for all existent vertex components - unsigned int c = 0; - if (mesh->mVertices) { - c |= ASSBIN_MESH_HAS_POSITIONS; - } - if (mesh->mNormals) { - c |= ASSBIN_MESH_HAS_NORMALS; - } - if (mesh->mTangents && mesh->mBitangents) { - c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS; - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) { - if (!mesh->mTextureCoords[n]) { - break; - } - c |= ASSBIN_MESH_HAS_TEXCOORD(n); - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) { - if (!mesh->mColors[n]) { - break; - } - c |= ASSBIN_MESH_HAS_COLOR(n); - } - Write<unsigned int>(&chunk,c); - - aiVector3D minVec, maxVec; - if (mesh->mVertices) { - if (shortened) { - WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices); - } // else write as usual - else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices); - } - if (mesh->mNormals) { - if (shortened) { - WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices); - } // else write as usual - else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices); - } - if (mesh->mTangents && mesh->mBitangents) { - if (shortened) { - WriteBounds(&chunk,mesh->mTangents,mesh->mNumVertices); - WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices); - } // else write as usual - else { - WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices); - WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices); - } - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) { - if (!mesh->mColors[n]) - break; - - if (shortened) { - WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices); - } // else write as usual - else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices); - } - for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) { - if (!mesh->mTextureCoords[n]) - break; - - // write number of UV components - Write<unsigned int>(&chunk,mesh->mNumUVComponents[n]); - - if (shortened) { - WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices); - } // else write as usual - else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices); - } - - // write faces. There are no floating-point calculations involved - // in these, so we can write a simple hash over the face data - // to the dump file. We generate a single 32 Bit hash for 512 faces - // using Assimp's standard hashing function. - if (shortened) { - unsigned int processed = 0; - for (unsigned int job;(job = std::min(mesh->mNumFaces-processed,512u));processed += job) { - - uint32_t hash = 0; - for (unsigned int a = 0; a < job;++a) { - - const aiFace& f = mesh->mFaces[processed+a]; - uint32_t tmp = f.mNumIndices; - hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash); - for (unsigned int i = 0; i < f.mNumIndices; ++i) { - static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff"); - tmp = static_cast<uint32_t>( f.mIndices[i] ); - hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash); - } - } - Write<unsigned int>(&chunk,hash); - } - } - else // else write as usual - { - // if there are less than 2^16 vertices, we can simply use 16 bit integers ... - for (unsigned int i = 0; i < mesh->mNumFaces;++i) { - const aiFace& f = mesh->mFaces[i]; - - static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff"); - Write<uint16_t>(&chunk,f.mNumIndices); - - for (unsigned int a = 0; a < f.mNumIndices;++a) { - if (mesh->mNumVertices < (1u<<16)) { - Write<uint16_t>(&chunk,f.mIndices[a]); - } - else Write<unsigned int>(&chunk,f.mIndices[a]); - } - } - } - - // write bones - if (mesh->mNumBones) { - for (unsigned int a = 0; a < mesh->mNumBones;++a) { - const aiBone* b = mesh->mBones[a]; - WriteBinaryBone(&chunk,b); - } - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryMaterialProperty(IOStream * container, const aiMaterialProperty* prop) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIALPROPERTY ); - - Write<aiString>(&chunk,prop->mKey); - Write<unsigned int>(&chunk,prop->mSemantic); - Write<unsigned int>(&chunk,prop->mIndex); - - Write<unsigned int>(&chunk,prop->mDataLength); - Write<unsigned int>(&chunk,(unsigned int)prop->mType); - chunk.Write(prop->mData,1,prop->mDataLength); - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryMaterial(IOStream * container, const aiMaterial* mat) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIAL); - - Write<unsigned int>(&chunk,mat->mNumProperties); - for (unsigned int i = 0; i < mat->mNumProperties;++i) { - WriteBinaryMaterialProperty( &chunk, mat->mProperties[i]); - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryNodeAnim(IOStream * container, const aiNodeAnim* nd) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODEANIM ); - - Write<aiString>(&chunk,nd->mNodeName); - Write<unsigned int>(&chunk,nd->mNumPositionKeys); - Write<unsigned int>(&chunk,nd->mNumRotationKeys); - Write<unsigned int>(&chunk,nd->mNumScalingKeys); - Write<unsigned int>(&chunk,nd->mPreState); - Write<unsigned int>(&chunk,nd->mPostState); - - if (nd->mPositionKeys) { - if (shortened) { - WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys); - - } // else write as usual - else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys); - } - if (nd->mRotationKeys) { - if (shortened) { - WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys); - - } // else write as usual - else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys); - } - if (nd->mScalingKeys) { - if (shortened) { - WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys); - - } // else write as usual - else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys); - } - } - - - // ----------------------------------------------------------------------------------- - void WriteBinaryAnim( IOStream * container, const aiAnimation* anim ) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIANIMATION ); - - Write<aiString>(&chunk,anim->mName); - Write<double>(&chunk,anim->mDuration); - Write<double>(&chunk,anim->mTicksPerSecond); - Write<unsigned int>(&chunk,anim->mNumChannels); - - for (unsigned int a = 0; a < anim->mNumChannels;++a) { - const aiNodeAnim* nd = anim->mChannels[a]; - WriteBinaryNodeAnim(&chunk,nd); - } - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryLight( IOStream * container, const aiLight* l ) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AILIGHT ); - - Write<aiString>(&chunk,l->mName); - Write<unsigned int>(&chunk,l->mType); - - if (l->mType != aiLightSource_DIRECTIONAL) { - Write<float>(&chunk,l->mAttenuationConstant); - Write<float>(&chunk,l->mAttenuationLinear); - Write<float>(&chunk,l->mAttenuationQuadratic); - } - - Write<aiColor3D>(&chunk,l->mColorDiffuse); - Write<aiColor3D>(&chunk,l->mColorSpecular); - Write<aiColor3D>(&chunk,l->mColorAmbient); - - if (l->mType == aiLightSource_SPOT) { - Write<float>(&chunk,l->mAngleInnerCone); - Write<float>(&chunk,l->mAngleOuterCone); - } - - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryCamera( IOStream * container, const aiCamera* cam ) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AICAMERA ); - - Write<aiString>(&chunk,cam->mName); - Write<aiVector3D>(&chunk,cam->mPosition); - Write<aiVector3D>(&chunk,cam->mLookAt); - Write<aiVector3D>(&chunk,cam->mUp); - Write<float>(&chunk,cam->mHorizontalFOV); - Write<float>(&chunk,cam->mClipPlaneNear); - Write<float>(&chunk,cam->mClipPlaneFar); - Write<float>(&chunk,cam->mAspect); - } - - // ----------------------------------------------------------------------------------- - void WriteBinaryScene( IOStream * container, const aiScene* scene) - { - AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AISCENE ); - - // basic scene information - Write<unsigned int>(&chunk,scene->mFlags); - Write<unsigned int>(&chunk,scene->mNumMeshes); - Write<unsigned int>(&chunk,scene->mNumMaterials); - Write<unsigned int>(&chunk,scene->mNumAnimations); - Write<unsigned int>(&chunk,scene->mNumTextures); - Write<unsigned int>(&chunk,scene->mNumLights); - Write<unsigned int>(&chunk,scene->mNumCameras); - - // write node graph - WriteBinaryNode( &chunk, scene->mRootNode ); - - // write all meshes - for (unsigned int i = 0; i < scene->mNumMeshes;++i) { - const aiMesh* mesh = scene->mMeshes[i]; - WriteBinaryMesh( &chunk,mesh); - } - - // write materials - for (unsigned int i = 0; i< scene->mNumMaterials; ++i) { - const aiMaterial* mat = scene->mMaterials[i]; - WriteBinaryMaterial(&chunk,mat); - } - - // write all animations - for (unsigned int i = 0; i < scene->mNumAnimations;++i) { - const aiAnimation* anim = scene->mAnimations[i]; - WriteBinaryAnim(&chunk,anim); - } - - - // write all textures - for (unsigned int i = 0; i < scene->mNumTextures;++i) { - const aiTexture* mesh = scene->mTextures[i]; - WriteBinaryTexture(&chunk,mesh); - } - - // write lights - for (unsigned int i = 0; i < scene->mNumLights;++i) { - const aiLight* l = scene->mLights[i]; - WriteBinaryLight(&chunk,l); - } - - // write cameras - for (unsigned int i = 0; i < scene->mNumCameras;++i) { - const aiCamera* cam = scene->mCameras[i]; - WriteBinaryCamera(&chunk,cam); - } - - } - - public: - AssbinExport() - : shortened(false), compressed(false) // temporary settings until properties are introduced for exporters - { - } - - // ----------------------------------------------------------------------------------- - // Write a binary model dump - void WriteBinaryDump(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene) - { - IOStream * out = pIOSystem->Open( pFile, "wb" ); - if (!out) return; - - time_t tt = time(NULL); - tm* p = gmtime(&tt); - - // header - char s[64]; - memset( s, 0, 64 ); -#if _MSC_VER >= 1400 - sprintf_s(s,"ASSIMP.binary-dump.%s",asctime(p)); -#else - ai_snprintf(s,64,"ASSIMP.binary-dump.%s",asctime(p)); -#endif - out->Write( s, 44, 1 ); - // == 44 bytes - - Write<unsigned int>( out, ASSBIN_VERSION_MAJOR ); - Write<unsigned int>( out, ASSBIN_VERSION_MINOR ); - Write<unsigned int>( out, aiGetVersionRevision() ); - Write<unsigned int>( out, aiGetCompileFlags() ); - Write<uint16_t>( out, shortened ); - Write<uint16_t>( out, compressed ); - // == 20 bytes - - char buff[256]; - strncpy(buff,pFile,256); - out->Write(buff,sizeof(char),256); - - char cmd[] = "\0"; - strncpy(buff,cmd,128); - out->Write(buff,sizeof(char),128); - - // leave 64 bytes free for future extensions - memset(buff,0xcd,64); - out->Write(buff,sizeof(char),64); - // == 435 bytes - - // ==== total header size: 512 bytes - ai_assert( out->Tell() == ASSBIN_HEADER_LENGTH ); - - // Up to here the data is uncompressed. For compressed files, the rest - // is compressed using standard DEFLATE from zlib. - if (compressed) - { - AssbinChunkWriter uncompressedStream( NULL, 0 ); - WriteBinaryScene( &uncompressedStream, pScene ); - - uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell()); - uLongf compressedSize = (uLongf)(uncompressedStream.Tell() * 1.001 + 12.); - uint8_t* compressedBuffer = new uint8_t[ compressedSize ]; - - compress2( compressedBuffer, &compressedSize, (const Bytef*)uncompressedStream.GetBufferPointer(), uncompressedSize, 9 ); - - out->Write( &uncompressedSize, sizeof(uint32_t), 1 ); - out->Write( compressedBuffer, sizeof(char), compressedSize ); - - delete[] compressedBuffer; - } - else - { - WriteBinaryScene( out, pScene ); - } - - pIOSystem->Close( out ); - } - }; - -void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) -{ - AssbinExport exporter; - exporter.WriteBinaryDump( pFile, pIOSystem, pScene ); -} -} // end of namespace Assimp - -#endif // ASSIMP_BUILD_NO_ASSBIN_EXPORTER -#endif // ASSIMP_BUILD_NO_EXPORT |