void BvhStrategy::Preprocess(World const& world)
{
// If something has been changed we need to rebuild BVH
if (!m_bvh || world.has_changed() || world.GetStateChange() != ShapeImpl::kStateChangeNone)
{
int numshapes = (int)world.shapes_.size();
int numvertices = 0;
int numfaces = 0;
// This buffer tracks mesh start index for next stage as mesh face indices are relative to 0
std::vector<int> mesh_vertices_start_idx(numshapes);
std::vector<int> mesh_faces_start_idx(numshapes);
// Recreate it
// First check if we need to use SAH
auto builder = world.options_.GetOption("bvh.builder");
bool enablesah = false;
if (builder && builder->AsString() == "sah")
{
enablesah = true;
}
m_bvh.reset(new Bvh(enablesah));
// Partition the array into meshes and instances
std::vector<Shape const*> shapes(world.shapes_);
auto firstinst = std::partition(shapes.begin(), shapes.end(),
[&](Shape const* shape)
{
return !static_cast<ShapeImpl const*>(shape)->is_instance();
});
// Count the number of meshes
int nummeshes = (int)std::distance(shapes.begin(), firstinst);
// Count the number of instances
int numinstances = (int)std::distance(firstinst, shapes.end());
for (int i = 0; i < nummeshes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
// We can't avoild allocating it here, since bounds aren't stored anywhere
std::vector<bbox> bounds(numfaces);
std::vector<ShapeData> shapedata(numshapes);
// We handle meshes first collecting their world space bounds
#pragma omp parallel for
for (int i = 0; i < nummeshes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
for (int j = 0; j < mesh->num_faces(); ++j)
{
// Here we directly get world space bounds
mesh->GetFaceBounds(j, false, bounds[mesh_faces_start_idx[i] + j]);
}
shapedata[i].id = mesh->GetId();
shapedata[i].mask = mesh->GetMask();
}
// Then we handle instances. Need to flatten them into actual geometry.
#pragma omp parallel for
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
// Instance is using its own transform for base shape geometry
// so we need to get object space bounds and transform them manually
matrix m, minv;
instance->GetTransform(m, minv);
for (int j = 0; j < mesh->num_faces(); ++j)
{
bbox tmp;
mesh->GetFaceBounds(j, true, tmp);
bounds[mesh_faces_start_idx[i] + j] = transform_bbox(tmp, m);
}
shapedata[i].id = instance->GetId();
shapedata[i].mask = instance->GetMask();
}
m_bvh->Build(&bounds[0], numfaces);
PlainBvhTranslator translator;
translator.Process(*m_bvh);
// Update GPU data
// Copy translated nodes first
m_gpudata->bvh = m_device->CreateBuffer(translator.nodes_.size() * sizeof(PlainBvhTranslator::Node), Calc::BufferType::kRead, &translator.nodes_[0]);
// Create vertex buffer
{
// Vertices
m_gpudata->vertices = m_device->CreateBuffer(numvertices * sizeof(float3), Calc::BufferType::kRead);
// Get the pointer to mapped data
float3* vertexdata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->vertices, 0, 0, numvertices * sizeof(float3), Calc::MapType::kMapWrite, (void**)&vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here we need to put data in world space rather than object space
// So we need to get the transform from the mesh and multiply each vertex
matrix m, minv;
#pragma omp parallel for
for (int i = 0; i < nummeshes; ++i)
{
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
mesh->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
#pragma omp parallel for
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
instance->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
m_device->UnmapBuffer(m_gpudata->vertices, 0, vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
// Create face buffer
{
struct Face
{
// Up to 3 indices
int idx[3];
// Shape index
int shapeidx;
// Primitive ID within the mesh
int id;
// Idx count
int cnt;
};
// Create face buffer
m_gpudata->faces = m_device->CreateBuffer(numfaces * sizeof(Face), Calc::BufferType::kRead);
// Get the pointer to mapped data
Face* facedata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->faces, 0, 0, numfaces * sizeof(Face), Calc::BufferType::kWrite, (void**)&facedata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here the point is to add mesh starting index to actual index contained within the mesh,
// getting absolute index in the buffer.
// Besides that we need to permute the faces accorningly to BVH reordering, whihc
// is contained within bvh.primids_
int const* reordering = m_bvh->GetIndices();
for (int i = 0; i < numfaces; ++i)
{
int indextolook4 = reordering[i];
// We need to find a shape corresponding to current face
auto iter = std::upper_bound(mesh_faces_start_idx.cbegin(), mesh_faces_start_idx.cend(), indextolook4);
// Find the index of the shape
int shapeidx = static_cast<int>(std::distance(mesh_faces_start_idx.cbegin(), iter) - 1);
// Get the mesh directly or out of instance
Mesh const* mesh = nullptr;
if (shapeidx < nummeshes)
{
mesh = static_cast<Mesh const*>(shapes[shapeidx]);
}
else
{
mesh = static_cast<Mesh const*>(static_cast<Instance const*>(shapes[shapeidx])->GetBaseShape());
}
// Get vertex buffer of the current mesh
Mesh::Face const* myfacedata = mesh->GetFaceData();
// Find face idx
int faceidx = indextolook4 - mesh_faces_start_idx[shapeidx];
// Find mesh start idx
int mystartidx = mesh_vertices_start_idx[shapeidx];
// Copy face data to GPU buffer
facedata[i].idx[0] = myfacedata[faceidx].idx[0] + mystartidx;
facedata[i].idx[1] = myfacedata[faceidx].idx[1] + mystartidx;
facedata[i].idx[2] = myfacedata[faceidx].idx[2] + mystartidx;
facedata[i].shapeidx = shapeidx;
facedata[i].cnt = 0;
facedata[i].id = faceidx;
}
m_device->UnmapBuffer(m_gpudata->faces, 0, facedata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
// Create shapes buffer
m_gpudata->shapes = m_device->CreateBuffer(numshapes * sizeof(ShapeData), Calc::BufferType::kRead, &shapedata[0]);
// Create helper raycounter buffer
m_gpudata->raycnt = m_device->CreateBuffer(sizeof(int), Calc::BufferType::kWrite);
// Make sure everything is commited
m_device->Finish(0);
}
}
void IntersectorShortStack::Process(World const& world)
{
// If something has been changed we need to rebuild BVH
if (!m_bvh || world.has_changed() || world.GetStateChange() != ShapeImpl::kStateChangeNone)
{
if (m_bvh)
{
m_device->DeleteBuffer(m_gpudata->bvh);
m_device->DeleteBuffer(m_gpudata->vertices);
}
// Check if we can allocate enough stack memory
Calc::DeviceSpec spec;
m_device->GetSpec(spec);
if (spec.max_alloc_size <= kMaxBatchSize * kMaxStackSize * sizeof(int))
{
throw ExceptionImpl("fatbvh accelerator can't allocate enough stack memory, try using bvh instead");
}
int numshapes = (int)world.shapes_.size();
int numvertices = 0;
int numfaces = 0;
// This buffer tracks mesh start index for next stage as mesh face indices are relative to 0
std::vector<int> mesh_vertices_start_idx(numshapes);
std::vector<int> mesh_faces_start_idx(numshapes);
auto builder = world.options_.GetOption("bvh.builder");
auto splits = world.options_.GetOption("bvh.sah.use_splits");
auto maxdepth = world.options_.GetOption("bvh.sah.max_split_depth");
auto overlap = world.options_.GetOption("bvh.sah.min_overlap");
auto tcost = world.options_.GetOption("bvh.sah.traversal_cost");
auto node_budget = world.options_.GetOption("bvh.sah.extra_node_budget");
auto nbins = world.options_.GetOption("bvh.sah.num_bins");
bool use_sah = false;
bool use_splits = false;
int max_split_depth = maxdepth ? (int)maxdepth->AsFloat() : 10;
int num_bins = nbins ? (int)nbins->AsFloat() : 64;
float min_overlap = overlap ? overlap->AsFloat() : 0.05f;
float traversal_cost = tcost ? tcost->AsFloat() : 10.f;
float extra_node_budget = node_budget ? node_budget->AsFloat() : 0.5f;
if (builder && builder->AsString() == "sah")
{
use_sah = true;
}
if (splits && splits->AsFloat() > 0.f)
{
use_splits = true;
}
m_bvh.reset(use_splits ?
new SplitBvh(traversal_cost, num_bins, max_split_depth, min_overlap, extra_node_budget) :
new Bvh(traversal_cost, num_bins, use_sah)
);
// Partition the array into meshes and instances
std::vector<Shape const*> shapes(world.shapes_);
auto firstinst = std::partition(shapes.begin(), shapes.end(),
[&](Shape const* shape)
{
return !static_cast<ShapeImpl const*>(shape)->is_instance();
});
// Count the number of meshes
int nummeshes = (int)std::distance(shapes.begin(), firstinst);
// Count the number of instances
int numinstances = (int)std::distance(firstinst, shapes.end());
for (int i = 0; i < nummeshes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
// We can't avoild allocating it here, since bounds aren't stored anywhere
std::vector<bbox> bounds(numfaces);
// We handle meshes first collecting their world space bounds
#pragma omp parallel for
for (int i = 0; i < nummeshes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
for (int j = 0; j < mesh->num_faces(); ++j)
{
// Here we directly get world space bounds
mesh->GetFaceBounds(j, false, bounds[mesh_faces_start_idx[i] + j]);
}
}
// Then we handle instances. Need to flatten them into actual geometry.
#pragma omp parallel for
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
// Instance is using its own transform for base shape geometry
// so we need to get object space bounds and transform them manually
matrix m, minv;
instance->GetTransform(m, minv);
for (int j = 0; j < mesh->num_faces(); ++j)
{
bbox tmp;
mesh->GetFaceBounds(j, true, tmp);
bounds[mesh_faces_start_idx[i] + j] = transform_bbox(tmp, m);
}
}
m_bvh->Build(&bounds[0], numfaces);
#ifdef RR_PROFILE
m_bvh->PrintStatistics(std::cout);
#endif
// Check if the tree height is reasonable
if (m_bvh->GetHeight() >= kMaxStackSize)
{
m_bvh.reset(nullptr);
throw ExceptionImpl("fatbvh accelerator can cause stack overflow for this scene, try using bvh instead");
}
FatNodeBvhTranslator translator;
translator.Process(*m_bvh);
// Update GPU data
// Create vertex buffer
{
// Vertices
m_gpudata->vertices = m_device->CreateBuffer(numvertices * sizeof(float3), Calc::BufferType::kRead);
// Get the pointer to mapped data
float3* vertexdata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->vertices, 0, 0, numvertices * sizeof(float3), Calc::MapType::kMapWrite, (void**)&vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here we need to put data in world space rather than object space
// So we need to get the transform from the mesh and multiply each vertex
matrix m, minv;
#pragma omp parallel for
for (int i = 0; i < nummeshes; ++i)
{
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
mesh->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
#pragma omp parallel for
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
instance->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
m_device->UnmapBuffer(m_gpudata->vertices, 0, vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
// Create face buffer
{
// This number is different from the number of faces for some BVHs
auto numindices = m_bvh->GetNumIndices();
std::vector<FatNodeBvhTranslator::Face> facedata(numindices);
// Here the point is to add mesh starting index to actual index contained within the mesh,
// getting absolute index in the buffer.
// Besides that we need to permute the faces accorningly to BVH reordering, whihc
// is contained within bvh.primids_
int const* reordering = m_bvh->GetIndices();
for (int i = 0; i < numindices; ++i)
{
int indextolook4 = reordering[i];
// We need to find a shape corresponding to current face
auto iter = std::upper_bound(mesh_faces_start_idx.cbegin(), mesh_faces_start_idx.cend(), indextolook4);
// Find the index of the shape
int shapeidx = static_cast<int>(std::distance(mesh_faces_start_idx.cbegin(), iter) - 1);
// Get the mesh directly or out of instance
Mesh const* mesh = nullptr;
if (shapeidx < nummeshes)
{
mesh = static_cast<Mesh const*>(shapes[shapeidx]);
}
else
{
mesh = static_cast<Mesh const*>(static_cast<Instance const*>(shapes[shapeidx])->GetBaseShape());
}
// Get vertex buffer of the current mesh
Mesh::Face const* myfacedata = mesh->GetFaceData();
// Find face idx
int faceidx = indextolook4 - mesh_faces_start_idx[shapeidx];
// Find mesh start idx
int mystartidx = mesh_vertices_start_idx[shapeidx];
// Copy face data to GPU buffer
facedata[i].idx[0] = myfacedata[faceidx].idx[0] + mystartidx;
facedata[i].idx[1] = myfacedata[faceidx].idx[1] + mystartidx;
facedata[i].idx[2] = myfacedata[faceidx].idx[2] + mystartidx;
facedata[i].shapeidx = shapes[shapeidx]->GetId();
facedata[i].shape_mask = shapes[shapeidx]->GetMask();
facedata[i].id = faceidx;
}
translator.InjectIndices(&facedata[0]);
}
// Copy translated nodes first
m_gpudata->bvh = m_device->CreateBuffer(translator.nodes_.size() * sizeof(FatNodeBvhTranslator::Node), Calc::BufferType::kRead, &translator.nodes_[0]);
// Stack
m_gpudata->stack = m_device->CreateBuffer(kMaxBatchSize*kMaxStackSize, Calc::BufferType::kWrite);
// Make sure everything is commited
m_device->Finish(0);
}
}
void HlbvhStrategy::Preprocess(World const& world)
{
// If something has been changed we need to rebuild BVH
if (!m_bvh || world.has_changed())
{
if (m_bvh)
{
m_device->DeleteBuffer(m_gpudata->vertices);
m_device->DeleteBuffer(m_gpudata->faces);
m_device->DeleteBuffer(m_gpudata->shapes);
m_device->DeleteBuffer(m_gpudata->raycnt);
}
int numshapes = (int)world.shapes_.size();
int numvertices = 0;
int numfaces = 0;
// This buffer tracks mesh start index for next stage as mesh face indices are relative to 0
std::vector<int> mesh_vertices_start_idx(numshapes);
std::vector<int> mesh_faces_start_idx(numshapes);
//
m_bvh.reset(new Hlbvh(m_device));
// Here we now that only Meshes are present, otherwise 2level strategy would have been used
for (int i = 0; i < numshapes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(world.shapes_[i]);
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
// We can't avoid allocating it here, since bounds aren't stored anywhere
std::vector<bbox> bounds(numfaces);
std::vector<ShapeData> shapes(numshapes);
#pragma omp parallel for
for (int i = 0; i < numshapes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(world.shapes_[i]);
for (int j = 0; j < mesh->num_faces(); ++j)
{
mesh->GetFaceBounds(j, false, bounds[mesh_faces_start_idx[i] + j]);
}
shapes[i].id = mesh->GetId();
shapes[i].mask = mesh->GetMask();
}
m_bvh->Build(&bounds[0], numfaces);
// Create vertex buffer
{
// Vertices
m_gpudata->vertices = m_device->CreateBuffer(numvertices * sizeof(float3), Calc::BufferType::kRead);
// Get the pointer to mapped data
float3* vertexdata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->vertices, 0, 0, numvertices * sizeof(float3), Calc::MapType::kMapWrite, (void**)&vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here we need to put data in world space rather than object space
// So we need to get the transform from the mesh and multiply each vertex
matrix m, minv;
#pragma omp parallel for
for (int i = 0; i < numshapes; ++i)
{
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(world.shapes_[i]);
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
mesh->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
m_device->UnmapBuffer(m_gpudata->vertices, 0, vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
// Create face buffer
{
struct Face
{
// Up to 3 indices
int idx[3];
// Shape idx
int shapeidx;
// Primitive ID within the mesh
int id;
// Idx count
int cnt;
};
// Create face buffer
{
struct Face
{
// Up to 3 indices
int idx[3];
// Shape index
int shapeidx;
// Primitive ID within the mesh
int id;
// Idx count
int cnt;
};
// Create face buffer
m_gpudata->faces = m_device->CreateBuffer(numfaces * sizeof(Face), Calc::BufferType::kRead);
// Get the pointer to mapped data
Face* facedata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->faces, 0, 0, numfaces * sizeof(Face), Calc::BufferType::kWrite, (void**)&facedata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here the point is to add mesh starting index to actual index contained within the mesh,
// getting absolute index in the buffer.
// Besides that we need to permute the faces accorningly to BVH reordering, whihc
// is contained within bvh.primids_
for (int i = 0; i < numfaces; ++i)
{
int indextolook4 = i;
// We need to find a shape corresponding to current face
auto iter = std::upper_bound(mesh_faces_start_idx.cbegin(), mesh_faces_start_idx.cend(), indextolook4);
// Find the index of the shape
int shapeidx = static_cast<int>(std::distance(mesh_faces_start_idx.cbegin(), iter) - 1);
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(world.shapes_[shapeidx]);
// Get vertex buffer of the current mesh
Mesh::Face const* myfacedata = mesh->GetFaceData();
// Find face idx
int faceidx = indextolook4 - mesh_faces_start_idx[shapeidx];
// Find mesh start idx
int mystartidx = mesh_vertices_start_idx[shapeidx];
// Copy face data to GPU buffer
facedata[i].idx[0] = myfacedata[faceidx].idx[0] + mystartidx;
facedata[i].idx[1] = myfacedata[faceidx].idx[1] + mystartidx;
facedata[i].idx[2] = myfacedata[faceidx].idx[2] + mystartidx;
facedata[i].shapeidx = shapeidx;
facedata[i].cnt = (myfacedata[faceidx].type_ == Mesh::FaceType::QUAD ? 4 : 3);
facedata[i].id = faceidx;
}
m_device->UnmapBuffer(m_gpudata->faces, 0, facedata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
}
// Create shapes buffer
m_gpudata->shapes = m_device->CreateBuffer(numshapes * sizeof(ShapeData), Calc::BufferType::kRead, &shapes[0]);
// Create helper raycounter buffer
m_gpudata->raycnt = m_device->CreateBuffer(sizeof(int), Calc::BufferType::kWrite);
// Stack
m_gpudata->stack = m_device->CreateBuffer(kMaxBatchSize*kMaxStackSize, Calc::BufferType::kWrite);
// Make sure everything is commited
m_device->Finish(0);
}
else if (world.GetStateChange() != ShapeImpl::kStateChangeNone)
{
int numshapes = (int)world.shapes_.size();
int numvertices = 0;
int numfaces = 0;
// This buffer tracks mesh start index for next stage as mesh face indices are relative to 0
std::vector<int> mesh_vertices_start_idx(numshapes);
std::vector<int> mesh_faces_start_idx(numshapes);
//
//bvh_.reset(new Hlbvh(context_));
// Here we now that only Meshes are present, otherwise 2level strategy would have been used
for (int i = 0; i < numshapes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(world.shapes_[i]);
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
// We can't avoid allocating it here, since bounds aren't stored anywhere
std::vector<bbox> bounds(numfaces);
#pragma omp parallel for
for (int i = 0; i < numshapes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(world.shapes_[i]);
for (int j = 0; j < mesh->num_faces(); ++j)
{
mesh->GetFaceBounds(j, false, bounds[mesh_faces_start_idx[i] + j]);
}
}
m_bvh->Build(&bounds[0], numfaces);
// Create vertex buffer
{
// Vertices
m_gpudata->vertices = m_device->CreateBuffer(numvertices * sizeof(float3), Calc::BufferType::kRead);
// Get the pointer to mapped data
float3* vertexdata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->vertices, 0, 0, numvertices * sizeof(float3), Calc::MapType::kMapWrite, (void**)&vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here we need to put data in world space rather than object space
// So we need to get the transform from the mesh and multiply each vertex
matrix m, minv;
#pragma omp parallel for
for (int i = 0; i < numshapes; ++i)
{
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(world.shapes_[i]);
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
mesh->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
m_device->UnmapBuffer(m_gpudata->vertices, 0, vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
}
}