From c98371068cd70c58afa9f97a69c31f28d6e627cd Mon Sep 17 00:00:00 2001 From: Ben Date: Thu, 29 Aug 2019 22:32:43 +0100 Subject: [PATCH] pathtracing --- src/common.hpp | 12 +- src/definitions/{ => materials}/material.hpp | 0 src/definitions/scene.cpp | 2 +- src/display/tonemap.cpp | 45 -------- src/display/tonemapfb.cpp | 72 ++++++++++++ src/display/{tonemap.hpp => tonemapfb.hpp} | 17 ++- src/engine/progressiverenderer.cpp | 78 +++++++++++-- src/engine/progressiverenderer.hpp | 14 ++- src/engine/renderengine.cpp | 114 ++++++++++++++++--- src/engine/renderengine.hpp | 8 +- src/util/threadpool.cpp | 12 +- src/util/threadpool.hpp | 6 +- test/main.cpp | 25 ++-- 13 files changed, 301 insertions(+), 104 deletions(-) rename src/definitions/{ => materials}/material.hpp (100%) delete mode 100644 src/display/tonemap.cpp create mode 100644 src/display/tonemapfb.cpp rename src/display/{tonemap.hpp => tonemapfb.hpp} (59%) diff --git a/src/common.hpp b/src/common.hpp index 4d3c902..36c685e 100644 --- a/src/common.hpp +++ b/src/common.hpp @@ -14,24 +14,24 @@ #include enum OperationMode { - MODE_OPERATION_DEFAULT, MODE_OPERATION_PROGRESSIVE_GUI, MODE_OPERATION_PROGRESSIVE_IMG, - MODE_OPERATION_SAMPLES_IMG + MODE_OPERATION_SAMPLES_IMG, + MODE_OPERATION_DEFAULT }; enum RenderMode { - MODE_RENDER_DEFAULT, MODE_RENDER_PATHTRACE, - MODE_RENDER_NORMALS + MODE_RENDER_NORMALS, + MODE_RENDER_DEFAULT }; enum AccelerationMode { - MODE_ACCELERATION_DEFAULT, MODE_ACCELERATION_NONE, MODE_ACCELERATION_KD, MODE_ACCELERATION_KD_SLOW, - MODE_ACCELERATION_BVH + MODE_ACCELERATION_BVH, + MODE_ACCELERATION_DEFAULT }; #endif diff --git a/src/definitions/material.hpp b/src/definitions/materials/material.hpp similarity index 100% rename from src/definitions/material.hpp rename to src/definitions/materials/material.hpp diff --git a/src/definitions/scene.cpp b/src/definitions/scene.cpp index 48a53b9..7af0c07 100644 --- a/src/definitions/scene.cpp +++ b/src/definitions/scene.cpp @@ -8,5 +8,5 @@ Scene::Scene(int width, int height) { } glm::vec3 Scene::SampleSky(Ray ray) { - return { 0.617f, 0.980f, 1.000f }; + return { 10.0f, 10.0f, 10.0f }; } diff --git a/src/display/tonemap.cpp b/src/display/tonemap.cpp deleted file mode 100644 index 2dc91e7..0000000 --- a/src/display/tonemap.cpp +++ /dev/null @@ -1,45 +0,0 @@ -#include "tonemap.hpp" - -#include "framebuffer.hpp" - -#include "../pixel.hpp" - -MapBuffer::MapBuffer(int xres, int yres) { - XRes = xres; YRes = yres; - Data = (glm::vec3*)malloc((xres * yres) * sizeof(glm::vec3)); - memset((void*)Data, 0, (xres * yres) * sizeof(glm::vec3)); -} - -void MapBuffer::SetPixel(int x, int y, glm::vec3 p) { - Data[y * this->XRes + x] = p; -} - -void MapBuffer::SetPixelSafe(int x, int y, glm::vec3 p) { - if (x >= 0 && x < this->XRes && y >= 0 && this->YRes) { - Data[y * this->XRes + x] = p; - } -} - -void MapBuffer::SetFramebuffer(glm::vec3* fb) { - free(Data); - Data = fb; -} - -void MapBuffer::ClearFramebuffer() { - memset((void*)Data, 0, (XRes * YRes) * sizeof(glm::vec3)); -} - -void MapBuffer::ClampBasic(FrameBuffer* buffer) { - for (int x = 0; x < XRes; x++) - for (int y = 0; y < YRes; y++) { - buffer->SetPixelSafe(x, y, Clamp(Data[y * this->XRes + x], 1.0f, 0.0f)); - } -} - -void MapBuffer::MapBasic(FrameBuffer* buffer) { - -} - -MapBuffer::~MapBuffer() { - free(Data); -} diff --git a/src/display/tonemapfb.cpp b/src/display/tonemapfb.cpp new file mode 100644 index 0000000..a1288e3 --- /dev/null +++ b/src/display/tonemapfb.cpp @@ -0,0 +1,72 @@ +#include "tonemapfb.hpp" + +#include "framebuffer.hpp" + +#include "../pixel.hpp" + +ToneMapFrameBuffer::ToneMapFrameBuffer(int xres, int yres) { + XRes = xres; YRes = yres; + RenderTo = (glm::vec3*)malloc((xres * yres) * sizeof(glm::vec3)); + memset((void*)RenderTo, 0, (xres * yres) * sizeof(glm::vec3)); + ProcData = (glm::vec3*)malloc((xres * yres) * sizeof(glm::vec3)); + memset((void*)ProcData, 0, (xres * yres) * sizeof(glm::vec3)); +} + +void ToneMapFrameBuffer::SetPixel(int x, int y, glm::vec3 p) { + if (LastOp != OPERATION_SET) { ClearFramebuffer(); } + LastOp = OPERATION_SET; + RenderTo[y * this->XRes + x] = p; +} + +void ToneMapFrameBuffer::SetPixelSafe(int x, int y, glm::vec3 p) { + if (x >= 0 && x < this->XRes && y >= 0 && this->YRes) { + if (LastOp != OPERATION_SET) { ClearFramebuffer(); } + LastOp = OPERATION_SET; + RenderTo[y * this->XRes + x] = p; + } +} + +void ToneMapFrameBuffer::AddPixelSafe(int x, int y, glm::vec3 p) { + if (x >= 0 && x < this->XRes && y >= 0 && this->YRes) { + if (LastOp != OPERATION_ADD) { ClearFramebuffer(); } + LastOp = OPERATION_ADD; + RenderTo[y * this->XRes + x] += p; + } +} + +void ToneMapFrameBuffer::SetFramebuffer(glm::vec3* fb) { + free(ProcData); + RenderTo = fb; +} + +void ToneMapFrameBuffer::ClearFramebuffer() { + memset((void*)RenderTo, 0, (XRes * YRes) * sizeof(glm::vec3)); +} + +void ToneMapFrameBuffer::ClampBasic(FrameBuffer* buffer) { + for (int x = 0; x < XRes; x++) + for (int y = 0; y < YRes; y++) { + buffer->SetPixelSafe(x, y, Clamp(ProcData[y * this->XRes + x], 1.0f, 0.0f)); + } +} + +void ToneMapFrameBuffer::MapBasic(FrameBuffer* buffer) { + float max = 0.0f; + + for (int x = 0; x < XRes; x++) + for (int y = 0; y < YRes; y++) { + if (ProcData[y * this->XRes + x].r > max) max = ProcData[y * this->XRes + x].r; + if (ProcData[y * this->XRes + x].g > max) max = ProcData[y * this->XRes + x].g; + if (ProcData[y * this->XRes + x].b > max) max = ProcData[y * this->XRes + x].b; + } + + for (int x = 0; x < XRes; x++) + for (int y = 0; y < YRes; y++) { + buffer->SetPixelSafe(x, y, ProcData[y * this->XRes + x] / max); + } +} + +ToneMapFrameBuffer::~ToneMapFrameBuffer() { + free(RenderTo); + free(ProcData); +} diff --git a/src/display/tonemap.hpp b/src/display/tonemapfb.hpp similarity index 59% rename from src/display/tonemap.hpp rename to src/display/tonemapfb.hpp index ba6c826..a8e685f 100644 --- a/src/display/tonemap.hpp +++ b/src/display/tonemapfb.hpp @@ -9,12 +9,19 @@ class FrameBuffer; class Pixel; -class MapBuffer { +enum LastOperation { + OPERATION_NONE, + OPERATION_SET, + OPERATION_ADD +}; + +class ToneMapFrameBuffer { public: - MapBuffer(int xres, int yres); + ToneMapFrameBuffer(int xres, int yres); void SetPixel(int x, int y, glm::vec3 p); void SetPixelSafe(int x, int y, glm::vec3); + void AddPixelSafe(int x, int y, glm::vec3); void SetFramebuffer(glm::vec3* fb); void ClearFramebuffer(); @@ -24,10 +31,12 @@ public: void MapBasic(FrameBuffer* buffer); - glm::vec3* Data; + LastOperation LastOp = OPERATION_NONE; + glm::vec3* RenderTo; + glm::vec3* ProcData; int XRes, YRes; - ~MapBuffer(); + ~ToneMapFrameBuffer(); }; #endif diff --git a/src/engine/progressiverenderer.cpp b/src/engine/progressiverenderer.cpp index d5d53ff..ee7b341 100644 --- a/src/engine/progressiverenderer.cpp +++ b/src/engine/progressiverenderer.cpp @@ -1,5 +1,9 @@ #include "progressiverenderer.hpp" +#include +#include +#include + #include "renderengine.hpp" #include "../common.hpp" @@ -7,7 +11,7 @@ #include "../display/displayinterface.hpp" #include "../display/framebuffer.hpp" -#include "../display/tonemap.hpp" +#include "../display/tonemapfb.hpp" #include "../util/assetloader.hpp" #include "../util/threadpool.hpp" @@ -35,30 +39,75 @@ void ProgressiveRenderer::Input() { while (SDL_PollEvent(&e)) if (e.type == SDL_QUIT) m_interface->Close(); + //const Uint8* state = SDL_GetKeyboardState(NULL); + + //if (state[SDL_SCANCODE_W]) m_scene->objects[0]->center.y += 0.01f; + //if (state[SDL_SCANCODE_S]) m_scene->objects[0]->center.y -= 0.01f; + //if (state[SDL_SCANCODE_D]) m_scene->objects[0]->center.x += 0.01f; + //if (state[SDL_SCANCODE_A]) m_scene->objects[0]->center.x -= 0.01f; + if (!m_interface->ImGui) return; ImGui::NewFrame(); ImGui::Begin("Debug"); - ImGui::Checkbox("Render Normals", &m_normals); - if (m_normals) { - m_engine->Mode = MODE_RENDER_NORMALS; - } else { - m_engine->Mode = MODE_RENDER_PATHTRACE; + + if (m_engine->Mode != MODE_RENDER_NORMALS) { + std::stringstream str; str << "SPP: " << m_engine->SPP; + ImGui::Text(str.str().c_str()); } + std::stringstream str0; str0 << "FPS: " << 1.0f / AverageFrameTime; + ImGui::Text(str0.str().c_str()); + std::stringstream str1; str1 << "MS Per Frame: " << AverageFrameTime * 1000.0f; + ImGui::Text(str1.str().c_str()); + std::stringstream str2; str2 << "S Per Frame: " << AverageFrameTime; + ImGui::Text(str2.str().c_str()); + + float upper = 0.0f; float lower = 0.0f; + for (int i = 0; i < AllFrameTimes.size(); i++) { + if (AllFrameTimes[i] > upper) upper = AllFrameTimes[i]; + if (AllFrameTimes[i] < lower) lower = AllFrameTimes[i]; + } + ImGui::PlotLines("FrameTimes", FrameTimes.data(), FrameTimes.size(), 0, NULL, lower, upper, ImVec2(0, 40)); + + ImGui::BeginChild("Render Settings"); + + const char* renderItems[] = { "PathTrace", "Normals" }; + ImGui::Combo("Render Mode", &m_renderModeSelected, renderItems, IM_ARRAYSIZE(renderItems)); + m_engine->Mode = (RenderMode)m_renderModeSelected; + + const char* toneMapItems[] = { "Clamp", "Basic Tonemap" }; + ImGui::Combo("ToneMap Mode", &m_toneMapModeSelected, toneMapItems, IM_ARRAYSIZE(toneMapItems)); + + ImGui::EndChild(); ImGui::End(); } void ProgressiveRenderer::Render() { m_threadPool->SetJobs(this, m_scene->w, m_scene->h); - // Starts render loop + std::chrono::high_resolution_clock::time_point frameStartTime = std::chrono::high_resolution_clock::now(); + std::chrono::high_resolution_clock::time_point frameEndTime; + Ready = true; m_threadPool->Ready = true; while (m_interface->Active) { if (m_threadPool->CheckAllJobs()) { - m_threadPool->MappedThreadFrameBuffer->ClampBasic(m_threadPool->ThreadFrameBuffer); + m_engine->PostProcess(m_threadPool->MappedThreadFrameBuffer->RenderTo, m_threadPool->MappedThreadFrameBuffer->ProcData, m_scene->w, m_scene->h); + + if (m_engine->Mode != MODE_RENDER_NORMALS) { + if (m_toneMapModeSelected == 0) m_threadPool->MappedThreadFrameBuffer->ClampBasic(m_threadPool->ThreadFrameBuffer); + + if (m_toneMapModeSelected == 1) m_threadPool->MappedThreadFrameBuffer->MapBasic(m_threadPool->ThreadFrameBuffer); + } else { + m_threadPool->MappedThreadFrameBuffer->ClampBasic(m_threadPool->ThreadFrameBuffer); + } + m_threadPool->MergeBuffers(m_interface->Framebuffer->Data, m_scene->w, m_scene->h); m_threadPool->RunJobsAgain(); + + frameEndTime = std::chrono::high_resolution_clock::now(); + m_calculateTimes(frameStartTime, frameEndTime); + frameStartTime = std::chrono::high_resolution_clock::now(); } Input(); @@ -69,6 +118,17 @@ void ProgressiveRenderer::Render() { m_threadPool->Destroy(); } -void ProgressiveRenderer::RenderProgressive() { +void ProgressiveRenderer::m_calculateTimes(std::chrono::high_resolution_clock::time_point frameStartTime, + std::chrono::high_resolution_clock::time_point frameEndTime) { + m_framesRendererd++; + + float frameTime = std::chrono::duration_cast(frameEndTime - frameStartTime).count(); + frameTime /= 1000; + + FrameTimes.push_back(frameTime); + AllFrameTimes.push_back(frameTime); + if (FrameTimes.size() > 11) FrameTimes.erase(FrameTimes.begin()); + + AverageFrameTime = std::accumulate(AllFrameTimes.begin(), AllFrameTimes.end(), 0.0) / AllFrameTimes.size(); } diff --git a/src/engine/progressiverenderer.hpp b/src/engine/progressiverenderer.hpp index d9c516a..9f23f50 100644 --- a/src/engine/progressiverenderer.hpp +++ b/src/engine/progressiverenderer.hpp @@ -4,9 +4,7 @@ #include "../common.hpp" #include "../maths.hpp" -#include #include -#include #include #include @@ -24,9 +22,11 @@ public: void Input(); void Render(); - void RenderProgressive(); bool Ready = false; + std::vector FrameTimes = { }; + std::vector AllFrameTimes = { }; + float AverageFrameTime = 0.0f; public: RenderThreadPool* m_threadPool = nullptr; @@ -37,7 +37,13 @@ public: private: std::mutex m_mutex; - bool m_normals = true; + void m_calculateTimes(std::chrono::high_resolution_clock::time_point frameStartTime, + std::chrono::high_resolution_clock::time_point frameEndTime); + + int m_renderModeSelected = 0; + int m_toneMapModeSelected = 1; + + int m_framesRendererd = 0; }; #endif diff --git a/src/engine/renderengine.cpp b/src/engine/renderengine.cpp index 0d62e2e..8ae5916 100644 --- a/src/engine/renderengine.cpp +++ b/src/engine/renderengine.cpp @@ -1,5 +1,7 @@ #include "renderengine.hpp" +#include + #include "../pixel.hpp" #include "../util/threadpool.hpp" @@ -10,11 +12,17 @@ #include "../display/displayinterface.hpp" #include "../display/framebuffer.hpp" -#include "../display/tonemap.hpp" +#include "../display/tonemapfb.hpp" #include "../engine/renderengine.hpp" #include "../engine/progressiverenderer.hpp" +static glm::vec3 Black{ 0.0f, 0.0f, 0.0f }; +static glm::vec3 White{ 1.0f, 1.0f, 1.0f }; +static glm::vec3 Red { 1.0f, 0.2f, 0.2f }; +static glm::vec3 Green{ 0.2f, 1.0f, 0.2f }; +static glm::vec3 Blue { 0.2f, 0.2f, 1.0f }; + void workerThread(RenderThreadPool* threadpool, ProgressiveRenderer* renderer, int idd, int yStart, int yRange) { while (!renderer->Ready && !threadpool->Ready) { std::chrono::milliseconds dura(10); @@ -27,12 +35,21 @@ void workerThread(RenderThreadPool* threadpool, ProgressiveRenderer* renderer, i for (int x = 0; x < renderer->m_scene->w; x++) { Ray ray = renderer->m_scene->camera->CastRay(x, y); glm::vec3 col = renderer->m_engine->GetColour(ray, 0); - threadpool->MappedThreadFrameBuffer->SetPixelSafe(x, y, col); + + if (renderer->m_engine->Mode == MODE_RENDER_NORMALS) { + threadpool->MappedThreadFrameBuffer->SetPixelSafe(x, y, col); + } else { + // threadpool->MappedThreadFrameBuffer->SetPixelSafe(x, y, col); + threadpool->MappedThreadFrameBuffer->AddPixelSafe(x, y, col); + } } threadpool->ThreadStatus[idd] = true; - while (threadpool->ThreadStatus[idd]) { } + while (threadpool->ThreadStatus[idd]) { + std::chrono::nanoseconds dura(1); + std::this_thread::sleep_for(dura); + } } } @@ -44,22 +61,91 @@ void RenderEngine::SetScene(Scene* scene) { m_scene = scene; } +std::default_random_engine generator; +// std::uniform_real_distribution distribution(-1,1); +// (float)rand() / float(RAND_MAX)*2.0f - 1.0f; + +float rand01() { + std::uniform_real_distribution distribution(0, 1); + return distribution(generator); +} + +glm::vec3 CosineBRDF(glm::vec3 normal) { + const float TWO_PI = 2.0f * PI; + + float r0 = rand01(); + float r1 = rand01(); + + glm::vec3 uu = glm::normalize(glm::cross(normal, { 0.0f, 1.0f, 1.0f })); + glm::vec3 vv = glm::cross(uu, normal); + + float ra = sqrtf(r1); + + float rx = ra * cosf(TWO_PI * r0); + float ry = ra * sinf(TWO_PI * r0); + + float rz = sqrtf(1.0f - r1); + + return glm::normalize(rx * uu + ry * vv + rz * normal); +} + glm::vec3 RenderEngine::GetColour(Ray ray, int depth) { + if (depth > 6) return { 0.0f, 0.0f, 0.0f }; float t; Primative* hit = nullptr; bool didhit = TraceRayScene(ray, m_scene, t, hit); - if (!didhit) { - return m_scene->SampleSky(ray); - } + if (!didhit) return m_scene->SampleSky(ray); glm::vec3 hitPoint = ray.origin + ray.direction * t; - - if (Mode == MODE_RENDER_NORMALS) return GetNormalColour(hit, hitPoint); - - return { 1.0f, 1.0f, 1.0f }; -} - -glm::vec3 RenderEngine::GetNormalColour(Primative* hit, glm::vec3 hitPoint) { glm::vec3 normal = hit->SurfaceNormal(hitPoint); - return { ((normal.x + 1.0f) * 127.5f) / 255.0f, ((normal.y + 1.0f) * 127.5f) / 255.0f, ((normal.z + 1.0f) * 127.5f) / 255.0f }; + if (Mode == MODE_RENDER_NORMALS) { return GetNormalColour(normal); } + + std::uniform_real_distribution distribution(0, 2); + int col = round(distribution(generator)); + + glm::vec3 colour = { 1.0f, 1.0f, 1.0f }; + if (hit->type == TYPE_PLANE) { + glm::vec2 uv = hit->TexCoords(hitPoint); + float angle = fastDegreetoRadian(.0f); + float s = uv.x * cos(angle) - uv.y * sin(angle); + float t = uv.y * cos(angle) + uv.x * sin(angle); + float S = 0.05f; float T = 0.05f; + float pattern = (modulo(s * S) < 0.5f) ^ (modulo(t * T) < 0.5f); + colour.r = pattern; colour.g = pattern; colour.b = pattern; + } + + glm::vec3 direction = CosineBRDF(normal); + + Ray newRay{ hitPoint, direction }; + + // Prevent acne + if (glm::dot(newRay.direction, normal) < 0.0f) { + newRay.origin = ray.origin + ray.direction * t - normal * EPSILON; + } + else { + newRay.origin = ray.origin + ray.direction * t + normal * EPSILON; + } + + return GetColour(newRay, depth + 1) * colour; +} + +void RenderEngine::PostProcess(glm::vec3* src, glm::vec3* dst, int w, int h) { + if (Mode == MODE_RENDER_NORMALS) { + for (int y = 0; y < h; y++) + for (int x = 0; x < w; x++) { + dst[y * w + x] = src[y * w + x]; + } + SPP = 0; + return; + } + + SPP++; + for (int y = 0; y < h; y++) + for (int x = 0; x < w; x++) { + dst[y * w + x] = src[y * w + x] / (float)SPP; + } +} + +glm::vec3 RenderEngine::GetNormalColour(glm::vec3 normal) { + return ((normal + 1.0f) * 127.5f) / 255.0f; } diff --git a/src/engine/renderengine.hpp b/src/engine/renderengine.hpp index 73c4b7f..abb299f 100644 --- a/src/engine/renderengine.hpp +++ b/src/engine/renderengine.hpp @@ -15,10 +15,14 @@ public: void SetScene(Scene* scene); glm::vec3 GetColour(Ray ray, int depth); - RenderMode Mode = MODE_RENDER_NORMALS; + void PostProcess(glm::vec3* src, glm::vec3* dst, int w, int h); + + RenderMode Mode = MODE_RENDER_PATHTRACE; + + int SPP = 0; private: - glm::vec3 GetNormalColour(Primative* hit, glm::vec3 hitPoint); + glm::vec3 GetNormalColour(glm::vec3 normal); Scene* m_scene = nullptr; }; diff --git a/src/util/threadpool.cpp b/src/util/threadpool.cpp index 54b0d0e..3b230d9 100644 --- a/src/util/threadpool.cpp +++ b/src/util/threadpool.cpp @@ -6,7 +6,7 @@ #include "../display/displayinterface.hpp" #include "../display/framebuffer.hpp" -#include "../display/tonemap.hpp" +#include "../display/tonemapfb.hpp" #include "../engine/renderengine.hpp" #include "../engine/progressiverenderer.hpp" @@ -18,7 +18,7 @@ RenderThreadPool::RenderThreadPool() { }; void RenderThreadPool::SetJobs(ProgressiveRenderer* renderer, int w, int h) { - MappedThreadFrameBuffer = new MapBuffer(w, h); + MappedThreadFrameBuffer = new ToneMapFrameBuffer(w, h); ThreadFrameBuffer = new FrameBuffer(w, h); for (int i = 0; i < ThreadCount; i++) { if (i == ThreadCount - 1) { @@ -26,15 +26,15 @@ void RenderThreadPool::SetJobs(ProgressiveRenderer* renderer, int w, int h) { (w / ThreadCount) * i, -((w / ThreadCount) * i - w) )); - RenderRegions.push_back({ ((w / ThreadCount) * i) * w, - (-((w / ThreadCount) * i - w)) * w }); + //RenderRegions.push_back({ ((w / ThreadCount) * i) * w, + // (-((w / ThreadCount) * i - w)) * w }); } else { Pool.push_back(new std::thread(workerThread, this, renderer, i, (h / ThreadCount) * i, (h / ThreadCount) * (i + 1) - (h / ThreadCount) * i )); - RenderRegions.push_back({ ((h / ThreadCount) * i) * w, - ((h / ThreadCount) * (i + 1) - (h / ThreadCount) * i) * w }); + //RenderRegions.push_back({ ((h / ThreadCount) * i) * w, + // ((h / ThreadCount) * (i + 1) - (h / ThreadCount) * i) * w }); } } } diff --git a/src/util/threadpool.hpp b/src/util/threadpool.hpp index 76646fb..8bd62c6 100644 --- a/src/util/threadpool.hpp +++ b/src/util/threadpool.hpp @@ -7,8 +7,8 @@ #include class ProgressiveRenderer; +class ToneMapFrameBuffer; class FrameBuffer; -class MapBuffer; class ThreadPool { public: @@ -31,8 +31,8 @@ public: void MergeBuffers(uint32_t* framebuffer, int w, int h); - std::vector> RenderRegions; // offest, size - MapBuffer* MappedThreadFrameBuffer; + // std::vector> RenderRegions; // offest, size + ToneMapFrameBuffer* MappedThreadFrameBuffer; FrameBuffer* ThreadFrameBuffer; }; diff --git a/test/main.cpp b/test/main.cpp index 8cc7da2..91c5d34 100644 --- a/test/main.cpp +++ b/test/main.cpp @@ -1,4 +1,5 @@ #include + #include "../src/inferno.hpp" static const int width = 600; @@ -17,21 +18,25 @@ int main(int argc, char** argv) { Scene* scene = new Scene(width, height); scene->camera = new Camera(width, height); - // scene->objects.push_back(new Sphere({0.0f, 0.0f, -4.0f}, 1.0f)); + //scene->objects.push_back(new Sphere({ 0.0f, 0.0f, -8.0f }, 1.0f)); + //scene->objects.push_back(new Sphere({ 2.0f, 0.0f, -8.0f }, 1.0f)); + //scene->objects.push_back(new Sphere({ -2.0f, 0.0f, -8.0f }, 1.0f)); + //scene->objects.push_back(new Plane( { 0.0f, -25.0f, 0.0f }, { 0.0f, -1.0f, 1.0f })); - // std::vector tris = LoadTrianglesBasic("/home/ben/programming/inferno/resources/dragon-normals.obj"); - // for (const auto& object : tris) - // object->Translate({ 0.0f, -5.0f, -20.0f }); + // std::vector tris = LoadTrianglesBasic("/home/ben/programming/inferno/resources/dragon-normals.obj"); + //std::vector tris = LoadTrianglesBasic("E:/Projects/Inferno/resources/dragon-normals.obj"); + //for (const auto& object : tris) + // object->Translate({ 0.0f, -5.0f, -20.0f }); // std::vector tris = LoadTrianglesBasic("/home/ben/programming/inferno/resources/lucy-normals.obj"); - // std::vector tris = LoadTrianglesBasic("E:/Projects/Inferno/resources/lucy-normals.obj"); - // for (const auto& object : tris) - // object->Translate({ 0.0f, -3.9f, -10.6f }); + std::vector tris = LoadTrianglesBasic("E:/Projects/Inferno/resources/lucy-normals.obj"); + for (const auto& object : tris) + object->Translate({ 0.0f, -3.9f, -10.6f }); //std::vector tris = LoadTrianglesBasic("/home/ben/programming/inferno/resources/cornell.obj"); - std::vector tris = LoadTrianglesBasic("E:/Projects/Inferno/resources/cornell.obj"); - for (const auto& object : tris) - object->Translate({ 0.0f, -0.9f, -3.0f }); + //std::vector tris = LoadTrianglesBasic("E:/Projects/Inferno/resources/cornell.obj"); + //for (const auto& object : tris) + // object->Translate({ 0.0f, -0.9f, -3.0f }); Mesh* mesh = new Mesh(tris); mesh->Optimise();