Use template versions of IDataBlob::GetDataPtr and IDataBlob::GetConstDataPtr methods

TheMostDiligent · TheMostDiligent · commit dea46277cf21 · 2024-10-29T13:38:28.000-07:00
diff --git a/AssetLoader/interface/DXSDKMeshLoader.hpp b/AssetLoader/interface/DXSDKMeshLoader.hpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -331,7 +331,7 @@ class DXSDKMesh
     virtual ~DXSDKMesh();
 
     bool Create(const Char* szFileName);
-    bool Create(Uint8* pData, Uint32 DataUint8s);
+    bool Create(const Uint8* pData, Uint32 DataUint8s);
     void LoadGPUResources(const Char* ResourceDirectory, IRenderDevice* pDevice, IDeviceContext* pDeviceCtx);
     void Destroy();
 
@@ -400,8 +400,7 @@ class DXSDKMesh
 protected:
     bool CreateFromFile(const char* szFileName);
 
-    bool CreateFromMemory(Uint8* pData,
-                          Uint32 DataUint8s);
+    bool CreateFromMemory(const Uint8* pData, Uint32 DataUint8s);
 
     void ComputeBoundingBoxes();
 
diff --git a/AssetLoader/src/DXSDKMeshLoader.cpp b/AssetLoader/src/DXSDKMeshLoader.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -56,8 +56,7 @@ bool DXSDKMesh::CreateFromFile(const char* szFileName)
 
     File.Close();
 
-    auto res = CreateFromMemory(reinterpret_cast<Uint8*>(pFileData->GetDataPtr()),
-                                static_cast<Uint32>(pFileData->GetSize()));
+    auto res = CreateFromMemory(pFileData->GetConstDataPtr<Uint8>(), static_cast<Uint32>(pFileData->GetSize()));
 
     return res;
 }
@@ -103,8 +102,7 @@ void DXSDKMesh::ComputeBoundingBoxes()
     }
 }
 
-bool DXSDKMesh::CreateFromMemory(Uint8* pData,
-                                 Uint32 DataUint8s)
+bool DXSDKMesh::CreateFromMemory(const Uint8* pData, Uint32 DataUint8s)
 {
     m_StaticMeshData.resize(DataUint8s);
     memcpy(m_StaticMeshData.data(), pData, DataUint8s);
@@ -281,7 +279,7 @@ bool DXSDKMesh::Create(const Char* szFileName)
 }
 
 //--------------------------------------------------------------------------------------
-bool DXSDKMesh::Create(Uint8* pData, Uint32 DataUint8s)
+bool DXSDKMesh::Create(const Uint8* pData, Uint32 DataUint8s)
 {
     return CreateFromMemory(pData, DataUint8s);
 }
diff --git a/HLSL2GLSLConverter/src/HLSL2GLSLConverterApp.cpp b/HLSL2GLSLConverter/src/HLSL2GLSLConverterApp.cpp
@@ -164,7 +164,7 @@ int HLSL2GLSLConverterApp::Convert(IRenderDevice* pDevice)
     }
     auto pHLSLSourceBlob = DataBlobImpl::Create();
     pInputFileStream->ReadBlob(pHLSLSourceBlob);
-    auto* HLSLSource = reinterpret_cast<char*>(pHLSLSourceBlob->GetDataPtr());
+    char* HLSLSource = pHLSLSourceBlob->GetDataPtr<char>();
     auto  SourceLen  = static_cast<Int32>(pHLSLSourceBlob->GetSize());
 
     RefCntAutoPtr<IHLSL2GLSLConverter> pConverter;
@@ -208,7 +208,7 @@ int HLSL2GLSLConverterApp::Convert(IRenderDevice* pDevice)
         ShaderCreateInfo ShaderCI;
         ShaderCI.EntryPoint     = m_EntryPoint.c_str();
         ShaderCI.Desc           = {"Test shader", m_ShaderType, true};
-        ShaderCI.Source         = reinterpret_cast<const char*>(pGLSLSourceBlob->GetConstDataPtr());
+        ShaderCI.Source         = pGLSLSourceBlob->GetConstDataPtr<char>();
         ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_GLSL;
         RefCntAutoPtr<IShader> pTestShader;
         pDevice->CreateShader(ShaderCI, &pTestShader);
@@ -222,7 +222,7 @@ int HLSL2GLSLConverterApp::Convert(IRenderDevice* pDevice)
 
     if (m_PrintConvertedSource)
     {
-        LOG_INFO_MESSAGE("Converted GLSL:\n", reinterpret_cast<const char*>(pGLSLSourceBlob->GetConstDataPtr()));
+        LOG_INFO_MESSAGE("Converted GLSL:\n", pGLSLSourceBlob->GetConstDataPtr<char>());
     }
 
     return 0;
diff --git a/RenderStateNotation/src/RenderStateNotationParserImpl.cpp b/RenderStateNotation/src/RenderStateNotationParserImpl.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -302,7 +302,7 @@ Bool RenderStateNotationParserImpl::ParseFileInternal(const Char*
             auto pFileData = DataBlobImpl::Create();
             pFileStream->ReadBlob(pFileData);
 
-            if (!ParseStringInternal(static_cast<const char*>(pFileData->GetConstDataPtr()), StaticCast<Uint32>(pFileData->GetSize()), pStreamFactory))
+            if (!ParseStringInternal(pFileData->GetConstDataPtr<char>(), StaticCast<Uint32>(pFileData->GetSize()), pStreamFactory))
                 LOG_ERROR_AND_THROW("Failed to parse file: '", FilePath, "'.");
         }
 
diff --git a/RenderStatePackager/src/ParsingEnvironment.cpp b/RenderStatePackager/src/ParsingEnvironment.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -94,7 +94,7 @@ bool ParsingEnvironment::Initialize()
             auto pFileData = DataBlobImpl::Create(0);
             File->Read(pFileData);
 
-            ParseRSNDeviceCreateInfo(static_cast<const char*>(pFileData->GetConstDataPtr()), StaticCast<Uint32>(pFileData->GetSize()), DeviceCI, Allocator);
+            ParseRSNDeviceCreateInfo(pFileData->GetConstDataPtr<char>(), StaticCast<Uint32>(pFileData->GetSize()), DeviceCI, Allocator);
         }
 
         auto ConstructString = [](std::vector<std::string> const& Paths) {
diff --git a/Tests/DiligentToolsTest/include/DRSNLoader.hpp b/Tests/DiligentToolsTest/include/DRSNLoader.hpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -60,7 +60,7 @@ inline nlohmann::json LoadDRSNFromFile(const Char* FilePath)
 
         auto pFileData = DataBlobImpl::Create();
         File->Read(pFileData);
-        Json = nlohmann::json::parse(String{reinterpret_cast<const char*>(pFileData->GetConstDataPtr()), pFileData->GetSize()});
+        Json = nlohmann::json::parse(String{pFileData->GetConstDataPtr<char>(), pFileData->GetSize()});
     }
     catch (std::runtime_error& err)
     {
diff --git a/Tests/DiligentToolsTest/src/JPEGCodecTest.cpp b/Tests/DiligentToolsTest/src/JPEGCodecTest.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -72,7 +72,7 @@ TEST(Tools_TextureLoader, JPEGCodec)
     ASSERT_EQ(DecodedImgDesc.NumComponents, NumComponents);
     ASSERT_EQ(DecodedImgDesc.ComponentType, VT_UINT8);
 
-    const Uint8* pTestPixels = reinterpret_cast<const Uint8*>(pDecodedPixelsBlob->GetDataPtr());
+    const Uint8* pTestPixels = pDecodedPixelsBlob->GetConstDataPtr<Uint8>();
     for (Uint32 y = 0; y < TestImgHeight; ++y)
     {
         for (Uint32 x = 0; x < TestImgWidth; ++x)
diff --git a/Tests/DiligentToolsTest/src/PNGCodecTest.cpp b/Tests/DiligentToolsTest/src/PNGCodecTest.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2024 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -80,7 +80,7 @@ TEST(Tools_TextureLoader, PNGCodec)
         ASSERT_EQ(DecodedImgDesc.NumComponents, NumComponents);
         ASSERT_EQ(DecodedImgDesc.ComponentType, VT_UINT8);
 
-        const Uint8* pTestPixels = reinterpret_cast<const Uint8*>(pDecodedPixelsBlob->GetDataPtr());
+        const Uint8* pTestPixels = pDecodedPixelsBlob->GetConstDataPtr<Uint8>();
         for (Uint32 y = 0; y < TestImgHeight; ++y)
         {
             for (Uint32 x = 0; x < TestImgWidth; ++x)
diff --git a/TextureLoader/src/Image.cpp b/TextureLoader/src/Image.cpp
@@ -231,7 +231,7 @@ void Image::LoadTiffFile(IDataBlob* pFileData, const ImageLoadInfo& LoadInfo)
     if (PlanarConfig == PLANARCONFIG_CONTIG || m_Desc.NumComponents == 1)
     {
         VERIFY_EXPR(m_Desc.RowStride >= ScanlineSize);
-        auto* pDataPtr = reinterpret_cast<Uint8*>(m_pData->GetDataPtr());
+        Uint8* pDataPtr = m_pData->GetDataPtr<Uint8>();
         for (Uint32 row = 0; row < m_Desc.Height; row++, pDataPtr += m_Desc.RowStride)
         {
             TIFFReadScanline(TiffFile, pDataPtr, row);
@@ -244,7 +244,7 @@ void Image::LoadTiffFile(IDataBlob* pFileData, const ImageLoadInfo& LoadInfo)
         {
             for (Uint16 comp = 0; comp < m_Desc.NumComponents; ++comp)
             {
-                auto* const pDstRow = reinterpret_cast<Uint8*>(m_pData->GetDataPtr()) + m_Desc.RowStride * row + comp;
+                Uint8* const pDstRow = m_pData->GetDataPtr<Uint8>() + m_Desc.RowStride * row + comp;
 
                 TIFFReadScanline(TiffFile, ScanlineData.data(), row, comp);
 
@@ -286,7 +286,7 @@ void Image::LoadTiffFile(IDataBlob* pFileData, const ImageLoadInfo& LoadInfo)
 static bool LoadHDRFile(IDataBlob* pSrcHdrBits, IDataBlob* pDstPixels, ImageDesc* pDstImgDesc)
 {
     Int32  Width = 0, Height = 0, NumComponents = 0;
-    float* pFloatData = stbi_loadf_from_memory(static_cast<const Uint8*>(pSrcHdrBits->GetConstDataPtr()), static_cast<Int32>(pSrcHdrBits->GetSize()), &Width, &Height, &NumComponents, 0);
+    float* pFloatData = stbi_loadf_from_memory(pSrcHdrBits->GetConstDataPtr<stbi_uc>(), static_cast<Int32>(pSrcHdrBits->GetSize()), &Width, &Height, &NumComponents, 0);
     if (pFloatData == nullptr)
     {
         LOG_ERROR_MESSAGE("Failed to load HDR image from memory. STB supports only 32-bit rle rgbe textures");
@@ -308,7 +308,7 @@ static bool LoadHDRFile(IDataBlob* pSrcHdrBits, IDataBlob* pDstPixels, ImageDesc
 static bool LoadTGAFile(IDataBlob* pSrcTgaBits, IDataBlob* pDstPixels, ImageDesc* pDstImgDesc)
 {
     Int32  Width = 0, Height = 0, NumComponents = 0;
-    Uint8* pFloatData = stbi_load_from_memory(static_cast<const Uint8*>(pSrcTgaBits->GetConstDataPtr()), static_cast<Int32>(pSrcTgaBits->GetSize()), &Width, &Height, &NumComponents, 0);
+    Uint8* pFloatData = stbi_load_from_memory(pSrcTgaBits->GetConstDataPtr<stbi_uc>(), static_cast<Int32>(pSrcTgaBits->GetSize()), &Width, &Height, &NumComponents, 0);
     if (pFloatData == nullptr)
     {
         LOG_ERROR_MESSAGE("Failed to load TGA image from memory");
@@ -657,7 +657,7 @@ IMAGE_FILE_FORMAT CreateImageFromFile(const Char* FilePath,
         auto pFileData = DataBlobImpl::Create();
         pFileStream->ReadBlob(pFileData);
 
-        ImgFileFormat = Image::GetFileFormat(static_cast<const Uint8*>(pFileData->GetDataPtr()), pFileData->GetSize(), FilePath);
+        ImgFileFormat = Image::GetFileFormat(pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), FilePath);
         if (ImgFileFormat == IMAGE_FILE_FORMAT_UNKNOWN)
         {
             LOG_ERROR_AND_THROW("Unable to derive image format for file '", FilePath, "\".");
diff --git a/TextureLoader/src/SGILoader.cpp b/TextureLoader/src/SGILoader.cpp
@@ -63,10 +63,10 @@ bool LoadSGI(IDataBlob* pSGIData,
              ImageDesc* pDstImgDesc)
 {
     VERIFY_EXPR(pSGIData != nullptr && pDstPixels != nullptr && pDstImgDesc != nullptr);
-    const auto* pDataStart = reinterpret_cast<const Uint8*>(pSGIData->GetConstDataPtr());
-    const auto  Size       = pSGIData->GetSize();
-    const auto* pDataEnd   = pDataStart + Size;
-    const auto* pSrcPtr    = pDataStart;
+    const Uint8* pDataStart = pSGIData->GetConstDataPtr<Uint8>();
+    const size_t Size       = pSGIData->GetSize();
+    const Uint8* pDataEnd   = pDataStart + Size;
+    const Uint8* pSrcPtr    = pDataStart;
 
     if (Size < sizeof(SGIHeader))
     {
@@ -113,7 +113,7 @@ bool LoadSGI(IDataBlob* pSGIData,
 
     pDstImgDesc->RowStride = Width * NumChannels * BytesPerChannel;
     pDstPixels->Resize(size_t{Height} * pDstImgDesc->RowStride);
-    auto* pDstPtr = reinterpret_cast<Uint8*>(pDstPixels->GetDataPtr());
+    Uint8* pDstPtr = pDstPixels->GetDataPtr<Uint8>();
 
     if (Header.Compression == 0)
     {
diff --git a/TextureLoader/src/TextureLoaderImpl.cpp b/TextureLoader/src/TextureLoaderImpl.cpp
@@ -482,7 +482,7 @@ void CreateTextureLoaderFromFile(const char*            FilePath,
         File->Read(pFileData);
 
         RefCntAutoPtr<ITextureLoader> pTexLoader{
-            MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, reinterpret_cast<const Uint8*>(pFileData->GetConstDataPtr()), pFileData->GetSize(), std::move(pFileData)) //
+            MakeNewRCObj<TextureLoaderImpl>()(TexLoadInfo, pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), std::move(pFileData)) //
         };
         if (pTexLoader)
             pTexLoader->QueryInterface(IID_TextureLoader, reinterpret_cast<IObject**>(ppLoader));

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2019-2022 Diligent Graphics LLC`
	`2`	`+ * Copyright 2019-2024 Diligent Graphics LLC`
`3`	`3`	`* Copyright 2015-2019 Egor Yusov`
`4`	`4`	`*`
`5`	`5`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`@@ -56,8 +56,7 @@ bool DXSDKMesh::CreateFromFile(const char* szFileName)`
`56`	`56`
`57`	`57`	`File.Close();`
`58`	`58`
`59`		`- auto res = CreateFromMemory(reinterpret_cast<Uint8*>(pFileData->GetDataPtr()),`
`60`		`- static_cast<Uint32>(pFileData->GetSize()));`
	`59`	`+ auto res = CreateFromMemory(pFileData->GetConstDataPtr<Uint8>(), static_cast<Uint32>(pFileData->GetSize()));`
`61`	`60`
`62`	`61`	`return res;`
`63`	`62`	`}`
`@@ -103,8 +102,7 @@ void DXSDKMesh::ComputeBoundingBoxes()`
`103`	`102`	`}`
`104`	`103`	`}`
`105`	`104`
`106`		`-bool DXSDKMesh::CreateFromMemory(Uint8* pData,`
`107`		`- Uint32 DataUint8s)`
	`105`	`+bool DXSDKMesh::CreateFromMemory(const Uint8* pData, Uint32 DataUint8s)`
`108`	`106`	`{`
`109`	`107`	`m_StaticMeshData.resize(DataUint8s);`
`110`	`108`	`memcpy(m_StaticMeshData.data(), pData, DataUint8s);`
`@@ -281,7 +279,7 @@ bool DXSDKMesh::Create(const Char* szFileName)`
`281`	`279`	`}`
`282`	`280`
`283`	`281`	`//--------------------------------------------------------------------------------------`
`284`		`-bool DXSDKMesh::Create(Uint8* pData, Uint32 DataUint8s)`
	`282`	`+bool DXSDKMesh::Create(const Uint8* pData, Uint32 DataUint8s)`
`285`	`283`	`{`
`286`	`284`	`return CreateFromMemory(pData, DataUint8s);`
`287`	`285`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2019-2023 Diligent Graphics LLC`
	`2`	`+ * Copyright 2019-2024 Diligent Graphics LLC`
`3`	`3`	`*`
`4`	`4`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`5`	`5`	`* you may not use this file except in compliance with the License.`
`@@ -302,7 +302,7 @@ Bool RenderStateNotationParserImpl::ParseFileInternal(const Char*`
`302`	`302`	`auto pFileData = DataBlobImpl::Create();`
`303`	`303`	`pFileStream->ReadBlob(pFileData);`
`304`	`304`
`305`		`- if (!ParseStringInternal(static_cast<const char*>(pFileData->GetConstDataPtr()), StaticCast<Uint32>(pFileData->GetSize()), pStreamFactory))`
	`305`	`+ if (!ParseStringInternal(pFileData->GetConstDataPtr<char>(), StaticCast<Uint32>(pFileData->GetSize()), pStreamFactory))`
`306`	`306`	`LOG_ERROR_AND_THROW("Failed to parse file: '", FilePath, "'.");`
`307`	`307`	`}`
`308`	`308`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ void Image::LoadTiffFile(IDataBlob* pFileData, const ImageLoadInfo& LoadInfo)`
`231`	`231`	`if (PlanarConfig == PLANARCONFIG_CONTIG \|\| m_Desc.NumComponents == 1)`
`232`	`232`	`{`
`233`	`233`	`VERIFY_EXPR(m_Desc.RowStride >= ScanlineSize);`
`234`		`- auto* pDataPtr = reinterpret_cast<Uint8*>(m_pData->GetDataPtr());`
	`234`	`+ Uint8* pDataPtr = m_pData->GetDataPtr<Uint8>();`
`235`	`235`	`for (Uint32 row = 0; row < m_Desc.Height; row++, pDataPtr += m_Desc.RowStride)`
`236`	`236`	`{`
`237`	`237`	`TIFFReadScanline(TiffFile, pDataPtr, row);`
`@@ -244,7 +244,7 @@ void Image::LoadTiffFile(IDataBlob* pFileData, const ImageLoadInfo& LoadInfo)`
`244`	`244`	`{`
`245`	`245`	`for (Uint16 comp = 0; comp < m_Desc.NumComponents; ++comp)`
`246`	`246`	`{`
`247`		`- auto* const pDstRow = reinterpret_cast<Uint8>(m_pData->GetDataPtr()) + m_Desc.RowStride row + comp;`
	`247`	`+ Uint8* const pDstRow = m_pData->GetDataPtr<Uint8>() + m_Desc.RowStride * row + comp;`
`248`	`248`
`249`	`249`	`TIFFReadScanline(TiffFile, ScanlineData.data(), row, comp);`
`250`	`250`
`@@ -286,7 +286,7 @@ void Image::LoadTiffFile(IDataBlob* pFileData, const ImageLoadInfo& LoadInfo)`
`286`	`286`	`static bool LoadHDRFile(IDataBlob* pSrcHdrBits, IDataBlob* pDstPixels, ImageDesc* pDstImgDesc)`
`287`	`287`	`{`
`288`	`288`	`Int32 Width = 0, Height = 0, NumComponents = 0;`
`289`		`- float* pFloatData = stbi_loadf_from_memory(static_cast<const Uint8*>(pSrcHdrBits->GetConstDataPtr()), static_cast<Int32>(pSrcHdrBits->GetSize()), &Width, &Height, &NumComponents, 0);`
	`289`	`+ float* pFloatData = stbi_loadf_from_memory(pSrcHdrBits->GetConstDataPtr<stbi_uc>(), static_cast<Int32>(pSrcHdrBits->GetSize()), &Width, &Height, &NumComponents, 0);`
`290`	`290`	`if (pFloatData == nullptr)`
`291`	`291`	`{`
`292`	`292`	`LOG_ERROR_MESSAGE("Failed to load HDR image from memory. STB supports only 32-bit rle rgbe textures");`
`@@ -308,7 +308,7 @@ static bool LoadHDRFile(IDataBlob* pSrcHdrBits, IDataBlob* pDstPixels, ImageDesc`
`308`	`308`	`static bool LoadTGAFile(IDataBlob* pSrcTgaBits, IDataBlob* pDstPixels, ImageDesc* pDstImgDesc)`
`309`	`309`	`{`
`310`	`310`	`Int32 Width = 0, Height = 0, NumComponents = 0;`
`311`		`- Uint8* pFloatData = stbi_load_from_memory(static_cast<const Uint8*>(pSrcTgaBits->GetConstDataPtr()), static_cast<Int32>(pSrcTgaBits->GetSize()), &Width, &Height, &NumComponents, 0);`
	`311`	`+ Uint8* pFloatData = stbi_load_from_memory(pSrcTgaBits->GetConstDataPtr<stbi_uc>(), static_cast<Int32>(pSrcTgaBits->GetSize()), &Width, &Height, &NumComponents, 0);`
`312`	`312`	`if (pFloatData == nullptr)`
`313`	`313`	`{`
`314`	`314`	`LOG_ERROR_MESSAGE("Failed to load TGA image from memory");`
`@@ -657,7 +657,7 @@ IMAGE_FILE_FORMAT CreateImageFromFile(const Char* FilePath,`
`657`	`657`	`auto pFileData = DataBlobImpl::Create();`
`658`	`658`	`pFileStream->ReadBlob(pFileData);`
`659`	`659`
`660`		`- ImgFileFormat = Image::GetFileFormat(static_cast<const Uint8*>(pFileData->GetDataPtr()), pFileData->GetSize(), FilePath);`
	`660`	`+ ImgFileFormat = Image::GetFileFormat(pFileData->GetConstDataPtr<Uint8>(), pFileData->GetSize(), FilePath);`
`661`	`661`	`if (ImgFileFormat == IMAGE_FILE_FORMAT_UNKNOWN)`
`662`	`662`	`{`
`663`	`663`	`LOG_ERROR_AND_THROW("Unable to derive image format for file '", FilePath, "\".");`