1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
// Copyright 2009-2020 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "bvh.h"
#include "../common/ray.h"
#include "../common/stack_item.h"
#include "node_intersector_frustum.h"
namespace embree
{
namespace isa
{
template<int K, bool robust>
struct TravRayK;
/*! BVH hybrid packet intersector. Switches between packet and single ray traversal (optional). */
template<int N, int K, int types, bool robust, typename PrimitiveIntersectorK, bool single = true>
class BVHNIntersectorKHybrid
{
/* right now AVX512KNL SIMD extension only for standard node types */
static const size_t Nx = types == BVH_AN1 ? vextend<N>::size : N;
/* shortcuts for frequently used types */
typedef typename PrimitiveIntersectorK::Precalculations Precalculations;
typedef typename PrimitiveIntersectorK::Primitive Primitive;
typedef BVHN<N> BVH;
typedef typename BVH::NodeRef NodeRef;
typedef typename BVH::BaseNode BaseNode;
typedef typename BVH::AABBNode AABBNode;
static const size_t stackSizeSingle = 1+(N-1)*BVH::maxDepth+3; // +3 due to 16-wide store
static const size_t stackSizeChunk = 1+(N-1)*BVH::maxDepth;
static const size_t switchThresholdIncoherent = \
(K==4) ? 3 :
(K==8) ? ((N==4) ? 5 : 7) :
(K==16) ? 14 : // 14 seems to work best for KNL due to better ordered chunk traversal
0;
private:
static void intersect1(Accel::Intersectors* This, const BVH* bvh, NodeRef root, size_t k, Precalculations& pre,
RayHitK<K>& ray, const TravRayK<K, robust>& tray, IntersectContext* context);
static bool occluded1(Accel::Intersectors* This, const BVH* bvh, NodeRef root, size_t k, Precalculations& pre,
RayK<K>& ray, const TravRayK<K, robust>& tray, IntersectContext* context);
public:
static void intersect(vint<K>* valid, Accel::Intersectors* This, RayHitK<K>& ray, IntersectContext* context);
static void occluded (vint<K>* valid, Accel::Intersectors* This, RayK<K>& ray, IntersectContext* context);
static void intersectCoherent(vint<K>* valid, Accel::Intersectors* This, RayHitK<K>& ray, IntersectContext* context);
static void occludedCoherent (vint<K>* valid, Accel::Intersectors* This, RayK<K>& ray, IntersectContext* context);
};
/*! BVH packet intersector. */
template<int N, int K, int types, bool robust, typename PrimitiveIntersectorK>
class BVHNIntersectorKChunk : public BVHNIntersectorKHybrid<N, K, types, robust, PrimitiveIntersectorK, false> {};
}
}
|