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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
// Copyright 2009-2020 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "geometry.h"
#include "buffer.h"
namespace embree
{
/*! Grid Mesh */
struct GridMesh : public Geometry
{
/*! type of this geometry */
static const Geometry::GTypeMask geom_type = Geometry::MTY_GRID_MESH;
/*! grid */
struct Grid
{
unsigned int startVtxID;
unsigned int lineVtxOffset;
unsigned short resX,resY;
/* border flags due to 3x3 vertex pattern */
__forceinline unsigned int get3x3FlagsX(const unsigned int x) const
{
return (x + 2 >= (unsigned int)resX) ? (1<<15) : 0;
}
/* border flags due to 3x3 vertex pattern */
__forceinline unsigned int get3x3FlagsY(const unsigned int y) const
{
return (y + 2 >= (unsigned int)resY) ? (1<<15) : 0;
}
/*! outputs grid structure */
__forceinline friend embree_ostream operator<<(embree_ostream cout, const Grid& t) {
return cout << "Grid { startVtxID " << t.startVtxID << ", lineVtxOffset " << t.lineVtxOffset << ", resX " << t.resX << ", resY " << t.resY << " }";
}
};
public:
/*! grid mesh construction */
GridMesh (Device* device);
/* geometry interface */
public:
void setMask(unsigned mask);
void setNumTimeSteps (unsigned int numTimeSteps);
void setVertexAttributeCount (unsigned int N);
void setBuffer(RTCBufferType type, unsigned int slot, RTCFormat format, const Ref<Buffer>& buffer, size_t offset, size_t stride, unsigned int num);
void* getBuffer(RTCBufferType type, unsigned int slot);
void updateBuffer(RTCBufferType type, unsigned int slot);
void commit();
bool verify();
void interpolate(const RTCInterpolateArguments* const args);
void addElementsToCount (GeometryCounts & counts) const;
__forceinline unsigned int getNumSubGrids(const size_t gridID)
{
const Grid &g = grid(gridID);
return max((unsigned int)1,((unsigned int)g.resX >> 1) * ((unsigned int)g.resY >> 1));
}
/*! get fast access to first vertex buffer */
__forceinline float * getCompactVertexArray () const {
return (float*) vertices0.getPtr();
}
public:
/*! returns number of vertices */
__forceinline size_t numVertices() const {
return vertices[0].size();
}
/*! returns i'th grid*/
__forceinline const Grid& grid(size_t i) const {
return grids[i];
}
/*! returns i'th vertex of the first time step */
__forceinline const Vec3fa vertex(size_t i) const { // FIXME: check if this does a unaligned load
return vertices0[i];
}
/*! returns i'th vertex of the first time step */
__forceinline const char* vertexPtr(size_t i) const {
return vertices0.getPtr(i);
}
/*! returns i'th vertex of itime'th timestep */
__forceinline const Vec3fa vertex(size_t i, size_t itime) const {
return vertices[itime][i];
}
/*! returns i'th vertex of itime'th timestep */
__forceinline const char* vertexPtr(size_t i, size_t itime) const {
return vertices[itime].getPtr(i);
}
/*! returns i'th vertex of the first timestep */
__forceinline size_t grid_vertex_index(const Grid& g, size_t x, size_t y) const {
assert(x < (size_t)g.resX);
assert(y < (size_t)g.resY);
return g.startVtxID + x + y * g.lineVtxOffset;
}
/*! returns i'th vertex of the first timestep */
__forceinline const Vec3fa grid_vertex(const Grid& g, size_t x, size_t y) const {
const size_t index = grid_vertex_index(g,x,y);
return vertex(index);
}
/*! returns i'th vertex of the itime'th timestep */
__forceinline const Vec3fa grid_vertex(const Grid& g, size_t x, size_t y, size_t itime) const {
const size_t index = grid_vertex_index(g,x,y);
return vertex(index,itime);
}
/*! calculates the build bounds of the i'th primitive, if it's valid */
__forceinline bool buildBounds(const Grid& g, size_t sx, size_t sy, BBox3fa& bbox) const
{
BBox3fa b(empty);
for (size_t t=0; t<numTimeSteps; t++)
{
for (size_t y=sy;y<min(sy+3,(size_t)g.resY);y++)
for (size_t x=sx;x<min(sx+3,(size_t)g.resX);x++)
{
const Vec3fa v = grid_vertex(g,x,y,t);
if (unlikely(!isvalid(v))) return false;
b.extend(v);
}
}
bbox = b;
return true;
}
/*! calculates the build bounds of the i'th primitive at the itime'th time segment, if it's valid */
__forceinline bool buildBounds(const Grid& g, size_t sx, size_t sy, size_t itime, BBox3fa& bbox) const
{
assert(itime < numTimeSteps);
BBox3fa b0(empty);
for (size_t y=sy;y<min(sy+3,(size_t)g.resY);y++)
for (size_t x=sx;x<min(sx+3,(size_t)g.resX);x++)
{
const Vec3fa v = grid_vertex(g,x,y,itime);
if (unlikely(!isvalid(v))) return false;
b0.extend(v);
}
/* use bounds of first time step in builder */
bbox = b0;
return true;
}
__forceinline bool valid(size_t gridID, size_t itime=0) const {
return valid(gridID, make_range(itime, itime));
}
/*! check if the i'th primitive is valid between the specified time range */
__forceinline bool valid(size_t gridID, const range<size_t>& itime_range) const
{
if (unlikely(gridID >= grids.size())) return false;
const Grid &g = grid(gridID);
if (unlikely(g.startVtxID + 0 >= vertices0.size())) return false;
if (unlikely(g.startVtxID + (g.resY-1)*g.lineVtxOffset + g.resX-1 >= vertices0.size())) return false;
for (size_t y=0;y<g.resY;y++)
for (size_t x=0;x<g.resX;x++)
for (size_t itime = itime_range.begin(); itime <= itime_range.end(); itime++)
if (!isvalid(grid_vertex(g,x,y,itime))) return false;
return true;
}
__forceinline BBox3fa bounds(const Grid& g, size_t sx, size_t sy, size_t itime) const
{
BBox3fa box(empty);
buildBounds(g,sx,sy,itime,box);
return box;
}
__forceinline LBBox3fa linearBounds(const Grid& g, size_t sx, size_t sy, size_t itime) const {
BBox3fa bounds0, bounds1;
buildBounds(g,sx,sy,itime+0,bounds0);
buildBounds(g,sx,sy,itime+1,bounds1);
return LBBox3fa(bounds0,bounds1);
}
/*! calculates the linear bounds of the i'th primitive for the specified time range */
__forceinline LBBox3fa linearBounds(const Grid& g, size_t sx, size_t sy, const BBox1f& dt) const {
return LBBox3fa([&] (size_t itime) { return bounds(g,sx,sy,itime); }, dt, time_range, fnumTimeSegments);
}
public:
BufferView<Grid> grids; //!< array of triangles
BufferView<Vec3fa> vertices0; //!< fast access to first vertex buffer
vector<BufferView<Vec3fa>> vertices; //!< vertex array for each timestep
vector<RawBufferView> vertexAttribs; //!< vertex attributes
};
namespace isa
{
struct GridMeshISA : public GridMesh
{
GridMeshISA (Device* device)
: GridMesh(device) {}
};
}
DECLARE_ISA_FUNCTION(GridMesh*, createGridMesh, Device*);
}
|