tom/RT_GPU
1
0
Fork 0
mirror of https://github.com/TheRedShip/RT_GPU.git synced 2025-09-27 18:48:36 +02:00
Code Issues Packages Projects Releases Wiki Activity

change scene request. doesn't work, black screen

Browse Source
This commit is contained in:
tomoron
2025-03-16 17:57:51 +01:00
parent b003531bfa
commit 3efff641ae
9 changed files with 124 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
srcs/RT.cpp
View File

@ -6,7 +6,7 @@
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/27 14:51:49 by TheRed #+# #+# */
/* Updated: 2025/02/25 01:51:27 by tomoron ### ########.fr */
/* Updated: 2025/03/16 17:38:51 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
@ -17,7 +17,6 @@ void drawScreenTriangle(GLuint VAO, GLuint output_texture, GLuint program);
std::vector<GLuint> generateTextures(unsigned int textures_count);
std::vector<Buffer *> createDataOnGPU(Scene &scene);
void updateDataOnGPU(Scene &scene, std::vector<Buffer *> buffers);
void shaderDenoise(ShaderProgram &denoising_program, GPUDenoise &denoise, std::vector<GLuint> textures);
@ -60,7 +59,7 @@ int main(int argc, char **argv)
render_program.attachShader(&frag);
render_program.link();
std::vector<Buffer *> buffers = createDataOnGPU(scene);
std::vector<Buffer *> buffers = scene.createDataOnGPU();
if (!scene.loadTextures())
return (-1);

38
srcs/RT_utils.cpp
View File

@ -6,7 +6,7 @@
/* By: TheRed <TheRed@students.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/12 23:21:09 by TheRed #+# #+# */
/* Updated: 2025/02/12 23:21:09 by TheRed ### ########.fr */
/* Updated: 2025/03/16 17:37:32 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
@ -74,40 +74,6 @@ std::vector<GLuint> generateTextures(unsigned int textures_count)
return (textures);
}
std::vector<Buffer *> createDataOnGPU(Scene &scene)
{
GLint max_gpu_size;
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_gpu_size);
const std::vector<GPUObject> &object_data = scene.getObjectData();
const std::vector<GPUTriangle> &triangle_data = scene.getTriangleData();
const std::vector<GPUBvh> &bvh_nodes = scene.getBvh();
const std::vector<GPUBvhData> &bvh_data = scene.getBvhData();
const std::vector<GPUMaterial> &material_data = scene.getMaterialData();
std::cout << "Sending " << object_data.size() << " objects for " << \
object_data.size() * sizeof(GPUObject) + \
triangle_data.size() * sizeof(GPUTriangle) + \
bvh_nodes.size() * sizeof(GPUBvh) + \
material_data.size() * sizeof(GPUMaterial) \
<< " / " << max_gpu_size << " bytes" << std::endl;
std::vector<Buffer *> buffers;
buffers.push_back(new Buffer(Buffer::Type::SSBO, 1, sizeof(GPUObject) * object_data.size(), object_data.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 2, sizeof(GPUTriangle) * triangle_data.size(), triangle_data.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 3, sizeof(GPUBvhData) * bvh_data.size(), bvh_data.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 4, sizeof(GPUBvh) * bvh_nodes.size(), bvh_nodes.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 5, sizeof(GPUMaterial) * material_data.size(), nullptr));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 6, scene.getGPULights().size() * sizeof(int), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 0, sizeof(GPUCamera), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 1, sizeof(GPUVolume), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 2, sizeof(GPUDebug), nullptr));
return (buffers);
}
void updateDataOnGPU(Scene &scene, std::vector<Buffer *> buffers)
{
const std::vector<GPUMaterial> &material_data = scene.getMaterialData();
@ -150,4 +116,4 @@ void shaderDenoise(ShaderProgram &denoising_program, GPUDenoise &denoise, std::v
}
glBindImageTexture(5, textures[output_texture], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
}
}

59
srcs/class/Clusterizer/client.cpp
View File

@ -6,7 +6,7 @@
/* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/20 21:08:38 by tomoron #+# #+# */
/* Updated: 2025/02/25 20:41:09 by tomoron ### ########.fr */
/* Updated: 2025/03/16 16:42:41 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
@ -37,7 +37,6 @@ void Clusterizer::initClient(std::string &dest)
void Clusterizer::openClientConnection(const char *ip, int port)
{
struct sockaddr_in serv_addr;
uint8_t sendBuffer;
if(port > 65535 || port < 0)
{
@ -59,8 +58,7 @@ void Clusterizer::openClientConnection(const char *ip, int port)
close(_serverFd);
_serverFd = 0;
}
sendBuffer = RDY;
(void)write(_serverFd, &sendBuffer, 1);
// (void)write(_serverFd, (uint8_t []){RDY}, 1);
}
void Clusterizer::clientGetJob(void)
@ -79,7 +77,31 @@ void Clusterizer::clientGetJob(void)
_progress = 0;
}
void Clusterizer::clientHandleBuffer(void)
bool Clusterizer::stringComplete(void)
{
for(size_t i = 1; i < _receiveBuffer.size(); i++)
if(_receiveBuffer[i] == 0)
return(true);
return(false);
}
void Clusterizer::changeMap(Scene &scene)
{
size_t len;
len = 1;
while(_receiveBuffer[len])
len++;
_sceneName = std::string((char *)_receiveBuffer.data() + 1);
_receiveBuffer.erase(_receiveBuffer.begin(), _receiveBuffer.begin() + len);
std::cout << "changing scene to name :" << _sceneName << std::endl;
scene.changeScene(_sceneName);
if(scene.fail())
throw std::runtime_error("map change failed");
(void)write(_serverFd, (uint8_t []){RDY}, 1);
}
void Clusterizer::clientHandleBuffer(Scene &scene)
{
std::vector<uint8_t> sendBuf;
@ -98,11 +120,19 @@ void Clusterizer::clientHandleBuffer(void)
}
else if(_receiveBuffer[0] == ABORT)
{
std::cout << "got a abort request, aborting current job";
std::cout << "got a abort request, aborting current job" << std::endl;
delete _currentJob;
_currentJob = 0;
_receiveBuffer.erase(_receiveBuffer.begin());
}
else if(_receiveBuffer[0] == SET_MAP)
{
std::cout << "got change map request" << std::endl;
if(stringComplete())
changeMap(scene);
else
std::cout << "string is not complete, waiting for eof signal" << std::endl;
}
else
{
std::cout << "unknown request sent, ignoring" << std::endl;
@ -111,10 +141,10 @@ void Clusterizer::clientHandleBuffer(void)
if(sendBuf.size())
(void)write(1, sendBuf.data(), sendBuf.size());
(void)write(_serverFd, sendBuf.data(), sendBuf.size());
}
void Clusterizer::clientReceive(void)
void Clusterizer::clientReceive(Scene &scene)
{
uint8_t buffer[512];
size_t ret;
@ -130,7 +160,7 @@ void Clusterizer::clientReceive(void)
}
_receiveBuffer.insert(_receiveBuffer.end(), buffer, buffer + ret);
}
clientHandleBuffer();
clientHandleBuffer(scene);
}
void Clusterizer::sendProgress(uint8_t progress)
@ -165,7 +195,7 @@ std::vector<uint8_t> Clusterizer::rgb32fToRgb24i(std::vector<float> &imageFloat)
return(buffer);
}
void Clusterizer::sendImageToServer(std::vector<GLuint> &textures, ShaderProgram &denoisingProgram)
void Clusterizer::sendImageToServer(Scene &scene, std::vector<GLuint> &textures, ShaderProgram &denoisingProgram)
{
_srvReady = 0;
std::vector<float> imageFloat(WIDTH * HEIGHT * 4);
@ -174,7 +204,7 @@ void Clusterizer::sendImageToServer(std::vector<GLuint> &textures, ShaderProgram
(void)write(_serverFd, (uint8_t []){IMG_SEND_RQ}, 1);
while(!_srvReady)
{
clientReceive();
clientReceive(scene);
if(!_serverFd)
{
delete _currentJob;
@ -234,7 +264,7 @@ void Clusterizer::handleCurrentJob(Scene &scene, Window &win, std::vector<GLuint
if((size_t)win.getFrameCount() == _currentJob->samples)
{
std::cout << "send request" << std::endl;
sendImageToServer(textures, denoisingProgram);
sendImageToServer(scene, textures, denoisingProgram);
}
}
@ -245,10 +275,13 @@ void Clusterizer::updateClient(Scene &scene, Window &win, std::vector<GLuint> &t
{
std::cout << "server isn't connected, waiting for connection" << std::endl;
while(!_serverFd)
{
openClientConnection(_serverIp.c_str(), _serverPort);
usleep(10000);
}
std::cout << "server reconnected." << std::endl;
}
clientReceive();
clientReceive(scene);
handleCurrentJob(scene, win, textures, denoisingProgram);
}

6
srcs/class/Clusterizer/server.cpp
View File

@ -6,7 +6,7 @@
/* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/20 21:08:38 by tomoron #+# #+# */
/* Updated: 2025/03/14 14:22:06 by tomoron ### ########.fr */
/* Updated: 2025/03/16 17:39:06 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
@ -73,6 +73,8 @@ int Clusterizer::acceptClients(void)
std::cout << "new client :" << fd << std::endl;
_clients[fd].ready = 0;
_clients[fd].curJob = 0;
(void)write(fd, (uint8_t []){SET_MAP}, 1);
(void)write(fd, _sceneName.c_str(), _sceneName.size() + 1);
updatePollfds();
return(1);
}
@ -157,8 +159,8 @@ void Clusterizer::getImageFromClient(int fd, std::vector<uint8_t> &buf)
auto posIter = std::find(_jobs[IN_PROGRESS].begin(), _jobs[IN_PROGRESS].end(), _clients[fd].curJob);
_jobs[IN_PROGRESS].erase(posIter);
_jobs[DONE].push_back(_clients[fd].curJob);
_clients[fd].curJob = 0;
_clients[fd].curJob = 0;
_curFrame++;
}

58
srcs/class/Scene.cpp
View File

@ -6,7 +6,7 @@
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/23 18:29:41 by ycontre #+# #+# */
/* Updated: 2025/02/13 18:13:58 by ycontre ### ########.fr */
/* Updated: 2025/03/16 17:49:37 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,13 +16,19 @@
#include "stb_image.h"
Scene::Scene(std::string &name)
{
_camera = new Camera(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), -90.0f, 0.0f);
_fail = 0;
init(name);
}
void Scene::init(std::string &name)
{
std::ifstream file(name);
std::string line;
_camera = new Camera(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), -90.0f, 0.0f);
_gpu_volume.enabled = 0;
_fail = 0;
_gpu_volume.sigma_a = glm::vec3(0.0000f);
_gpu_volume.sigma_s = glm::vec3(0.0800f);
_gpu_volume.sigma_t = _gpu_volume.sigma_a + _gpu_volume.sigma_s;
@ -397,3 +403,49 @@ GPUMaterial Scene::getMaterial(int material_index)
throw std::runtime_error("Incorrect material index");
return (_gpu_materials[material_index]);
}
std::vector<Buffer *> Scene::createDataOnGPU(void)
{
GLint max_gpu_size;
glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &max_gpu_size);
std::cout << "Sending " << _gpu_objects.size() << " objects for " << \
_gpu_objects.size() * sizeof(GPUObject) + \
_gpu_triangles.size() * sizeof(GPUTriangle) + \
_gpu_bvh.size() * sizeof(GPUBvh) + \
_gpu_materials.size() * sizeof(GPUMaterial) \
<< " / " << max_gpu_size << " bytes" << std::endl;
std::vector<Buffer *> buffers;
buffers.push_back(new Buffer(Buffer::Type::SSBO, 1, sizeof(GPUObject) * _gpu_objects.size(), _gpu_objects.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 2, sizeof(GPUTriangle) * _gpu_triangles.size(), _gpu_triangles.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 3, sizeof(GPUBvhData) * _gpu_bvh_data.size(), _gpu_bvh_data.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 4, sizeof(GPUBvh) * _gpu_bvh.size(), _gpu_bvh.data()));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 5, sizeof(GPUMaterial) * _gpu_materials.size(), nullptr));
buffers.push_back(new Buffer(Buffer::Type::SSBO, 6, getGPULights().size() * sizeof(int), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 0, sizeof(GPUCamera), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 1, sizeof(GPUVolume), nullptr));
buffers.push_back(new Buffer(Buffer::Type::UBO, 2, sizeof(GPUDebug), nullptr));
return (buffers);
}
void Scene::changeScene(std::string &name)
{
_gpu_bvh_data.clear();
_gpu_bvh.clear();
_gpu_objects.clear();
_gpu_triangles.clear();
_gpu_materials.clear();
_textures.clear();
_emissive_textures.clear();
_gpu_textures.clear();
_gpu_emissive_textures.clear();
_gpu_lights.clear();
init(name);
createDataOnGPU();
loadTextures();
}