emrainey / hobbies Goto Github PK

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

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

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

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.

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

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

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

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

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.

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

Some surfaces can emit light. Determine if this is the best place to do that or not.

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

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

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

Use UnitsOfMeasure!

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

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.

@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> ?

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 ?)

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

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

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

Filter should:

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

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

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".

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 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);
}

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.

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

Add those IDE hints into the CMakeLists.txt

(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?

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

Read the section on Lambertian surfaces.

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

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

• Paraboliod
• Eliptical Cone
• Eliptical Hyperboloid

Determine which mapping is the best for these surfaces too.

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

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.

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

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

Check for collisions with objects which have transparency > 0.

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

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

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

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).

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

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

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.