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

177
src/Nazara/Core/ByteArray.cpp
View File

@@ -3,6 +3,29 @@
#include <cstring>
#include <Nazara/Core/Debug.hpp>
inline unsigned int nzPow2(unsigned int n)
{
unsigned int x = 1;
while(x <= n)
x <<= 1;
return x;
}
// Cet algorithme est inspiré de la documentation de Qt
inline unsigned int nzGetNewSize(unsigned int newSize)
{
if (newSize < 20)
return newSize+4;
else
{
if (newSize < (1 << 12)-12)
return nzPow2(newSize << 1)-12;
else
return newSize + (1 << 11);
}
}
NzByteArray::NzByteArray() :
m_sharedArray(&emptyArray)
{
@@ -13,10 +36,10 @@ NzByteArray::NzByteArray(const nzUInt8* buffer, unsigned int bufferLength)
if (bufferLength > 0)
{
m_sharedArray = new SharedArray;
m_sharedArray->allocatedSize = bufferLength;
m_sharedArray->buffer = new nzUInt8[bufferLength];
m_sharedArray->capacity = bufferLength;
m_sharedArray->size = bufferLength;
std::memcpy(m_sharedArray->buffer, buffer, bufferLength*sizeof(nzUInt8));
std::memcpy(m_sharedArray->buffer, buffer, bufferLength);
}
else
m_sharedArray = &emptyArray;
@@ -49,9 +72,38 @@ NzByteArray::~NzByteArray()
ReleaseArray();
}
unsigned int NzByteArray::Capacity() const
NzByteArray& NzByteArray::Append(const NzByteArray& byteArray)
{
return m_sharedArray->allocatedSize;
if (byteArray.m_sharedArray->size == 0)
return *this;
if (m_sharedArray->size == 0 && m_sharedArray->capacity < byteArray.m_sharedArray->size)
return operator=(byteArray);
if (m_sharedArray->capacity >= m_sharedArray->size + byteArray.m_sharedArray->size)
{
EnsureOwnership();
std::memcpy(&m_sharedArray->buffer[m_sharedArray->size], byteArray.m_sharedArray->buffer, byteArray.m_sharedArray->size);
m_sharedArray->size += byteArray.m_sharedArray->size;
}
else
{
unsigned int newSize = m_sharedArray->size + byteArray.m_sharedArray->size;
unsigned int bufferSize = nzGetNewSize(newSize);
nzUInt8* buffer = new nzUInt8[bufferSize+1];
std::memcpy(buffer, m_sharedArray->buffer, m_sharedArray->size);
std::memcpy(&buffer[m_sharedArray->size], byteArray.m_sharedArray->buffer, byteArray.m_sharedArray->size);
ReleaseArray();
m_sharedArray = new SharedArray;
m_sharedArray->buffer = buffer;
m_sharedArray->capacity = bufferSize;
m_sharedArray->size = newSize;
}
return *this;
}
void NzByteArray::Clear()
@@ -59,7 +111,19 @@ void NzByteArray::Clear()
ReleaseArray();
}
const nzUInt8* NzByteArray::GetBuffer() const
nzUInt8* NzByteArray::GetBuffer()
{
EnsureOwnership();
return m_sharedArray->buffer;
}
unsigned int NzByteArray::GetCapacity() const
{
return m_sharedArray->capacity;
}
const nzUInt8* NzByteArray::GetConstBuffer() const
{
return m_sharedArray->buffer;
}
@@ -83,12 +147,12 @@ NzByteArray& NzByteArray::Insert(int pos, const nzUInt8* buffer, unsigned int bu
unsigned int start = std::min(static_cast<unsigned int>(pos), m_sharedArray->size);
// Si le buffer est déjà suffisamment grand
if (m_sharedArray->allocatedSize >= m_sharedArray->size + bufferLength)
if (m_sharedArray->capacity >= m_sharedArray->size + bufferLength)
{
EnsureOwnership();
std::memmove(&m_sharedArray->buffer[start+bufferLength], &m_sharedArray->buffer[start], m_sharedArray->size*sizeof(nzUInt8));
std::memcpy(&m_sharedArray->buffer[start], buffer, bufferLength*sizeof(nzUInt8));
std::memmove(&m_sharedArray->buffer[start+bufferLength], &m_sharedArray->buffer[start], m_sharedArray->size);
std::memcpy(&m_sharedArray->buffer[start], buffer, bufferLength);
m_sharedArray->size += bufferLength;
}
@@ -118,7 +182,55 @@ NzByteArray& NzByteArray::Insert(int pos, const nzUInt8* buffer, unsigned int bu
return *this;
}
NzByteArray& NzByteArray::Insert(int pos, const NzByteArray& byteArray);
NzByteArray& NzByteArray::Insert(int pos, const NzByteArray& byteArray)
{
if (string.m_sharedArray->size == 0)
return *this;
if (m_sharedArray->size == 0 && m_sharedArray->capacity < string.m_sharedArray->size)
return operator=(string);
if (pos < 0)
pos = std::max(static_cast<int>(m_sharedArray->size + pos), 0);
unsigned int start = std::min(static_cast<unsigned int>(pos), m_sharedArray->size);
// Si le buffer est déjà suffisamment grand
if (m_sharedArray->capacity >= m_sharedArray->size + string.m_sharedArray->size)
{
EnsureOwnership();
std::memmove(&m_sharedArray->string[start+string.m_sharedArray->size], &m_sharedArray->string[start], m_sharedArray->size*sizeof(char));
std::memcpy(&m_sharedArray->string[start], string.m_sharedArray->string, string.m_sharedArray->size*sizeof(char));
m_sharedArray->size += string.m_sharedArray->size;
}
else
{
unsigned int newSize = m_sharedArray->size+string.m_sharedArray->size;
char* newString = new char[newSize+1];
char* ptr = newString;
const char* s = m_sharedArray->string;
while (ptr != &newString[start])
*ptr++ = *s++;
const char* p = string.m_sharedArray->string;
while (ptr != &newString[start+string.m_sharedArray->size])
*ptr++ = *p++;
std::strcpy(ptr, s);
ReleaseString();
m_sharedArray = new SharedString;
m_sharedArray->capacity = newSize;
m_sharedArray->size = newSize;
m_sharedArray->string = newString;
}
return *this;
}
bool NzByteArray::IsEmpty() const
{
@@ -130,9 +242,9 @@ void NzByteArray::Reserve(unsigned int bufferSize)
if (m_sharedArray->allocatedSize >= bufferSize)
return;
char* ptr = new char[bufferSize+1];
nzUInt8* ptr = new nzUInt8[bufferSize+1];
if (m_sharedArray->size > 0)
std::strcpy(ptr, m_sharedArray->buffer);
std::memcpy(ptr, m_sharedArray->buffer, m_sharedArray->size);
unsigned int size = m_sharedArray->size;
@@ -143,45 +255,6 @@ void NzByteArray::Reserve(unsigned int bufferSize)
m_sharedArray->size = size;
}
NzByteArray& NzByteArray::Resize(int size, nzUInt8 byte = '\0');
NzByteArray NzByteArray::Resized(int size, nzUInt8 byte = '\0') const;
NzByteArray SubArray(int startPos, int endPos = -1) const;
void Swap(NzByteArray& byteArray);
NzByteArray& Trim(nzUInt8 byte = '\0');
NzByteArray Trimmed(nzUInt8 byte = '\0') const;
// Méthodes compatibles STD
nzUInt8* begin();
const nzUInt8* begin() const;
nzUInt8* end();
const nzUInt8* end() const;
void push_front(nzUInt8 c);
void push_back(nzUInt8 c);
typedef const nzUInt8& const_reference;
typedef nzUInt8* iterator;
//typedef nzUInt8* reverse_iterator;
typedef nzUInt8 value_type;
// Méthodes compatibles STD
nzUInt8& operator[](unsigned int pos);
nzUInt8 operator[](unsigned int pos) const;
NzByteArray& operator=(const NzByteArray& byteArray);
NzByteArray& operator=(NzByteArray&& byteArray);
NzByteArray operator+(const NzByteArray& byteArray) const;
NzByteArray& operator+=(const NzByteArray& byteArray);
static int Compare(const NzByteArray& first, const NzByteArray& second);
static SharedArray emptyArray;
private:
void EnsureOwnership();
bool FillHash(NzHashImpl* hash) const;
void ReleaseArray();
NzByteArray::SharedString NzByteArray::emptyArray(0, 0, 0, nullptr);
unsigned int NzByteArray::npos(static_cast<unsigned int>(-1));
*/

50
src/Nazara/Core/MemoryStream.cpp Normal file
View File

@@ -0,0 +1,50 @@
// 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/MemoryStream.hpp>
#include <algorithm>
#include <cstring>
#include <Nazara/Core/Debug.hpp>
NzMemoryStream::NzMemoryStream(const void* ptr, nzUInt64 size) :
m_ptr(static_cast<const nzUInt8*>(ptr)),
m_pos(0),
m_size(size)
{
}
NzMemoryStream::~NzMemoryStream()
{
}
bool NzMemoryStream::EndOfStream() const
{
return m_pos == m_size;
}
nzUInt64 NzMemoryStream::GetCursorPos() const
{
return m_pos;
}
nzUInt64 NzMemoryStream::GetSize() const
{
return m_size;
}
std::size_t NzMemoryStream::Read(void* buffer, std::size_t size)
{
unsigned int readSize = std::min(static_cast<nzUInt64>(size), m_size-m_pos);
std::memcpy(buffer, &m_ptr[m_pos], readSize);
m_pos += readSize;
return readSize;
}
bool NzMemoryStream::SetCursorPos(nzUInt64 offset)
{
m_pos = std::min(offset, m_size);
return true;
}

84
src/Nazara/Core/String.cpp
View File

@@ -91,7 +91,7 @@ NzString::NzString(char character)
else
{
m_sharedString = new SharedString;
m_sharedString->allocatedSize = 1;
m_sharedString->capacity = 1;
m_sharedString->size = 1;
m_sharedString->string = new char[2];
m_sharedString->string[0] = character;
@@ -107,7 +107,7 @@ NzString::NzString(const char* string)
if (size > 0)
{
m_sharedString = new SharedString;
m_sharedString->allocatedSize = size;
m_sharedString->capacity = size;
m_sharedString->size = size;
m_sharedString->string = new char[size+1];
std::strcpy(m_sharedString->string, string);
@@ -124,7 +124,7 @@ NzString::NzString(const std::string& string)
if (string.size() > 0)
{
m_sharedString = new SharedString;
m_sharedString->allocatedSize = string.capacity();
m_sharedString->capacity = string.capacity();
m_sharedString->size = string.size();
m_sharedString->string = new char[string.capacity()+1];
std::strcpy(m_sharedString->string, string.c_str());
@@ -165,10 +165,10 @@ NzString& NzString::Append(char character)
if (character == '\0')
return *this;
if (m_sharedString->size == 0 && m_sharedString->allocatedSize == 0)
if (m_sharedString->size == 0 && m_sharedString->capacity == 0)
return operator=(character);
if (m_sharedString->allocatedSize > m_sharedString->size)
if (m_sharedString->capacity > m_sharedString->size)
{
EnsureOwnership();
@@ -188,7 +188,7 @@ NzString& NzString::Append(char character)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = bufferSize;
m_sharedString->capacity = bufferSize;
m_sharedString->size = newSize;
m_sharedString->string = str;
}
@@ -205,7 +205,7 @@ NzString& NzString::Append(const char* string)
if (length == 0)
return *this;
if (m_sharedString->allocatedSize >= m_sharedString->size + length)
if (m_sharedString->capacity >= m_sharedString->size + length)
{
EnsureOwnership();
@@ -223,7 +223,7 @@ NzString& NzString::Append(const char* string)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = bufferSize;
m_sharedString->capacity = bufferSize;
m_sharedString->size = newSize;
m_sharedString->string = str;
}
@@ -236,10 +236,10 @@ NzString& NzString::Append(const NzString& string)
if (string.m_sharedString->size == 0)
return *this;
if (m_sharedString->size == 0 && m_sharedString->allocatedSize < string.m_sharedString->size)
if (m_sharedString->size == 0 && m_sharedString->capacity < string.m_sharedString->size)
return operator=(string);
if (m_sharedString->allocatedSize >= m_sharedString->size + string.m_sharedString->size)
if (m_sharedString->capacity >= m_sharedString->size + string.m_sharedString->size)
{
EnsureOwnership();
@@ -257,7 +257,7 @@ NzString& NzString::Append(const NzString& string)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = bufferSize;
m_sharedString->capacity = bufferSize;
m_sharedString->size = newSize;
m_sharedString->string = str;
}
@@ -2231,7 +2231,7 @@ char* NzString::GetBuffer()
unsigned int NzString::GetCapacity() const
{
return m_sharedString->allocatedSize;
return m_sharedString->capacity;
}
const char* NzString::GetConstBuffer() const
@@ -2464,7 +2464,7 @@ NzString& NzString::Insert(int pos, char character)
if (character == '\0')
return *this;
if (m_sharedString->size == 0 && m_sharedString->allocatedSize == 0)
if (m_sharedString->size == 0 && m_sharedString->capacity == 0)
return operator=(character);
if (pos < 0)
@@ -2473,7 +2473,7 @@ NzString& NzString::Insert(int pos, char character)
unsigned int start = std::min(static_cast<unsigned int>(pos), m_sharedString->size);
// Si le buffer est déjà suffisamment grand
if (m_sharedString->allocatedSize >= m_sharedString->size+1)
if (m_sharedString->capacity >= m_sharedString->size+1)
{
EnsureOwnership();
@@ -2499,7 +2499,7 @@ NzString& NzString::Insert(int pos, char character)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = newSize;
m_sharedString->capacity = newSize;
m_sharedString->size = newSize;
m_sharedString->string = newString;
}
@@ -2519,7 +2519,7 @@ NzString& NzString::Insert(int pos, const char* string)
// Si le buffer est déjà suffisamment grand
unsigned int len = std::strlen(string);
if (m_sharedString->allocatedSize >= m_sharedString->size+len)
if (m_sharedString->capacity >= m_sharedString->size+len)
{
EnsureOwnership();
@@ -2547,7 +2547,7 @@ NzString& NzString::Insert(int pos, const char* string)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = newSize;
m_sharedString->capacity = newSize;
m_sharedString->size = newSize;
m_sharedString->string = newString;
}
@@ -2560,7 +2560,7 @@ NzString& NzString::Insert(int pos, const NzString& string)
if (string.m_sharedString->size == 0)
return *this;
if (m_sharedString->size == 0 && m_sharedString->allocatedSize < string.m_sharedString->size)
if (m_sharedString->size == 0 && m_sharedString->capacity < string.m_sharedString->size)
return operator=(string);
if (pos < 0)
@@ -2569,7 +2569,7 @@ NzString& NzString::Insert(int pos, const NzString& string)
unsigned int start = std::min(static_cast<unsigned int>(pos), m_sharedString->size);
// Si le buffer est déjà suffisamment grand
if (m_sharedString->allocatedSize >= m_sharedString->size + string.m_sharedString->size)
if (m_sharedString->capacity >= m_sharedString->size + string.m_sharedString->size)
{
EnsureOwnership();
@@ -2597,7 +2597,7 @@ NzString& NzString::Insert(int pos, const NzString& string)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = newSize;
m_sharedString->capacity = newSize;
m_sharedString->size = newSize;
m_sharedString->string = newString;
}
@@ -2870,7 +2870,7 @@ unsigned int NzString::Replace(const char* oldString, const char* replaceString,
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = newSize;
m_sharedString->capacity = newSize;
m_sharedString->size = newSize;
m_sharedString->string = newString;
}
@@ -2940,7 +2940,7 @@ unsigned int NzString::Replace(const NzString& oldString, const NzString& replac
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = newSize;
m_sharedString->capacity = newSize;
m_sharedString->size = newSize;
m_sharedString->string = newString;
}
@@ -3180,7 +3180,7 @@ unsigned int NzString::ReplaceAny(const char* oldCharacters, char replaceCharact
*/
void NzString::Reserve(unsigned int bufferSize)
{
if (m_sharedString->allocatedSize >= bufferSize)
if (m_sharedString->capacity >= bufferSize)
return;
char* ptr = new char[bufferSize+1];
@@ -3191,7 +3191,7 @@ void NzString::Reserve(unsigned int bufferSize)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = bufferSize;
m_sharedString->capacity = bufferSize;
m_sharedString->size = size;
m_sharedString->string = ptr;
}
@@ -3203,7 +3203,7 @@ NzString& NzString::Resize(int size, char character)
unsigned int newSize = static_cast<unsigned int>(size);
if (m_sharedString->allocatedSize >= newSize)
if (m_sharedString->capacity >= newSize)
{
EnsureOwnership();
@@ -3232,7 +3232,7 @@ NzString& NzString::Resize(int size, char character)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = newSize;
m_sharedString->capacity = newSize;
m_sharedString->size = newSize;
m_sharedString->string = newString;
}
@@ -4103,13 +4103,13 @@ NzString& NzString::operator=(char character)
{
if (character != '\0')
{
if (m_sharedString->allocatedSize >= 1)
if (m_sharedString->capacity >= 1)
EnsureOwnership();
else
{
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = 1;
m_sharedString->capacity = 1;
m_sharedString->string = new char[2];
}
@@ -4128,14 +4128,14 @@ NzString& NzString::operator=(const char* string)
if (string && string[0] != '\0')
{
unsigned int size = std::strlen(string);
if (m_sharedString->allocatedSize >= size)
if (m_sharedString->capacity >= size)
EnsureOwnership();
else
{
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = size;
m_sharedString->capacity = size;
m_sharedString->string = new char[size+1];
}
@@ -4152,14 +4152,14 @@ NzString& NzString::operator=(const std::string& string)
{
if (string.size() > 0)
{
if (m_sharedString->allocatedSize >= string.size())
if (m_sharedString->capacity >= string.size())
EnsureOwnership();
else
{
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = string.size();
m_sharedString->capacity = string.size();
m_sharedString->string = new char[string.size()+1];
}
@@ -4269,7 +4269,7 @@ NzString& NzString::operator+=(char character)
if (m_sharedString->size == 0)
return operator=(character);
if (m_sharedString->allocatedSize > m_sharedString->size)
if (m_sharedString->capacity > m_sharedString->size)
{
EnsureOwnership();
@@ -4289,7 +4289,7 @@ NzString& NzString::operator+=(char character)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = bufferSize;
m_sharedString->capacity = bufferSize;
m_sharedString->size = newSize;
m_sharedString->string = str;
}
@@ -4309,7 +4309,7 @@ NzString& NzString::operator+=(const char* string)
if (length == 0)
return *this;
if (m_sharedString->allocatedSize >= m_sharedString->size + length)
if (m_sharedString->capacity >= m_sharedString->size + length)
{
EnsureOwnership();
@@ -4327,7 +4327,7 @@ NzString& NzString::operator+=(const char* string)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = bufferSize;
m_sharedString->capacity = bufferSize;
m_sharedString->size = newSize;
m_sharedString->string = str;
}
@@ -4343,7 +4343,7 @@ NzString& NzString::operator+=(const std::string& string)
if (m_sharedString->size == 0)
return operator=(string);
if (m_sharedString->allocatedSize >= m_sharedString->size + string.size())
if (m_sharedString->capacity >= m_sharedString->size + string.size())
{
EnsureOwnership();
@@ -4361,7 +4361,7 @@ NzString& NzString::operator+=(const std::string& string)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = bufferSize;
m_sharedString->capacity = bufferSize;
m_sharedString->size = newSize;
m_sharedString->string = str;
}
@@ -4377,7 +4377,7 @@ NzString& NzString::operator+=(const NzString& string)
if (m_sharedString->size == 0)
return operator=(string);
if (m_sharedString->allocatedSize >= m_sharedString->size + string.m_sharedString->size)
if (m_sharedString->capacity >= m_sharedString->size + string.m_sharedString->size)
{
EnsureOwnership();
@@ -4395,7 +4395,7 @@ NzString& NzString::operator+=(const NzString& string)
ReleaseString();
m_sharedString = new SharedString;
m_sharedString->allocatedSize = bufferSize;
m_sharedString->capacity = bufferSize;
m_sharedString->size = newSize;
m_sharedString->string = str;
}
@@ -5037,10 +5037,10 @@ void NzString::EnsureOwnership()
{
m_sharedString->refCount--;
char* string = new char[m_sharedString->allocatedSize+1];
char* string = new char[m_sharedString->capacity+1];
std::strcpy(string, m_sharedString->string);
m_sharedString = new SharedString(1, m_sharedString->allocatedSize, m_sharedString->size, string);
m_sharedString = new SharedString(1, m_sharedString->capacity, m_sharedString->size, string);
}
}

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

@@ -7,6 +7,8 @@
#include <Nazara/Core/Win32/Time.hpp>
#include <Nazara/Core/Debug.hpp>
///TODO: Faire en sorte que le EOF corresponde aux autres EOF de Nazara
NzFileImpl::NzFileImpl(const NzFile* parent) :
m_endOfFile(false)
{

1
src/Nazara/Renderer/Buffer.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Renderer/OpenGL.hpp>
#include <Nazara/Renderer/Buffer.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/HardwareBuffer.hpp>
#include <Nazara/Renderer/Renderer.hpp>
#include <Nazara/Renderer/SoftwareBuffer.hpp>

1
src/Nazara/Renderer/IndexBuffer.cpp
View File

@@ -4,6 +4,7 @@
#include <Nazara/Renderer/IndexBuffer.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <stdexcept>
#include <Nazara/Renderer/Debug.hpp>

1
src/Nazara/Renderer/OcclusionQuery.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Renderer/OpenGL.hpp>
#include <Nazara/Renderer/OcclusionQuery.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/Renderer.hpp>
#include <stdexcept>
#include <Nazara/Renderer/Debug.hpp>

1
src/Nazara/Renderer/RenderWindow.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Renderer/OpenGL.hpp>
#include <Nazara/Renderer/RenderWindow.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/Context.hpp>
#include <Nazara/Renderer/ContextParameters.hpp>
#include <Nazara/Renderer/Debug.hpp>

57
src/Nazara/Renderer/Renderer.cpp
View File

@@ -6,12 +6,14 @@
#include <Nazara/Renderer/Renderer.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Renderer/BufferImpl.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/Context.hpp>
#include <Nazara/Renderer/IndexBuffer.hpp>
#include <Nazara/Renderer/RenderTarget.hpp>
#include <Nazara/Renderer/Shader.hpp>
#include <Nazara/Renderer/ShaderImpl.hpp>
#include <Nazara/Renderer/VertexBuffer.hpp>
#include <Nazara/Utility/Utility.hpp>
#include <stdexcept>
#include <Nazara/Renderer/Debug.hpp>
@@ -45,7 +47,8 @@ m_vertexBufferUpdated(false)
NzRenderer::~NzRenderer()
{
Uninitialize();
if (s_initialized)
Uninitialize();
s_instance = nullptr;
}
@@ -166,6 +169,21 @@ bool NzRenderer::HasCapability(nzRendererCap capability) const
bool NzRenderer::Initialize()
{
#if NAZARA_RENDERER_SAFE
if (s_initialized)
{
NazaraError("Renderer already initialized");
return true;
}
#endif
// Initialisation du module Utility
if (!NzUtility::IsInitialized())
{
m_utilityModule = new NzUtility;
m_utilityModule->Initialize();
}
if (NzOpenGL::Initialize())
{
m_capabilities[nzRendererCap_AnisotropicFilter] = NzOpenGL::IsSupported(NzOpenGL::AnisotropicFilter);
@@ -179,6 +197,8 @@ bool NzRenderer::Initialize()
m_capabilities[nzRendererCap_TextureMulti] = true; // Natif depuis OpenGL 1.3
m_capabilities[nzRendererCap_TextureNPOT] = true; // Natif depuis OpenGL 2.0
s_initialized = true;
return true;
}
else
@@ -329,23 +349,28 @@ bool NzRenderer::SetVertexDeclaration(const NzVertexDeclaration* vertexDeclarati
void NzRenderer::Uninitialize()
{
NzOpenGL::Uninitialize();
}
#if NAZARA_RENDERER_SAFE
if (!s_initialized)
{
NazaraError("Renderer not initialized");
return;
}
#endif
#if NAZARA_RENDERER_SINGLETON
void NzRenderer::Destroy()
{
delete s_instance;
s_instance = nullptr;
NzOpenGL::Uninitialize();
s_initialized = false;
if (m_utilityModule)
{
delete m_utilityModule;
m_utilityModule = nullptr;
}
}
#endif
NzRenderer* NzRenderer::Instance()
{
#if NAZARA_RENDERER_SINGLETON
if (!s_instance)
s_instance = new NzRenderer;
#elif defined(NAZARA_DEBUG)
#if defined(NAZARA_DEBUG)
if (!s_instance)
NazaraError("Renderer not instanced");
#endif
@@ -353,6 +378,11 @@ NzRenderer* NzRenderer::Instance()
return s_instance;
}
bool NzRenderer::IsInitialized()
{
return s_initialized;
}
bool NzRenderer::UpdateVertexBuffer()
{
#if NAZARA_RENDERER_SAFE
@@ -384,3 +414,4 @@ bool NzRenderer::UpdateVertexBuffer()
}
NzRenderer* NzRenderer::s_instance = nullptr;
bool NzRenderer::s_initialized = false;

1
src/Nazara/Renderer/Shader.cpp
View File

@@ -7,6 +7,7 @@
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/File.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/GLSLShader.hpp>
#include <Nazara/Renderer/Renderer.hpp>
#include <Nazara/Renderer/ShaderImpl.hpp>

1
src/Nazara/Renderer/SoftwareBuffer.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Renderer/OpenGL.hpp>
#include <Nazara/Renderer/SoftwareBuffer.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <cstring>
#include <stdexcept>
#include <Nazara/Renderer/Debug.hpp>

1
src/Nazara/Renderer/VertexDeclaration.cpp
View File

@@ -4,6 +4,7 @@
#include <Nazara/Renderer/VertexDeclaration.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Renderer/Config.hpp>
#include <Nazara/Renderer/Renderer.hpp>
#include <Nazara/Renderer/Debug.hpp>

475
src/Nazara/Utility/Image.cpp Normal file
View File

@@ -0,0 +1,475 @@
// 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/Utility/Image.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/ResourceLoader.hpp>
#include <Nazara/Utility/Debug.hpp>
NzImage::NzImage() :
m_sharedImage(&emptyImage)
{
}
NzImage::NzImage(const NzImage& image) :
NzResource(image),
m_sharedImage(image.m_sharedImage)
{
if (m_sharedImage != &emptyImage)
{
NazaraMutexLock(m_sharedImage->mutex);
m_sharedImage->refCount++;
NazaraMutexUnlock(m_sharedImage->mutex);
}
}
NzImage::NzImage(NzImage&& image) :
m_sharedImage(image.m_sharedImage)
{
image.m_sharedImage = &emptyImage;
}
NzImage::~NzImage()
{
ReleaseImage();
}
bool NzImage::Copy(const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos)
{
#if NAZARA_UTILITY_SAFE
if (!source.IsValid())
{
NazaraError("Source image must be valid");
return false;
}
if (source.GetFormat() != m_sharedImage->format)
{
NazaraError("Source image format does not match destination image format");
return false;
}
#endif
return Update(&source.GetConstPixels()[(srcRect.x + srcRect.y * source.GetHeight()) * source.GetBPP()], NzRectui(dstPos.x, dstPos.y, srcRect.width, srcRect.height));
}
bool NzImage::CopyToFace(nzCubemapFace face, const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos)
{
#if NAZARA_UTILITY_SAFE
if (!source.IsValid())
{
NazaraError("Source image must be valid");
return false;
}
if (source.GetFormat() != m_sharedImage->format)
{
NazaraError("Source image format does not match destination image format");
return false;
}
#endif
return UpdateFace(face, &source.GetConstPixels()[(srcRect.x + srcRect.y * source.GetHeight()) * source.GetBPP()], NzRectui(dstPos.x, dstPos.y, srcRect.width, srcRect.height));
}
bool NzImage::Create(nzImageType type, nzPixelFormat format, unsigned int width, unsigned int height, unsigned int depth)
{
ReleaseImage();
unsigned int size = width*height*depth*NzPixelFormat::GetBPP(format);
if (size == 0)
return true;
#if NAZARA_UTILITY_SAFE
switch (type)
{
case nzImageType_1D:
if (height > 1)
{
NazaraError("1D textures must be 1 height");
return false;
}
if (depth > 1)
{
NazaraError("1D textures must be 1 depth");
return false;
}
break;
case nzImageType_2D:
if (depth > 1)
{
NazaraError("2D textures must be 1 depth");
return false;
}
break;
case nzImageType_Cubemap:
if (depth > 1)
{
NazaraError("Cubemaps must be 1 depth");
return false;
}
if (width != height)
{
NazaraError("Cubemaps must have square dimensions");
return false;
}
size *= 6; // Les cubemaps ont six faces
break;
default:
break;
}
#else
if (type == nzImageType_Cubemap)
size *= 6; // Les cubemaps ont six faces
#endif
m_sharedImage = new SharedImage(1, type, format, new nzUInt8[size], width, height, depth);
return true;
}
void NzImage::Destroy()
{
ReleaseImage();
}
nzUInt8 NzImage::GetBPP() const
{
return NzPixelFormat::GetBPP(m_sharedImage->format);
}
const nzUInt8* NzImage::GetConstPixels() const
{
return m_sharedImage->pixels;
}
unsigned int NzImage::GetDepth() const
{
return m_sharedImage->depth;
}
nzPixelFormat NzImage::GetFormat() const
{
return m_sharedImage->format;
}
unsigned int NzImage::GetHeight() const
{
return m_sharedImage->height;
}
nzUInt8* NzImage::GetPixels()
{
EnsureOwnership();
return m_sharedImage->pixels;
}
unsigned int NzImage::GetSize() const
{
return m_sharedImage->width * m_sharedImage->height * m_sharedImage->depth * NzPixelFormat::GetBPP(m_sharedImage->format);
}
nzImageType NzImage::GetType() const
{
return m_sharedImage->type;
}
unsigned int NzImage::GetWidth() const
{
return m_sharedImage->width;
}
bool NzImage::IsCompressed() const
{
return NzPixelFormat::IsCompressed(m_sharedImage->format);
}
bool NzImage::IsCubemap() const
{
return m_sharedImage->type == nzImageType_Cubemap;
}
bool NzImage::IsValid() const
{
return m_sharedImage != &emptyImage;
}
bool NzImage::LoadFromFile(const NzString& filePath, const NzImageParams& params)
{
return NzResourceLoader<NzImage, NzImageParams>::LoadResourceFromFile(this, filePath, params);
}
bool NzImage::LoadFromMemory(const void* data, std::size_t size, const NzImageParams& params)
{
return NzResourceLoader<NzImage, NzImageParams>::LoadResourceFromMemory(this, data, size, params);
}
bool NzImage::LoadFromStream(NzInputStream& stream, const NzImageParams& params)
{
return NzResourceLoader<NzImage, NzImageParams>::LoadResourceFromStream(this, stream, params);
}
bool NzImage::Update(const nzUInt8* pixels)
{
#if NAZARA_UTILITY_SAFE
if (!IsValid())
{
NazaraError("Image must be valid");
return false;
}
if (IsCubemap())
{
NazaraError("Update is not designed for cubemaps, use UpdateFace instead");
return false;
}
if (!pixels)
{
NazaraError("Invalid pixel source");
return false;
}
#endif
EnsureOwnership();
std::memcpy(m_sharedImage->pixels, pixels, GetSize());
return true;
}
bool NzImage::Update(const nzUInt8* pixels, const NzRectui& rect)
{
#if NAZARA_UTILITY_SAFE
if (!IsValid())
{
NazaraError("Image must be valid");
return false;
}
if (IsCubemap())
{
NazaraError("Update is not designed for cubemaps, use UpdateFace instead");
return false;
}
if (!pixels)
{
NazaraError("Invalid pixel source");
return false;
}
if (!rect.IsValid())
{
NazaraError("Invalid rectangle");
return false;
}
if (rect.width > m_sharedImage->width || rect.height > m_sharedImage->height)
{
NazaraError("Rectangle dimensions are out of bounds");
return false;
}
#endif
EnsureOwnership();
nzUInt8 bpp = NzPixelFormat::GetBPP(m_sharedImage->format);
nzUInt8* dstPixels = m_sharedImage->pixels + (rect.x + rect.y * m_sharedImage->width) * bpp;
unsigned int srcStride = rect.width * bpp;
unsigned int dstStride = m_sharedImage->width * bpp;
unsigned int blockSize = m_sharedImage->width * bpp;
for (unsigned int i = 0; i < rect.height; ++i)
{
std::memcpy(dstPixels, pixels, blockSize);
pixels += srcStride;
dstPixels += dstStride;
}
return true;
}
bool NzImage::UpdateFace(nzCubemapFace face, const nzUInt8* pixels)
{
#if NAZARA_UTILITY_SAFE
if (!IsValid())
{
NazaraError("Image must be valid");
return false;
}
if (!IsCubemap())
{
NazaraError("Update is only designed for cubemaps, use Update instead");
return false;
}
if (!pixels)
{
NazaraError("Invalid pixel source");
return false;
}
#endif
EnsureOwnership();
unsigned int size = GetSize();
std::memcpy(&m_sharedImage->pixels[size*(face-nzCubemapFace_PositiveX)], pixels, size);
return true;
}
bool NzImage::UpdateFace(nzCubemapFace face, const nzUInt8* pixels, const NzRectui& rect)
{
#if NAZARA_UTILITY_SAFE
if (!IsValid())
{
NazaraError("Image must be valid");
return false;
}
if (!IsCubemap())
{
NazaraError("Update is only designed for cubemaps, use Update instead");
return false;
}
if (!pixels)
{
NazaraError("Invalid pixel source");
return false;
}
if (!rect.IsValid())
{
NazaraError("Invalid rectangle");
return false;
}
if (rect.width > m_sharedImage->width || rect.height > m_sharedImage->height)
{
NazaraError("Rectangle dimensions are out of bounds");
return false;
}
#endif
EnsureOwnership();
nzUInt8 bpp = NzPixelFormat::GetBPP(m_sharedImage->format);
nzUInt8* dstPixels = m_sharedImage->pixels + (rect.x + rect.y * m_sharedImage->width + (face-nzCubemapFace_PositiveX)*m_sharedImage->width*m_sharedImage->height) * bpp;
unsigned int srcStride = rect.width * bpp;
unsigned int dstStride = m_sharedImage->width * bpp;
unsigned int blockSize = m_sharedImage->width * bpp;
for (unsigned int i = 0; i < rect.height; ++i)
{
std::memcpy(dstPixels, pixels, blockSize);
pixels += srcStride;
dstPixels += dstStride;
}
return true;
}
NzImage& NzImage::operator=(const NzImage& image)
{
ReleaseImage();
m_sharedImage = image.m_sharedImage;
if (m_sharedImage != &emptyImage)
{
NazaraMutexLock(m_sharedImage->mutex);
m_sharedImage->refCount++;
NazaraMutexUnlock(m_sharedImage->mutex);
}
return *this;
}
NzImage& NzImage::operator=(NzImage&& image)
{
std::swap(m_sharedImage, image.m_sharedImage);
return *this;
}
void NzImage::RegisterFileLoader(const NzString& extensions, LoadFileFunction loadFile)
{
return RegisterResourceFileLoader(extensions, loadFile);
}
void NzImage::RegisterMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory)
{
return RegisterResourceMemoryLoader(isLoadingSupported, loadMemory);
}
void NzImage::RegisterStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream)
{
return RegisterResourceStreamLoader(isLoadingSupported, loadStream);
}
void NzImage::UnregisterFileLoader(const NzString& extensions, LoadFileFunction loadFile)
{
UnregisterResourceFileLoader(extensions, loadFile);
}
void NzImage::UnregisterMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory)
{
UnregisterResourceMemoryLoader(isLoadingSupported, loadMemory);
}
void NzImage::UnregisterStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream)
{
UnregisterResourceStreamLoader(isLoadingSupported, loadStream);
}
void NzImage::EnsureOwnership()
{
if (m_sharedImage == &emptyImage)
return;
NazaraLock(m_sharedImage->mutex);
if (m_sharedImage->refCount > 1)
{
m_sharedImage->refCount--;
unsigned int size = GetSize();
nzUInt8* pixels = new nzUInt8[size];
std::memcpy(pixels, m_sharedImage->pixels, size);
m_sharedImage = new SharedImage(1, m_sharedImage->type, m_sharedImage->format, pixels, m_sharedImage->width, m_sharedImage->height, m_sharedImage->depth);
}
}
void NzImage::ReleaseImage()
{
if (m_sharedImage == &emptyImage)
return;
NazaraMutexLock(m_sharedImage->mutex);
m_sharedImage->refCount--;
NazaraMutexUnlock(m_sharedImage->mutex);
if (m_sharedImage->refCount == 0)
{
delete[] m_sharedImage->pixels;
delete m_sharedImage;
}
m_sharedImage = &emptyImage;
}
NzImage::SharedImage NzImage::emptyImage(0, nzImageType_2D, nzPixelFormat_R8G8B8, nullptr, 0, 0, 0);

365
src/Nazara/Utility/Loaders/PCX.cpp Normal file
View File

@@ -0,0 +1,365 @@
// Copyright (C) 2011 Jérôme Leclercq
// This file is part of the "Ungine".
// For conditions of distribution and use, see copyright notice in Core.h
#include <Nazara/Utility/Loaders/PCX.hpp>
#include <Nazara/Core/Endianness.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/File.hpp>
#include <Nazara/Core/InputStream.hpp>
#include <Nazara/Core/MemoryStream.hpp>
#include <Nazara/Utility/Image.hpp>
#include <Nazara/Utility/Debug.hpp>
// Auteur du loader original : David Henry
namespace
{
struct pcx_header
{
nzUInt8 manufacturer;
nzUInt8 version;
nzUInt8 encoding;
nzUInt8 bitsPerPixel;
nzUInt16 xmin, ymin;
nzUInt16 xmax, ymax;
nzUInt16 horzRes, vertRes;
nzUInt8 palette[48];
nzUInt8 reserved;
nzUInt8 numColorPlanes;
nzUInt16 bytesPerScanLine;
nzUInt16 paletteType;
nzUInt16 horzSize, vertSize;
nzUInt8 padding[54];
};
bool NzLoader_PCX_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters);
bool NzLoader_PCX_LoadFile(NzImage* resource, const NzString& filePath, const NzImageParams& parameters)
{
NzFile file(filePath);
if (!file.Open(NzFile::ReadOnly))
{
NazaraError("Failed to open file");
return false;
}
return NzLoader_PCX_LoadStream(resource, file, parameters);
}
bool NzLoader_PCX_LoadMemory(NzImage* resource, const void* data, unsigned int size, const NzImageParams& parameters)
{
NzMemoryStream stream(data, size);
return NzLoader_PCX_LoadStream(resource, stream, parameters);
}
bool NzLoader_PCX_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
pcx_header header;
if (stream.Read(&header, sizeof(pcx_header)) != sizeof(pcx_header))
{
NazaraError("Failed to read header");
return false;
}
if (header.manufacturer != 0x0a)
{
NazaraError("Bad version number (" + NzString::Number(header.manufacturer) + ')');
return false;
}
unsigned int bitCount = header.bitsPerPixel * header.numColorPlanes;
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))
{
NazaraError("Failed to create image");
return false;
}
nzUInt8* pixels = resource->GetPixels();
int rle_value = 0;
unsigned int rle_count = 0;
switch (bitCount)
{
case 1:
{
for (unsigned int y = 0; y < height; ++y)
{
nzUInt8* ptr = &pixels[y * width * 3];
int bytes = header.bytesPerScanLine;
/* decode line number y */
while (bytes--)
{
if (rle_count == 0)
{
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
return false;
}
if (rle_value < 0xc0)
rle_count = 1;
else
{
rle_count = rle_value - 0xc0;
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
return false;
}
}
}
rle_count--;
for (int i = 7; i >= 0; --i)
{
int colorIndex = ((rle_value & (1 << i)) > 0);
*ptr++ = header.palette[colorIndex * 3 + 0];
*ptr++ = header.palette[colorIndex * 3 + 1];
*ptr++ = header.palette[colorIndex * 3 + 2];
}
}
}
break;
}
case 4:
{
nzUInt8* colorIndex = new nzUInt8[width];
nzUInt8* line = new nzUInt8[header.bytesPerScanLine];
for (unsigned int y = 0; y < height; ++y)
{
nzUInt8* ptr = &pixels[y * width * 3];
std::memset(colorIndex, 0, width);
for (unsigned int c = 0; c < 4; ++c)
{
nzUInt8* pLine = line;
int bytes = header.bytesPerScanLine;
/* decode line number y */
while (bytes--)
{
if (rle_count == 0)
{
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
delete[] colorIndex;
delete[] line;
return false;
}
if (rle_value < 0xc0)
rle_count = 1;
else
{
rle_count = rle_value - 0xc0;
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
delete[] colorIndex;
delete[] line;
return false;
}
}
}
rle_count--;
*(pLine++) = rle_value;
}
/* compute line's color indexes */
for (unsigned int x = 0; x < width; ++x)
{
if (line[x / 8] & (128 >> (x % 8)))
colorIndex[x] += (1 << c);
}
}
/* decode scan line. color index => rgb */
for (unsigned int x = 0; x < width; ++x)
{
*ptr++ = header.palette[colorIndex[x] * 3 + 0];
*ptr++ = header.palette[colorIndex[x] * 3 + 1];
*ptr++ = header.palette[colorIndex[x] * 3 + 2];
}
}
/* release memory */
delete[] colorIndex;
delete[] line;
break;
}
case 8:
{
nzUInt8 palette[768];
/* the palette is contained in the last 769 bytes of the file */
unsigned int curPos = stream.GetCursorPos();
stream.SetCursorPos(stream.GetSize()-769);
nzUInt8 magic;
if (!stream.Read(&magic, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
return false;
}
/* first byte must be equal to 0x0c (12) */
if (magic != 0x0c)
{
NazaraError("Colormap's first byte must be 0x0c (0x" + NzString::Number(magic, 16) + ')');
return false;
}
/* read palette */
if (stream.Read(palette, 768) != 768)
{
NazaraError("Failed to read palette");
return false;
}
stream.SetCursorPos(curPos);
/* read pixel data */
for (unsigned int y = 0; y < height; ++y)
{
nzUInt8* ptr = &pixels[y * width * 3];
int bytes = header.bytesPerScanLine;
/* decode line number y */
while (bytes--)
{
if (rle_count == 0)
{
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
return false;
}
if (rle_value < 0xc0)
rle_count = 1;
else
{
rle_count = rle_value - 0xc0;
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
return false;
}
}
}
rle_count--;
*ptr++ = palette[rle_value * 3 + 0];
*ptr++ = palette[rle_value * 3 + 1];
*ptr++ = palette[rle_value * 3 + 2];
}
}
break;
}
case 24:
{
for (unsigned int y = 0; y < height; ++y)
{
/* for each color plane */
for (int c = 0; c < 3; ++c)
{
nzUInt8* ptr = &pixels[y * width * 4];
int bytes = header.bytesPerScanLine;
/* decode line number y */
while (bytes--)
{
if (rle_count == 0)
{
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
return false;
}
if (rle_value < 0xc0)
rle_count = 1;
else
{
rle_count = rle_value - 0xc0;
if (!stream.Read(&rle_value, 1))
{
NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
return false;
}
}
}
rle_count--;
ptr[c] = static_cast<nzUInt8>(rle_value);
ptr += 3;
}
}
}
break;
}
default:
NazaraError("Unknown " + NzString::Number(bitCount) + " bitcount pcx files");
return false;
}
return true;
}
bool NzLoader_PCX_IsMemoryLoadingSupported(const void* data, unsigned int size, const NzImageParams& parameters)
{
NazaraUnused(parameters);
if (size < sizeof(pcx_header))
return false;
return *reinterpret_cast<const nzUInt8*>(data) == 0x0a;
}
bool NzLoader_PCX_IsStreamLoadingSupported(NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
nzUInt8 manufacturer;
stream.Read(&manufacturer, 1);
return manufacturer == 0x0a;
}
}
void NzLoaders_PCX_Register()
{
NzImage::RegisterFileLoader("pcx", NzLoader_PCX_LoadFile);
NzImage::RegisterMemoryLoader(NzLoader_PCX_IsMemoryLoadingSupported, NzLoader_PCX_LoadMemory);
NzImage::RegisterStreamLoader(NzLoader_PCX_IsStreamLoadingSupported, NzLoader_PCX_LoadStream);
}
void NzLoaders_PCX_Unregister()
{
///TODO
}

15
src/Nazara/Utility/Loaders/PCX.hpp Normal file
View File

@@ -0,0 +1,15 @@
// 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_LOADERS_PCX_HPP
#define NAZARA_LOADERS_PCX_HPP
#include <Nazara/Prerequesites.hpp>
void NzLoaders_PCX_Register();
void NzLoaders_PCX_Unregister();
#endif // NAZARA_LOADERS_PCX_HPP

125
src/Nazara/Utility/Loaders/STB.cpp Normal file
View File

@@ -0,0 +1,125 @@
// Copyright (C) 2011 Jérôme Leclercq
// This file is part of the "Ungine".
// For conditions of distribution and use, see copyright notice in Core.h
#include <Nazara/Utility/Loaders/STB.hpp>
#include <Nazara/Core/Endianness.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/File.hpp>
#include <Nazara/Core/InputStream.hpp>
#include <Nazara/Core/MemoryStream.hpp>
#include <Nazara/Utility/Image.hpp>
#define STBI_HEADER_FILE_ONLY
#include <Nazara/Utility/Loaders/STB/stb_image.c>
#include <Nazara/Utility/Debug.hpp>
// Auteur du loader original : David Henry
namespace
{
int Read(void* userdata, char* data, int size)
{
NzInputStream* stream = static_cast<NzInputStream*>(userdata);
return static_cast<int>(stream->Read(data, size));
}
void Skip(void* userdata, unsigned int size)
{
NzInputStream* stream = static_cast<NzInputStream*>(userdata);
stream->Read(nullptr, size);
}
int Eof(void* userdata)
{
NzInputStream* stream = static_cast<NzInputStream*>(userdata);
return stream->GetCursorPos() >= stream->GetSize();
}
static stbi_io_callbacks callbacks = {Read, Skip, Eof};
bool NzLoader_STB_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters);
bool NzLoader_STB_LoadFile(NzImage* resource, const NzString& filePath, const NzImageParams& parameters)
{
NzFile file(filePath);
if (!file.Open(NzFile::ReadOnly))
{
NazaraError("Failed to open file");
return false;
}
return NzLoader_STB_LoadStream(resource, file, parameters);
}
bool NzLoader_STB_LoadMemory(NzImage* resource, const void* data, unsigned int size, const NzImageParams& parameters)
{
NzMemoryStream stream(data, size);
return NzLoader_STB_LoadStream(resource, stream, parameters);
}
bool NzLoader_STB_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
static nzPixelFormat format[4] = {
nzPixelFormat_L8,
nzPixelFormat_L8A8,
nzPixelFormat_R8G8B8,
nzPixelFormat_R8G8B8A8
};
int width, height, bpp;
nzUInt8* ptr = stbi_load_from_callbacks(&callbacks, &stream, &width, &height, &bpp, STBI_default);
if (!ptr)
{
NazaraError("Failed to load image: " + NzString(stbi_failure_reason()));
return false;
}
if (!resource->Create(nzImageType_2D, format[bpp-1], width, height))
{
NazaraError("Failed to create image");
stbi_image_free(ptr);
return false;
}
resource->Update(ptr);
stbi_image_free(ptr);
return true;
}
bool NzLoader_STB_IsMemoryLoadingSupported(const void* data, unsigned int size, const NzImageParams& parameters)
{
NazaraUnused(parameters);
int width, height, bpp;
return stbi_info_from_memory(static_cast<const stbi_uc*>(data), size, &width, &height, &bpp);
}
bool NzLoader_STB_IsStreamLoadingSupported(NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
int width, height, bpp;
return stbi_info_from_callbacks(&callbacks, &stream, &width, &height, &bpp);
}
}
void NzLoaders_STB_Register()
{
NzImage::RegisterFileLoader("bmp, gif, hdr, jpg, jpeg, pic, png, psd, tga", NzLoader_STB_LoadFile);
NzImage::RegisterMemoryLoader(NzLoader_STB_IsMemoryLoadingSupported, NzLoader_STB_LoadMemory);
NzImage::RegisterStreamLoader(NzLoader_STB_IsStreamLoadingSupported, NzLoader_STB_LoadStream);
}
void NzLoaders_STB_Unregister()
{
NzImage::UnregisterStreamLoader(NzLoader_STB_IsStreamLoadingSupported, NzLoader_STB_LoadStream);
NzImage::UnregisterMemoryLoader(NzLoader_STB_IsMemoryLoadingSupported, NzLoader_STB_LoadMemory);
NzImage::UnregisterFileLoader("bmp, gif, hdr, jpg, jpeg, pic, png, psd, tga", NzLoader_STB_LoadFile);
}

15
src/Nazara/Utility/Loaders/STB.hpp Normal file
View File

@@ -0,0 +1,15 @@
// 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_LOADERS_STB_HPP
#define NAZARA_LOADERS_STB_HPP
#include <Nazara/Prerequesites.hpp>
void NzLoaders_STB_Register();
void NzLoaders_STB_Unregister();
#endif // NAZARA_LOADERS_STB_HPP

4673
src/Nazara/Utility/Loaders/STB/stb_image.c Normal file
View File

File diff suppressed because it is too large Load Diff

7
src/Nazara/Utility/Resource.cpp
View File

@@ -5,6 +5,7 @@
#include <Nazara/Utility/Resource.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/Debug.hpp>
NzResource::NzResource(bool persistent) :
m_resourcePersistent(persistent),
@@ -12,6 +13,12 @@ m_resourceReferenceCount(0)
{
}
NzResource::NzResource(const NzResource& resource) :
m_resourcePersistent(resource.m_resourcePersistent),
m_resourceReferenceCount(0)
{
}
NzResource::~NzResource() = default;
void NzResource::AddResourceReference() const

62
src/Nazara/Utility/Utility.cpp Normal file
View File

@@ -0,0 +1,62 @@
// 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/Utility/Utility.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Utility/Config.hpp>
#include <Nazara/Utility/Loaders/PCX.hpp>
#include <Nazara/Utility/Loaders/STB.hpp>
#include <Nazara/Utility/Debug.hpp>
NzUtility::NzUtility()
{
}
NzUtility::~NzUtility()
{
if (s_initialized)
Uninitialize();
}
bool NzUtility::Initialize()
{
#if NAZARA_UTILITY_SAFE
if (s_initialized)
{
NazaraError("Renderer already initialized");
return true;
}
#endif
// Loaders spécialisés
NzLoaders_PCX_Register(); // Loader de fichiers .PCX (1, 4, 8, 24)
// Loaders génériques (En dernier pour donner la priorité aux loaders spécialisés)
NzLoaders_STB_Register(); // Loader générique (STB)
s_initialized = true;
return true;
}
void NzUtility::Uninitialize()
{
#if NAZARA_UTILITY_SAFE
if (!s_initialized)
{
NazaraError("Utility not initialized");
return;
}
#endif
NzLoaders_STB_Unregister();
NzLoaders_PCX_Unregister();
}
bool NzUtility::IsInitialized()
{
return s_initialized;
}
bool NzUtility::s_initialized = false;

1
src/Nazara/Utility/Win32/WindowImpl.cpp
View File

@@ -9,6 +9,7 @@
#include <Nazara/Core/Mutex.hpp>
#include <Nazara/Core/Thread.hpp>
#include <Nazara/Core/ThreadCondition.hpp>
#include <Nazara/Utility/Config.hpp>
#include <cstdio>
#include <windowsx.h>
#include <Nazara/Utility/Debug.hpp>