emrainey / hobbies Goto Github PK

(N triangles or does the triangle cross trick work for more than 3 points (as long as it is convex and coplanar?)

Makes any closed polygon shape?

Start the camera at the initialized position, but able to move it in a spherical way around the look_at point and re-render.

Given a ray (normal + center), x unit reference in plane and any other point within the plane, return the polar coordinates of that point.

Need some good ground truth data and then we can test the implementation.

This would speed up collision detect and possible eliminate some checks all together.

After implementing function, make a interesting surface tester to vary the parameters and then figure out how to make a raytrace:: medium with it.

• Paraboliod
• Eliptical Cone
• Eliptical Hyperboloid

Determine which mapping is the best for these surfaces too.

Negative refractive index somewhat solves but this is notionally wrong. Look into the math to make sure the transmitted angle is correct (from the normal).

Check for collisions with objects which have transparency > 0.

They are there by convenience now but ultimately don't belong there. The internal mask object can stay but the calls don't need to.

I can't remember where but I needed this function for something and then later could not figure out how light would actually do this. I think it's perhaps a subsitute for a dot product for colors.

This would simplify some of the math (maybe?) but would impact the texture mapping as that would have to re-scale.

The overlap for some objects may do well enough but there's some area of improvement where the bound objects report in object space as non-origin objects so that mediums & surfaces assign then the right surface qualities.

Add a way for overlaps to properly return a normal from only one sub object. If an object should not return a normal at a point it should return R3::null. Some objects like cones or cylinders have normal generators which don't check if a point is on the "surface".

Not sure if it's working correctly or not, but the unit tests for QuadraticSaddle is producing weird results. Try removing the plane and just see what's left & fix if needed. May find out saddles aren't possible.

If reasonable, implement elementary test for linalg::matrix.

It's missing quite a bit compared to other measurements.

Add those IDE hints into the CMakeLists.txt

Would like to see added:

• Total New Sample Rays
• Total Eye Rays (original + anti-aliasing)
• Total Shadow Rays
• Average Recursion Depth per pixel?
• Start Time Rendering
• Elapsed Time Rendering
• Number of Objects in Scene
• Number of Lights in Scene

• operator==
• operator!=
• operator- (negation)
• operator/(const xmat_&);
• inverse() ?

See http://www.paulbourke.net/dataformats/tga/

Read the section on Lambertian surfaces.

https://raytracing.github.io/books/RayTracingInOneWeekend.html

Potentially leaving it with xmmt but also have a using in raytrace with names it back to color.

I already have this function in transparent mediums:

element_type absorbance(element_type distance) const;

which is implemented as

element_type transparent::absorbance(element_type distance) const {
    return std::exp(-distance * m_fade);
}

Use UnitsOfMeasure!

It looks like a odd tartan pattern now, it's supposed to be something else entirely.

implement diffraction (a special case of which is refraction and reflection). This may come as a special case of a BDSF.

basal::module("steel");

Should be all that's needed. When compiled for Mac/Linux/Windows it will use standard nomenclature.

DARWIN => lib{}.dylib
LINUX => lib{}.so
WINDOWS => {}.dll

@see https://64.github.io/tonemapping/#uncharted-2

This would seem to require that the raytrace::image is actually a fourcc::image<color, pixel_format::SRGB> ?

Filter should:

• Gamma correct properly
• Be fairly simple
• Be inside the raytrace::image but use functions in fourcc where needed.

Finish an implementation if it's reasonable, even if utterly slow.

Using this method, we can implement ocean or weird ground with hills using perlin noise

In order to be used in overlaps the math within a cylinder must be able to return normals correctly and return infinite lengths.

Cuboids can occasionally return single intersections if the ray passes exactly through the sharp edge of a corner. I suppose it could miss entirely if it went through two edges.

Pass the current scale level to each recursive trace as a magnitude. When that constituent level is below a threshold, return and do not recurse anymore. This would replace a fixed number of reflective/transmitted ray-casts.

Some surfaces can emit light. This should be a property of the surface itself and potentially of the object? When determining if a point is in shadow or not, also then (super complexity bump!) check to see if any light emitting surfaces are in view of the point. This requires shooting shadow rays at every object in the scene. It would help, as a shortcut, to have a global flag which indicates if there are any emitting objects, then we can skip the check if none were specified.

https://cmake.org/cmake/help/latest/variable/CMAKE_PROJECT_PROJECT-NAME_INCLUDE.html?highlight=cmake_project_%20include

Take patterns from images and produce encodings. This will allow more flexible input patterns.

It might be double/float issues in the gtest_sphere.cpp which is cause points on interior of a sphere pointing out to intersect with the sphere, which doesn't make sense. They should not. Did I implement double-sidedness?

Add a method to translate any point on a torus to a 2d point (2 angles). The first is the angle to the R3::basis::X in the XY plane. The second is the rotation around the donut (find through dot ?)

Today I only generate 2D, add a 3d function (which does more averaging and takes longer)

Update the conanfile.py in each project. DON'T BREAK THE CURRENT CMake BUILD!

Make a background mapper which can deterministically recreate a starfield given some R3::vector as input.

While it seems to be working, I need to test out more uses.

@see https://raytracing.github.io/books/RayTracingInOneWeekend.html

Find: "fuzzed" metals. These mediums would alter the object's normals or reflections via an offset?

Match up API and see if there's a way to swap out and use the __AVX2__ implementation.

Previously they where absolute, which was awful. Now they are completely relative, which isn't the best either. Use basal::options to implement an argument processor.