110 lines
2.7 KiB
C++
110 lines
2.7 KiB
C++
// Copyright (C) 2015 Jérôme Leclercq
|
|
// This file is part of the "Nazara Engine - Utility module"
|
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
|
|
|
#include <Nazara/Network/NetPacket.hpp>
|
|
#include <Nazara/Core/LockGuard.hpp>
|
|
#include <Nazara/Core/MemoryView.hpp>
|
|
#include <Nazara/Network/Debug.hpp>
|
|
|
|
namespace Nz
|
|
{
|
|
void NetPacket::OnReceive(UInt16 netCode, const void* data, std::size_t size)
|
|
{
|
|
Reset(netCode, data, size);
|
|
}
|
|
|
|
const void* NetPacket::OnSend(std::size_t* newSize) const
|
|
{
|
|
NazaraAssert(newSize, "Invalid size pointer");
|
|
NazaraAssert(m_netCode != NetCode_Invalid, "Invalid NetCode");
|
|
|
|
std::size_t size = m_buffer->GetSize();
|
|
if (!EncodeHeader(m_buffer->GetBuffer(), static_cast<UInt16>(size), m_netCode))
|
|
{
|
|
NazaraError("Failed to encode packet header");
|
|
return nullptr;
|
|
}
|
|
|
|
*newSize = size;
|
|
return m_buffer->GetBuffer();
|
|
}
|
|
|
|
bool NetPacket::DecodeHeader(const void* data, UInt16* packetSize, UInt16* netCode)
|
|
{
|
|
MemoryView stream(data, HeaderSize);
|
|
|
|
SerializationContext context;
|
|
context.stream = &stream;
|
|
|
|
return Unserialize(context, packetSize) && Unserialize(context, netCode);
|
|
}
|
|
|
|
bool NetPacket::EncodeHeader(void* data, UInt16 packetSize, UInt16 netCode)
|
|
{
|
|
MemoryView stream(data, HeaderSize);
|
|
|
|
SerializationContext context;
|
|
context.stream = &stream;
|
|
|
|
return Serialize(context, packetSize) && Serialize(context, netCode);
|
|
}
|
|
|
|
void NetPacket::OnEmptyStream()
|
|
{
|
|
Reset(0);
|
|
}
|
|
|
|
void NetPacket::FreeStream()
|
|
{
|
|
if (!m_buffer)
|
|
return;
|
|
|
|
std::size_t size = m_buffer->GetSize();
|
|
|
|
Nz::LockGuard lock(*s_availableBuffersMutex);
|
|
s_availableBuffers.emplace_back(std::make_pair(size, std::move(m_buffer)));
|
|
}
|
|
|
|
void NetPacket::InitStream(std::size_t minCapacity, UInt64 cursorPos, UInt32 openMode)
|
|
{
|
|
NazaraAssert(minCapacity >= cursorPos, "Cannot init stream with a smaller capacity than wanted cursor pos");
|
|
|
|
{
|
|
Nz::LockGuard lock(*s_availableBuffersMutex);
|
|
|
|
FreeStream(); //< In case it wasn't released yet
|
|
|
|
if (!s_availableBuffers.empty())
|
|
{
|
|
m_buffer = std::move(s_availableBuffers.back().second);
|
|
s_availableBuffers.pop_back();
|
|
}
|
|
}
|
|
|
|
if (!m_buffer)
|
|
m_buffer = std::make_unique<ByteArray>();
|
|
|
|
m_buffer->Resize(static_cast<std::size_t>(cursorPos));
|
|
|
|
m_memoryStream.SetBuffer(m_buffer.get(), openMode);
|
|
m_memoryStream.SetCursorPos(cursorPos);
|
|
SetStream(&m_memoryStream);
|
|
}
|
|
|
|
bool NetPacket::Initialize()
|
|
{
|
|
s_availableBuffersMutex = std::make_unique<Mutex>();
|
|
return true;
|
|
}
|
|
|
|
void NetPacket::Uninitialize()
|
|
{
|
|
s_availableBuffers.clear();
|
|
s_availableBuffersMutex.reset();
|
|
}
|
|
|
|
std::unique_ptr<Mutex> NetPacket::s_availableBuffersMutex;
|
|
std::vector<std::pair<std::size_t, std::unique_ptr<ByteArray>>> NetPacket::s_availableBuffers;
|
|
}
|