kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity
064caae7b2
blender/intern/cycles/kernel/bvh/qbvh_traversal.h

549 lines
17 KiB
C
Raw Normal View History

Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
/*
Cycles: Cleanup file headers Some of the files were wrongly attributing code to some other organizations and in few places proper attribution was missing. This is mainly either a copy-paste error (when new file was created from an existing one and header wasn't updated) or due to some refactor which split non-original-BF code with purely BF code. Should solve some confusion around.
2016-09-29 08:11:40 +00:00
* Copyright 2011-2013 Blender Foundation
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* This is a template BVH traversal function, where various features can be
* enabled/disabled. This way we can compile optimized versions for each case
* without new features slowing things down.
*
* BVH_INSTANCING: object instancing
* BVH_HAIR: hair curve rendering
* BVH_HAIR_MINIMUM_WIDTH: hair curve rendering with minimum width
* BVH_MOTION: motion blur rendering
*
*/
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
#if BVH_FEATURE(BVH_HAIR)
# define NODE_INTERSECT qbvh_node_intersect
# define NODE_INTERSECT_ROBUST qbvh_node_intersect_robust
#else
# define NODE_INTERSECT qbvh_aligned_node_intersect
# define NODE_INTERSECT_ROBUST qbvh_aligned_node_intersect_robust
#endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
const Ray *ray,
Intersection *isect,
const uint visibility
#if BVH_FEATURE(BVH_HAIR_MINIMUM_WIDTH)
,uint *lcg_state,
float difl,
float extmax
#endif
)
{
/* TODO(sergey):
* - Test if pushing distance on the stack helps (for non shadow rays).
* - Separate version for shadow rays.
* - Likely and unlikely for if() statements.
* - Test restrict attribute for pointers.
*/
/* Traversal stack in CUDA thread-local memory. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
QBVHStackItem traversal_stack[BVH_QSTACK_SIZE];
traversal_stack[0].addr = ENTRYPOINT_SENTINEL;
traversal_stack[0].dist = -FLT_MAX;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
/* Traversal variables in registers. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
int stack_ptr = 0;
int node_addr = kernel_data.bvh.root;
float node_dist = -FLT_MAX;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
/* Ray parameters in registers. */
float3 P = ray->P;
float3 dir = bvh_clamp_direction(ray->D);
float3 idir = bvh_inverse_direction(dir);
int object = OBJECT_NONE;
#if BVH_FEATURE(BVH_MOTION)
Cycles: Fix wrong intersection with motion blur and degenerate object transform
2015-10-08 16:24:54 +00:00
Transform ob_itfm;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#endif
Fix T43596: Refraction BSDF crashes blender on pre-sse4 CPU This is the same issue T43475: SSE4 code is more robust to non-finite values in the ray origin/direction. So for now added a check before doing BVH traversal for pre-SSE4 CPUs. For sure actual root of the issue is a bit different and much more tricky to solve, especially without disturbing render results too much. Still looking into this. In any case, it's kinda fine to have such a check, we might later make it to be a kernel_assert() instead of just a return.
2015-02-10 12:31:55 +00:00
#ifndef __KERNEL_SSE41__
if(!isfinite(P.x)) {
return false;
}
#endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
isect->t = ray->t;
isect->u = 0.0f;
isect->v = 0.0f;
isect->prim = PRIM_NONE;
isect->object = OBJECT_NONE;
Cycles: Simplify code around debug stats in BVH traversing
2016-05-27 08:55:48 +00:00
BVH_DEBUG_INIT();
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
ssef tnear(0.0f), tfar(ray->t);
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
#if BVH_FEATURE(BVH_HAIR)
sse3f dir4(ssef(dir.x), ssef(dir.y), ssef(dir.z));
#endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
sse3f idir4(ssef(idir.x), ssef(idir.y), ssef(idir.z));
#ifdef __KERNEL_AVX2__
float3 P_idir = P*idir;
sse3f P_idir4 = sse3f(P_idir.x, P_idir.y, P_idir.z);
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
#endif
#if BVH_FEATURE(BVH_HAIR) || !defined(__KERNEL_AVX2__)
sse3f org4 = sse3f(ssef(P.x), ssef(P.y), ssef(P.z));
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#endif
/* Offsets to select the side that becomes the lower or upper bound. */
Cycles: BVH-related SSE optimization Several ideas here: - Optimize calculation of near_{x,y,z} in a way that does not require 3 if() statements per update, which avoids negative effect of wrong branch prediction. - Optimization of direction clamping for BVH. - Optimization of point/direction transform. Brings ~1.5% speedup again depending on a scene (unfortunately, this speedup can't be sum across all previous commits because speedup of each of the changes varies from scene to scene, but it still seems to be nice solid speedup of few percent on Linux and bigger speedup was reported on Windows). Once again ,thanks Maxym for inspiration! Still TODO: We have multiple places where we need to calculate near x,y,z indices in BVH, for now it's only done for main BVH traversal. Will try to move this calculation to an utility function and see if that can be easily re-used across all the BVH flavors.
2016-10-25 12:47:34 +00:00
#ifdef __KERNEL_SSE__
int near_x = 0, near_y = 2, near_z = 4;
int far_x = 1, far_y = 3, far_z = 5;
const size_t mask = movemask(ssef(idir.m128));
const int mask_x = mask & 1;
const int mask_y = (mask & 2) >> 1;
const int mask_z = (mask & 4) >> 2;
near_x += mask_x; far_x -= mask_x;
near_y += mask_y; far_y -= mask_y;
near_z += mask_z; far_z -= mask_z;
#else
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
int near_x, near_y, near_z;
int far_x, far_y, far_z;
if(idir.x >= 0.0f) { near_x = 0; far_x = 1; } else { near_x = 1; far_x = 0; }
if(idir.y >= 0.0f) { near_y = 2; far_y = 3; } else { near_y = 3; far_y = 2; }
if(idir.z >= 0.0f) { near_z = 4; far_z = 5; } else { near_z = 5; far_z = 4; }
Cycles: BVH-related SSE optimization Several ideas here: - Optimize calculation of near_{x,y,z} in a way that does not require 3 if() statements per update, which avoids negative effect of wrong branch prediction. - Optimization of direction clamping for BVH. - Optimization of point/direction transform. Brings ~1.5% speedup again depending on a scene (unfortunately, this speedup can't be sum across all previous commits because speedup of each of the changes varies from scene to scene, but it still seems to be nice solid speedup of few percent on Linux and bigger speedup was reported on Windows). Once again ,thanks Maxym for inspiration! Still TODO: We have multiple places where we need to calculate near x,y,z indices in BVH, for now it's only done for main BVH traversal. Will try to move this calculation to an utility function and see if that can be easily re-used across all the BVH flavors.
2016-10-25 12:47:34 +00:00
#endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
IsectPrecalc isect_precalc;
triangle_intersect_precalc(dir, &isect_precalc);
/* Traversal loop. */
do {
do {
/* Traverse internal nodes. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
while(node_addr >= 0 && node_addr != ENTRYPOINT_SENTINEL) {
float4 inodes = kernel_tex_fetch(__bvh_nodes, node_addr+0);
Cycles: Support visibility check for inner nodes of QBVH It was initially unsupported because initial idea of checking visibility of all children was slowing scenes down a lot. Now the idea has changed and we only perform visibility check of current node. This avoids huge slowdown (from tests here it seems to be withing 1-2%, but more tests would never hurt) and gives nice speedup of ray traversal for complex scenes which utilized ray visibility. Here's timing of koro.blend: Without visibility check With visibility check Original file 4min 20sec 4min 23sec Camera rays only 1min 43 sec 55sec Unfortunately, this doesn't come for free and requires extra data in BVH node, which increases memory usage of BVH nodes by 15%. This we can solve with some future trickery of avoiding __tri_storage created for curve segments.
2016-06-10 08:14:05 +00:00
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(UNLIKELY(node_dist > isect->t)
Cycles: Support visibility check for inner nodes of QBVH It was initially unsupported because initial idea of checking visibility of all children was slowing scenes down a lot. Now the idea has changed and we only perform visibility check of current node. This avoids huge slowdown (from tests here it seems to be withing 1-2%, but more tests would never hurt) and gives nice speedup of ray traversal for complex scenes which utilized ray visibility. Here's timing of koro.blend: Without visibility check With visibility check Original file 4min 20sec 4min 23sec Camera rays only 1min 43 sec 55sec Unfortunately, this doesn't come for free and requires extra data in BVH node, which increases memory usage of BVH nodes by 15%. This we can solve with some future trickery of avoiding __tri_storage created for curve segments.
2016-06-10 08:14:05 +00:00
#ifdef __VISIBILITY_FLAG__
|| (__float_as_uint(inodes.x) & visibility) == 0)
#endif
{
Cycles: Distance optimization for QBVH This commit implements heuristic which allows to skip nodes pushed to the stack from intersection if distance to them is larger than the distance to the current intersection. This should solve speed regression which i didn't notice in the original QBVH commit (which could have because i had WIP version of this patch applied in my local branch). From quick tests speed seems to be much closer to what is was with regular BVH. There's still some possible code cleanup, but they'll need a bit of assembly code check and now i want to make it so artists can happily use Cycles over the holidays.
2014-12-25 17:40:02 +00:00
/* Pop. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
node_addr = traversal_stack[stack_ptr].addr;
node_dist = traversal_stack[stack_ptr].dist;
--stack_ptr;
Cycles: Distance optimization for QBVH This commit implements heuristic which allows to skip nodes pushed to the stack from intersection if distance to them is larger than the distance to the current intersection. This should solve speed regression which i didn't notice in the original QBVH commit (which could have because i had WIP version of this patch applied in my local branch). From quick tests speed seems to be much closer to what is was with regular BVH. There's still some possible code cleanup, but they'll need a bit of assembly code check and now i want to make it so artists can happily use Cycles over the holidays.
2014-12-25 17:40:02 +00:00
continue;
}
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
int child_mask;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
ssef dist;
Cycles: Simplify code around debug stats in BVH traversing
2016-05-27 08:55:48 +00:00
BVH_DEBUG_NEXT_STEP();
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#if BVH_FEATURE(BVH_HAIR_MINIMUM_WIDTH)
if(difl != 0.0f) {
/* NOTE: We extend all the child BB instead of fetching
* and checking visibility flags for each of the,
*
* Need to test if doing opposite would be any faster.
*/
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
child_mask = NODE_INTERSECT_ROBUST(kg,
tnear,
tfar,
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# ifdef __KERNEL_AVX2__
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
P_idir4,
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
# endif
# if BVH_FEATURE(BVH_HAIR) || !defined(__KERNEL_AVX2__)
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
org4,
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# endif
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
# if BVH_FEATURE(BVH_HAIR)
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
dir4,
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
# endif
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
idir4,
near_x, near_y, near_z,
far_x, far_y, far_z,
node_addr,
difl,
&dist);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
else
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
#endif /* BVH_HAIR_MINIMUM_WIDTH */
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
{
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
child_mask = NODE_INTERSECT(kg,
tnear,
tfar,
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#ifdef __KERNEL_AVX2__
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
P_idir4,
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
#endif
#if BVH_FEATURE(BVH_HAIR) || !defined(__KERNEL_AVX2__)
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
org4,
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
#endif
#if BVH_FEATURE(BVH_HAIR)
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
dir4,
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#endif
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
idir4,
near_x, near_y, near_z,
far_x, far_y, far_z,
node_addr,
&dist);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(child_mask != 0) {
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
float4 cnodes;
/* TODO(sergey): Investigate whether moving cnodes upwards
* gives a speedup (will be different cache pattern but will
* avoid extra check here),
*/
#if BVH_FEATURE(BVH_HAIR)
if(__float_as_uint(inodes.x) & PATH_RAY_NODE_UNALIGNED) {
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
cnodes = kernel_tex_fetch(__bvh_nodes, node_addr+13);
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
}
else
#endif
{
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
cnodes = kernel_tex_fetch(__bvh_nodes, node_addr+7);
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
}
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
/* One child is hit, continue with that child. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
int r = __bscf(child_mask);
Cycles: Distance optimization for QBVH This commit implements heuristic which allows to skip nodes pushed to the stack from intersection if distance to them is larger than the distance to the current intersection. This should solve speed regression which i didn't notice in the original QBVH commit (which could have because i had WIP version of this patch applied in my local branch). From quick tests speed seems to be much closer to what is was with regular BVH. There's still some possible code cleanup, but they'll need a bit of assembly code check and now i want to make it so artists can happily use Cycles over the holidays.
2014-12-25 17:40:02 +00:00
float d0 = ((float*)&dist)[r];
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(child_mask == 0) {
node_addr = __float_as_int(cnodes[r]);
node_dist = d0;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
continue;
}
/* Two children are hit, push far child, and continue with
* closer child.
*/
int c0 = __float_as_int(cnodes[r]);
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
r = __bscf(child_mask);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
int c1 = __float_as_int(cnodes[r]);
float d1 = ((float*)&dist)[r];
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(child_mask == 0) {
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
if(d1 < d0) {
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
node_addr = c1;
node_dist = d1;
++stack_ptr;
kernel_assert(stack_ptr < BVH_QSTACK_SIZE);
traversal_stack[stack_ptr].addr = c0;
traversal_stack[stack_ptr].dist = d0;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
continue;
}
else {
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
node_addr = c0;
node_dist = d0;
++stack_ptr;
kernel_assert(stack_ptr < BVH_QSTACK_SIZE);
traversal_stack[stack_ptr].addr = c1;
traversal_stack[stack_ptr].dist = d1;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
continue;
}
}
/* Here starts the slow path for 3 or 4 hit children. We push
* all nodes onto the stack to sort them there.
*/
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
++stack_ptr;
kernel_assert(stack_ptr < BVH_QSTACK_SIZE);
traversal_stack[stack_ptr].addr = c1;
traversal_stack[stack_ptr].dist = d1;
++stack_ptr;
kernel_assert(stack_ptr < BVH_QSTACK_SIZE);
traversal_stack[stack_ptr].addr = c0;
traversal_stack[stack_ptr].dist = d0;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
/* Three children are hit, push all onto stack and sort 3
* stack items, continue with closest child.
*/
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
r = __bscf(child_mask);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
int c2 = __float_as_int(cnodes[r]);
float d2 = ((float*)&dist)[r];
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(child_mask == 0) {
++stack_ptr;
kernel_assert(stack_ptr < BVH_QSTACK_SIZE);
traversal_stack[stack_ptr].addr = c2;
traversal_stack[stack_ptr].dist = d2;
qbvh_stack_sort(&traversal_stack[stack_ptr],
&traversal_stack[stack_ptr - 1],
&traversal_stack[stack_ptr - 2]);
node_addr = traversal_stack[stack_ptr].addr;
node_dist = traversal_stack[stack_ptr].dist;
--stack_ptr;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
continue;
}
/* Four children are hit, push all onto stack and sort 4
* stack items, continue with closest child.
*/
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
r = __bscf(child_mask);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
int c3 = __float_as_int(cnodes[r]);
float d3 = ((float*)&dist)[r];
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
++stack_ptr;
kernel_assert(stack_ptr < BVH_QSTACK_SIZE);
traversal_stack[stack_ptr].addr = c3;
traversal_stack[stack_ptr].dist = d3;
++stack_ptr;
kernel_assert(stack_ptr < BVH_QSTACK_SIZE);
traversal_stack[stack_ptr].addr = c2;
traversal_stack[stack_ptr].dist = d2;
qbvh_stack_sort(&traversal_stack[stack_ptr],
&traversal_stack[stack_ptr - 1],
&traversal_stack[stack_ptr - 2],
&traversal_stack[stack_ptr - 3]);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
node_addr = traversal_stack[stack_ptr].addr;
node_dist = traversal_stack[stack_ptr].dist;
--stack_ptr;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
/* If node is leaf, fetch triangle list. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(node_addr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr-1));
Cycles: Fix visibility check for instanced nodes The issue is that only instance node contains proper visibility flags, nodes from instanced BVH are not correct.
2014-12-27 18:33:50 +00:00
#ifdef __VISIBILITY_FLAG__
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(UNLIKELY((node_dist > isect->t) ||
Cycles: Support visibility check for inner nodes of QBVH It was initially unsupported because initial idea of checking visibility of all children was slowing scenes down a lot. Now the idea has changed and we only perform visibility check of current node. This avoids huge slowdown (from tests here it seems to be withing 1-2%, but more tests would never hurt) and gives nice speedup of ray traversal for complex scenes which utilized ray visibility. Here's timing of koro.blend: Without visibility check With visibility check Original file 4min 20sec 4min 23sec Camera rays only 1min 43 sec 55sec Unfortunately, this doesn't come for free and requires extra data in BVH node, which increases memory usage of BVH nodes by 15%. This we can solve with some future trickery of avoiding __tri_storage created for curve segments.
2016-06-10 08:14:05 +00:00
((__float_as_uint(leaf.z) & visibility) == 0)))
Cycles: Fix MSVC which desn't like condition to be split by preprocessor
2014-12-29 16:10:37 +00:00
#else
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(UNLIKELY((node_dist > isect->t)))
Cycles: Fix visibility check for instanced nodes The issue is that only instance node contains proper visibility flags, nodes from instanced BVH are not correct.
2014-12-27 18:33:50 +00:00
#endif
{
Cycles: Distance optimization for QBVH This commit implements heuristic which allows to skip nodes pushed to the stack from intersection if distance to them is larger than the distance to the current intersection. This should solve speed regression which i didn't notice in the original QBVH commit (which could have because i had WIP version of this patch applied in my local branch). From quick tests speed seems to be much closer to what is was with regular BVH. There's still some possible code cleanup, but they'll need a bit of assembly code check and now i want to make it so artists can happily use Cycles over the holidays.
2014-12-25 17:40:02 +00:00
/* Pop. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
node_addr = traversal_stack[stack_ptr].addr;
node_dist = traversal_stack[stack_ptr].dist;
--stack_ptr;
Cycles: Distance optimization for QBVH This commit implements heuristic which allows to skip nodes pushed to the stack from intersection if distance to them is larger than the distance to the current intersection. This should solve speed regression which i didn't notice in the original QBVH commit (which could have because i had WIP version of this patch applied in my local branch). From quick tests speed seems to be much closer to what is was with regular BVH. There's still some possible code cleanup, but they'll need a bit of assembly code check and now i want to make it so artists can happily use Cycles over the holidays.
2014-12-25 17:40:02 +00:00
continue;
}
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
int prim_addr = __float_as_int(leaf.x);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#if BVH_FEATURE(BVH_INSTANCING)
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(prim_addr >= 0) {
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#endif
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
int prim_addr2 = __float_as_int(leaf.y);
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
const uint type = __float_as_int(leaf.w);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
/* Pop. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
node_addr = traversal_stack[stack_ptr].addr;
node_dist = traversal_stack[stack_ptr].dist;
--stack_ptr;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
/* Primitive intersection. */
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
switch(type & PRIMITIVE_ALL) {
case PRIMITIVE_TRIANGLE: {
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
for(; prim_addr < prim_addr2; prim_addr++) {
Cycles: Simplify code around debug stats in BVH traversing
2016-05-27 08:55:48 +00:00
BVH_DEBUG_NEXT_STEP();
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
kernel_assert(kernel_tex_fetch(__prim_type, prim_addr) == type);
if(triangle_intersect(kg,
&isect_precalc,
isect,
P,
visibility,
object,
prim_addr)) {
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
tfar = ssef(isect->t);
/* Shadow ray early termination. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(visibility == PATH_RAY_SHADOW_OPAQUE) {
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
return true;
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
}
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
}
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
break;
}
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#if BVH_FEATURE(BVH_MOTION)
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
case PRIMITIVE_MOTION_TRIANGLE: {
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
for(; prim_addr < prim_addr2; prim_addr++) {
Cycles: Simplify code around debug stats in BVH traversing
2016-05-27 08:55:48 +00:00
BVH_DEBUG_NEXT_STEP();
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
kernel_assert(kernel_tex_fetch(__prim_type, prim_addr) == type);
if(motion_triangle_intersect(kg,
isect,
P,
dir,
ray->time,
visibility,
object,
prim_addr)) {
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
tfar = ssef(isect->t);
/* Shadow ray early termination. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(visibility == PATH_RAY_SHADOW_OPAQUE) {
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
return true;
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
}
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
}
}
break;
}
#endif /* BVH_FEATURE(BVH_MOTION) */
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#if BVH_FEATURE(BVH_HAIR)
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
case PRIMITIVE_CURVE:
case PRIMITIVE_MOTION_CURVE: {
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
for(; prim_addr < prim_addr2; prim_addr++) {
Cycles: Simplify code around debug stats in BVH traversing
2016-05-27 08:55:48 +00:00
BVH_DEBUG_NEXT_STEP();
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
kernel_assert(kernel_tex_fetch(__prim_type, prim_addr) == type);
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
bool hit;
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(kernel_data.curve.curveflags & CURVE_KN_INTERPOLATE) {
hit = bvh_cardinal_curve_intersect(kg,
isect,
P,
dir,
visibility,
object,
prim_addr,
ray->time,
type,
lcg_state,
difl,
extmax);
}
else {
hit = bvh_curve_intersect(kg,
isect,
P,
dir,
visibility,
object,
prim_addr,
ray->time,
type,
lcg_state,
difl,
extmax);
}
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
if(hit) {
tfar = ssef(isect->t);
/* Shadow ray early termination. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(visibility == PATH_RAY_SHADOW_OPAQUE) {
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
return true;
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
}
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
}
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
break;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
Cycles: Enable leaf split by primitive type and adopt BVH traversal for this This commit enables BVH leaf nodes split by the primitive type and makes it so BVH traversal code is now aware and benefits from this. As was mentioned in original commit, this change is crucial to be able to do single ray to multiple triangle intersection. But it also appears to give barely visible speedup in some scene. In any case there should be no noticeable slowdown, and this change is what we need to have anyway.
2015-01-10 17:41:49 +00:00
#endif /* BVH_FEATURE(BVH_HAIR) */
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
}
#if BVH_FEATURE(BVH_INSTANCING)
else {
/* Instance push. */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
object = kernel_tex_fetch(__prim_object, -prim_addr-1);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# if BVH_FEATURE(BVH_MOTION)
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
qbvh_instance_motion_push(kg, object, ray, &P, &dir, &idir, &isect->t, &node_dist, &ob_itfm);
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# else
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
qbvh_instance_push(kg, object, ray, &P, &dir, &idir, &isect->t, &node_dist);
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
Cycles: BVH-related SSE optimization Several ideas here: - Optimize calculation of near_{x,y,z} in a way that does not require 3 if() statements per update, which avoids negative effect of wrong branch prediction. - Optimization of direction clamping for BVH. - Optimization of point/direction transform. Brings ~1.5% speedup again depending on a scene (unfortunately, this speedup can't be sum across all previous commits because speedup of each of the changes varies from scene to scene, but it still seems to be nice solid speedup of few percent on Linux and bigger speedup was reported on Windows). Once again ,thanks Maxym for inspiration! Still TODO: We have multiple places where we need to calculate near x,y,z indices in BVH, for now it's only done for main BVH traversal. Will try to move this calculation to an utility function and see if that can be easily re-used across all the BVH flavors.
2016-10-25 12:47:34 +00:00
#ifdef __KERNEL_SSE__
near_x = 0; near_y = 2; near_z = 4;
far_x = 1; far_y = 3; far_z = 5;
const size_t mask = movemask(ssef(idir.m128));
const int mask_x = mask & 1;
const int mask_y = (mask & 2) >> 1;
const int mask_z = (mask & 4) >> 2;
near_x += mask_x; far_x -= mask_x;
near_y += mask_y; far_y -= mask_y;
near_z += mask_z; far_z -= mask_z;
#else
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
if(idir.x >= 0.0f) { near_x = 0; far_x = 1; } else { near_x = 1; far_x = 0; }
if(idir.y >= 0.0f) { near_y = 2; far_y = 3; } else { near_y = 3; far_y = 2; }
if(idir.z >= 0.0f) { near_z = 4; far_z = 5; } else { near_z = 5; far_z = 4; }
Cycles: BVH-related SSE optimization Several ideas here: - Optimize calculation of near_{x,y,z} in a way that does not require 3 if() statements per update, which avoids negative effect of wrong branch prediction. - Optimization of direction clamping for BVH. - Optimization of point/direction transform. Brings ~1.5% speedup again depending on a scene (unfortunately, this speedup can't be sum across all previous commits because speedup of each of the changes varies from scene to scene, but it still seems to be nice solid speedup of few percent on Linux and bigger speedup was reported on Windows). Once again ,thanks Maxym for inspiration! Still TODO: We have multiple places where we need to calculate near x,y,z indices in BVH, for now it's only done for main BVH traversal. Will try to move this calculation to an utility function and see if that can be easily re-used across all the BVH flavors.
2016-10-25 12:47:34 +00:00
#endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
tfar = ssef(isect->t);
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
# if BVH_FEATURE(BVH_HAIR)
dir4 = sse3f(ssef(dir.x), ssef(dir.y), ssef(dir.z));
# endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
idir4 = sse3f(ssef(idir.x), ssef(idir.y), ssef(idir.z));
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# ifdef __KERNEL_AVX2__
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
P_idir = P*idir;
P_idir4 = sse3f(P_idir.x, P_idir.y, P_idir.z);
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# endif
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
# if BVH_FEATURE(BVH_HAIR) || !defined(__KERNEL_AVX2__)
org4 = sse3f(ssef(P.x), ssef(P.y), ssef(P.z));
# endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
triangle_intersect_precalc(dir, &isect_precalc);
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
++stack_ptr;
kernel_assert(stack_ptr < BVH_QSTACK_SIZE);
traversal_stack[stack_ptr].addr = ENTRYPOINT_SENTINEL;
traversal_stack[stack_ptr].dist = -FLT_MAX;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
node_addr = kernel_tex_fetch(__object_node, object);
Cycles: Add debug pass which shows number of instance pushes during camera ray intersection TODO: We might want to refactor debug passes into PASS_DEBUG and some debug_type (similar to Blender's side passes) to avoid issue of running out of bits.
2015-06-11 22:12:03 +00:00
Cycles: Simplify code around debug stats in BVH traversing
2016-05-27 08:55:48 +00:00
BVH_DEBUG_NEXT_INSTANCE();
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
}
#endif /* FEATURE(BVH_INSTANCING) */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
} while(node_addr != ENTRYPOINT_SENTINEL);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
#if BVH_FEATURE(BVH_INSTANCING)
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
if(stack_ptr >= 0) {
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
kernel_assert(object != OBJECT_NONE);
/* Instance pop. */
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# if BVH_FEATURE(BVH_MOTION)
Cycles: Fix wrong intersection with motion blur and degenerate object transform
2015-10-08 16:24:54 +00:00
bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, &isect->t, &ob_itfm);
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# else
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
bvh_instance_pop(kg, object, ray, &P, &dir, &idir, &isect->t);
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
Cycles: BVH-related SSE optimization Several ideas here: - Optimize calculation of near_{x,y,z} in a way that does not require 3 if() statements per update, which avoids negative effect of wrong branch prediction. - Optimization of direction clamping for BVH. - Optimization of point/direction transform. Brings ~1.5% speedup again depending on a scene (unfortunately, this speedup can't be sum across all previous commits because speedup of each of the changes varies from scene to scene, but it still seems to be nice solid speedup of few percent on Linux and bigger speedup was reported on Windows). Once again ,thanks Maxym for inspiration! Still TODO: We have multiple places where we need to calculate near x,y,z indices in BVH, for now it's only done for main BVH traversal. Will try to move this calculation to an utility function and see if that can be easily re-used across all the BVH flavors.
2016-10-25 12:47:34 +00:00
#ifdef __KERNEL_SSE__
near_x = 0; near_y = 2; near_z = 4;
far_x = 1; far_y = 3; far_z = 5;
const size_t mask = movemask(ssef(idir.m128));
const int mask_x = mask & 1;
const int mask_y = (mask & 2) >> 1;
const int mask_z = (mask & 4) >> 2;
near_x += mask_x; far_x -= mask_x;
near_y += mask_y; far_y -= mask_y;
near_z += mask_z; far_z -= mask_z;
#else
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
if(idir.x >= 0.0f) { near_x = 0; far_x = 1; } else { near_x = 1; far_x = 0; }
if(idir.y >= 0.0f) { near_y = 2; far_y = 3; } else { near_y = 3; far_y = 2; }
if(idir.z >= 0.0f) { near_z = 4; far_z = 5; } else { near_z = 5; far_z = 4; }
Cycles: BVH-related SSE optimization Several ideas here: - Optimize calculation of near_{x,y,z} in a way that does not require 3 if() statements per update, which avoids negative effect of wrong branch prediction. - Optimization of direction clamping for BVH. - Optimization of point/direction transform. Brings ~1.5% speedup again depending on a scene (unfortunately, this speedup can't be sum across all previous commits because speedup of each of the changes varies from scene to scene, but it still seems to be nice solid speedup of few percent on Linux and bigger speedup was reported on Windows). Once again ,thanks Maxym for inspiration! Still TODO: We have multiple places where we need to calculate near x,y,z indices in BVH, for now it's only done for main BVH traversal. Will try to move this calculation to an utility function and see if that can be easily re-used across all the BVH flavors.
2016-10-25 12:47:34 +00:00
#endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
tfar = ssef(isect->t);
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
# if BVH_FEATURE(BVH_HAIR)
dir4 = sse3f(ssef(dir.x), ssef(dir.y), ssef(dir.z));
# endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
idir4 = sse3f(ssef(idir.x), ssef(idir.y), ssef(idir.z));
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# ifdef __KERNEL_AVX2__
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
P_idir = P*idir;
P_idir4 = sse3f(P_idir.x, P_idir.y, P_idir.z);
Cycles: Cleanup, indent nested preprocessor directives Quite straightforward, main trick is happening in path_source_replace_includes(). Reviewers: brecht, dingto, lukasstockner97, juicyfruit Differential Revision: https://developer.blender.org/D1794
2016-02-12 17:33:43 +00:00
# endif
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
# if BVH_FEATURE(BVH_HAIR) || !defined(__KERNEL_AVX2__)
org4 = sse3f(ssef(P.x), ssef(P.y), ssef(P.z));
# endif
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
triangle_intersect_precalc(dir, &isect_precalc);
object = OBJECT_NONE;
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
node_addr = traversal_stack[stack_ptr].addr;
node_dist = traversal_stack[stack_ptr].dist;
--stack_ptr;
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
}
#endif /* FEATURE(BVH_INSTANCING) */
Cycles: Cleanup, variables name Using camel case for variables is something what didn't came from our original code, but rather from third party libraries. Let's avoid those as much as possible.
2016-07-11 11:44:19 +00:00
} while(node_addr != ENTRYPOINT_SENTINEL);
Cycles: Implement QBVH tree traversal This commit implements traversal for QBVH tree, which is based on the old loop code for traversal itself and Embree for node intersection. This commit also does some changes to the loop inspired by Embree: - Visibility flags are only checked for primitives. Doing visibility check for every node cost quite reasonable amount of time and in most cases those checks are true-positive. Other idea here would be to do visibility checks for leaf nodes only, but this would need to be investigated further. - For minimum hair width we extend all the nodes' bounding boxes. Again doing curve visibility check is quite costly for each of the nodes and those checks returns truth for most of the hierarchy anyway. There are number of possible optimization still, but current state is good enough in terms it makes rendering faster a little bit after recent watertight commit. Currently QBVH is only implemented for CPU with SSE2 support at least. All other devices would need to be supported later (if that'd make sense from performance point of view). The code is enabled for compilation in kernel. but blender wouldn't use it still.
2014-12-16 15:11:37 +00:00
return (isect->prim != PRIM_NONE);
}
Cycles: Implement unaligned nodes BVH traversal This commit implements traversal of unaligned BVH nodes. QBVH traversal is fully SIMD optimized and calculates orientation for all 4 children at a time, regular BVH might probably be optimized a bit more.
2016-07-07 10:23:13 +00:00
#undef NODE_INTERSECT
#undef NODE_INTERSECT_ROBUST
Copy Permalink