wowgetoffyourcellphone/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Activity

# Added support for COLLADA skeletal animations.

Browse Source 
Moved COLLADA-loading code into separate class, since it now handles
both PMD and PSA.
Desingletonised CSkeletonAnimManager, moved into CGameView.
Made Atlas load its icons with buffered IO, for possible efficiency.

This was SVN commit r4934.
This commit is contained in:
Ykkrosh 2007-03-01 18:52:53 +00:00
parent ea29a1caeb
commit fa45d214b3
21 changed files with 424 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

236
source/graphics/ColladaManager.cpp Normal file
View File

@ -0,0 +1,236 @@
#include "precompiled.h"
#include "ColladaManager.h"
#include "graphics/ModelDef.h"
#include "lib/res/file/vfs.h"
#include "lib/res/handle.h"
#include "ps/CLogger.h"
#include "ps/CStr.h"
#include "ps/CVFSFile.h"
#include "ps/DllLoader.h"
namespace Collada
{
#include "collada/DLL.h"
}
namespace
{
struct VFSOutputCB
{
VFSOutputCB(Handle hf) : hf(hf) {}
void operator() (const char* data, unsigned int length)
{
FileIOBuf buf = (FileIOBuf)data;
const ssize_t ret = vfs_io(hf, length, &buf);
// TODO: handle errors sensibly
}
Handle hf;
};
void ColladaLog(int severity, const char* text)
{
LOG(severity == LOG_INFO ? NORMAL :
severity == LOG_WARNING ? WARNING : ERROR,
"collada", "%s", text);
}
void ColladaOutput(void* cb_data, const char* data, unsigned int length)
{
VFSOutputCB* cb = static_cast<VFSOutputCB*>(cb_data);
(*cb)(data, length);
}
}
class CColladaManagerImpl
{
DllLoader dll;
void (*set_logger)(Collada::LogFn logger);
int (*convert_dae_to_pmd)(const char* dae, Collada::OutputFn pmd_writer, void* cb_data);
int (*convert_dae_to_psa)(const char* dae, Collada::OutputFn psa_writer, void* cb_data);
public:
CColladaManagerImpl()
: dll("Collada")
{
}
~CColladaManagerImpl()
{
if (dll.IsLoaded())
set_logger(NULL); // unregister the log handler
}
bool Convert(const CStr& daeFilename, const CStr& pmdFilename, CColladaManager::FileType type)
{
// To avoid always loading the DLL when it's usually not going to be
// used (and to do the same on Linux where delay-loading won't help),
// and to avoid compile-time dependencies (because it's a minor pain
// to get all the right libraries to build the COLLADA DLL), we load
// it dynamically when it is required, instead of using the exported
// functions and binding at link-time.
if (! dll.IsLoaded())
{
if (! dll.LoadDLL())
{
LOG_ONCE(ERROR, "collada", "Failed to load COLLADA conversion DLL");
return false;
}
try
{
dll.LoadSymbol("set_logger", set_logger);
dll.LoadSymbol("convert_dae_to_pmd", convert_dae_to_pmd);
dll.LoadSymbol("convert_dae_to_psa", convert_dae_to_psa);
}
catch (PSERROR_DllLoader&)
{
LOG(ERROR, "collada", "Failed to load symbols from COLLADA conversion DLL");
dll.Unload();
return false;
}
set_logger(ColladaLog);
}
// We need to null-terminate the buffer, so do it (possibly inefficiently)
// by converting to a CStr
CStr daeData;
{
CVFSFile daeFile;
if (daeFile.Load(daeFilename) != PSRETURN_OK)
return false;
daeData = daeFile.GetAsString();
// scope closes daeFile - necessary if we don't use FILE_LONG_LIVED
}
// Prepare the output file
Handle hf = vfs_open(pmdFilename, FILE_WRITE|FILE_NO_AIO);
if (hf < 0)
return false;
// Do the conversion
VFSOutputCB cb (hf);
switch (type)
{
case CColladaManager::PMD: convert_dae_to_pmd(daeData.c_str(), ColladaOutput, static_cast<void*>(&cb)); break;
case CColladaManager::PSA: convert_dae_to_psa(daeData.c_str(), ColladaOutput, static_cast<void*>(&cb)); break;
}
vfs_close(hf);
return true;
}
};
CColladaManager::CColladaManager()
: m(new CColladaManagerImpl())
{
}
CColladaManager::~CColladaManager()
{
delete m;
}
CStr CColladaManager::GetLoadableFilename(const CStr &sourceName, FileType type)
{
const char* extn = NULL;
switch (type)
{
case PMD: extn = ".pmd"; break;
case PSA: extn = ".psa"; break;
// no other alternatives
}
/*
If there is a .dae file:
* Calculate a hash to identify it.
* Look for a cached .pmd file matching that hash.
* If it exists, load it. Else, convert the .dae into .pmd and load it.
Otherwise, if there is a (non-cache) .pmd file:
* Load it.
Else, fail.
The hash calculation ought to be fast, since normally (during development)
the .dae file will exist but won't have changed recently and so the cache
would be used. Hence, just hash the file's size, mtime, and the converter
version number (so updates of the converter can cause regeneration of .pmds)
instead of the file's actual contents.
TODO (maybe): The .dae -> .pmd conversion may fail (e.g. if the .dae is
invalid or unsupported), but it may take a long time to start the conversion
then realise it's not going to work. That will delay the loading of the game
every time, which is annoying, so maybe it should cache the error message
until the .dae is updated and fixed. (Alternatively, avoid having that many
broken .daes in the game.)
*/
// (TODO: the comments and variable names say "pmd" but actually they can
// be "psa" too.)
CStr dae = sourceName + ".dae";
if (! vfs_exists(dae))
{
// No .dae - got to use the .pmd, assuming there is one
return sourceName + extn;
}
// There is a .dae - see if there's an up-to-date cached copy
struct stat fileStat;
if (vfs_stat(dae, &fileStat) < 0)
{
// This shouldn't occur for any sensible reasons
LOG(ERROR, "collada", "Failed to stat DAE file '%s'", dae.c_str());
return "";
}
// Build a struct of all the data we want to hash.
// (Use ints and not time_t/off_t because we don't care about overflow
// but do care about the fields not being 64-bit aligned)
// (Remove the lowest bit of mtime because some things round it to a
// resolution of 2 seconds)
struct { int version; int mtime; int size; } hashSource
= { COLLADA_CONVERTER_VERSION, (int)fileStat.st_mtime & ~1, (int)fileStat.st_size };
cassert(sizeof(hashSource) == sizeof(int) * 3); // no padding, because that would be bad
// Calculate the hash, convert to hex
u32 hash = fnv_hash(static_cast<void*>(&hashSource), sizeof(hashSource));
char hashString[9];
sprintf(hashString, "%08x", hash);
// realDaePath is "mods/whatever/art/meshes/whatever.dae"
char realDaePath[PATH_MAX];
vfs_realpath(dae, realDaePath);
// cachedPmdVfsPath is "cache/mods/whatever/art/meshes/whatever_{hash}.pmd"
CStr cachedPmdVfsPath = "cache/";
cachedPmdVfsPath += realDaePath;
// Remove the .dae extension (which will certainly be there)
cachedPmdVfsPath = cachedPmdVfsPath.substr(0, cachedPmdVfsPath.length()-4);
// Add a _hash.pmd extension
cachedPmdVfsPath += "_";
cachedPmdVfsPath += hashString;
cachedPmdVfsPath += extn;
// If it's not in the cache, we'll have to create it first
if (! vfs_exists(cachedPmdVfsPath))
{
if (! m->Convert(dae, cachedPmdVfsPath, type))
return ""; // failed to convert
}
return cachedPmdVfsPath;
}

32
source/graphics/ColladaManager.h Normal file
View File

@ -0,0 +1,32 @@
#ifndef COLLADAMANAGER_H__
#define COLLADAMANAGER_H__
class CStr8;
class CColladaManagerImpl;
class CColladaManager
{
public:
enum FileType { PMD, PSA };
CColladaManager();
~CColladaManager();
/**
* Returns the VFS path to a PMD/PSA file for the given source file.
* Performs a (cached) conversion from COLLADA if necessary.
*
* @param sourceName path and name, minus extension, of file to load.
* One of either "sourceName.pmd" or "sourceName.dae" should exist.
*
* @return full VFS path (including extension) of file to load; or empty
* string if there was a problem and it could not be loaded.
*/
CStr8 GetLoadableFilename(const CStr8& sourceName, FileType type);
private:
CColladaManagerImpl* m;
};
#endif // COLLADAMANAGER_H__

8
source/graphics/GameView.cpp
View File

@ -4,11 +4,13 @@
#include "graphics/Camera.h"
#include "graphics/CinemaTrack.h"
#include "graphics/ColladaManager.h"
#include "graphics/HFTracer.h"
#include "graphics/LightEnv.h"
#include "graphics/Model.h"
#include "graphics/ObjectManager.h"
#include "graphics/Patch.h"
#include "graphics/SkeletonAnimManager.h"
#include "graphics/Terrain.h"
#include "graphics/TextureManager.h"
#include "graphics/Unit.h"
@ -57,7 +59,9 @@ class CGameViewImpl : public CJSObject<CGameViewImpl>, boost::noncopyable
{
public:
CGameViewImpl(CGame* game)
: Game(game), MeshManager(), ObjectManager(MeshManager),
: Game(game),
ColladaManager(), MeshManager(ColladaManager), SkeletonAnimManager(ColladaManager),
ObjectManager(MeshManager, SkeletonAnimManager),
ViewCamera(),
CullCamera(),
LockCullCamera(false),
@ -79,7 +83,9 @@ public:
}
CGame* Game;
CColladaManager ColladaManager;
CMeshManager MeshManager;
CSkeletonAnimManager SkeletonAnimManager;
CObjectManager ObjectManager;
/**

219
source/graphics/MeshManager.cpp
View File

@ -2,140 +2,25 @@
#include "MeshManager.h"
#include "graphics/ColladaManager.h"
#include "graphics/ModelDef.h"
#include "ps/CLogger.h"
#include "ps/FileUnpacker.h" // to get access to its CError
#include "ps/CVFSFile.h"
#include "ps/DllLoader.h"
#include "lib/res/file/vfs.h"
namespace Collada
{
#include "collada/DLL.h"
}
#include <boost/weak_ptr.hpp>
#include "ps/Profile.h"
#define LOG_CATEGORY "mesh"
void ColladaLog(int severity, const char* text)
{
LOG(severity==LOG_INFO ? NORMAL : severity==LOG_WARNING ? WARNING : ERROR,
"collada", "%s", text);
}
// TODO: should this cache models while they're not actively in the game?
// (Currently they'll probably be deleted when the reference count drops to 0,
// even if it's quite possible that they'll get reloaded very soon.)
struct VFSOutputCB
{
VFSOutputCB(Handle hf) : hf(hf) {}
void operator() (const char* data, unsigned int length)
{
FileIOBuf buf = (FileIOBuf)data;
const ssize_t ret = vfs_io(hf, length, &buf);
// TODO: handle errors sensibly
}
Handle hf;
};
void ColladaOutput(void* cb_data, const char* data, unsigned int length)
{
VFSOutputCB* cb = static_cast<VFSOutputCB*>(cb_data);
(*cb)(data, length);
}
typedef STL_HASH_MAP<CStr, boost::weak_ptr<CModelDef>, CStr_hash_compare> mesh_map;
class CMeshManagerImpl
{
DllLoader dll;
void (*set_logger)(Collada::LogFn logger);
int (*convert_dae_to_pmd)(const char* dae, Collada::OutputFn pmd_writer, void* cb_data);
public:
mesh_map MeshMap;
CMeshManagerImpl()
: dll("Collada")
{
}
~CMeshManagerImpl()
{
if (dll.IsLoaded())
set_logger(NULL); // unregister the log handler
}
CModelDefPtr Convert(const CStr& daeFilename, const CStr& pmdFilename, const CStr& name)
{
// To avoid always loading the DLL when it's usually not going to be
// used (and to do the same on Linux where delay-loading won't help),
// and to avoid compile-time dependencies (because it's a minor pain
// to get all the right libraries to build the COLLADA DLL), we load
// it dynamically when it is required, instead of using the exported
// functions and binding at link-time.
if (! dll.IsLoaded())
{
if (! dll.LoadDLL())
{
LOG_ONCE(ERROR, LOG_CATEGORY, "Failed to load COLLADA conversion DLL");
return CModelDefPtr();
}
try
{
dll.LoadSymbol("set_logger", set_logger);
dll.LoadSymbol("convert_dae_to_pmd", convert_dae_to_pmd);
}
catch (PSERROR_DllLoader&)
{
LOG(ERROR, LOG_CATEGORY, "Failed to load symbols from COLLADA conversion DLL");
dll.Unload();
return CModelDefPtr();
}
set_logger(ColladaLog);
}
// We need to null-terminate the buffer, so do it (possibly inefficiently)
// by converting to a CStr
CStr daeData;
{
CVFSFile daeFile;
if (daeFile.Load(daeFilename) != PSRETURN_OK)
return CModelDefPtr();
daeData = daeFile.GetAsString();
// scope closes daeFile - necessary if we don't use FILE_LONG_LIVED
}
// Prepare the output file
Handle hf = vfs_open(pmdFilename, FILE_WRITE|FILE_NO_AIO);
if (hf < 0)
return CModelDefPtr();
// Do the conversion
VFSOutputCB cb (hf);
convert_dae_to_pmd(daeData.c_str(), ColladaOutput, static_cast<void*>(&cb));
vfs_close(hf);
// Now load the PMD that was just created
CModelDefPtr model (CModelDef::Load(pmdFilename, name));
MeshMap[name] = model;
return model;
}
};
CMeshManager::CMeshManager()
: m(new CMeshManagerImpl())
CMeshManager::CMeshManager(CColladaManager& colladaManager)
: m_ColladaManager(colladaManager)
{
}
CMeshManager::~CMeshManager()
{
delete m;
}
CModelDefPtr CMeshManager::GetMesh(const CStr& filename)
@ -148,91 +33,25 @@ CModelDefPtr CMeshManager::GetMesh(const CStr& filename)
name = filename;
// Find the mesh if it's already been loaded and cached
mesh_map::iterator iter = m->MeshMap.find(name);
if (iter != m->MeshMap.end() && !iter->second.expired())
mesh_map::iterator iter = m_MeshMap.find(name);
if (iter != m_MeshMap.end() && !iter->second.expired())
return CModelDefPtr(iter->second);
/*
PROFILE( "load mesh" );
If there is a .dae file:
* Calculate a hash to identify it.
* Look for a cached .pmd file matching that hash.
* If it exists, load it. Else, convert the .dae into .pmd and load it.
Otherwise, if there is a (non-cache) .pmd file:
* Load it.
Else, fail.
CStr pmdFilename = m_ColladaManager.GetLoadableFilename(name, CColladaManager::PMD);
The hash calculation ought to be fast, since normally (during development)
the .dae file will exist but won't have changed recently and so the cache
would be used. Hence, just hash the file's size, mtime, and the converter
version number (so updates will cause regeneration of .pmds) instead of
its contents.
TODO (maybe): The .dae -> .pmd conversion may fail (e.g. if the .dae is
invalid or unsupported), but it may take a long time to start the conversion
then realise it's not going to work. That will delay the loading of the game
every time, which is annoying, so maybe it should cache the error messge
until the .dae is updated and fixed. (Alternatively, avoid having many
broken .daes in the game's data files.)
*/
if (pmdFilename.empty())
{
LOG(ERROR, LOG_CATEGORY, "Could not load mesh '%s'", filename.c_str());
return CModelDefPtr();
}
try
{
CStr dae = name+".dae";
if (! vfs_exists(dae))
{
// No .dae - got to use the .pmd, assuming there is one
CModelDefPtr model (CModelDef::Load(name+".pmd", name));
m->MeshMap[name] = model;
return model;
}
// There is a .dae - see if there's an up-to-date cached copy
struct stat fileStat;
if (vfs_stat(dae, &fileStat) < 0)
{
// This shouldn't occur for any sensible reasons
LOG(ERROR, LOG_CATEGORY, "Failed to stat DAE file '%s'", filename.c_str());
return CModelDefPtr();
}
// Build a struct of all the data we want to hash.
// (Use ints and not time_t/off_t because we don't care about overflow
// but do care about the fields not being 64-bit aligned)
struct { int version; int mtime; int size; } hashSource
= { COLLADA_CONVERTER_VERSION, fileStat.st_mtime & ~1, fileStat.st_size };
cassert(sizeof(hashSource) == sizeof(int) * 3); // no padding, because that would be bad
// Calculate the hash, convert to hex
u32 hash = fnv_hash(static_cast<void*>(&hashSource), sizeof(hashSource));
char hashString[9];
sprintf(hashString, "%08x", hash);
char realDaePath[PATH_MAX];
vfs_realpath(dae, realDaePath);
// realDaePath is "mods/whatever/art/meshes/whatever.dae"
CStr cachedPmdVfsPath = "cache/";
cachedPmdVfsPath += realDaePath;
// Remove the .dae extension (which will certainly be there)
cachedPmdVfsPath = cachedPmdVfsPath.substr(0, cachedPmdVfsPath.length()-4);
// Add a _hash.pmd extension
cachedPmdVfsPath += "_";
cachedPmdVfsPath += hashString;
cachedPmdVfsPath += ".pmd";
// If it's cached, load and return that copy
if (vfs_exists(cachedPmdVfsPath))
{
CModelDefPtr model (CModelDef::Load(cachedPmdVfsPath, name));
m->MeshMap[name] = model;
return model;
}
// Not in the cache, so create it
return m->Convert(dae, cachedPmdVfsPath, name);
CModelDefPtr model (CModelDef::Load(pmdFilename, name));
m_MeshMap[name] = model;
return model;
}
catch (PSERROR_File&)
{

17
source/graphics/MeshManager.h
View File

@ -1,25 +1,28 @@
#ifndef __H_MESHMANAGER_H__
#define __H_MESHMANAGER_H__
#include "ps/CStr.h"
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
class CModelDef;
typedef boost::shared_ptr<CModelDef> CModelDefPtr;
class CStr8;
class CColladaManager;
class CMeshManagerImpl;
class CMeshManager
class CMeshManager : boost::noncopyable
{
public:
CMeshManager();
CMeshManager(CColladaManager& colladaManager);
~CMeshManager();
CModelDefPtr GetMesh(const CStr8& filename);
CModelDefPtr GetMesh(const CStr& filename);
private:
CMeshManagerImpl* m;
typedef STL_HASH_MAP<CStr, boost::weak_ptr<CModelDef>, CStr_hash_compare> mesh_map;
mesh_map m_MeshMap;
CColladaManager& m_ColladaManager;
};
#endif

9
source/graphics/Model.cpp
View File

@ -26,10 +26,11 @@
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor
CModel::CModel()
CModel::CModel(CSkeletonAnimManager& skeletonAnimManager)
: m_Parent(NULL), m_Flags(0), m_Anim(NULL), m_AnimTime(0),
m_BoneMatrices(NULL), m_InverseBindBoneMatrices(NULL),
m_PositionValid(false), m_ShadingColor(1,1,1,1)
m_PositionValid(false), m_ShadingColor(1,1,1,1),
m_SkeletonAnimManager(skeletonAnimManager)
{
}
@ -201,7 +202,7 @@ void CModel::CalcAnimatedObjectBound(CSkeletonAnimDef* anim,CBound& result)
// animation specific to this model
CSkeletonAnim* CModel::BuildAnimation(const char* filename, const char* name, float speed, double actionpos, double actionpos2)
{
CSkeletonAnimDef* def=g_SkelAnimMan.GetAnimation(filename);
CSkeletonAnimDef* def = m_SkeletonAnimManager.GetAnimation(filename);
if (!def) return NULL;
@ -463,7 +464,7 @@ void CModel::RemoveProp(SPropPoint* point)
// Clone: return a clone of this model
CModel* CModel::Clone() const
{
CModel* clone = new CModel;
CModel* clone = new CModel(m_SkeletonAnimManager);
clone->m_ObjectBounds = m_ObjectBounds;
clone->InitModel(m_pModelDef);
clone->SetTexture(m_Texture);

8
source/graphics/Model.h
View File

@ -20,6 +20,7 @@ struct SPropPoint;
class CObjectEntry;
class CSkeletonAnim;
class CSkeletonAnimDef;
class CSkeletonAnimManager;
#define MODELFLAG_CASTSHADOWS (1<<0)
#define MODELFLAG_NOLOOPANIMATION (1<<1)
@ -27,7 +28,7 @@ class CSkeletonAnimDef;
///////////////////////////////////////////////////////////////////////////////
// CModel: basically, a mesh object - holds the texturing and skinning
// information for a model in game
class CModel : public CRenderableObject
class CModel : public CRenderableObject, boost::noncopyable
{
friend class CUnitAnimation;
// HACK - we should probably move the rest of this class's animation state
@ -44,7 +45,7 @@ public:
public:
// constructor
CModel();
CModel(CSkeletonAnimManager& skeletonAnimManager);
// destructor
~CModel();
@ -201,6 +202,9 @@ private:
// modulating color
CColor m_ShadingColor;
// manager object which can load animations for us
CSkeletonAnimManager& m_SkeletonAnimManager;
};
#endif

2
source/graphics/ObjectEntry.cpp
View File

@ -82,7 +82,7 @@ bool CObjectEntry::BuildVariation(const std::vector<std::set<CStr> >& selections
// delete old model, create new
delete m_Model;
m_Model = new CModel;
m_Model = new CModel(objectManager.GetSkeletonAnimManager());
m_Model->SetTexture((const char*) m_TextureName);
m_Model->SetMaterial(g_MaterialManager.LoadMaterial(m_Base->m_Material));
m_Model->InitModel(modeldef);

4
source/graphics/ObjectManager.cpp
View File

@ -34,8 +34,8 @@ bool operator< (const CObjectManager::ObjectKey& a, const CObjectManager::Object
return a.ActorVariation < b.ActorVariation;
}
CObjectManager::CObjectManager(CMeshManager& meshManager)
: m_MeshManager(meshManager)
CObjectManager::CObjectManager(CMeshManager& meshManager, CSkeletonAnimManager& skeletonAnimManager)
: m_MeshManager(meshManager), m_SkeletonAnimManager(skeletonAnimManager)
{
}

8
source/graphics/ObjectManager.h
View File

@ -10,6 +10,7 @@ class CMatrix3D;
class CMeshManager;
class CObjectBase;
class CObjectEntry;
class CSkeletonAnimManager;
///////////////////////////////////////////////////////////////////////////////////////////
// CObjectManager: manager class for all possible actor types
@ -28,10 +29,14 @@ public:
public:
// constructor, destructor
CObjectManager(CMeshManager& meshManager);
CObjectManager(CMeshManager& meshManager, CSkeletonAnimManager& skeletonAnimManager);
~CObjectManager();
// Provide access to the manager classes for meshes and animations - they're
// needed when objects are being created and so this seems like a convenient
// place to centralise access.
CMeshManager& GetMeshManager() const { return m_MeshManager; }
CSkeletonAnimManager& GetSkeletonAnimManager() const { return m_SkeletonAnimManager; }
void UnloadObjects();
@ -49,6 +54,7 @@ public:
private:
CMeshManager& m_MeshManager;
CSkeletonAnimManager& m_SkeletonAnimManager;
std::map<ObjectKey, CObjectEntry*> m_Objects;
std::map<CStr, CObjectBase*> m_ObjectBases;

86
source/graphics/SkeletonAnimManager.cpp
View File

@ -8,18 +8,21 @@
#include "precompiled.h"
#include "lib/res/res.h"
#include "Model.h"
#include "ps/CLogger.h"
#include "SkeletonAnimManager.h"
#include "graphics/ColladaManager.h"
#include "graphics/Model.h"
#include "graphics/SkeletonAnimDef.h"
#include "lib/res/res.h"
#include "ps/CLogger.h"
#include "ps/FileUnpacker.h"
#include <algorithm>
#define LOG_CATEGORY "graphics"
///////////////////////////////////////////////////////////////////////////////
// CSkeletonAnimManager constructor
CSkeletonAnimManager::CSkeletonAnimManager()
CSkeletonAnimManager::CSkeletonAnimManager(CColladaManager& colladaManager)
: m_ColladaManager(colladaManager)
{
}
@ -28,48 +31,55 @@ CSkeletonAnimManager::CSkeletonAnimManager()
CSkeletonAnimManager::~CSkeletonAnimManager()
{
typedef std::map<CStr,CSkeletonAnimDef*>::iterator Iter;
for (Iter i=m_Animations.begin();i!=m_Animations.end();++i) {
for (Iter i = m_Animations.begin(); i != m_Animations.end(); ++i)
delete i->second;
}
}
///////////////////////////////////////////////////////////////////////////////
// GetAnimation: return a given animation by filename; return null if filename
// doesn't refer to valid animation file
CSkeletonAnimDef* CSkeletonAnimManager::GetAnimation(const char* filename)
CSkeletonAnimDef* CSkeletonAnimManager::GetAnimation(const CStr& filename)
{
// already loaded?
CStr fname(filename);
std::map<CStr,CSkeletonAnimDef*>::iterator iter=m_Animations.find(fname);
if (iter!=m_Animations.end()) {
// yes - return it
// Strip a three-letter file extension (if there is one) from the filename
CStr name;
if (filename.length() > 4 && filename[filename.length()-4] == '.')
name = filename.substr(0, filename.length()-4);
else
name = filename;
// Find if it's already been loaded
std::map<CStr, CSkeletonAnimDef*>::iterator iter = m_Animations.find(name);
if (iter != m_Animations.end())
return iter->second;
CSkeletonAnimDef* def = NULL;
// Find the file to load
CStr psaFilename = m_ColladaManager.GetLoadableFilename(name, CColladaManager::PSA);
if (psaFilename.empty())
{
LOG(ERROR, LOG_CATEGORY, "Could not load animation '%s'", filename.c_str());
def = NULL;
}
else
{
try
{
def = CSkeletonAnimDef::Load(psaFilename);
}
catch (PSERROR_File&)
{
// ignore errors (they'll be logged elsewhere)
}
}
// already failed to load?
std::set<CStr>::iterator setiter=m_BadAnimationFiles.find(fname);
if (setiter!=m_BadAnimationFiles.end()) {
// yes - return null
return 0;
}
if (def)
LOG(NORMAL, LOG_CATEGORY, "CSkeletonAnimManager::GetAnimation(%s): Loaded successfully", filename.c_str());
else
LOG(ERROR, LOG_CATEGORY, "CSkeletonAnimManager::GetAnimation(%s): Failed loading, marked file as bad", filename.c_str());
// try and load it now
CSkeletonAnimDef* def;
try {
def=CSkeletonAnimDef::Load(filename);
} catch (PSERROR_File&) {
def=0;
}
if (!def) {
LOG(ERROR, LOG_CATEGORY, "CSkeletonAnimManager::GetAnimation(%s): Failed loading, marked file as bad", filename);
// add this file as bad
m_BadAnimationFiles.insert(fname);
return 0;
} else {
LOG(NORMAL, LOG_CATEGORY, "CSkeletonAnimManager::GetAnimation(%s): Loaded successfully", filename);
// add mapping for this file
m_Animations[fname]=def;
return def;
}
// Add to map
m_Animations[name] = def; // NULL if failed to load - we won't try loading it again
return def;
}

22
source/graphics/SkeletonAnimManager.h
View File

@ -11,34 +11,32 @@
#include <map>
#include <set>
#include "SkeletonAnimDef.h"
#include "ps/Singleton.h"
// access to sole CSkeletonAnimManager object
#define g_SkelAnimMan CSkeletonAnimManager::GetSingleton()
class CColladaManager;
class CSkeletonAnimDef;
class CStr8;
///////////////////////////////////////////////////////////////////////////////
// CSkeletonAnimManager : owner class of all skeleton anims - manages creation,
// loading and destruction of animation data
class CSkeletonAnimManager : public Singleton<CSkeletonAnimManager>
class CSkeletonAnimManager : boost::noncopyable
{
public:
// constructor, destructor
CSkeletonAnimManager();
CSkeletonAnimManager(CColladaManager& colladaManager);
~CSkeletonAnimManager();
// return a given animation by filename; return null if filename doesn't
// refer to valid animation file
CSkeletonAnimDef* GetAnimation(const char* filename);
CSkeletonAnimDef* GetAnimation(const CStr8& filename);
private:
CSkeletonAnimDef* LoadAnimation(const char* filename);
// map of all known animations
std::map<CStr,CSkeletonAnimDef*> m_Animations;
// set of bad animation names - prevents multiple reloads of bad files
std::set<CStr> m_BadAnimationFiles;
// map of all known animations. Value is NULL if it failed to load.
std::map<CStr8, CSkeletonAnimDef*> m_Animations;
CColladaManager& m_ColladaManager;
};
#endif

18
source/graphics/tests/test_MeshManager.h
View File

@ -6,6 +6,7 @@
#include "lib/res/file/trace.h"
#include "lib/res/h_mgr.h"
#include "graphics/ColladaManager.h"
#include "graphics/MeshManager.h"
#include "graphics/ModelDef.h"
@ -95,6 +96,7 @@ class TestMeshManager : public CxxTest::TestSuite
TS_ASSERT_OK(vfs_opt_rebuild_main_archive(MOD_PATH"/trace.txt", MOD_PATH"/test%02d.zip"));
}
CColladaManager* colladaManager;
CMeshManager* meshManager;
public:
@ -102,12 +104,14 @@ public:
void setUp()
{
initVfs();
meshManager = new CMeshManager();
colladaManager = new CColladaManager();
meshManager = new CMeshManager(*colladaManager);
}
void tearDown()
{
delete meshManager;
delete colladaManager;
deinitVfs();
}
@ -163,6 +167,18 @@ public:
if (modeldef) TS_ASSERT_STR_EQUALS(modeldef->GetName(), testBase);
}
void test_load_dae_caching()
{
copyFile(srcDAE, testDAE);
CStr daeName1 = colladaManager->GetLoadableFilename(testBase, CColladaManager::PMD);
CStr daeName2 = colladaManager->GetLoadableFilename(testBase, CColladaManager::PMD);
TS_ASSERT(daeName1.length());
TS_ASSERT_STR_EQUALS(daeName1, daeName2);
// TODO: it'd be nice to test that it isn't doing the DAE->PMD conversion
// again, but there doesn't seem to be an easy way to check that
}
void test_load_nonexistent_pmd()
{
CModelDefPtr modeldef = meshManager->GetMesh(testPMD);

6
source/ps/GameSetup/GameSetup.cpp
View File

@ -36,7 +36,6 @@
#include "graphics/MapReader.h"
#include "graphics/MaterialManager.h"
#include "graphics/ParticleEngine.h"
#include "graphics/SkeletonAnimManager.h"
#include "graphics/TextureManager.h"
#include "renderer/Renderer.h"
@ -710,9 +709,6 @@ static void InitRenderer()
// create the material manager
new CMaterialManager;
// create actor related stuff
new CSkeletonAnimManager;
MICROLOG(L"init renderer");
g_Renderer.Open(g_xres,g_yres,g_bpp);
@ -811,8 +807,6 @@ void Shutdown(uint flags)
// destroy actor related stuff
TIMER_BEGIN("shutdown actor stuff");
delete &g_SkelAnimMan;
delete &g_MaterialManager;
TIMER_END("shutdown actor stuff");

10
source/ps/Profile.cpp
View File

@ -372,6 +372,11 @@ void CProfileNode::Frame()
static long get_memory_alloc_count()
{
#if HAVE_VC_DEBUG_ALLOC
// TODO: it's probably better to use _CrtSetAllocHook to increment a
// user-visible counter. (I didn't know that existed when I wrote this.)
// Find the number of allocations that have ever occurred, by doing a dummy
// allocation and checking its request number
static long bias = 0; // so we can subtract the allocations caused by this function
void* p = malloc(1);
long requestNumber = 0;
@ -381,6 +386,9 @@ static long get_memory_alloc_count()
++bias;
return requestNumber - bias;
#else
// TODO: support other compilers if it's easy.
// TODO: don't show this column of data when we don't have sensible values
// to display.
return 0;
#endif
}
@ -450,7 +458,7 @@ void CProfileManager::StartScript( const char* name )
current->Call();
}
const char* CProfileManager::InternString( CStr8 intern )
const char* CProfileManager::InternString( const CStr8& intern )
{
std::map<CStr8, const char*>::iterator it = m_internedStrings.find( intern );
if( it != m_internedStrings.end() )

8
source/ps/Profile.h
View File

@ -134,7 +134,7 @@ public:
// Resets absolutely everything
void StructuralReset();
const char* InternString( CStr8 intern );
const char* InternString( const CStr8& intern );
inline const CProfileNode* GetCurrent() { return( current ); }
inline const CProfileNode* GetRoot() { return( root ); }
@ -150,11 +150,13 @@ class CProfileSample
public:
CProfileSample( const char* name )
{
g_Profiler.Start( name );
if (CProfileManager::IsInitialised())
g_Profiler.Start( name );
}
~CProfileSample()
{
g_Profiler.Stop();
if (CProfileManager::IsInitialised())
g_Profiler.Stop();
}
};

2
source/test_setup.cpp
View File

@ -25,7 +25,7 @@ class LeakReporter : public CxxTest::GlobalFixture
// Send output to stdout as well as the debug window, so it works during
// the normal build process as well as when debugging the test .exe
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE|_CRTDBG_MODE_DEBUG);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDOUT);
#endif

2
source/tools/atlas/AtlasUI/CustomControls/Buttons/ToolButton.cpp
View File

@ -71,7 +71,7 @@ void ToolButtonBar::AddToolButton(const wxString& shortLabel, const wxString& lo
wxFileName iconPath (_T("tools/atlas/toolbar/"));
iconPath.MakeAbsolute(Datafile::GetDataDirectory());
iconPath.SetFullName(iconPNGFilename);
wxFileInputStream fstr (iconPath.GetFullPath());
wxFFileInputStream fstr (iconPath.GetFullPath());
if (! fstr.Ok())
{
wxLogError(_("Failed to open toolbar icon file '%s'"), iconPath.GetFullPath().c_str());

2
source/tools/atlas/AtlasUI/ScenarioEditor/SectionLayout.cpp
View File

@ -86,7 +86,7 @@ public:
wxFileName iconPath (_T("tools/atlas/toolbar/"));
iconPath.MakeAbsolute(Datafile::GetDataDirectory());
iconPath.SetFullName(iconPNGFilename);
wxFileInputStream fstr (iconPath.GetFullPath());
wxFFileInputStream fstr (iconPath.GetFullPath());
if (! fstr.Ok())
{
wxLogError(_("Failed to open toolbar icon file '%s'"), iconPath.GetFullPath().c_str());

2
source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Cinematic/Cinematic.cpp
View File

@ -841,7 +841,7 @@ wxImage CinematicSidebar::LoadIcon(const wxString& filename)
wxFileName iconPath (_T("tools/atlas/buttons/"));
iconPath.MakeAbsolute(Datafile::GetDataDirectory());
iconPath.SetFullName(filename);
wxFileInputStream fstr (iconPath.GetFullPath());
wxFFileInputStream fstr (iconPath.GetFullPath());
if (! fstr.Ok())
{
wxLogError(_("Failed to open cinematic icon file '%s'"), iconPath.GetFullPath().c_str());

7
source/tools/atlas/GameInterface/ActorViewer.cpp
View File

@ -4,11 +4,13 @@
#include "View.h"
#include "graphics/ColladaManager.h"
#include "graphics/Model.h"
#include "graphics/ObjectManager.h"
#include "graphics/Patch.h"
#include "graphics/SkeletonAnim.h"
#include "graphics/SkeletonAnimDef.h"
#include "graphics/SkeletonAnimManager.h"
#include "graphics/Terrain.h"
#include "graphics/TextureEntry.h"
#include "graphics/TextureManager.h"
@ -25,7 +27,8 @@
struct ActorViewerImpl : public Scene, boost::noncopyable
{
ActorViewerImpl()
: Unit(NULL), MeshManager(), ObjectManager(MeshManager)
: Unit(NULL), ColladaManager(), MeshManager(ColladaManager), SkeletonAnimManager(ColladaManager),
ObjectManager(MeshManager, SkeletonAnimManager)
{
}
@ -41,7 +44,9 @@ struct ActorViewerImpl : public Scene, boost::noncopyable
CTerrain Terrain;
CColladaManager ColladaManager;
CMeshManager MeshManager;
CSkeletonAnimManager SkeletonAnimManager;
CObjectManager ObjectManager;
// Simplistic implementation of the Scene interface