Dynamitos/RayTracer
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

marking it much faster

Browse Source
This commit is contained in:
Dynamitos
2025-01-25 18:05:47 +01:00
parent 86b6d678f6
commit 463e3d925e
18 changed files with 287 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/scene/AABB.h
+1 -1
View File
@@ -44,7 +44,7 @@ struct AABB
max = glm::vec3(std::max(max.x, transformed.x), std::max(max.y, transformed.y), std::max(max.z, transformed.z));
}
}
bool intersects(Ray ray, float tmin, float tmax)
bool intersects(Ray ray, float tmin, float tmax) const
{
glm::vec3 invD = 1.0f / ray.direction;
glm::vec3 t0s = glm::vec3(min - ray.origin) * invD;
src/scene/BVH.cpp
+79 -87
View File
@@ -4,110 +4,102 @@
void BVH::addModel(PModel model, glm::mat4 transform)
{
model->boundingBox.transform(transform);
for (auto& point : model->positions)
{
point = glm::vec3(transform * glm::vec4(point, 1));
}
models.push_back(std::move(model));
model->transform(transform);
models.push_back(std::move(model));
}
void BVH::addModels(std::vector<PModel> _models, glm::mat4 transform)
{
for (auto & _model : _models)
{
_model->boundingBox.transform(transform);
for (auto& point : _model->positions)
{
point = glm::vec3(transform * glm::vec4(point, 1));
}
models.push_back(std::move(_model));
}
for (auto& _model : _models)
{
_model->transform(transform);
models.push_back(std::move(_model));
}
}
void BVH::generate()
{
std::vector<PNode> pendingNodes;
while (!models.empty())
std::vector<PNode> pendingNodes;
while (!models.empty())
{
pendingNodes.push_back(std::make_unique<Node>(std::move(models.back())));
models.pop_back();
}
while (pendingNodes.size() > 1)
{
int lhs = pendingNodes.size();
int rhs = pendingNodes.size();
float minSurface = std::numeric_limits<float>::max();
for (int i = 0; i < pendingNodes.size(); ++i)
{
pendingNodes.push_back(std::make_unique<Node>(std::move(models.back())));
models.pop_back();
}
while (pendingNodes.size() > 1)
{
int lhs = pendingNodes.size();
int rhs = pendingNodes.size();
float minSurface = std::numeric_limits<float>::max();
for (int i = 0; i < pendingNodes.size(); ++i)
for (int j = 0; j < pendingNodes.size(); ++j)
{
if (i == j)
continue;
AABB combined = AABB::combine(pendingNodes[i]->aabb, pendingNodes[j]->aabb);
float surface = combined.surfaceArea();
if (minSurface > surface)
{
for (int j = 0; j < pendingNodes.size(); ++j)
{
if (i == j)
continue;
AABB combined = AABB::combine(pendingNodes[i]->aabb, pendingNodes[j]->aabb);
float surface = combined.surfaceArea();
if (minSurface > surface)
{
lhs = i;
rhs = j;
minSurface = surface;
}
}
lhs = i;
rhs = j;
minSurface = surface;
}
PNode newNode = std::make_unique<Node>(AABB::combine(pendingNodes[lhs]->aabb, pendingNodes[rhs]->aabb));
newNode->left = std::move(pendingNodes[lhs]);
newNode->right = std::move(pendingNodes[rhs]);
pendingNodes.erase(pendingNodes.begin() + lhs);
pendingNodes.erase(pendingNodes.begin() + rhs);
pendingNodes.push_back(std::move(newNode));
}
}
hierarchy = std::move(pendingNodes[0]);
PNode newNode = std::make_unique<Node>(AABB::combine(pendingNodes[lhs]->aabb, pendingNodes[rhs]->aabb));
newNode->left = std::move(pendingNodes[lhs]);
newNode->right = std::move(pendingNodes[rhs]);
pendingNodes.erase(pendingNodes.begin() + lhs);
pendingNodes.erase(pendingNodes.begin() + rhs);
pendingNodes.push_back(std::move(newNode));
}
hierarchy = std::move(pendingNodes[0]);
}
std::optional<IntersectionInfo> BVH::traceRay(Ray ray)
std::optional<IntersectionInfo> BVH::traceRay(Ray ray) const
{
auto results = generateIntersections(hierarchy, ray);
float closestT = std::numeric_limits<float>::max();
IntersectionInfo info;
for (uint32_t i = 0; i < results.size(); ++i)
auto results = generateIntersections(hierarchy, ray);
float closestT = std::numeric_limits<float>::max();
IntersectionInfo info;
for (uint32_t i = 0; i < results.size(); ++i)
{
if (results[i].t < closestT)
{
if (results[i].t < closestT)
{
closestT = results[i].t;
info = results[i];
}
}
if (closestT < std::numeric_limits<float>::max())
{
return info;
closestT = results[i].t;
info = results[i];
}
}
if (closestT < std::numeric_limits<float>::max())
{
return info;
}
return {};
}
std::vector<IntersectionInfo> BVH::generateIntersections(const PNode& currentNode, Ray ray) const
{
if (!currentNode->aabb.intersects(ray, 0, std::numeric_limits<float>::max()))
{
return {};
}
}
if (currentNode->model != nullptr)
{
auto result = currentNode->model->intersect(ray);
if (result.has_value())
{
return {*result};
}
else
{
return {};
}
}
auto leftResults = generateIntersections(currentNode->left, ray);
auto rightResults = generateIntersections(currentNode->right, ray);
std::vector<IntersectionInfo> BVH::generateIntersections(PNode& currentNode, Ray ray)
{
if (!currentNode->aabb.intersects(ray, 0, std::numeric_limits<float>::max()))
{
return {};
}
if (currentNode->model != nullptr)
{
auto result = currentNode->model->intersect(ray);
if (result.has_value())
{
return {*result};
}
else
{
return {};
}
}
auto leftResults = generateIntersections(currentNode->left, ray);
auto rightResults = generateIntersections(currentNode->right, ray);
for (auto& it : rightResults)
{
leftResults.push_back(std::move(it));
}
return leftResults;
for (auto& it : rightResults)
{
leftResults.push_back(std::move(it));
}
return leftResults;
}
src/scene/BVH.h
+21 -22
View File
@@ -1,34 +1,33 @@
#pragma once
#include "AABB.h"
#include "util/Model.h"
#include <vector>
#include <glm/glm.hpp>
#include "util/Ray.h"
#include <glm/glm.hpp>
#include <optional>
#include <vector>
class BVH
{
public:
void addModel(PModel model, glm::mat4 transform);
void addModels(std::vector<PModel> models, glm::mat4 transform);
void generate();
public:
void addModel(PModel model, glm::mat4 transform);
void addModels(std::vector<PModel> models, glm::mat4 transform);
void generate();
std::optional<IntersectionInfo> traceRay(Ray ray);
std::optional<IntersectionInfo> traceRay(Ray ray) const;
private:
DECLARE_REF(Node)
struct Node
{
PNode left;
PNode right;
AABB aabb;
PModel model;
Node(AABB aabb) : aabb(aabb) {}
Node(PModel model) : aabb(model->boundingBox), model(std::move(model)) {}
};
PNode hierarchy;
std::vector<PModel> models;
private:
DECLARE_REF(Node)
struct Node
{
PNode left;
PNode right;
AABB aabb;
PModel model;
Node(AABB aabb) : aabb(aabb) {}
Node(PModel model) : aabb(model->boundingBox), model(std::move(model)) {}
};
PNode hierarchy;
std::vector<PModel> models;
std::vector<IntersectionInfo> generateIntersections(PNode& currentNode, Ray ray);
std::vector<IntersectionInfo> generateIntersections(const PNode& currentNode, Ray ray) const;
};
src/scene/Scene.cpp
+13 -17
View File
@@ -17,13 +17,7 @@ Scene::~Scene() {}
static bool firstTime = true;
void Scene::startRender(Camera cam, RenderParameter params)
{
if (!firstTime)
{
pendingCancel = true;
worker.join();
firstTime = false;
}
pendingCancel = false;
threadPool.cancel();
image.clear();
accumulator.clear();
image.resize(params.width * params.height);
@@ -31,22 +25,23 @@ void Scene::startRender(Camera cam, RenderParameter params)
worker = std::thread(&Scene::render, this, cam, params);
}
glm::vec3 rand01(glm::uvec3 x)
{ // pseudo-random number generator
for (int i = 3; i-- > 0;)
x = ((x >> 8U) ^ glm::uvec3(x.y, x.z, x.x)) * 1103515245U;
return glm::vec3(x) * (1.0f / float(0xffffffffU));
}
void Scene::render(Camera camera, RenderParameter params)
{
std::random_device rd;
for (int samp = 0; samp < params.numSamples; ++samp)
{
if (pendingCancel)
return;
Batch batch;
for (int w = 0; w < params.width; ++w)
{
batch.jobs.push_back(
[&](int w) -> Task
[&](int w, int samp) -> Task
{
std::mt19937 gen(rd());
std::uniform_real_distribution<float> rnd01(0.0, 1.0);
std::uniform_real_distribution<float> rnd02(0.0, 2.0);
for (int h = 0; h < params.height; ++h)
{
Ray cam = Ray(camera.position, glm::normalize(camera.direction));
@@ -59,7 +54,8 @@ void Scene::render(Camera camera, RenderParameter params)
//-- sample sensor
glm::uvec2 pix = glm::uvec2(w, h);
glm::vec2 rnd2 = glm::vec2(rnd02(gen), rnd02(gen)); // vvv tent filter sample
glm::vec3 rnd1 = rand01(glm::uvec3(pix, samp));
glm::vec2 rnd2 = 2.0f * glm::vec2(rnd1); // vvv tent filter sample
glm::vec2 tent =
glm::vec2(rnd2.x < 1 ? sqrt(rnd2.x) - 1 : 1 - sqrt(2 - rnd2.x), rnd2.y < 1 ? sqrt(rnd2.y) - 1 : 1 - sqrt(2 - rnd2.y));
glm::vec2 s =
@@ -76,7 +72,7 @@ void Scene::render(Camera camera, RenderParameter params)
glm::vec3 lensX = glm::cross(lensN, glm::vec3(0, 1, 0)); // the exact vector doesnt matter
glm::vec3 lensY = glm::cross(lensN, lensX);
glm::vec3 lensSample = lensP + rnd01(gen) * camera.A * lensX + rnd01(gen) * camera.A * lensY;
glm::vec3 lensSample = lensP + rnd1.x * camera.A * lensX + rnd1.y * camera.A * lensY;
glm::vec3 focalPoint = cam.origin + (camera.S_O + S_I) * cam.direction;
float t = glm::dot(focalPoint - r.origin, lensN) / glm::dot(r.direction, lensN);
@@ -91,7 +87,7 @@ void Scene::render(Camera camera, RenderParameter params)
}
}
co_return;
}(w));
}(w, samp));
}
auto start = std::chrono::high_resolution_clock::now();
threadPool.runBatch(std::move(batch));
src/scene/Scene.h
+15 -1
View File
@@ -11,6 +11,19 @@ struct RenderParameter
int numSamples;
};
struct PointLight
{
glm::vec3 position;
glm::vec3 color;
float attenuation;
};
struct DirectionalLight
{
glm::vec3 direction;
glm::vec3 color;
};
class Scene
{
public:
@@ -20,12 +33,13 @@ class Scene
constexpr const std::vector<glm::vec3>& getImage() const { return image; }
private:
virtual void render(Camera cam, RenderParameter params);
std::atomic_bool pendingCancel = false;
ThreadPool threadPool;
std::thread worker;
// the thing being displayed
std::vector<glm::vec3> image;
// radiance accumulator
std::vector<glm::vec3> accumulator;
std::vector<PointLight> pointLights;
std::vector<DirectionalLight> directionalLights;
BVH bvh;
};