mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
334 lines
11 KiB
C++
334 lines
11 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef __RESOURCE_H__
|
|
#define __RESOURCE_H__
|
|
|
|
#ifndef _DATACHUNKER_H_
|
|
#include "core/dataChunker.h"
|
|
#endif
|
|
|
|
#ifndef _PATH_H_
|
|
#include "core/util/path.h"
|
|
#endif
|
|
|
|
#ifndef _REFBASE_H_
|
|
#include "core/util/refBase.h"
|
|
#endif
|
|
|
|
#ifndef _TIMECLASS_H_
|
|
#include "core/util/timeClass.h"
|
|
#endif
|
|
|
|
#ifndef _TSIGNAL_H_
|
|
#include "core/util/tSignal.h"
|
|
#endif
|
|
|
|
#ifndef _PLATFORMASSERT_H_
|
|
#include "platform/platformAssert.h"
|
|
#endif
|
|
|
|
#include <memory>
|
|
|
|
class ResourceManager;
|
|
|
|
// This is a utility class used by the resource manager.
|
|
// The prime responsibility of this class is to delete
|
|
// a resource. The base type is never used, but a template
|
|
// version is always derived that knows how to delete the
|
|
// particular type of resource. Normally, one needs not
|
|
// worry about this class. However, if one wants to delete
|
|
// a particular resource in a special manner, one may
|
|
// override the ResourceHolder<T>::~ResourceHolder method.
|
|
class ResourceHolderBase
|
|
{
|
|
public:
|
|
static FreeListChunker<ResourceHolderBase> smHolderFactory;
|
|
|
|
ResourceHolderBase() = default; // Default constructor
|
|
virtual ~ResourceHolderBase() {}
|
|
|
|
// Return void pointer to resource data.
|
|
void* getResource() const { return mRes.get(); }
|
|
|
|
protected:
|
|
// Construct a resource holder pointing at 'p'.
|
|
template<typename T>
|
|
ResourceHolderBase(T* p) : mRes(p, [](void*) {}) {}
|
|
|
|
std::unique_ptr<void, void(*)(void*)> mRes{ nullptr, [](void*) {} };
|
|
};
|
|
|
|
// All resources are derived from this type. The base type
|
|
// is only instantiated by the resource manager
|
|
// (the resource manager will return a base resource which a
|
|
// derived resource, Resource<T>, will construct itself
|
|
// with). Base class handles locking and unlocking and
|
|
// provides several virtual functions to be defined by
|
|
// derived resource.
|
|
class ResourceBase
|
|
{
|
|
friend class ResourceManager;
|
|
|
|
protected:
|
|
class Header;
|
|
|
|
public:
|
|
typedef U32 Signature;
|
|
|
|
public:
|
|
ResourceBase(Header *header) { mResourceHeader = (header ? header : &smBlank); }
|
|
virtual ~ResourceBase() {}
|
|
|
|
const Torque::Path &getPath() const
|
|
{
|
|
AssertFatal(mResourceHeader != NULL,"ResourceBase::getPath called on invalid resource");
|
|
return mResourceHeader->getPath();
|
|
}
|
|
|
|
U32 getChecksum() const
|
|
{
|
|
AssertFatal(mResourceHeader != NULL,"ResourceBase::getChecksum called on invalid resource");
|
|
return mResourceHeader->getChecksum();
|
|
}
|
|
|
|
protected:
|
|
|
|
typedef void ( *NotifyUnloadFn )( const Torque::Path& path, void* resource );
|
|
|
|
class Header : public StrongRefBase
|
|
{
|
|
public:
|
|
Header()
|
|
: mSignature(0),
|
|
mResource(NULL),
|
|
mNotifyUnload( NULL )
|
|
{
|
|
}
|
|
|
|
const Torque::Path &getPath() const { return mPath; }
|
|
|
|
Signature getSignature() const { return mSignature; }
|
|
void *getResource() const { return (mResource ? mResource->getResource() : NULL); }
|
|
U32 getChecksum() const;
|
|
|
|
void destroySelf() override;
|
|
|
|
private:
|
|
|
|
friend class ResourceBase;
|
|
friend class ResourceManager;
|
|
|
|
Signature mSignature;
|
|
ResourceHolderBase* mResource;
|
|
Torque::Path mPath;
|
|
NotifyUnloadFn mNotifyUnload;
|
|
};
|
|
|
|
protected:
|
|
static Header smBlank;
|
|
ResourceBase() : mResourceHeader(&smBlank) {}
|
|
|
|
StrongRefPtr<Header> mResourceHeader;
|
|
|
|
void assign(const ResourceBase &inResource, void* resource = NULL);
|
|
|
|
// The following functions are virtual, but cannot be pure-virtual
|
|
// because we need to be able to instantiate this class.
|
|
|
|
// To be defined by derived class. Creates a resource
|
|
// holder of the desired type. Resource template handles
|
|
// this, so one should never need to override.
|
|
virtual ResourceHolderBase *createHolder(void *)
|
|
{
|
|
AssertFatal(0,"ResourceBase::createHolder: should not be called");
|
|
return NULL;
|
|
}
|
|
|
|
// Create a Resource of desired type using passed path. Derived
|
|
// resource class must define this.
|
|
virtual void *create(const Torque::Path &path)
|
|
{
|
|
AssertFatal(0,"ResourceBase::create: should not be called");
|
|
return NULL;
|
|
}
|
|
|
|
// Return signature for desired type.
|
|
virtual Signature getSignature() const
|
|
{
|
|
return mResourceHeader->getSignature();
|
|
}
|
|
|
|
virtual Signal<bool(const Torque::Path &, void**)> &getStaticLoadSignal()
|
|
{
|
|
AssertFatal(0,"ResourceBase::getStaticLoadSignal: should not be called");
|
|
static Signal<bool(const Torque::Path &, void**)> sLoadSignal;
|
|
|
|
return sLoadSignal;
|
|
}
|
|
|
|
virtual void _triggerPostLoadSignal() {}
|
|
virtual NotifyUnloadFn _getNotifyUnloadFn() { return ( NotifyUnloadFn ) NULL; }
|
|
};
|
|
|
|
// This is a utility class used by resource manager. Classes derived
|
|
// from this template pretty much just know how to delete the template's
|
|
// type.
|
|
template<class T>
|
|
class ResourceHolder : public ResourceHolderBase
|
|
{
|
|
public:
|
|
ResourceHolder(T* t) : ResourceHolderBase(t) {}
|
|
virtual ~ResourceHolder() {
|
|
if (mRes) {
|
|
T* typedmRes = static_cast<T*>(mRes.get());
|
|
typedmRes->~T(); // Call the destructor explicitly
|
|
}
|
|
}
|
|
};
|
|
|
|
// Resource template. When dealing with resources, this is the
|
|
// class that will be used. One creates resources by opening or
|
|
// creating them via the resource manager. The resource manager
|
|
// returns ResourceBases, which can be used to construct any
|
|
// type of resource (see the constructors for this template).
|
|
// When instantiating classes using this template, it is always
|
|
// necessary to define the create and getSignature methods.
|
|
// The createMethod will be responsible for loading a resource
|
|
// from disk using passed path.
|
|
template<class T> class Resource : public ResourceBase
|
|
{
|
|
public:
|
|
Resource() {}
|
|
Resource(const ResourceBase &base) { assign(base); }
|
|
|
|
void operator=(const ResourceBase & base) { assign(base); }
|
|
T* operator->() { return getResource(); }
|
|
T& operator*() { return *getResource(); }
|
|
operator T*() { return getResource(); }
|
|
const T* operator->() const { return getResource(); }
|
|
const T& operator*() const { return *getResource(); }
|
|
operator const T*() const { return getResource(); }
|
|
|
|
void setResource(const ResourceBase & base, void* resource) { assign(base, resource); }
|
|
|
|
static Signature signature();
|
|
|
|
/// Registering with this signal will give an opportunity to handle resource
|
|
/// creation before calling the create() function. This may be used to handle
|
|
/// file extensions differently and allow a more plugin-like approach to
|
|
/// adding resources. Using this mechanism, one could, for example, override
|
|
/// the default methods for loading DTS without touching the main source.
|
|
static Signal<bool(const Torque::Path &, void**)> &getLoadSignal()
|
|
{
|
|
static Signal<bool(const Torque::Path &, void**)> sLoadSignal;
|
|
return sLoadSignal;
|
|
}
|
|
|
|
/// Register with this signal to get notified when resources of this type
|
|
/// have been loaded.
|
|
static Signal< void( Resource< T >& ) >& getPostLoadSignal()
|
|
{
|
|
static Signal< void( Resource< T >& ) > sPostLoadSignal;
|
|
return sPostLoadSignal;
|
|
}
|
|
|
|
/// Register with this signal to get notified when resources of this type
|
|
/// are about to get unloaded.
|
|
static Signal< void( const Torque::Path&, T* ) >& getUnloadSignal()
|
|
{
|
|
static Signal< void( const Torque::Path&, T* ) > sUnloadSignal;
|
|
return sUnloadSignal;
|
|
}
|
|
|
|
private:
|
|
T *getResource() { return (T*)mResourceHeader->getResource(); }
|
|
const T *getResource() const { return (T*)mResourceHeader->getResource(); }
|
|
|
|
Signature getSignature() const override { return Resource<T>::signature(); }
|
|
|
|
ResourceHolderBase *createHolder(void *) override;
|
|
|
|
Signal<bool(const Torque::Path &, void**)> &getStaticLoadSignal() override { return getLoadSignal(); }
|
|
|
|
static void _notifyUnload( const Torque::Path& path, void* resource ) { getUnloadSignal().trigger( path, ( T* ) resource ); }
|
|
|
|
void _triggerPostLoadSignal() override { getPostLoadSignal().trigger( *this ); }
|
|
NotifyUnloadFn _getNotifyUnloadFn() override { return ( NotifyUnloadFn ) &_notifyUnload; }
|
|
|
|
// These are to be define by instantiated resources
|
|
// No generic version is provided...however, since
|
|
// base resources are instantiated by resource manager,
|
|
// these are not pure virtuals if undefined (but will assert)...
|
|
void *create(const Torque::Path &path) override;
|
|
};
|
|
|
|
|
|
template<class T> inline ResourceHolderBase *Resource<T>::createHolder(void *ptr)
|
|
{
|
|
ResourceHolder<T> *resHolder = (ResourceHolder<T>*)(ResourceHolderBase::smHolderFactory.alloc());
|
|
|
|
resHolder = constructInPlace(resHolder,(T*)ptr);
|
|
|
|
return resHolder;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Load Signal Hooks.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/// This template may be used to register a load signal as follows:
|
|
/// static ResourceRegisterLoadSignal<T> sgAuto( staticLoadFunction );
|
|
template <class T>
|
|
class ResourceRegisterLoadSignal
|
|
{
|
|
public:
|
|
ResourceRegisterLoadSignal( Delegate<bool(const Torque::Path &, void **)> func )
|
|
{
|
|
Resource<T>::getLoadSignal().notify( func );
|
|
}
|
|
};
|
|
|
|
template< class T >
|
|
class ResourceRegisterPostLoadSignal
|
|
{
|
|
public:
|
|
|
|
ResourceRegisterPostLoadSignal( Delegate< void( Resource< T >& ) > func )
|
|
{
|
|
Resource< T >::getPostLoadSignal().notify( func );
|
|
}
|
|
};
|
|
|
|
template< class T >
|
|
class ResourceRegisterUnloadSignal
|
|
{
|
|
public:
|
|
|
|
ResourceRegisterUnloadSignal( Delegate< void( const Torque::Path&, T* ) > func )
|
|
{
|
|
Resource< T >::getUnloadSignal().notify( func );
|
|
}
|
|
};
|
|
|
|
#endif // __RESOURCE_H__
|