kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity
44fc0ddee9
blender/intern/cycles/kernel/geom/geom_bvh_traversal.h

358 lines
11 KiB
C
Raw Normal View History

Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
/*
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
* Adapted from code Copyright 2009-2010 NVIDIA Corporation,
* and code copyright 2009-2012 Intel Corporation
*
* Modifications Copyright 2011-2013, Blender Foundation.
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +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
*
*/
#define FEATURE(f) (((BVH_FUNCTION_FEATURES) & (f)) != 0)
Cycles: change __device and similar qualifiers to ccl_device in kernel code. This to avoids build conflicts with libc++ on FreeBSD, these __ prefixed values are reserved for compilers. I apologize to anyone who has patches or branches and has to go through the pain of merging this change, it may be easiest to do these same replacements in your code and then apply/merge the patch. Ref T37477.
2013-11-15 23:17:10 +00:00
ccl_device bool BVH_FUNCTION_NAME
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
(KernelGlobals *kg, const Ray *ray, Intersection *isect, const uint visibility
#if FEATURE(BVH_HAIR_MINIMUM_WIDTH)
Cycles OpenCL: fix other build issues when enabling more features.
2013-05-09 15:28:38 +00:00
, uint *lcg_state, float difl, float extmax
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#endif
)
{
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +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
*/
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
/* 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 */
Cycles: fix crash in SSE hair and half-floats on x86+vc2008 MSVC 2008 ignores alignement attribute when assigning from unaligned float4 vector, returned from other function. Now Cycles uses unaligned loads instead of casts for win32 in x86 mode.
2014-02-27 10:49:21 +00:00
float3 P = ray->P;
Cycles: avoid 1.0f/(1.0f/x) divisions, which msvc (only) can't optimize. This makes bmw scene in msvc 12 builds 6% faster. It also gives a minor speedup for SSE hair in all compilers.
2014-04-03 18:08:53 +00:00
float3 dir = bvh_clamp_direction(ray->D);
float3 idir = bvh_inverse_direction(dir);
Cycles code refactor: replace magic ~0 values in the code with defines.
2014-03-29 12:03:47 +00:00
int object = OBJECT_NONE;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#if FEATURE(BVH_MOTION)
Transform ob_tfm;
#endif
Cycles: shadow function optimization for transparent shadows (CPU only). Old algorithm: Raytrace from one transparent surface to the next step by step. To minimize overhead in cases where we don't need transparent shadows, we first trace a regular shadow ray. We check if the hit primitive was potentially transparent, and only in that case start marching. this gives extra ray cast for the cases were we do want transparency. New algorithm: We trace a single ray. If it hits any opaque surface, or more than a given number of transparent surfaces is hit, then we consider the geometry to be entirely blocked. If not, all transparent surfaces will be recorded and we will shade them one by one to determine how much light is blocked. This all happens in one scene intersection function. Recording all hits works well in some cases but may be slower in others. If we have many semi-transparent hairs, one intersection may be faster because you'd be reinteresecting the same hairs a lot with each step otherwise. If however there is mostly binary transparency then we may be recording many unnecessary intersections when one of the first surfaces blocks all light. We found that this helps quite nicely in some scenes, on koro.blend this can give a 50% reduction in render time, on the pabellon barcelona scene and a forest scene with transparent leaves it was 30%. Some other files rendered maybe 1% or 2% slower, but this seems a reasonable tradeoff. Differential Revision: https://developer.blender.org/D473
2014-04-19 15:02:30 +00:00
isect->t = ray->t;
Cycles code refactor: replace magic ~0 values in the code with defines.
2014-03-29 12:03:47 +00:00
isect->object = OBJECT_NONE;
isect->prim = PRIM_NONE;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
isect->u = 0.0f;
isect->v = 0.0f;
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
#if defined(__KERNEL_SSE2__)
Cycles: optimized SSE BVH traversal now also works with SSE2 CPUs, so all the way back to Pentium 4, using a slightly less efficient instruction. Also ensure /Ox is used for Visual Studio for RelWithDebInfo builds.
2013-06-19 17:54:26 +00:00
const shuffle_swap_t shuf_identity = shuffle_swap_identity();
const shuffle_swap_t shuf_swap = shuffle_swap_swap();
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
const ssef pn = cast(ssei(0, 0, 0x80000000, 0x80000000));
ssef Psplat[3], idirsplat[3];
Cycles: small optimization for SSE 4.1 bvh intersector Gives 0.7% - 1.3% speedup for BMW1M-MikePan scene. Reviewers: juicyfruit Differential Revision: https://developer.blender.org/D280
2014-02-03 16:46:13 +00:00
shuffle_swap_t shufflexyz[3];
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
Psplat[0] = ssef(P.x);
Psplat[1] = ssef(P.y);
Psplat[2] = ssef(P.z);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
ssef tsplat(0.0f, 0.0f, -isect->t, -isect->t);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles: small optimization for SSE 4.1 bvh intersector Gives 0.7% - 1.3% speedup for BMW1M-MikePan scene. Reviewers: juicyfruit Differential Revision: https://developer.blender.org/D280
2014-02-03 16:46:13 +00:00
gen_idirsplat_swap(pn, shuf_identity, shuf_swap, idir, idirsplat, shufflexyz);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
#endif
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
/* traversal loop */
do {
Code cleanup
2014-05-05 02:29:28 +00:00
do {
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
/* traverse internal nodes */
Code cleanup
2014-05-05 02:29:28 +00:00
while(nodeAddr >= 0 && nodeAddr != ENTRYPOINT_SENTINEL) {
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
bool traverseChild0, traverseChild1;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
int nodeAddrChild1;
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
#if !defined(__KERNEL_SSE2__)
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
/* Intersect two child bounding boxes, non-SSE version */
Fix cycles crash on some processors. We actually need S-SSE3 support for this new BVH traversal code, not just SSE3.
2013-06-18 16:52:02 +00:00
float t = isect->t;
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
/* fetch node data */
float4 node0 = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_NODE_SIZE+0);
float4 node1 = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_NODE_SIZE+1);
float4 node2 = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_NODE_SIZE+2);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_NODE_SIZE+3);
/* intersect ray against child nodes */
NO_EXTENDED_PRECISION float c0lox = (node0.x - P.x) * idir.x;
NO_EXTENDED_PRECISION float c0hix = (node0.z - P.x) * idir.x;
NO_EXTENDED_PRECISION float c0loy = (node1.x - P.y) * idir.y;
NO_EXTENDED_PRECISION float c0hiy = (node1.z - P.y) * idir.y;
NO_EXTENDED_PRECISION float c0loz = (node2.x - P.z) * idir.z;
NO_EXTENDED_PRECISION float c0hiz = (node2.z - P.z) * idir.z;
NO_EXTENDED_PRECISION float c0min = max4(min(c0lox, c0hix), min(c0loy, c0hiy), min(c0loz, c0hiz), 0.0f);
NO_EXTENDED_PRECISION float c0max = min4(max(c0lox, c0hix), max(c0loy, c0hiy), max(c0loz, c0hiz), t);
NO_EXTENDED_PRECISION float c1lox = (node0.y - P.x) * idir.x;
NO_EXTENDED_PRECISION float c1hix = (node0.w - P.x) * idir.x;
NO_EXTENDED_PRECISION float c1loy = (node1.y - P.y) * idir.y;
NO_EXTENDED_PRECISION float c1hiy = (node1.w - P.y) * idir.y;
NO_EXTENDED_PRECISION float c1loz = (node2.y - P.z) * idir.z;
NO_EXTENDED_PRECISION float c1hiz = (node2.w - P.z) * idir.z;
NO_EXTENDED_PRECISION float c1min = max4(min(c1lox, c1hix), min(c1loy, c1hiy), min(c1loz, c1hiz), 0.0f);
NO_EXTENDED_PRECISION float c1max = min4(max(c1lox, c1hix), max(c1loy, c1hiy), max(c1loz, c1hiz), t);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
#if FEATURE(BVH_HAIR_MINIMUM_WIDTH)
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
if(difl != 0.0f) {
float hdiff = 1.0f + difl;
float ldiff = 1.0f - difl;
if(__float_as_int(cnodes.z) & PATH_RAY_CURVE) {
c0min = max(ldiff * c0min, c0min - extmax);
c0max = min(hdiff * c0max, c0max + extmax);
}
if(__float_as_int(cnodes.w) & PATH_RAY_CURVE) {
c1min = max(ldiff * c1min, c1min - extmax);
c1max = min(hdiff * c1max, c1max + extmax);
}
}
#endif
/* decide which nodes to traverse next */
#ifdef __VISIBILITY_FLAG__
/* this visibility test gives a 5% performance hit, how to solve? */
traverseChild0 = (c0max >= c0min) && (__float_as_uint(cnodes.z) & visibility);
traverseChild1 = (c1max >= c1min) && (__float_as_uint(cnodes.w) & visibility);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#else
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
traverseChild0 = (c0max >= c0min);
traverseChild1 = (c1max >= c1min);
#endif
Cycles: optimized SSE BVH traversal now also works with SSE2 CPUs, so all the way back to Pentium 4, using a slightly less efficient instruction. Also ensure /Ox is used for Visual Studio for RelWithDebInfo builds.
2013-06-19 17:54:26 +00:00
#else // __KERNEL_SSE2__
/* Intersect two child bounding boxes, SSE3 version adapted from Embree */
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
/* fetch node data */
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr*BVH_NODE_SIZE;
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
const float4 cnodes = ((float4*)bvh_nodes)[3];
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
/* intersect ray against child nodes */
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
const ssef tminmaxx = (shuffle_swap(bvh_nodes[0], shufflexyz[0]) - Psplat[0]) * idirsplat[0];
const ssef tminmaxy = (shuffle_swap(bvh_nodes[1], shufflexyz[1]) - Psplat[1]) * idirsplat[1];
const ssef tminmaxz = (shuffle_swap(bvh_nodes[2], shufflexyz[2]) - Psplat[2]) * idirsplat[2];
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
/* calculate { c0min, c1min, -c0max, -c1max} */
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
ssef minmax = max(max(tminmaxx, tminmaxy), max(tminmaxz, tsplat));
const ssef tminmax = minmax ^ pn;
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
#if FEATURE(BVH_HAIR_MINIMUM_WIDTH)
if(difl != 0.0f) {
float4 *tminmaxview = (float4*)&tminmax;
float &c0min = tminmaxview->x, &c1min = tminmaxview->y;
float &c0max = tminmaxview->z, &c1max = tminmaxview->w;
float hdiff = 1.0f + difl;
float ldiff = 1.0f - difl;
if(__float_as_int(cnodes.z) & PATH_RAY_CURVE) {
c0min = max(ldiff * c0min, c0min - extmax);
c0max = min(hdiff * c0max, c0max + extmax);
}
if(__float_as_int(cnodes.w) & PATH_RAY_CURVE) {
c1min = max(ldiff * c1min, c1min - extmax);
c1max = min(hdiff * c1max, c1max + extmax);
}
}
#endif
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
const sseb lrhit = tminmax <= shuffle<2, 3, 0, 1>(tminmax);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
/* decide which nodes to traverse next */
#ifdef __VISIBILITY_FLAG__
/* this visibility test gives a 5% performance hit, how to solve? */
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
traverseChild0 = (movemask(lrhit) & 1) && (__float_as_uint(cnodes.z) & visibility);
traverseChild1 = (movemask(lrhit) & 2) && (__float_as_uint(cnodes.w) & visibility);
Cycles OpenCL: fix other build issues when enabling more features.
2013-05-09 15:28:38 +00:00
#else
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
traverseChild0 = (movemask(lrhit) & 1);
traverseChild1 = (movemask(lrhit) & 2);
Cycles OpenCL: fix other build issues when enabling more features.
2013-05-09 15:28:38 +00:00
#endif
Cycles: optimized SSE BVH traversal now also works with SSE2 CPUs, so all the way back to Pentium 4, using a slightly less efficient instruction. Also ensure /Ox is used for Visual Studio for RelWithDebInfo builds.
2013-06-19 17:54:26 +00:00
#endif // __KERNEL_SSE2__
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
nodeAddr = __float_as_int(cnodes.x);
nodeAddrChild1 = __float_as_int(cnodes.y);
if(traverseChild0 && traverseChild1) {
/* both children were intersected, push the farther one */
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
#if !defined(__KERNEL_SSE2__)
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
bool closestChild1 = (c1min < c0min);
#else
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
bool closestChild1 = tminmax[1] < tminmax[0];
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#endif
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
if(closestChild1) {
int tmp = nodeAddr;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
nodeAddr = nodeAddrChild1;
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
nodeAddrChild1 = tmp;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
}
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
++stackPtr;
traversalStack[stackPtr] = nodeAddrChild1;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
}
else {
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
/* one child was intersected */
if(traverseChild1) {
nodeAddr = nodeAddrChild1;
}
else if(!traverseChild0) {
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
/* neither child was intersected */
nodeAddr = traversalStack[stackPtr];
--stackPtr;
}
}
}
/* if node is leaf, fetch triangle list */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_nodes, (-nodeAddr-1)*BVH_NODE_SIZE+(BVH_NODE_SIZE-1));
int primAddr = __float_as_int(leaf.x);
#if FEATURE(BVH_INSTANCING)
if(primAddr >= 0) {
#endif
int primAddr2 = __float_as_int(leaf.y);
/* pop */
nodeAddr = traversalStack[stackPtr];
--stackPtr;
/* primitive intersection */
while(primAddr < primAddr2) {
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
bool hit;
Cycles code refactor: changes to make adding new primitive types easier.
2014-03-29 12:03:46 +00:00
uint type = kernel_tex_fetch(__prim_type, primAddr);
Cycles: optimized SSE BVH traversal now also works with SSE2 CPUs, so all the way back to Pentium 4, using a slightly less efficient instruction. Also ensure /Ox is used for Visual Studio for RelWithDebInfo builds.
2013-06-19 17:54:26 +00:00
Cycles code refactor: changes to make adding new primitive types easier.
2014-03-29 12:03:46 +00:00
switch(type & PRIMITIVE_ALL) {
case PRIMITIVE_TRIANGLE: {
Cycles: avoid 1.0f/(1.0f/x) divisions, which msvc (only) can't optimize. This makes bmw scene in msvc 12 builds 6% faster. It also gives a minor speedup for SSE hair in all compilers.
2014-04-03 18:08:53 +00:00
hit = triangle_intersect(kg, isect, P, dir, visibility, object, primAddr);
Cycles code refactor: changes to make adding new primitive types easier.
2014-03-29 12:03:46 +00:00
break;
}
Cycles: avoid some CUDA performance on scenes without deformation motion blur.
2014-04-26 12:25:20 +00:00
#if FEATURE(BVH_MOTION)
Cycles: add support for mesh deformation motion blur.
2014-03-29 12:03:47 +00:00
case PRIMITIVE_MOTION_TRIANGLE: {
Cycles: avoid 1.0f/(1.0f/x) divisions, which msvc (only) can't optimize. This makes bmw scene in msvc 12 builds 6% faster. It also gives a minor speedup for SSE hair in all compilers.
2014-04-03 18:08:53 +00:00
hit = motion_triangle_intersect(kg, isect, P, dir, ray->time, visibility, object, primAddr);
Cycles: add support for mesh deformation motion blur.
2014-03-29 12:03:47 +00:00
break;
}
Cycles: avoid some CUDA performance on scenes without deformation motion blur.
2014-04-26 12:25:20 +00:00
#endif
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#if FEATURE(BVH_HAIR)
Cycles: add support for curve deformation motion blur.
2014-03-29 12:03:47 +00:00
case PRIMITIVE_CURVE:
case PRIMITIVE_MOTION_CURVE: {
Cycles code refactor: changes to make adding new primitive types easier.
2014-03-29 12:03:46 +00:00
if(kernel_data.curve.curveflags & CURVE_KN_INTERPOLATE)
Cycles: avoid 1.0f/(1.0f/x) divisions, which msvc (only) can't optimize. This makes bmw scene in msvc 12 builds 6% faster. It also gives a minor speedup for SSE hair in all compilers.
2014-04-03 18:08:53 +00:00
hit = bvh_cardinal_curve_intersect(kg, isect, P, dir, visibility, object, primAddr, ray->time, type, lcg_state, difl, extmax);
Cycles code refactor: changes to make adding new primitive types easier.
2014-03-29 12:03:46 +00:00
else
Cycles: avoid 1.0f/(1.0f/x) divisions, which msvc (only) can't optimize. This makes bmw scene in msvc 12 builds 6% faster. It also gives a minor speedup for SSE hair in all compilers.
2014-04-03 18:08:53 +00:00
hit = bvh_curve_intersect(kg, isect, P, dir, visibility, object, primAddr, ray->time, type, lcg_state, difl, extmax);
Cycles code refactor: changes to make adding new primitive types easier.
2014-03-29 12:03:46 +00:00
break;
}
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
#endif
Cycles code refactor: changes to make adding new primitive types easier.
2014-03-29 12:03:46 +00:00
default: {
hit = false;
break;
}
}
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
/* shadow ray early termination */
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
#if defined(__KERNEL_SSE2__)
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
if(hit) {
if(visibility == PATH_RAY_SHADOW_OPAQUE)
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
return true;
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
tsplat = ssef(0.0f, 0.0f, -isect->t, -isect->t);
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
}
#else
if(hit && visibility == PATH_RAY_SHADOW_OPAQUE)
return true;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#endif
primAddr++;
}
}
#if FEATURE(BVH_INSTANCING)
else {
/* instance push */
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
object = kernel_tex_fetch(__prim_object, -primAddr-1);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#if FEATURE(BVH_MOTION)
Cycles: shadow function optimization for transparent shadows (CPU only). Old algorithm: Raytrace from one transparent surface to the next step by step. To minimize overhead in cases where we don't need transparent shadows, we first trace a regular shadow ray. We check if the hit primitive was potentially transparent, and only in that case start marching. this gives extra ray cast for the cases were we do want transparency. New algorithm: We trace a single ray. If it hits any opaque surface, or more than a given number of transparent surfaces is hit, then we consider the geometry to be entirely blocked. If not, all transparent surfaces will be recorded and we will shade them one by one to determine how much light is blocked. This all happens in one scene intersection function. Recording all hits works well in some cases but may be slower in others. If we have many semi-transparent hairs, one intersection may be faster because you'd be reinteresecting the same hairs a lot with each step otherwise. If however there is mostly binary transparency then we may be recording many unnecessary intersections when one of the first surfaces blocks all light. We found that this helps quite nicely in some scenes, on koro.blend this can give a 50% reduction in render time, on the pabellon barcelona scene and a forest scene with transparent leaves it was 30%. Some other files rendered maybe 1% or 2% slower, but this seems a reasonable tradeoff. Differential Revision: https://developer.blender.org/D473
2014-04-19 15:02:30 +00:00
bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir, &isect->t, &ob_tfm);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#else
Cycles: shadow function optimization for transparent shadows (CPU only). Old algorithm: Raytrace from one transparent surface to the next step by step. To minimize overhead in cases where we don't need transparent shadows, we first trace a regular shadow ray. We check if the hit primitive was potentially transparent, and only in that case start marching. this gives extra ray cast for the cases were we do want transparency. New algorithm: We trace a single ray. If it hits any opaque surface, or more than a given number of transparent surfaces is hit, then we consider the geometry to be entirely blocked. If not, all transparent surfaces will be recorded and we will shade them one by one to determine how much light is blocked. This all happens in one scene intersection function. Recording all hits works well in some cases but may be slower in others. If we have many semi-transparent hairs, one intersection may be faster because you'd be reinteresecting the same hairs a lot with each step otherwise. If however there is mostly binary transparency then we may be recording many unnecessary intersections when one of the first surfaces blocks all light. We found that this helps quite nicely in some scenes, on koro.blend this can give a 50% reduction in render time, on the pabellon barcelona scene and a forest scene with transparent leaves it was 30%. Some other files rendered maybe 1% or 2% slower, but this seems a reasonable tradeoff. Differential Revision: https://developer.blender.org/D473
2014-04-19 15:02:30 +00:00
bvh_instance_push(kg, object, ray, &P, &dir, &idir, &isect->t);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#endif
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
#if defined(__KERNEL_SSE2__)
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
Psplat[0] = ssef(P.x);
Psplat[1] = ssef(P.y);
Psplat[2] = ssef(P.z);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
tsplat = ssef(0.0f, 0.0f, -isect->t, -isect->t);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles: small optimization for SSE 4.1 bvh intersector Gives 0.7% - 1.3% speedup for BMW1M-MikePan scene. Reviewers: juicyfruit Differential Revision: https://developer.blender.org/D280
2014-02-03 16:46:13 +00:00
gen_idirsplat_swap(pn, shuf_identity, shuf_swap, idir, idirsplat, shufflexyz);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
#endif
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
++stackPtr;
traversalStack[stackPtr] = ENTRYPOINT_SENTINEL;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
Cycles: Subsurface Scattering New features: * Bump mapping now works with SSS * Texture Blur factor for SSS, see the documentation for details: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Subsurface_Scattering Work in progress for feedback: Initial implementation of the "BSSRDF Importance Sampling" paper, which uses a different importance sampling method. It gives better quality results in many ways, with the availability of both Cubic and Gaussian falloff functions, but also tends to be more noisy when using the progressive integrator and does not give great results with some geometry. It works quite well for the non-progressive integrator and is often less noisy there. This code may still change a lot, so unless you're testing it may be best to stick to the Compatible falloff function. Skin test render and file that takes advantage of the gaussian falloff: http://www.pasteall.org/pic/show.php?id=57661 http://www.pasteall.org/pic/show.php?id=57662 http://www.pasteall.org/blend/23501
2013-08-18 14:15:57 +00:00
nodeAddr = kernel_tex_fetch(__object_node, object);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
}
}
#endif
} while(nodeAddr != ENTRYPOINT_SENTINEL);
#if FEATURE(BVH_INSTANCING)
if(stackPtr >= 0) {
Cycles code refactor: replace magic ~0 values in the code with defines.
2014-03-29 12:03:47 +00:00
kernel_assert(object != OBJECT_NONE);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
/* instance pop */
#if FEATURE(BVH_MOTION)
Cycles: shadow function optimization for transparent shadows (CPU only). Old algorithm: Raytrace from one transparent surface to the next step by step. To minimize overhead in cases where we don't need transparent shadows, we first trace a regular shadow ray. We check if the hit primitive was potentially transparent, and only in that case start marching. this gives extra ray cast for the cases were we do want transparency. New algorithm: We trace a single ray. If it hits any opaque surface, or more than a given number of transparent surfaces is hit, then we consider the geometry to be entirely blocked. If not, all transparent surfaces will be recorded and we will shade them one by one to determine how much light is blocked. This all happens in one scene intersection function. Recording all hits works well in some cases but may be slower in others. If we have many semi-transparent hairs, one intersection may be faster because you'd be reinteresecting the same hairs a lot with each step otherwise. If however there is mostly binary transparency then we may be recording many unnecessary intersections when one of the first surfaces blocks all light. We found that this helps quite nicely in some scenes, on koro.blend this can give a 50% reduction in render time, on the pabellon barcelona scene and a forest scene with transparent leaves it was 30%. Some other files rendered maybe 1% or 2% slower, but this seems a reasonable tradeoff. Differential Revision: https://developer.blender.org/D473
2014-04-19 15:02:30 +00:00
bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, &isect->t, &ob_tfm);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#else
Cycles: shadow function optimization for transparent shadows (CPU only). Old algorithm: Raytrace from one transparent surface to the next step by step. To minimize overhead in cases where we don't need transparent shadows, we first trace a regular shadow ray. We check if the hit primitive was potentially transparent, and only in that case start marching. this gives extra ray cast for the cases were we do want transparency. New algorithm: We trace a single ray. If it hits any opaque surface, or more than a given number of transparent surfaces is hit, then we consider the geometry to be entirely blocked. If not, all transparent surfaces will be recorded and we will shade them one by one to determine how much light is blocked. This all happens in one scene intersection function. Recording all hits works well in some cases but may be slower in others. If we have many semi-transparent hairs, one intersection may be faster because you'd be reinteresecting the same hairs a lot with each step otherwise. If however there is mostly binary transparency then we may be recording many unnecessary intersections when one of the first surfaces blocks all light. We found that this helps quite nicely in some scenes, on koro.blend this can give a 50% reduction in render time, on the pabellon barcelona scene and a forest scene with transparent leaves it was 30%. Some other files rendered maybe 1% or 2% slower, but this seems a reasonable tradeoff. Differential Revision: https://developer.blender.org/D473
2014-04-19 15:02:30 +00:00
bvh_instance_pop(kg, object, ray, &P, &dir, &idir, &isect->t);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
#endif
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles: mix hair minimum width code with SSE intersection code Gives 6.5% speedup for hair.blend from testsuite. This commit was previously reverted, but should work ok now. Patch by Sv. Lockal.
2014-02-11 17:41:09 +00:00
#if defined(__KERNEL_SSE2__)
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
Psplat[0] = ssef(P.x);
Psplat[1] = ssef(P.y);
Psplat[2] = ssef(P.z);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles Refactor: Add SSE Utility code from Embree for cleaner SSE code. This makes the code a bit easier to understand, and might come in handy if we want to reuse more Embree code. Differential Revision: https://developer.blender.org/D482 Code by Brecht, with fixes by Lockal, Sergey and myself.
2014-06-13 19:13:18 +00:00
tsplat = ssef(0.0f, 0.0f, -isect->t, -isect->t);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
Cycles: small optimization for SSE 4.1 bvh intersector Gives 0.7% - 1.3% speedup for BMW1M-MikePan scene. Reviewers: juicyfruit Differential Revision: https://developer.blender.org/D280
2014-02-03 16:46:13 +00:00
gen_idirsplat_swap(pn, shuf_identity, shuf_swap, idir, idirsplat, shufflexyz);
Cycles: optimization for BVH traveral on CPU's with SSE3, using code from Embree. On the BMW scene, this gives roughly a 10% speedup overall with clang/gcc, and 30% speedup with visual studio (2008). It turns out visual studio was optimizing the existing code quite poorly compared to pretty good autovectorization by clang/gcc, but hand written SSE code also gives a smaller speed boost there. This code isn't enabled when using the hair minimum width feature yet, need to make that work with the SSE code still.
2013-06-18 09:36:06 +00:00
#endif
Cycles code refactor: replace magic ~0 values in the code with defines.
2014-03-29 12:03:47 +00:00
object = OBJECT_NONE;
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
nodeAddr = traversalStack[stackPtr];
--stackPtr;
}
#endif
} while(nodeAddr != ENTRYPOINT_SENTINEL);
Cycles code refactor: replace magic ~0 values in the code with defines.
2014-03-29 12:03:47 +00:00
return (isect->prim != PRIM_NONE);
Cycles: code refactoring to deduplicate the various BVH traversal variations. Now there is a single BVH traversal code with #ifdefs for various features. At runtime it will then select the appropriate variation to use depending if instancing, hair or motion blur is in use. This makes scenes without hair render a bit faster, especially after the minimum width feature was added. It's not the most beautiful code, but we can't use c++ templates and there were already 4 copies, adding 4 more to handle the hair case separately would be too much.
2013-04-17 20:07:22 +00:00
}
#undef FEATURE
#undef BVH_FUNCTION_NAME
#undef BVH_FUNCTION_FEATURES
Copy Permalink