tom/RT_GPU
1
0
Fork 0
mirror of https://github.com/TheRedShip/RT_GPU.git synced 2025-09-27 10:48:34 +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

1
Makefile
View File

@ -80,6 +80,7 @@ $(NAME): $(OBJS) $(HEADERS)
@echo $(WHITE) $(NAME): PROJECT COMPILED !$(RESET) @echo $(WHITE) $(NAME): PROJECT COMPILED !$(RESET)
else else
$(NAME): $(OBJS) $(HEADERS) $(NAME): $(OBJS) $(HEADERS)
@printf "$(LINE_CLR)$(WHITE) $(NAME): linking ...$(RESET)"
@$(CC) $(OBJS) $(IFLAGS) $(CFLAGS) $(LDFLAGS) -o $(NAME) @$(CC) $(OBJS) $(IFLAGS) $(CFLAGS) $(LDFLAGS) -o $(NAME)
@printf "$(LINE_CLR)$(WHITE) $(NAME): PROJECT COMPILED !$(RESET)\n\n" @printf "$(LINE_CLR)$(WHITE) $(NAME): PROJECT COMPILED !$(RESET)\n\n"
endif endif

12
includes/RT/Clusterizer.hpp
View File

@ -6,7 +6,7 @@
/* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */ /* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/20 18:25:18 by tomoron #+# #+# */ /* Created: 2025/02/20 18:25:18 by tomoron #+# #+# */
/* Updated: 2025/02/25 22:26:49 by tomoron ### ########.fr */ /* Updated: 2025/03/14 17:29:56 by tomoron ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -49,6 +49,7 @@ typedef enum e_msg
PROGRESS_UPDATE, PROGRESS_UPDATE,
IMG_SEND_RQ, IMG_SEND_RQ,
IMG, IMG,
SET_MAP,
ABORT ABORT
} t_msg; } t_msg;
@ -83,15 +84,18 @@ class Clusterizer
private: //client private: //client
void initClient(std::string &dest); void initClient(std::string &dest);
void openClientConnection(const char *ip, int port); void openClientConnection(const char *ip, int port);
void clientHandleBuffer(void); void clientHandleBuffer(Scene &scene);
void updateClient(Scene &scene, Window &win, std::vector<GLuint> &textures, ShaderProgram &denoisingProgram); void updateClient(Scene &scene, Window &win, std::vector<GLuint> &textures, ShaderProgram &denoisingProgram);
void clientGetJob(void); void clientGetJob(void);
void clientReceive(void); void clientReceive(Scene &scene);
void handleCurrentJob(Scene &scene, Window &win, std::vector<GLuint> &textures, ShaderProgram &denoisingProgram); void handleCurrentJob(Scene &scene, Window &win, std::vector<GLuint> &textures, ShaderProgram &denoisingProgram);
void sendProgress(uint8_t progress); void sendProgress(uint8_t progress);
void sendImageToServer(std::vector<GLuint> &textures, ShaderProgram &denoisingProgram); void sendImageToServer(Scene &scene, std::vector<GLuint> &textures, ShaderProgram &denoisingProgram);
std::vector<uint8_t> rgb32fToRgb24i(std::vector<float> &imageFloat); std::vector<uint8_t> rgb32fToRgb24i(std::vector<float> &imageFloat);
void changeMap(Scene &scene);
bool stringComplete(void);
int _serverFd; int _serverFd;
std::string _serverIp; std::string _serverIp;
int _serverPort; int _serverPort;

7
includes/RT/Scene.hpp
View File

@ -6,7 +6,7 @@
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */ /* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/23 18:30:18 by ycontre #+# #+# */ /* Created: 2024/12/23 18:30:18 by ycontre #+# #+# */
/* Updated: 2025/02/25 01:44:31 by tomoron ### ########.fr */ /* Updated: 2025/03/16 17:00:32 by tomoron ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -140,8 +140,13 @@ class Scene
GPUMaterial getMaterial(int material_index); GPUMaterial getMaterial(int material_index);
bool fail(void) const; bool fail(void) const;
void changeScene(std::string &name);
std::vector<Buffer *> createDataOnGPU(void);
private: private:
void init(std::string &name);
bool _fail; bool _fail;
std::vector<GPUBvhData> _gpu_bvh_data; std::vector<GPUBvhData> _gpu_bvh_data;

BIN
output.path
View File

Binary file not shown.

5
srcs/RT.cpp
View File

@ -6,7 +6,7 @@
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */ /* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/27 14:51:49 by TheRed #+# #+# */ /* 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<GLuint> generateTextures(unsigned int textures_count);
std::vector<Buffer *> createDataOnGPU(Scene &scene);
void updateDataOnGPU(Scene &scene, std::vector<Buffer *> buffers); void updateDataOnGPU(Scene &scene, std::vector<Buffer *> buffers);
void shaderDenoise(ShaderProgram &denoising_program, GPUDenoise &denoise, std::vector<GLuint> textures); 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.attachShader(&frag);
render_program.link(); render_program.link();
std::vector<Buffer *> buffers = createDataOnGPU(scene); std::vector<Buffer *> buffers = scene.createDataOnGPU();
if (!scene.loadTextures()) if (!scene.loadTextures())
return (-1); return (-1);

38
srcs/RT_utils.cpp
View File

@ -6,7 +6,7 @@
/* By: TheRed <TheRed@students.42.fr> +#+ +:+ +#+ */ /* By: TheRed <TheRed@students.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/12 23:21:09 by TheRed #+# #+# */ /* 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); 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) void updateDataOnGPU(Scene &scene, std::vector<Buffer *> buffers)
{ {
const std::vector<GPUMaterial> &material_data = scene.getMaterialData(); 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); 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> +#+ +:+ +#+ */ /* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/20 21:08:38 by tomoron #+# #+# */ /* 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) void Clusterizer::openClientConnection(const char *ip, int port)
{ {
struct sockaddr_in serv_addr; struct sockaddr_in serv_addr;
uint8_t sendBuffer;
if(port > 65535 || port < 0) if(port > 65535 || port < 0)
{ {
@ -59,8 +58,7 @@ void Clusterizer::openClientConnection(const char *ip, int port)
close(_serverFd); close(_serverFd);
_serverFd = 0; _serverFd = 0;
} }
sendBuffer = RDY; // (void)write(_serverFd, (uint8_t []){RDY}, 1);
(void)write(_serverFd, &sendBuffer, 1);
} }
void Clusterizer::clientGetJob(void) void Clusterizer::clientGetJob(void)
@ -79,7 +77,31 @@ void Clusterizer::clientGetJob(void)
_progress = 0; _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; std::vector<uint8_t> sendBuf;
@ -98,11 +120,19 @@ void Clusterizer::clientHandleBuffer(void)
} }
else if(_receiveBuffer[0] == ABORT) 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; delete _currentJob;
_currentJob = 0; _currentJob = 0;
_receiveBuffer.erase(_receiveBuffer.begin()); _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 else
{ {
std::cout << "unknown request sent, ignoring" << std::endl; std::cout << "unknown request sent, ignoring" << std::endl;
@ -111,10 +141,10 @@ void Clusterizer::clientHandleBuffer(void)
if(sendBuf.size()) 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]; uint8_t buffer[512];
size_t ret; size_t ret;
@ -130,7 +160,7 @@ void Clusterizer::clientReceive(void)
} }
_receiveBuffer.insert(_receiveBuffer.end(), buffer, buffer + ret); _receiveBuffer.insert(_receiveBuffer.end(), buffer, buffer + ret);
} }
clientHandleBuffer(); clientHandleBuffer(scene);
} }
void Clusterizer::sendProgress(uint8_t progress) void Clusterizer::sendProgress(uint8_t progress)
@ -165,7 +195,7 @@ std::vector<uint8_t> Clusterizer::rgb32fToRgb24i(std::vector<float> &imageFloat)
return(buffer); return(buffer);
} }
void Clusterizer::sendImageToServer(std::vector<GLuint> &textures, ShaderProgram &denoisingProgram) void Clusterizer::sendImageToServer(Scene &scene, std::vector<GLuint> &textures, ShaderProgram &denoisingProgram)
{ {
_srvReady = 0; _srvReady = 0;
std::vector<float> imageFloat(WIDTH * HEIGHT * 4); 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); (void)write(_serverFd, (uint8_t []){IMG_SEND_RQ}, 1);
while(!_srvReady) while(!_srvReady)
{ {
clientReceive(); clientReceive(scene);
if(!_serverFd) if(!_serverFd)
{ {
delete _currentJob; delete _currentJob;
@ -234,7 +264,7 @@ void Clusterizer::handleCurrentJob(Scene &scene, Window &win, std::vector<GLuint
if((size_t)win.getFrameCount() == _currentJob->samples) if((size_t)win.getFrameCount() == _currentJob->samples)
{ {
std::cout << "send request" << std::endl; 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; std::cout << "server isn't connected, waiting for connection" << std::endl;
while(!_serverFd) while(!_serverFd)
{
openClientConnection(_serverIp.c_str(), _serverPort); openClientConnection(_serverIp.c_str(), _serverPort);
usleep(10000);
}
std::cout << "server reconnected." << std::endl; std::cout << "server reconnected." << std::endl;
} }
clientReceive(); clientReceive(scene);
handleCurrentJob(scene, win, textures, denoisingProgram); handleCurrentJob(scene, win, textures, denoisingProgram);
} }

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

@ -6,7 +6,7 @@
/* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */ /* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/20 21:08:38 by tomoron #+# #+# */ /* 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; std::cout << "new client :" << fd << std::endl;
_clients[fd].ready = 0; _clients[fd].ready = 0;
_clients[fd].curJob = 0; _clients[fd].curJob = 0;
(void)write(fd, (uint8_t []){SET_MAP}, 1);
(void)write(fd, _sceneName.c_str(), _sceneName.size() + 1);
updatePollfds(); updatePollfds();
return(1); 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); auto posIter = std::find(_jobs[IN_PROGRESS].begin(), _jobs[IN_PROGRESS].end(), _clients[fd].curJob);
_jobs[IN_PROGRESS].erase(posIter); _jobs[IN_PROGRESS].erase(posIter);
_jobs[DONE].push_back(_clients[fd].curJob); _jobs[DONE].push_back(_clients[fd].curJob);
_clients[fd].curJob = 0;
_clients[fd].curJob = 0;
_curFrame++; _curFrame++;
} }

58
srcs/class/Scene.cpp
View File

@ -6,7 +6,7 @@
/* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */ /* By: ycontre <ycontre@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/12/23 18:29:41 by ycontre #+# #+# */ /* 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" #include "stb_image.h"
Scene::Scene(std::string &name) 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::ifstream file(name);
std::string line; 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; _gpu_volume.enabled = 0;
_fail = 0;
_gpu_volume.sigma_a = glm::vec3(0.0000f); _gpu_volume.sigma_a = glm::vec3(0.0000f);
_gpu_volume.sigma_s = glm::vec3(0.0800f); _gpu_volume.sigma_s = glm::vec3(0.0800f);
_gpu_volume.sigma_t = _gpu_volume.sigma_a + _gpu_volume.sigma_s; _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"); throw std::runtime_error("Incorrect material index");
return (_gpu_materials[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();
}