sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity
90b9fa3608
blender/intern/cycles/kernel/kernel_bvh_traversal.h

350 lines
12 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)
__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
* - SSE for hair
* - 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 */
const float tmax = ray->t;
float3 P = ray->P;
float3 idir = bvh_inverse_direction(ray->D);
int object = ~0;
#if FEATURE(BVH_MOTION)
Transform ob_tfm;
#endif
isect->t = tmax;
isect->object = ~0;
isect->prim = ~0;
isect->u = 0.0f;
isect->v = 0.0f;
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
#if defined(__KERNEL_SSE2__) && !FEATURE(BVH_HAIR_MINIMUM_WIDTH)
const shuffle_swap_t shuf_identity = shuffle_swap_identity();
const shuffle_swap_t shuf_swap = shuffle_swap_swap();
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
const __m128i pn = _mm_set_epi32(0x80000000, 0x80000000, 0x00000000, 0x00000000);
__m128 Psplat[3], idirsplat[3];
Psplat[0] = _mm_set_ps1(P.x);
Psplat[1] = _mm_set_ps1(P.y);
Psplat[2] = _mm_set_ps1(P.z);
idirsplat[0] = _mm_xor_ps(_mm_set_ps1(idir.x), _mm_castsi128_ps(pn));
idirsplat[1] = _mm_xor_ps(_mm_set_ps1(idir.y), _mm_castsi128_ps(pn));
idirsplat[2] = _mm_xor_ps(_mm_set_ps1(idir.z), _mm_castsi128_ps(pn));
__m128 tsplat = _mm_set_ps(-isect->t, -isect->t, 0.0f, 0.0f);
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
shuffle_swap_t shufflex = (idir.x >= 0)? shuf_identity: shuf_swap;
shuffle_swap_t shuffley = (idir.y >= 0)? shuf_identity: shuf_swap;
shuffle_swap_t shufflez = (idir.z >= 0)? shuf_identity: shuf_swap;
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 {
do
{
/* traverse internal nodes */
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: 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
#if !defined(__KERNEL_SSE2__) || 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
/* 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 */
__m128 *bvh_nodes = (__m128*)kg->__bvh_nodes.data + nodeAddr*BVH_NODE_SIZE;
float4 cnodes = ((float4*)bvh_nodes)[3];
/* intersect ray against child nodes */
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 __m128 tminmaxx = _mm_mul_ps(_mm_sub_ps(shuffle_swap(bvh_nodes[0], shufflex), Psplat[0]), idirsplat[0]);
const __m128 tminmaxy = _mm_mul_ps(_mm_sub_ps(shuffle_swap(bvh_nodes[1], shuffley), Psplat[1]), idirsplat[1]);
const __m128 tminmaxz = _mm_mul_ps(_mm_sub_ps(shuffle_swap(bvh_nodes[2], shufflez), 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
const __m128 tminmax = _mm_xor_ps(_mm_max_ps(_mm_max_ps(tminmaxx, tminmaxy), _mm_max_ps(tminmaxz, tsplat)), _mm_castsi128_ps(pn));
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 __m128 lrhit = _mm_cmple_ps(tminmax, shuffle_swap(tminmax, shuf_swap));
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? */
traverseChild0 = (_mm_movemask_ps(lrhit) & 1) && (__float_as_uint(cnodes.z) & visibility);
traverseChild1 = (_mm_movemask_ps(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: 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 = (_mm_movemask_ps(lrhit) & 1);
traverseChild1 = (_mm_movemask_ps(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: 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
#if !defined(__KERNEL_SSE2__) || 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
bool closestChild1 = (c1min < c0min);
#else
union { __m128 m128; float v[4]; } uminmax;
uminmax.m128 = tminmax;
bool closestChild1 = uminmax.v[1] < uminmax.v[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: 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: 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
/* intersect ray against primitive */
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: 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
uint segment = kernel_tex_fetch(__prim_segment, primAddr);
if(segment != ~0) {
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: 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(kernel_data.curve.curveflags & CURVE_KN_INTERPOLATE)
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_MINIMUM_WIDTH)
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
hit = bvh_cardinal_curve_intersect(kg, isect, P, idir, visibility, object, primAddr, segment, lcg_state, difl, extmax);
else
hit = bvh_curve_intersect(kg, isect, P, idir, visibility, object, primAddr, segment, lcg_state, difl, 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
#else
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
hit = bvh_cardinal_curve_intersect(kg, isect, P, idir, visibility, object, primAddr, segment);
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: 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
hit = bvh_curve_intersect(kg, isect, P, idir, visibility, object, primAddr, segment);
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: 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
#endif
hit = bvh_triangle_intersect(kg, isect, P, idir, visibility, object, primAddr);
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: 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
#if defined(__KERNEL_SSE2__) && !FEATURE(BVH_HAIR_MINIMUM_WIDTH)
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: 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
tsplat = _mm_set_ps(-isect->t, -isect->t, 0.0f, 0.0f);
}
#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: 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
bvh_instance_motion_push(kg, object, ray, &P, &idir, &isect->t, &ob_tfm, tmax);
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: 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
bvh_instance_push(kg, object, ray, &P, &idir, &isect->t, tmax);
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: 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
#if defined(__KERNEL_SSE2__) && !FEATURE(BVH_HAIR_MINIMUM_WIDTH)
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
Psplat[0] = _mm_set_ps1(P.x);
Psplat[1] = _mm_set_ps1(P.y);
Psplat[2] = _mm_set_ps1(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: 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
idirsplat[0] = _mm_xor_ps(_mm_set_ps1(idir.x), _mm_castsi128_ps(pn));
idirsplat[1] = _mm_xor_ps(_mm_set_ps1(idir.y), _mm_castsi128_ps(pn));
idirsplat[2] = _mm_xor_ps(_mm_set_ps1(idir.z), _mm_castsi128_ps(pn));
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: 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
tsplat = _mm_set_ps(-isect->t, -isect->t, 0.0f, 0.0f);
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: 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
shufflex = (idir.x >= 0)? shuf_identity: shuf_swap;
shuffley = (idir.y >= 0)? shuf_identity: shuf_swap;
shufflez = (idir.z >= 0)? shuf_identity: shuf_swap;
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) {
kernel_assert(object != ~0);
/* instance pop */
#if FEATURE(BVH_MOTION)
bvh_instance_motion_pop(kg, object, ray, &P, &idir, &isect->t, &ob_tfm, tmax);
#else
bvh_instance_pop(kg, object, ray, &P, &idir, &isect->t, tmax);
#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: 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
#if defined(__KERNEL_SSE2__) && !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
Psplat[0] = _mm_set_ps1(P.x);
Psplat[1] = _mm_set_ps1(P.y);
Psplat[2] = _mm_set_ps1(P.z);
idirsplat[0] = _mm_xor_ps(_mm_set_ps1(idir.x), _mm_castsi128_ps(pn));
idirsplat[1] = _mm_xor_ps(_mm_set_ps1(idir.y), _mm_castsi128_ps(pn));
idirsplat[2] = _mm_xor_ps(_mm_set_ps1(idir.z), _mm_castsi128_ps(pn));
tsplat = _mm_set_ps(-isect->t, -isect->t, 0.0f, 0.0f);
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
shufflex = (idir.x >= 0)? shuf_identity: shuf_swap;
shuffley = (idir.y >= 0)? shuf_identity: shuf_swap;
shufflez = (idir.z >= 0)? shuf_identity: shuf_swap;
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
object = ~0;
nodeAddr = traversalStack[stackPtr];
--stackPtr;
}
#endif
} while(nodeAddr != ENTRYPOINT_SENTINEL);
return (isect->prim != ~0);
}
#undef FEATURE
#undef BVH_FUNCTION_NAME
#undef BVH_FUNCTION_FEATURES
Copy Permalink