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> #include <string>
#if NAZARA_CORE_ENABLE_ASSERTS || defined(NAZARA_DEBUG) #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 #else
#define NazaraAssert(a, err) for (;;) break #define NazaraAssert(a, err) for (;;) break
#endif #endif
#define NazaraError(err) Nz::Error::Trigger(Nz::ErrorType::Normal, 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_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_FUNCTION) #define NazaraWarning(err) Nz::Error::Trigger(Nz::ErrorType::Warning, err, __LINE__, __FILE__, NAZARA_PRETTY_FUNCTION)
namespace Nz namespace Nz
{ {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -13,11 +13,11 @@
namespace Nz namespace Nz
{ {
class NAZARA_CORE_API WhirlpoolHash final : public AbstractHash class NAZARA_CORE_API WhirlpoolHasher final : public AbstractHash
{ {
public: public:
WhirlpoolHash() = default; WhirlpoolHasher() = default;
~WhirlpoolHash() = default; ~WhirlpoolHasher() = default;
void Append(const UInt8* data, std::size_t len) override; void Append(const UInt8* data, std::size_t len) override;
void Begin() 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 // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Renderer/Renderer.hpp> #include <Nazara/Renderer/Renderer.hpp>
#include <NazaraUtils/Hash.hpp>
#include <functional> #include <functional>
#include <Nazara/Graphics/Debug.hpp> #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" // This file is part of the "Nazara Engine - Math module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Algorithm.hpp> #include <NazaraUtils/Hash.hpp>
#include <cstring> #include <cstring>
#include <limits> #include <limits>
#include <sstream> #include <sstream>
@ -774,15 +774,9 @@ namespace std
*/ */
std::size_t operator()(const Nz::Vector2<T>& v) const std::size_t operator()(const Nz::Vector2<T>& v) const
{ {
std::size_t seed {}; return Nz::HashCombine(v.x, v.y);
Nz::HashCombine(seed, v.x);
Nz::HashCombine(seed, v.y);
return seed;
} }
}; };
} }
#include <Nazara/Core/DebugOff.hpp> #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" // This file is part of the "Nazara Engine - Math module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Algorithm.hpp> #include <NazaraUtils/Hash.hpp>
#include <cstring> #include <cstring>
#include <limits> #include <limits>
#include <stdexcept> #include <stdexcept>
@ -990,13 +990,7 @@ namespace std
std::size_t operator()(const Nz::Vector3<T>& v) const std::size_t operator()(const Nz::Vector3<T>& v) const
{ {
std::size_t seed {}; return Nz::HashCombine(v.x, v.y, v.z);
Nz::HashCombine(seed, v.x);
Nz::HashCombine(seed, v.y);
Nz::HashCombine(seed, v.z);
return seed;
} }
}; };
} }

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

@ -2,7 +2,7 @@
// This file is part of the "Nazara Engine - Math module" // This file is part of the "Nazara Engine - Math module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Algorithm.hpp> #include <NazaraUtils/Algorithm.hpp>
#include <cstring> #include <cstring>
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
@ -808,17 +808,9 @@ namespace std
*/ */
std::size_t operator()(const Nz::Vector4<T>& v) const std::size_t operator()(const Nz::Vector4<T>& v) const
{ {
std::size_t seed {}; return Nz::HashCombine(v.x, v.y, v.z, v.w);
Nz::HashCombine(seed, v.x);
Nz::HashCombine(seed, v.y);
Nz::HashCombine(seed, v.z);
Nz::HashCombine(seed, v.w);
return seed;
} }
}; };
} }
#include <Nazara/Core/DebugOff.hpp> #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" // This file is part of the "Nazara Engine - OpenGL renderer"
// For conditions of distribution and use, see copyright notice in Config.hpp // 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> #include <Nazara/OpenGLRenderer/Debug.hpp>
namespace Nz::GL namespace Nz::GL
@ -50,9 +50,7 @@ namespace Nz::GL
inline std::size_t OpenGLVaoSetupHasher::operator()(const OpenGLVaoSetup& setup) const inline std::size_t OpenGLVaoSetupHasher::operator()(const OpenGLVaoSetup& setup) const
{ {
std::size_t seed = 0; std::size_t seed = std::hash<GLuint>{}(setup.indexBuffer);
HashCombine(seed, setup.indexBuffer);
std::size_t bindingIndex = 0; std::size_t bindingIndex = 0;
for (const auto& attribOpt : setup.vertexAttribs) 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" // This file is part of the "Nazara Engine - Renderer module"
// For conditions of distribution and use, see copyright notice in Config.hpp // 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> #include <Nazara/Renderer/Debug.hpp>
namespace Nz namespace Nz
@ -50,18 +50,15 @@ struct std::hash<Nz::TextureSamplerInfo>
{ {
std::size_t operator()(const Nz::TextureSamplerInfo& sampler) const std::size_t operator()(const Nz::TextureSamplerInfo& sampler) const
{ {
std::size_t seed = 0; return Nz::HashCombine(sampler.anisotropyLevel,
Nz::HashCombine(seed, sampler.anisotropyLevel); sampler.magFilter,
Nz::HashCombine(seed, sampler.magFilter); sampler.minFilter,
Nz::HashCombine(seed, sampler.minFilter); sampler.mipmapMode,
Nz::HashCombine(seed, sampler.mipmapMode); sampler.wrapModeU,
Nz::HashCombine(seed, sampler.wrapModeU); sampler.wrapModeV,
Nz::HashCombine(seed, sampler.wrapModeV); sampler.wrapModeW,
Nz::HashCombine(seed, sampler.wrapModeW); sampler.depthCompare,
Nz::HashCombine(seed, sampler.depthCompare); sampler.depthComparison);
Nz::HashCombine(seed, sampler.depthComparison);
return seed;
} }
}; };

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

@ -46,34 +46,34 @@ namespace Nz
switch (type) switch (type)
{ {
case HashType::Fletcher16: case HashType::Fletcher16:
return std::make_unique<Fletcher16Hash>(); return std::make_unique<Fletcher16Hasher>();
case HashType::CRC32: case HashType::CRC32:
return std::make_unique<CRC32Hash>(); return std::make_unique<CRC32Hasher>();
case HashType::CRC64: case HashType::CRC64:
return std::make_unique<CRC64Hash>(); return std::make_unique<CRC64Hasher>();
case HashType::MD5: case HashType::MD5:
return std::make_unique<MD5Hash>(); return std::make_unique<MD5Hasher>();
case HashType::SHA1: case HashType::SHA1:
return std::make_unique<SHA1Hash>(); return std::make_unique<SHA1Hasher>();
case HashType::SHA224: case HashType::SHA224:
return std::make_unique<SHA224Hash>(); return std::make_unique<SHA224Hasher>();
case HashType::SHA256: case HashType::SHA256:
return std::make_unique<SHA256Hash>(); return std::make_unique<SHA256Hasher>();
case HashType::SHA384: case HashType::SHA384:
return std::make_unique<SHA384Hash>(); return std::make_unique<SHA384Hasher>();
case HashType::SHA512: case HashType::SHA512:
return std::make_unique<SHA512Hash>(); return std::make_unique<SHA512Hasher>();
case HashType::Whirlpool: case HashType::Whirlpool:
return std::make_unique<WhirlpoolHash>(); return std::make_unique<WhirlpoolHasher>();
} }
NazaraInternalError("Hash type not handled (0x" + NumberToString(UnderlyingCast(type), 16) + ')'); 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 NAZARA_USE_ANONYMOUS_NAMESPACE
@ -84,7 +84,7 @@ namespace Nz
} }
} }
CRC32Hash::~CRC32Hash() CRC32Hasher::~CRC32Hasher()
{ {
NAZARA_USE_ANONYMOUS_NAMESPACE NAZARA_USE_ANONYMOUS_NAMESPACE
@ -92,18 +92,18 @@ namespace Nz
delete[] m_table; 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--) while (len--)
m_crc = m_table[(m_crc ^ *data++) & 0xFF] ^ (m_crc >> 8); m_crc = m_table[(m_crc ^ *data++) & 0xFF] ^ (m_crc >> 8);
} }
void CRC32Hash::Begin() void CRC32Hasher::Begin()
{ {
m_crc = 0xFFFFFFFF; m_crc = 0xFFFFFFFF;
} }
ByteArray CRC32Hash::End() ByteArray CRC32Hasher::End()
{ {
m_crc ^= 0xFFFFFFFF; m_crc ^= 0xFFFFFFFF;
@ -114,12 +114,12 @@ namespace Nz
return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 4); return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 4);
} }
std::size_t CRC32Hash::GetDigestLength() const std::size_t CRC32Hasher::GetDigestLength() const
{ {
return 4; return 4;
} }
const char* CRC32Hash::GetHashName() const const char* CRC32Hasher::GetHashName() const
{ {
return "CRC32"; 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 NAZARA_USE_ANONYMOUS_NAMESPACE
@ -86,12 +86,12 @@ namespace Nz
m_crc = (m_crc << 8) ^ crc64_table[((m_crc >> 56) ^ *data++) & 0xFF]; m_crc = (m_crc << 8) ^ crc64_table[((m_crc >> 56) ^ *data++) & 0xFF];
} }
void CRC64Hash::Begin() void CRC64Hasher::Begin()
{ {
m_crc = 0; m_crc = 0;
} }
ByteArray CRC64Hash::End() ByteArray CRC64Hasher::End()
{ {
#ifdef NAZARA_LITTLE_ENDIAN #ifdef NAZARA_LITTLE_ENDIAN
SwapBytes(&m_crc, sizeof(UInt64)); SwapBytes(&m_crc, sizeof(UInt64));
@ -100,12 +100,12 @@ namespace Nz
return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 8); return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 8);
} }
std::size_t CRC64Hash::GetDigestLength() const std::size_t CRC64Hasher::GetDigestLength() const
{ {
return 8; return 8;
} }
const char* CRC64Hash::GetHashName() const const char* CRC64Hasher::GetHashName() const
{ {
return "CRC64"; return "CRC64";
} }

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -8,27 +8,27 @@
namespace Nz namespace Nz
{ {
SHA512Hash::SHA512Hash() SHA512Hasher::SHA512Hasher()
{ {
m_state = new SHA_CTX; m_state = new SHA_CTX;
} }
SHA512Hash::~SHA512Hash() SHA512Hasher::~SHA512Hasher()
{ {
delete m_state; 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); SHA512_Update(m_state, data, len);
} }
void SHA512Hash::Begin() void SHA512Hasher::Begin()
{ {
SHA512_Init(m_state); SHA512_Init(m_state);
} }
ByteArray SHA512Hash::End() ByteArray SHA512Hasher::End()
{ {
UInt8 digest[SHA512_DIGEST_LENGTH]; UInt8 digest[SHA512_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA512_DIGEST_LENGTH); return ByteArray(digest, SHA512_DIGEST_LENGTH);
} }
std::size_t SHA512Hash::GetDigestLength() const std::size_t SHA512Hasher::GetDigestLength() const
{ {
return SHA512_DIGEST_LENGTH; return SHA512_DIGEST_LENGTH;
} }
const char* SHA512Hash::GetHashName() const const char* SHA512Hasher::GetHashName() const
{ {
return "SHA512"; 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 len *= 8; // Whirlpool works with bits
@ -713,7 +713,7 @@ namespace Nz
m_bufferPos = bufferPos; m_bufferPos = bufferPos;
} }
void WhirlpoolHash::Begin() void WhirlpoolHasher::Begin()
{ {
std::memset(m_bitLength, 0, 32); std::memset(m_bitLength, 0, 32);
m_bufferBits = m_bufferPos = 0; m_bufferBits = m_bufferPos = 0;
@ -722,7 +722,7 @@ namespace Nz
m_hash[i] = 0L; // initial value m_hash[i] = 0L; // initial value
} }
ByteArray WhirlpoolHash::End() ByteArray WhirlpoolHasher::End()
{ {
UInt8 result[64]; UInt8 result[64];
@ -775,18 +775,18 @@ namespace Nz
return ByteArray(&result[0], 64); return ByteArray(&result[0], 64);
} }
std::size_t WhirlpoolHash::GetDigestLength() const std::size_t WhirlpoolHasher::GetDigestLength() const
{ {
return 64; return 64;
} }
const char* WhirlpoolHash::GetHashName() const const char* WhirlpoolHasher::GetHashName() const
{ {
return "Whirlpool"; return "Whirlpool";
} }
void WhirlpoolHash::ProcessBuffer() void WhirlpoolHasher::ProcessBuffer()
{ {
NAZARA_USE_ANONYMOUS_NAMESPACE 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; 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://defuse.ca/checksums.htm
// https://toolslick.com/programming/hashing/crc-calculator // 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); 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") WHEN("We compute " << hash.GetHashName() << " of " << physFileEntry.stream->GetPath() << " file")
{ {
CHECK(Nz::ToUpper(Nz::ComputeHash(hash, *physFileEntry.stream).ToHex()) == expectedHash); 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) 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") WHEN("We compute " << hash.GetHashName() << " of " << filepath << " file")
{ {
hash.Begin(); hash.Begin();