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

Added formats conversion 

Functor, NonCopyable, Tuple are now parts of NazaraCore (NazaraCore no
longer needs NazaraUtility)
Added loadFormat image parameter (ask loader to load image in specific
format)
Fixed utility project building
It is now possible to convert, get validity or get name of pixel formats
Changed endianness macros' name
Removed useless NazaraEndianness macro
Removed unused files
This commit is contained in:
Lynix 2012-05-24 18:55:48 +02:00
parent 570e0a8070
commit b243d15c74
40 changed files with 1609 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
build/scripts/module/utility.lua
View File

@ -7,6 +7,7 @@ files
"../include/Nazara/Utility/**.hpp",
"../include/Nazara/Utility/**.inl",
"../src/Nazara/Utility/**.hpp",
"../src/Nazara/Utility/**.c",
"../src/Nazara/Utility/**.cpp"
}

27
include/Nazara/Audio/Sound.hpp
View File

@ -1,27 +0,0 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_SOUND_HPP
#define NAZARA_SOUND_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Utility/Resource.hpp>
class NAZARA_API NzSound
{
public:
NzSound();
~NzSound();
bool LoadFromFile(const NzString& filePath);
bool LoadFromMemory(const nzUInt8* ptr, std::size_t size);
private:
};
#endif // NAZARA_SOUND_HPP

2
include/Nazara/Core/DynLib.hpp
View File

@ -8,8 +8,8 @@
#define NAZARA_DYNLIB_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#define NAZARA_CLASS_DYNLIB
#include <Nazara/Core/ThreadSafety.hpp>

22
include/Nazara/Core/Endianness.hpp
View File

@ -9,26 +9,18 @@
#include <Nazara/Prerequesites.hpp>
#if defined(NAZARA_ENDIANNESS_BIGENDIAN)
#define NAZARA_ENDIANNESS_DETECTED 1
#define NazaraEndianness nzEndianness_BigEndian
#elif defined(NAZARA_ENDIANNESS_LITTLEENDIAN)
#define NAZARA_ENDIANNESS_DETECTED 1
#define NazaraEndianness nzEndianness_LittleEndian
#else
#if !defined(NAZARA_BIG_ENDIAN) && !defined(NAZARA_LITTLE_ENDIAN)
// Détection automatique selon les macros du compilateur
#if defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || (defined(__MIPS__) && defined(__MISPEB__)) || \
defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || defined(__sparc__) || defined(__hppa__)
#define NAZARA_ENDIANNESS_DETECTED 1
#define NAZARA_ENDIANNESS_BIGENDIAN
#define NazaraEndianness nzEndianness_BigEndian
#define NAZARA_BIG_ENDIAN
#elif defined(__i386__) || defined(__i386) || defined(__X86__) || defined (__x86_64)
#define NAZARA_ENDIANNESS_DETECTED 1
#define NAZARA_ENDIANNESS_LITTLEENDIAN
#define NazaraEndianness nzEndianness_LittleEndian
#define NAZARA_LITTLE_ENDIAN
#else
#define NAZARA_ENDIANNESS_DETECTED 0
#define NazaraEndianness NzGetPlatformEndianness()
#error Failed to identify endianness, you must define either NAZARA_BIG_ENDIAN or NAZARA_LITTLE_ENDIAN
#endif
#elif defined(NAZARA_BIG_ENDIAN) && defined(NAZARA_LITTLE_ENDIAN)
#error You cannot define both NAZARA_BIG_ENDIAN and NAZARA_LITTLE_ENDIAN
#endif
enum nzEndianness

26
include/Nazara/Core/Endianness.inl
View File

@ -17,27 +17,11 @@ inline void NzByteSwap(void* buffer, unsigned int size)
inline nzEndianness NzGetPlatformEndianness()
{
#if NAZARA_ENDIANNESS_DETECTED
return NazaraEndianness;
#else
static nzEndianness endianness = nzEndianness_Unknown;
static bool tested = false;
if (!tested)
{
nzUInt32 i = 1;
nzUInt8* p = reinterpret_cast<nzUInt8*>(&i);
// Méthode de récupération de l'endianness au runtime
if (p[0] == 1)
endianness = nzEndianness_LittleEndian;
else if (p[3] == 1)
endianness = nzEndianness_BigEndian;
tested = true;
}
return endianness;
#endif
#if defined(NAZARA_BIG_ENDIAN)
return nzEndianness_BigEndian;
#elif defined(NAZARA_LITTLE_ENDIAN)
return nzEndianness_LittleEndian;
#endif
}
#include <Nazara/Core/DebugOff.hpp>

2
include/Nazara/Core/File.hpp
View File

@ -13,8 +13,8 @@
#include <Nazara/Core/Hashable.hpp>
#include <Nazara/Core/HashDigest.hpp>
#include <Nazara/Core/InputStream.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#define NAZARA_CLASS_FILE
#include <Nazara/Core/ThreadSafety.hpp>

4
include/Nazara/Utility/Functor.hpp → include/Nazara/Core/Functor.hpp
View File

@ -7,7 +7,7 @@
#ifndef NAZARA_FUNCTOR_HPP
#define NAZARA_FUNCTOR_HPP
#include <Nazara/Utility/Tuple.hpp>
#include <Nazara/Core/Tuple.hpp>
// Inspiré du code de la SFML par Laurent Gomila
@ -40,6 +40,6 @@ template<typename F, typename... Args> struct NzFunctorWithArgs : NzFunctor
template<typename F> struct NzFunctorWithoutArgs;
template<typename F, typename... Args> struct NzFunctorWithArgs;
#include <Nazara/Utility/Functor.inl>
#include <Nazara/Core/Functor.inl>
#endif // NAZARA_FUNCTOR_HPP

0
include/Nazara/Utility/Functor.inl → include/Nazara/Core/Functor.inl
View File

2
include/Nazara/Core/Hash.hpp
View File

@ -11,7 +11,7 @@
#include <Nazara/Core/Hashable.hpp>
#include <Nazara/Core/HashDigest.hpp>
#include <Nazara/Core/HashImpl.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
class NAZARA_API NzHash : NzNonCopyable
{

2
include/Nazara/Core/HashImpl.hpp
View File

@ -8,7 +8,7 @@
#define NAZARA_HASHIMPL_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
class NzHashDigest;

2
include/Nazara/Core/Log.hpp
View File

@ -9,8 +9,8 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#define NAZARA_CLASS_LOG
#include <Nazara/Core/ThreadSafety.hpp>

2
include/Nazara/Core/Mutex.hpp
View File

@ -8,7 +8,7 @@
#define NAZARA_MUTEX_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
class NzMutexImpl;
class NzThreadCondition;

0
include/Nazara/Utility/NonCopyable.hpp → include/Nazara/Core/NonCopyable.hpp
View File

2
include/Nazara/Core/Semaphore.hpp
View File

@ -8,7 +8,7 @@
#define NAZARA_SEMAPHORE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
class NzSemaphoreImpl;

4
include/Nazara/Core/Thread.hpp
View File

@ -10,8 +10,8 @@
#define NAZARA_THREAD_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/Functor.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/Functor.hpp>
#include <Nazara/Core/NonCopyable.hpp>
class NzThreadImpl;

2
include/Nazara/Utility/Tuple.hpp → include/Nazara/Core/Tuple.hpp
View File

@ -11,6 +11,6 @@
template<typename F, typename... ArgsT> void NzUnpackTuple(F func, const std::tuple<ArgsT...>& t);
#include <Nazara/Utility/Tuple.inl>
#include <Nazara/Core/Tuple.inl>
#endif // NAZARA_TUPLE_HPP

0
include/Nazara/Utility/Tuple.inl → include/Nazara/Core/Tuple.inl
View File

3
include/Nazara/Prerequesites.hpp
View File

@ -23,9 +23,8 @@
#define NAZARA_FUNCTION __FUNCSIG__
#elif defined(__GNUC__)
#define NAZARA_COMPILER_GCC
#define NAZARA_FUNCTION __PRETTY_FUNCTION__
#define NAZARA_DEPRECATED(txt) __attribute__((__deprecated__(txt)))
#define NAZARA_FUNCTION __PRETTY_FUNCTION__
#elif defined(__BORLANDC__)
#define NAZARA_COMPILER_BORDLAND
#define NAZARA_DEPRECATED(txt)

2
include/Nazara/Renderer/Buffer.hpp
View File

@ -8,7 +8,7 @@
#define NAZARA_BUFFER_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <Nazara/Utility/Resource.hpp>
enum nzBufferLock

2
include/Nazara/Renderer/OcclusionQuery.hpp
View File

@ -8,7 +8,7 @@
#define NAZARA_OCCLUSIONQUERY_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
class NAZARA_API NzOcclusionQuery : NzNonCopyable
{

2
include/Nazara/Renderer/Shader.hpp
View File

@ -8,9 +8,9 @@
#define NAZARA_SHADER_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Matrix4.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Utility/Resource.hpp>
enum nzShaderLanguage

13
include/Nazara/Utility/Image.hpp
View File

@ -35,12 +35,21 @@ enum nzImageType
struct NzImageParams
{
// GCC 4.7 je te veux
NzImageParams() :
loadFormat(nzPixelFormat_Undefined)
{
}
nzPixelFormat loadFormat;
bool IsValid() const
{
return true;
return loadFormat == nzPixelFormat_Undefined || NzPixelFormat::IsValid(loadFormat);
}
};
///TODO: Animations ?
///TODO: Filtres
///TODO: Mipmaps
@ -55,6 +64,8 @@ class NAZARA_API NzImage : public NzResource, public NzResourceLoader<NzImage, N
NzImage(SharedImage* sharedImage);
~NzImage();
bool Convert(nzPixelFormat format);
bool Copy(const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos);
bool CopyToFace(nzCubemapFace face, const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos);

52
include/Nazara/Utility/PixelFormat.hpp
View File

@ -8,31 +8,65 @@
#define NAZARA_PIXELFORMAT_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/String.hpp>
enum nzPixelFormat
{
nzPixelFormat_Undefined,
nzPixelFormat_B8G8R8,
nzPixelFormat_B8G8R8A8,
nzPixelFormat_BGR8,
nzPixelFormat_BGRA8,
nzPixelFormat_DXT1,
nzPixelFormat_DXT3,
nzPixelFormat_DXT5,
nzPixelFormat_L8,
nzPixelFormat_L8A8,
nzPixelFormat_R4G4A4A4,
nzPixelFormat_R5G5A5A1,
nzPixelFormat_R8,
nzPixelFormat_R8G8,
nzPixelFormat_R8G8B8,
nzPixelFormat_R8G8B8A8
nzPixelFormat_LA8,
/*
nzPixelFormat_RGB16F,
nzPixelFormat_RGB16I,
nzPixelFormat_RGB32F,
nzPixelFormat_RGB32I,
*/
nzPixelFormat_RGBA16F,
nzPixelFormat_RGBA16I,
/*
nzPixelFormat_RGBA32F,
nzPixelFormat_RGBA32I,
*/
nzPixelFormat_RGBA4,
nzPixelFormat_RGB5A1,
nzPixelFormat_RGB8,
nzPixelFormat_RGBA8,
nzPixelFormat_Count
};
class NzUtility;
class NzPixelFormat
{
friend class NzUtility;
public:
typedef nzUInt8* (*ConvertFunction)(const nzUInt8* start, const nzUInt8* end, nzUInt8* dst);
static bool Convert(nzPixelFormat srcFormat, nzPixelFormat dstFormat, const void* src, void* dst);
static bool Convert(nzPixelFormat srcFormat, nzPixelFormat dstFormat, const void* start, const void* end, void* dst);
static nzUInt8 GetBPP(nzPixelFormat format);
static bool IsCompressed(nzPixelFormat format);
static bool IsValid(nzPixelFormat format);
static void SetConvertFunction(nzPixelFormat srcFormat, nzPixelFormat dstFormat, ConvertFunction);
static NzString ToString(nzPixelFormat format);
private:
static bool Initialize();
static void Uninitialize();
static ConvertFunction s_convertFunctions[nzPixelFormat_Count][nzPixelFormat_Count];
};
#include <Nazara/Utility/PixelFormat.inl>

199
include/Nazara/Utility/PixelFormat.inl
View File

@ -2,19 +2,76 @@
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Debug.hpp>
#include <Nazara/Core/Error.hpp>
#include <cstring>
#include <Nazara/Utility/Debug.hpp>
inline bool NzPixelFormat::Convert(nzPixelFormat srcFormat, nzPixelFormat dstFormat, const void* src, void* dst)
{
if (srcFormat == dstFormat)
{
std::memcpy(dst, src, GetBPP(srcFormat));
return true;
}
#if NAZARA_UTILITY_SAFE
if (IsCompressed(srcFormat))
{
NazaraError("Cannot convert single pixel from compressed format");
return false;
}
if (IsCompressed(dstFormat))
{
NazaraError("Cannot convert single pixel to compressed format");
return false;
}
#endif
ConvertFunction func = s_convertFunctions[srcFormat][dstFormat];
if (!func)
{
NazaraError("Pixel format conversion from " + ToString(srcFormat) + " to " + ToString(dstFormat) + " not supported");
return false;
}
func(static_cast<const nzUInt8*>(src), static_cast<const nzUInt8*>(src) + GetBPP(srcFormat), static_cast<nzUInt8*>(dst));
return true;
}
inline bool NzPixelFormat::Convert(nzPixelFormat srcFormat, nzPixelFormat dstFormat, const void* start, const void* end, void* dst)
{
if (srcFormat == dstFormat)
{
std::memcpy(dst, start, static_cast<const nzUInt8*>(end)-static_cast<const nzUInt8*>(start));
return true;
}
ConvertFunction func = s_convertFunctions[srcFormat][dstFormat];
if (!func)
{
NazaraError("Pixel format conversion from " + ToString(srcFormat) + " to " + ToString(dstFormat) + " not supported");
return false;
}
func(static_cast<const nzUInt8*>(start), static_cast<const nzUInt8*>(end), static_cast<nzUInt8*>(dst));
return true;
}
inline nzUInt8 NzPixelFormat::GetBPP(nzPixelFormat format)
{
switch (format)
{
case nzPixelFormat_Count:
case nzPixelFormat_Undefined:
return 0;
case nzPixelFormat_B8G8R8:
case nzPixelFormat_BGR8:
return 3;
case nzPixelFormat_B8G8R8A8:
case nzPixelFormat_BGRA8:
return 4;
case nzPixelFormat_DXT1:
@ -29,28 +86,48 @@ inline nzUInt8 NzPixelFormat::GetBPP(nzPixelFormat format)
case nzPixelFormat_L8:
return 1;
case nzPixelFormat_L8A8:
case nzPixelFormat_LA8:
return 2;
/*
case nzPixelFormat_RGB16F:
return 6;
case nzPixelFormat_RGB16I:
return 6;
case nzPixelFormat_RGB32F:
return 12;
case nzPixelFormat_RGB32I:
return 12;
*/
case nzPixelFormat_RGBA16F:
return 8;
case nzPixelFormat_RGBA16I:
return 8;
/*
case nzPixelFormat_RGBA32F:
return 16;
case nzPixelFormat_RGBA32I:
return 16;
*/
case nzPixelFormat_RGBA4:
return 2;
case nzPixelFormat_R4G4A4A4:
case nzPixelFormat_RGB5A1:
return 2;
case nzPixelFormat_R5G5A5A1:
return 2;
case nzPixelFormat_R8:
return 1;
case nzPixelFormat_R8G8:
return 2;
case nzPixelFormat_R8G8B8:
case nzPixelFormat_RGB8:
return 3;
case nzPixelFormat_R8G8B8A8:
case nzPixelFormat_RGBA8:
return 4;
}
NazaraInternalError("Invalid pixel format");
return 0;
}
@ -68,4 +145,92 @@ inline bool NzPixelFormat::IsCompressed(nzPixelFormat format)
}
}
#include <Nazara/Core/DebugOff.hpp>
inline bool NzPixelFormat::IsValid(nzPixelFormat format)
{
switch (format)
{
case nzPixelFormat_Count:
case nzPixelFormat_Undefined:
return false;
default:
return true;
}
}
inline void NzPixelFormat::SetConvertFunction(nzPixelFormat srcFormat, nzPixelFormat dstFormat, ConvertFunction func)
{
s_convertFunctions[srcFormat][dstFormat] = func;
}
inline NzString NzPixelFormat::ToString(nzPixelFormat format)
{
switch (format)
{
case nzPixelFormat_BGR8:
return "BGR8";
case nzPixelFormat_BGRA8:
return "BGRA8";
case nzPixelFormat_DXT1:
return "DXT1";
case nzPixelFormat_DXT3:
return "DXT3";
case nzPixelFormat_DXT5:
return "DXT5";
case nzPixelFormat_L8:
return "L8";
case nzPixelFormat_LA8:
return "LA8";
/*
case nzPixelFormat_RGB16F:
return "RGB16F";
case nzPixelFormat_RGB16I:
return "RGB16I";
case nzPixelFormat_RGB32F:
return "RGB32F";
case nzPixelFormat_RGB32I:
return "RGB32I";
*/
case nzPixelFormat_RGBA16F:
return "RGBA16F";
case nzPixelFormat_RGBA16I:
return "RGBA16I";
/*
case nzPixelFormat_RGBA32F:
return "RGBA32F";
case nzPixelFormat_RGBA32I:
return "RGBA32I";
*/
case nzPixelFormat_RGBA4:
return "RGBA4";
case nzPixelFormat_RGB5A1:
return "RGB5A1";
case nzPixelFormat_RGB8:
return "RGB8";
case nzPixelFormat_RGBA8:
return "RGBA8";
default:
NazaraInternalError("Invalid pixel format");
case nzPixelFormat_Count:
case nzPixelFormat_Undefined:
return "Invalid format";
}
}
#include <Nazara/Utility/DebugOff.hpp>

2
include/Nazara/Utility/Window.hpp
View File

@ -10,11 +10,11 @@
#define NAZARA_WINDOW_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/Event.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Utility/VideoMode.hpp>
#include <Nazara/Utility/WindowHandle.hpp>
#include <queue>

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

@ -111,8 +111,9 @@ NzHashDigest NzHashCRC32::End()
{
m_state->crc ^= 0xFFFFFFFF;
if (NazaraEndianness == nzEndianness_LittleEndian)
NzByteSwap(&m_state->crc, sizeof(nzUInt32));
#ifdef NAZARA_LITTLE_ENDIAN
NzByteSwap(&m_state->crc, sizeof(nzUInt32));
#endif
return NzHashDigest(GetHashName(), reinterpret_cast<nzUInt8*>(&m_state->crc), 4);
}

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

@ -52,8 +52,10 @@ NzHashDigest NzHashFletcher16::End()
m_state->sum2 = (m_state->sum2 & 0xff) + (m_state->sum2 >> 8);
nzUInt32 fletcher = (m_state->sum2 << 8) | m_state->sum1;
if (NazaraEndianness == nzEndianness_BigEndian)
NzByteSwap(&fletcher, sizeof(nzUInt32));
#ifdef NAZARA_BIG_ENDIAN
NzByteSwap(&fletcher, sizeof(nzUInt32));
#endif
return NzHashDigest(GetHashName(), reinterpret_cast<nzUInt8*>(&fletcher), 2);
}

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

@ -114,7 +114,7 @@ namespace
nzUInt32 d = state->abcd[3];
nzUInt32 t;
#ifdef NAZARA_ENDIANNESS_BIGENDIAN
#ifdef NAZARA_BIG_ENDIAN
/* Define storage only for big-endian CPUs. */
nzUInt32 X[16];

36
src/Nazara/Core/Hash/SHA/Internal.cpp
View File

@ -42,7 +42,7 @@
#include <cstring>
/*** ENDIAN REVERSAL MACROS *******************************************/
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
#define REVERSE32(w,x) { \
nzUInt32 tmp = (w); \
@ -272,7 +272,7 @@ void SHA1_Init(SHA_CTX* context)
context->s1.bitcount = 0;
}
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
#define ROUND1_0_TO_15(a,b,c,d,e) \
REVERSE32(*data++, W1[j]); \
@ -281,7 +281,7 @@ void SHA1_Init(SHA_CTX* context)
(b) = ROTL32(30, (b)); \
j++;
#else // NAZARA_ENDIANNESS_LITTLEENDIAN
#else // NAZARA_LITTLE_ENDIAN
#define ROUND1_0_TO_15(a,b,c,d,e) \
(e) = ROTL32(5, (a)) + Ch((b), (c), (d)) + (e) + \
@ -289,7 +289,7 @@ void SHA1_Init(SHA_CTX* context)
(b) = ROTL32(30, (b)); \
j++;
#endif // NAZARA_ENDIANNESS_LITTLEENDIAN
#endif // NAZARA_LITTLE_ENDIAN
#define ROUND1_16_TO_19(a,b,c,d,e) \
T1 = W1[(j+13)&0x0f] ^ W1[(j+8)&0x0f] ^ W1[(j+2)&0x0f] ^ W1[j&0x0f]; \
@ -512,7 +512,7 @@ void SHA1_End(SHA_CTX* context, nzUInt8* digest)
}
}
/* Set the bit count: */
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
/* Convert FROM host byte order */
REVERSE64(context->s1.bitcount,context->s1.bitcount);
#endif
@ -523,7 +523,7 @@ void SHA1_End(SHA_CTX* context, nzUInt8* digest)
SHA1_Internal_Transform(context, reinterpret_cast<nzUInt32*>(context->s1.buffer));
/* Save the hash data for output: */
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
{
/* Convert TO host byte order */
for (int j = 0; j < (SHA1_DIGEST_LENGTH >> 2); j++)
@ -551,7 +551,7 @@ void SHA256_Init(SHA_CTX* context)
SHA256_Internal_Init(context, sha256_initial_hash_value);
}
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
REVERSE32(*data++, W256[j]); \
@ -561,7 +561,7 @@ void SHA256_Init(SHA_CTX* context)
(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
j++
#else // NAZARA_ENDIANNESS_LITTLEENDIAN
#else // NAZARA_LITTLE_ENDIAN
#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
@ -570,7 +570,7 @@ void SHA256_Init(SHA_CTX* context)
(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
j++
#endif // NAZARA_ENDIANNESS_LITTLEENDIAN
#endif // NAZARA_LITTLE_ENDIAN
#define ROUND256(a,b,c,d,e,f,g,h) \
s0 = W256[(j+1)&0x0f]; \
@ -693,7 +693,7 @@ void SHA256_Update(SHA_CTX* context, const nzUInt8 *data, std::size_t len)
void SHA256_Internal_Last(SHA_CTX* context)
{
unsigned int usedspace = (context->s256.bitcount >> 3) % 64;
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
/* Convert FROM host byte order */
REVERSE64(context->s256.bitcount,context->s256.bitcount);
#endif
@ -744,7 +744,7 @@ void SHA256_End(SHA_CTX* context, nzUInt8* digest)
SHA256_Internal_Last(context);
/* Save the hash data for output: */
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
{
/* Convert TO host byte order */
for (int j = 0; j < (SHA256_DIGEST_LENGTH >> 2); j++)
@ -786,7 +786,7 @@ void SHA224_End(SHA_CTX* context, nzUInt8* digest)
SHA256_Internal_Last(context);
/* Save the hash data for output: */
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
{
/* Convert TO host byte order */
for (int j = 0; j < (SHA224_DIGEST_LENGTH >> 2); j++)
@ -816,7 +816,7 @@ void SHA512_Init(SHA_CTX* context)
}
/* Unrolled SHA-512 round macros: */
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
REVERSE64(*data++, W512[j]); \
@ -827,7 +827,7 @@ void SHA512_Init(SHA_CTX* context)
j++
#else // NAZARA_ENDIANNESS_LITTLEENDIAN
#else // NAZARA_LITTLE_ENDIAN
#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
@ -836,7 +836,7 @@ void SHA512_Init(SHA_CTX* context)
(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
j++
#endif // NAZARA_ENDIANNESS_LITTLEENDIAN
#endif // NAZARA_LITTLE_ENDIAN
#define ROUND512(a,b,c,d,e,f,g,h) \
s0 = W512[(j+1)&0x0f]; \
@ -958,7 +958,7 @@ void SHA512_Internal_Last(SHA_CTX* context)
unsigned int usedspace;
usedspace = (context->s512.bitcount[0] >> 3) % 128;
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
/* Convert FROM host byte order */
REVERSE64(context->s512.bitcount[0],context->s512.bitcount[0]);
REVERSE64(context->s512.bitcount[1],context->s512.bitcount[1]);
@ -1011,7 +1011,7 @@ void SHA512_End(SHA_CTX* context, nzUInt8* digest)
SHA512_Internal_Last(context);
/* Save the hash data for output: */
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
{
/* Convert TO host byte order */
for (int j = 0; j < (SHA512_DIGEST_LENGTH >> 3); j++)
@ -1051,7 +1051,7 @@ void SHA384_End(SHA_CTX* context, nzUInt8* digest)
SHA512_Internal_Last(context);
/* Save the hash data for output: */
#ifdef NAZARA_ENDIANNESS_LITTLEENDIAN
#ifdef NAZARA_LITTLE_ENDIAN
{
/* Convert TO host byte order */
for (int j = 0; j < (SHA384_DIGEST_LENGTH >> 3); j++)

2
src/Nazara/Core/Win32/DirectoryImpl.hpp
View File

@ -8,7 +8,7 @@
#define NAZARA_DIRECTORYIMPL_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <windows.h>
class NzDirectory;

2
src/Nazara/Core/Win32/DynLibImpl.hpp
View File

@ -8,7 +8,7 @@
#define NAZARA_DYNLIBIMPL_HPP
#include <Nazara/Core/DynLib.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <windows.h>
class NzString;

2
src/Nazara/Core/Win32/FileImpl.hpp
View File

@ -9,7 +9,7 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/File.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <ctime>
#include <windows.h>

2
src/Nazara/Core/Win32/ThreadImpl.cpp
View File

@ -6,7 +6,7 @@
#include <Nazara/Core/Win32/ThreadImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Utility/Functor.hpp>
#include <Nazara/Core/Functor.hpp>
#include <process.h>
#include <Nazara/Core/Debug.hpp>

4
src/Nazara/Renderer/OpenGL.cpp
View File

@ -383,10 +383,6 @@ bool NzOpenGL::Initialize()
NzContextParameters::defaultMajorVersion = openGLversion/100;
NzContextParameters::defaultMinorVersion = (openGLversion%100)/10;
/*
NzContextParameters::defaultMajorVersion = std::min(openGLversion/100, 2U);
NzContextParameters::defaultMinorVersion = std::min((openGLversion%100)/10, 1U);
*/
if (!NzContext::InitializeReference())
{
NazaraError("Failed to initialize reference context");

97
src/Nazara/Utility/Image.cpp
View File

@ -36,6 +36,79 @@ NzImage::~NzImage()
ReleaseImage();
}
bool NzImage::Convert(nzPixelFormat format)
{
if (format == m_sharedImage->format)
return true;
#if NAZARA_UTILITY_SAFE
if (!IsValid())
{
NazaraError("Image must be valid");
return false;
}
if (!NzPixelFormat::IsValid(format))
{
NazaraError("Invalid pixel format");
return false;
}
#endif
EnsureOwnership();
unsigned int depth = (IsCubemap()) ? 6 : m_sharedImage->depth;
unsigned int pixelsPerFace = m_sharedImage->width*m_sharedImage->height;
nzUInt8* buffer;
if (depth > 1)
{
// Les images 3D sont un empilement d'images 2D
// Quant aux cubemaps, ils sont stockés côte à côte, ce qui revient au même
buffer = new nzUInt8[pixelsPerFace*depth*NzPixelFormat::GetBPP(format)];
nzUInt8* ptr = buffer;
nzUInt8* pixels = m_sharedImage->pixels;
unsigned int srcStride = pixelsPerFace * NzPixelFormat::GetBPP(m_sharedImage->format);
unsigned int dstStride = pixelsPerFace * NzPixelFormat::GetBPP(format);
for (unsigned int i = 0; i < depth; ++i)
{
if (!NzPixelFormat::Convert(m_sharedImage->format, format, pixels, &pixels[srcStride], ptr))
{
NazaraError("Failed to convert image");
delete[] buffer;
return false;
}
pixels += srcStride;
ptr += dstStride;
}
delete[] buffer;
}
else
{
buffer = new nzUInt8[pixelsPerFace*NzPixelFormat::GetBPP(format)];
if (!NzPixelFormat::Convert(m_sharedImage->format, format, m_sharedImage->pixels, &m_sharedImage->pixels[pixelsPerFace*NzPixelFormat::GetBPP(m_sharedImage->format)], buffer))
{
NazaraError("Failed to convert image");
delete[] buffer;
return false;
}
}
delete[] m_sharedImage->pixels;
m_sharedImage->format = format;
m_sharedImage->pixels = buffer;
return true;
}
bool NzImage::Copy(const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos)
{
#if NAZARA_UTILITY_SAFE
@ -78,6 +151,14 @@ bool NzImage::Create(nzImageType type, nzPixelFormat format, unsigned int width,
{
ReleaseImage();
#if NAZARA_UTILITY_SAFE
if (!NzPixelFormat::IsValid(format))
{
NazaraError("Invalid pixel format");
return false;
}
#endif
unsigned int size = width*height*depth*NzPixelFormat::GetBPP(format);
if (size == 0)
return true;
@ -131,7 +212,19 @@ bool NzImage::Create(nzImageType type, nzPixelFormat format, unsigned int width,
size *= 6; // Les cubemaps ont six faces
#endif
m_sharedImage = new SharedImage(1, type, format, new nzUInt8[size], width, height, depth);
// Cette allocation est protégée car sa taille dépend directement de paramètres utilisateurs
nzUInt8* buffer;
try
{
buffer = new nzUInt8[size];
}
catch (const std::exception& e)
{
NazaraError("Failed to allocate image buffer (" + NzString(e.what()) + ')');
return false;
}
m_sharedImage = new SharedImage(1, type, format, buffer, width, height, depth);
return true;
}
@ -472,4 +565,4 @@ void NzImage::ReleaseImage()
m_sharedImage = &emptyImage;
}
NzImage::SharedImage NzImage::emptyImage(0, nzImageType_2D, nzPixelFormat_R8G8B8, nullptr, 0, 0, 0);
NzImage::SharedImage NzImage::emptyImage(0, nzImageType_2D, nzPixelFormat_Undefined, nullptr, 0, 0, 0);

7
src/Nazara/Utility/Loaders/PCX.cpp
View File

@ -74,7 +74,7 @@ namespace
return false;
}
#if NAZARA_ENDIANNESS_BIGENDIAN
#if NAZARA_BIG_ENDIAN
// Les fichiers PCX sont en little endian
NzByteSwap(&header.xmin, sizeof(nzUInt16));
NzByteSwap(&header.ymin, sizeof(nzUInt16));
@ -93,7 +93,7 @@ namespace
unsigned int width = header.xmax - header.xmin+1;
unsigned int height = header.ymax - header.ymin+1;
if (!resource->Create(nzImageType_2D, nzPixelFormat_R8G8B8, width, height))
if (!resource->Create(nzImageType_2D, nzPixelFormat_RGB8, width, height))
{
NazaraError("Failed to create image");
return false;
@ -343,6 +343,9 @@ namespace
return false;
}
if (parameters.loadFormat != nzPixelFormat_Undefined)
resource->Convert(parameters.loadFormat);
return true;
}

47
src/Nazara/Utility/Loaders/STB.cpp
View File

@ -63,15 +63,44 @@ namespace
{
NazaraUnused(parameters);
static nzPixelFormat format[4] = {
static nzPixelFormat formats[4] = {
nzPixelFormat_L8,
nzPixelFormat_L8A8,
nzPixelFormat_R8G8B8,
nzPixelFormat_R8G8B8A8
nzPixelFormat_LA8,
nzPixelFormat_RGB8,
nzPixelFormat_RGBA8
};
nzPixelFormat format;
int stbiFormat;
switch (parameters.loadFormat)
{
case nzPixelFormat_L8:
format = nzPixelFormat_L8;
stbiFormat = STBI_grey;
break;
case nzPixelFormat_LA8:
format = nzPixelFormat_LA8;
stbiFormat = STBI_grey_alpha;
break;
case nzPixelFormat_RGB8:
format = nzPixelFormat_RGB8;
stbiFormat = STBI_rgb;
break;
case nzPixelFormat_RGBA8:
format = nzPixelFormat_RGBA8;
stbiFormat = STBI_rgb_alpha;
break;
default:
format = nzPixelFormat_Undefined;
stbiFormat = STBI_default;
}
int width, height, bpp;
nzUInt8* ptr = stbi_load_from_callbacks(&callbacks, &stream, &width, &height, &bpp, STBI_default);
nzUInt8* ptr = stbi_load_from_callbacks(&callbacks, &stream, &width, &height, &bpp, stbiFormat);
if (!ptr)
{
@ -79,7 +108,10 @@ namespace
return false;
}
if (!resource->Create(nzImageType_2D, format[bpp-1], width, height))
if (format == nzPixelFormat_Undefined)
format = formats[bpp-1];
if (!resource->Create(nzImageType_2D, format, width, height))
{
NazaraError("Failed to create image");
stbi_image_free(ptr);
@ -90,6 +122,9 @@ namespace
resource->Update(ptr);
stbi_image_free(ptr);
if (stbiFormat == STBI_default && parameters.loadFormat != nzPixelFormat_Undefined)
resource->Convert(parameters.loadFormat);
return true;
}

1161
src/Nazara/Utility/PixelFormat.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

9
src/Nazara/Utility/Utility.cpp
View File

@ -7,6 +7,7 @@
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/Loaders/PCX.hpp>
#include <Nazara/Utility/Loaders/STB.hpp>
#include <Nazara/Utility/PixelFormat.hpp>
#include <Nazara/Utility/Debug.hpp>
NzUtility::NzUtility()
@ -29,6 +30,12 @@ bool NzUtility::Initialize()
}
#endif
if (!NzPixelFormat::Initialize())
{
NazaraError("Failed to initialize pixel format");
return false;
}
// Loaders spécialisés
NzLoaders_PCX_Register(); // Loader de fichiers .PCX (1, 4, 8, 24)
@ -53,6 +60,8 @@ void NzUtility::Uninitialize()
NzLoaders_STB_Unregister();
NzLoaders_PCX_Unregister();
NzPixelFormat::Uninitialize();
s_initialized = false;
}

2
src/Nazara/Utility/Win32/WindowImpl.hpp
View File

@ -9,12 +9,12 @@
#ifndef NAZARA_WINDOWIMPL_HPP
#define NAZARA_WINDOWIMPL_HPP
#include <Nazara/Core/NonCopyable.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/Keyboard.hpp>
#include <Nazara/Utility/Mouse.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Utility/VideoMode.hpp>
#include <Nazara/Utility/Window.hpp>
#include <windows.h>