31:T7d9,

Python

Similar to Javascript, using threads from the [`multithreading`](https://docs.python.org/3/library/multiprocessing.html#module-multithreading) module does not actually distribute the work amongst cores as they are children of the main thread. To properly share work, the [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing) module must be used directly or through the [`concurrent.futures.ProcessPoolExecutor`](https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ProcessPoolExecutor) interface.

When executed as a script (the environment `name` is `__main__`), the `render` call starts the threads. Like Javascript and unlike C++, memory is not shared between processes, so we have to pass back the image changes from `trace_tile`:

${md`~~~python import os import concurrent.futures def trace_tiles(index, tile_size, scene): # Iterate over the slab of our tile return [trace(ray, scene) for ray in generate_ray_from_index(i) for i in range(index*tile_size, (index+1)*title_size)] def render(image): # Any initialization goes here # Get number of logical cores num_processes = os.process_cpu_count() # Get size of tile tile_size = len(image.pixels) / num_processes # Creeate the process manager and generate threads with concurrent.futures.ProcessPoolExecutor() as executor: threads = [executor.spawn(trace_tile, i, tile_size, scene) for i in range(num_processes)] status = concurrent.futures.wait(threads) # assign to slice for i, result in enumerate(status.done): image.pixels[i*tile_size:(i+1)*tile_size] = result return image ~~~`}

The only change to `trace` is to take the `scene` as an argument.

32:T428,## Non-Recursive Threaded By splitting each pixel's rays across parallel tiles, we have increased efficiency. However, not all tiles are created the same. One part of the image could be mostly empty, while another could be dense—the latter would recurse more and have more lighting calculations. As a consequence, some processes will finish (perhaps significantly) earlier than others. The threads become *incoherent*. To address this imbalance, we will remove recursion and instead use a pool of rays from which we pull. Initially, this pool consists of rays passing through all the pixels. The next wave of rays will be those for the next bounce and so on. We process waves until they are empty or a maximum depth is reached. By splitting active rays amongst the processors, our threads are *coherently* performing roughly the same amount of work. This approach is a *wavefront* approach. Since we are unrolling the recursion, we need to properly accumulate the color as we descend in depth. Note how the reflected components of the specular builds up:33:T722,

${md`~~~js async function trace_pool_slice(index, slice_size, pool, next_pool, image) { // Iterate over the rays in the pool for(const ray of pool.slice(index*slice_size, (index+1)*slice_size)) { next_ray = trace(ray) image[next_ray.pixel].add(next_ray.color) if(next_ray.alive) { next_pool[index] = next_ray } } // We do not return image as we modify the original } function render(image) { // Other initialization // Get number of logical cores const num_processes = window.navigator.hardwareConcurrency; // Populate initial pool let active_pool = image.pixels.map(generate_ray); // Number of iterations/depth let depth = 0; // Repeat until no longer active or too many iterations while(active_pool.length > 0 && depth < MAX_DEPTH) { // Next pool is full of empty rays let next_pool = [...Array(active_pool.length)]; // Get size of pool slice let pool_slice_size = active_pool.length / num_processes; // Generate a "thread" for each (really a microtask in JS) const threads = [...Array(num_processes)].map((x,i)=>trace_pool_slice(i, pool_slice_size, active_pool, next_pool, image)); // Wait for all threads to finish Promise.all(threads).then(); // Populate the next pool with active rays and repeat active_pool = next_pool.filter((x)=>x !== undefined); // Update depth depth += 1; } return image; } ~~~`}

34:T976,

Python

We again use [`concurrent.futures.ProcessPoolExecutor`](https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ProcessPoolExecutor) interface but split amongst the pool. Without recursion, this should be the most performant for Python.

${md`~~~python import os import concurrent.futures def trace_pool_slice(index, pool_slice, scene): # Iterate over the slab of our tile return [trace(ray, scene) for ray in pool_slice] def render(image): # Any initialization goes here # Get number of logical cores num_processes = os.process_cpu_count() # Get the active pool active_pool = [generate_ray(pixel) for pixel in image.pixels] # Number of iterations/depth depth = 0 # Creete the process manager and generate threads with concurrent.futures.ProcessPoolExecutor() as executor: while len(active_pool) > 0 and depth < MAX_DEPTH: # Get size of pool pool_size = len(active_pool) / num_processes # Spawn threads threads = [executor.spawn(trace_pool_slice, i, active_pool[i*pool_size:(i+1)*pool_size], scene) for i in range(num_processes)] status = concurrent.futures.wait(threads) # update colors and cull dead rays active_pool = [] for i, result in enumerate(status.done): image.pixels[i*pool_size:(i+1)*tile_size] = map(lambda x,y:x+y.color, image.pixels[i*pool_size:(i+1)*pool_size], result) active_pool.append([ray if ray.alive for ray in result]) depth += 1 return image ~~~`}

We update `trace` to be non-recursive.

${md`~~~python def trace(ray): color = color(0,0,0); intersection = intersect(ray) if intersection: color = direct_lighting(ray, intersection) next_ray = scatter(ray, intersection) next_ray.color += ray.coeff * color next_ray.coeff = ray.coeff * intersection.coeff next_ray.alive = true else: next_ray = ray next_ray.alive = false return ray ~~~`}

35:T5eb,cpp_base_thread = md` ~~~c++ #import #import #import #import // Requires C++20 void trace_tile(std::size_t index, std::size_t tile_size, image& image) { // Iterate over the slab of our tile for(auto pixel : std::span(image.pixels.begin() + index*tile_size, image.pixels.begin() + (index+1)*tile_size)) { auto ray = generate_ray(pixel); image[pixel] = trace(ray); } // We do not return image as we modify the original } void render(image& image) { // Other initialization // Get number of logical cores std::size_t num_processes = std::thread::hardware_concurrency(); // Get size of tile std::size_t tile_size = image.pixels().size() / num_processes; // We will save the std::future promises generated so that the thread // doesn't block when the std::future expires; they will block as one // when the std::vector goes out of scope similar to how Promise.all works std::vector> threads; // Generate the threads for(std::size_t i = 0; i < num_processes; i++) { // Note we capture the image and scene by reference explicitly in the lambda // to avoid a costly copy (and leaving the image unchanged) threads.emplace_back(std::async([=, &image, &scene]() { trace_tile(i, tile_size, image); })); } // When render terminates, it will block until the image is rendered due to // std::vector's destructor calling the std::futures' destructor that blocks } ~~~`36:T90a,cpp_base_iterate = md` ~~~c++ void trace_pool_slice(std::size_t index, std::size_t slice_size, std::vector pool, std::vector next_pool, image& image) { // Iterate over the slab of our tile for(auto ray : std::span(pool.pixels.begin() + index*slice_size, pool.pixels.begin() + (index+1)*slice_size)) { auto next_ray = trace(ray); image[next_ray.pixel] += next_ray.color; if(next_ray.alive) { next_pool[index] = next_ray; } } } void render(image& image) { // Other initialization // Get number of logical cores std::size_t num_processes = std::thread::hardware_concurrency(); // Active pool std::vector active_pool; std::transform(images.pixels.begin(), images.pixels.end(), std::back_inserter(active_pool), generate_ray); // Number of iterations/depth unsigned int depth = 0; while(active_pool.size() > 0 && depth < MAX_DEPTH) { // Get size of slice std::size_t slice_size = active_pool.size() / num_processes; // We will save the std::future promises generated so that the thread // doesn't block when the std::future expires; they will block as one // when the std::vector is emptied similar to how Promise.all works std::vector> threads; // Generate next slice std::vector next_pool = std::vector(active_pool.size); // Generate the threads for(std::size_t i = 0; i < num_processes; i++) { // Note we capture the image and scene by reference explicitly in the lambda // to avoid a costly copy (and leaving the image unchanged) threads.emplace_back(std::async([=, &image, &scene]() { trace_pool_slice(i, slice_size, active_pool, next_pool, image); })); } // Clear the thread vector to wait for the render threads.empty(); // Populate the next pool with active rays and repeat active_pool.empty(); active_pool.copy_if(next_pool.begin(), next_pool.end(), std::back_inserter(active_pool), [](ray& r){return r.alive}); // Update depth depth += 1; } } ~~~`37:[] 2f:{"title":"Implementing Ray Casting Methods","cells":[{"id":0,"value":"# Implementing Ray Casting Methods\n\nThe fundamental algorithm for ray casting methods (ray tracing and ray marching and later path tracing) have different approaches for implementation. The approaches decrease the runtime but increase the implementation effort. We review them here.","pinned":false,"hidden":false,"mode":"md"},{"id":43,"value":"

Not a fan of coffee?

The examples in this notebook are primarily in Javascript as this platform is web-based. The concepts are universal, they just require translation into the appropriate language. Examples in other languages will be added over time.

","pinned":false,"hidden":false,"mode":"md"},{"id":434,"value":"

Caution

The code provided below has not been fully tested but should provide guidance to get running versions. Please provide feedback via comments if you wish to suggest modifications.

","pinned":false,"hidden":false,"mode":"md"},{"id":392,"value":"toc({\n headers: \"h2,h3,h4\",\n title: null\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":6,"value":"## Review of Ray Casting\n\nRecall that ray casting is an approximation of a solution to the [rendering equation](https://observablehq.com/@cse4413msstate/lighting-shading-iv-light-transport?collection=@cse4413msstate/ray-tracing-notes)","pinned":false,"hidden":false,"mode":"md"},{"id":260,"value":"tex.block`\\begin{aligned}L_o\\left(\\mathrm{p}, \\omega_o\\right) &= L_e\\left(\\mathrm{p}, \\omega_o\\right) \n + \\int_{\\Omega} f_r(\\mathrm{p}, \\omega_o, \\omega_i) L_i\\left(\\mathrm p, \\omega_i\\right)\\left(\\mathrm{\\mathbf{n} \\cdot \\omega_i}\\right) d\\omega_i \\end{aligned}`","pinned":false,"hidden":false,"mode":"ojs"},{"id":265,"value":"For each ray, classic ray casting methods approximate the radiance as a sum of three factors: the emission, direct, and indirect radiance","pinned":false,"hidden":false,"mode":"md"},{"id":267,"value":"tex.block`\\begin{aligned}L_o\\left(\\mathrm{p}, \\omega_o\\right) &\\approx L_e + L_\\text{direct} + L_\\text{indirect}\\\\\nL_\\text{direct} &= \\sum_l^\\text{\\# lights}\\overbrace{f_r(\\mathrm{p}, \\omega_o, \\omega_{i_l}) L_i\\left(\\mathrm p, \\omega_{i_l}\\right)\\left(\\mathrm{\\mathbf{n} \\cdot \\omega_{i_l}}\\right)}^{\\text{diffuse}}\\\\ \nL_\\text{indirect} &= \\overbrace{\\overbrace{f_r(\\mathrm{p}, \\omega_o, \\omega_{r}) L_i\\left(\\mathrm p, \\omega_{r}\\right)\\left(\\mathrm{\\mathbf{n} \\cdot \\omega_{r}}\\right)}^{\\text{reflection}} + \\overbrace{f_r(\\mathrm{p}, \\omega_o, \\omega_{t}) L_i\\left(\\mathrm p, \\omega_{t}\\right)\\left(\\mathrm{\\mathbf{n} \\cdot \\omega_{t}}\\right)}^{\\text{transmission}}}^{\\text{specular}}\n\\end{aligned}`","pinned":false,"hidden":false,"mode":"ojs"},{"id":293,"value":"where ${tex`\\omega_{i_l}`} is the direction towards a light ${tex`l`}, ${tex`\\omega_r`} is the direction of the perfect reflection vector about the normal ${tex`\\mathbf{n}`}, and ${tex`\\omega_t`} is the appropriate transmission vector given the relative indices of refraction. \n\nThe key insight of ray-based methods is that the incoming radiance ${tex`L_i\\left(\\mathrm{p},\\omega_i\\right)`} is the same as the outgoing radiance ${tex`L_o\\left(\\mathrm{p}', -\\omega_i \\right)`} from some other point ${tex`\\mathrm{p}'`} on another surface. To find this point, we cast a ray in the direction the incoming radiance came from; this is the ray casting function ${tex`t\\left(\\mathrm{p},\\omega_i\\right)`}","pinned":false,"hidden":false,"mode":"md"},{"id":310,"value":"tex.block`L_i\\left(\\mathrm{p},\\omega_i\\right) = L_o\\left(t\\left(\\mathrm{p},\\omega_i\\right), -\\omega_i \\right)`","pinned":false,"hidden":false,"mode":"ojs"},{"id":323,"value":"Thus we see how ray casting is recursive; we repeatedly gather more and more indirect light until our rays miss all objects or some maximum depth is reached","pinned":false,"hidden":false,"mode":"md"},{"id":325,"value":"tex.block`\\begin{aligned}L_o\\left(\\mathrm{p}, \\omega_o\\right) &\\approx L_e + L_\\text{direct} + k_s L_o\\left(t\\left(\\mathrm{p},\\omega_r\\right), -\\omega_r \\right) + k_t L_o\\left(t\\left(\\mathrm{p},\\omega_t\\right), -\\omega_t \\right)\\end{aligned}`","pinned":false,"hidden":false,"mode":"ojs"},{"id":331,"value":"where ${tex`k_s`} and ${tex`k_t`} capture the material properties of the object and the cosine projection. This formulation is Whitted ray tracing. The examples below focus on one spawned ray, but can be adapted to two such as this formulation.","pinned":false,"hidden":false,"mode":"md"},{"id":255,"value":"## Recursive Serial Approach\n\nThe classic version of ray casting works as follows:\n\n

\n ${md`\n~~~js\nfunction render(image)\n{\n // Other initialization\n \n for(const pixel of image.pixels)\n {\n let ray = generate_ray(pixel) // generate_ray defined elsewhere\n let color = trace(ray) // see below\n image[pixel] = color // output is an image\n }\n return image\n}\n~~~`}\n

\nThis assumes one ray per pixel; for multiple rays, an inner loop is needed and the pixel colors averaged at the end.\n","pinned":false,"hidden":false,"mode":"md"},{"id":257,"value":"\nThe internals of `trace` look like:\n\n

\n${md`~~~js\nfunction trace(ray, depth = 0)\n{\n color = Color(0,0,0)\n intersection = intersect(ray, intersection)\n if(intersection)\n {\n color = direct_lighting(ray, intersection)\n if(depth < MAX_DEPTH)\n {\n depth += 1\n next_ray = scatter(ray, intersection)\n // coeff is the appropriate specular coefficient, including the cosine term\n color.add(intersection.coeff * trace(next_ray, depth))\n }\n }\n return color\n}\n~~~`}

\n \nNote the recursion: When processing indirect lighting, we call `trace` again with one or more appropriately scattered ray(s)—in Whitted ray tracing, for example, two indirect rays are traced. We stop when the ray misses (no intersection) or we pass the maximum depth `MAX_DEPTH`.","pinned":false,"hidden":false,"mode":"md"},{"id":148,"value":"

C++

The base ray casting loop is the same (assume some library for the color, ray, and other types):

\n ${cpp_serial_base}\n

`trace` follows similarly:

\n\n

\n ${cpp_serial_trace}\n

","pinned":false,"hidden":false,"mode":"md"},{"id":210,"value":"

Python

The Python approach is similar, but note that recursion is costly in Python compared to C++ and thus this approach is not recommended for serious scenes:

\n\n

\n ${python_serial_base}\n\n ${python_serial_trace}\n

","pinned":false,"hidden":false,"mode":"md"},{"id":12,"value":"## Recursive Threaded\n\nThe base recursive approach works fine, but is not very efficient, especially given modern machines with multiple cores. Note that different calls to `trace` have no dependency on each other—the result of one ray does not depend on the result of a previous or future ray. Only the image is shared; even then, each ray accesses a different pixel so there are no race conditions. Thus, parallelism is a natural approach.\n\nOur approach will create a thread for each logical core of the CPU; the render loop is modified to create the threads and await the completion of all of them to continue. Each thread is given a portion of the image (a tile) to trace; vertical slabs of pixel scanlines are used in this example.","pinned":false,"hidden":false,"mode":"md"},{"id":110,"value":"

\n${md`~~~js\nasync function trace_tile(index, tile_size, image)\n{\n // Iterate over the slab of our tile\n for(const pixel of image.pixels.slice(index*tile_size, (index+1)*tile_size))\n {\n let ray = generate_ray(pixel)\n let color = trace(ray)\n image[pixel] = color\n }\n // We do not return image as we modify the original\n}\n\nfunction render(image)\n{\n // Other initialization\n\n // Get number of logical cores\n const num_processes = window.navigator.hardwareConcurrency;\n // Get size of tile\n const tile_size = image.pixels.length / num_processes;\n // Generate a \"thread\" for each (really a microtask in JS)\n const threads = [...Array(num_processes)].map((x,i)=>trace_tile(i, tile_size, image));\n // Wait for all threads to finish\n Promise.all(threads).then();\n return image;\n}\n~~~`}

","pinned":false,"hidden":false,"mode":"md"},{"id":142,"value":"`trace` does not need to be modified for this approach.","pinned":false,"hidden":false,"mode":"md"},{"id":104,"value":"

Javascript: Not how I Work(er)

The above example in Javascript does not actually create separate threads, it just tells the JS engine to add them to the queue of microtasks it switches between in the same thread. As a single call to `trace` can be lengthy, the main thread (usually the web browser) will become less responsive.\n \nThe more idiomatic version of this approach for Javascript would be a [Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_A) which creates an actual separate thread. `trace_thread` and `trace` would then be defined in a separate script which forms the base of the Worker; the main thread with `render` will create the Worker and update the `image` when it receives events from the Workers.\n

","pinned":false,"hidden":false,"mode":"md"},{"id":158,"value":"

C++

Since C++11, C++ can use a similar `async` idiom to generate threads. We split the threads using a lambda function to capture the `image` to avoid copying:

\n\n

\n ${cpp_base_thread}\n

\n \n

Note, we use `std::span` to slice the container of `image.pixels()`; another loop construct would be used if not using C++20.

\n\n

As before, `trace` does not need to be modified.

","pinned":false,"hidden":false,"mode":"md"},{"id":386,"value":"$31","pinned":false,"hidden":false,"mode":"md"},{"id":15,"value":"$32","pinned":false,"hidden":false,"mode":"md"},{"id":348,"value":"tex.block`\\begin{aligned}L_o\\left(\\mathrm{p}, \\omega_o\\right) &\\approx \\dots + k_s L_o\\left(t\\left(\\mathrm{p},\\omega_r\\right), -\\omega_r \\right) + \\dots\\\\\n&\\approx \\dots k_s\\left(\\dots+k'_sL_o\\left(t\\left(\\mathrm{p}',\\omega'_r\\right), -\\omega'_r \\right) + \\dots\\right)+\\dots\\\\\n&\\approx \\dots k_sk'_s\\left(\\dots+k''_s L_o\\left(t\\left(\\mathrm{p}'',\\omega''_r\\right), -\\omega''_r \\right) + \\dots\\right)+\\dots\\\\\n&\\approx \\dots \\sum_{i=0}^{\\text{max depth}} \\prod_j^i k_{s_j} L_o(t(\\mathrm{p}\\overbrace{'\\dots'}^{j\\text{ times}},\\omega_r\\overbrace{'\\dots'}^{j\\text{ times}}), -\\omega_r\\overbrace{'\\dots'}^{j\\text{ times}} )\\dots\\end{aligned}`","pinned":false,"hidden":false,"mode":"ojs"},{"id":379,"value":"The other components accumulate similarly. Thus, to do iterative casting, we have to accumulate the specular components for each depth to properly attenuate the color; the attenuated direct lighting is added to the overall color at each step.","pinned":false,"hidden":false,"mode":"md"},{"id":182,"value":"

Doubling Trouble

The approach suggested works best when there is at most one ray spawned at each location. This is not true of Whitted-style ray tracing with its specular and transmission rays. In this case, the pool may double size each round and care must be taken when assigning the color so as to not double count.

","pinned":false,"hidden":false,"mode":"md"},{"id":184,"value":"`trace` has a small modification.","pinned":false,"hidden":false,"mode":"md"},{"id":186,"value":"

\n${md`~~~js\nfunction trace(ray)\n{\n color = Color(0,0,0)\n intersection = intersect(ray, intersection)\n if(intersection)\n {\n color = direct_lighting(ray, intersection)\n next_ray = scatter(ray, intersection)\n next_ray.color = color.scale(ray.coeff)\n next_ray.coeff = ray.coeff * intersection.coeff\n next_ray.alive = true\n }\n else\n {\n next_ray = Ray(ray);\n next_ray.alive = false\n }\n return next_ray\n}\n~~~`}

","pinned":false,"hidden":false,"mode":"md"},{"id":192,"value":"Note that `trace` now returns a `ray` and that the `ray` encodes more information—it indicates if it is still `alive` (there is another bounce), stores its accumulated `coeff` and `color` to appropriately build up its value. Not shown here, but `ray` also knows what `pixel` spawned it.\n\nFor the base code, `trace_tile` becomes `trace_pool_slice` which is responsible for its part of the active pool. After all `trace_pool_slice` threads complete, `render` updates the pool and continues to render until all `rays` are not `alive`.","pinned":false,"hidden":false,"mode":"md"},{"id":200,"value":"$33","pinned":false,"hidden":false,"mode":"md"},{"id":400,"value":"

C++

`trace` needs to be modified to accumulate the color information as we did above:

\n\n ${cpp_trace_iterate}\n

\n \n

For the base, we need to modify our iteration over threads to empty the thread storage `std::vector` each round in order to wait for the processes to finish:

\n\n

\n ${cpp_base_iterate}\n

","pinned":false,"hidden":false,"mode":"md"},{"id":499,"value":"$34","pinned":false,"hidden":false,"mode":"md"},{"id":457,"value":"Wavefront rendering is the primary way to do ray casting on GPU hardware as they do not support recursion. The next ray pools are loaded as buffers on the GPU and the CPU manages assignment of rays to GPU thread. Indeed, due to the parallel processing of GPUs, each individual ray can be assigned to its own shader, with groups of rays being executed in parallel behind the scenes by the GPU pipeline.","pinned":false,"hidden":false,"mode":"md"},{"id":436,"value":"## Notes\n\nThe C++ version was inspired by Brenton's [\"Solving multithreaded raytracing issues with C++11\"](https://medium.com/@phostershop/solving-multithreaded-raytracing-issues-with-c-11-7f018ecd76fa). ","pinned":false,"hidden":false,"mode":"md"},{"id":394,"value":"import {toc} from \"@nebrius/indented-toc\"","pinned":true,"hidden":false,"mode":"ojs"},{"id":55,"value":"cpp_serial_base=md`~~~c++\nvoid render(image& image)\n{\n for(auto pixel : image.pixels())\n {\n auto ray = generate_ray(pixel);\n auto color = trace(ray);\n image[pixel] = color;\n }\n}\n~~~\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":151,"value":"cpp_serial_trace = md`\n~~~c++\ncolor3 trace(const ray& ray, unsigned int depth = 0)\n{\n color3 color(0,0,0);\n if(auto intersection = intersect(ray))\n {\n color = direct_lighting(ray, intersection);\n if(depth < MAX_DEPTH)\n {\n depth += 1;\n auto next_ray = scatter(ray, intersection);\n color += intersection.coeff * trace(next_ray, depth);\n }\n }\n return color;\n}\n~~~\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":161,"value":"$35","pinned":false,"hidden":false,"mode":"ojs"},{"id":212,"value":"python_serial_base = md`~~~python\ndef render(image):\n # Any initialization goes here\n\n for pixel in image.pixels():\n ray = generate_ray(pixel);\n color = trace(ray);\n image[pixel] = color;\n~~~\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":221,"value":"python_serial_trace = md`~~~python\ndef trace(ray):\n color = color(0,0,0);\n intersection = intersect(ray)\n if intersection:\n color = direct_lighting(ray, intersection);\n next_ray = scatter(ray, intersection);\n color += intersection.coeff * trace(next_ray);\n return color;\n~~~\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":406,"value":"cpp_trace_iterate = md`\n~~~c++\nray trace(const ray& ray)\n{\n auto next_ray = ray(ray);\n if(auto intersection = intersect(ray))\n {\n auto color = direct_lighting(ray, intersection);\n next_ray = scatter(ray, intersection);\n next_ray.color = intersection.coeff * color;\n next_ray.coeff = ray.coeff * intersection.coeff;\n next_ray.alive = true;\n }\n else\n {\n next_ray.alive = false;\n }\n return next_ray;\n}\n~~~`","pinned":false,"hidden":false,"mode":"ojs"},{"id":414,"value":"$36","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W37","stdlib":"1","titling":"auto"}