ray-tracer | A photo-realistic 3D rendering engine | Graphics library

Your vectors store the BvhNodes everywhere by value. This means that every time you push_back a node, its copy constructor is called, which in turn copies the children vector member inside the node, which copies its own elements etc. This basically results in complete subtrees being copied/freed every time you insert or erase a node.

This in turn can result in memory fragmentation, which can eventually cause a vector reallocation to fail and cause a segfault.

Without the full code, I can recommend these 2 things:

1. Store the children as (smart) pointers instead of by value

2. Create a custom allocator for the vectors to enable a more fine-grained debugging, and check for allocation failures

One way to lay out binary tree nodes in an array is: for all nodes in the tree, if a given node has array index i, its children are at indices 2i + 1 and 2i + 2 (described more fully here).

Assuming you have a complete tree, you can write your tree to an array with a simple breadth-first traversal:

In pseudo-code:

This question reduces to:

How can I pick a uniformly-distributed random point on a disk?

A naive approach would be to generate random polar coordinates and transform them to cartesian coordinates:

1. Randomly generate an angle θ between 0 and 2π
2. Randomly generate a distance d between 0 and radius r of your disk
3. Transform to cartesian coordinates with x = r cos θ and y = r sin θ

This is incorrect because it causes the points to bunch up in the center; for example:

A correct, but inefficient, way to do this is via rejection sampling:

1. Uniformly generate random x and y, each over [0, 1]
2. If sqrt(x^2 + y^2) < 1, return the point
3. Goto 1

The correct way to do this is illustrated here:

1. Randomly generate an angle θ between 0 and 2π
2. Randomly generate a distance d between 0 and radius r of your disk
3. Transform to cartesian coordinates with x = sqrt(r) cos θ and y = sqrt(r) sin θ

I am trying to implement a simple OpenGL renderer that simulates a pinhole camera model.

A standard perspective projection matrix already implements a pinhole camera model. What you're doing here is just having more calculations per vertex, which could all be pre-calculated on the CPU and put in a single matrix.

The only difference is the z range. But a "pinhole camera" does not have a z range, all points are projected to the image plane. So what you want here is a pinhole camera model for x and y, and a linear mapping for z.

However, your implementation is wrong. A GPU will interpolate the z linearly in window space. That means, it will calculate the barycentric coordinates of each fragment with respect to the 2D projection of the triangle of the window. However, when using a perspective projection, and when the triangle is not excatly parallel to the image plane, those barycentric coordinates will not be those the respective 3D point would have had with respect to the actual 3D primitive before the projection.

The trick here is that since in screen space, we typically have x/z and y/z as the vertex coordinates, and when we interpolate linaerily inbetween that, we also have to interpolate 1/z for the depth. However, in reality, we don't divide by z, but w (and let the projection matrix set w_clip = [+/-]z_eye for us). After the division by w_clip, we get a hyperbolic mapping of the z value, but with the nice property that it can be linearly interpolated in window space.

What this means is that by your use of a linear z mapping, your primitives now would have to be bend along the z dimension to get the correct result. Look at the following top-down view of the situation. The "lines" represent flat triangles, looked from straight above:

In eye space, the view rays would all go from the origin through each pixel (we could imagine the 2D pixel raster on the near plane, for example). In NDC, we have transformed this to an orthograhic projection. The pixels still can be imagined at the near plane, but all view rays now are parallel.

In the standard hyperbolical mapping, the point in the middle of the frustum is compressed much towards the end. However, the traingle still is flat.

If you use a linear mapping instead, your triangle would have not to be flat any more. Look for example at the intersection point between the two traingles. It must have the same x (and y) coordinate as in the hyperbolic case, for the correct result.

However, you only transform the vertices according to a linear z value, the GPU will still linearly interpolate the result, so in your case, you would get straight connections between your transformed points, your intersection point between the two triangles is moved, and your depth values are all wrong except for the actual vertex points itself.

If you want to use a linear depth buffer, you have to correct the depth of each fragment in the fragment shader, to implement the required non-linear interpolation on your own. Doing so would break a lot of the clever depth test optimizations GPUs do, notably early Z and hierachical Z, so while it is possible, you'l loose some performance.

The much better solution is: Just use a standard hyperbolic depth value. Just linearize the depth values after you read them back. Also, don't do the z Division in the vertex shader. You do not only break z this way, you also break the perspective-corrected interpolation of the varyings, so your shading will also be wrong. Let the GPU do the division, just shuffle the correct value into gl_Position.w. The GPU will internally not only do the divide, the perspective corrected interpolation also depends on w.

In the example, the compiler tells you why x has been invalidated by the move:

Seems you need a lock while using std::cout , otherwise the async tasks will make a mess output( they all try to print on the console at same time). However I recommend you using GDIplus ( seems you are using in your code) to print the text instead of showing on a console window which is rather ugly.

This is one of the many issues with mutable value types and why they should be avoided althogether.

In your first scenario: