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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/scene.h"
#include "../common/primref.h"
namespace embree
{
namespace isa
{
template<size_t N>
__forceinline void splitPolygon(const BBox3fa& bounds,
const size_t dim,
const float pos,
const Vec3fa (&v)[N+1],
const Vec3fa (&inv_length)[N],
BBox3fa& left_o,
BBox3fa& right_o)
{
BBox3fa left = empty, right = empty;
/* clip triangle to left and right box by processing all edges */
for (size_t i=0; i<N; i++)
{
const Vec3fa &v0 = v[i];
const Vec3fa &v1 = v[i+1];
const float v0d = v0[dim];
const float v1d = v1[dim];
if (v0d <= pos) left. extend(v0); // this point is on left side
if (v0d >= pos) right.extend(v0); // this point is on right side
if ((v0d < pos && pos < v1d) || (v1d < pos && pos < v0d)) // the edge crosses the splitting location
{
assert((v1d-v0d) != 0.0f);
const Vec3fa c = madd(Vec3fa((pos-v0d)*inv_length[i][dim]),v1-v0,v0);
left.extend(c);
right.extend(c);
}
}
/* clip against current bounds */
left_o = intersect(left,bounds);
right_o = intersect(right,bounds);
}
template<size_t N>
__forceinline void splitPolygon(const PrimRef& prim,
const size_t dim,
const float pos,
const Vec3fa (&v)[N+1],
PrimRef& left_o,
PrimRef& right_o)
{
BBox3fa left = empty, right = empty;
for (size_t i=0; i<N; i++)
{
const Vec3fa &v0 = v[i];
const Vec3fa &v1 = v[i+1];
const float v0d = v0[dim];
const float v1d = v1[dim];
if (v0d <= pos) left. extend(v0); // this point is on left side
if (v0d >= pos) right.extend(v0); // this point is on right side
if ((v0d < pos && pos < v1d) || (v1d < pos && pos < v0d)) // the edge crosses the splitting location
{
assert((v1d-v0d) != 0.0f);
const float inv_length = 1.0f/(v1d-v0d);
const Vec3fa c = madd(Vec3fa((pos-v0d)*inv_length),v1-v0,v0);
left.extend(c);
right.extend(c);
}
}
/* clip against current bounds */
new (&left_o ) PrimRef(intersect(left ,prim.bounds()),prim.geomID(), prim.primID());
new (&right_o) PrimRef(intersect(right,prim.bounds()),prim.geomID(), prim.primID());
}
struct TriangleSplitter
{
__forceinline TriangleSplitter(const Scene* scene, const PrimRef& prim)
{
const unsigned int mask = 0xFFFFFFFF >> RESERVED_NUM_SPATIAL_SPLITS_GEOMID_BITS;
const TriangleMesh* mesh = (const TriangleMesh*) scene->get(prim.geomID() & mask );
TriangleMesh::Triangle tri = mesh->triangle(prim.primID());
v[0] = mesh->vertex(tri.v[0]);
v[1] = mesh->vertex(tri.v[1]);
v[2] = mesh->vertex(tri.v[2]);
v[3] = mesh->vertex(tri.v[0]);
inv_length[0] = Vec3fa(1.0f) / (v[1]-v[0]);
inv_length[1] = Vec3fa(1.0f) / (v[2]-v[1]);
inv_length[2] = Vec3fa(1.0f) / (v[0]-v[2]);
}
__forceinline void operator() (const PrimRef& prim, const size_t dim, const float pos, PrimRef& left_o, PrimRef& right_o) const {
splitPolygon<3>(prim,dim,pos,v,left_o,right_o);
}
__forceinline void operator() (const BBox3fa& prim, const size_t dim, const float pos, BBox3fa& left_o, BBox3fa& right_o) const {
splitPolygon<3>(prim,dim,pos,v,inv_length,left_o,right_o);
}
private:
Vec3fa v[4];
Vec3fa inv_length[3];
};
struct TriangleSplitterFactory
{
__forceinline TriangleSplitterFactory(const Scene* scene)
: scene(scene) {}
__forceinline TriangleSplitter operator() (const PrimRef& prim) const {
return TriangleSplitter(scene,prim);
}
private:
const Scene* scene;
};
struct QuadSplitter
{
__forceinline QuadSplitter(const Scene* scene, const PrimRef& prim)
{
const unsigned int mask = 0xFFFFFFFF >> RESERVED_NUM_SPATIAL_SPLITS_GEOMID_BITS;
const QuadMesh* mesh = (const QuadMesh*) scene->get(prim.geomID() & mask );
QuadMesh::Quad quad = mesh->quad(prim.primID());
v[0] = mesh->vertex(quad.v[0]);
v[1] = mesh->vertex(quad.v[1]);
v[2] = mesh->vertex(quad.v[2]);
v[3] = mesh->vertex(quad.v[3]);
v[4] = mesh->vertex(quad.v[0]);
inv_length[0] = Vec3fa(1.0f) / (v[1]-v[0]);
inv_length[1] = Vec3fa(1.0f) / (v[2]-v[1]);
inv_length[2] = Vec3fa(1.0f) / (v[3]-v[2]);
inv_length[3] = Vec3fa(1.0f) / (v[0]-v[3]);
}
__forceinline void operator() (const PrimRef& prim, const size_t dim, const float pos, PrimRef& left_o, PrimRef& right_o) const {
splitPolygon<4>(prim,dim,pos,v,left_o,right_o);
}
__forceinline void operator() (const BBox3fa& prim, const size_t dim, const float pos, BBox3fa& left_o, BBox3fa& right_o) const {
splitPolygon<4>(prim,dim,pos,v,inv_length,left_o,right_o);
}
private:
Vec3fa v[5];
Vec3fa inv_length[4];
};
struct QuadSplitterFactory
{
__forceinline QuadSplitterFactory(const Scene* scene)
: scene(scene) {}
__forceinline QuadSplitter operator() (const PrimRef& prim) const {
return QuadSplitter(scene,prim);
}
private:
const Scene* scene;
};
struct DummySplitter
{
__forceinline DummySplitter(const Scene* scene, const PrimRef& prim)
{
}
};
struct DummySplitterFactory
{
__forceinline DummySplitterFactory(const Scene* scene)
: scene(scene) {}
__forceinline DummySplitter operator() (const PrimRef& prim) const {
return DummySplitter(scene,prim);
}
private:
const Scene* scene;
};
}
}
|