BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into FixNetworkBugs

Browse Source 
# Conflicts:
#	include/Engine/Network/Client.h
#	include/Engine/Network/MessageType.h
#	include/Engine/Network/Server.h
#	include/Engine/Network/TCPServer.h
#	src/Engine/Network/Client.cpp
#	src/Engine/Network/TCPServer.cpp
This commit is contained in:
Jocke
2016-02-25 15:13:11 +01:00
parent 508d8a6f00 da1c7b3093
commit f66fa7a183
60 changed files with 1006 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Network/Client.cpp
+77 -2
View File
@@ -13,6 +13,8 @@ Client::Client(World* world, EventBroker* eventBroker)
m_PlayerName = config->Get<std::string>("Networking.Name", "Raptorcopter");
m_SendInputIntervalMs = config->Get<int>("Networking.SendInputIntervalMs", 33);
LOG_INFO("Client initialized");
m_ServerlistRequest.Connect(m_PlayerName, "192.168.1.255", 32554);
}
Client::Client(World* world, EventBroker* eventBroker, std::unique_ptr<SnapshotFilter> snapshotFilter)
@@ -31,6 +33,7 @@ void Client::Connect(std::string address, int port)
EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Client::OnPlayerDamage);
EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Client::OnPlayerSpawned);
EVENT_SUBSCRIBE_MEMBER(m_EPDoubleJump, &Client::OnDoubleJump);
EVENT_SUBSCRIBE_MEMBER(m_ESearchForServers, &Client::OnSearchForServers);
auto config = ResourceManager::Load<ConfigFile>("Config.ini");
m_Address = address;
if (address.empty()) {
@@ -67,6 +70,21 @@ void Client::Update()
}
while (m_ServerlistRequest.IsSocketAvailable()) {
Packet packet(MessageType::Invalid);
m_ServerlistRequest.Receive(packet);
if (packet.GetMessageType() == MessageType::ServerlistRequest) {
parseServerlist(packet);
}
}
if (m_SearchingForServers) {
if (m_SearchingTime < (1000* (std::clock() - m_StartSearchTime) / (double)CLOCKS_PER_SEC)) {
m_SearchingForServers = false;
displayServerlist();
}
}
if (m_IsConnected) {
// Don't send 1 input in 1 packet, bunch em up.
if (m_SendInputIntervalMs < (1000 * (std::clock() - m_TimeSinceSentInputs) / (double)CLOCKS_PER_SEC)) {
@@ -177,6 +195,22 @@ void Client::parsePing()
m_Reliable.Send(packet);
}
void Client::parseServerlist(Packet& packet)
{
// Pop size, message type, and ID
packet.ReadPrimitive<int>();
packet.ReadPrimitive<int>();
packet.ReadPrimitive<int>();
std::string address = packet.ReadString();
int port = packet.ReadPrimitive<int>();
std::string serverName = packet.ReadString();
int playersConnected = packet.ReadPrimitive<int>();
//TODO: This should not happen when a client is connected to a server
m_Serverlist.push_back({ address, port, serverName, playersConnected });
}
void Client::parseKick()
{
LOG_WARNING("You have been kicked from the server.");
@@ -330,17 +364,19 @@ void Client::parseSnapshot(Packet& packet)
if (serverClientMapsHasEntity(serverEntityID)) {
EntityID localEntityID = m_ServerIDToClientID.at(serverEntityID);
EntityWrapper localEntity(m_World, localEntityID);
// Update entity
if (m_World->HasComponent(localEntityID, componentType)) {
// TODO Fix memory leak here
if (localEntity.Name() == "CapturePointHUD") {
UpdateLocalCapturePointHUD(localEntity);
}
SharedComponentWrapper newComponent = createSharedComponent(packet, localEntityID, componentInfo);
bool shouldApply = true;
// Apply potential filter function
if (m_SnapshotFilter != nullptr) {
shouldApply = m_SnapshotFilter->FilterComponent(localEntity, newComponent);
}
if (shouldApply) {
if (shouldApply) {
ComponentWrapper currentComponent = m_World->GetComponent(localEntityID, componentType);
memcpy(currentComponent.Data, newComponent.Data, componentInfo.Stride);
}
@@ -381,6 +417,18 @@ void Client::parseSnapshot(Packet& packet)
parseSpawnEvents();
}
void Client::UpdateLocalCapturePointHUD(EntityWrapper capturePointHUD)
{
//auto children = m_World->GetChildren(capturePointHUD.ID);
//for (auto it = children.first; it != children.second; it++) {
// it->first
//}
//
//EntityWrapper& localHUD = m_LocalPlayer.FirstChildByName("HUD").FirstChildByName("CapturePointHUD");
//m_World->GetComponentPools()
}
void Client::disconnect()
{
m_IsConnected = false;
@@ -393,6 +441,12 @@ void Client::disconnect()
bool Client::OnInputCommand(const Events::InputCommand & e)
{
// TEMP
if (e.Command == "SearchForServers" && e.Value > 0) {
Events::SearchForServers e;
m_EventBroker->Publish(e);
}
if (e.PlayerID != -1) {
return false;
}
@@ -460,6 +514,17 @@ bool Client::OnPlayerSpawned(const Events::PlayerSpawned& e)
return true;
}
bool Client::OnSearchForServers(const Events::SearchForServers& e)
{
m_SearchingForServers = true;
m_StartSearchTime = std::clock();
m_Serverlist.clear();
LOG_INFO("Searching for LAN servers...\n");
Packet packet(MessageType::ServerlistRequest);
m_ServerlistRequest.Broadcast(packet, 13); // TODO: Config
return true;
}
void Client::parsePlayerDamage(Packet& packet)
{
Events::PlayerDamage e;
@@ -566,6 +631,16 @@ void Client::becomePlayer()
m_Reliable.Send(packet);
}
void Client::displayServerlist()
{
LOG_INFO("This is a serverlist:\n");
for (int i = 0; i < m_Serverlist.size(); i++) {
ServerInfo si = m_Serverlist[i];
LOG_INFO("%s:%i\t%s\t%i\n", si.Address.c_str(), si.Port, si.Name.c_str(), si.PlayersConnected);
}
}
bool Client::clientServerMapsHasEntity(EntityID clientEntityID)
{
if (m_ClientIDToServerID.find(clientEntityID) != m_ClientIDToServerID.end()) {
src/Engine/Network/HybridClient.cpp
-10
View File
@@ -1,10 +0,0 @@
#include "Network/HybridClient.h"
HybridClient::HybridClient()
{
}
HybridClient::~HybridClient()
{
}
src/Engine/Network/HybridServer.cpp
-9
View File
@@ -1,9 +0,0 @@
#include "Network/HybridServer.h"
HybridServer::HybridServer()
{
}
HybridServer::~HybridServer()
{
}
src/Engine/Network/NetworkClient.cpp
+11
View File
@@ -0,0 +1,11 @@
#include "Network/NetworkClient.h"
NetworkClient::NetworkClient()
{
m_ReadBuffer = new char[m_BufferSize];
}
NetworkClient::~NetworkClient()
{
delete[] m_ReadBuffer;
}
src/Engine/Network/NetworkServer.cpp
+11
View File
@@ -0,0 +1,11 @@
#include "Network/NetworkServer.h"
NetworkServer::NetworkServer()
{
m_ReadBuffer = new char[m_BufferSize];
}
NetworkServer::~NetworkServer()
{
delete[] m_ReadBuffer;
}
src/Engine/Network/Server.cpp
+92 -8
View File
@@ -2,6 +2,7 @@
Server::Server(World* world, EventBroker* eventBroker, int port)
: Network(world, eventBroker)
, m_ServerlistRequest(13)
{
ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05f);
@@ -13,7 +14,7 @@ Server::Server(World* world, EventBroker* eventBroker, int port)
EVENT_SUBSCRIBE_MEMBER(m_EComponentDeleted, &Server::OnComponentDeleted);
EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Server::OnPlayerDamage);
// Bind
// BindWW
if (port == 0) {
port = config->Get<float>("Networking.Port", 27666);
}
@@ -58,8 +59,24 @@ void Server::Update()
parseMessageType(packet);
}
}
while (m_ServerlistRequest.IsSocketAvailable()) {
Packet packet(MessageType::Invalid);
PlayerDefinition localArea;
localArea.Endpoint = boost::asio::ip::udp::endpoint();
m_ServerlistRequest.Receive(packet, localArea);
if(packet.GetMessageType() == MessageType::ServerlistRequest) {
packet.ReadPrimitive<int>(); // Pop size
packet.ReadPrimitive<int>(); // Pop MsgType
packet.ReadPrimitive<int>(); // Pop packet ID
int port = packet.ReadPrimitive<int>();
std::string address = localArea.Endpoint.address().to_string();
parseServerlistRequest(boost::asio::ip::udp::endpoint(boost::asio::ip::address().from_string(address), port));
}
}
// Check if players have disconnected
for (int i = 0; i < m_PlayersToDisconnect.size(); i++) {
for (int i = 0; i < m_PlayersToDisconnect.size(); i++) {
disconnect(m_PlayersToDisconnect.at(i));
}
m_PlayersToDisconnect.clear();
@@ -75,6 +92,7 @@ void Server::Update()
sendPing();
previousePingMessage = currentTime;
}
// Time out logic
if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
checkForTimeOuts();
@@ -118,7 +136,7 @@ void Server::parseMessageType(Packet& packet)
parseOnPlayerDamage(packet);
break;
case MessageType::PlayerTransform:
parsePlayerTransform(packet);
parsePlayerTransform(packet);
break;
case MessageType::OnDoubleJump:
parseDoubleJump(packet);
@@ -149,7 +167,7 @@ void Server::sendSnapshot()
{
Packet packet(MessageType::Snapshot);
addInputCommandsToPacket(packet);
addChildrenToPacket(packet, EntityID_Invalid);
addPlayersToPacket(packet, EntityID_Invalid);
unreliableBroadcast(packet);
}
@@ -166,7 +184,7 @@ void Server::addInputCommandsToPacket(Packet& packet)
m_InputCommandsToBroadcast.clear();
}
void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
{
auto itPair = m_World->GetChildren(entityID);
std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
@@ -174,6 +192,7 @@ void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
for (auto it = itPair.first; it != itPair.second; it++) {
EntityID childEntityID = it->second;
// HACK: Only sync players for now, since the map turned out to be TOO LARGE to send in one snapshot and Simon's computer shits itself
// HACK: Also checked CapturePointHUD for now. (this would get out of sync);
EntityWrapper childEntity(m_World, childEntityID);
if (!shouldSendToClient(childEntity)) {
continue;
@@ -215,6 +234,49 @@ void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
}
}
void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
{
auto itPair = m_World->GetChildren(entityID);
std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
// Loop through every child
for (auto it = itPair.first; it != itPair.second; it++) {
EntityID childEntityID = it->second;
// Write EntityID and parentsID and Entity name
packet.WritePrimitive(childEntityID);
packet.WritePrimitive(entityID);
packet.WriteString(m_World->GetName(childEntityID));
// Write components to child
int numberOfComponents = 0;
for (auto& i : worldComponentPools) {
if (i.second->KnowsEntity(childEntityID)) {
numberOfComponents++;
}
}
// Write how many components should be read
packet.WritePrimitive(numberOfComponents);
for (auto& i : worldComponentPools) {
// If the entity exist in the pool
if (i.second->KnowsEntity(childEntityID)) {
ComponentWrapper componentWrapper = i.second->GetByEntity(childEntityID);
// ComponentType
packet.WriteString(componentWrapper.Info.Name);
// Loop through fields
for (auto& componentField : componentWrapper.Info.FieldsInOrder) {
ComponentInfo::Field_t fieldInfo = componentWrapper.Info.Fields.at(componentField);
if (fieldInfo.Type == "string") {
std::string& value = componentWrapper[componentField];
packet.WriteString(value);
} else {
packet.WriteData(componentWrapper.Data + fieldInfo.Offset, fieldInfo.Stride);
}
}
}
}
// Go to to your children
addChildrenToPacket(packet, childEntityID);
}
}
void Server::sendPing()
{
// Prints connected players ping
@@ -233,6 +295,8 @@ void Server::sendPing()
reliableBroadcast(packet);
}
void Server::checkForTimeOuts()
{
double startPing = 1000 * m_StartPingTime
@@ -307,6 +371,11 @@ void Server::parseTCPConnect(Packet & packet)
connnectPacket.WritePrimitive(playerID);
m_Reliable.Send(connnectPacket);
Packet firstSnapshot(MessageType::Snapshot);
addInputCommandsToPacket(firstSnapshot);
addChildrenToPacket(firstSnapshot, EntityID_Invalid);
m_Reliable.Send(firstSnapshot);
// Send notification that a player has connected
//Packet notificationPacket(MessageType::PlayerConnected);
//broadcast(notificationPacket);
@@ -325,6 +394,17 @@ void Server::parseDisconnect()
}
}
void Server::parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint)
{
Packet packet(MessageType::ServerlistRequest);
packet.WriteString(m_Reliable.Address());
packet.WritePrimitive<int>(m_Reliable.Port());
packet.WriteString("SERVERNAME");
packet.WritePrimitive<int>(m_ConnectedPlayers.size());
m_ServerlistRequest.Send(packet);
}
void Server::disconnect(PlayerID playerID)
{
//broadcast("A player disconnected");
@@ -349,6 +429,7 @@ void Server::parseOnPlayerDamage(Packet & packet)
e.Victim = EntityWrapper(m_World, packet.ReadPrimitive<EntityID>());
e.Damage = packet.ReadPrimitive<double>();
m_EventBroker->Publish(e);
//LOG_DEBUG("Server::parseOnPlayerDamage: Command is %s. Value is %f. PlayerID is %i.", e.DamageAmount, e.PlayerDamagedID, e.TypeOfDamage.c_str());
}
@@ -378,7 +459,7 @@ bool Server::OnInputCommand(const Events::InputCommand & e)
isReadingData = !isReadingData;
m_SaveDataTimer = std::clock();
}
if (e.Command == "KickPlayer" && e.Value > 0) {
else if (e.Command == "KickPlayer" && e.Value > 0) {
kick(0);
}
@@ -449,7 +530,9 @@ void Server::parsePing()
{
for (auto& kv : m_ConnectedPlayers) {
if (kv.second.TCPAddress == m_Address &&
kv.second.TCPPort == m_Port) {
kv.second.TCPPort == m_Port
|| (kv.second.Endpoint.address() == m_Address
&& kv.second.Endpoint.port() == m_Port)) {
kv.second.StopTime = std::clock();
break;
}
@@ -521,7 +604,8 @@ void Server::parsePlayerTransform(Packet& packet)
bool Server::shouldSendToClient(EntityWrapper childEntity)
{
return childEntity.HasComponent("Player") || childEntity.FirstParentWithComponent("Player").Valid();
return childEntity.HasComponent("Player") || childEntity.FirstParentWithComponent("Player").Valid()
|| childEntity.HasComponent("CapturePoint") || childEntity.FirstParentWithComponent("CapturePoint").Valid();
}
PlayerID Server::GetPlayerIDFromEndpoint()
src/Engine/Network/TCPClient.cpp
+19 -9
View File
@@ -56,32 +56,42 @@ void TCPClient::Disconnect()
void TCPClient::Receive(Packet& packet)
{
size_t bytesRead = readBuffer(m_ReadBuffer);
size_t bytesRead = readBuffer();
if (bytesRead > 0) {
packet.ReconstructFromData(m_ReadBuffer, bytesRead);
}
}
size_t TCPClient::readBuffer(char* data)
size_t TCPClient::readBuffer()
{
if (!m_Socket) {
return 0;
}
boost::system::error_code error;
// Read size of packet
size_t bytesReceived = m_Socket->read_some(boost
::asio::buffer((void*)data, sizeof(int)),
error);
int sizeOfPacket = 0;
memcpy(&sizeOfPacket, data, sizeof(int));
m_Socket->receive(boost
::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
boost::asio::ip::tcp::socket::message_peek, error);
unsigned int sizeOfPacket = 0;
memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
// if the buffer is to small increase the size of it
// TODO if message is huge 1 time the buffer will not decrease.
if (sizeOfPacket > m_BufferSize) {
delete[] m_ReadBuffer;
m_ReadBuffer = new char[sizeOfPacket];
m_BufferSize = sizeOfPacket;
}
// Read the rest of the message
bytesReceived += m_Socket->read_some(boost
::asio::buffer((void*)(data + bytesReceived), sizeOfPacket - bytesReceived),
size_t bytesReceived = m_Socket->read_some(boost
::asio::buffer((void*)(m_ReadBuffer), sizeOfPacket),
error);
if (error) {
//LOG_ERROR("receive: %s", error.message().c_str());
}
if (sizeOfPacket > 1000000)
LOG_WARNING("The packets received are bigger than 1MB");
return bytesReceived;
}
src/Engine/Network/TCPServer.cpp
+35 -11
View File
@@ -1,11 +1,13 @@
#include "Network/TCPServer.h"
using namespace boost::asio::ip;
TCPServer::TCPServer()
TCPServer::TCPServer()
{
acceptor = std::unique_ptr<tcp::acceptor>(new tcp::acceptor(m_IOService, tcp::endpoint(tcp::v4(), 27666)));
// Make the acceptor non-blocking so we wont get stuck in AcceptNewConnections().
acceptor->non_blocking(true);
m_Port = GetPort();
m_Address = GetAddress();
}
TCPServer::~TCPServer()
@@ -44,8 +46,8 @@ PlayerID TCPServer::getPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefin
void TCPServer::Send(Packet & packet, PlayerDefinition & playerDefinition)
{
packet.UpdateSize();
try {
packet.UpdateSize();
int bytesSent = playerDefinition.TCPSocket->send(
boost::asio::buffer(packet.Data(), packet.Size()),
0);
@@ -67,37 +69,59 @@ void TCPServer::Send(Packet & packet)
void TCPServer::Disconnect()
{
}
int TCPServer::GetPort()
{
return acceptor->local_endpoint().port();
}
std::string TCPServer::GetAddress()
{
boost::asio::ip::tcp::resolver resolver(m_IOService);
boost::asio::ip::tcp::resolver::query query(boost::asio::ip::tcp::v4(), boost::asio::ip::host_name(), "");
boost::asio::ip::tcp::resolver::iterator it = resolver.resolve(query);
boost::asio::ip::tcp::endpoint endpoint = *it;
return endpoint.address().to_string().c_str();
}
void TCPServer::Receive(Packet & packet, PlayerDefinition & playerDefinition)
{
int bytesRead = readBuffer(m_ReadBuffer, playerDefinition);
int bytesRead = readBuffer(playerDefinition);
if (bytesRead > 0) {
packet.ReconstructFromData(m_ReadBuffer, bytesRead);
}
lastReceivedSocket = playerDefinition.TCPSocket;
}
int TCPServer::readBuffer(char* data, PlayerDefinition & playerDefinition)
int TCPServer::readBuffer(PlayerDefinition & playerDefinition)
{
if (!playerDefinition.TCPSocket) {
return 0;
}
boost::system::error_code error;
// Read size of packet
size_t bytesReceived = playerDefinition.TCPSocket->read_some(boost
::asio::buffer((void*)data, sizeof(int)),
error);
int sizeOfPacket = 0;
memcpy(&sizeOfPacket, data, sizeof(int));
playerDefinition.TCPSocket->receive(boost
::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
boost::asio::ip::tcp::socket::message_peek, error);
unsigned int sizeOfPacket = 0;
memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
// if the buffer is to small increase the size of it
if (sizeOfPacket > m_BufferSize) {
delete[] m_ReadBuffer;
m_ReadBuffer = new char[sizeOfPacket];
m_BufferSize = sizeOfPacket;
}
// Read the rest of the message
bytesReceived += playerDefinition.TCPSocket->read_some(boost
::asio::buffer((void*)(data + bytesReceived), sizeOfPacket - bytesReceived),
size_t bytesReceived = playerDefinition.TCPSocket->read_some(boost
::asio::buffer((void*)(m_ReadBuffer), sizeOfPacket),
error);
if (error) {
//LOG_ERROR("receive: %s", error.message().c_str());
}
if (sizeOfPacket > 1000000)
LOG_WARNING("The packets received are bigger than 1MB");
return bytesReceived;
}
src/Engine/Network/UDPClient.cpp
+40 -8
View File
@@ -15,9 +15,9 @@ void UDPClient::Connect(std::string playerName, std::string address, int port)
if (m_Socket) {
return;
}
m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address().from_string(address), port);
m_Socket = boost::shared_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService));
m_Socket->connect(m_ReceiverEndpoint);
m_Socket->open(boost::asio::ip::udp::v4());
}
void UDPClient::Disconnect()
@@ -27,34 +27,66 @@ void UDPClient::Disconnect()
void UDPClient::Receive(Packet& packet)
{
int bytesRead = readBuffer(m_ReadBuffer);
int bytesRead = readBuffer();
if (bytesRead > 0) {
packet.ReconstructFromData(m_ReadBuffer, bytesRead);
}
}
int UDPClient::readBuffer(char* data)
int UDPClient::readBuffer()
{
if (!m_Socket) {
return 0;
}
boost::system::error_code error;
int bytesReceived = m_Socket->receive_from(boost
::asio::buffer((void*)data, BUFFERSIZE),
m_ReceiverEndpoint,
0, error);
// Read size of packet
m_Socket->receive(boost
::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
boost::asio::ip::udp::socket::message_peek, error);
int sizeOfPacket = 0;
memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
// if the buffer is to small increase the size of it
if (sizeOfPacket > m_BufferSize) {
delete[] m_ReadBuffer;
m_ReadBuffer = new char[sizeOfPacket];
m_BufferSize = sizeOfPacket;
}
size_t availableData = m_Socket->available();
// Read the rest of the message
size_t bytesReceived = m_Socket->receive_from(boost
::asio::buffer((void*)(m_ReadBuffer),
sizeOfPacket),
m_ReceiverEndpoint, 0, error);
if (error) {
//LOG_ERROR("receive: %s", error.message().c_str());
}
if (sizeOfPacket > 1000000)
LOG_WARNING("The packets received are bigger than 1MB");
return bytesReceived;
}
void UDPClient::Send(Packet& packet)
{
packet.UpdateSize();
m_Socket->send_to(boost::asio::buffer(
packet.Data(),
packet.Size()),
m_ReceiverEndpoint, 0);
}
void UDPClient::Broadcast(Packet& packet, int port)
{
packet.UpdateSize();
m_Socket->set_option(boost::asio::socket_base::broadcast(true));
m_Socket->send_to(boost::asio::buffer(
packet.Data(),
packet.Size()),
udp::endpoint(boost::asio::ip::address_v4().broadcast(), port)
, 0);
m_Socket->set_option(boost::asio::socket_base::broadcast(false));
}
bool UDPClient::IsSocketAvailable()
src/Engine/Network/UDPServer.cpp
+65 -10
View File
@@ -5,11 +5,17 @@ UDPServer::UDPServer()
m_Socket = std::unique_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 27666)));
}
UDPServer::UDPServer(int port)
{
m_Socket = std::unique_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), port)));
}
UDPServer::~UDPServer()
{ }
void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
{
packet.UpdateSize();
try {
int bytesSent = m_Socket->send_to(
boost::asio::buffer(packet.Data(), packet.Size()),
@@ -23,6 +29,7 @@ void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
// Send back to endpoint of received packet
void UDPServer::Send(Packet & packet)
{
packet.UpdateSize();
m_Socket->send_to(
boost::asio::buffer(
packet.Data(),
@@ -31,9 +38,35 @@ void UDPServer::Send(Packet & packet)
0);
}
// Broadcasting respond specific logic
void UDPServer::Send(Packet & packet, boost::asio::ip::udp::endpoint endpoint)
{
packet.UpdateSize();
m_Socket->send_to(
boost::asio::buffer(
packet.Data(),
packet.Size()),
endpoint,
0);
}
// Broadcasting
void UDPServer::Broadcast(Packet & packet, int port)
{
packet.UpdateSize();
m_Socket->set_option(boost::asio::socket_base::broadcast(true));
m_Socket->send_to(
boost::asio::buffer(
packet.Data(),
packet.Size()),
boost::asio::ip::udp::endpoint(boost::asio::ip::address_v4().broadcast(),port),
0);
m_Socket->set_option(boost::asio::socket_base::broadcast(false));
}
void UDPServer::Receive(Packet & packet, PlayerDefinition & playerDefinition)
{
int bytesRead = readBuffer(m_ReadBuffer);
int bytesRead = readBuffer();
if (bytesRead > 0) {
packet.ReconstructFromData(m_ReadBuffer, bytesRead);
}
@@ -45,17 +78,39 @@ bool UDPServer::IsSocketAvailable()
return m_Socket->available();
}
int UDPServer::readBuffer(char* data)
int UDPServer::readBuffer()
{
boost::system::error_code error = boost::asio::error::host_not_found;
unsigned int length = m_Socket->receive_from(
boost::asio::buffer((void*)data
, BUFFERSIZE)
, m_ReceiverEndpoint, 0, error);
if (error) {
LOG_WARNING(error.message().c_str());
if (!m_Socket) {
return 0;
}
return length;
int addasdasd = m_Socket->available();
boost::system::error_code error;
// Read size of packet
m_Socket->receive_from(boost
::asio::buffer((void*)m_ReadBuffer, sizeof(int)),
m_ReceiverEndpoint, boost::asio::ip::udp::socket::message_peek, error);
unsigned int sizeOfPacket = 0;
memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
// if the buffer is to small increase the size of it
if (sizeOfPacket > m_BufferSize) {
delete[] m_ReadBuffer;
m_ReadBuffer = new char[sizeOfPacket];
m_BufferSize = sizeOfPacket;
}
// Read the rest of the message
size_t bytesReceived = m_Socket->receive_from(boost
::asio::buffer((void*)(m_ReadBuffer),
sizeOfPacket),
m_ReceiverEndpoint, 0, error);
if (error) {
//LOG_ERROR("receive: %s", error.message().c_str());
}
if (sizeOfPacket > 1000000)
LOG_WARNING("The packets received are bigger than 1MB");
return bytesReceived;
}
void UDPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)
src/Engine/Rendering/CubeMapPass.cpp
+40
View File
@@ -0,0 +1,40 @@
#include "Rendering/CubeMapPass.h"
CubeMapPass::CubeMapPass(IRenderer* renderer)
:m_Renderer(renderer)
{
LoadTextures("Nevada");
}
void CubeMapPass::LoadTextures(std::string input)
{
if (m_PreviusCubeMapTexture != input) {
m_CubeMapTextures.clear();
for (int i = 0; i < 6; i++) {
std::string str;
str = "Textures/Test/CubeMap/" + input + "/CubeMapTest0" + std::to_string(i) + ".png";
Texture* img = ResourceManager::Load<Texture>(str);
m_CubeMapTextures.push_back(img);
}
GenerateCubeMapTexture();
}
}
void CubeMapPass::GenerateCubeMapTexture()
{
if (m_CubeMapTexture == -1) {
glGenTextures(1, &m_CubeMapTexture);
}
glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapTexture);
for (int i = 0; i < 6; i++) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGBA32F, m_CubeMapTextures[0]->Width, m_CubeMapTextures[0]->Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_CubeMapTextures[i]->Data);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
GLERROR("Generate Cubemap");
}
src/Engine/Rendering/DrawBloomPass.cpp
+2
View File
@@ -52,6 +52,7 @@ void DrawBloomPass::InitializeBuffers()
void DrawBloomPass::ClearBuffer()
{
GLERROR("PRE");
m_GaussianFrameBuffer_horiz.Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -60,6 +61,7 @@ void DrawBloomPass::ClearBuffer()
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_GaussianFrameBuffer_vert.Unbind();
GLERROR("END");
}
void DrawBloomPass::Draw(GLuint texture)
src/Engine/Rendering/DrawFinalPass.cpp
+39 -3
View File
@@ -1,10 +1,11 @@
#include "Rendering/DrawFinalPass.h"
DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass)
DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass)
: m_Renderer(renderer)
, m_LightCullingPass(lightCullingPass)
, m_CubeMapPass(cubeMapPass)
{
//TODO: Make sure that uniforms are not sent into shader if not needed.
m_Renderer = renderer;
m_LightCullingPass = lightCullingPass;
m_ShieldPixelRate = 8;
InitializeTextures();
InitializeShaderPrograms();
@@ -192,8 +193,10 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
state->StencilMask(0x00);
DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene, SSAOTexture);
GLERROR("OpaqueObjects");
state->BlendFunc(GL_ONE, GL_ONE);
DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene, SSAOTexture);
GLERROR("TransparentObjects");
state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
DrawSprites(scene.Jobs.SpriteJob, scene);
GLERROR("SpriteJobs");
@@ -259,20 +262,35 @@ void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
void DrawFinalPass::ClearBuffer()
{
GLERROR("PRE");
m_FinalPassFrameBufferLowRes.Bind();
GLERROR("Bind LowRes");
glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_ShieldPixelRate, m_Renderer->GetViewportSize().Height/m_ShieldPixelRate);
glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
GLERROR("ViewPort,Scissor LowRes");
glClearColor(0.f, 0.f, 0.f, 0.f);
GLERROR("1");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLERROR("2");
glDisable(GL_SCISSOR_TEST);
GLERROR("3");
m_FinalPassFrameBufferLowRes.Unbind();
GLERROR("prebind HighRes");
m_FinalPassFrameBuffer.Bind();
GLERROR("Bind HighRes");
glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
GLERROR("ViewPort,Scissor LowRes");
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_FinalPassFrameBuffer.Unbind();
GLERROR("END");
}
@@ -356,12 +374,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
case RawModel::MaterialType::SingleTextures:
{
if (explosionEffectJob->Model->IsSkinned()) {
m_ExplosionEffectSkinnedProgram->Bind();
GLERROR("Bind ExplosionEffectSkinned program");
//bind uniforms
BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
//bind textures
BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
std::vector<glm::mat4> frameBones;
if (explosionEffectJob->AnimationOffset.animation != nullptr) {
frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
@@ -376,6 +399,10 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
//bind textures
BindExplosionTextures(explosionHandle, explosionEffectJob);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
}
break;
}
@@ -434,6 +461,10 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
//bind textures
BindModelTextures(forwardSkinnedHandle, modelJob);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
std::vector<glm::mat4> frameBones;
if (modelJob->AnimationOffset.animation != nullptr) {
frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
@@ -449,6 +480,9 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
BindModelUniforms(forwardHandle, modelJob, scene);
//bind textures
BindModelTextures(forwardHandle, modelJob);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
}
break;
}
@@ -807,6 +841,8 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job)
{
switch (job->Type) {
case RawModel::MaterialType::SingleTextures:
case RawModel::MaterialType::Basic:
src/Engine/Rendering/PickingPass.cpp
+6 -15
View File
@@ -21,23 +21,13 @@ void PickingPass::InitializeTextures()
{
GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
GenerateTexture(&m_DepthBuffer, GL_CLAMP_TO_BORDER, GL_NEAREST,
glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
}
void PickingPass::InitializeFrameBuffers()
{
/* glGenRenderbuffers(1, &m_DepthBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);*/
glGenTextures(1, &m_DepthBuffer);
glBindTexture(GL_TEXTURE_2D, m_DepthBuffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width), (int)(m_Renderer->GetViewportSize().Height), 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_PickingTexture, GL_COLOR_ATTACHMENT0)));
m_PickingBuffer.Generate();
@@ -64,6 +54,7 @@ void PickingPass::InitializeShaderPrograms()
void PickingPass::Draw(RenderScene& scene)
{
GLERROR("PRE");
PickingPassState* state = new PickingPassState(m_PickingBuffer.GetHandle());
//TODO: Render: Add code for more jobs than modeljobs.
@@ -367,6 +358,7 @@ void PickingPass::Draw(RenderScene& scene)
void PickingPass::ClearPicking()
{
GLERROR("PRE");
m_PickingColorsToEntity.clear();
m_EntityColors.clear();
m_ColorCounter[0] = 0;
@@ -376,14 +368,13 @@ void PickingPass::ClearPicking()
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_PickingBuffer.Unbind();
GLERROR("END");
}
void PickingPass::OnWindowResize()
{
InitializeTextures();
glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
m_PickingBuffer.Generate();
}
src/Engine/Rendering/PickingPassState.cpp
+3 -2
View File
@@ -3,9 +3,9 @@
PickingPassState::PickingPassState(GLuint frameBuffer)
{
GLERROR("---2");
GLERROR("PRE");
BindFramebuffer(frameBuffer);
GLERROR("---3");
GLERROR("Bind Framebuffer");
Enable(GL_DEPTH_TEST);
Enable(GL_CULL_FACE);
Disable(GL_BLEND);
@@ -13,6 +13,7 @@ PickingPassState::PickingPassState(GLuint frameBuffer)
glm::vec4 clearColor = glm::vec4(0.f);
//ClearColor(clearColor);
//Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLERROR("END");
}
PickingPassState::~PickingPassState()
src/Engine/Rendering/RenderSystem.cpp
+96 -6
View File
@@ -52,6 +52,101 @@ void RenderSystem::fillSprites(std::list<std::shared_ptr<RenderJob>>& jobs, Worl
continue;
}
glm::mat4 modelMatrix;
// See a sprite is an SpriteIndicator
bool isIndicator = false;
if (world->HasComponent(entity.ID, "SpriteIndicator"))
{
auto indicator = entity["SpriteIndicator"];
float minScale = (float)(double)indicator["MinScale"];
bool hasTeam = indicator["VisibleForSingleTeamOnly"];
isIndicator = true;
glm::vec3 pos = Transform::AbsolutePosition(entity);
EntityWrapper entityTeam;
if (hasTeam && (entity.HasComponent("Team") || entity.FirstParentWithComponent("Team").Valid()) && m_LocalPlayer.World != nullptr) {
if (!entity.HasComponent("Team")) {
entityTeam = entity.FirstParentWithComponent("Team");
}
else {
entityTeam = entity;
}
ComponentWrapper& entityTeamComponent = entityTeam["Team"];
ComponentWrapper& localComponent = m_LocalPlayer["Team"];
int entityTeamInt = entityTeamComponent["Team"];
int localComponentInt = localComponent["Team"];
int SpectatorInt = localComponent["Team"].Enum("Spectator");
if (entityTeamInt != localComponentInt && localComponentInt != SpectatorInt) {
continue;
}
}
// Code for check if sprite is inside or outside of screen
//glm::vec4 projectedPos = m_Camera->ProjectionMatrix() * m_Camera->ViewMatrix() * glm::vec4(pos, 1.0f);
//projectedPos /= projectedPos.w;
//// Check if inside of outside of screen.
//if (projectedPos.x < -1.0f || projectedPos.x > 1.0f || projectedPos.y < -1.0f || projectedPos.y > 1.0f) {
// // is outside of screen
//} else {
// // is inside of screen
//}
glm::vec3 zAxis = glm::vec3(0.0f, 1.0f, 0.0f);
glm::vec3 normal = pos - m_Camera->Position();
//float distance = glm::length(normal);
//if (distance < minDistance) {
// pos = pos - glm::normalize(normal) * (distance - minDistance);
//} else if (distance > maxDistance) {
// pos = pos - glm::normalize(normal) * (distance - maxDistance);
//}
normal.y = 0;
normal = glm::normalize(normal);
glm::vec3 right = glm::cross(normal, zAxis);
glm::vec3 up = glm::cross(right, normal);
modelMatrix[0][0] = right.x;
modelMatrix[0][1] = right.y;
modelMatrix[0][2] = right.z;
modelMatrix[0][3] = 0.0f;
modelMatrix[1][0] = zAxis.x;
modelMatrix[1][1] = zAxis.y;
modelMatrix[1][2] = zAxis.z;
modelMatrix[1][3] = 0.0f;
modelMatrix[2][0] = normal.x;
modelMatrix[2][1] = normal.y;
modelMatrix[2][2] = normal.z;
modelMatrix[2][3] = 0.0f;
modelMatrix[3][0] = pos.x;
modelMatrix[3][1] = pos.y;
modelMatrix[3][2] = pos.z;
modelMatrix[3][3] = 1.0f;
glm::mat4 tranformationMatrix = modelMatrix * glm::scale(Transform::AbsoluteScale(entity));
glm::vec4 tmp = tranformationMatrix * glm::vec4(glm::vec3(0.5, 0.5, 0), 1.0f);
glm::vec2 projectedTopRight = m_Camera->WorldToScreen(glm::vec3(tmp), m_Renderer->GetViewportSize());
tmp = tranformationMatrix * glm::vec4(glm::vec3(-0.5, -0.5, 0), 1.0f);
glm::vec2 projectedBottomLeft = m_Camera->WorldToScreen(glm::vec3(tmp), m_Renderer->GetViewportSize());
float diag = glm::length(projectedBottomLeft - projectedTopRight);
if (diag < minScale) {
tranformationMatrix = tranformationMatrix * glm::scale(glm::vec3(minScale / diag, minScale / diag, minScale / diag));
}
modelMatrix = tranformationMatrix;
}
else {
modelMatrix = Transform::ModelMatrix(entity.ID, world);
}
std::string diffuseResource = cSprite["DiffuseTexture"];
std::string glowResource = cSprite["GlowMap"];
bool depthSorted = cSprite["DepthSort"];
@@ -67,11 +162,7 @@ void RenderSystem::fillSprites(std::list<std::shared_ptr<RenderJob>>& jobs, Worl
fillColor = (glm::vec4)fillComponent["Color"];
}
glm::mat4 modelMatrix = Transform::ModelMatrix(entity.ID, world);
//modelMatrix *= m_Camera->BillboardMatrix();
std::shared_ptr<SpriteJob> spriteJob = std::shared_ptr<SpriteJob>(new SpriteJob(cSprite, m_Camera, modelMatrix, world, fillColor, fillPercentage, depthSorted));
std::shared_ptr<SpriteJob> spriteJob = std::shared_ptr<SpriteJob>(new SpriteJob(cSprite, m_Camera, modelMatrix, world, fillColor, fillPercentage, depthSorted, isIndicator));
jobs.push_back(spriteJob);
}
@@ -93,7 +184,6 @@ bool RenderSystem::isEntityVisible(EntityWrapper& entity)
) {
return false;
}
return true;
}
src/Engine/Rendering/Renderer.cpp
+14 -5
View File
@@ -30,6 +30,7 @@ void Renderer::glfwFrameBufferCallback(GLFWwindow* window, int width, int height
currentRenderer->m_LightCullingPass->OnWindowResize();
currentRenderer->m_PickingPass->OnWindowResize();
currentRenderer->m_DrawBloomPass->OnWindowResize();
currentRenderer->m_SSAOPass->OnWindowResize();
}
void Renderer::InitializeWindow()
@@ -88,9 +89,6 @@ void Renderer::InitializeShaders()
//m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ExplosionEffect.frag.glsl")));
//m_ExplosionEffectProgram->Compile();
//m_ExplosionEffectProgram->Link();
}
void Renderer::InputUpdate(double dt)
@@ -108,7 +106,14 @@ void Renderer::Update(double dt)
void Renderer::Draw(RenderFrame& frame)
{
GLERROR("PRE");
ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking\0Ambient Occlusion");
ImGui::Combo("CubeMap", &m_CubeMapTexture, "Nevada(512)\0Sky(1024)");
if(m_CubeMapTexture == 0) {
m_CubeMapPass->LoadTextures("Nevada");
} else if (m_CubeMapTexture == 1) {
m_CubeMapPass->LoadTextures("Sky");
}
ImGui::SliderFloat("SSAO sample radius", &m_SSAO_Radius, 0.01f, 5.0f);
ImGui::SliderFloat("SSAO bias", &m_SSAO_Bias, 0.0f, 0.1f);
@@ -117,6 +122,7 @@ void Renderer::Draw(RenderFrame& frame)
ImGui::SliderInt("SSAO Number of Samples", &m_SSAO_NumOfSamples, 2, 100);
ImGui::SliderInt("SSAO Number of Turns", &m_SSAO_NumOfTurns, 0, 50);
m_SSAOPass->Setting(m_SSAO_Radius, m_SSAO_Bias, m_SSAO_Contrast, m_SSAO_IntensityScale, m_SSAO_NumOfSamples, m_SSAO_NumOfTurns);
GLERROR("SSAO Settings");
//clear buffer 0
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -126,7 +132,9 @@ void Renderer::Draw(RenderFrame& frame)
m_PickingPass->ClearPicking();
m_DrawFinalPass->ClearBuffer();
m_DrawBloomPass->ClearBuffer();
m_SSAOPass->ClearBuffer();
PerformanceTimer::StopTimer("Renderer-ClearBuffers");
GLERROR("ClearBuffers");
for (auto scene : frame.RenderScenes) {
PerformanceTimer::StartTimer("Renderer-Depth");
m_PickingPass->Draw(*scene);
@@ -239,9 +247,10 @@ void Renderer::InitializeRenderPasses()
{
m_PickingPass = new PickingPass(this, m_EventBroker);
m_LightCullingPass = new LightCullingPass(this);
m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
m_CubeMapPass = new CubeMapPass(this);
m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass);
m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
m_DrawBloomPass = new DrawBloomPass(this);
m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
m_SSAOPass = new SSAOPass(this);
m_SSAOPass = new SSAOPass(this);
}
src/Engine/Rendering/SSAOPass.cpp
+12 -8
View File
@@ -6,6 +6,7 @@ SSAOPass::SSAOPass(IRenderer* renderer)
m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
InitializeTexture();
InitializeBuffer();
InitializeShaderProgram();
Setting(0.1f, 0.012f, 1.0f, 1.0f, 13, 7);
@@ -28,16 +29,16 @@ void SSAOPass::InitializeShaderProgram()
m_SSAOViewSpaceZProgram->Link();
}
void SSAOPass::InitializeTexture() {
GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R8, GL_RED, GL_FLOAT);
GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R32F, GL_RED, GL_FLOAT);
}
void SSAOPass::InitializeBuffer()
{
GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R8, GL_RED, GL_FLOAT);
m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
m_SSAOFramBuffer.Generate();
GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R32F, GL_RED, GL_FLOAT);
m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
m_SSAOViewSpaceZFramBuffer.Generate();
}
@@ -45,12 +46,12 @@ void SSAOPass::InitializeBuffer()
void SSAOPass::ClearBuffer()
{
m_SSAOFramBuffer.Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClearColor(1.f, 1.f, 1.f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_SSAOFramBuffer.Unbind();
m_SSAOViewSpaceZFramBuffer.Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClearColor(1.f, 1.f, 1.f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_SSAOViewSpaceZFramBuffer.Unbind();
}
@@ -136,6 +137,9 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
m_DrawBloomPass->Draw(m_SSAOTexture);
}
void ComputeAO(GLuint depthBuffer, Camera* camera) {
void SSAOPass::OnWindowResize() {
m_DrawBloomPass->OnWindowResize();
InitializeTexture();
m_SSAOFramBuffer.Generate();
m_SSAOViewSpaceZFramBuffer.Generate();
}
src/Engine/Rendering/Texture.cpp
+2
View File
@@ -18,6 +18,7 @@ Texture::Texture(std::string path)
this->Width = img->Width;
this->Height = img->Height;
this->Data = img->Data;
GLint format;
switch (img->Format) {
@@ -28,6 +29,7 @@ Texture::Texture(std::string path)
format = GL_RGBA;
break;
}
// Construct the OpenGL texture
glGenTextures(1, &m_Texture);