Commit: c6cfa45f67f7a9a60d1d2c650d611c326345c472
Author: Sergey Sharybin
Date:   Fri Jun 17 14:26:03 2016 +0200
Branches: cycles_bvh
https://developer.blender.org/rBc6cfa45f67f7a9a60d1d2c650d611c326345c472

Cycles: Hook up intersectors to non-SSE2 BVH traversal

Seems to be passing regression tests on CPU. CUDA kernels also seems to work 
fine.

===================================================================

M       intern/cycles/kernel/geom/geom_bvh_nodes.h
M       intern/cycles/kernel/geom/geom_bvh_shadow.h
M       intern/cycles/kernel/geom/geom_bvh_subsurface.h
M       intern/cycles/kernel/geom/geom_bvh_traversal.h
M       intern/cycles/kernel/geom/geom_bvh_volume.h
M       intern/cycles/kernel/geom/geom_bvh_volume_all.h

===================================================================

diff --git a/intern/cycles/kernel/geom/geom_bvh_nodes.h 
b/intern/cycles/kernel/geom/geom_bvh_nodes.h
index f7b9cec..c622d7a 100644
--- a/intern/cycles/kernel/geom/geom_bvh_nodes.h
+++ b/intern/cycles/kernel/geom/geom_bvh_nodes.h
@@ -273,14 +273,14 @@ ccl_device_inline int 
bvh_unaligned_node_intersect_robust(KernelGlobals *kg,
        return mask;
 }
 
-ccl_device_inline int bvh_curve_intersect_node(KernelGlobals *kg,
-                                               const float3 P,
-                                               const float3 dir,
-                                               const float3 idir,
-                                               const float t,
-                                               const uint visibility,
-                                               int nodeAddr,
-                                               float dist[2])
+ccl_device_inline int bvh_node_intersect(KernelGlobals *kg,
+                                         const float3 P,
+                                         const float3 dir,
+                                         const float3 idir,
+                                         const float t,
+                                         const uint visibility,
+                                         int nodeAddr,
+                                         float dist[2])
 {
        float4 node = kernel_tex_fetch(__bvh_nodes, nodeAddr);
        if(__float_as_uint(node.x) & PATH_RAY_NODE_UNALIGNED) {
@@ -304,15 +304,15 @@ ccl_device_inline int 
bvh_curve_intersect_node(KernelGlobals *kg,
        }
 }
 
-ccl_device_inline int bvh_curve_intersect_node_robust(KernelGlobals *kg,
-                                                      const float3 P,
-                                                      const float3 dir,
-                                                      const float3 idir,
-                                                      const float t,
-                                                      const float difl,
-                                                      const uint visibility,
-                                                      int nodeAddr,
-                                                      float dist[2])
+ccl_device_inline int bvh_node_intersect_robust(KernelGlobals *kg,
+                                                const float3 P,
+                                                const float3 dir,
+                                                const float3 idir,
+                                                const float t,
+                                                const float difl,
+                                                const uint visibility,
+                                                int nodeAddr,
+                                                float dist[2])
 {
        float4 node = kernel_tex_fetch(__bvh_nodes, nodeAddr);
        if(__float_as_uint(node.x) & PATH_RAY_NODE_UNALIGNED) {
@@ -458,14 +458,14 @@ int ccl_device_inline bvh_aligned_node_intersect_robust(
 #  endif
 }
 
-int ccl_device bvh_unaligned_node_intersect(KernelGlobals *kg,
-                                            const float3 P,
-                                            const float3 dir,
-                                            const ssef& tnear,
-                                            const ssef& tfar,
-                                            const uint visibility,
-                                            int nodeAddr,
-                                            float dist[2])
+int ccl_device_inline bvh_unaligned_node_intersect(KernelGlobals *kg,
+                                                   const float3 P,
+                                                   const float3 dir,
+                                                   const ssef& tnear,
+                                                   const ssef& tfar,
+                                                   const uint visibility,
+                                                   int nodeAddr,
+                                                   float dist[2])
 {
        Transform space0 = bvh_unaligned_node_fetch_space(kg, nodeAddr, 0);
        Transform space1 = bvh_unaligned_node_fetch_space(kg, nodeAddr, 1);
@@ -519,15 +519,15 @@ int ccl_device bvh_unaligned_node_intersect(KernelGlobals 
*kg,
 #  endif
 }
 
-int ccl_device bvh_unaligned_node_intersect_robust(KernelGlobals *kg,
-                                                   const float3 P,
-                                                   const float3 dir,
-                                                   const ssef& tnear,
-                                                   const ssef& tfar,
-                                                   const float difl,
-                                                   const uint visibility,
-                                                   int nodeAddr,
-                                                   float dist[2])
+int ccl_device_inline bvh_unaligned_node_intersect_robust(KernelGlobals *kg,
+                                                          const float3 P,
+                                                          const float3 dir,
+                                                          const ssef& tnear,
+                                                          const ssef& tfar,
+                                                          const float difl,
+                                                          const uint 
visibility,
+                                                          int nodeAddr,
+                                                          float dist[2])
 {
        Transform space0 = bvh_unaligned_node_fetch_space(kg, nodeAddr, 0);
        Transform space1 = bvh_unaligned_node_fetch_space(kg, nodeAddr, 1);
diff --git a/intern/cycles/kernel/geom/geom_bvh_shadow.h 
b/intern/cycles/kernel/geom/geom_bvh_shadow.h
index 0d4e9cf..cbc92c0 100644
--- a/intern/cycles/kernel/geom/geom_bvh_shadow.h
+++ b/intern/cycles/kernel/geom/geom_bvh_shadow.h
@@ -100,6 +100,14 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals 
*kg,
                                float4 cnodes = kernel_tex_fetch(__bvh_nodes, 
nodeAddr+0);
 
 #if !defined(__KERNEL_SSE2__)
+                               traverse_mask = bvh_node_intersect(kg,
+                                                                  P,
+                                                                  dir,
+                                                                  idir,
+                                                                  isect_t,
+                                                                  
PATH_RAY_SHADOW,
+                                                                  nodeAddr,
+                                                                  dist);
 #else // __KERNEL_SSE2__
                                traverse_mask = bvh_node_intersect(kg,
                                                                   P,
diff --git a/intern/cycles/kernel/geom/geom_bvh_subsurface.h 
b/intern/cycles/kernel/geom/geom_bvh_subsurface.h
index 514c0f4..f42cca0 100644
--- a/intern/cycles/kernel/geom/geom_bvh_subsurface.h
+++ b/intern/cycles/kernel/geom/geom_bvh_subsurface.h
@@ -109,6 +109,14 @@ ccl_device void BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals 
*kg,
                                float4 cnodes = kernel_tex_fetch(__bvh_nodes, 
nodeAddr+0);
 
 #if !defined(__KERNEL_SSE2__)
+                               traverse_mask = bvh_node_intersect(kg,
+                                                                  P,
+                                                                  dir,
+                                                                  idir,
+                                                                  isect_t,
+                                                                  
PATH_RAY_ALL_VISIBILITY,
+                                                                  nodeAddr,
+                                                                  dist);
 #else // __KERNEL_SSE2__
                                traverse_mask = bvh_node_intersect(kg,
                                                                   P,
diff --git a/intern/cycles/kernel/geom/geom_bvh_traversal.h 
b/intern/cycles/kernel/geom/geom_bvh_traversal.h
index add8fce..c6c41b5 100644
--- a/intern/cycles/kernel/geom/geom_bvh_traversal.h
+++ b/intern/cycles/kernel/geom/geom_bvh_traversal.h
@@ -109,10 +109,27 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals 
*kg,
 #if !defined(__KERNEL_SSE2__)
 #  if BVH_FEATURE(BVH_HAIR_MINIMUM_WIDTH)
                                if(difl != 0.0f) {
+                                       traverse_mask = 
bvh_node_intersect_robust(kg,
+                                                                               
  P,
+                                                                               
  dir,
+                                                                               
  idir,
+                                                                               
  isect->t,
+                                                                               
  difl,
+                                                                               
  visibility,
+                                                                               
  nodeAddr,
+                                                                               
  dist);
                                }
                                else
 #  endif
                                {
+                                       traverse_mask = bvh_node_intersect(kg,
+                                                                          P,
+                                                                          dir,
+                                                                          idir,
+                                                                          
isect->t,
+                                                                          
visibility,
+                                                                          
nodeAddr,
+                                                                          
dist);
                                }
 #else // __KERNEL_SSE2__
 #  if BVH_FEATURE(BVH_HAIR_MINIMUM_WIDTH)
diff --git a/intern/cycles/kernel/geom/geom_bvh_volume.h 
b/intern/cycles/kernel/geom/geom_bvh_volume.h
index 31dd238..7da8b7e 100644
--- a/intern/cycles/kernel/geom/geom_bvh_volume.h
+++ b/intern/cycles/kernel/geom/geom_bvh_volume.h
@@ -97,6 +97,14 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals 
*kg,
                                float4 cnodes = kernel_tex_fetch(__bvh_nodes, 
nodeAddr+0);
 
 #if !defined(__KERNEL_SSE2__)
+                               traverse_mask = bvh_node_intersect(kg,
+                                                                  P,
+                                                                  dir,
+                                                                  idir,
+                                                                  isect->t,
+                                                                  visibility,
+                                                                  nodeAddr,
+                                                                  dist);
 #else // __KERNEL_SSE2__
                                traverse_mask = bvh_node_intersect(kg,
                                                                   P,
diff --git a/intern/cycles/kernel/geom/geom_bvh_volume_all.h 
b/intern/cycles/kernel/geom/geom_bvh_volume_all.h
index 13c54d1..07b12b8 100644
--- a/intern/cycles/kernel/geom/geom_bvh_volume_all.h
+++ b/intern/cycles/kernel/geom/geom_bvh_volume_all.h
@@ -101,6 +101,14 @@ ccl_device uint BVH_FU

@@ Diff output truncated at 10240 characters. @@

_______________________________________________
Bf-blender-cvs mailing list
[email protected]
https://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to