Moved buffers to Utility

Fixed NzVector4::operator/
Replaced enumName_Count by enumName_Max
Renamed (Index/Vertex)Buffer::GetBufferPtr by GetPointer

src/Nazara/Utility/Buffer.cpp

@@ -0,0 +1,273 @@
+// 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/Buffer.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Utility/BufferImpl.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/SoftwareBuffer.hpp>
+#include <cstring>
+#include <stdexcept>
+#include <Nazara/Utility/Debug.hpp>
+
+namespace
+{
+	NzBufferImpl* SoftwareBufferFunction(NzBuffer* parent, nzBufferType type)
+	{
+		return new NzSoftwareBuffer(parent, type);
+	}
+}
+
+NzBuffer::NzBuffer(nzBufferType type) :
+m_type(type),
+m_typeSize(0),
+m_impl(nullptr),
+m_length(0)
+{
+}
+
+NzBuffer::NzBuffer(nzBufferType type, unsigned int length, nzUInt8 typeSize, nzBufferStorage storage, nzBufferUsage usage) :
+m_type(type),
+m_impl(nullptr)
+{
+	Create(length, typeSize, storage, usage);
+
+	#ifdef NAZARA_DEBUG
+	if (!m_impl)
+	{
+		NazaraError("Failed to create buffer");
+		throw std::runtime_error("Constructor failed");
+	}
+	#endif
+}
+
+NzBuffer::~NzBuffer()
+{
+	Destroy();
+}
+
+bool NzBuffer::CopyContent(NzBuffer& buffer)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Buffer must be valid");
+		return false;
+	}
+
+	if (!buffer.IsValid())
+	{
+		NazaraError("Source buffer must be valid");
+		return false;
+	}
+
+	if (!buffer.GetTypeSize() != m_typeSize)
+	{
+		NazaraError("Source buffer type size does not match buffer type size");
+		return false;
+	}
+	#endif
+
+	void* ptr = buffer.Map(nzBufferAccess_ReadOnly);
+	if (!ptr)
+	{
+		NazaraError("Failed to map source buffer");
+		return false;
+	}
+
+	bool r = Fill(ptr, 0, buffer.GetLength());
+
+	if (!buffer.Unmap())
+		NazaraWarning("Failed to unmap source buffer");
+
+	return r;
+}
+
+bool NzBuffer::Create(unsigned int length, nzUInt8 typeSize, nzBufferStorage storage, nzBufferUsage usage)
+{
+	Destroy();
+
+	// On tente d'abord de faire un buffer hardware, si supporté
+	if (s_bufferFunctions[storage])
+	{
+		NzBufferImpl* impl = s_bufferFunctions[storage](this, m_type);
+		if (!impl->Create(length*typeSize, usage))
+		{
+			NazaraError("Failed to create buffer");
+			delete impl;
+
+			return false;
+		}
+
+		m_impl = impl;
+	}
+	else
+	{
+		NazaraError("Buffer storage not supported");
+		return false;
+	}
+
+	m_length = length;
+	m_typeSize = typeSize;
+	m_usage = usage;
+
+	// Si on arrive ici c'est que tout s'est bien passé.
+	return true;
+}
+
+void NzBuffer::Destroy()
+{
+	if (m_impl)
+	{
+		m_impl->Destroy();
+		delete m_impl;
+		m_impl = nullptr;
+	}
+}
+
+bool NzBuffer::Fill(const void* data, unsigned int offset, unsigned int length)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Buffer not valid");
+		return false;
+	}
+
+	if (offset+length > m_length)
+	{
+		NazaraError("Exceeding buffer size");
+		return false;
+	}
+	#endif
+
+	return m_impl->Fill(data, offset*m_typeSize, length*m_typeSize);
+}
+
+NzBufferImpl* NzBuffer::GetImpl() const
+{
+	return m_impl;
+}
+
+unsigned int NzBuffer::GetLength() const
+{
+	return m_length;
+}
+
+void* NzBuffer::GetPointer()
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Buffer not valid");
+		return nullptr;
+	}
+	#endif
+
+	return m_impl->GetPointer();
+}
+
+const void* NzBuffer::GetPointer() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Buffer not valid");
+		return nullptr;
+	}
+	#endif
+
+	return m_impl->GetPointer();
+}
+
+unsigned int NzBuffer::GetSize() const
+{
+	return m_length*m_typeSize;
+}
+
+nzBufferStorage NzBuffer::GetStorage() const
+{
+	return m_storage;
+}
+
+nzBufferType NzBuffer::GetType() const
+{
+	return m_type;
+}
+
+nzUInt8 NzBuffer::GetTypeSize() const
+{
+	return m_typeSize;
+}
+
+nzBufferUsage NzBuffer::GetUsage() const
+{
+	return m_usage;
+}
+
+bool NzBuffer::IsHardware() const
+{
+	return m_storage == nzBufferStorage_Hardware;
+}
+
+bool NzBuffer::IsValid() const
+{
+	return m_impl != nullptr;
+}
+
+void* NzBuffer::Map(nzBufferAccess access, unsigned int offset, unsigned int length)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Buffer not valid");
+		return nullptr;
+	}
+
+	if (offset+length > m_length)
+	{
+		NazaraError("Exceeding buffer size");
+		return nullptr;
+	}
+	#endif
+
+	return m_impl->Map(access, offset*m_typeSize, length*m_typeSize);
+}
+
+bool NzBuffer::Unmap()
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Buffer not valid");
+		return false;
+	}
+	#endif
+
+	return m_impl->Unmap();
+}
+
+bool NzBuffer::IsSupported(nzBufferStorage storage)
+{
+	return s_bufferFunctions[storage] != nullptr;
+}
+
+void NzBuffer::SetBufferFunction(nzBufferStorage storage, BufferFunction func)
+{
+	s_bufferFunctions[storage] = func;
+}
+
+bool NzBuffer::Initialize()
+{
+	s_bufferFunctions[nzBufferStorage_Software] = SoftwareBufferFunction;
+
+	return true;
+}
+
+void NzBuffer::Uninitialize()
+{
+	std::memset(s_bufferFunctions, 0, (nzBufferStorage_Max+1)*sizeof(NzBuffer::BufferFunction));
+}
+
+NzBuffer::BufferFunction NzBuffer::s_bufferFunctions[nzBufferStorage_Max+1] = {0};