void StatefulMeshSerializer::determineFileFormat(DataStreamPtr stream) { determineEndianness(stream); // Read header and determine the version unsigned short headerID; // Read header ID readShorts(stream, &headerID, 1); if (headerID != HEADER_CHUNK_ID) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "File header not found", "MeshSerializer::importMesh"); } // Read version mMeshFileVersion = readString(stream); // Jump back to start stream->seek(0); #if OGRE_ENDIAN == OGRE_ENDIAN_BIG mMeshFileEndian = mFlipEndian ? ENDIAN_LITTLE : ENDIAN_BIG; #else mMeshFileEndian = mFlipEndian ? ENDIAN_BIG : ENDIAN_LITTLE; #endif }
//--------------------------------------------------------------------- void SkeletonSerializer::importSkeleton(DataStreamPtr& stream, Skeleton* pSkel) { // Determine endianness (must be the first thing we do!) determineEndianness(stream); // Check header readFileHeader(stream); unsigned short streamID; while(!stream->eof()) { streamID = readChunk(stream); switch (streamID) { case SKELETON_BONE: readBone(stream, pSkel); break; case SKELETON_BONE_PARENT: readBoneParent(stream, pSkel); break; case SKELETON_ANIMATION: readAnimation(stream, pSkel); break; case SKELETON_ANIMATION_LINK: readSkeletonAnimationLink(stream, pSkel); break; } } // Assume bones are stored in the binding pose pSkel->setBindingPose(); }
void LodConfigSerializer::importLodConfig(Ogre::LodConfig* config, DataStreamPtr& stream) { mStream = stream; mLodConfig = config; // Determine endianness (must be the first thing we do!) determineEndianness(mStream); // Check header readFileHeader(mStream); pushInnerChunk(mStream); while (!mStream->eof()) { unsigned short streamID = readChunk(mStream); switch (streamID) { case LCCID_LOD_CONFIG: readLodConfig(); break; default: backpedalChunkHeader(mStream); popInnerChunk(mStream); return; } } popInnerChunk(mStream); }
void LodConfigSerializer::exportLodConfig(Ogre::LodConfig& config, Ogre::DataStreamPtr stream, Endian endianMode /*= ENDIAN_NATIVE*/ ) { Ogre::LogManager::getSingleton().logMessage("MeshSerializer writing mesh data to stream " + stream->getName() + "..."); // Decide on endian mode determineEndianness(endianMode); mLodConfig = &config; mStream = stream; if (!stream->isWriteable()) { OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Unable to use stream " + stream->getName() + " for writing", "LodConfigSerializer::export"); } writeFileHeader(); LogManager::getSingleton().logMessage("File header written."); LogManager::getSingleton().logMessage("Writing Lod Config..."); pushInnerChunk(mStream); writeLodConfig(); popInnerChunk(mStream); LogManager::getSingleton().logMessage("LodConfigSerializer export successful."); }
void StatefulSkeletonSerializer::determineFileFormat(DataStreamPtr stream) { determineEndianness(stream); #if OGRE_ENDIAN == OGRE_ENDIAN_BIG mSkeletonFileEndian = mFlipEndian ? ENDIAN_LITTLE : ENDIAN_BIG; #else mSkeletonFileEndian = mFlipEndian ? ENDIAN_BIG : ENDIAN_LITTLE; #endif }
//--------------------------------------------------------------------- void SkeletonSerializer::exportSkeleton(const Skeleton* pSkeleton, const String& filename, Endian endianMode) { // Decide on endian mode determineEndianness(endianMode); String msg; mpfFile = fopen(filename.c_str(), "wb"); if (!mpfFile) { OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE, "Unable to open file " + filename + " for writing", "SkeletonSerializer::exportSkeleton"); } writeFileHeader(); // Write main skeleton data LogManager::getSingleton().logMessage("Exporting bones.."); writeSkeleton(pSkeleton); LogManager::getSingleton().logMessage("Bones exported."); // Write all animations unsigned short numAnims = pSkeleton->getNumAnimations(); LogManager::getSingleton().stream() << "Exporting animations, count=" << numAnims; for (unsigned short i = 0; i < numAnims; ++i) { Animation* pAnim = pSkeleton->getAnimation(i); LogManager::getSingleton().stream() << "Exporting animation: " << pAnim->getName(); writeAnimation(pSkeleton, pAnim); LogManager::getSingleton().logMessage("Animation exported."); } // Write links Skeleton::LinkedSkeletonAnimSourceIterator linkIt = pSkeleton->getLinkedSkeletonAnimationSourceIterator(); while(linkIt.hasMoreElements()) { const LinkedSkeletonAnimationSource& link = linkIt.getNext(); writeSkeletonAnimationLink(pSkeleton, link); } fclose(mpfFile); }
//--------------------------------------------------------------------- void MeshSerializer::importMesh(DataStreamPtr& stream, Mesh* pDest) { determineEndianness(stream); // Read header and determine the version unsigned short headerID; // Read header ID readShorts(stream, &headerID, 1); if (headerID != HEADER_CHUNK_ID) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "File header not found", "MeshSerializer::importMesh"); } // Read version String ver = readString(stream); // Jump back to start stream->seek(0); // Find the implementation to use MeshSerializerImpl* impl = 0; for (MeshVersionDataList::iterator i = mVersionData.begin(); i != mVersionData.end(); ++i) { if ((*i)->versionString == ver) { impl = (*i)->impl; break; } } if (!impl) OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Cannot find serializer implementation for " "mesh version " + ver, "MeshSerializer::importMesh"); // Call implementation impl->importMesh(stream, pDest, mListener); // Warn on old version of mesh if (ver != mVersionData[0]->versionString) { LogManager::getSingleton().logMessage("WARNING: " + pDest->getName() + " is an older format (" + ver + "); you should upgrade it as soon as possible" + " using the OgreMeshTool tool.", LML_CRITICAL); } if(mListener) mListener->processMeshCompleted(pDest); }
//--------------------------------------------------------------------- void SkeletonSerializer::exportSkeleton(const Skeleton* pSkeleton, DataStreamPtr stream, SkeletonVersion ver, Endian endianMode) { setWorkingVersion(ver); // Decide on endian mode determineEndianness(endianMode); String msg; mStream = stream; if (!stream->isWriteable()) { OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE, "Unable to write to stream " + stream->getName(), "SkeletonSerializer::exportSkeleton"); } writeFileHeader(); // Write main skeleton data LogManager::getSingleton().logMessage("Exporting bones.."); writeSkeleton(pSkeleton, ver); LogManager::getSingleton().logMessage("Bones exported."); // Write all animations unsigned short numAnims = pSkeleton->getNumAnimations(); LogManager::getSingleton().stream() << "Exporting animations, count=" << numAnims; for (unsigned short i = 0; i < numAnims; ++i) { Animation* pAnim = pSkeleton->getAnimation(i); LogManager::getSingleton().stream() << "Exporting animation: " << pAnim->getName(); writeAnimation(pSkeleton, pAnim, ver); LogManager::getSingleton().logMessage("Animation exported."); } // Write links Skeleton::LinkedSkeletonAnimSourceIterator linkIt = pSkeleton->getLinkedSkeletonAnimationSourceIterator(); while(linkIt.hasMoreElements()) { const LinkedSkeletonAnimationSource& link = linkIt.getNext(); writeSkeletonAnimationLink(pSkeleton, link); } }
//--------------------------------------------------------------------- void StreamSerialiser::writeHeader() { if (mEndian == ENDIAN_AUTO) determineEndianness(); // Header chunk has zero data size writeChunkImpl(HEADER_ID, 1); // real format bool realIsDouble = (mRealFormat == REAL_DOUBLE); write(&realIsDouble); writeChunkEnd(HEADER_ID); mReadWriteHeader = false; }
//--------------------------------------------------------------------- void SkeletonSerializer::importSkeleton(DataStreamPtr& stream, Skeleton* pSkel) { // Determine endianness (must be the first thing we do!) determineEndianness(stream); // Check header readFileHeader(stream); pushInnerChunk(stream); unsigned short streamID = readChunk(stream); while(!stream->eof()) { switch (streamID) { case SKELETON_BLENDMODE: { // Optional blend mode uint16 blendMode; readShorts(stream, &blendMode, 1); pSkel->setBlendMode(static_cast<SkeletonAnimationBlendMode>(blendMode)); break; } case SKELETON_BONE: readBone(stream, pSkel); break; case SKELETON_BONE_PARENT: readBoneParent(stream, pSkel); break; case SKELETON_ANIMATION: readAnimation(stream, pSkel); break; case SKELETON_ANIMATION_LINK: readSkeletonAnimationLink(stream, pSkel); break; default: break; } streamID = readChunk(stream); } // Assume bones are stored in the binding pose pSkel->setBindingPose(); popInnerChunk(stream); }
//--------------------------------------------------------------------- void ParseOgre::importMesh(DataStreamPtr& stream, OgreMesh* pDest) { determineEndianness(stream); // Read header and determine the version unsigned short headerID;// = *(U16*)p; // Read header ID //stream.g readShorts(stream, &headerID, 1); //Read(&headerID,sizeof(headerID),1,pData,uiPos); if (headerID != HEADER_CHUNK_ID) { // OGRE_EXCEPT(0, "File header not found", // "ParseOgre::importMesh"); } // Read version AString ver = readString(stream); // AChar version[MAX_NAME]; // ReadStr(pData,version,uiPos); // ver = version; // Jump back to start stream->seek(0); // Find the implementation to use ParseOgreImplMap::iterator impl = mImplementations.find(ver); if (impl == mImplementations.end()) { // OGRE_EXCEPT(0, "Cannot find serializer implementation for " // "current version " + ver, "ParseOgre::importMesh"); } // Call implementation impl->second->importMesh(stream, pDest, mListener); // Warn on old version of mesh if (ver != msCurrentVersion) { // LogManager("WARNING: " + pDest->getName() + // " is an older format (" + ver + "); you should upgrade it as soon as possible" + // " using the OgreMeshUpgrade tool."); } }
//--------------------------------------------------------------------- void MeshSerializer::importMesh(DataStreamPtr& stream, Mesh* pDest) { determineEndianness(stream); // Read header and determine the version unsigned short headerID; // Read header ID readShorts(stream, &headerID, 1); if (headerID != HEADER_CHUNK_ID) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "File header not found", "MeshSerializer::importMesh"); } // Read version String ver = readString(stream); // Jump back to start stream->seek(0); // Find the implementation to use MeshSerializerImplMap::iterator impl = mImplementations.find(ver); if (impl == mImplementations.end()) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Cannot find serializer implementation for " "current version " + ver, "MeshSerializer::importMesh"); } // Call implementation impl->second->importMesh(stream, pDest, mListener); // Warn on old version of mesh if (ver != msCurrentVersion) { LogManager::getSingleton().logMessage("WARNING: " + pDest->getName() + " is an older format (" + ver + "); you should upgrade it as soon as possible" + " using the OgreMeshUpgrade tool."); } }
//--------------------------------------------------------------------- void StreamSerialiser::readHeader() { uint32 headerid; size_t actually_read = mStream->read(&headerid, sizeof(uint32)); // skip back mStream->skip(0 - (long)actually_read); // validate that this is a header chunk if (headerid == REVERSE_HEADER_ID) { mFlipEndian = true; } else if (headerid == HEADER_ID) { mFlipEndian = false; } else { // no good OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Cannot determine endian mode because header is missing", "StreamSerialiser::readHeader"); } determineEndianness(); mReadWriteHeader = false; const Chunk* c = readChunkBegin(); // endian should be flipped now assert(c->id == HEADER_ID); (void)c; // Silence warning // read real storage format bool realIsDouble; read(&realIsDouble); mRealFormat = realIsDouble? REAL_DOUBLE : REAL_FLOAT; readChunkEnd(HEADER_ID); }
void OgreMeshDeserializer::deserialize() { // Determine endianness (must be the first thing we do!) determineEndianness(m_stream); // Check header readFileHeader(m_stream); unsigned short streamID = readChunk(m_stream); while (!m_stream.eof()) { switch (streamID) { case M_MESH: readMesh(); break; default: skipChunk(m_stream); } streamID = readChunk(m_stream); } }