internal PLATFORM_READ_DATA_FROM_FILE(SDLReadDataFromFile) {
if (PlatformNoFileErrors(Source)) {
sdl_platform_file_handle *SDLFileHandle = (sdl_platform_file_handle *)Source->Platform;
if (pread(SDLFileHandle->FD, Dest, Size, Offset) != (ssize_t)Size) {
SDLFileError(Source, "Read file failed.");
}
}
}
void RawLoadAssetWork(loadAssetWork_s* lawData)
{
Platform.readDataFromFile(lawData->handle, lawData->offset, lawData->size, lawData->destination);
WRITE_BARRIER;
if(PlatformNoFileErrors(lawData->handle))
{
SetSlotState(lawData->slot, (assetState_e) lawData->finalState);
SetLockedState(lawData->slot, (assetState_e) lawData->lockState);
}
else
{
SetSlotState(lawData->slot, assetState_unloaded);
ZeroSetMem(lawData->destination, lawData->size);
}
EndTaskWithMemory(lawData->task);
}
assets_s* AllocateAssets(memoryBlock_s* memoryBlock)
{
assets_s* assets = PushStruct(memoryBlock, assets_s);
assets->assetUseQueue = InitLinkedList(memoryBlock, Kilobytes(2));
assets->dyMemoryBlock = InitDynamicMemoryBlock(memoryBlock, Megabytes(64), Kilobytes(10));
assets->tagCount = 1;
assets->assetCount = 1;
platformFileGroup_s* fileGroup = Platform.getAllFilesOfTypeBegin("wa");
assets->fileCount = fileGroup->fileCount;
assets->files = PushArray(memoryBlock, assets->fileCount, assetFile_s);
for(uint32_t index = 0; index < assets->fileCount; index++)
{
assetFile_s* file = assets->files + index;
file->tagBase = assets->tagCount;
file->handle = Platform.openNextFile(fileGroup);
file->header = {};
Platform.readDataFromFile(file->handle, 0, sizeof(file->header), &file->header);
uint32_t assetTypeArraySize = file->header.assetTypesCount*sizeof(waAssetType_s);
file->assetTypeArray = (waAssetType_s*) PushSize(memoryBlock, assetTypeArraySize);
Platform.readDataFromFile(file->handle, file->header.assetTypes, assetTypeArraySize,
file->assetTypeArray);
if(PlatformNoFileErrors(file->handle))
{
if(file->header.magicValue != MAGIC_VALUE)
{
Platform.fileError(file->handle, "wa file has an invalid magic value");
}
if(file->header.version > WALLACE_ASSET_VERSION)
{
Platform.fileError(file->handle, "wa file has a version which exceeds game version");
}
if(PlatformNoFileErrors(file->handle))
{
// NOTE: The first asset and tag slot in every
// .wa is a null (reserved) so we don't count it as
// something we will need space for!
assets->tagCount += (file->header.tagCount - 1);
assets->assetCount += (file->header.assetCount - 1);
}
}
else
{
InvalidCodePath;
}
}
Platform.getAllFilesOfTypeEnd(fileGroup);
assets->assets = PushArray(memoryBlock, assets->assetCount, assetFileData_s);
assets->slots = PushArray(memoryBlock, assets->assetCount, assetData_s);
assets->tags = PushArray(memoryBlock, assets->tagCount, waTag_s);
assets->tags[0] = {};
for(uint32_t fileIndex = 0; fileIndex < assets->fileCount; fileIndex++)
{
assetFile_s* file = assets->files + fileIndex;
if(PlatformNoFileErrors(file->handle))
{
uint32_t tagArraySize = sizeof(waTag_s) * (file->header.tagCount - 1);
Platform.readDataFromFile(file->handle, file->header.tags + sizeof(waTag_s), tagArraySize,
assets->tags + file->tagBase);
}
}
// NOTE: Reserve one null asset at the beginning
uint32_t assetCount = 0;
assets->assets[assetCount] = {};
assetCount++;
for(uint32_t destTypeId = 0; destTypeId < assetType_last; destTypeId++)
{
waAssetType_s* destType = assets->assetTypes + destTypeId;
destType->firstAssetIndex = assetCount;
for(uint32_t fileIndex = 0; fileIndex < assets->fileCount; fileIndex++)
{
assetFile_s* file = assets->files + fileIndex;
if(PlatformNoFileErrors(file->handle))
{
for(uint32_t sourceIndex = 0; sourceIndex < file->header.assetTypesCount; sourceIndex++)
{
waAssetType_s* sourceType = file->assetTypeArray + sourceIndex;
if(sourceType->typeId == destTypeId)
{
uint32_t assetCountForType = sourceType->onePastLastAssetIndex -
sourceType->firstAssetIndex;
temporaryMemory_s tempMem = BeginTemporaryMemory(memoryBlock);
waAssetFileData_s* waAssetArray = PushArray(memoryBlock, assetCountForType, waAssetFileData_s);
Platform.readDataFromFile(file->handle, file->header.assets +
sourceType->firstAssetIndex * sizeof(waAssetFileData_s),
assetCountForType * sizeof(waAssetFileData_s), waAssetArray);
for(uint32_t assetIndex = 0; assetIndex < assetCountForType; assetIndex++)
{
waAssetFileData_s* waAsset = waAssetArray + assetIndex;
// Assert(assetCount < assets->assetCount);
assetFileData_s* asset = assets->assets + assetCount++;
asset->fileIndex = fileIndex;
asset->wa = *waAsset;
if(asset->wa.firstTagIndex == 0)
{
asset->wa.firstTagIndex = 0;
asset->wa.onePastLastTagIndex = 0;
}
else
{
asset->wa.firstTagIndex += (file->tagBase - 1);
asset->wa.onePastLastTagIndex += (file->tagBase - 1);
}
}
EndTemporaryMemory(tempMem);
}
}
}
}
destType->onePastLastAssetIndex = assetCount;
}
// Assert(assetCount == assets->assetCount);
return assets;
}
