d41b9344036eee4296cd3d1d8828dbcad32afc3a
[xonotic/netradiant.git] / radiant / referencecache.cpp
1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #include "referencecache.h"
23
24 #include "debugging/debugging.h"
25
26 #include "iscenegraph.h"
27 #include "iselection.h"
28 #include "iundo.h"
29 #include "imap.h"
30 MapModules& ReferenceAPI_getMapModules();
31 #include "imodel.h"
32 ModelModules& ReferenceAPI_getModelModules();
33 #include "ifilesystem.h"
34 #include "iarchive.h"
35 #include "ifiletypes.h"
36 #include "ireference.h"
37 #include "ientity.h"
38 #include "qerplugin.h"
39
40 #include <list>
41
42 #include "container/cache.h"
43 #include "container/hashfunc.h"
44 #include "os/path.h"
45 #include "stream/textfilestream.h"
46 #include "nullmodel.h"
47 #include "maplib.h"
48 #include "stream/stringstream.h"
49 #include "os/file.h"
50 #include "moduleobserver.h"
51 #include "moduleobservers.h"
52
53 #include "mainframe.h"
54 #include "map.h"
55 #include "filetypes.h"
56
57
58 bool References_Saved();
59
60 void MapChanged()
61 {
62   Map_SetModified(g_map, !References_Saved());
63 }
64
65
66 EntityCreator* g_entityCreator = 0;
67
68 bool MapResource_loadFile(const MapFormat& format, scene::Node& root, const char* filename)
69 {
70   globalOutputStream() << "Open file " << filename << " for read...";
71   TextFileInputStream file(filename);
72   if(!file.failed())
73   {
74     globalOutputStream() << "success\n";
75     ScopeDisableScreenUpdates disableScreenUpdates(path_get_filename_start(filename), "Loading Map");
76     ASSERT_NOTNULL(g_entityCreator);
77     format.readGraph(root, file, *g_entityCreator);
78     return true;
79   }
80   else
81   {
82     globalErrorStream() << "failure\n";
83     return false;
84   }
85 }
86
87 NodeSmartReference MapResource_load(const MapFormat& format, const char* path, const char* name)
88 {
89   NodeSmartReference root(NewMapRoot(name));
90
91   StringOutputStream fullpath(256);
92   fullpath << path << name;
93
94   if(path_is_absolute(fullpath.c_str()))
95   {
96     MapResource_loadFile(format, root, fullpath.c_str());
97   }
98   else
99   {
100     globalErrorStream() << "map path is not fully qualified: " << makeQuoted(fullpath.c_str()) << "\n";
101   }
102
103   return root;
104 }
105
106 bool MapResource_saveFile(const MapFormat& format, scene::Node& root, GraphTraversalFunc traverse, const char* filename)
107 {
108   //ASSERT_MESSAGE(path_is_absolute(filename), "MapResource_saveFile: path is not absolute: " << makeQuoted(filename));
109   globalOutputStream() << "Open file " << filename << " for write...";
110   TextFileOutputStream file(filename);
111   if(!file.failed())
112   {
113     globalOutputStream() << "success\n";
114     ScopeDisableScreenUpdates disableScreenUpdates(path_get_filename_start(filename), "Saving Map");
115     format.writeGraph(root, traverse, file);
116     return true;
117   }
118
119   globalErrorStream() << "failure\n";
120   return false;
121 }
122
123 bool file_saveBackup(const char* path)
124 {
125   if(file_writeable(path))
126   {
127           StringOutputStream backup(256);
128     backup << StringRange(path, path_get_extension(path)) << "bak";
129
130     return (!file_exists(backup.c_str()) || file_remove(backup.c_str())) // remove backup
131       && file_move(path, backup.c_str()); // rename current to backup
132   }
133
134   globalErrorStream() << "map path is not writeable: " << makeQuoted(path) << "\n";
135   return false;
136 }
137
138 bool MapResource_save(const MapFormat& format, scene::Node& root, const char* path, const char* name)
139 {
140   StringOutputStream fullpath(256);
141   fullpath << path << name;
142
143   if(path_is_absolute(fullpath.c_str()))
144   {
145     if(!file_exists(fullpath.c_str()) || file_saveBackup(fullpath.c_str()))
146     {
147       return MapResource_saveFile(format, root, Map_Traverse, fullpath.c_str());
148     }
149
150     globalErrorStream() << "failed to save a backup map file: " << makeQuoted(fullpath.c_str()) << "\n";
151     return false;
152   }
153
154   globalErrorStream() << "map path is not fully qualified: " << makeQuoted(fullpath.c_str()) << "\n";
155   return false;
156 }
157
158 namespace
159 {
160   NodeSmartReference g_nullNode(NewNullNode());
161   NodeSmartReference g_nullModel(g_nullNode);
162 }
163
164 class NullModelLoader : public ModelLoader
165 {
166 public:
167   scene::Node& loadModel(ArchiveFile& file)
168   {
169     return g_nullModel;
170   }
171 };
172
173 namespace
174 {
175   NullModelLoader g_NullModelLoader;
176 }
177
178
179 /// \brief Returns the model loader for the model \p type or 0 if the model \p type has no loader module
180 ModelLoader* ModelLoader_forType(const char* type)
181 {
182   const char* moduleName = findModuleName(&GlobalFiletypes(), ModelLoader::Name(), type);
183   if(string_not_empty(moduleName))
184   {
185     ModelLoader* table = ReferenceAPI_getModelModules().findModule(moduleName);
186     if(table != 0)
187     {
188       return table;
189     }
190     else
191     {
192       globalErrorStream() << "ERROR: Model type incorrectly registered: \"" << moduleName << "\"\n";
193       return &g_NullModelLoader;
194     }
195   }
196   return 0;
197 }
198
199 NodeSmartReference ModelResource_load(ModelLoader* loader, const char* name)
200 {
201   ScopeDisableScreenUpdates disableScreenUpdates(path_get_filename_start(name), "Loading Model");
202
203   NodeSmartReference model(g_nullModel);
204
205   {
206     ArchiveFile* file = GlobalFileSystem().openFile(name);
207
208     if(file != 0)
209     {
210       globalOutputStream() << "Loaded Model: \"" << name << "\"\n";
211       model = loader->loadModel(*file);
212       file->release();
213     }
214     else
215     {
216       globalErrorStream() << "Model load failed: \"" << name << "\"\n";
217     }
218   }
219
220   model.get().m_isRoot = true;
221
222   return model;
223 }
224
225
226 inline hash_t path_hash(const char* path, hash_t previous = 0)
227 {
228 #if defined(WIN32)
229   return string_hash_nocase(path, previous);
230 #else // UNIX
231   return string_hash(path, previous);
232 #endif
233 }
234
235 struct PathEqual
236 {
237   bool operator()(const CopiedString& path, const CopiedString& other) const
238   {
239     return path_equal(path.c_str(), other.c_str());
240   }
241 };
242
243 struct PathHash
244 {
245   typedef hash_t hash_type;
246   hash_type operator()(const CopiedString& path) const
247   {
248     return path_hash(path.c_str());
249   }
250 };
251
252 typedef std::pair<CopiedString, CopiedString> ModelKey;
253
254 struct ModelKeyEqual
255 {
256   bool operator()(const ModelKey& key, const ModelKey& other) const
257   {
258     return path_equal(key.first.c_str(), other.first.c_str()) && path_equal(key.second.c_str(), other.second.c_str());
259   }
260 };
261
262 struct ModelKeyHash
263 {
264   typedef hash_t hash_type;
265   hash_type operator()(const ModelKey& key) const
266   {
267     return hash_combine(path_hash(key.first.c_str()), path_hash(key.second.c_str()));
268   }
269 };
270
271 typedef HashTable<ModelKey, NodeSmartReference, ModelKeyHash, ModelKeyEqual> ModelCache;
272 ModelCache g_modelCache;
273 bool g_modelCache_enabled = true;
274
275 ModelCache::iterator ModelCache_find(const char* path, const char* name)
276 {
277   if(g_modelCache_enabled)
278   {
279     return g_modelCache.find(ModelKey(path, name));
280   }
281   return g_modelCache.end();
282 }
283
284 ModelCache::iterator ModelCache_insert(const char* path, const char* name, scene::Node& node)
285 {
286   if(g_modelCache_enabled)
287   {
288     return g_modelCache.insert(ModelKey(path, name), NodeSmartReference(node));
289   }
290   return g_modelCache.insert(ModelKey("", ""), g_nullModel);
291 }
292
293 void ModelCache_flush(const char* path, const char* name)
294 {
295   ModelCache::iterator i = g_modelCache.find(ModelKey(path, name));
296   if(i != g_modelCache.end())
297   {
298     //ASSERT_MESSAGE((*i).value.getCount() == 0, "resource flushed while still in use: " << (*i).key.first.c_str() << (*i).key.second.c_str());
299     g_modelCache.erase(i);
300   }
301 }
302
303 void ModelCache_clear()
304 {
305   g_modelCache_enabled = false;
306   g_modelCache.clear();
307   g_modelCache_enabled = true;
308 }
309
310 NodeSmartReference Model_load(ModelLoader* loader, const char* path, const char* name, const char* type)
311 {
312   if(loader != 0)
313   {
314     return ModelResource_load(loader, name);
315   }
316   else
317   {
318     const char* moduleName = findModuleName(&GlobalFiletypes(), MapFormat::Name(), type);
319     if(string_not_empty(moduleName))
320     {
321       const MapFormat* format = ReferenceAPI_getMapModules().findModule(moduleName);
322       if(format != 0)
323       {
324         return MapResource_load(*format, path, name);
325       }
326       else
327       {
328         globalErrorStream() << "ERROR: Map type incorrectly registered: \"" << moduleName << "\"\n";
329         return g_nullModel;
330       }
331     }
332     else
333     {
334       if(string_not_empty(type))
335       {
336         globalErrorStream() << "Model type not supported: \"" << name << "\"\n";
337       }
338       return g_nullModel;
339     }
340   }
341 }
342
343 namespace
344 {
345   bool g_realised = false;
346
347   // name may be absolute or relative
348   const char* rootPath(const char* name)
349   {
350     return GlobalFileSystem().findRoot(
351       path_is_absolute(name)
352         ? name
353         : GlobalFileSystem().findFile(name)
354     );
355   }
356 }
357
358 struct ModelResource : public Resource
359 {
360   NodeSmartReference m_model;
361   const CopiedString m_originalName;
362   CopiedString m_path;
363   CopiedString m_name;
364   CopiedString m_type;
365   ModelLoader* m_loader;
366   ModuleObservers m_observers;
367   std::time_t m_modified;
368   std::size_t m_unrealised;
369
370   ModelResource(const CopiedString& name) :
371     m_model(g_nullModel),
372     m_originalName(name),
373     m_type(path_get_extension(name.c_str())),
374     m_loader(0),
375     m_modified(0),
376     m_unrealised(1)
377   {
378     m_loader = ModelLoader_forType(m_type.c_str());
379
380     if(g_realised)
381     {
382       realise();
383     }
384   }
385   ~ModelResource()
386   {
387     if(realised())
388     {
389       unrealise();
390     }
391     ASSERT_MESSAGE(!realised(), "ModelResource::~ModelResource: resource reference still realised: " << makeQuoted(m_name.c_str()));
392   }
393   // NOT COPYABLE
394   ModelResource(const ModelResource&);
395   // NOT ASSIGNABLE
396   ModelResource& operator=(const ModelResource&);
397
398   void setModel(const NodeSmartReference& model)
399   {
400     m_model = model;
401   }
402   void clearModel()
403   {
404     m_model = g_nullModel;
405   }
406
407   void loadCached()
408   {
409     if(g_modelCache_enabled)
410     {
411       // cache lookup
412       ModelCache::iterator i = ModelCache_find(m_path.c_str(), m_name.c_str());
413       if(i == g_modelCache.end())
414       {
415         i = ModelCache_insert(
416           m_path.c_str(),
417           m_name.c_str(),
418           Model_load(m_loader, m_path.c_str(), m_name.c_str(), m_type.c_str())
419         );
420       }
421
422       setModel((*i).value);
423     }
424     else
425     {
426       setModel(Model_load(m_loader, m_path.c_str(), m_name.c_str(), m_type.c_str()));
427     }
428   }
429
430   void loadModel()
431   {
432     loadCached();
433     connectMap();
434     mapSave();
435   }
436
437   bool load()
438   {
439     ASSERT_MESSAGE(realised(), "resource not realised");
440     if(m_model == g_nullModel)
441     {
442       loadModel();
443     }
444
445     return m_model != g_nullModel;
446   }
447   bool save()
448   {
449     if(!mapSaved())
450     {
451       const char* moduleName = findModuleName(GetFileTypeRegistry(), MapFormat::Name(), m_type.c_str());
452       if(string_not_empty(moduleName))
453       {
454         const MapFormat* format = ReferenceAPI_getMapModules().findModule(moduleName);
455         if(format != 0 && MapResource_save(*format, m_model.get(), m_path.c_str(), m_name.c_str()))
456         {
457           mapSave();
458           return true;
459         }
460       }
461     }
462     return false;
463   }
464   void flush()
465   {
466     if(realised())
467     {
468       ModelCache_flush(m_path.c_str(), m_name.c_str());
469     }
470   }
471   scene::Node* getNode()
472   {
473     //if(m_model != g_nullModel)
474     {
475       return m_model.get_pointer();
476     }
477     //return 0;
478   }
479   void setNode(scene::Node* node)
480   {
481     ModelCache::iterator i = ModelCache_find(m_path.c_str(), m_name.c_str());
482     if(i != g_modelCache.end())
483     {
484       (*i).value = NodeSmartReference(*node);
485     }
486     setModel(NodeSmartReference(*node));
487
488     connectMap();
489   }
490   void attach(ModuleObserver& observer)
491   {
492     if(realised())
493     {
494       observer.realise();
495     }
496     m_observers.attach(observer);
497   }
498   void detach(ModuleObserver& observer)
499   {
500     if(realised())
501     {
502       observer.unrealise();
503     }
504     m_observers.detach(observer);
505   }
506   bool realised()
507   {
508     return m_unrealised == 0;
509   }
510   void realise()
511   {
512     ASSERT_MESSAGE(m_unrealised != 0, "ModelResource::realise: already realised");
513     if(--m_unrealised == 0)
514     {
515       m_path = rootPath(m_originalName.c_str());
516       m_name = path_make_relative(m_originalName.c_str(), m_path.c_str());
517
518       //globalOutputStream() << "ModelResource::realise: " << m_path.c_str() << m_name.c_str() << "\n";
519
520       m_observers.realise();
521     }
522   }
523   void unrealise()
524   {
525     if(++m_unrealised == 1)
526     {
527       m_observers.unrealise();
528
529       //globalOutputStream() << "ModelResource::unrealise: " << m_path.c_str() << m_name.c_str() << "\n";
530       clearModel();
531     }
532   }
533   bool isMap() const
534   {
535     return Node_getMapFile(m_model) != 0;
536   }
537   void connectMap()
538   {
539     MapFile* map = Node_getMapFile(m_model);
540     if(map != 0)
541     {
542       map->setChangedCallback(FreeCaller<MapChanged>());
543     }
544   }
545   std::time_t modified() const
546   {
547     StringOutputStream fullpath(256);
548     fullpath << m_path.c_str() << m_name.c_str();
549     return file_modified(fullpath.c_str());
550   }
551   void mapSave()
552   {
553     m_modified = modified();
554     MapFile* map = Node_getMapFile(m_model);
555     if(map != 0)
556     {
557       map->save();
558     }
559   }
560   bool mapSaved() const
561   {
562     MapFile* map = Node_getMapFile(m_model);
563     if(map != 0)
564     {
565       return m_modified == modified() && map->saved();
566     }
567     return true;
568   }
569   bool isModified() const
570   {
571     return ((!string_empty(m_path.c_str()) // had or has an absolute path
572         && m_modified != modified()) // AND disk timestamp changed
573       || !path_equal(rootPath(m_originalName.c_str()), m_path.c_str())); // OR absolute vfs-root changed
574   }
575   void refresh()
576   {
577     if(isModified())
578     {
579       flush();
580       unrealise();
581       realise();
582     }
583   }
584 };
585
586 class HashtableReferenceCache : public ReferenceCache, public ModuleObserver
587 {
588   typedef HashedCache<CopiedString, ModelResource, PathHash, PathEqual> ModelReferences;
589   ModelReferences m_references;
590   std::size_t m_unrealised;
591
592   class ModelReferencesSnapshot
593   {
594     ModelReferences& m_references;
595     typedef std::list<ModelReferences::iterator> Iterators;
596     Iterators m_iterators;
597   public:
598     typedef Iterators::iterator iterator;
599     ModelReferencesSnapshot(ModelReferences& references) : m_references(references)
600     {
601       for(ModelReferences::iterator i = m_references.begin(); i != m_references.end(); ++i)
602       {
603         m_references.capture(i);
604         m_iterators.push_back(i);
605       }
606     }
607     ~ModelReferencesSnapshot()
608     {
609       for(Iterators::iterator i = m_iterators.begin(); i != m_iterators.end(); ++i)
610       {
611         m_references.release(*i);
612       }
613     }
614     iterator begin()
615     {
616       return m_iterators.begin();
617     }
618     iterator end()
619     {
620       return m_iterators.end();
621     }
622   };
623
624 public:
625
626   typedef ModelReferences::iterator iterator;
627
628   HashtableReferenceCache() : m_unrealised(1)
629   {
630   }
631
632   iterator begin()
633   {
634     return m_references.begin();
635   }
636   iterator end()
637   {
638     return m_references.end();
639   }
640
641   void clear()
642   {
643     m_references.clear();
644   }
645
646   Resource* capture(const char* path)
647   {
648     //globalOutputStream() << "capture: \"" << path << "\"\n";
649     return m_references.capture(CopiedString(path)).get();
650   }
651   void release(const char* path)
652   {
653     m_references.release(CopiedString(path));
654     //globalOutputStream() << "release: \"" << path << "\"\n";
655   }
656
657   void setEntityCreator(EntityCreator& entityCreator)
658   {
659     g_entityCreator = &entityCreator;
660   }
661
662   bool realised() const
663   {
664     return m_unrealised == 0;
665   }
666   void realise()
667   {
668     ASSERT_MESSAGE(m_unrealised != 0, "HashtableReferenceCache::realise: already realised");
669     if(--m_unrealised == 0)
670     {
671       g_realised = true;
672
673       {
674         ModelReferencesSnapshot snapshot(m_references);
675         for(ModelReferencesSnapshot::iterator i = snapshot.begin(); i != snapshot.end(); ++i)
676         {
677           ModelReferences::value_type& value = *(*i);
678           if(value.value.count() != 1)
679           {
680             value.value.get()->realise();
681           }
682         }
683       }
684     }
685   }
686   void unrealise()
687   {
688     if(++m_unrealised == 1)
689     {
690       g_realised = false;
691
692       {
693         ModelReferencesSnapshot snapshot(m_references);
694         for(ModelReferencesSnapshot::iterator i = snapshot.begin(); i != snapshot.end(); ++i)
695         {
696           ModelReferences::value_type& value = *(*i);
697           if(value.value.count() != 1)
698           {
699             value.value.get()->unrealise();
700           }
701         }
702       }
703
704       ModelCache_clear();
705     }
706   }
707   void refresh()
708   {
709     ModelReferencesSnapshot snapshot(m_references);
710     for(ModelReferencesSnapshot::iterator i = snapshot.begin(); i != snapshot.end(); ++i)
711     {
712       ModelResource* resource = (*(*i)).value.get();
713       if(!resource->isMap())
714       {
715         resource->refresh();
716       }
717     }
718   }
719 };
720
721 namespace
722 {
723   HashtableReferenceCache g_referenceCache;
724 }
725
726 #if 0
727 class ResourceVisitor
728 {
729 public:
730   virtual void visit(const char* name, const char* path, const
731 };
732 #endif
733
734 void SaveReferences()
735 {
736   ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Saving Map");
737   for(HashtableReferenceCache::iterator i = g_referenceCache.begin(); i != g_referenceCache.end(); ++i)
738   {
739     (*i).value->save();
740   }
741   MapChanged();
742 }
743
744 bool References_Saved()
745 {
746   for(HashtableReferenceCache::iterator i = g_referenceCache.begin(); i != g_referenceCache.end(); ++i)
747   {
748     scene::Node* node = (*i).value->getNode();
749     if(node != 0)
750     {
751       MapFile* map = Node_getMapFile(*node);
752       if(map != 0 && !map->saved())
753       {
754         return false;
755       }
756     }
757   }
758   return true;
759 }
760
761 void RefreshReferences()
762 {
763   ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Refreshing Models");
764   g_referenceCache.refresh();
765 }
766
767
768 void FlushReferences()
769 {
770   ModelCache_clear();
771
772   g_referenceCache.clear();
773 }
774
775 ReferenceCache& GetReferenceCache()
776 {
777   return g_referenceCache;
778 }
779
780
781 #include "modulesystem/modulesmap.h"
782 #include "modulesystem/singletonmodule.h"
783 #include "modulesystem/moduleregistry.h"
784
785 class ReferenceDependencies :
786   public GlobalRadiantModuleRef,
787   public GlobalFileSystemModuleRef,
788   public GlobalFiletypesModuleRef
789 {
790   ModelModulesRef m_model_modules;
791   MapModulesRef m_map_modules;
792 public:
793   ReferenceDependencies() :
794     m_model_modules(GlobalRadiant().getRequiredGameDescriptionKeyValue("modeltypes")),
795     m_map_modules(GlobalRadiant().getRequiredGameDescriptionKeyValue("maptypes"))
796   {
797   }
798   ModelModules& getModelModules()
799   {
800     return m_model_modules.get();
801   }
802   MapModules& getMapModules()
803   {
804     return m_map_modules.get();
805   }
806 };
807
808 class ReferenceAPI : public TypeSystemRef
809 {
810   ReferenceCache* m_reference;
811 public:
812   typedef ReferenceCache Type;
813   STRING_CONSTANT(Name, "*");
814
815   ReferenceAPI()
816   {
817     g_nullModel = NewNullModel();
818
819     GlobalFileSystem().attach(g_referenceCache);
820
821     m_reference = &GetReferenceCache();
822   }
823   ~ReferenceAPI()
824   {
825     GlobalFileSystem().detach(g_referenceCache);
826
827     g_nullModel = g_nullNode;
828   }
829   ReferenceCache* getTable()
830   {
831     return m_reference;
832   }
833 };
834
835 typedef SingletonModule<ReferenceAPI, ReferenceDependencies> ReferenceModule;
836 typedef Static<ReferenceModule> StaticReferenceModule;
837 StaticRegisterModule staticRegisterReference(StaticReferenceModule::instance());
838
839 ModelModules& ReferenceAPI_getModelModules()
840 {
841   return StaticReferenceModule::instance().getDependencies().getModelModules();
842 }
843 MapModules& ReferenceAPI_getMapModules()
844 {
845   return StaticReferenceModule::instance().getDependencies().getMapModules();
846 }