RTCScene convertScene(ISPCScene* scene_in)
{
for (unsigned int i=0; i<scene_in->numGeometries; i++)
{
ISPCGeometry* geometry = scene_in->geometries[i];
if (geometry->type == SUBDIV_MESH) {
g_subdiv_mode = true; break;
}
}
RTCScene scene_out = ConvertScene(g_device, g_ispc_scene, RTC_BUILD_QUALITY_MEDIUM);
rtcSetSceneProgressMonitorFunction(scene_out,monitorProgressFunction,nullptr);
/* commit individual objects in case of instancing */
if (g_instancing_mode != ISPC_INSTANCING_NONE)
{
for (unsigned int i=0; i<scene_in->numGeometries; i++) {
ISPCGeometry* geometry = g_ispc_scene->geometries[i];
if (geometry->type == GROUP) rtcCommitScene(geometry->scene);
}
}
/* commit changes to scene */
return scene_out;
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create scene */
g_scene = rtcNewScene(g_device);
rtcSetSceneFlags(g_scene,RTC_SCENE_FLAG_DYNAMIC | RTC_SCENE_FLAG_ROBUST);
rtcSetSceneBuildQuality(g_scene,RTC_BUILD_QUALITY_LOW);
/* create some triangulated spheres */
for (int i=0; i<numSpheres; i++)
{
const float phi = i*2.0f*float(pi)/numSpheres;
const float r = 2.0f*float(pi)/numSpheres;
const Vec3fa p = 2.0f*Vec3fa(sin(phi),0.0f,-cos(phi));
//RTCBuildQuality quality = i%3 == 0 ? RTC_BUILD_QUALITY_MEDIUM : i%3 == 1 ? RTC_BUILD_QUALITY_REFIT : RTC_BUILD_QUALITY_LOW;
RTCBuildQuality quality = i%2 ? RTC_BUILD_QUALITY_REFIT : RTC_BUILD_QUALITY_LOW;
//RTCBuildQuality quality = RTC_BUILD_QUALITY_REFIT;
int id = createSphere(quality,p,r);
position[id] = p;
radius[id] = r;
colors[id].x = (i%16+1)/17.0f;
colors[id].y = (i%8+1)/9.0f;
colors[id].z = (i%4+1)/5.0f;
}
/* add ground plane to scene */
int id = addGroundPlane(g_scene);
colors[id] = Vec3fa(1.0f,1.0f,1.0f);
/* commit changes to scene */
rtcCommitScene (g_scene);
/* set start render mode */
renderTile = renderTileStandard;
key_pressed_handler = device_key_pressed_default;
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const unsigned int width,
const unsigned int height,
const float time,
const ISPCCamera& camera)
{
bool camera_changed = g_changed; g_changed = false;
/* create scene */
if (g_scene == nullptr) {
g_scene = convertScene(g_ispc_scene);
if (g_subdiv_mode) updateEdgeLevels(g_ispc_scene, camera.xfm.p);
rtcCommitScene (g_scene);
old_p = camera.xfm.p;
}
else
{
/* check if camera changed */
if (ne(camera.xfm.p,old_p)) {
camera_changed = true;
old_p = camera.xfm.p;
}
/* update edge levels if camera changed */
if (camera_changed && g_subdiv_mode) {
updateEdgeLevels(g_ispc_scene,camera.xfm.p);
rtcCommitScene (g_scene);
}
}
/* render image */
const int numTilesX = (width +TILE_SIZE_X-1)/TILE_SIZE_X;
const int numTilesY = (height+TILE_SIZE_Y-1)/TILE_SIZE_Y;
parallel_for(size_t(0),size_t(numTilesX*numTilesY),[&](const range<size_t>& range) {
const int threadIndex = (int)TaskScheduler::threadIndex();
for (size_t i=range.begin(); i<range.end(); i++)
renderTileTask((int)i,threadIndex,pixels,width,height,time,camera,numTilesX,numTilesY);
});
//rtcDebug();
}
void Model::commit()
{
useEmbreeDynamicSceneFlag = getParam<int>("dynamicScene", 0);
useEmbreeCompactSceneFlag = getParam<int>("compactMode", 0);
useEmbreeRobustSceneFlag = getParam<int>("robustMode", 0);
postStatusMsg(2)
<< "=======================================================\n"
<< "Finalizing model, has " << geometry.size()
<< " geometries and " << volume.size() << " volumes";
RTCDevice embreeDevice = (RTCDevice)ospray_getEmbreeDevice();
int sceneFlags = 0;
sceneFlags =
sceneFlags | (useEmbreeDynamicSceneFlag ? RTC_SCENE_FLAG_DYNAMIC : 0);
sceneFlags =
sceneFlags | (useEmbreeCompactSceneFlag ? RTC_SCENE_FLAG_COMPACT : 0);
sceneFlags =
sceneFlags | (useEmbreeRobustSceneFlag ? RTC_SCENE_FLAG_ROBUST : 0);
ispc::Model_init(getIE(),
embreeDevice,
sceneFlags,
geometry.size(),
volume.size());
embreeSceneHandle = (RTCScene)ispc::Model_getEmbreeSceneHandle(getIE());
bounds = empty;
for (size_t i = 0; i < geometry.size(); i++) {
postStatusMsg(2)
<< "=======================================================\n"
<< "Finalizing geometry " << i;
geometry[i]->finalize(this);
bounds.extend(geometry[i]->bounds);
ispc::Model_setGeometry(getIE(), i, geometry[i]->getIE());
}
for (size_t i=0; i<volume.size(); i++)
ispc::Model_setVolume(getIE(), i, volume[i]->getIE());
rtcCommitScene(embreeSceneHandle);
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create scene */
g_scene = rtcNewScene(g_device);
rtcSetSceneFlags(g_scene,RTC_SCENE_FLAG_ROBUST);
/* add ground plane */
addGroundPlane(g_scene);
/* add cube */
addCube(g_scene);
/* commit changes to scene */
rtcCommitScene (g_scene);
/* set start render mode */
renderTile = renderTileStandard;
key_pressed_handler = device_key_pressed_default;
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const unsigned int width,
const unsigned int height,
const float time,
const ISPCCamera& camera)
{
#if !defined(FORCE_FIXED_EDGE_TESSELLATION)
setQuadSubdivCubeLevels (rtcGetGeometry(g_scene, quadCubeID), camera.xfm.p);
setTriangleSubdivCubeLevels (rtcGetGeometry(g_scene, triCubeID), camera.xfm.p);
#endif
rtcCommitScene(g_scene);
const int numTilesX = (width +TILE_SIZE_X-1)/TILE_SIZE_X;
const int numTilesY = (height+TILE_SIZE_Y-1)/TILE_SIZE_Y;
parallel_for(size_t(0),size_t(numTilesX*numTilesY),[&](const range<size_t>& range) {
const int threadIndex = (int)TaskScheduler::threadIndex();
for (size_t i=range.begin(); i<range.end(); i++)
renderTileTask((int)i,threadIndex,pixels,width,height,time,camera,numTilesX,numTilesY);
});
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const unsigned int width,
const unsigned int height,
const float time,
const ISPCCamera& camera)
{
/* animate sphere */
for (int i=0; i<numSpheres; i++)
animateSphere(i,time+i);
/* commit changes to scene */
rtcCommitScene (g_scene);
/* render all pixels */
const int numTilesX = (width +TILE_SIZE_X-1)/TILE_SIZE_X;
const int numTilesY = (height+TILE_SIZE_Y-1)/TILE_SIZE_Y;
parallel_for(size_t(0),size_t(numTilesX*numTilesY),[&](const range<size_t>& range) {
const int threadIndex = (int)TaskScheduler::threadIndex();
for (size_t i=range.begin(); i<range.end(); i++)
renderTileTask((int)i,threadIndex,pixels,width,height,time,camera,numTilesX,numTilesY);
});
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create scene */
g_scene = rtcNewScene(g_device);
/* add ground plane */
addGroundPlane(g_scene);
/* add cubes */
addCurve(g_scene,Vec3fa(4.0f,-1.0f,-3.5f));
quadCubeID = addQuadSubdivCube(g_scene,Vec3fa(4.0f,0.0f,0.0f));
triCubeID = addTriangleSubdivCube(g_scene,Vec3fa(4.0f,0.0f,3.5f));
addTriangleCube(g_scene,Vec3fa(0.0f,0.0f,-3.0f));
addQuadCube(g_scene,Vec3fa(0.0f,0.0f,3.0f));
/* commit changes to scene */
rtcCommitScene (g_scene);
/* set start render mode */
renderTile = renderTileStandard;
key_pressed_handler = device_key_pressed_default;
}
EmbreeScene::EmbreeScene(const EmbreeScene::Arguments& arguments)
{
// Start stopwatch.
Stopwatch<DefaultWallclockTimer> stopwatch;
stopwatch.start();
Statistics statistics;
m_device = arguments.m_device.m_device;
m_scene = rtcNewScene(m_device);
rtcSetSceneBuildQuality(
m_scene,
RTCBuildQuality::RTC_BUILD_QUALITY_HIGH);
const ObjectInstanceContainer& instance_container = arguments.m_assembly.object_instances();
const size_t instance_count = instance_container.size();
m_geometry_container.reserve(instance_count);
for (size_t instance_idx = 0; instance_idx < instance_count; ++instance_idx)
{
const ObjectInstance* object_instance = instance_container.get_by_index(instance_idx);
assert(object_instance);
RTCGeometry geometry_handle;
// Set per instance data.
unique_ptr<EmbreeGeometryData> geometry_data(new EmbreeGeometryData());
geometry_data->m_object_instance_idx = instance_idx;
geometry_data->m_vis_flags = object_instance->get_vis_flags();
//
// Collect geometry data for the instance.
//
const char* object_model = object_instance->get_object().get_model();
if (strcmp(object_model, MeshObjectFactory().get_model()) == 0)
{
geometry_data->m_geometry_type = RTC_GEOMETRY_TYPE_TRIANGLE;
// Retrieve triangle data.
collect_triangle_data(*object_instance, *geometry_data);
geometry_handle = rtcNewGeometry(
m_device,
RTC_GEOMETRY_TYPE_TRIANGLE);
rtcSetGeometryBuildQuality(
geometry_handle,
RTCBuildQuality::RTC_BUILD_QUALITY_HIGH);
rtcSetGeometryTimeStepCount(
geometry_handle,
geometry_data->m_motion_steps_count);
geometry_data->m_geometry_handle = geometry_handle;
const unsigned int vertices_count = geometry_data->m_vertices_count;
const unsigned int vertices_stride = geometry_data->m_vertices_stride;
for (unsigned int m = 0; m < geometry_data->m_motion_steps_count; ++m)
{
// Byte offset for the current motion segment.
const unsigned int vertices_offset = m * vertices_count * vertices_stride;
// Set vertices.
rtcSetSharedGeometryBuffer(
geometry_handle, // geometry
RTC_BUFFER_TYPE_VERTEX, // buffer type
m, // slot
RTC_FORMAT_FLOAT3, // format
geometry_data->m_vertices, // buffer
vertices_offset, // byte offset
vertices_stride, // byte stride
vertices_count); // item count
}
// Set vertex indices.
rtcSetSharedGeometryBuffer(
geometry_handle, // geometry
RTC_BUFFER_TYPE_INDEX, // buffer type
0, // slot
RTC_FORMAT_UINT3, // format
geometry_data->m_primitives, // buffer
0, // byte offset
geometry_data->m_primitives_stride, // byte stride
geometry_data->m_primitives_count); // item count
rtcSetGeometryMask(
geometry_handle,
geometry_data->m_vis_flags);
rtcCommitGeometry(geometry_handle);
}
else if (strcmp(object_model, CurveObjectFactory().get_model()) == 0)
{
geometry_data->m_geometry_type = RTC_GEOMETRY_TYPE_FLAT_BEZIER_CURVE;
// Retrieve curve data.
collect_curve_data(*object_instance, *geometry_data);
geometry_handle = rtcNewGeometry(
m_device,
RTC_GEOMETRY_TYPE_FLAT_BEZIER_CURVE);
rtcSetGeometryBuildQuality(
geometry_handle,
RTCBuildQuality::RTC_BUILD_QUALITY_HIGH);
// Set vertices. (x_pos, y_pos, z_pos, radii)
rtcSetSharedGeometryBuffer(
geometry_handle, // geometry
RTC_BUFFER_TYPE_INDEX, // buffer type
0, // slot
RTC_FORMAT_FLOAT4, // format
geometry_data->m_vertices, // buffer
0, // byte offset
geometry_data->m_vertices_stride, // byte stride
geometry_data->m_vertices_count); // item count
// Set vertex indices.
rtcSetSharedGeometryBuffer(
geometry_handle, // geometry
RTC_BUFFER_TYPE_INDEX, // buffer type
0, // slot
RTC_FORMAT_UINT4, // format
geometry_data->m_primitives, // buffer
0, // byte offset
geometry_data->m_primitives_stride, // byte stride
geometry_data->m_primitives_count); // item count
}
else
{
// Unsupported object type.
continue;
}
rtcAttachGeometryByID(m_scene, geometry_handle, static_cast<unsigned int>(instance_idx));
m_geometry_container.push_back(std::move(geometry_data));
}
rtcCommitScene(m_scene);
statistics.insert_time("total build time", stopwatch.measure().get_seconds());
RENDERER_LOG_DEBUG("%s",
StatisticsVector::make(
"Embree scene #" + to_string(arguments.m_assembly.get_uid()) + " statistics",
statistics).to_string().c_str());
}
