sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update for latest nazarautils update

This commit is contained in:
SirLynix 2023-07-17 19:05:15 +02:00
parent af3d1cfa26
commit f2bc1bff7a
30 changed files with 129 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/Nazara/Core/Error.hpp
View File

@ -13,14 +13,14 @@
#include <string>
#if NAZARA_CORE_ENABLE_ASSERTS || defined(NAZARA_DEBUG)
#define NazaraAssert(a, err) if (!(a)) Nz::Error::Trigger(Nz::ErrorType::AssertFailed, err, __LINE__, __FILE__, NAZARA_FUNCTION)
#define NazaraAssert(a, err) if (!(a)) Nz::Error::Trigger(Nz::ErrorType::AssertFailed, err, __LINE__, __FILE__, NAZARA_PRETTY_FUNCTION)
#else
#define NazaraAssert(a, err) for (;;) break
#endif
#define NazaraError(err) Nz::Error::Trigger(Nz::ErrorType::Normal, err, __LINE__, __FILE__, NAZARA_FUNCTION)
#define NazaraInternalError(err) Nz::Error::Trigger(Nz::ErrorType::Internal, err, __LINE__, __FILE__, NAZARA_FUNCTION)
#define NazaraWarning(err) Nz::Error::Trigger(Nz::ErrorType::Warning, err, __LINE__, __FILE__, NAZARA_FUNCTION)
#define NazaraError(err) Nz::Error::Trigger(Nz::ErrorType::Normal, err, __LINE__, __FILE__, NAZARA_PRETTY_FUNCTION)
#define NazaraInternalError(err) Nz::Error::Trigger(Nz::ErrorType::Internal, err, __LINE__, __FILE__, NAZARA_PRETTY_FUNCTION)
#define NazaraWarning(err) Nz::Error::Trigger(Nz::ErrorType::Warning, err, __LINE__, __FILE__, NAZARA_PRETTY_FUNCTION)
namespace Nz
{

6
include/Nazara/Core/Hash/CRC32.hpp
View File

@ -13,11 +13,11 @@
namespace Nz
{
class NAZARA_CORE_API CRC32Hash final : public AbstractHash
class NAZARA_CORE_API CRC32Hasher final : public AbstractHash
{
public:
CRC32Hash(UInt32 polynomial = DefaultPolynomial);
~CRC32Hash();
CRC32Hasher(UInt32 polynomial = DefaultPolynomial);
~CRC32Hasher();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/CRC64.hpp
View File

@ -13,11 +13,11 @@
namespace Nz
{
class NAZARA_CORE_API CRC64Hash final : public AbstractHash
class NAZARA_CORE_API CRC64Hasher final : public AbstractHash
{
public:
CRC64Hash() = default;
~CRC64Hash() = default;
CRC64Hasher() = default;
~CRC64Hasher() = default;
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/Fletcher16.hpp
View File

@ -13,11 +13,11 @@
namespace Nz
{
class NAZARA_CORE_API Fletcher16Hash final : public AbstractHash
class NAZARA_CORE_API Fletcher16Hasher final : public AbstractHash
{
public:
Fletcher16Hash() = default;
~Fletcher16Hash() = default;
Fletcher16Hasher() = default;
~Fletcher16Hasher() = default;
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/MD5.hpp
View File

@ -13,11 +13,11 @@
namespace Nz
{
class NAZARA_CORE_API MD5Hash final : public AbstractHash
class NAZARA_CORE_API MD5Hasher final : public AbstractHash
{
public:
MD5Hash() = default;
~MD5Hash() = default;
MD5Hasher() = default;
~MD5Hasher() = default;
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA1.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API SHA1Hash final : public AbstractHash
class NAZARA_CORE_API SHA1Hasher final : public AbstractHash
{
public:
SHA1Hash();
~SHA1Hash();
SHA1Hasher();
~SHA1Hasher();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA224.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API SHA224Hash final : public AbstractHash
class NAZARA_CORE_API SHA224Hasher final : public AbstractHash
{
public:
SHA224Hash();
~SHA224Hash();
SHA224Hasher();
~SHA224Hasher();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA256.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API SHA256Hash final : public AbstractHash
class NAZARA_CORE_API SHA256Hasher final : public AbstractHash
{
public:
SHA256Hash();
~SHA256Hash();
SHA256Hasher();
~SHA256Hasher();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA384.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API SHA384Hash final : public AbstractHash
class NAZARA_CORE_API SHA384Hasher final : public AbstractHash
{
public:
SHA384Hash();
~SHA384Hash();
SHA384Hasher();
~SHA384Hasher();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA512.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API SHA512Hash final : public AbstractHash
class NAZARA_CORE_API SHA512Hasher final : public AbstractHash
{
public:
SHA512Hash();
~SHA512Hash();
SHA512Hasher();
~SHA512Hasher();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/Whirlpool.hpp
View File

@ -13,11 +13,11 @@
namespace Nz
{
class NAZARA_CORE_API WhirlpoolHash final : public AbstractHash
class NAZARA_CORE_API WhirlpoolHasher final : public AbstractHash
{
public:
WhirlpoolHash() = default;
~WhirlpoolHash() = default;
WhirlpoolHasher() = default;
~WhirlpoolHasher() = default;
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

1
include/Nazara/Graphics/MaterialPipeline.inl
View File

@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Renderer/Renderer.hpp>
#include <NazaraUtils/Hash.hpp>
#include <functional>
#include <Nazara/Graphics/Debug.hpp>

10
include/Nazara/Math/Vector2.inl
View File

@ -2,7 +2,7 @@
// This file is part of the "Nazara Engine - Math module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Algorithm.hpp>
#include <NazaraUtils/Hash.hpp>
#include <cstring>
#include <limits>
#include <sstream>
@ -774,15 +774,9 @@ namespace std
*/
std::size_t operator()(const Nz::Vector2<T>& v) const
{
std::size_t seed {};
Nz::HashCombine(seed, v.x);
Nz::HashCombine(seed, v.y);
return seed;
return Nz::HashCombine(v.x, v.y);
}
};
}
#include <Nazara/Core/DebugOff.hpp>
#include "Vector2.hpp"

10
include/Nazara/Math/Vector3.inl
View File

@ -2,7 +2,7 @@
// This file is part of the "Nazara Engine - Math module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Algorithm.hpp>
#include <NazaraUtils/Hash.hpp>
#include <cstring>
#include <limits>
#include <stdexcept>
@ -990,13 +990,7 @@ namespace std
std::size_t operator()(const Nz::Vector3<T>& v) const
{
std::size_t seed {};
Nz::HashCombine(seed, v.x);
Nz::HashCombine(seed, v.y);
Nz::HashCombine(seed, v.z);
return seed;
return Nz::HashCombine(v.x, v.y, v.z);
}
};
}

12
include/Nazara/Math/Vector4.inl
View File

@ -2,7 +2,7 @@
// This file is part of the "Nazara Engine - Math module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Algorithm.hpp>
#include <NazaraUtils/Algorithm.hpp>
#include <cstring>
#include <sstream>
#include <stdexcept>
@ -808,17 +808,9 @@ namespace std
*/
std::size_t operator()(const Nz::Vector4<T>& v) const
{
std::size_t seed {};
Nz::HashCombine(seed, v.x);
Nz::HashCombine(seed, v.y);
Nz::HashCombine(seed, v.z);
Nz::HashCombine(seed, v.w);
return seed;
return Nz::HashCombine(v.x, v.y, v.z, v.w);
}
};
}
#include <Nazara/Core/DebugOff.hpp>
#include "Vector4.hpp"

6
include/Nazara/OpenGLRenderer/OpenGLVaoCache.inl
View File

@ -2,7 +2,7 @@
// This file is part of the "Nazara Engine - OpenGL renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Algorithm.hpp>
#include <NazaraUtils/Hash.hpp>
#include <Nazara/OpenGLRenderer/Debug.hpp>
namespace Nz::GL
@ -50,9 +50,7 @@ namespace Nz::GL
inline std::size_t OpenGLVaoSetupHasher::operator()(const OpenGLVaoSetup& setup) const
{
std::size_t seed = 0;
HashCombine(seed, setup.indexBuffer);
std::size_t seed = std::hash<GLuint>{}(setup.indexBuffer);
std::size_t bindingIndex = 0;
for (const auto& attribOpt : setup.vertexAttribs)

23
include/Nazara/Renderer/TextureSampler.inl
View File

@ -2,7 +2,7 @@
// This file is part of the "Nazara Engine - Renderer module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Algorithm.hpp>
#include <NazaraUtils/Hash.hpp>
#include <Nazara/Renderer/Debug.hpp>
namespace Nz
@ -50,18 +50,15 @@ struct std::hash<Nz::TextureSamplerInfo>
{
std::size_t operator()(const Nz::TextureSamplerInfo& sampler) const
{
std::size_t seed = 0;
Nz::HashCombine(seed, sampler.anisotropyLevel);
Nz::HashCombine(seed, sampler.magFilter);
Nz::HashCombine(seed, sampler.minFilter);
Nz::HashCombine(seed, sampler.mipmapMode);
Nz::HashCombine(seed, sampler.wrapModeU);
Nz::HashCombine(seed, sampler.wrapModeV);
Nz::HashCombine(seed, sampler.wrapModeW);
Nz::HashCombine(seed, sampler.depthCompare);
Nz::HashCombine(seed, sampler.depthComparison);
return seed;
return Nz::HashCombine(sampler.anisotropyLevel,
sampler.magFilter,
sampler.minFilter,
sampler.mipmapMode,
sampler.wrapModeU,
sampler.wrapModeV,
sampler.wrapModeW,
sampler.depthCompare,
sampler.depthComparison);
}
};

20
src/Nazara/Core/AbstractHash.cpp
View File

@ -46,34 +46,34 @@ namespace Nz
switch (type)
{
case HashType::Fletcher16:
return std::make_unique<Fletcher16Hash>();
return std::make_unique<Fletcher16Hasher>();
case HashType::CRC32:
return std::make_unique<CRC32Hash>();
return std::make_unique<CRC32Hasher>();
case HashType::CRC64:
return std::make_unique<CRC64Hash>();
return std::make_unique<CRC64Hasher>();
case HashType::MD5:
return std::make_unique<MD5Hash>();
return std::make_unique<MD5Hasher>();
case HashType::SHA1:
return std::make_unique<SHA1Hash>();
return std::make_unique<SHA1Hasher>();
case HashType::SHA224:
return std::make_unique<SHA224Hash>();
return std::make_unique<SHA224Hasher>();
case HashType::SHA256:
return std::make_unique<SHA256Hash>();
return std::make_unique<SHA256Hasher>();
case HashType::SHA384:
return std::make_unique<SHA384Hash>();
return std::make_unique<SHA384Hasher>();
case HashType::SHA512:
return std::make_unique<SHA512Hash>();
return std::make_unique<SHA512Hasher>();
case HashType::Whirlpool:
return std::make_unique<WhirlpoolHash>();
return std::make_unique<WhirlpoolHasher>();
}
NazaraInternalError("Hash type not handled (0x" + NumberToString(UnderlyingCast(type), 16) + ')');

14
src/Nazara/Core/Hash/CRC32.cpp
View File

@ -61,7 +61,7 @@ namespace Nz
};
}
CRC32Hash::CRC32Hash(UInt32 polynomial)
CRC32Hasher::CRC32Hasher(UInt32 polynomial)
{
NAZARA_USE_ANONYMOUS_NAMESPACE
@ -84,7 +84,7 @@ namespace Nz
}
}
CRC32Hash::~CRC32Hash()
CRC32Hasher::~CRC32Hasher()
{
NAZARA_USE_ANONYMOUS_NAMESPACE
@ -92,18 +92,18 @@ namespace Nz
delete[] m_table;
}
void CRC32Hash::Append(const UInt8* data, std::size_t len)
void CRC32Hasher::Append(const UInt8* data, std::size_t len)
{
while (len--)
m_crc = m_table[(m_crc ^ *data++) & 0xFF] ^ (m_crc >> 8);
}
void CRC32Hash::Begin()
void CRC32Hasher::Begin()
{
m_crc = 0xFFFFFFFF;
}
ByteArray CRC32Hash::End()
ByteArray CRC32Hasher::End()
{
m_crc ^= 0xFFFFFFFF;
@ -114,12 +114,12 @@ namespace Nz
return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 4);
}
std::size_t CRC32Hash::GetDigestLength() const
std::size_t CRC32Hasher::GetDigestLength() const
{
return 4;
}
const char* CRC32Hash::GetHashName() const
const char* CRC32Hasher::GetHashName() const
{
return "CRC32";
}

10
src/Nazara/Core/Hash/CRC64.cpp
View File

@ -78,7 +78,7 @@ namespace Nz
};
}
void CRC64Hash::Append(const UInt8* data, std::size_t len)
void CRC64Hasher::Append(const UInt8* data, std::size_t len)
{
NAZARA_USE_ANONYMOUS_NAMESPACE
@ -86,12 +86,12 @@ namespace Nz
m_crc = (m_crc << 8) ^ crc64_table[((m_crc >> 56) ^ *data++) & 0xFF];
}
void CRC64Hash::Begin()
void CRC64Hasher::Begin()
{
m_crc = 0;
}
ByteArray CRC64Hash::End()
ByteArray CRC64Hasher::End()
{
#ifdef NAZARA_LITTLE_ENDIAN
SwapBytes(&m_crc, sizeof(UInt64));
@ -100,12 +100,12 @@ namespace Nz
return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 8);
}
std::size_t CRC64Hash::GetDigestLength() const
std::size_t CRC64Hasher::GetDigestLength() const
{
return 8;
}
const char* CRC64Hash::GetHashName() const
const char* CRC64Hasher::GetHashName() const
{
return "CRC64";
}

10
src/Nazara/Core/Hash/Fletcher16.cpp
View File

@ -8,7 +8,7 @@
namespace Nz
{
void Fletcher16Hash::Append(const UInt8* data, std::size_t len)
void Fletcher16Hasher::Append(const UInt8* data, std::size_t len)
{
while (len > 0)
{
@ -27,13 +27,13 @@ namespace Nz
}
}
void Fletcher16Hash::Begin()
void Fletcher16Hasher::Begin()
{
m_sum1 = 0xFF;
m_sum2 = 0xFF;
}
ByteArray Fletcher16Hash::End()
ByteArray Fletcher16Hasher::End()
{
m_sum1 = (m_sum1 & 0xFF) + (m_sum1 >> 8);
m_sum2 = (m_sum2 & 0xFF) + (m_sum2 >> 8);
@ -47,12 +47,12 @@ namespace Nz
return ByteArray(reinterpret_cast<UInt8*>(&fletcher), 2);
}
std::size_t Fletcher16Hash::GetDigestLength() const
std::size_t Fletcher16Hasher::GetDigestLength() const
{
return 2;
}
const char* Fletcher16Hash::GetHashName() const
const char* Fletcher16Hasher::GetHashName() const
{
return "Fletcher16";
}

12
src/Nazara/Core/Hash/MD5.cpp
View File

@ -99,7 +99,7 @@
namespace Nz
{
void MD5Hash::Append(const UInt8* data, std::size_t len)
void MD5Hasher::Append(const UInt8* data, std::size_t len)
{
const UInt8 *p = data;
std::size_t left = len;
@ -138,7 +138,7 @@ namespace Nz
std::memcpy(m_buf, p, left);
}
void MD5Hash::Begin()
void MD5Hasher::Begin()
{
m_count[0] = m_count[1] = 0;
m_abcd[0] = 0x67452301;
@ -147,7 +147,7 @@ namespace Nz
m_abcd[3] = 0x10325476;
}
ByteArray MD5Hash::End()
ByteArray MD5Hasher::End()
{
static const unsigned char pad[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -174,17 +174,17 @@ namespace Nz
return ByteArray(&digest[0], 16);
}
std::size_t MD5Hash::GetDigestLength() const
std::size_t MD5Hasher::GetDigestLength() const
{
return 16;
}
const char* MD5Hash::GetHashName() const
const char* MD5Hasher::GetHashName() const
{
return "MD5";
}
void MD5Hash::md5_process(const UInt8* data)
void MD5Hasher::md5_process(const UInt8* data)
{
UInt32 a = m_abcd[0];
UInt32 b = m_abcd[1];

14
src/Nazara/Core/Hash/SHA1.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
SHA1Hash::SHA1Hash()
SHA1Hasher::SHA1Hasher()
{
m_state = new SHA_CTX;
}
SHA1Hash::~SHA1Hash()
SHA1Hasher::~SHA1Hasher()
{
delete m_state;
}
void SHA1Hash::Append(const UInt8* data, std::size_t len)
void SHA1Hasher::Append(const UInt8* data, std::size_t len)
{
SHA1_Update(m_state, data, len);
}
void SHA1Hash::Begin()
void SHA1Hasher::Begin()
{
SHA1_Init(m_state);
}
ByteArray SHA1Hash::End()
ByteArray SHA1Hasher::End()
{
UInt8 digest[SHA1_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA1_DIGEST_LENGTH);
}
std::size_t SHA1Hash::GetDigestLength() const
std::size_t SHA1Hasher::GetDigestLength() const
{
return SHA1_DIGEST_LENGTH;
}
const char* SHA1Hash::GetHashName() const
const char* SHA1Hasher::GetHashName() const
{
return "SHA1";
}

14
src/Nazara/Core/Hash/SHA224.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
SHA224Hash::SHA224Hash()
SHA224Hasher::SHA224Hasher()
{
m_state = new SHA_CTX;
}
SHA224Hash::~SHA224Hash()
SHA224Hasher::~SHA224Hasher()
{
delete m_state;
}
void SHA224Hash::Append(const UInt8* data, std::size_t len)
void SHA224Hasher::Append(const UInt8* data, std::size_t len)
{
SHA224_Update(m_state, data, len);
}
void SHA224Hash::Begin()
void SHA224Hasher::Begin()
{
SHA224_Init(m_state);
}
ByteArray SHA224Hash::End()
ByteArray SHA224Hasher::End()
{
UInt8 digest[SHA224_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA224_DIGEST_LENGTH);
}
std::size_t SHA224Hash::GetDigestLength() const
std::size_t SHA224Hasher::GetDigestLength() const
{
return SHA224_DIGEST_LENGTH;
}
const char* SHA224Hash::GetHashName() const
const char* SHA224Hasher::GetHashName() const
{
return "SHA224";
}

14
src/Nazara/Core/Hash/SHA256.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
SHA256Hash::SHA256Hash()
SHA256Hasher::SHA256Hasher()
{
m_state = new SHA_CTX;
}
SHA256Hash::~SHA256Hash()
SHA256Hasher::~SHA256Hasher()
{
delete m_state;
}
void SHA256Hash::Append(const UInt8* data, std::size_t len)
void SHA256Hasher::Append(const UInt8* data, std::size_t len)
{
SHA256_Update(m_state, data, len);
}
void SHA256Hash::Begin()
void SHA256Hasher::Begin()
{
SHA256_Init(m_state);
}
ByteArray SHA256Hash::End()
ByteArray SHA256Hasher::End()
{
UInt8 digest[SHA256_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA256_DIGEST_LENGTH);
}
std::size_t SHA256Hash::GetDigestLength() const
std::size_t SHA256Hasher::GetDigestLength() const
{
return SHA256_DIGEST_LENGTH;
}
const char* SHA256Hash::GetHashName() const
const char* SHA256Hasher::GetHashName() const
{
return "SHA256";
}

14
src/Nazara/Core/Hash/SHA384.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
SHA384Hash::SHA384Hash()
SHA384Hasher::SHA384Hasher()
{
m_state = new SHA_CTX;
}
SHA384Hash::~SHA384Hash()
SHA384Hasher::~SHA384Hasher()
{
delete m_state;
}
void SHA384Hash::Append(const UInt8* data, std::size_t len)
void SHA384Hasher::Append(const UInt8* data, std::size_t len)
{
SHA384_Update(m_state, data, len);
}
void SHA384Hash::Begin()
void SHA384Hasher::Begin()
{
SHA384_Init(m_state);
}
ByteArray SHA384Hash::End()
ByteArray SHA384Hasher::End()
{
UInt8 digest[SHA384_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA384_DIGEST_LENGTH);
}
std::size_t SHA384Hash::GetDigestLength() const
std::size_t SHA384Hasher::GetDigestLength() const
{
return SHA384_DIGEST_LENGTH;
}
const char* SHA384Hash::GetHashName() const
const char* SHA384Hasher::GetHashName() const
{
return "SHA384";
}

14
src/Nazara/Core/Hash/SHA512.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
SHA512Hash::SHA512Hash()
SHA512Hasher::SHA512Hasher()
{
m_state = new SHA_CTX;
}
SHA512Hash::~SHA512Hash()
SHA512Hasher::~SHA512Hasher()
{
delete m_state;
}
void SHA512Hash::Append(const UInt8* data, std::size_t len)
void SHA512Hasher::Append(const UInt8* data, std::size_t len)
{
SHA512_Update(m_state, data, len);
}
void SHA512Hash::Begin()
void SHA512Hasher::Begin()
{
SHA512_Init(m_state);
}
ByteArray SHA512Hash::End()
ByteArray SHA512Hasher::End()
{
UInt8 digest[SHA512_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA512_DIGEST_LENGTH);
}
std::size_t SHA512Hash::GetDigestLength() const
std::size_t SHA512Hasher::GetDigestLength() const
{
return SHA512_DIGEST_LENGTH;
}
const char* SHA512Hash::GetHashName() const
const char* SHA512Hasher::GetHashName() const
{
return "SHA512";
}

12
src/Nazara/Core/Hash/Whirlpool.cpp
View File

@ -626,7 +626,7 @@ namespace Nz
};
}
void WhirlpoolHash::Append(const UInt8* data, std::size_t len)
void WhirlpoolHasher::Append(const UInt8* data, std::size_t len)
{
len *= 8; // Whirlpool works with bits
@ -713,7 +713,7 @@ namespace Nz
m_bufferPos = bufferPos;
}
void WhirlpoolHash::Begin()
void WhirlpoolHasher::Begin()
{
std::memset(m_bitLength, 0, 32);
m_bufferBits = m_bufferPos = 0;
@ -722,7 +722,7 @@ namespace Nz
m_hash[i] = 0L; // initial value
}
ByteArray WhirlpoolHash::End()
ByteArray WhirlpoolHasher::End()
{
UInt8 result[64];
@ -775,18 +775,18 @@ namespace Nz
return ByteArray(&result[0], 64);
}
std::size_t WhirlpoolHash::GetDigestLength() const
std::size_t WhirlpoolHasher::GetDigestLength() const
{
return 64;
}
const char* WhirlpoolHash::GetHashName() const
const char* WhirlpoolHasher::GetHashName() const
{
return "Whirlpool";
}
void WhirlpoolHash::ProcessBuffer()
void WhirlpoolHasher::ProcessBuffer()
{
NAZARA_USE_ANONYMOUS_NAMESPACE

6
tests/UnitTests/Engine/Core/AlgorithmCoreTest.cpp
View File

@ -21,12 +21,6 @@ TEST_CASE("ComputeHash", "[CORE][ALGORITHM]")
const char* expectedOutput;
};
static_assert(Nz::CRC32("Nazara Engine") == 0x8A2F5235);
static_assert(Nz::CRC32("The quick brown fox jumps over the lazy dog") == 0x414FA339);
CHECK(Nz::CRC32("Nazara Engine") == 0x8A2F5235);
CHECK(Nz::CRC32("The quick brown fox jumps over the lazy dog") == 0x414FA339);
// https://defuse.ca/checksums.htm
// https://toolslick.com/programming/hashing/crc-calculator

4
tests/UnitTests/Engine/Core/VirtualDirectoryTest.cpp
View File

@ -208,7 +208,7 @@ TEST_CASE("VirtualDirectory", "[Core][VirtualDirectory]")
const auto& physFileEntry = std::get<Nz::VirtualDirectory::FileEntry>(entry);
Nz::SHA256Hash hash;
Nz::SHA256Hasher hash;
WHEN("We compute " << hash.GetHashName() << " of " << physFileEntry.stream->GetPath() << " file")
{
CHECK(Nz::ToUpper(Nz::ComputeHash(hash, *physFileEntry.stream).ToHex()) == expectedHash);
@ -221,7 +221,7 @@ TEST_CASE("VirtualDirectory", "[Core][VirtualDirectory]")
{
return dir->GetFileContent(filepath, [&](const void* data, std::size_t size)
{
Nz::SHA256Hash hash;
Nz::SHA256Hasher hash;
WHEN("We compute " << hash.GetHashName() << " of " << filepath << " file")
{
hash.Begin();