blender
/
blender
132
398
Fork 577
Code Issues 6.2k Pull Requests 747 Projects 19 Wiki Activity

Cycles: Switch node address to absolute values in BVH tree 

This seems to be straightforward way to support heterogeneous nodes
in the same tree.

There is some penalty related on 4gig limit of the address space now,
but here's are the thing:

Traversal code was already using ints to store final offset, so
there can't be regressions really.

This is a required commit to make it possible to encode both aligned
and unaligned nodes in the same array. Also, in the future we can use
this to get rid of __leaf_nodes array (which is a bit tricky to do since
trickery in pack_instances().
This commit is contained in:
Sergey Sharybin 2016-06-14 14:29:09 +02:00
parent 17e7454263
commit 1a2012145d
13 changed files with 82 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
intern/cycles/bvh/bvh.cpp
View File

@ -288,8 +288,8 @@ void BVH::pack_instances(size_t nodes_size, size_t leaf_nodes_size)
BVH *bvh = mesh->bvh;
int noffset = nodes_offset/nsize;
int noffset_leaf = nodes_leaf_offset/nsize_leaf;
int noffset = nodes_offset;
int noffset_leaf = nodes_leaf_offset;
int mesh_tri_offset = mesh->tri_offset;
int mesh_curve_offset = mesh->curve_offset;
@ -421,7 +421,7 @@ void RegularBVH::pack_leaf(const BVHStackEntry& e, const LeafNode *leaf)
data[0].w = __uint_as_float(pack.prim_type[leaf->m_lo]);
}
memcpy(&pack.leaf_nodes[e.idx * BVH_NODE_LEAF_SIZE], data, sizeof(float4)*BVH_NODE_LEAF_SIZE);
memcpy(&pack.leaf_nodes[e.idx], data, sizeof(float4)*BVH_NODE_LEAF_SIZE);
}
void RegularBVH::pack_inner(const BVHStackEntry& e, const BVHStackEntry& e0, const BVHStackEntry& e1)
@ -439,7 +439,7 @@ void RegularBVH::pack_node(int idx, const BoundBox& b0, const BoundBox& b1, int
make_int4(c0, c1, visibility0, visibility1)
};
memcpy(&pack.nodes[idx * BVH_NODE_SIZE], data, sizeof(int4)*BVH_NODE_SIZE);
memcpy(&pack.nodes[idx], data, sizeof(int4)*BVH_NODE_SIZE);
}
void RegularBVH::pack_nodes(const BVHNode *root)
@ -465,10 +465,13 @@ void RegularBVH::pack_nodes(const BVHNode *root)
vector<BVHStackEntry> stack;
stack.reserve(BVHParams::MAX_DEPTH*2);
if(root->is_leaf())
if(root->is_leaf()) {
stack.push_back(BVHStackEntry(root, nextLeafNodeIdx++));
else
stack.push_back(BVHStackEntry(root, nextNodeIdx++));
}
else {
stack.push_back(BVHStackEntry(root, nextNodeIdx));
nextNodeIdx += BVH_NODE_SIZE;
}
while(stack.size()) {
BVHStackEntry e = stack.back();
@ -481,10 +484,19 @@ void RegularBVH::pack_nodes(const BVHNode *root)
}
else {
/* innner node */
int idx0 = (e.node->get_child(0)->is_leaf())? (nextLeafNodeIdx++) : (nextNodeIdx++);
int idx1 = (e.node->get_child(1)->is_leaf())? (nextLeafNodeIdx++) : (nextNodeIdx++);
stack.push_back(BVHStackEntry(e.node->get_child(0), idx0));
stack.push_back(BVHStackEntry(e.node->get_child(1), idx1));
int idx[2];
for (int i = 0; i < 2; ++i) {
if (e.node->get_child(i)->is_leaf()) {
idx[i] = nextLeafNodeIdx++;
}
else {
idx[i] = nextNodeIdx;
nextNodeIdx += BVH_NODE_SIZE;
}
}
stack.push_back(BVHStackEntry(e.node->get_child(0), idx[0]));
stack.push_back(BVHStackEntry(e.node->get_child(1), idx[1]));
pack_inner(e, stack[stack.size()-2], stack[stack.size()-1]);
}
@ -506,7 +518,7 @@ void RegularBVH::refit_nodes()
void RegularBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility)
{
if(leaf) {
int4 *data = &pack.leaf_nodes[idx*BVH_NODE_LEAF_SIZE];
int4 *data = &pack.leaf_nodes[idx];
int c0 = data[0].x;
int c1 = data[0].y;
/* refit leaf node */
@ -580,12 +592,12 @@ void RegularBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility
leaf_data[0].y = __int_as_float(c1);
leaf_data[0].z = __uint_as_float(visibility);
leaf_data[0].w = __uint_as_float(data[0].w);
memcpy(&pack.leaf_nodes[idx * BVH_NODE_LEAF_SIZE],
memcpy(&pack.leaf_nodes[idx],
leaf_data,
sizeof(float4)*BVH_NODE_LEAF_SIZE);
}
else {
int4 *data = &pack.nodes[idx*BVH_NODE_SIZE];
int4 *data = &pack.nodes[idx];
int c0 = data[3].x;
int c1 = data[3].y;
/* refit inner node, set bbox from children */
@ -630,7 +642,7 @@ void QBVH::pack_leaf(const BVHStackEntry& e, const LeafNode *leaf)
data[0].w = __uint_as_float(pack.prim_type[leaf->m_lo]);
}
memcpy(&pack.leaf_nodes[e.idx * BVH_QNODE_LEAF_SIZE], data, sizeof(float4)*BVH_QNODE_LEAF_SIZE);
memcpy(&pack.leaf_nodes[e.idx], data, sizeof(float4)*BVH_QNODE_LEAF_SIZE);
}
void QBVH::pack_inner(const BVHStackEntry& e, const BVHStackEntry *en, int num)
@ -668,7 +680,7 @@ void QBVH::pack_inner(const BVHStackEntry& e, const BVHStackEntry *en, int num)
data[7][i] = __int_as_float(0);
}
memcpy(&pack.nodes[e.idx * BVH_QNODE_SIZE], data, sizeof(float4)*BVH_QNODE_SIZE);
memcpy(&pack.nodes[e.idx], data, sizeof(float4)*BVH_QNODE_SIZE);
}
/* Quad SIMD Nodes */
@ -701,7 +713,8 @@ void QBVH::pack_nodes(const BVHNode *root)
stack.push_back(BVHStackEntry(root, nextLeafNodeIdx++));
}
else {
stack.push_back(BVHStackEntry(root, nextNodeIdx++));
stack.push_back(BVHStackEntry(root, nextNodeIdx));
nextNodeIdx += BVH_QNODE_SIZE;
}
while(stack.size()) {
@ -746,7 +759,8 @@ void QBVH::pack_nodes(const BVHNode *root)
idx = nextLeafNodeIdx++;
}
else {
idx = nextNodeIdx++;
idx = nextNodeIdx;
nextNodeIdx += BVH_QNODE_SIZE;
}
stack.push_back(BVHStackEntry(nodes[i], idx));
}
@ -772,7 +786,7 @@ void QBVH::refit_nodes()
void QBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility)
{
if(leaf) {
int4 *data = &pack.leaf_nodes[idx*BVH_QNODE_LEAF_SIZE];
int4 *data = &pack.leaf_nodes[idx];
int4 c = data[0];
/* Refit leaf node. */
for(int prim = c.x; prim < c.y; prim++) {
@ -854,12 +868,12 @@ void QBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility)
leaf_data[0].y = __int_as_float(c.y);
leaf_data[0].z = __uint_as_float(visibility);
leaf_data[0].w = __uint_as_float(c.w);
memcpy(&pack.leaf_nodes[idx * BVH_QNODE_LEAF_SIZE],
memcpy(&pack.leaf_nodes[idx],
leaf_data,
sizeof(float4)*BVH_QNODE_LEAF_SIZE);
}
else {
int4 *data = &pack.nodes[idx*BVH_QNODE_SIZE];
int4 *data = &pack.nodes[idx];
int4 c = data[7];
/* Refit inner node, set bbox from children. */
BoundBox child_bbox[4] = {BoundBox::empty,
@ -895,7 +909,7 @@ void QBVH::refit_node(int idx, bool leaf, BoundBox& bbox, uint& visibility)
inner_data[6][i] = bb_max.z;
inner_data[7][i] = __int_as_float(c[i]);
}
memcpy(&pack.nodes[idx * BVH_QNODE_SIZE],
memcpy(&pack.nodes[idx],
inner_data,
sizeof(float4)*BVH_QNODE_SIZE);
}

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

@ -21,10 +21,6 @@
/* 64 object BVH + 64 mesh BVH + 64 object node splitting */
#define BVH_STACK_SIZE 192
#define BVH_QSTACK_SIZE 384
#define BVH_NODE_SIZE 4
#define BVH_NODE_LEAF_SIZE 1
#define BVH_QNODE_SIZE 8
#define BVH_QNODE_LEAF_SIZE 1
#define TRI_NODE_SIZE 3
#include "geom_attribute.h"

12
intern/cycles/kernel/geom/geom_bvh_shadow.h
View File

@ -102,10 +102,10 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
float t = isect_t;
/* 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);
float4 node0 = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
float4 node1 = kernel_tex_fetch(__bvh_nodes, nodeAddr+1);
float4 node2 = kernel_tex_fetch(__bvh_nodes, nodeAddr+2);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+3);
/* intersect ray against child nodes */
float c0lox = (node0.x - P.x) * idir.x;
@ -140,7 +140,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* Intersect two child bounding boxes, SSE3 version adapted from Embree */
/* fetch node data */
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr*BVH_NODE_SIZE;
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr;
const float4 cnodes = ((float4*)bvh_nodes)[3];
/* intersect ray against child nodes */
@ -200,7 +200,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* if node is leaf, fetch triangle list */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_NODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
int primAddr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)

12
intern/cycles/kernel/geom/geom_bvh_subsurface.h
View File

@ -113,10 +113,10 @@ ccl_device void BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
float t = isect_t;
/* 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);
float4 node0 = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
float4 node1 = kernel_tex_fetch(__bvh_nodes, nodeAddr+1);
float4 node2 = kernel_tex_fetch(__bvh_nodes, nodeAddr+2);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+3);
/* intersect ray against child nodes */
float c0lox = (node0.x - P.x) * idir.x;
@ -145,7 +145,7 @@ ccl_device void BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* Intersect two child bounding boxes, SSE3 version adapted from Embree */
/* fetch node data */
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr*BVH_NODE_SIZE;
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr;
const float4 cnodes = ((float4*)bvh_nodes)[3];
/* intersect ray against child nodes */
@ -199,7 +199,7 @@ ccl_device void BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* if node is leaf, fetch triangle list */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_NODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
int primAddr = __float_as_int(leaf.x);
const int primAddr2 = __float_as_int(leaf.y);

12
intern/cycles/kernel/geom/geom_bvh_traversal.h
View File

@ -109,10 +109,10 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
float t = isect->t;
/* 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);
float4 node0 = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
float4 node1 = kernel_tex_fetch(__bvh_nodes, nodeAddr+1);
float4 node2 = kernel_tex_fetch(__bvh_nodes, nodeAddr+2);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+3);
/* intersect ray against child nodes */
float c0lox = (node0.x - P.x) * idir.x;
@ -162,7 +162,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* Intersect two child bounding boxes, SSE3 version adapted from Embree */
/* fetch node data */
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr*BVH_NODE_SIZE;
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr;
const float4 cnodes = ((float4*)bvh_nodes)[3];
/* intersect ray against child nodes */
@ -243,7 +243,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* if node is leaf, fetch triangle list */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_NODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
int primAddr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)

12
intern/cycles/kernel/geom/geom_bvh_volume.h
View File

@ -99,10 +99,10 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
float t = isect->t;
/* 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);
float4 node0 = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
float4 node1 = kernel_tex_fetch(__bvh_nodes, nodeAddr+1);
float4 node2 = kernel_tex_fetch(__bvh_nodes, nodeAddr+2);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+3);
/* intersect ray against child nodes */
float c0lox = (node0.x - P.x) * idir.x;
@ -131,7 +131,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* Intersect two child bounding boxes, SSE3 version adapted from Embree */
/* fetch node data */
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr*BVH_NODE_SIZE;
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr;
const float4 cnodes = ((float4*)bvh_nodes)[3];
/* intersect ray against child nodes */
@ -186,7 +186,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* if node is leaf, fetch triangle list */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_NODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
int primAddr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)

12
intern/cycles/kernel/geom/geom_bvh_volume_all.h
View File

@ -103,10 +103,10 @@ ccl_device uint BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
float t = isect_array->t;
/* 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);
float4 node0 = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
float4 node1 = kernel_tex_fetch(__bvh_nodes, nodeAddr+1);
float4 node2 = kernel_tex_fetch(__bvh_nodes, nodeAddr+2);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+3);
/* intersect ray against child nodes */
float c0lox = (node0.x - P.x) * idir.x;
@ -135,7 +135,7 @@ ccl_device uint BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* Intersect two child bounding boxes, SSE3 version adapted from Embree */
/* fetch node data */
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr*BVH_NODE_SIZE;
const ssef *bvh_nodes = (ssef*)kg->__bvh_nodes.data + nodeAddr;
const float4 cnodes = ((float4*)bvh_nodes)[3];
/* intersect ray against child nodes */
@ -190,7 +190,7 @@ ccl_device uint BVH_FUNCTION_FULL_NAME(BVH)(KernelGlobals *kg,
/* if node is leaf, fetch triangle list */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_NODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
int primAddr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)

4
intern/cycles/kernel/geom/geom_qbvh.h
View File

@ -69,7 +69,7 @@ ccl_device_inline int qbvh_node_intersect(KernelGlobals *__restrict kg,
const int nodeAddr,
ssef *__restrict dist)
{
const int offset = nodeAddr*BVH_QNODE_SIZE + 1;
const int offset = nodeAddr + 1;
#ifdef __KERNEL_AVX2__
const ssef tnear_x = msub(kernel_tex_fetch_ssef(__bvh_nodes, offset+near_x), idir.x, org_idir.x);
const ssef tnear_y = msub(kernel_tex_fetch_ssef(__bvh_nodes, offset+near_y), idir.y, org_idir.y);
@ -120,7 +120,7 @@ ccl_device_inline int qbvh_node_intersect_robust(KernelGlobals *__restrict kg,
const float difl,
ssef *__restrict dist)
{
const int offset = nodeAddr*BVH_QNODE_SIZE + 1;
const int offset = nodeAddr + 1;
#ifdef __KERNEL_AVX2__
const ssef tnear_x = msub(kernel_tex_fetch_ssef(__bvh_nodes, offset+near_x), idir.x, P_idir.x);
const ssef tnear_y = msub(kernel_tex_fetch_ssef(__bvh_nodes, offset+near_y), idir.y, P_idir.y);

7
intern/cycles/kernel/geom/geom_qbvh_shadow.h
View File

@ -97,7 +97,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
do {
/* Traverse internal nodes. */
while(nodeAddr >= 0 && nodeAddr != ENTRYPOINT_SENTINEL) {
float4 inodes = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_QNODE_SIZE+0);
float4 inodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
#ifdef __VISIBILITY_FLAG__
if((__float_as_uint(inodes.x) & PATH_RAY_SHADOW) == 0) {
@ -124,8 +124,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
&dist);
if(traverseChild != 0) {
float4 cnodes = kernel_tex_fetch(__bvh_nodes,
nodeAddr*BVH_QNODE_SIZE+7);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+7);
/* One child is hit, continue with that child. */
int r = __bscf(traverseChild);
@ -218,7 +217,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
/* If node is leaf, fetch triangle list. */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_QNODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
#ifdef __VISIBILITY_FLAG__
if((__float_as_uint(leaf.z) & PATH_RAY_SHADOW) == 0) {
/* Pop. */

5
intern/cycles/kernel/geom/geom_qbvh_subsurface.h
View File

@ -123,8 +123,7 @@ ccl_device void BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
&dist);
if(traverseChild != 0) {
float4 cnodes = kernel_tex_fetch(__bvh_nodes,
nodeAddr*BVH_QNODE_SIZE+7);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+7);
/* One child is hit, continue with that child. */
int r = __bscf(traverseChild);
@ -217,7 +216,7 @@ ccl_device void BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
/* If node is leaf, fetch triangle list. */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_QNODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
int primAddr = __float_as_int(leaf.x);
int primAddr2 = __float_as_int(leaf.y);

8
intern/cycles/kernel/geom/geom_qbvh_traversal.h
View File

@ -106,8 +106,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
do {
/* Traverse internal nodes. */
while(nodeAddr >= 0 && nodeAddr != ENTRYPOINT_SENTINEL) {
float4 inodes = kernel_tex_fetch(__bvh_nodes,
nodeAddr*BVH_QNODE_SIZE+0);
float4 inodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
if(UNLIKELY(nodeDist > isect->t)
#ifdef __VISIBILITY_FLAG__
@ -167,8 +166,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
}
if(traverseChild != 0) {
float4 cnodes = kernel_tex_fetch(__bvh_nodes,
nodeAddr*BVH_QNODE_SIZE+7);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+7);
/* One child is hit, continue with that child. */
int r = __bscf(traverseChild);
@ -266,7 +264,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
/* If node is leaf, fetch triangle list. */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_QNODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
#ifdef __VISIBILITY_FLAG__
if(UNLIKELY((nodeDist > isect->t) ||

7
intern/cycles/kernel/geom/geom_qbvh_volume.h
View File

@ -94,7 +94,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
/* Traverse internal nodes. */
while(nodeAddr >= 0 && nodeAddr != ENTRYPOINT_SENTINEL) {
#ifdef __VISIBILITY_FLAG__
float4 inodes = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_QNODE_SIZE+0);
float4 inodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
if((__float_as_uint(inodes.x) & visibility) == 0) {
/* Pop. */
nodeAddr = traversalStack[stackPtr].addr;
@ -119,8 +119,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
&dist);
if(traverseChild != 0) {
float4 cnodes = kernel_tex_fetch(__bvh_nodes,
nodeAddr*BVH_QNODE_SIZE+7);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+7);
/* One child is hit, continue with that child. */
int r = __bscf(traverseChild);
@ -213,7 +212,7 @@ ccl_device bool BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
/* If node is leaf, fetch triangle list. */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_QNODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
int primAddr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)

7
intern/cycles/kernel/geom/geom_qbvh_volume_all.h
View File

@ -98,7 +98,7 @@ ccl_device uint BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
/* Traverse internal nodes. */
while(nodeAddr >= 0 && nodeAddr != ENTRYPOINT_SENTINEL) {
#ifdef __VISIBILITY_FLAG__
float4 inodes = kernel_tex_fetch(__bvh_nodes, nodeAddr*BVH_QNODE_SIZE+0);
float4 inodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+0);
if((__float_as_uint(inodes.x) & visibility) == 0) {
/* Pop. */
nodeAddr = traversalStack[stackPtr].addr;
@ -123,8 +123,7 @@ ccl_device uint BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
&dist);
if(traverseChild != 0) {
float4 cnodes = kernel_tex_fetch(__bvh_nodes,
nodeAddr*BVH_QNODE_SIZE+7);
float4 cnodes = kernel_tex_fetch(__bvh_nodes, nodeAddr+7);
/* One child is hit, continue with that child. */
int r = __bscf(traverseChild);
@ -217,7 +216,7 @@ ccl_device uint BVH_FUNCTION_FULL_NAME(QBVH)(KernelGlobals *kg,
/* If node is leaf, fetch triangle list. */
if(nodeAddr < 0) {
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1)*BVH_QNODE_LEAF_SIZE);
float4 leaf = kernel_tex_fetch(__bvh_leaf_nodes, (-nodeAddr-1));
int primAddr = __float_as_int(leaf.x);
#if BVH_FEATURE(BVH_INSTANCING)