kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity
2ecbc3b777
blender/intern/cycles/kernel/bvh/bvh_volume.h

325 lines
9.4 KiB
C
Raw Normal View History

Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
/*
* Adapted from code Copyright 2009-2010 NVIDIA Corporation,
* and code copyright 2009-2012 Intel Corporation
*
* Modifications Copyright 2011-2014, Blender Foundation.
*
* 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.
*/
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 __QBVH__
Cycles: Move BVK kernel files to own directory BVH traversal is not really that much a geometry and we've got quite some traversals now. Makes sense to keep them separate in the name of source structure clarity.
2016-07-11 10:28:45 +00:00
# include "qbvh_volume.h"
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)
# define NODE_INTERSECT bvh_node_intersect
#else
# define NODE_INTERSECT bvh_aligned_node_intersect
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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
/* This is a template BVH traversal function for volumes, 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_MOTION: motion blur rendering
*
*/
Cycles: Rework BVH functions calls a little bit Basic idea is to allow multiple implementation per feature-set, meaning this commit tries to make it easier to hook new algorithms for BVH traversal.
2014-12-24 19:06:49 +00:00
ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
const Ray *ray,
Cycles: Fix wrong camera in volume check when domain is only visible to camera rays
2016-04-04 17:30:38 +00:00
Intersection *isect,
const uint visibility)
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
{
/* todo:
* - 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 */
int traversalStack[BVH_STACK_SIZE];
traversalStack[0] = ENTRYPOINT_SENTINEL;
/* traversal variables in registers */
int stackPtr = 0;
int nodeAddr = kernel_data.bvh.root;
/* 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;
Cycles: Code cleanup, de-duplicate definition of FEATURE Previously every BVH traversal file was defining macro to check which features should be compiled in, now this macro is defined in the parent header.
2014-12-24 19:10:17 +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
Transform ob_itfm;
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
#endif
isect->t = ray->t;
isect->u = 0.0f;
isect->v = 0.0f;
Cycles: set hit values in-order
2014-10-11 09:16:31 +00:00
isect->prim = PRIM_NONE;
isect->object = OBJECT_NONE;
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
#if defined(__KERNEL_SSE2__)
const shuffle_swap_t shuf_identity = shuffle_swap_identity();
const shuffle_swap_t shuf_swap = shuffle_swap_swap();
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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
const ssef pn = cast(ssei(0, 0, 0x80000000, 0x80000000));
ssef Psplat[3], idirsplat[3];
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)
ssef tnear(0.0f), tfar(isect->t);
# endif
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
shuffle_swap_t shufflexyz[3];
Psplat[0] = ssef(P.x);
Psplat[1] = ssef(P.y);
Psplat[2] = ssef(P.z);
ssef tsplat(0.0f, 0.0f, -isect->t, -isect->t);
gen_idirsplat_swap(pn, shuf_identity, shuf_swap, idir, idirsplat, shufflexyz);
#endif
Cycles: Implement watertight ray/triangle intersection Using this paper: Sven Woop, Watertight Ray/Triangle Intersection http://jcgt.org/published/0002/01/05/paper.pdf This change is expected to address quite reasonable amount of reports from the bug tracker, plus it might help reducing the noise in some scenes. Unfortunately, it's currently about 7% slower than the previous solution with pre-computed triangle plane equations, but maybe with some smart tweaks to the code (tests reshuffle, using SIMD in a nice way or so) we can avoid the speed regression. But perhaps smartest thing to do here would be to change single triangle / ray intersection with multiple triangles / ray intersections. That's how Embree does this and it's watertight single ray intersection is not any faster that this. Currently only triangle intersection is modified accordingly to the paper, in the future we would also want to modify the node / ray intersection. Reviewers: brecht, juicyfruit Subscribers: dingto, ton Differential Revision: https://developer.blender.org/D819
2014-12-15 16:18:01 +00:00
IsectPrecalc isect_precalc;
triangle_intersect_precalc(dir, &isect_precalc);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
/* traversal loop */
do {
do {
/* traverse internal nodes */
while(nodeAddr >= 0 && nodeAddr != ENTRYPOINT_SENTINEL) {
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
int nodeAddrChild1, traverse_mask;
float dist[2];
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
#if !defined(__KERNEL_SSE2__)
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
traverse_mask = NODE_INTERSECT(kg,
P,
# if BVH_FEATURE(BVH_HAIR)
dir,
# endif
idir,
isect->t,
nodeAddr,
visibility,
dist);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
#else // __KERNEL_SSE2__
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
traverse_mask = NODE_INTERSECT(kg,
P,
dir,
# if BVH_FEATURE(BVH_HAIR)
tnear,
tfar,
# endif
tsplat,
Psplat,
idirsplat,
shufflexyz,
nodeAddr,
visibility,
dist);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
#endif // __KERNEL_SSE2__
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
nodeAddr = __float_as_int(cnodes.z);
nodeAddrChild1 = __float_as_int(cnodes.w);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
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(traverse_mask == 3) {
/* Both children were intersected, push the farther one. */
bool closestChild1 = (dist[1] < dist[0]);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
if(closestChild1) {
int tmp = nodeAddr;
nodeAddr = nodeAddrChild1;
nodeAddrChild1 = tmp;
}
++stackPtr;
Cycles: Add asserts around BVH stack pushes This way we're kind of safer to troubleshoot possible stack overflow issues.
2014-12-29 09:00:25 +00:00
kernel_assert(stackPtr < BVH_STACK_SIZE);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
traversalStack[stackPtr] = nodeAddrChild1;
}
else {
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
/* One child was intersected. */
if(traverse_mask == 2) {
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
nodeAddr = nodeAddrChild1;
}
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 if(traverse_mask == 0) {
/* Neither child was intersected. */
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
nodeAddr = traversalStack[stackPtr];
--stackPtr;
}
}
}
/* if node is leaf, fetch triangle list */
if(nodeAddr < 0) {
Cycles: Switch node address to absolute values in BVH tree This seems to be straightforward way to support heterogeneous nodes in the same tree. There is some penalty related on 4gig limit of the address space now, but here's are the thing: Traversal code was already using ints to store final offset, so there can't be regressions really. This is a required commit to make it possible to encode both aligned and unaligned nodes in the same array. Also, in the future we can use this to get rid of __leaf_nodes array (which is a bit tricky to do since trickery in pack_instances().
2016-06-14 12:29:09 +00:00
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
int primAddr = __float_as_int(leaf.x);
Cycles: Code cleanup, de-duplicate definition of FEATURE Previously every BVH traversal file was defining macro to check which features should be compiled in, now this macro is defined in the parent header.
2014-12-24 19:10:17 +00:00
#if BVH_FEATURE(BVH_INSTANCING)
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
if(primAddr >= 0) {
#endif
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 int primAddr2 = __float_as_int(leaf.y);
const uint type = __float_as_int(leaf.w);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
/* pop */
nodeAddr = traversalStack[stackPtr];
--stackPtr;
/* 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: {
/* intersect ray against primitive */
for(; primAddr < primAddr2; primAddr++) {
Cycles: Add leaf primitives sanity check asserts to the kernel This way we'll notice that leaf splitting didn't happen correct pretty easily in debug builds. There'll be absolutely no impact on release builds.
2015-01-11 21:04:35 +00:00
kernel_assert(kernel_tex_fetch(__prim_type, primAddr) == 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
/* only primitives from volume object */
uint tri_object = (object == OBJECT_NONE)? kernel_tex_fetch(__prim_object, primAddr): object;
int object_flag = kernel_tex_fetch(__object_flag, tri_object);
if((object_flag & SD_OBJECT_HAS_VOLUME) == 0) {
continue;
}
Cycles: Remove unused direction from triangle intersection functions This argument was unused and got nicely optimized out. But once it starts to be using registers are getting stressed really crazy, causing slow down of render.
2015-04-01 16:08:12 +00:00
triangle_intersect(kg, &isect_precalc, isect, P, visibility, object, primAddr);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +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: Code cleanup, de-duplicate definition of FEATURE Previously every BVH traversal file was defining macro to check which features should be compiled in, now this macro is defined in the parent header.
2014-12-24 19:10:17 +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: {
/* intersect ray against primitive */
for(; primAddr < primAddr2; primAddr++) {
Cycles: Add leaf primitives sanity check asserts to the kernel This way we'll notice that leaf splitting didn't happen correct pretty easily in debug builds. There'll be absolutely no impact on release builds.
2015-01-11 21:04:35 +00:00
kernel_assert(kernel_tex_fetch(__prim_type, primAddr) == 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
/* only primitives from volume object */
uint tri_object = (object == OBJECT_NONE)? kernel_tex_fetch(__prim_object, primAddr): object;
int object_flag = kernel_tex_fetch(__object_flag, tri_object);
if((object_flag & SD_OBJECT_HAS_VOLUME) == 0) {
continue;
}
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
motion_triangle_intersect(kg, isect, P, dir, ray->time, visibility, object, primAddr);
}
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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
#endif
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
default: {
break;
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
}
}
}
Cycles: Code cleanup, de-duplicate definition of FEATURE Previously every BVH traversal file was defining macro to check which features should be compiled in, now this macro is defined in the parent header.
2014-12-24 19:10:17 +00:00
#if BVH_FEATURE(BVH_INSTANCING)
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
else {
/* instance push */
object = kernel_tex_fetch(__prim_object, -primAddr-1);
int object_flag = kernel_tex_fetch(__object_flag, object);
if(object_flag & SD_OBJECT_HAS_VOLUME) {
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_push(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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
bvh_instance_push(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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
Cycles: Implement watertight ray/triangle intersection Using this paper: Sven Woop, Watertight Ray/Triangle Intersection http://jcgt.org/published/0002/01/05/paper.pdf This change is expected to address quite reasonable amount of reports from the bug tracker, plus it might help reducing the noise in some scenes. Unfortunately, it's currently about 7% slower than the previous solution with pre-computed triangle plane equations, but maybe with some smart tweaks to the code (tests reshuffle, using SIMD in a nice way or so) we can avoid the speed regression. But perhaps smartest thing to do here would be to change single triangle / ray intersection with multiple triangles / ray intersections. That's how Embree does this and it's watertight single ray intersection is not any faster that this. Currently only triangle intersection is modified accordingly to the paper, in the future we would also want to modify the node / ray intersection. Reviewers: brecht, juicyfruit Subscribers: dingto, ton Differential Revision: https://developer.blender.org/D819
2014-12-15 16:18:01 +00:00
triangle_intersect_precalc(dir, &isect_precalc);
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 defined(__KERNEL_SSE2__)
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
Psplat[0] = ssef(P.x);
Psplat[1] = ssef(P.y);
Psplat[2] = ssef(P.z);
tsplat = ssef(0.0f, 0.0f, -isect->t, -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)
tfar = ssef(isect->t);
# endif
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
gen_idirsplat_swap(pn, shuf_identity, shuf_swap, idir, idirsplat, shufflexyz);
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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
++stackPtr;
Cycles: Add asserts around BVH stack pushes This way we're kind of safer to troubleshoot possible stack overflow issues.
2014-12-29 09:00:25 +00:00
kernel_assert(stackPtr < BVH_STACK_SIZE);
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
traversalStack[stackPtr] = ENTRYPOINT_SENTINEL;
nodeAddr = kernel_tex_fetch(__object_node, object);
}
else {
/* pop */
Fix T42411: Camera inside volume + particle dupli (object/group) doesn't work The issue was caused by missing current object instance initialization after object was ignored for instance push.
2014-11-04 18:55:05 +00:00
object = OBJECT_NONE;
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
nodeAddr = traversalStack[stackPtr];
--stackPtr;
}
}
}
Cycles; Code cleanup, make it more obvious what #endif belongs to
2014-12-22 17:51:59 +00:00
#endif /* FEATURE(BVH_INSTANCING) */
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
} while(nodeAddr != ENTRYPOINT_SENTINEL);
Cycles: Code cleanup, de-duplicate definition of FEATURE Previously every BVH traversal file was defining macro to check which features should be compiled in, now this macro is defined in the parent header.
2014-12-24 19:10:17 +00:00
#if BVH_FEATURE(BVH_INSTANCING)
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
if(stackPtr >= 0) {
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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
Cycles: Implement watertight ray/triangle intersection Using this paper: Sven Woop, Watertight Ray/Triangle Intersection http://jcgt.org/published/0002/01/05/paper.pdf This change is expected to address quite reasonable amount of reports from the bug tracker, plus it might help reducing the noise in some scenes. Unfortunately, it's currently about 7% slower than the previous solution with pre-computed triangle plane equations, but maybe with some smart tweaks to the code (tests reshuffle, using SIMD in a nice way or so) we can avoid the speed regression. But perhaps smartest thing to do here would be to change single triangle / ray intersection with multiple triangles / ray intersections. That's how Embree does this and it's watertight single ray intersection is not any faster that this. Currently only triangle intersection is modified accordingly to the paper, in the future we would also want to modify the node / ray intersection. Reviewers: brecht, juicyfruit Subscribers: dingto, ton Differential Revision: https://developer.blender.org/D819
2014-12-15 16:18:01 +00:00
triangle_intersect_precalc(dir, &isect_precalc);
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 defined(__KERNEL_SSE2__)
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
Psplat[0] = ssef(P.x);
Psplat[1] = ssef(P.y);
Psplat[2] = ssef(P.z);
tsplat = ssef(0.0f, 0.0f, -isect->t, -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)
tfar = ssef(isect->t);
# endif
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
gen_idirsplat_swap(pn, shuf_identity, shuf_swap, idir, idirsplat, shufflexyz);
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: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
object = OBJECT_NONE;
nodeAddr = traversalStack[stackPtr];
--stackPtr;
}
Cycles; Code cleanup, make it more obvious what #endif belongs to
2014-12-22 17:51:59 +00:00
#endif /* FEATURE(BVH_MOTION) */
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
} while(nodeAddr != ENTRYPOINT_SENTINEL);
return (isect->prim != PRIM_NONE);
}
Cycles: Rework BVH functions calls a little bit Basic idea is to allow multiple implementation per feature-set, meaning this commit tries to make it easier to hook new algorithms for BVH traversal.
2014-12-24 19:06:49 +00:00
ccl_device_inline bool BVH_FUNCTION_NAME(KernelGlobals *kg,
const Ray *ray,
Cycles: Fix wrong camera in volume check when domain is only visible to camera rays
2016-04-04 17:30:38 +00:00
Intersection *isect,
const uint visibility)
Cycles: Rework BVH functions calls a little bit Basic idea is to allow multiple implementation per feature-set, meaning this commit tries to make it easier to hook new algorithms for BVH traversal.
2014-12-24 19:06: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
#ifdef __QBVH__
if(kernel_data.bvh.use_qbvh) {
return BVH_FUNCTION_FULL_NAME(QBVH)(kg,
ray,
Cycles: Fix wrong camera in volume check when domain is only visible to camera rays
2016-04-04 17:30:38 +00:00
isect,
visibility);
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
#endif
{
Cycles: Add some sanity check asserts in the traversal code This way we'll be sure (in debug builds) that regular BVH traversal is not used for QBVH tree (could happen because of mismatch of logic in kernel and render).
2014-12-29 08:34:10 +00:00
kernel_assert(kernel_data.bvh.use_qbvh == false);
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 BVH_FUNCTION_FULL_NAME(BVH)(kg,
ray,
Cycles: Fix wrong camera in volume check when domain is only visible to camera rays
2016-04-04 17:30:38 +00:00
isect,
visibility);
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: Rework BVH functions calls a little bit Basic idea is to allow multiple implementation per feature-set, meaning this commit tries to make it easier to hook new algorithms for BVH traversal.
2014-12-24 19:06:49 +00:00
}
Cycles: Speedup of kernel side camera-in-volume detection The idea is to only count intersections with objects which has volumetric shader and ignore all other objects. This is probably as fast as we can go without involving some forth level magic.
2014-10-02 21:42:16 +00:00
#undef BVH_FUNCTION_NAME
#undef BVH_FUNCTION_FEATURES
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
Copy Permalink