archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Cycles: remove __UV__ and __INSTANCING__ as kernel options

Browse Source 
The kernel did not work correctly when these were disabled anyway. The
optimized BVH traversal for the no instances case was also only used on
the CPU, so no longer makes sense to keep.

Ref T73778

Depends on D8010

Maniphest Tasks: T73778

Differential Revision: https://developer.blender.org/D8011
This commit is contained in:
Brecht Van Lommel
2020-02-23 10:15:35 +01:00
parent fed101a7be
commit 1de0e13af6
12 changed files with 58 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
intern/cycles/kernel/bvh/bvh.h
View File

@@ -51,27 +51,21 @@ CCL_NAMESPACE_BEGIN
# define BVH_FUNCTION_FEATURES 0 # define BVH_FUNCTION_FEATURES 0
# include "kernel/bvh/bvh_traversal.h" # include "kernel/bvh/bvh_traversal.h"
# if defined(__INSTANCING__)
# define BVH_FUNCTION_NAME bvh_intersect_instancing
# define BVH_FUNCTION_FEATURES BVH_INSTANCING
# include "kernel/bvh/bvh_traversal.h"
# endif
# if defined(__HAIR__) # if defined(__HAIR__)
# define BVH_FUNCTION_NAME bvh_intersect_hair # define BVH_FUNCTION_NAME bvh_intersect_hair
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_HAIR # define BVH_FUNCTION_FEATURES BVH_HAIR
# include "kernel/bvh/bvh_traversal.h" # include "kernel/bvh/bvh_traversal.h"
# endif # endif
# if defined(__OBJECT_MOTION__) # if defined(__OBJECT_MOTION__)
# define BVH_FUNCTION_NAME bvh_intersect_motion # define BVH_FUNCTION_NAME bvh_intersect_motion
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_MOTION # define BVH_FUNCTION_FEATURES BVH_MOTION
# include "kernel/bvh/bvh_traversal.h" # include "kernel/bvh/bvh_traversal.h"
# endif # endif
# if defined(__HAIR__) && defined(__OBJECT_MOTION__) # if defined(__HAIR__) && defined(__OBJECT_MOTION__)
# define BVH_FUNCTION_NAME bvh_intersect_hair_motion # define BVH_FUNCTION_NAME bvh_intersect_hair_motion
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_HAIR | BVH_MOTION # define BVH_FUNCTION_FEATURES BVH_HAIR | BVH_MOTION
# include "kernel/bvh/bvh_traversal.h" # include "kernel/bvh/bvh_traversal.h"
# endif # endif
@@ -96,15 +90,9 @@ CCL_NAMESPACE_BEGIN
# define BVH_FUNCTION_FEATURES BVH_HAIR # define BVH_FUNCTION_FEATURES BVH_HAIR
# include "kernel/bvh/bvh_volume.h" # include "kernel/bvh/bvh_volume.h"
# if defined(__INSTANCING__)
# define BVH_FUNCTION_NAME bvh_intersect_volume_instancing
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_HAIR
# include "kernel/bvh/bvh_volume.h"
# endif
# if defined(__OBJECT_MOTION__) # if defined(__OBJECT_MOTION__)
# define BVH_FUNCTION_NAME bvh_intersect_volume_motion # define BVH_FUNCTION_NAME bvh_intersect_volume_motion
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_MOTION | BVH_HAIR # define BVH_FUNCTION_FEATURES BVH_MOTION | BVH_HAIR
# include "kernel/bvh/bvh_volume.h" # include "kernel/bvh/bvh_volume.h"
# endif # endif
# endif /* __VOLUME__ */ # endif /* __VOLUME__ */
@@ -116,27 +104,21 @@ CCL_NAMESPACE_BEGIN
# define BVH_FUNCTION_FEATURES 0 # define BVH_FUNCTION_FEATURES 0
# include "kernel/bvh/bvh_shadow_all.h" # include "kernel/bvh/bvh_shadow_all.h"
# if defined(__INSTANCING__)
# define BVH_FUNCTION_NAME bvh_intersect_shadow_all_instancing
# define BVH_FUNCTION_FEATURES BVH_INSTANCING
# include "kernel/bvh/bvh_shadow_all.h"
# endif
# if defined(__HAIR__) # if defined(__HAIR__)
# define BVH_FUNCTION_NAME bvh_intersect_shadow_all_hair # define BVH_FUNCTION_NAME bvh_intersect_shadow_all_hair
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_HAIR # define BVH_FUNCTION_FEATURES BVH_HAIR
# include "kernel/bvh/bvh_shadow_all.h" # include "kernel/bvh/bvh_shadow_all.h"
# endif # endif
# if defined(__OBJECT_MOTION__) # if defined(__OBJECT_MOTION__)
# define BVH_FUNCTION_NAME bvh_intersect_shadow_all_motion # define BVH_FUNCTION_NAME bvh_intersect_shadow_all_motion
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_MOTION # define BVH_FUNCTION_FEATURES BVH_MOTION
# include "kernel/bvh/bvh_shadow_all.h" # include "kernel/bvh/bvh_shadow_all.h"
# endif # endif
# if defined(__HAIR__) && defined(__OBJECT_MOTION__) # if defined(__HAIR__) && defined(__OBJECT_MOTION__)
# define BVH_FUNCTION_NAME bvh_intersect_shadow_all_hair_motion # define BVH_FUNCTION_NAME bvh_intersect_shadow_all_hair_motion
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_HAIR | BVH_MOTION # define BVH_FUNCTION_FEATURES BVH_HAIR | BVH_MOTION
# include "kernel/bvh/bvh_shadow_all.h" # include "kernel/bvh/bvh_shadow_all.h"
# endif # endif
# endif /* __SHADOW_RECORD_ALL__ */ # endif /* __SHADOW_RECORD_ALL__ */
@@ -148,15 +130,9 @@ CCL_NAMESPACE_BEGIN
# define BVH_FUNCTION_FEATURES BVH_HAIR # define BVH_FUNCTION_FEATURES BVH_HAIR
# include "kernel/bvh/bvh_volume_all.h" # include "kernel/bvh/bvh_volume_all.h"
# if defined(__INSTANCING__)
# define BVH_FUNCTION_NAME bvh_intersect_volume_all_instancing
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_HAIR
# include "kernel/bvh/bvh_volume_all.h"
# endif
# if defined(__OBJECT_MOTION__) # if defined(__OBJECT_MOTION__)
# define BVH_FUNCTION_NAME bvh_intersect_volume_all_motion # define BVH_FUNCTION_NAME bvh_intersect_volume_all_motion
# define BVH_FUNCTION_FEATURES BVH_INSTANCING | BVH_MOTION | BVH_HAIR # define BVH_FUNCTION_FEATURES BVH_MOTION | BVH_HAIR
# include "kernel/bvh/bvh_volume_all.h" # include "kernel/bvh/bvh_volume_all.h"
# endif # endif
# endif /* __VOLUME_RECORD_ALL__ */ # endif /* __VOLUME_RECORD_ALL__ */
@@ -264,20 +240,7 @@ ccl_device_intersect bool scene_intersect(KernelGlobals *kg,
} }
# endif /* __HAIR__ */ # endif /* __HAIR__ */
# ifdef __KERNEL_CPU__
# ifdef __INSTANCING__
if (kernel_data.bvh.have_instancing) {
return bvh_intersect_instancing(kg, ray, isect, visibility);
}
# endif /* __INSTANCING__ */
return bvh_intersect(kg, ray, isect, visibility); return bvh_intersect(kg, ray, isect, visibility);
# else /* __KERNEL_CPU__ */
# ifdef __INSTANCING__
return bvh_intersect_instancing(kg, ray, isect, visibility);
# else
return bvh_intersect(kg, ray, isect, visibility);
# endif /* __INSTANCING__ */
# endif /* __KERNEL_CPU__ */
#endif /* __KERNEL_OPTIX__ */ #endif /* __KERNEL_OPTIX__ */
} }
@@ -476,20 +439,7 @@ ccl_device_intersect bool scene_intersect_shadow_all(KernelGlobals *kg,
} }
# endif /* __HAIR__ */ # endif /* __HAIR__ */
# ifdef __KERNEL_CPU__
# ifdef __INSTANCING__
if (kernel_data.bvh.have_instancing) {
return bvh_intersect_shadow_all_instancing(kg, ray, isect, visibility, max_hits, num_hits);
}
# endif /* __INSTANCING__ */
return bvh_intersect_shadow_all(kg, ray, isect, visibility, max_hits, num_hits); return bvh_intersect_shadow_all(kg, ray, isect, visibility, max_hits, num_hits);
# else
# ifdef __INSTANCING__
return bvh_intersect_shadow_all_instancing(kg, ray, isect, visibility, max_hits, num_hits);
# else
return bvh_intersect_shadow_all(kg, ray, isect, visibility, max_hits, num_hits);
# endif /* __INSTANCING__ */
# endif /* __KERNEL_CPU__ */
# endif /* __KERNEL_OPTIX__ */ # endif /* __KERNEL_OPTIX__ */
} }
#endif /* __SHADOW_RECORD_ALL__ */ #endif /* __SHADOW_RECORD_ALL__ */
@@ -548,20 +498,7 @@ ccl_device_intersect bool scene_intersect_volume(KernelGlobals *kg,
} }
# endif /* __OBJECT_MOTION__ */ # endif /* __OBJECT_MOTION__ */
# ifdef __KERNEL_CPU__
# ifdef __INSTANCING__
if (kernel_data.bvh.have_instancing) {
return bvh_intersect_volume_instancing(kg, ray, isect, visibility);
}
# endif /* __INSTANCING__ */
return bvh_intersect_volume(kg, ray, isect, visibility); return bvh_intersect_volume(kg, ray, isect, visibility);
# else /* __KERNEL_CPU__ */
# ifdef __INSTANCING__
return bvh_intersect_volume_instancing(kg, ray, isect, visibility);
# else
return bvh_intersect_volume(kg, ray, isect, visibility);
# endif /* __INSTANCING__ */
# endif /* __KERNEL_CPU__ */
# endif /* __KERNEL_OPTIX__ */ # endif /* __KERNEL_OPTIX__ */
} }
#endif /* __VOLUME__ */ #endif /* __VOLUME__ */
@@ -599,11 +536,6 @@ ccl_device_intersect uint scene_intersect_volume_all(KernelGlobals *kg,
} }
# endif /* __OBJECT_MOTION__ */ # endif /* __OBJECT_MOTION__ */
# ifdef __INSTANCING__
if (kernel_data.bvh.have_instancing) {
return bvh_intersect_volume_all_instancing(kg, ray, isect, max_hits, visibility);
}
# endif /* __INSTANCING__ */
return bvh_intersect_volume_all(kg, ray, isect, max_hits, visibility); return bvh_intersect_volume_all(kg, ray, isect, max_hits, visibility);
} }
#endif /* __VOLUME_RECORD_ALL__ */ #endif /* __VOLUME_RECORD_ALL__ */

29
intern/cycles/kernel/bvh/bvh_shadow_all.h
View File

@@ -34,7 +34,6 @@
* enabled/disabled. This way we can compile optimized versions for each case * enabled/disabled. This way we can compile optimized versions for each case
* without new features slowing things down. * without new features slowing things down.
* *
* BVH_INSTANCING: object instancing
* BVH_HAIR: hair curve rendering * BVH_HAIR: hair curve rendering
* BVH_MOTION: motion blur rendering * BVH_MOTION: motion blur rendering
*/ */
@@ -76,9 +75,7 @@ ccl_device_inline
Transform ob_itfm; Transform ob_itfm;
#endif #endif
#if BVH_FEATURE(BVH_INSTANCING)
int num_hits_in_instance = 0; int num_hits_in_instance = 0;
#endif
*num_hits = 0; *num_hits = 0;
isect_array->t = tmax; isect_array->t = tmax;
@@ -174,9 +171,7 @@ ccl_device_inline
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr - 1)); float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr - 1));
int prim_addr = __float_as_int(leaf.x); int prim_addr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)
if (prim_addr >= 0) { if (prim_addr >= 0) {
#endif
const int prim_addr2 = __float_as_int(leaf.y); const int prim_addr2 = __float_as_int(leaf.y);
const uint type = __float_as_int(leaf.w); const uint type = __float_as_int(leaf.w);
const uint p_type = type & PRIMITIVE_ALL; const uint p_type = type & PRIMITIVE_ALL;
@@ -256,9 +251,7 @@ ccl_device_inline
/* move on to next entry in intersections array */ /* move on to next entry in intersections array */
isect_array++; isect_array++;
(*num_hits)++; (*num_hits)++;
#if BVH_FEATURE(BVH_INSTANCING)
num_hits_in_instance++; num_hits_in_instance++;
#endif
isect_array->t = isect_t; isect_array->t = isect_t;
} }
@@ -266,16 +259,15 @@ ccl_device_inline
prim_addr++; prim_addr++;
} }
} }
#if BVH_FEATURE(BVH_INSTANCING)
else { else {
/* instance push */ /* instance push */
object = kernel_tex_fetch(__prim_object, -prim_addr - 1); object = kernel_tex_fetch(__prim_object, -prim_addr - 1);
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
isect_t = bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir, isect_t, &ob_itfm); isect_t = bvh_instance_motion_push(kg, object, ray, &P, &dir, &idir, isect_t, &ob_itfm);
# else #else
isect_t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect_t); isect_t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect_t);
# endif #endif
num_hits_in_instance = 0; num_hits_in_instance = 0;
isect_array->t = isect_t; isect_array->t = isect_t;
@@ -299,10 +291,8 @@ ccl_device_inline
node_addr = kernel_tex_fetch(__object_node, object); node_addr = kernel_tex_fetch(__object_node, object);
} }
} }
#endif /* FEATURE(BVH_INSTANCING) */
} while (node_addr != ENTRYPOINT_SENTINEL); } while (node_addr != ENTRYPOINT_SENTINEL);
#if BVH_FEATURE(BVH_INSTANCING)
if (stack_ptr >= 0) { if (stack_ptr >= 0) {
kernel_assert(object != OBJECT_NONE); kernel_assert(object != OBJECT_NONE);
@@ -310,11 +300,11 @@ ccl_device_inline
if (num_hits_in_instance) { if (num_hits_in_instance) {
float t_fac; float t_fac;
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
bvh_instance_motion_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac, &ob_itfm); bvh_instance_motion_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac, &ob_itfm);
# else #else
bvh_instance_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac); bvh_instance_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac);
# endif #endif
/* scale isect->t to adjust for instancing */ /* scale isect->t to adjust for instancing */
for (int i = 0; i < num_hits_in_instance; i++) { for (int i = 0; i < num_hits_in_instance; i++) {
@@ -322,11 +312,11 @@ ccl_device_inline
} }
} }
else { else {
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX, &ob_itfm); bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX, &ob_itfm);
# else #else
bvh_instance_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX); bvh_instance_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX);
# endif #endif
} }
isect_t = tmax; isect_t = tmax;
@@ -348,7 +338,6 @@ ccl_device_inline
node_addr = traversal_stack[stack_ptr]; node_addr = traversal_stack[stack_ptr];
--stack_ptr; --stack_ptr;
} }
#endif /* FEATURE(BVH_INSTANCING) */
} while (node_addr != ENTRYPOINT_SENTINEL); } while (node_addr != ENTRYPOINT_SENTINEL);
return false; return false;

19
intern/cycles/kernel/bvh/bvh_traversal.h
View File

@@ -34,7 +34,6 @@
* enabled/disabled. This way we can compile optimized versions for each case * enabled/disabled. This way we can compile optimized versions for each case
* without new features slowing things down. * without new features slowing things down.
* *
* BVH_INSTANCING: object instancing
* BVH_HAIR: hair curve rendering * BVH_HAIR: hair curve rendering
* BVH_MOTION: motion blur rendering * BVH_MOTION: motion blur rendering
*/ */
@@ -173,9 +172,7 @@ ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr - 1)); float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr - 1));
int prim_addr = __float_as_int(leaf.x); int prim_addr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)
if (prim_addr >= 0) { if (prim_addr >= 0) {
#endif
const int prim_addr2 = __float_as_int(leaf.y); const int prim_addr2 = __float_as_int(leaf.y);
const uint type = __float_as_int(leaf.w); const uint type = __float_as_int(leaf.w);
@@ -259,17 +256,16 @@ ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
#endif /* BVH_FEATURE(BVH_HAIR) */ #endif /* BVH_FEATURE(BVH_HAIR) */
} }
} }
#if BVH_FEATURE(BVH_INSTANCING)
else { else {
/* instance push */ /* instance push */
object = kernel_tex_fetch(__prim_object, -prim_addr - 1); object = kernel_tex_fetch(__prim_object, -prim_addr - 1);
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
isect->t = bvh_instance_motion_push( isect->t = bvh_instance_motion_push(
kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm); kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm);
# else #else
isect->t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect->t); isect->t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect->t);
# endif #endif
# if defined(__KERNEL_SSE2__) # if defined(__KERNEL_SSE2__)
Psplat[0] = ssef(P.x); Psplat[0] = ssef(P.x);
@@ -293,19 +289,17 @@ ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
BVH_DEBUG_NEXT_INSTANCE(); BVH_DEBUG_NEXT_INSTANCE();
} }
} }
#endif /* FEATURE(BVH_INSTANCING) */
} while (node_addr != ENTRYPOINT_SENTINEL); } while (node_addr != ENTRYPOINT_SENTINEL);
#if BVH_FEATURE(BVH_INSTANCING)
if (stack_ptr >= 0) { if (stack_ptr >= 0) {
kernel_assert(object != OBJECT_NONE); kernel_assert(object != OBJECT_NONE);
/* instance pop */ /* instance pop */
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
isect->t = bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm); isect->t = bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm);
# else #else
isect->t = bvh_instance_pop(kg, object, ray, &P, &dir, &idir, isect->t); isect->t = bvh_instance_pop(kg, object, ray, &P, &dir, &idir, isect->t);
# endif #endif
# if defined(__KERNEL_SSE2__) # if defined(__KERNEL_SSE2__)
Psplat[0] = ssef(P.x); Psplat[0] = ssef(P.x);
@@ -324,7 +318,6 @@ ccl_device_noinline bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
node_addr = traversal_stack[stack_ptr]; node_addr = traversal_stack[stack_ptr];
--stack_ptr; --stack_ptr;
} }
#endif /* FEATURE(BVH_INSTANCING) */
} while (node_addr != ENTRYPOINT_SENTINEL); } while (node_addr != ENTRYPOINT_SENTINEL);
return (isect->prim != PRIM_NONE); return (isect->prim != PRIM_NONE);

5
intern/cycles/kernel/bvh/bvh_types.h
View File

@@ -35,9 +35,8 @@ CCL_NAMESPACE_BEGIN
#define BVH_OSTACK_SIZE 768 #define BVH_OSTACK_SIZE 768
/* BVH intersection function variations */ /* BVH intersection function variations */
#define BVH_INSTANCING 1 #define BVH_MOTION 1
#define BVH_MOTION 2 #define BVH_HAIR 2
#define BVH_HAIR 4
#define BVH_NAME_JOIN(x, y) x##_##y #define BVH_NAME_JOIN(x, y) x##_##y
#define BVH_NAME_EVAL(x, y) BVH_NAME_JOIN(x, y) #define BVH_NAME_EVAL(x, y) BVH_NAME_JOIN(x, y)

19
intern/cycles/kernel/bvh/bvh_volume.h
View File

@@ -34,7 +34,6 @@
* various features can be enabled/disabled. This way we can compile optimized * various features can be enabled/disabled. This way we can compile optimized
* versions for each case without new features slowing things down. * versions for each case without new features slowing things down.
* *
* BVH_INSTANCING: object instancing
* BVH_MOTION: motion blur rendering * BVH_MOTION: motion blur rendering
*/ */
@@ -170,9 +169,7 @@ ccl_device_inline
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr - 1)); float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr - 1));
int prim_addr = __float_as_int(leaf.x); int prim_addr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)
if (prim_addr >= 0) { if (prim_addr >= 0) {
#endif
const int prim_addr2 = __float_as_int(leaf.y); const int prim_addr2 = __float_as_int(leaf.y);
const uint type = __float_as_int(leaf.w); const uint type = __float_as_int(leaf.w);
@@ -222,18 +219,17 @@ ccl_device_inline
} }
} }
} }
#if BVH_FEATURE(BVH_INSTANCING)
else { else {
/* instance push */ /* instance push */
object = kernel_tex_fetch(__prim_object, -prim_addr - 1); object = kernel_tex_fetch(__prim_object, -prim_addr - 1);
int object_flag = kernel_tex_fetch(__object_flag, object); int object_flag = kernel_tex_fetch(__object_flag, object);
if (object_flag & SD_OBJECT_HAS_VOLUME) { if (object_flag & SD_OBJECT_HAS_VOLUME) {
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
isect->t = bvh_instance_motion_push( isect->t = bvh_instance_motion_push(
kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm); kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm);
# else #else
isect->t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect->t); isect->t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect->t);
# endif #endif
# if defined(__KERNEL_SSE2__) # if defined(__KERNEL_SSE2__)
Psplat[0] = ssef(P.x); Psplat[0] = ssef(P.x);
@@ -262,19 +258,17 @@ ccl_device_inline
} }
} }
} }
#endif /* FEATURE(BVH_INSTANCING) */
} while (node_addr != ENTRYPOINT_SENTINEL); } while (node_addr != ENTRYPOINT_SENTINEL);
#if BVH_FEATURE(BVH_INSTANCING)
if (stack_ptr >= 0) { if (stack_ptr >= 0) {
kernel_assert(object != OBJECT_NONE); kernel_assert(object != OBJECT_NONE);
/* instance pop */ /* instance pop */
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
isect->t = bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm); isect->t = bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, isect->t, &ob_itfm);
# else #else
isect->t = bvh_instance_pop(kg, object, ray, &P, &dir, &idir, isect->t); isect->t = bvh_instance_pop(kg, object, ray, &P, &dir, &idir, isect->t);
# endif #endif
# if defined(__KERNEL_SSE2__) # if defined(__KERNEL_SSE2__)
Psplat[0] = ssef(P.x); Psplat[0] = ssef(P.x);
@@ -293,7 +287,6 @@ ccl_device_inline
node_addr = traversal_stack[stack_ptr]; node_addr = traversal_stack[stack_ptr];
--stack_ptr; --stack_ptr;
} }
#endif /* FEATURE(BVH_MOTION) */
} while (node_addr != ENTRYPOINT_SENTINEL); } while (node_addr != ENTRYPOINT_SENTINEL);
return (isect->prim != PRIM_NONE); return (isect->prim != PRIM_NONE);

41
intern/cycles/kernel/bvh/bvh_volume_all.h
View File

@@ -34,7 +34,6 @@
* various features can be enabled/disabled. This way we can compile optimized * various features can be enabled/disabled. This way we can compile optimized
* versions for each case without new features slowing things down. * versions for each case without new features slowing things down.
* *
* BVH_INSTANCING: object instancing
* BVH_MOTION: motion blur rendering * BVH_MOTION: motion blur rendering
*/ */
@@ -76,9 +75,7 @@ ccl_device_inline
Transform ob_itfm; Transform ob_itfm;
#endif #endif
#if BVH_FEATURE(BVH_INSTANCING)
int num_hits_in_instance = 0; int num_hits_in_instance = 0;
#endif
uint num_hits = 0; uint num_hits = 0;
isect_array->t = tmax; isect_array->t = tmax;
@@ -174,9 +171,7 @@ ccl_device_inline
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr - 1)); float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-node_addr - 1));
int prim_addr = __float_as_int(leaf.x); int prim_addr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)
if (prim_addr >= 0) { if (prim_addr >= 0) {
#endif
const int prim_addr2 = __float_as_int(leaf.y); const int prim_addr2 = __float_as_int(leaf.y);
const uint type = __float_as_int(leaf.w); const uint type = __float_as_int(leaf.w);
bool hit; bool hit;
@@ -204,25 +199,21 @@ ccl_device_inline
/* Move on to next entry in intersections array. */ /* Move on to next entry in intersections array. */
isect_array++; isect_array++;
num_hits++; num_hits++;
#if BVH_FEATURE(BVH_INSTANCING)
num_hits_in_instance++; num_hits_in_instance++;
#endif
isect_array->t = isect_t; isect_array->t = isect_t;
if (num_hits == max_hits) { if (num_hits == max_hits) {
#if BVH_FEATURE(BVH_INSTANCING)
if (object != OBJECT_NONE) { if (object != OBJECT_NONE) {
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
float t_fac = 1.0f / len(transform_direction(&ob_itfm, dir)); float t_fac = 1.0f / len(transform_direction(&ob_itfm, dir));
# else #else
Transform itfm = object_fetch_transform( Transform itfm = object_fetch_transform(
kg, object, OBJECT_INVERSE_TRANSFORM); kg, object, OBJECT_INVERSE_TRANSFORM);
float t_fac = 1.0f / len(transform_direction(&itfm, dir)); float t_fac = 1.0f / len(transform_direction(&itfm, dir));
# endif #endif
for (int i = 0; i < num_hits_in_instance; i++) { for (int i = 0; i < num_hits_in_instance; i++) {
(isect_array - i - 1)->t *= t_fac; (isect_array - i - 1)->t *= t_fac;
} }
} }
#endif /* BVH_FEATURE(BVH_INSTANCING) */
return num_hits; return num_hits;
} }
} }
@@ -248,12 +239,9 @@ ccl_device_inline
/* Move on to next entry in intersections array. */ /* Move on to next entry in intersections array. */
isect_array++; isect_array++;
num_hits++; num_hits++;
# if BVH_FEATURE(BVH_INSTANCING)
num_hits_in_instance++; num_hits_in_instance++;
# endif
isect_array->t = isect_t; isect_array->t = isect_t;
if (num_hits == max_hits) { if (num_hits == max_hits) {
# if BVH_FEATURE(BVH_INSTANCING)
if (object != OBJECT_NONE) { if (object != OBJECT_NONE) {
# if BVH_FEATURE(BVH_MOTION) # if BVH_FEATURE(BVH_MOTION)
float t_fac = 1.0f / len(transform_direction(&ob_itfm, dir)); float t_fac = 1.0f / len(transform_direction(&ob_itfm, dir));
@@ -266,7 +254,6 @@ ccl_device_inline
(isect_array - i - 1)->t *= t_fac; (isect_array - i - 1)->t *= t_fac;
} }
} }
# endif /* BVH_FEATURE(BVH_INSTANCING) */
return num_hits; return num_hits;
} }
} }
@@ -279,18 +266,17 @@ ccl_device_inline
} }
} }
} }
#if BVH_FEATURE(BVH_INSTANCING)
else { else {
/* instance push */ /* instance push */
object = kernel_tex_fetch(__prim_object, -prim_addr - 1); object = kernel_tex_fetch(__prim_object, -prim_addr - 1);
int object_flag = kernel_tex_fetch(__object_flag, object); int object_flag = kernel_tex_fetch(__object_flag, object);
if (object_flag & SD_OBJECT_HAS_VOLUME) { if (object_flag & SD_OBJECT_HAS_VOLUME) {
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
isect_t = bvh_instance_motion_push( isect_t = bvh_instance_motion_push(
kg, object, ray, &P, &dir, &idir, isect_t, &ob_itfm); kg, object, ray, &P, &dir, &idir, isect_t, &ob_itfm);
# else #else
isect_t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect_t); isect_t = bvh_instance_push(kg, object, ray, &P, &dir, &idir, isect_t);
# endif #endif
num_hits_in_instance = 0; num_hits_in_instance = 0;
isect_array->t = isect_t; isect_array->t = isect_t;
@@ -322,32 +308,30 @@ ccl_device_inline
} }
} }
} }
#endif /* FEATURE(BVH_INSTANCING) */
} while (node_addr != ENTRYPOINT_SENTINEL); } while (node_addr != ENTRYPOINT_SENTINEL);
#if BVH_FEATURE(BVH_INSTANCING)
if (stack_ptr >= 0) { if (stack_ptr >= 0) {
kernel_assert(object != OBJECT_NONE); kernel_assert(object != OBJECT_NONE);
/* Instance pop. */ /* Instance pop. */
if (num_hits_in_instance) { if (num_hits_in_instance) {
float t_fac; float t_fac;
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
bvh_instance_motion_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac, &ob_itfm); bvh_instance_motion_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac, &ob_itfm);
# else #else
bvh_instance_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac); bvh_instance_pop_factor(kg, object, ray, &P, &dir, &idir, &t_fac);
# endif #endif
/* Scale isect->t to adjust for instancing. */ /* Scale isect->t to adjust for instancing. */
for (int i = 0; i < num_hits_in_instance; i++) { for (int i = 0; i < num_hits_in_instance; i++) {
(isect_array - i - 1)->t *= t_fac; (isect_array - i - 1)->t *= t_fac;
} }
} }
else { else {
# if BVH_FEATURE(BVH_MOTION) #if BVH_FEATURE(BVH_MOTION)
bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX, &ob_itfm); bvh_instance_motion_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX, &ob_itfm);
# else #else
bvh_instance_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX); bvh_instance_pop(kg, object, ray, &P, &dir, &idir, FLT_MAX);
# endif #endif
} }
isect_t = tmax; isect_t = tmax;
@@ -370,7 +354,6 @@ ccl_device_inline
node_addr = traversal_stack[stack_ptr]; node_addr = traversal_stack[stack_ptr];
--stack_ptr; --stack_ptr;
} }
#endif /* FEATURE(BVH_INSTANCING) */
} while (node_addr != ENTRYPOINT_SENTINEL); } while (node_addr != ENTRYPOINT_SENTINEL);
return num_hits; return num_hits;

2
intern/cycles/kernel/geom/geom_curve_intersect.h
View File

@@ -529,10 +529,8 @@ ccl_device_inline float3 curve_refine(KernelGlobals *kg,
P = P + D * t; P = P + D * t;
# ifdef __UV__
sd->u = isect->u; sd->u = isect->u;
sd->v = 0.0f; sd->v = 0.0f;
# endif
float3 tg = normalize(curvetangent(isect->u, p[0], p[1], p[2], p[3])); float3 tg = normalize(curvetangent(isect->u, p[0], p[1], p[2], p[3]));

8
intern/cycles/kernel/kernel_light.h
View File

@@ -313,20 +313,18 @@ ccl_device_inline bool triangle_world_space_vertices(
triangle_vertices(kg, prim, V); triangle_vertices(kg, prim, V);
} }
#ifdef __INSTANCING__
if (!(object_flag & SD_OBJECT_TRANSFORM_APPLIED)) { if (!(object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
# ifdef __OBJECT_MOTION__ #ifdef __OBJECT_MOTION__
float object_time = (time >= 0.0f) ? time : 0.5f; float object_time = (time >= 0.0f) ? time : 0.5f;
Transform tfm = object_fetch_transform_motion_test(kg, object, object_time, NULL); Transform tfm = object_fetch_transform_motion_test(kg, object, object_time, NULL);
# else #else
Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM);
# endif #endif
V[0] = transform_point(&tfm, V[0]); V[0] = transform_point(&tfm, V[0]);
V[1] = transform_point(&tfm, V[1]); V[1] = transform_point(&tfm, V[1]);
V[2] = transform_point(&tfm, V[2]); V[2] = transform_point(&tfm, V[2]);
has_motion = true; has_motion = true;
} }
#endif
return has_motion; return has_motion;
} }

30
intern/cycles/kernel/kernel_shader.h
View File

@@ -63,10 +63,8 @@ ccl_device_noinline
{ {
PROFILING_INIT(kg, PROFILING_SHADER_SETUP); PROFILING_INIT(kg, PROFILING_SHADER_SETUP);
#ifdef __INSTANCING__
sd->object = (isect->object == OBJECT_NONE) ? kernel_tex_fetch(__prim_object, isect->prim) : sd->object = (isect->object == OBJECT_NONE) ? kernel_tex_fetch(__prim_object, isect->prim) :
isect->object; isect->object;
#endif
sd->lamp = LAMP_NONE; sd->lamp = LAMP_NONE;
sd->type = isect->type; sd->type = isect->type;
@@ -82,10 +80,8 @@ ccl_device_noinline
sd->prim = kernel_tex_fetch(__prim_index, isect->prim); sd->prim = kernel_tex_fetch(__prim_index, isect->prim);
sd->ray_length = isect->t; sd->ray_length = isect->t;
#ifdef __UV__
sd->u = isect->u; sd->u = isect->u;
sd->v = isect->v; sd->v = isect->v;
#endif
#ifdef __HAIR__ #ifdef __HAIR__
if (sd->type & PRIMITIVE_ALL_CURVE) { if (sd->type & PRIMITIVE_ALL_CURVE) {
@@ -125,17 +121,15 @@ ccl_device_noinline
sd->flag |= kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags; sd->flag |= kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags;
#ifdef __INSTANCING__
if (isect->object != OBJECT_NONE) { if (isect->object != OBJECT_NONE) {
/* instance transform */ /* instance transform */
object_normal_transform_auto(kg, sd, &sd->N); object_normal_transform_auto(kg, sd, &sd->N);
object_normal_transform_auto(kg, sd, &sd->Ng); object_normal_transform_auto(kg, sd, &sd->Ng);
# ifdef __DPDU__ #ifdef __DPDU__
object_dir_transform_auto(kg, sd, &sd->dPdu); object_dir_transform_auto(kg, sd, &sd->dPdu);
object_dir_transform_auto(kg, sd, &sd->dPdv); object_dir_transform_auto(kg, sd, &sd->dPdv);
# endif
}
#endif #endif
}
/* backfacing test */ /* backfacing test */
bool backfacing = (dot(sd->Ng, sd->I) < 0.0f); bool backfacing = (dot(sd->Ng, sd->I) < 0.0f);
@@ -185,10 +179,8 @@ ccl_device_inline
sd->prim = kernel_tex_fetch(__prim_index, isect->prim); sd->prim = kernel_tex_fetch(__prim_index, isect->prim);
sd->type = isect->type; sd->type = isect->type;
# ifdef __UV__
sd->u = isect->u; sd->u = isect->u;
sd->v = isect->v; sd->v = isect->v;
# endif
/* fetch triangle data */ /* fetch triangle data */
if (sd->type == PRIMITIVE_TRIANGLE) { if (sd->type == PRIMITIVE_TRIANGLE) {
@@ -215,7 +207,6 @@ ccl_device_inline
sd->flag |= kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags; sd->flag |= kernel_tex_fetch(__shaders, (sd->shader & SHADER_MASK)).flags;
# ifdef __INSTANCING__
if (isect->object != OBJECT_NONE) { if (isect->object != OBJECT_NONE) {
/* instance transform */ /* instance transform */
object_normal_transform_auto(kg, sd, &sd->N); object_normal_transform_auto(kg, sd, &sd->N);
@@ -225,7 +216,6 @@ ccl_device_inline
object_dir_transform_auto(kg, sd, &sd->dPdv); object_dir_transform_auto(kg, sd, &sd->dPdv);
# endif # endif
} }
# endif
/* backfacing test */ /* backfacing test */
if (backfacing) { if (backfacing) {
@@ -285,16 +275,12 @@ ccl_device_inline void shader_setup_from_sample(KernelGlobals *kg,
sd->type = PRIMITIVE_NONE; sd->type = PRIMITIVE_NONE;
/* primitive */ /* primitive */
#ifdef __INSTANCING__
sd->object = object; sd->object = object;
#endif
sd->lamp = LAMP_NONE; sd->lamp = LAMP_NONE;
/* currently no access to bvh prim index for strand sd->prim*/ /* currently no access to bvh prim index for strand sd->prim*/
sd->prim = prim; sd->prim = prim;
#ifdef __UV__
sd->u = u; sd->u = u;
sd->v = v; sd->v = v;
#endif
sd->time = time; sd->time = time;
sd->ray_length = t; sd->ray_length = t;
@@ -330,23 +316,19 @@ ccl_device_inline void shader_setup_from_sample(KernelGlobals *kg,
if (sd->shader & SHADER_SMOOTH_NORMAL) { if (sd->shader & SHADER_SMOOTH_NORMAL) {
sd->N = triangle_smooth_normal(kg, Ng, sd->prim, sd->u, sd->v); sd->N = triangle_smooth_normal(kg, Ng, sd->prim, sd->u, sd->v);
#ifdef __INSTANCING__
if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) { if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
object_normal_transform_auto(kg, sd, &sd->N); object_normal_transform_auto(kg, sd, &sd->N);
} }
#endif
} }
/* dPdu/dPdv */ /* dPdu/dPdv */
#ifdef __DPDU__ #ifdef __DPDU__
triangle_dPdudv(kg, sd->prim, &sd->dPdu, &sd->dPdv); triangle_dPdudv(kg, sd->prim, &sd->dPdu, &sd->dPdv);
# ifdef __INSTANCING__
if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) { if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) {
object_dir_transform_auto(kg, sd, &sd->dPdu); object_dir_transform_auto(kg, sd, &sd->dPdu);
object_dir_transform_auto(kg, sd, &sd->dPdv); object_dir_transform_auto(kg, sd, &sd->dPdv);
} }
# endif
#endif #endif
} }
else { else {
@@ -432,15 +414,11 @@ ccl_device_inline void shader_setup_from_background(KernelGlobals *kg,
sd->time = ray->time; sd->time = ray->time;
sd->ray_length = 0.0f; sd->ray_length = 0.0f;
#ifdef __INSTANCING__
sd->object = OBJECT_NONE; sd->object = OBJECT_NONE;
#endif
sd->lamp = LAMP_NONE; sd->lamp = LAMP_NONE;
sd->prim = PRIM_NONE; sd->prim = PRIM_NONE;
#ifdef __UV__
sd->u = 0.0f; sd->u = 0.0f;
sd->v = 0.0f; sd->v = 0.0f;
#endif
#ifdef __DPDU__ #ifdef __DPDU__
/* dPdu/dPdv */ /* dPdu/dPdv */
@@ -481,17 +459,13 @@ ccl_device_inline void shader_setup_from_volume(KernelGlobals *kg, ShaderData *s
sd->time = ray->time; sd->time = ray->time;
sd->ray_length = 0.0f; /* todo: can we set this to some useful value? */ sd->ray_length = 0.0f; /* todo: can we set this to some useful value? */
# ifdef __INSTANCING__
sd->object = OBJECT_NONE; /* todo: fill this for texture coordinates */ sd->object = OBJECT_NONE; /* todo: fill this for texture coordinates */
# endif
sd->lamp = LAMP_NONE; sd->lamp = LAMP_NONE;
sd->prim = PRIM_NONE; sd->prim = PRIM_NONE;
sd->type = PRIMITIVE_NONE; sd->type = PRIMITIVE_NONE;
# ifdef __UV__
sd->u = 0.0f; sd->u = 0.0f;
sd->v = 0.0f; sd->v = 0.0f;
# endif
# ifdef __DPDU__ # ifdef __DPDU__
/* dPdu/dPdv */ /* dPdu/dPdv */

4
intern/cycles/kernel/kernel_types.h
View File

@@ -84,9 +84,7 @@ CCL_NAMESPACE_BEGIN
/* Kernel features */ /* Kernel features */
#define __SOBOL__ #define __SOBOL__
#define __INSTANCING__
#define __DPDU__ #define __DPDU__
#define __UV__
#define __BACKGROUND__ #define __BACKGROUND__
#define __CAUSTICS_TRICKS__ #define __CAUSTICS_TRICKS__
#define __VISIBILITY_FLAG__ #define __VISIBILITY_FLAG__
@@ -1406,9 +1404,9 @@ typedef struct KernelBVH {
int root; int root;
int have_motion; int have_motion;
int have_curves; int have_curves;
int have_instancing;
int bvh_layout; int bvh_layout;
int use_bvh_steps; int use_bvh_steps;
int pad;
/* Custom BVH */ /* Custom BVH */
#ifdef __KERNEL_OPTIX__ #ifdef __KERNEL_OPTIX__

2
intern/cycles/kernel/svm/svm_geometry.h
View File

@@ -41,11 +41,9 @@ ccl_device_inline void svm_node_geometry(
case NODE_GEOM_Ng: case NODE_GEOM_Ng:
data = sd->Ng; data = sd->Ng;
break; break;
#ifdef __UV__
case NODE_GEOM_uv: case NODE_GEOM_uv:
data = make_float3(sd->u, sd->v, 0.0f); data = make_float3(sd->u, sd->v, 0.0f);
break; break;
#endif
default: default:
data = make_float3(0.0f, 0.0f, 0.0f); data = make_float3(0.0f, 0.0f, 0.0f);
} }

8
intern/cycles/render/object.cpp
View File

@@ -616,7 +616,6 @@ void ObjectManager::device_update_transforms(DeviceScene *dscene, Scene *scene,
dscene->data.bvh.have_motion = state.have_motion; dscene->data.bvh.have_motion = state.have_motion;
dscene->data.bvh.have_curves = state.have_curves; dscene->data.bvh.have_curves = state.have_curves;
dscene->data.bvh.have_instancing = true;
} }
void ObjectManager::device_update(Device *device, void ObjectManager::device_update(Device *device,
@@ -791,7 +790,6 @@ void ObjectManager::apply_static_transforms(DeviceScene *dscene, Scene *scene, P
bool motion_blur = need_motion == Scene::MOTION_BLUR; bool motion_blur = need_motion == Scene::MOTION_BLUR;
bool apply_to_motion = need_motion != Scene::MOTION_PASS; bool apply_to_motion = need_motion != Scene::MOTION_PASS;
int i = 0; int i = 0;
bool have_instancing = false;
foreach (Object *object, scene->objects) { foreach (Object *object, scene->objects) {
map<Geometry *, int>::iterator it = geometry_users.find(object->geometry); map<Geometry *, int>::iterator it = geometry_users.find(object->geometry);
@@ -837,16 +835,10 @@ void ObjectManager::apply_static_transforms(DeviceScene *dscene, Scene *scene, P
if (geom->transform_negative_scaled) if (geom->transform_negative_scaled)
object_flag[i] |= SD_OBJECT_NEGATIVE_SCALE_APPLIED; object_flag[i] |= SD_OBJECT_NEGATIVE_SCALE_APPLIED;
} }
else
have_instancing = true;
} }
else
have_instancing = true;
i++; i++;
} }
dscene->data.bvh.have_instancing = have_instancing;
} }
void ObjectManager::tag_update(Scene *scene) void ObjectManager::tag_update(Scene *scene)