nel/tools/3d/pipeline_max/scene_class.cpp

   1 /**
   2  * \file scene_class.cpp
   3  * \brief CSceneClass
   4  * \date 2012-08-20 09:07GMT
   5  * \author Jan Boon (Kaetemi)
   6  * CSceneClass
   7  */
   8
   9 /*
  10  * Copyright (C) 2012  by authors
  11  *
  12  * This file is part of RYZOM CORE PIPELINE.
  13  * RYZOM CORE PIPELINE is free software: you can redistribute it
  14  * and/or modify it under the terms of the GNU Affero General Public
  15  * License as published by the Free Software Foundation, either
  16  * version 3 of the License, or (at your option) any later version.
  17  *
  18  * RYZOM CORE PIPELINE is distributed in the hope that it will be
  19  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  20  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Affero General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Affero General Public
  24  * License along with RYZOM CORE PIPELINE.  If not, see
  25  * <http://www.gnu.org/licenses/>.
  26  */
  27
  28 #include <nel/misc/types_nl.h>
  29 #include "scene_class.h"
  30
  31 // STL includes
  32 #include <iomanip>
  33
  34 // NeL includes
  35 // #include <nel/misc/debug.h>
  36
  37 // Project includes
  38
  39 using namespace std;
  40 // using namespace NLMISC;
  41
  42 namespace PIPELINE {
  43 namespace MAX {
  44
  45 ////////////////////////////////////////////////////////////////////////
  46 ////////////////////////////////////////////////////////////////////////
  47 ////////////////////////////////////////////////////////////////////////
  48
  49 // Elevate warnings to errors in this file for stricter reading
  50 #undef nlwarning
  51 #define nlwarning nlerror
  52
  53 // Elevate debug to error in this file for debugging
  54 // #undef nldebug
  55 // #define nldebug nlerror
  56
  57 // Chunk identifiers
  58 // #define ...
  59
  60 ////////////////////////////////////////////////////////////////////////
  61 ////////////////////////////////////////////////////////////////////////
  62 ////////////////////////////////////////////////////////////////////////
  63
  64 CSceneClass::CSceneClass(CScene *scene) : m_Scene(scene)
  65 {
  66
  67 }
  68
  69 CSceneClass::~CSceneClass()
  70 {
  71         if (!m_ChunksOwnsPointers)
  72         {
  73                 for (TStorageObjectContainer::iterator it = m_OrphanedChunks.begin(), end = m_OrphanedChunks.end(); it != end; ++it)
  74                         delete it->second;
  75                 m_OrphanedChunks.clear();
  76                 for (std::vector<IStorageObject *>::iterator it = m_ArchivedChunks.begin(), end = m_ArchivedChunks.end(); it != end; ++it)
  77                         delete (*it);
  78                 m_ArchivedChunks.clear();
  79         }
  80 }
  81
  82 std::string CSceneClass::className() const
  83 {
  84         return classDesc()->internalName();
  85 }
  86
  87 void CSceneClass::toString(std::ostream &ostream, const std::string &pad) const
  88 {
  89         if (m_ChunksOwnsPointers)
  90         {
  91                 CStorageContainer::toString(ostream, pad);
  92         }
  93         else
  94         {
  95                 ostream << "<ptr=0x";
  96                 {
  97                         std::stringstream ss;
  98                         ss << std::hex << std::setfill('0');
  99                         ss << std::setw(16) << (uint64)(void *)this;
 100                         ostream << ss.str();
 101                 }
 102                 ostream << "> ";
 103                 ostream << "(" << className() << ": " << ucstring(classDesc()->displayName()).toUtf8() << ", " << classDesc()->classId().toString() << ", 0x";
 104                 {
 105                         std::stringstream ss;
 106                         ss << std::hex << std::setfill('0');
 107                         ss << std::setw(8) << classDesc()->superClassId();
 108                         ostream << ss.str();
 109                 }
 110                 ostream << ", " << ucstring(classDesc()->dllPluginDesc()->internalName()).toUtf8() << ") [" << m_OrphanedChunks.size() << "] { ";
 111                 toStringLocal(ostream, pad);
 112                 // Append orphans
 113                 std::string padpad = pad + "\t";
 114                 sint i = 0;
 115                 for (TStorageObjectContainer::const_iterator it = m_OrphanedChunks.begin(), end = m_OrphanedChunks.end(); it != end; ++it)
 116                 {
 117                         std::stringstream ss;
 118                         ss << std::hex << std::setfill('0');
 119                         ss << std::setw(4) << it->first;
 120                         ostream << "\n" << pad << "Orphan[" << i << "] 0x" << ss.str() << ": ";
 121                         it->second->toString(ostream, padpad);
 122                         ++i;
 123                 }
 124                 ostream << "} ";
 125         }
 126 }
 127
 128 void CSceneClass::parse(uint16 version, uint filter)
 129 {
 130         // Cannot be parsed yet
 131         if (!m_ChunksOwnsPointers) { nlerror("Already parsed"); return; } // Already parsed, illegal to call twice
 132
 133         // Parse all child chunks
 134         CStorageContainer::parse(version);
 135
 136         // Orphanize all child chunk
 137         m_OrphanedChunks.insert(m_OrphanedChunks.end(), m_Chunks.begin(), m_Chunks.end());
 138
 139         // Take ownership
 140         m_ChunksOwnsPointers = false;
 141
 142         // Inheriting classes take control from here on, they should check
 143         // m_ChunksOwnsPointers to be false before taking action, in case
 144         // a subclass called disown due to failure.
 145 }
 146
 147 void CSceneClass::clean()
 148 {
 149         if (m_ChunksOwnsPointers) { nldebug("Not parsed, or disowned"); return; } // Must have local ownership, parsing may have failed
 150         if (m_Chunks.size() == 0 && m_OrphanedChunks.size() != 0) { nlwarning("Already cleaned"); return; } // Already cleaned, should not call twice, not reliable because not all chunks have child chunks
 151
 152         // Clear unneeded references from the parent
 153         m_Chunks.clear();
 154
 155         // Clean owned child chunks
 156         for (TStorageObjectContainer::const_iterator it = m_OrphanedChunks.begin(), end = m_OrphanedChunks.end(); it != end; ++it)
 157         {
 158                 if (it->second->isContainer())
 159                 {
 160                         static_cast<CStorageContainer *>(it->second)->clean();
 161                 }
 162         }
 163
 164         // Erase archived chunks, they must have been parsed perfectly
 165         for (std::vector<IStorageObject *>::iterator it = m_ArchivedChunks.begin(), end = m_ArchivedChunks.end(); it != end; ++it)
 166                 delete (*it);
 167         m_ArchivedChunks.clear();
 168 }
 169
 170 void CSceneClass::build(uint16 version, uint filter)
 171 {
 172         // Must be clean first
 173         if (!m_ChunksOwnsPointers && m_Chunks.size() != 0) { nlerror("Not cleaned"); return; } // Cannot call twice, illegal call
 174         if (m_Chunks.size() != 0) { nldebug("Not parsed, or disowned"); return; } // Don't have local ownership, parsing may have failed, the built version is implicitly up to date
 175
 176         // Store orphan chunks
 177         m_Chunks.insert(m_Chunks.end(), m_OrphanedChunks.begin(), m_OrphanedChunks.end());
 178
 179         // Build the orphan chunks (this is a little trick to do it this
 180         // way here, don't do this from subclasses)
 181         CStorageContainer::build(version);
 182
 183         // Set the insertion pointer before the orphans
 184         m_PutChunkInsert = m_Chunks.begin();
 185
 186         // Inheriting classes take control from here on, so the build is
 187         // called to owned subclasses from the putChunk function.
 188 }
 189
 190 void CSceneClass::disown()
 191 {
 192         if (m_ChunksOwnsPointers) { nldebug("Not parsed"); }
 193         if (!m_ChunksOwnsPointers && (m_Chunks.size() < m_OrphanedChunks.size())) { nlerror("Not built"); return; } // If chunks is not the owner, built chunks must match the parsed data. This check is not fully reliable
 194
 195         // Clear local references
 196         m_OrphanedChunks.clear();
 197         m_ArchivedChunks.clear();
 198
 199         // Return ownership
 200         m_ChunksOwnsPointers = true;
 201
 202         // Disown children
 203         CStorageContainer::disown();
 204 }
 205
 206 void CSceneClass::init()
 207 {
 208         // Nothing to do here!
 209 }
 210
 211 IStorageObject *CSceneClass::createChunkById(uint16 id, bool container)
 212 {
 213         return CStorageContainer::createChunkById(id, container);
 214 }
 215
 216 const ucstring CSceneClass::DisplayName = ucstring("Invalid Scene Class");
 217 const char *CSceneClass::InternalName = "SceneClass";
 218 const NLMISC::CClassId CSceneClass::ClassId = NLMISC::CClassId::Null; // This class is invalid
 219 const TSClassId CSceneClass::SuperClassId = 0x0000; // This class is invalid
 220
 221 namespace {
 222 static const CSceneClassDesc<CSceneClass> SceneClassDesc(static_cast<const IDllPluginDescInternal *>(&DllPluginDescBuiltin));
 223 } /* anonymous namespace */
 224
 225 bool CSceneClass::inherits(const NLMISC::CClassId classId) const
 226 {
 227         return false;
 228 }
 229
 230 const ISceneClassDesc *CSceneClass::classDesc() const
 231 {
 232         return static_cast<const ISceneClassDesc *>(&SceneClassDesc);
 233 }
 234
 235 void CSceneClass::toStringLocal(std::ostream &ostream, const std::string &pad, uint filter) const
 236 {
 237         // Nothing to do here...
 238 }
 239
 240 IStorageObject *CSceneClass::getChunk(uint16 id)
 241 {
 242         if (m_OrphanedChunks.begin()->first == id)
 243         {
 244                 IStorageObject *result = m_OrphanedChunks.begin()->second;
 245                 m_OrphanedChunks.pop_front();
 246                 return result;
 247         }
 248         else
 249         {
 250                 for (TStorageObjectContainer::iterator it = m_OrphanedChunks.begin(), end = m_OrphanedChunks.end(); it != end; ++it)
 251                 {
 252                         if (it->first == id)
 253                         {
 254                                 nlwarning("Try to get chunk with 0x%x id, but found 0x%x instead. Found the correct chunk at a different position. Unknown chunks, or chunks out of order", (uint32)id, (uint32)m_OrphanedChunks.begin()->first);
 255                                 IStorageObject *result = it->second;
 256                                 m_OrphanedChunks.erase(it);
 257                                 return result;
 258                         }
 259                 }
 260         }
 261         // nldebug("Chunk 0x%x not found, this is allowed, returning NULL", (uint32)id);
 262         return NULL;
 263 }
 264
 265 void CSceneClass::putChunk(uint16 id, IStorageObject *storageObject)
 266 {
 267         if (storageObject->isContainer())
 268         {
 269                 static_cast<CStorageContainer *>(storageObject)->build(VersionUnknown); // FIXME
 270         }
 271         m_OrphanedChunks.insert(m_PutChunkInsert, TStorageObjectWithId(id, storageObject));
 272 }
 273
 274 uint16 CSceneClass::peekChunk()
 275 {
 276         if (m_OrphanedChunks.size())
 277                 return m_OrphanedChunks.begin()->first;
 278         return 0x0000;
 279 }
 280
 281 ////////////////////////////////////////////////////////////////////////
 282 ////////////////////////////////////////////////////////////////////////
 283 ////////////////////////////////////////////////////////////////////////
 284
 285 } /* namespace MAX */
 286 } /* namespace PIPELINE */
 287
 288 /* end of file */