const void * ResCache::Load(const Resource & r)
{
	// Note: Change Post-printing
	//
	// Graphic resources are loaded differently, since the tool that created them (Ipac)
	// added some data to grab any sequence of frames - not just the whole thing.
	// 
	// Added an optional<int> &len in case we wanted to return the
	// length of the resource in bytes.

	int size = m_file->VGetResourceSize(r);
	char *buffer = Allocate(size);
	if (buffer==NULL)
	{
		return NULL;		// ResCache is out of memory!
	}

	memset(buffer,0,sizeof(buffer));
	// Create a new resource and add it to the lru list and map
	ResHandle *handle = SAFE_NEW ResHandle(r, buffer);
	m_lru.push_front(handle);
	m_resources[r.m_name] = handle;

	m_file->VGetResource(r, buffer);

	return buffer;
}
示例#2
0
//************************************
// Method:    VCreateHandle
// FullName:  Resource::VCreateHandle
// Access:    virtual public 
// Returns:   ResHandle *
// Qualifier:
// Parameter: const char * buffer
// Parameter: unsigned int size
// Parameter: ResCache * pResCache
//************************************
ResHandle *Resource::VCreateHandle(const char *buffer, unsigned int size, ResCache *pResCache)
{
	return DEBUG_CLIENTBLOCK ResHandle(*this, (char*)buffer, size, pResCache);
}
示例#3
0
	ResHandle* ResCache::Load(Resource* resource, IResourceFile *file)
	{
		// Create a new resource and add it to the lru list and map

		IResourceLoader* loader;
		ResHandle* handle;

		for (ResourceLoaders::iterator it = m_resourceLoaders.begin(); it != m_resourceLoaders.end(); ++it)
		{
			IResourceLoader* testLoader = *it;

			if (WildcardMatch(testLoader->VGetPattern().c_str(), resource->m_name.c_str()))
			{
				loader = testLoader;
				break;
			}
		}

		if (!loader)
		{
			//GCC_ASSERT(loader && _T("Default resource loader not found!"));
			return handle;		// Resource not loaded!
		}

		int rawSize = m_file->GetRawResourceSize(*resource);
		if (rawSize < 0)
		{
			//GCC_ASSERT(rawSize > 0 && "Resource size returned -1 - Resource not found");
			return nullptr;
		}

		int allocSize = rawSize + ((loader->VAddNullZero()) ? (1) : (0));
	
		char* rawBuffer;
		if (loader->VUseRawFile())
		{
			rawBuffer = Allocate(allocSize);
		}
		else
		{
			rawBuffer = NEW char[allocSize];
		}
		memset(rawBuffer, 0, allocSize);

		if (rawBuffer == NULL || m_file->GetRawResource(*resource, rawBuffer) == 0)
		{
			// resource cache out of memory
			return nullptr;
		}

		char* buffer = NULL;
		unsigned int size = 0;

		if (loader->VUseRawFile())
		{
			buffer = rawBuffer;
			handle = NEW ResHandle(*resource, buffer, rawSize, this);
		}
		else
		{
			size = loader->VGetLoadedResourceSize(rawBuffer, rawSize);
			buffer = Allocate(size);
			if (rawBuffer == NULL || buffer == NULL)
			{
				// resource cache out of memory
				return nullptr;
			}
			handle = NEW ResHandle(*resource, buffer, size, this);
			bool success = loader->VLoadResource(rawBuffer, rawSize, handle);

			if (loader->VDiscardRawBufferAfterLoad())
			{
				SAFE_DELETE_ARRAY(rawBuffer);
			}

			if (!success)
			{
				// resource cache out of memory
				return nullptr;
			}
		}

		if (handle)
		{
			m_lruResources.push_front(handle);
			m_resources[resource->m_name] = handle;
		}

		//JB_ASSERT(loader && _T("Default resource loader not found!"));
		return handle;		// ResCache is out of memory!
	}
示例#4
0
//
// ResCache::Load								- Chapter 8, page 228-230
//
shared_ptr<ResHandle> ResCache::Load(Resource *r)
{
	// Create a new resource and add it to the lru list and map

	shared_ptr<IResourceLoader> loader;
	shared_ptr<ResHandle> handle;

	for (ResourceLoaders::iterator it = m_resourceLoaders.begin(); it != m_resourceLoaders.end(); ++it)
	{
		shared_ptr<IResourceLoader> testLoader = *it;

		if (WildcardMatch(testLoader->VGetPattern().c_str(), r->m_name.c_str()))
		{
			loader = testLoader;
			break;
		}
	}

	if (!loader)
	{
		GCC_ASSERT(loader && _T("Default resource loader not found!"));
		return handle;		// Resource not loaded!
	}

	int rawSize = m_file->VGetRawResourceSize(*r);
	if (rawSize < 0)
	{
		GCC_ASSERT(rawSize > 0 && "Resource size returned -1 - Resource not found");
		return shared_ptr<ResHandle>();
	}

    int allocSize = rawSize + ((loader->VAddNullZero()) ? (1) : (0));
	char *rawBuffer = loader->VUseRawFile() ? Allocate(allocSize) : GCC_NEW char[allocSize];
    memset(rawBuffer, 0, allocSize);

	if (rawBuffer==NULL || m_file->VGetRawResource(*r, rawBuffer)==0)
	{
		// resource cache out of memory
		return shared_ptr<ResHandle>();
	}
	
	char *buffer = NULL;
	unsigned int size = 0;

	if (loader->VUseRawFile())
	{
		buffer = rawBuffer;
		handle = shared_ptr<ResHandle>(GCC_NEW ResHandle(*r, buffer, rawSize, this));
	}
	else
	{
		size = loader->VGetLoadedResourceSize(rawBuffer, rawSize);
        buffer = Allocate(size);
		if (rawBuffer==NULL || buffer==NULL)
		{
			// resource cache out of memory
			return shared_ptr<ResHandle>();
		}
		handle = shared_ptr<ResHandle>(GCC_NEW ResHandle(*r, buffer, size, this));
		bool success = loader->VLoadResource(rawBuffer, rawSize, handle);
		
		// [mrmike] - This was added after the chapter went to copy edit. It is used for those
		//            resoruces that are converted to a useable format upon load, such as a compressed
		//            file. If the raw buffer from the resource file isn't needed, it shouldn't take up
		//            any additional memory, so we release it.
		//
		if (loader->VDiscardRawBufferAfterLoad())
		{
			SAFE_DELETE_ARRAY(rawBuffer);
		}

		if (!success)
		{
			// resource cache out of memory
			return shared_ptr<ResHandle>();
		}
	}

	if (handle)
	{
		m_lru.push_front(handle);
		m_resources[r->m_name] = handle;
	}

	GCC_ASSERT(loader && _T("Default resource loader not found!"));
	return handle;		// ResCache is out of memory!
}