//--------------------------------------------------------------------------
void VeAudioSampleData::ParseWave(VeBinaryIStream& kInput)
{
VeWaveFileHeader kHeader;
VE_ASSERT_EQ(kInput.Read(&kHeader, 12), 12);
VE_ASSERT((!VeStrnicmp(kHeader.m_ac8Riff, "RIFF", 4)) && (!VeStrnicmp(kHeader.m_ac8Wave, "WAVE", 4)));
VeRiffChunk kChunk;
while(kInput.Read(&kChunk, 8) == 8)
{
if(!VeStrnicmp(kChunk.m_ac8ChunkName, "fmt ", 4))
{
VeWaveFormat kFormat;
VE_ASSERT_EQ(kInput.Read(&kFormat, kChunk.m_u32ChunkSize), VeInt32(kChunk.m_u32ChunkSize));
VE_ASSERT(kFormat.m_u16FormatTag == 1);
m_u32ChannelNum = kFormat.m_u16Channels;
m_u32SampleRate = kFormat.m_u32SamplesPerSec;
m_u32BitsPerSample = kFormat.m_u16BitsPerSample;
}
else if(!VeStrnicmp(kChunk.m_ac8ChunkName, "data", 4))
{
m_spData = VE_NEW VeBlob(kChunk.m_u32ChunkSize);
VE_ASSERT_EQ(kInput.Read(*m_spData, kChunk.m_u32ChunkSize), VeInt32(kChunk.m_u32ChunkSize));
}
else
{
kInput.Skip(kChunk.m_u32ChunkSize);
}
if (kChunk.m_u32ChunkSize & 1)
{
kInput.Skip(1);
}
}
}
//--------------------------------------------------------------------------
VeFilePath::ReadTask::ReadTask(const VeChar8* pcFullPath,
VeRefNode<ReadCallback>& kCallback) noexcept
: m_kFullPath(pcFullPath)
{
IncRefCount();
m_kNode.m_Content = this;
ve_sys.Collect(m_kNode);
m_kCallback.attach_back(kCallback);
m_kTask.m_Content = [this](VeTaskQueue& kMgr) noexcept
{
if (VE_SUCCEEDED(VeAccess(m_kFullPath, ACCESS_R_OK)))
{
FILE* pkFile(nullptr);
# ifdef VE_PLATFORM_WIN
fopen_s(&pkFile, m_kFullPath, "rb");
# else
pkFile = fopen(m_kFullPath, "rb");
# endif
if (pkFile)
{
fseek(pkFile, 0, SEEK_END);
VeSizeT stLen = ftell(pkFile);
fseek(pkFile, 0, SEEK_SET);
VeBlobPtr spBlob = VE_NEW VeBlob(stLen);
VeSizeT stRead = fread(spBlob->GetBuffer(), 1, stLen, pkFile);
fclose(pkFile);
if (stRead == stLen)
{
m_spData = VE_NEW VeMemoryIStream(spBlob);
}
}
}
m_kTask.m_Content = [this](VeTaskQueue& kMgr) noexcept
{
for (auto call : m_kCallback)
{
call(m_spData);
}
DecRefCount();
};
kMgr.AddFGTask(m_kTask);
};
ve_res_mgr.GetTaskQueue(VeResourceManager::TASK_FILE).AddBGTask(m_kTask);
}
//--------------------------------------------------------------------------
VeSurfacePtr VeSurface::CreateRGBSurface(VeUInt32 u32Flags,
VeInt32 i32Width, VeInt32 i32Height, VeInt32 i32Depth,
VeUInt32 u32Rmask, VeUInt32 u32Gmask, VeUInt32 u32Bmask,
VeUInt32 u32Amask) noexcept
{
VeUInt32 u32Format = VeMasksToPixelFormatEnum(i32Depth, u32Rmask,
u32Gmask, u32Bmask, u32Amask);
if (u32Format == VE_PIXELFORMAT_UNKNOWN) return nullptr;
VeSurfacePtr spSurface = VE_NEW VeSurface();
VE_ASSERT(spSurface);
spSurface->m_spFormat = VePixelFormat::Create(u32Format);
if (!spSurface->m_spFormat) return nullptr;
spSurface->m_i32Width = i32Width;
spSurface->m_i32Height = i32Height;
spSurface->m_i32Pitch = spSurface->CalculatePitch();
if (VE_ISPIXELFORMAT_INDEXED(spSurface->m_spFormat->m_u32Format))
{
VePalettePtr spPattle = VE_NEW VePalette((1 << spSurface->m_spFormat->m_u8BitsPerPixel));
VE_ASSERT(spPattle);
if (spPattle->m_kColors.size() == 2)
{
spPattle->m_kColors[0].r() = 0xFF;
spPattle->m_kColors[0].g() = 0xFF;
spPattle->m_kColors[0].b() = 0xFF;
spPattle->m_kColors[1].r() = 0x00;
spPattle->m_kColors[1].g() = 0x00;
spPattle->m_kColors[1].b() = 0x00;
}
spSurface->SetPalette(spPattle);
}
if (spSurface->m_i32Width && spSurface->m_i32Height)
{
VeSizeT stSize = spSurface->m_i32Height * spSurface->m_i32Pitch;
spSurface->m_spPixels = VE_NEW VeBlob(stSize);
VeZeroMemory(*spSurface->m_spPixels, stSize);
}
return spSurface;
}
//--------------------------------------------------------------------------
VeAssetPath::ReadTask::ReadTask(const VeChar8* pcFullPath,
VeRefNode<ReadCallback>& kCallback) noexcept
: m_kFullPath(pcFullPath)
{
IncRefCount();
m_kNode.m_Content = this;
ve_sys.Collect(m_kNode);
m_kCallback.attach_back(kCallback);
m_kTask.m_Content = [this](VeTaskQueue& kMgr) noexcept
{
AAsset* pkAsset = AAssetManager_open(s_pkAssetManager,
m_kFullPath, AASSET_MODE_UNKNOWN);
if (pkAsset)
{
VeInt32 i32Len = AAsset_getLength(pkAsset);
if (i32Len)
{
VeBlobPtr spBlob = VE_NEW VeBlob(i32Len);
VeInt32 i32Read = AAsset_read(pkAsset,
spBlob->GetBuffer(), i32Len);
if (i32Read == i32Len)
{
m_spData = VE_NEW VeMemoryIStream(spBlob);
}
}
AAsset_close(pkAsset);
}
m_kTask.m_Content = [this](VeTaskQueue& kMgr) noexcept
{
for (auto call : m_kCallback)
{
call(m_spData);
}
DecRefCount();
};
kMgr.AddFGTask(m_kTask);
};
ve_res_mgr.GetTaskQueue(VeResourceManager::TASK_FILE).AddBGTask(m_kTask);
}
//--------------------------------------------------------------------------
VeBlobPtr ParseDDS(VeTexture::FileInfo& kOut,
VeMemoryIStream& kIn) noexcept
{
if (kIn.RemainingLength() < sizeof(DDS_HEADER)) return nullptr;
DDS_HEADER* pkHeader = kIn.To<DDS_HEADER>();
if (pkHeader->m_u32Size != sizeof(DDS_HEADER) ||
pkHeader->m_kFormat.m_u32Size != sizeof(DDS_PIXELFORMAT)) return nullptr;
DDS_HEADER_DXT10* pkHeader10 = nullptr;
if ((pkHeader->m_kFormat.m_u32Flags & DDS_FOURCC)
&& (VE_FOURCC('D', 'X', '1', '0') == pkHeader->m_kFormat.m_u32FourCC))
{
if (kIn.RemainingLength() < sizeof(DDS_HEADER_DXT10)) return nullptr;
pkHeader10 = kIn.To<DDS_HEADER_DXT10>();
}
VeUInt32 u32Width = pkHeader->m_u32Width;
VeUInt32 u32Height = pkHeader->m_u32Height;
VeUInt32 u32Depth = pkHeader->m_u32Depth;
VeRenderResource::Dimension eResDim = VeRenderResource::DIMENSION_UNKNOWN;
VeUInt32 u32ArraySize = 1;
VeRenderResource::Format eFormat = VeRenderResource::FORMAT_UNKNOWN;
bool bIsCubeMap = false;
VeUInt32 u32MipCount = pkHeader->m_u32MipMapCount ? pkHeader->m_u32MipMapCount : 1;
if (pkHeader10)
{
u32ArraySize = pkHeader10->m_u32ArraySize;
if (u32ArraySize == 0) return nullptr;
switch (pkHeader10->m_eFormat)
{
case VeRenderResource::FORMAT_AI44:
case VeRenderResource::FORMAT_IA44:
case VeRenderResource::FORMAT_P8:
case VeRenderResource::FORMAT_A8P8:
return nullptr;
default:
if (VeRenderResource::BitsPerPixel(pkHeader10->m_eFormat) == 0)
{
return nullptr;
}
}
eFormat = pkHeader10->m_eFormat;
switch (pkHeader10->m_eResourceDimension)
{
case VeRenderResource::DIMENSION_TEXTURE1D:
if ((pkHeader->m_u32Flags & DDS_HEIGHT) && u32Height != 1)
{
return nullptr;
}
u32Height = u32Depth = 1;
break;
case VeRenderResource::DIMENSION_TEXTURE2D:
if (pkHeader10->m_u32MiscFlag & RESOURCE_MISC_TEXTURECUBE)
{
u32ArraySize *= 6;
bIsCubeMap = true;
}
u32Depth = 1;
break;
case VeRenderResource::DIMENSION_TEXTURE3D:
if (!(pkHeader->m_u32Flags & DDS_HEADER_FLAGS_VOLUME))
{
return nullptr;
}
if (u32ArraySize > 1)
{
return nullptr;
}
break;
default:
return nullptr;
}
eResDim = pkHeader10->m_eResourceDimension;
}
else
{
eFormat = GetDXGIFormat(pkHeader->m_kFormat);
if (eFormat == VeRenderResource::FORMAT_UNKNOWN)
{
return nullptr;
}
if (pkHeader->m_u32Flags & DDS_HEADER_FLAGS_VOLUME)
{
eResDim = VeRenderResource::DIMENSION_TEXTURE3D;
}
else
{
if (pkHeader->m_u32Caps2 & DDS_CUBEMAP)
{
if ((pkHeader->m_u32Caps2 & DDS_CUBEMAP_ALLFACES) != DDS_CUBEMAP_ALLFACES)
{
return nullptr;
}
u32ArraySize = 6;
bIsCubeMap = true;
}
u32Depth = 1;
eResDim = VeRenderResource::DIMENSION_TEXTURE2D;
}
VE_ASSERT(VeRenderResource::BitsPerPixel(eFormat) != 0);
}
if (u32MipCount > REQ_MIP_LEVELS)
{
return nullptr;
}
switch (eResDim)
{
case VeRenderResource::DIMENSION_TEXTURE1D:
if ((u32ArraySize > REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION) ||
(u32Width > REQ_TEXTURE1D_U_DIMENSION))
{
return nullptr;
}
break;
case VeRenderResource::DIMENSION_TEXTURE2D:
if (bIsCubeMap)
{
if ((u32ArraySize > REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION) ||
(u32Width > REQ_TEXTURECUBE_DIMENSION) ||
(u32Height > REQ_TEXTURECUBE_DIMENSION))
{
return nullptr;
}
}
else if ((u32ArraySize > REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION) ||
(u32Width > REQ_TEXTURE2D_U_OR_V_DIMENSION) ||
(u32Height > REQ_TEXTURE2D_U_OR_V_DIMENSION))
{
return nullptr;
}
break;
case VeRenderResource::DIMENSION_TEXTURE3D:
if ((u32ArraySize > 1) ||
(u32Width > REQ_TEXTURE3D_U_V_OR_W_DIMENSION) ||
(u32Height > REQ_TEXTURE3D_U_V_OR_W_DIMENSION) ||
(u32Depth > REQ_TEXTURE3D_U_V_OR_W_DIMENSION))
{
return nullptr;
}
break;
default:
return nullptr;
}
if (u32Depth != 1 && u32ArraySize != 1) return nullptr;
kOut.m_eDimension = eResDim;
kOut.m_eFormat = eFormat;
kOut.m_u32Width = u32Width;
kOut.m_u32Height = u32Height;
kOut.m_u16Depth = (VeUInt16)(u32Depth * u32ArraySize);
kOut.m_u16MipLevels = (VeUInt16)u32MipCount;
kOut.m_bIsCube = bIsCubeMap;
VeSizeT stDataSize = kIn.RemainingLength();
void* pvData = kIn.Skip(stDataSize);
return VE_NEW VeBlob(pvData, stDataSize);
}
//--------------------------------------------------------------------------
VeBlobWriter::VeBlobWriter() noexcept
{
m_spBlob = VE_NEW VeBlob();
}
