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

Added Image

Browse Source 
Added pixel format support
Added MemoryStream
Added Rect
Added ResourceLoader
Added generic loader (bmp, gif, hdr, jpg, jpeg, pic, png, psd, tga)
Added PCX loader
Added utility module initializer
Fixed Config.hpp include
Prerequesites.hpp now overwrites _WIN32_WINNT when defined
version is less than requiered version
Renderer's initialisation will implicitly initialize utility module
Removed RENDERER_SINGLETON option
Shaders are now resources
This commit is contained in:
Lynix
2012-05-21 21:54:13 +02:00
parent 47cdbbcdb0
commit 9b3f4e794a
51 changed files with 6845 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
include/Nazara/Core/ByteArray.hpp
View File

@@ -28,11 +28,13 @@ class NAZARA_API NzByteArray : public NzHashable
NzByteArray(SharedArray* sharedArray);
~NzByteArray();
unsigned int Capacity() const;
NzByteArray& Append(const NzByteArray& byteArray);
void Clear();
const nzUInt8* GetBuffer() const;
nzUInt8* GetBuffer();
unsigned int GetCapacity() const;
const nzUInt8* GetConstBuffer() const;
unsigned int GetSize() const;
NzByteArray& Insert(int pos, const nzUInt8* buffer, unsigned int bufferLength);
@@ -42,10 +44,10 @@ class NAZARA_API NzByteArray : public NzHashable
void Reserve(unsigned int bufferSize);
NzByteArray& Resize(int size, nzUInt8 byte = '\0');
NzByteArray Resized(int size, nzUInt8 byte = '\0') const;
NzByteArray& Resize(int size, nzUInt8 byte = 0);
NzByteArray Resized(int size, nzUInt8 byte = 0) const;
NzByteArray SubArray(int startPos, int endPos = -1) const;
NzByteArray Subarray(int startPos, int endPos = -1) const;
void Swap(NzByteArray& byteArray);
@@ -88,15 +90,15 @@ class NAZARA_API NzByteArray : public NzHashable
{
}
SharedArray(unsigned int bufferSize, unsigned int arraySize, unsigned short referenceCount, nzUInt8* ptr) :
allocatedSize(bufferSize),
SharedArray(unsigned short referenceCount, unsigned int bufferSize, unsigned int arraySize, nzUInt8* ptr) :
capacity(bufferSize),
size(arraySize),
refCount(referenceCount),
buffer(ptr)
{
}
unsigned int allocatedSize;
unsigned int capacity;
unsigned int size;
unsigned short refCount;
nzUInt8* buffer;
@@ -105,6 +107,7 @@ class NAZARA_API NzByteArray : public NzHashable
};
static SharedArray emptyArray;
static unsigned int npos;
private:
void EnsureOwnership();

6
include/Nazara/Core/InputStream.hpp
View File

@@ -14,8 +14,12 @@ class NzInputStream
public:
virtual ~NzInputStream();
virtual bool EndOfFile() const = 0;
virtual nzUInt64 GetCursorPos() const = 0;
virtual nzUInt64 GetSize() const = 0;
virtual std::size_t Read(void* buffer, std::size_t size) = 0;
virtual bool SetCursorPos(nzUInt64 offset) = 0;
};
#endif // NAZARA_INPUTSTREAM_HPP

34
include/Nazara/Core/MemoryStream.hpp Normal file
View File

@@ -0,0 +1,34 @@
// 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_MEMORYSTREAM_HPP
#define NAZARA_MEMORYSTREAM_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/InputStream.hpp>
class NAZARA_API NzMemoryStream : public NzInputStream
{
public:
NzMemoryStream(const void* ptr, nzUInt64 size);
~NzMemoryStream();
bool EndOfStream() const;
nzUInt64 GetCursorPos() const;
nzUInt64 GetSize() const;
std::size_t Read(void* buffer, std::size_t size);
bool SetCursorPos(nzUInt64 offset);
private:
const nzUInt8* m_ptr;
nzUInt64 m_pos;
nzUInt64 m_size;
};
#endif // NAZARA_MEMORYSTREAM_HPP

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

@@ -284,14 +284,14 @@ class NAZARA_API NzString : public NzHashable
}
SharedString(unsigned short referenceCount, unsigned int bufferSize, unsigned int stringSize, char* str) :
allocatedSize(bufferSize),
capacity(bufferSize),
size(stringSize),
string(str),
refCount(referenceCount)
{
}
unsigned int allocatedSize;
unsigned int capacity;
unsigned int size;
char* string;

1
include/Nazara/Math/Basic.hpp
View File

@@ -8,7 +8,6 @@
#define NAZARA_BASIC_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/Config.hpp>
#include <Nazara/Core/String.hpp>
#ifndef M_PI

1
include/Nazara/Math/Basic.inl
View File

@@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Config.hpp>
#include <algorithm>
#include <cmath>

1
include/Nazara/Math/EulerAngles.inl
View File

@@ -4,6 +4,7 @@
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Math/Basic.hpp>
#include <Nazara/Math/Config.hpp>
#include <Nazara/Math/Quaternion.hpp>
#include <Nazara/Math/Vector3.hpp>
#include <cmath>

3
include/Nazara/Math/Matrix4.hpp
View File

@@ -106,8 +106,7 @@ template<typename T> class NzMatrix4
T m31, m32, m33, m34;
T m41, m42, m43, m44;
unsigned int refCount;
unsigned short refCount;
NazaraMutex(mutex)
};

6
include/Nazara/Math/Matrix4.inl
View File

@@ -5,6 +5,7 @@
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Math/Basic.hpp>
#include <Nazara/Math/Config.hpp>
#include <Nazara/Math/EulerAngles.hpp>
#include <Nazara/Math/Quaternion.hpp>
#include <Nazara/Math/Vector2.hpp>
@@ -267,10 +268,7 @@ void NzMatrix4<T>::Set(const NzMatrix4& matrix)
template<typename T>
void NzMatrix4<T>::Set(NzMatrix4&& matrix)
{
ReleaseMatrix();
m_sharedMatrix = matrix.m_sharedMatrix;
matrix.m_sharedMatrix = nullptr;
std::swap(m_sharedMatrix, matrix.m_sharedMatrix);
}
template<typename T>

1
include/Nazara/Math/Quaternion.inl
View File

@@ -5,6 +5,7 @@
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Math/Basic.hpp>
#include <Nazara/Math/Config.hpp>
#include <Nazara/Math/EulerAngles.hpp>
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Core/Debug.hpp>

56
include/Nazara/Math/Rect.hpp Normal file
View File

@@ -0,0 +1,56 @@
// 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_RECT_HPP
#define NAZARA_RECT_HPP
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Vector2.hpp>
template<typename T>
class NzRect
{
public:
NzRect();
NzRect(T X, T Y, T Width, T Height);
NzRect(T rect[4]);
template<typename U> explicit NzRect(const NzRect<U>& rect);
NzRect(const NzRect& rect) = default;
~NzRect() = default;
bool Contains(T X, T Y) const;
bool Contains(const NzVector2<T>& point) const;
bool Contains(const NzRect& rect) const;
void ExtendTo(const NzVector2<T>& point);
void ExtendTo(const NzRect& rect);
bool Intersect(const NzRect& rect) const;
bool Intersect(const NzRect& rect, NzRect& intersection) const;
bool IsValid() const;
NzString ToString() const;
operator NzString() const;
T& operator[](unsigned int i);
T operator[](unsigned int i) const;
T x, y, width, height;
};
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzRect<T>& vec);
typedef NzRect<double> NzRectd;
typedef NzRect<float> NzRectf;
typedef NzRect<int> NzRecti;
typedef NzRect<unsigned int> NzRectui;
#include <Nazara/Math/Rect.inl>
#endif // NAZARA_RECT_HPP

162
include/Nazara/Math/Rect.inl Normal file
View File

@@ -0,0 +1,162 @@
// 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
#include <Nazara/Core/StringStream.hpp>
#include <algorithm>
#include <Nazara/Core/Debug.hpp>
template<typename T>
NzRect<T>::NzRect()
{
}
template<typename T>
NzRect<T>::NzRect(T X, T Y, T Width, T Height) :
x(X),
y(Y),
width(Width),
height(Height)
{
}
template<typename T>
NzRect<T>::NzRect(T vec[4]) :
x(vec[0]),
y(vec[1]),
width(vec[2]),
height(vec[3])
{
}
template<typename T>
template<typename U>
NzRect<T>::NzRect(const NzRect<U>& rect) :
x(static_cast<T>(rect.x)),
y(static_cast<T>(rect.y)),
width(static_cast<T>(rect.width)),
height(static_cast<T>(rect.height))
{
}
template<typename T>
bool NzRect<T>::Contains(T X, T Y) const
{
return X >= x && X < x+width &&
Y >= y && Y < y+height;
}
template<typename T>
bool NzRect<T>::Contains(const NzVector2<T>& point) const
{
return Contains(point.x, point.y);
}
template<typename T>
bool NzRect<T>::Contains(const NzRect<T>& rect) const
{
return Contains(rect.x, rect.y) &&
Contains(rect.x + rect.width, rect.y + rect.height);
}
template<typename T>
void NzRect<T>::ExtendTo(const NzVector2<T>& point)
{
x = std::min(x, point.x);
y = std::min(y, point.y);
width = std::max(x+width, point.x)-x;
height = std::max(x+width, point.x)-y;
}
template<typename T>
void NzRect<T>::ExtendTo(const NzRect& rect)
{
x = std::min(x, rect.x);
y = std::min(y, rect.y);
width = std::max(x+width, rect.x+rect.width)-x;
height = std::max(x+width, rect.x+rect.height)-y;
}
template<typename T>
bool NzRect<T>::Intersect(const NzRect& rect) const
{
NzRect intersection; // Optimisé par le compilateur
return Intersect(rect, intersection);
}
template<typename T>
bool NzRect<T>::Intersect(const NzRect& rect, NzRect& intersection) const
{
T left = std::max(x, rect.x);
T right = std::min(x+width, rect.x+rect.width);
T top = std::max(y, rect.y);
T bottom = std::min(y+height, rect.y+rect.height);
if (left < right && top < bottom)
{
intersection.x = left;
intersection.y = top;
intersection.width = right-left;
intersection.height = top-bottom;
return true;
}
else
return false;
}
template<typename T>
bool NzRect<T>::IsValid() const
{
return width > 0 && height > 0;
}
template<typename T>
NzString NzRect<T>::ToString() const
{
NzStringStream ss;
return ss << "Rect(" << x << ", " << y << ", " << width << ", " << height << ')';
}
template<typename T>
NzRect<T>::operator NzString() const
{
return ToString();
}
template<typename T>
T& NzRect<T>::operator[](unsigned int i)
{
if (i >= 4)
{
NzStringStream ss;
ss << __FILE__ << ':' << __LINE__ << ": Index out of range (" << i << " >= 4)";
throw std::domain_error(ss.ToString());
}
return *(&x+i);
}
template<typename T>
T NzRect<T>::operator[](unsigned int i) const
{
if (i >= 4)
{
NzStringStream ss;
ss << __FILE__ << ':' << __LINE__ << ": Index out of range (" << i << " >= 4)";
throw std::domain_error(ss.ToString());
}
return *(&x+i);
}
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzRect<T>& rect)
{
return out << rect.ToString();
}
#include <Nazara/Core/DebugOff.hpp>

1
include/Nazara/Math/Vector2.hpp
View File

@@ -74,6 +74,7 @@ template<typename T> NzVector2<T> operator/(T scale, const NzVector2<T>& vec);
typedef NzVector2<double> NzVector2d;
typedef NzVector2<float> NzVector2f;
typedef NzVector2<int> NzVector2i;
typedef NzVector2<unsigned int> NzVector2ui;
#include <Nazara/Math/Vector2.inl>

32
include/Nazara/Prerequesites.hpp
View File

@@ -5,15 +5,17 @@
#ifndef NAZARA_PREREQUESITES_HPP
#define NAZARA_PREREQUESITES_HPP
// Version du moteur
#define NAZARA_VERSION_MAJOR 0
#define NAZARA_VERSION_MINOR 1
// (Commenté en attendant GCC 4.7)
/*#if __cplusplus < 201103L
#error Nazara requires a C++11 compliant compiler
#endif*/
// Version du moteur
#define NAZARA_VERSION_MAJOR 0
#define NAZARA_VERSION_MINOR 1
#include <Nazara/Core/Config.hpp>
///TODO: Rajouter des tests d'identification de compilateurs
#if defined(_MSC_VER)
#define NAZARA_COMPILER_MSVC
@@ -59,11 +61,25 @@
#define NOMINMAX
#endif
#ifndef _WIN32_WINNT
#ifdef NAZARA_PLATFORM_WINDOWSVISTA
#define _WIN32_WINNT 0x0600 // Version de Windows minimale : Vista
#if NAZARA_CORE_WINDOWS_VISTA
// Version de Windows minimale : Vista
#if defined(_WIN32_WINNT)
#if _WIN32_WINNT < 0x0600
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif
#else
#define _WIN32_WINNT 0x0501 // Version de Windows minimale : XP
#define _WIN32_WINNT 0x0600
#endif
#else
// Version de Windows minimale : XP
#if defined(_WIN32_WINNT)
#if _WIN32_WINNT < 0x0501
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
#else
#define _WIN32_WINNT 0x0501
#endif
#endif
#endif

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

@@ -8,6 +8,7 @@
#define NAZARA_BUFFER_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Utility/Resource.hpp>
enum nzBufferLock
@@ -39,7 +40,7 @@ enum nzBufferUsage
class NzBufferImpl;
class NzRenderer;
class NAZARA_API NzBuffer : public NzResource
class NAZARA_API NzBuffer : public NzResource, NzNonCopyable
{
friend class NzRenderer;

3
include/Nazara/Renderer/Config.hpp
View File

@@ -41,7 +41,4 @@
// Active les tests de sécurité basés sur le code (Conseillé pour le développement)
#define NAZARA_RENDERER_SAFE 1
// Fait en sorte que le Renderer soit un singleton plutôt qu'une instance globale
#define NAZARA_RENDERER_SINGLETON 0
#endif // NAZARA_CONFIG_MODULENAME_HPP

1
include/Nazara/Renderer/RenderTarget.hpp
View File

@@ -8,6 +8,7 @@
#define NAZARA_RENDERTARGET_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/RenderTargetParameters.hpp>
class NzRenderer;

1
include/Nazara/Renderer/RenderWindow.hpp
View File

@@ -11,6 +11,7 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Renderer/RenderTarget.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Utility/Window.hpp>
#ifndef NAZARA_RENDERER_COMMON

13
include/Nazara/Renderer/Renderer.hpp
View File

@@ -44,9 +44,10 @@ enum nzRendererClear
nzRendererClear_Stencil = 0x04
};
class NzRenderTarget;
class NzIndexBuffer;
class NzRenderTarget;
class NzShader;
class NzUtility;
class NzVertexBuffer;
class NzVertexDeclaration;
@@ -79,23 +80,23 @@ class NAZARA_API NzRenderer
void Uninitialize();
#if NAZARA_RENDERER_SINGLETON
static void Destroy();
#endif
static NzRenderer* Instance();
static bool IsInitialized();
private:
bool UpdateVertexBuffer();
static NzRenderer* s_instance;
const NzIndexBuffer* m_indexBuffer;
NzRenderTarget* m_target;
NzShader* m_shader;
NzUtility* m_utilityModule;
const NzVertexBuffer* m_vertexBuffer;
const NzVertexDeclaration* m_vertexDeclaration;
bool m_capabilities[nzRendererCap_Count];
bool m_vertexBufferUpdated;
static NzRenderer* s_instance;
static bool s_initialized;
};
#endif // NAZARA_RENDERER_HPP

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

@@ -10,6 +10,8 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Matrix4.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
#include <Nazara/Utility/Resource.hpp>
enum nzShaderLanguage
{
@@ -31,7 +33,7 @@ enum nzShaderType
class NzRenderer;
class NzShaderImpl;
class NAZARA_API NzShader
class NAZARA_API NzShader : public NzResource, NzNonCopyable
{
friend class NzRenderer;

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

@@ -35,7 +35,7 @@
// Active les tests de sécurité basés sur le code (Conseillé pour le développement)
#define NAZARA_UTILITY_SAFE 1
// Fait tourner chaque fenêtre dans un thread séparé
// Fait tourner chaque fenêtre dans un thread séparé si le système le supporte
#define NAZARA_UTILITY_THREADED_WINDOW 1
#endif // NAZARA_CONFIG_UTILITY_HPP

135
include/Nazara/Utility/Image.hpp Normal file
View File

@@ -0,0 +1,135 @@
// 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_IMAGE_HPP
#define NAZARA_IMAGE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/InputStream.hpp>
#include <Nazara/Math/Rect.hpp>
#include <Nazara/Utility/ResourceLoader.hpp>
#include <Nazara/Utility/PixelFormat.hpp>
#include <Nazara/Utility/Resource.hpp>
//#include <Nazara/Utility/ThreadSafety.hpp>
enum nzCubemapFace
{
nzCubemapFace_PositiveX,
nzCubemapFace_NegativeX,
nzCubemapFace_PositiveY,
nzCubemapFace_NegativeY,
nzCubemapFace_PositiveZ,
nzCubemapFace_NegativeZ
};
enum nzImageType
{
nzImageType_1D,
nzImageType_2D,
nzImageType_3D,
nzImageType_Cubemap
};
struct NzImageParams
{
bool IsValid() const
{
return true;
}
};
///TODO: Filtres
///TODO: Mipmaps
class NAZARA_API NzImage : public NzResource, public NzResourceLoader<NzImage, NzImageParams>
{
public:
struct SharedImage;
NzImage();
NzImage(const NzImage& image);
NzImage(NzImage&& image);
NzImage(SharedImage* sharedImage);
~NzImage();
bool Copy(const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos);
bool CopyToFace(nzCubemapFace face, const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos);
bool Create(nzImageType type, nzPixelFormat format, unsigned int width, unsigned int height = 1, unsigned int depth = 1);
void Destroy();
nzUInt8 GetBPP() const;
const nzUInt8* GetConstPixels() const;
unsigned int GetDepth() const;
nzPixelFormat GetFormat() const;
unsigned int GetHeight() const;
nzUInt8* GetPixels();
unsigned int GetSize() const;
nzImageType GetType() const;
unsigned int GetWidth() const;
bool IsCompressed() const;
bool IsCubemap() const;
bool IsValid() const;
bool LoadFromFile(const NzString& filePath, const NzImageParams& params = NzImageParams());
bool LoadFromMemory(const void* data, std::size_t size, const NzImageParams& params = NzImageParams());
bool LoadFromStream(NzInputStream& stream, const NzImageParams& params = NzImageParams());
bool Update(const nzUInt8* pixels);
bool Update(const nzUInt8* pixels, const NzRectui& rect);
bool UpdateFace(nzCubemapFace face, const nzUInt8* pixels);
bool UpdateFace(nzCubemapFace face, const nzUInt8* pixels, const NzRectui& rect);
NzImage& operator=(const NzImage& image);
NzImage& operator=(NzImage&& image);
static void RegisterFileLoader(const NzString& extensions, LoadFileFunction loadFile);
static void RegisterMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory);
static void RegisterStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream);
static void UnregisterFileLoader(const NzString& extensions, LoadFileFunction loadFile);
static void UnregisterMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory);
static void UnregisterStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream);
struct SharedImage
{
SharedImage() : // Vivement GCC 4.7 sur Windows
refCount(1)
{
}
SharedImage(unsigned short RefCount, nzImageType Type, nzPixelFormat Format, nzUInt8* Pixels, unsigned int Width, unsigned int Height = 1, unsigned int Depth = 1) :
type(Type),
format(Format),
pixels(Pixels),
depth(Depth),
height(Height),
width(Width),
refCount(RefCount)
{
}
nzImageType type;
nzPixelFormat format;
nzUInt8* pixels;
unsigned int depth;
unsigned int height;
unsigned int width;
unsigned short refCount;
NazaraMutex(mutex)
};
static SharedImage emptyImage;
private:
void EnsureOwnership();
void ReleaseImage();
SharedImage* m_sharedImage;
};
#endif // NAZARA_IMAGE_HPP

40
include/Nazara/Utility/PixelFormat.hpp Normal file
View File

@@ -0,0 +1,40 @@
// 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_PIXELFORMAT_HPP
#define NAZARA_PIXELFORMAT_HPP
#include <Nazara/Prerequesites.hpp>
enum nzPixelFormat
{
nzPixelFormat_Undefined,
nzPixelFormat_B8G8R8,
nzPixelFormat_B8G8R8A8,
nzPixelFormat_DXT1,
nzPixelFormat_DXT3,
nzPixelFormat_DXT5,
nzPixelFormat_L8,
nzPixelFormat_L8A8,
nzPixelFormat_R4G4A4A4,
nzPixelFormat_R5G5A5A1,
nzPixelFormat_R8,
nzPixelFormat_R8G8,
nzPixelFormat_R8G8B8,
nzPixelFormat_R8G8B8A8
};
class NzPixelFormat
{
public:
static nzUInt8 GetBPP(nzPixelFormat format);
static bool IsCompressed(nzPixelFormat format);
};
#include <Nazara/Utility/PixelFormat.inl>
#endif // NAZARA_PIXELFORMAT_HPP

71
include/Nazara/Utility/PixelFormat.inl Normal file
View File

@@ -0,0 +1,71 @@
// 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
#include <Nazara/Core/Debug.hpp>
inline nzUInt8 NzPixelFormat::GetBPP(nzPixelFormat format)
{
switch (format)
{
case nzPixelFormat_Undefined:
return 0;
case nzPixelFormat_B8G8R8:
return 3;
case nzPixelFormat_B8G8R8A8:
return 4;
case nzPixelFormat_DXT1:
return 1;
case nzPixelFormat_DXT3:
return 2;
case nzPixelFormat_DXT5:
return 2;
case nzPixelFormat_L8:
return 1;
case nzPixelFormat_L8A8:
return 2;
case nzPixelFormat_R4G4A4A4:
return 2;
case nzPixelFormat_R5G5A5A1:
return 2;
case nzPixelFormat_R8:
return 1;
case nzPixelFormat_R8G8:
return 2;
case nzPixelFormat_R8G8B8:
return 3;
case nzPixelFormat_R8G8B8A8:
return 4;
}
return 0;
}
inline bool NzPixelFormat::IsCompressed(nzPixelFormat format)
{
switch (format)
{
case nzPixelFormat_DXT1:
case nzPixelFormat_DXT3:
case nzPixelFormat_DXT5:
return true;
default:
return false;
}
}
#include <Nazara/Core/DebugOff.hpp>

4
include/Nazara/Utility/Resource.hpp
View File

@@ -8,12 +8,12 @@
#define NAZARA_RESOURCE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Utility/NonCopyable.hpp>
class NAZARA_API NzResource : NzNonCopyable
class NAZARA_API NzResource
{
public:
NzResource(bool persistent = true);
NzResource(const NzResource& resource);
virtual ~NzResource();
void AddResourceReference() const;

49
include/Nazara/Utility/ResourceLoader.hpp Normal file
View File

@@ -0,0 +1,49 @@
// 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_RESOURCELOADER_HPP
#define NAZARA_RESOURCELOADER_HPP
#include <Nazara/Core/String.hpp>
#include <list>
#include <map>
#include <utility>
class NzInputStream;
template<typename Type, typename Parameters>
class NzResourceLoader
{
public:
typedef bool (*IsMemoryLoadingSupportedFunction)(const void* data, unsigned int size, const Parameters& parameters);
typedef bool (*IsStreamLoadingSupportedFunction)(NzInputStream& stream, const Parameters& parameters);
typedef bool (*LoadFileFunction)(Type* resource, const NzString& filePath, const Parameters& parameters);
typedef bool (*LoadMemoryFunction)(Type* resource, const void* data, unsigned int size, const Parameters& parameters);
typedef bool (*LoadStreamFunction)(Type* resource, NzInputStream& stream, const Parameters& parameters);
protected:
static bool LoadResourceFromFile(Type* resource, const NzString& filePath, const Parameters& parameters);
static bool LoadResourceFromMemory(Type* resource, const void* data, unsigned int size, const Parameters& parameters);
static bool LoadResourceFromStream(Type* resource, NzInputStream& stream, const Parameters& parameters);
static void RegisterResourceFileLoader(const NzString& extensions, LoadFileFunction loadFile);
static void RegisterResourceMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory);
static void RegisterResourceStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream);
static void UnregisterResourceFileLoader(const NzString& extensions, LoadFileFunction loadFile);
static void UnregisterResourceMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory);
static void UnregisterResourceStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream);
private:
typedef std::pair<IsMemoryLoadingSupportedFunction, LoadMemoryFunction> MemoryLoader;
typedef std::pair<IsStreamLoadingSupportedFunction, LoadStreamFunction> StreamLoader;
static std::list<MemoryLoader> s_memoryLoaders;
static std::list<StreamLoader> s_streamLoaders;
static std::multimap<NzString, LoadFileFunction> s_fileLoaders;
};
#include <Nazara/Utility/ResourceLoader.inl>
#endif // NAZARA_RESOURCELOADER_HPP

186
include/Nazara/Utility/ResourceLoader.inl Normal file
View File

@@ -0,0 +1,186 @@
// 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
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/File.hpp>
#include <Nazara/Core/InputStream.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/Debug.hpp>
template<typename Type, typename Parameters>
bool NzResourceLoader<Type, Parameters>::LoadResourceFromFile(Type* resource, const NzString& filePath, const Parameters& parameters)
{
#if NAZARA_UTILITY_SAFE
if (!parameters.IsValid())
{
NazaraError("Invalid Parameters");
return false;
}
#endif
NzString path = NzFile::NormalizePath(filePath);
NzString ext = path.SubstrFrom('.', -1, true);
if (ext.IsEmpty())
{
NazaraError("Failed to get file extension");
return false;
}
// Récupération de tous les loaders de cette extension
auto range = s_fileLoaders.equal_range(ext);
if (range.first == range.second)
{
NazaraError("No loader found for extension \"" + ext + '"');
return false;
}
for (auto it = range.first; it != range.second; ++it)
{
// Chargement de la ressource
if (it->second(resource, filePath, parameters))
return true;
NazaraWarning("Loader failed");
}
NazaraError("Failed to load file: all loaders failed");
return false;
}
template<typename Type, typename Parameters>
bool NzResourceLoader<Type, Parameters>::LoadResourceFromMemory(Type* resource, const void* data, unsigned int size, const Parameters& parameters)
{
#if NAZARA_UTILITY_SAFE
if (!parameters.IsValid())
{
NazaraError("Invalid Parameters");
return false;
}
if (!data || size == 0)
{
NazaraError("No data to load");
return false;
}
#endif
for (auto loader = s_memoryLoaders.begin(); loader != s_memoryLoaders.end(); ++loader)
{
// Le loader supporte-t-il les données ?
if (!loader->first(data, size, parameters))
continue;
// Chargement de la ressource
if (loader->second(resource, data, size, parameters))
return true;
NazaraWarning("Loader failed");
}
NazaraError("Failed to load file: all loaders failed");
return false;
}
template<typename Type, typename Parameters>
bool NzResourceLoader<Type, Parameters>::LoadResourceFromStream(Type* resource, NzInputStream& stream, const Parameters& parameters)
{
#if NAZARA_UTILITY_SAFE
if (!parameters.IsValid())
{
NazaraError("Invalid Parameters");
return false;
}
if (stream.GetSize() == 0 || stream.GetCursorPos() >= stream.GetSize())
{
NazaraError("No data to load");
return false;
}
#endif
nzUInt64 streamPos = stream.GetCursorPos();
for (auto loader = s_streamLoaders.begin(); loader != s_streamLoaders.end(); ++loader)
{
stream.SetCursorPos(streamPos);
// Le loader supporte-t-il les données ?
if (!loader->first(stream, parameters))
continue;
stream.SetCursorPos(streamPos);
// Chargement de la ressource
if (loader->second(resource, stream, parameters))
return true;
NazaraWarning("Loader failed");
}
NazaraError("Failed to load file: all loaders failed");
return false;
}
template<typename Type, typename Parameters>
void NzResourceLoader<Type, Parameters>::RegisterResourceFileLoader(const NzString& extensions, LoadFileFunction loadFile)
{
std::vector<NzString> exts;
extensions.SplitAny(exts, " /\\*.,;|-_");
for (const NzString& ext : exts)
s_fileLoaders.insert(std::make_pair(ext, loadFile));
}
template<typename Type, typename Parameters>
void NzResourceLoader<Type, Parameters>::RegisterResourceMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory)
{
s_memoryLoaders.push_back(std::make_pair(isLoadingSupported, loadMemory));
}
template<typename Type, typename Parameters>
void NzResourceLoader<Type, Parameters>::RegisterResourceStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream)
{
s_streamLoaders.push_back(std::make_pair(isLoadingSupported, loadStream));
}
template<typename Type, typename Parameters>
void NzResourceLoader<Type, Parameters>::UnregisterResourceFileLoader(const NzString& extensions, LoadFileFunction loadFile)
{
std::vector<NzString> exts;
extensions.SplitAny(exts, " /\\*.,;|-_");
for (const NzString& ext : exts)
{
// Récupération de tous les loaders de cette extension
auto range = s_fileLoaders.equal_range(ext);
for (auto it = range.first; it != range.second; ++it)
{
if (it->second == loadFile)
{
s_fileLoaders.erase(it);
break;
}
}
}
//s_fileLoaders.erase(std::make_pair(ext, loadFile));
}
template<typename Type, typename Parameters>
void NzResourceLoader<Type, Parameters>::UnregisterResourceMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory)
{
s_memoryLoaders.remove(std::make_pair(isLoadingSupported, loadMemory));
}
template<typename Type, typename Parameters>
void NzResourceLoader<Type, Parameters>::UnregisterResourceStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream)
{
s_streamLoaders.remove(std::make_pair(isLoadingSupported, loadStream));
}
template<typename T, typename P> std::list<typename NzResourceLoader<T, P>::MemoryLoader> NzResourceLoader<T, P>::s_memoryLoaders;
template<typename T, typename P> std::list<typename NzResourceLoader<T, P>::StreamLoader> NzResourceLoader<T, P>::s_streamLoaders;
template<typename T, typename P> std::multimap<NzString, typename NzResourceLoader<T, P>::LoadFileFunction> NzResourceLoader<T, P>::s_fileLoaders;
#include <Nazara/Utility/DebugOff.hpp>

27
include/Nazara/Utility/Utility.hpp Normal file
View File

@@ -0,0 +1,27 @@
// 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_UTILITY_HPP
#define NAZARA_UTILITY_HPP
#include <Nazara/Prerequesites.hpp>
class NAZARA_API NzUtility
{
public:
NzUtility();
~NzUtility();
bool Initialize();
void Uninitialize();
static bool IsInitialized();
private:
static bool s_initialized;
};
#endif // NAZARA_UTILITY_HPP