/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create new Embree device */
g_device = rtcNewDevice(cfg);
error_handler(rtcDeviceGetError(g_device));
/* set error handler */
rtcDeviceSetErrorFunction(g_device,error_handler);
/* create scene */
g_scene = rtcDeviceNewScene(g_device, RTC_SCENE_STATIC,RTC_INTERSECT1 | RTC_INTERPOLATE);
/* add ground plane */
addGroundPlane(g_scene);
/* add curve */
addCurve(g_scene,Vec3fa(0.0f,0.0f,0.0f));
/* commit changes to scene */
rtcCommit (g_scene);
/* set start render mode */
renderTile = renderTileStandard;
key_pressed_handler = device_key_pressed_default;
}
/* called by the C++ code for initialization */
extern "C" void device_init (int8* cfg)
{
/* initialize ray tracing core */
rtcInit(cfg);
/* create scene */
g_scene = rtcNewScene(RTC_SCENE_DYNAMIC,RTC_INTERSECT1);
/* 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 Vec3f p = 2.0f*Vec3f(sin(phi),0.0f,-cos(phi));
RTCGeometryFlags flags = i%2 ? RTC_GEOMETRY_DEFORMABLE : RTC_GEOMETRY_DYNAMIC;
//RTCGeometryFlags flags = RTC_GEOMETRY_DEFORMABLE;
int id = createSphere(flags,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] = Vec3f(1.0f,1.0f,1.0f);
/* commit changes to scene */
rtcCommit (g_scene);
/* set start render mode */
renderPixel = renderPixelStandard;
}
void Raytracer::buildScene()
{
SceneVisitor visitor(_meshes);
_rootNode->accept(visitor);
for (int meshId = 0; meshId < _meshes.size();++meshId)
{
unsigned int geoId = rtcNewTriangleMesh (_scene, RTC_GEOMETRY_STATIC, _meshes[meshId].getNumTriangles(), _meshes[meshId].getNumVertices());
osg::Vec4f* vertices = ( osg::Vec4f*) rtcMapBuffer(_scene,geoId,RTC_VERTEX_BUFFER);
for (int i =0; i < _meshes[meshId].getNumVertices();++i)
{
Vertex tri = _meshes[meshId].getVertices()[i];
vertices[i].x() =tri.pos.x();
vertices[i].y() =tri.pos.y();
vertices[i].z() =tri.pos.z();
}
rtcUnmapBuffer(_scene,geoId,RTC_VERTEX_BUFFER);
osg::Vec3i* triangles = (osg::Vec3i*) rtcMapBuffer(_scene,geoId,RTC_INDEX_BUFFER);
for (int i =0; i < _meshes[meshId].getNumTriangles();++i)
{
Triangle tri = _meshes[meshId].getTriangles()[i];
triangles[i].x() =tri.v0;
triangles[i].y() =tri.v1;
triangles[i].z() =tri.v2;
}
rtcUnmapBuffer(_scene,geoId,RTC_INDEX_BUFFER);
_geoToMesh[geoId] = meshId;
_meshToGeo[meshId] = geoId;
}
rtcCommit(_scene);
}
void lazyCreate(LazyGeometry* instance)
{
/* one thread will switch the object from the LAZY_INVALID state to the LAZY_CREATE state */
if (atomic_cmpxchg((int32_t*)&instance->state,LAZY_INVALID,LAZY_CREATE) == 0)
{
/* create the geometry */
printf("creating sphere %i\n",instance->userID);
instance->object = rtcDeviceNewScene(g_device,RTC_SCENE_STATIC,RTC_INTERSECT1);
createTriangulatedSphere(instance->object,instance->center,instance->radius);
/* now switch to the LAZY_COMMIT state */
__memory_barrier();
instance->state = LAZY_COMMIT;
}
else
{
/* wait until the geometry got created */
while (atomic_cmpxchg((int32_t*)&instance->state,10,11) < LAZY_COMMIT) {
// instead of actively spinning here, best use a condition to let the thread sleep, or let it help in the creation stage
}
}
/* multiple threads might enter the rtcCommit function to jointly
* build the internal data structures */
rtcCommit(instance->object);
/* switch to LAZY_VALID state */
atomic_cmpxchg((int32_t*)&instance->state,LAZY_COMMIT,LAZY_VALID);
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const int width,
const int height,
const float time,
const Vec3fa& vx,
const Vec3fa& vy,
const Vec3fa& vz,
const Vec3fa& p)
{
/* recompute levels */
updateEdgeLevelBuffer(g_scene,0,p);
/* rebuild scene */
#if !defined(PARALLEL_COMMIT)
rtcCommit (g_scene);
#else
launch[ getNumHWThreads() ] parallelCommit(g_scene);
#endif
/* render image */
const int numTilesX = (width +TILE_SIZE_X-1)/TILE_SIZE_X;
const int numTilesY = (height+TILE_SIZE_Y-1)/TILE_SIZE_Y;
launch_renderTile(numTilesX*numTilesY,pixels,width,height,time,vx,vy,vz,p,numTilesX,numTilesY);
rtcDebug();
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const int width,
const int height,
const float time,
const Vec3fa& vx,
const Vec3fa& vy,
const Vec3fa& vz,
const Vec3fa& p)
{
/* animate sphere */
for (int i=0; i<numSpheres; i++)
animateSphere(i,time+i);
/* commit changes to scene */
#if !defined(PARALLEL_COMMIT)
rtcCommit (g_scene);
#else
launch[ getNumHWThreads() ] parallelCommit(g_scene);
#endif
/* 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;
launch_renderTile(numTilesX*numTilesY,pixels,width,height,time,vx,vy,vz,p,numTilesX,numTilesY);
rtcDebug();
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create new Embree device */
g_device = rtcNewDevice(cfg);
error_handler(nullptr,rtcDeviceGetError(g_device));
/* set error handler */
rtcDeviceSetErrorFunction2(g_device,error_handler,nullptr);
/* create scene */
RTCAlgorithmFlags aflags;
if (g_mode == MODE_NORMAL) aflags = RTC_INTERSECT1;
else aflags = RTC_INTERSECT1 | RTC_INTERSECT_STREAM;
g_scene = rtcDeviceNewScene(g_device, RTC_SCENE_STATIC | RTC_SCENE_HIGH_QUALITY,aflags);
/* add cube */
addCube(g_scene,Vec3fa(0.0f,0.0f,0.0f),Vec3fa(10.0f,1.0f,1.0f),45.0f);
//addSubdivCube(g_scene);
/* add ground plane */
addGroundPlane(g_scene);
/* commit changes to scene */
rtcCommit (g_scene);
/* set start render mode */
if (g_mode == MODE_NORMAL) renderTile = renderTileStandard;
else renderTile = renderTileStandardStream;
key_pressed_handler = device_key_pressed_default;
}
EmbreeScene *embree_init(OzyScene ozy_scene) {
RTCDevice dev = rtcNewDevice(NULL);
RTCScene scene = rtcDeviceNewScene(dev,RTC_SCENE_STATIC, RTC_INTERSECT1);
for(unsigned i=0;i<ozy_scene.objects.count;i++){
Object *obj = ozy_scene.objects.data + i;
unsigned geomID = rtcNewTriangleMesh(scene, RTC_GEOMETRY_STATIC ,
obj->num_tris, obj->num_verts);
float* vertices = static_cast<float*>(rtcMapBuffer(scene, geomID,
RTC_VERTEX_BUFFER));
for(u32 ii=0;ii<obj->num_verts;ii++){
vertices[ii * 4 + 0] = obj->verts[ii].x;
vertices[ii * 4 + 1] = obj->verts[ii].y;
vertices[ii * 4 + 2] = obj->verts[ii].z;
}
rtcUnmapBuffer(scene, geomID, RTC_VERTEX_BUFFER);
u32* triangles = static_cast<u32*>( rtcMapBuffer(scene, geomID, RTC_INDEX_BUFFER));
for(u32 ii=0;ii<obj->num_tris*3;ii++){
triangles[ii] = obj->tris[ii];
}
rtcUnmapBuffer(scene, geomID, RTC_INDEX_BUFFER);
}
rtcCommit(scene);
EmbreeScene *embree_scene = new EmbreeScene;
embree_scene->dev = dev;
embree_scene->scene = scene;
return embree_scene;
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create new Embree device */
g_device = rtcNewDevice(cfg);
/* configure the size of the software cache used for subdivision geometry */
rtcDeviceSetParameter1i(g_device,RTC_SOFTWARE_CACHE_SIZE,100*1024*1024);
/* set error handler */
rtcDeviceSetErrorFunction(g_device,error_handler);
/* create scene */
g_scene = rtcDeviceNewScene(g_device,RTC_SCENE_DYNAMIC | RTC_SCENE_ROBUST,RTC_INTERSECT1 | RTC_INTERPOLATE);
/* add ground plane */
addGroundPlane(g_scene);
/* add cube */
addCube(g_scene);
/* commit changes to scene */
rtcCommit (g_scene);
/* set start render mode */
renderPixel = renderPixelStandard;
key_pressed_handler = device_key_pressed_default;
}
RTCScene convertScene(ISPCScene* scene_in)
{
for (size_t i=0; i<scene_in->numGeometries; i++)
{
ISPCGeometry* geometry = scene_in->geometries[i];
if (geometry->type == SUBDIV_MESH) {
g_subdiv_mode = true; break;
}
}
int scene_flags = RTC_SCENE_STATIC | RTC_SCENE_INCOHERENT;
int scene_aflags = RTC_INTERSECT1 | RTC_INTERPOLATE;
if (g_subdiv_mode)
scene_flags = RTC_SCENE_DYNAMIC | RTC_SCENE_INCOHERENT | RTC_SCENE_ROBUST;
RTCScene scene_out = ConvertScene(g_device, g_ispc_scene,(RTCSceneFlags)scene_flags, (RTCAlgorithmFlags) scene_aflags, RTC_GEOMETRY_STATIC);
/* commit individual objects in case of instancing */
if (g_instancing_mode == ISPC_INSTANCING_SCENE_GEOMETRY || g_instancing_mode == ISPC_INSTANCING_SCENE_GROUP)
{
for (unsigned int i=0; i<scene_in->numGeometries; i++) {
if (scene_in->geomID_to_scene[i]) rtcCommit(scene_in->geomID_to_scene[i]);
}
}
/* commit changes to scene */
return scene_out;
}
/* main function in embree namespace */
int main(int argc, char** argv)
{
/* for best performance set FTZ and DAZ flags in MXCSR control and status register */
_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
_MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
/* initialize ray tracing core and force bvh4.triangle4v hierarchy for triangles */
rtcInit("tri_accel=bvh4.triangle4v");
/* set error handler */
rtcSetErrorFunction(error_handler);
/* create scene */
g_scene = rtcNewScene(RTC_SCENE_STATIC,RTC_INTERSECT1);
addCube(g_scene,Vec3fa(-1,0,0));
addCube(g_scene,Vec3fa(1,0,0));
addCube(g_scene,Vec3fa(0,0,-1));
addCube(g_scene,Vec3fa(0,0,1));
addHair(g_scene);
addGroundPlane(g_scene);
rtcCommit (g_scene);
/* print triangle BVH */
print_bvh(g_scene);
/* cleanup */
rtcDeleteScene (g_scene);
rtcExit();
return 0;
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const int width,
const int height,
const float time,
const Vec3f& vx,
const Vec3f& vy,
const Vec3f& vz,
const Vec3f& p)
{
/* move instances */
float t = 0.7f*time;
g_instance0->local2world.p = mul(2.0f,Vec3f(+cos(t),0.0f,+sin(t)));
g_instance1->local2world.p = mul(2.0f,Vec3f(-cos(t),0.0f,-sin(t)));
g_instance2->local2world.p = mul(2.0f,Vec3f(-sin(t),0.0f,+cos(t)));
g_instance3->local2world.p = mul(2.0f,Vec3f(+sin(t),0.0f,-cos(t)));
updateInstance(g_scene,g_instance0);
updateInstance(g_scene,g_instance1);
updateInstance(g_scene,g_instance2);
updateInstance(g_scene,g_instance3);
rtcCommit (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;
launch_renderTile(numTilesX*numTilesY,pixels,width,height,time,vx,vy,vz,p,numTilesX,numTilesY);
rtcDebug();
}
/* called by the C++ code for initialization */
extern "C" void device_init (int8* cfg)
{
/* initialize ray tracing core */
rtcInit(cfg);
/* set error handler */
rtcSetErrorFunction(error_handler);
/* create scene */
g_scene = rtcNewScene(RTC_SCENE_DYNAMIC | RTC_SCENE_ROBUST,RTC_INTERSECT1);
/* add cube */
addCube(g_scene);
/* add ground plane */
addGroundPlane(g_scene);
/* commit changes to scene */
#if !defined(PARALLEL_COMMIT)
rtcCommit (g_scene);
#else
launch[ getNumHWThreads() ] parallelCommit(g_scene);
#endif
/* set start render mode */
renderPixel = renderPixelStandard;
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create new Embree device */
g_device = rtcNewDevice(cfg);
error_handler(rtcDeviceGetError(g_device));
/* set error handler */
rtcDeviceSetErrorFunction(g_device,error_handler);
RTCAlgorithmFlags aflags;
if (g_mode == MODE_NORMAL) aflags = RTC_INTERSECT1;
else aflags = RTC_INTERSECT1 | RTC_INTERSECT_STREAM;
/* create scene */
g_scene = rtcDeviceNewScene(g_device, RTC_SCENE_DYNAMIC,aflags);
/* create scene with 4 triangulated spheres */
g_scene1 = rtcDeviceNewScene(g_device, RTC_SCENE_STATIC,aflags);
createTriangulatedSphere(g_scene1,Vec3fa( 0, 0,+1),0.5);
createTriangulatedSphere(g_scene1,Vec3fa(+1, 0, 0),0.5);
createTriangulatedSphere(g_scene1,Vec3fa( 0, 0,-1),0.5);
createTriangulatedSphere(g_scene1,Vec3fa(-1, 0, 0),0.5);
rtcCommit (g_scene1);
/* instantiate geometry */
g_instance0 = rtcNewInstance(g_scene,g_scene1);
g_instance1 = rtcNewInstance(g_scene,g_scene1);
g_instance2 = rtcNewInstance(g_scene,g_scene1);
g_instance3 = rtcNewInstance(g_scene,g_scene1);
createGroundPlane(g_scene);
/* set all colors */
colors[0][0] = Vec3fa(0.25,0,0);
colors[0][1] = Vec3fa(0.50,0,0);
colors[0][2] = Vec3fa(0.75,0,0);
colors[0][3] = Vec3fa(1.00,0,0);
colors[1][0] = Vec3fa(0,0.25,0);
colors[1][1] = Vec3fa(0,0.50,0);
colors[1][2] = Vec3fa(0,0.75,0);
colors[1][3] = Vec3fa(0,1.00,0);
colors[2][0] = Vec3fa(0,0,0.25);
colors[2][1] = Vec3fa(0,0,0.50);
colors[2][2] = Vec3fa(0,0,0.75);
colors[2][3] = Vec3fa(0,0,1.00);
colors[3][0] = Vec3fa(0.25,0.25,0);
colors[3][1] = Vec3fa(0.50,0.50,0);
colors[3][2] = Vec3fa(0.75,0.75,0);
colors[3][3] = Vec3fa(1.00,1.00,0);
/* set start render mode */
if (g_mode == MODE_NORMAL) renderTile = renderTileStandard;
else renderTile = renderTileStandardStream;
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);
rtcCommit (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);
rtcCommit (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();
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* initialize ray tracing core */
rtcInit(cfg);
/* set error handler */
rtcSetErrorFunction(error_handler);
/* create scene */
g_scene = rtcNewScene(RTC_SCENE_DYNAMIC,RTC_INTERSECT1);
/* create scene with 4 triangulated spheres */
g_scene1 = rtcNewScene(RTC_SCENE_STATIC,RTC_INTERSECT1);
createTriangulatedSphere(g_scene1,Vec3fa( 0, 0,+1),0.5);
createTriangulatedSphere(g_scene1,Vec3fa(+1, 0, 0),0.5);
createTriangulatedSphere(g_scene1,Vec3fa( 0, 0,-1),0.5);
createTriangulatedSphere(g_scene1,Vec3fa(-1, 0, 0),0.5);
rtcCommit (g_scene1);
/* instantiate geometry */
g_instance0 = rtcNewInstance(g_scene,g_scene1);
g_instance1 = rtcNewInstance(g_scene,g_scene1);
g_instance2 = rtcNewInstance(g_scene,g_scene1);
g_instance3 = rtcNewInstance(g_scene,g_scene1);
createGroundPlane(g_scene);
/* set all colors */
colors[0][0] = Vec3fa(0.25,0,0);
colors[0][1] = Vec3fa(0.50,0,0);
colors[0][2] = Vec3fa(0.75,0,0);
colors[0][3] = Vec3fa(1.00,0,0);
colors[1][0] = Vec3fa(0,0.25,0);
colors[1][1] = Vec3fa(0,0.50,0);
colors[1][2] = Vec3fa(0,0.75,0);
colors[1][3] = Vec3fa(0,1.00,0);
colors[2][0] = Vec3fa(0,0,0.25);
colors[2][1] = Vec3fa(0,0,0.50);
colors[2][2] = Vec3fa(0,0,0.75);
colors[2][3] = Vec3fa(0,0,1.00);
colors[3][0] = Vec3fa(0.25,0.25,0);
colors[3][1] = Vec3fa(0.50,0.50,0);
colors[3][2] = Vec3fa(0.75,0.75,0);
colors[3][3] = Vec3fa(1.00,1.00,0);
/* set start render mode */
renderPixel = renderPixelStandard;
key_pressed_handler = device_key_pressed_default;
}
void Scene::embreeInit(RTCDevice device) {
Embree.scene = rtcDeviceNewScene(device, EMBREE_SFLAGS_SCENE, EMBREE_AFLAGS_SCENE);
for (uint i = 0; i < objects.size(); i++) {
objects[i]->embreeInit(device);
uint instID = rtcNewInstance2(Embree.scene, objects[i]->Embree.scene);
rtcSetTransform2(Embree.scene, instID, RTC_MATRIX_COLUMN_MAJOR_ALIGNED16, objects[i]->matrix.e);
Embree.instIDmap[instID] = objects[i];
}
rtcCommit(Embree.scene);
}
/* 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)
{
float t0 = 0.7f*time;
float t1 = 1.5f*time;
/* rotate instances around themselves */
LinearSpace3fa xfm;
xfm.vx = Vec3fa(cos(t1),0,sin(t1));
xfm.vy = Vec3fa(0,1,0);
xfm.vz = Vec3fa(-sin(t1),0,cos(t1));
/* calculate transformations to move instances in cirle */
for (int i=0; i<4; i++) {
float t = t0+i*2.0f*float(pi)/4.0f;
instance_xfm[i] = AffineSpace3fa(xfm,2.2f*Vec3fa(+cos(t),0.0f,+sin(t)));
}
/* calculate transformations to properly transform normals */
for (int i=0; i<4; i++)
normal_xfm[i] = transposed(rcp(instance_xfm[i].l));
/* set instance transformations */
rtcSetTransform2(g_scene,g_instance0,RTC_MATRIX_COLUMN_MAJOR_ALIGNED16,(float*)&instance_xfm[0],0);
rtcSetTransform2(g_scene,g_instance1,RTC_MATRIX_COLUMN_MAJOR_ALIGNED16,(float*)&instance_xfm[1],0);
rtcSetTransform2(g_scene,g_instance2,RTC_MATRIX_COLUMN_MAJOR_ALIGNED16,(float*)&instance_xfm[2],0);
rtcSetTransform2(g_scene,g_instance3,RTC_MATRIX_COLUMN_MAJOR_ALIGNED16,(float*)&instance_xfm[3],0);
/* update scene */
rtcUpdate(g_scene,g_instance0);
rtcUpdate(g_scene,g_instance1);
rtcUpdate(g_scene,g_instance2);
rtcUpdate(g_scene,g_instance3);
rtcCommit (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 new Embree device */
g_device = rtcNewDevice(cfg);
error_handler(rtcDeviceGetError(g_device));
/* set error handler */
rtcDeviceSetErrorFunction(g_device,error_handler);
/* create scene */
g_scene = convertScene(g_ispc_scene);
rtcCommit (g_scene);
/* set render tile function to use */
renderTile = renderTileStandard;
key_pressed_handler = device_key_pressed_default;
}
RTCScene convertScene(ISPCScene* scene_in)
{
/* create scene */
RTCScene scene_out = rtcDeviceNewScene(g_device, RTC_SCENE_STATIC | RTC_SCENE_INCOHERENT, RTC_INTERSECT1);
for (size_t i=0; i<scene_in->numGeometries; i++)
{
ISPCGeometry* geometry = scene_in->geometries[i];
if (geometry->type == TRIANGLE_MESH)
convertTriangleMesh((ISPCTriangleMesh*) geometry, scene_out);
else if (geometry->type == HAIR_SET)
convertHairSet((ISPCHairSet*) geometry, scene_out);
}
/* commit changes to scene */
rtcCommit (scene_out);
return scene_out;
}
/* called by the C++ code for initialization */
extern "C" void device_init (int8* cfg)
{
/* initialize ray tracing core */
rtcInit(cfg);
/* set error handler */
rtcSetErrorFunction(error_handler);
/* create scene */
g_scene = rtcNewScene(RTC_SCENE_DYNAMIC,RTC_INTERSECT1);
/* 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));
//RTCGeometryFlags flags = i%3 == 0 ? RTC_GEOMETRY_STATIC : i%3 == 1 ? RTC_GEOMETRY_DEFORMABLE : RTC_GEOMETRY_DYNAMIC;
RTCGeometryFlags flags = i%2 ? RTC_GEOMETRY_DEFORMABLE : RTC_GEOMETRY_DYNAMIC;
//RTCGeometryFlags flags = RTC_GEOMETRY_DEFORMABLE;
int id = createSphere(flags,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 */
#if !defined(PARALLEL_COMMIT)
rtcCommit (g_scene);
#else
launch[ getNumHWThreads() ] parallelCommit(g_scene);
#endif
/* set start render mode */
renderPixel = renderPixelStandard;
}
/* called by the C++ code for initialization */
extern "C" void device_init (int8* cfg)
{
/* initialize ray tracing core */
rtcInit(cfg);
/* create scene */
g_scene = rtcNewScene(RTC_SCENE_STATIC,RTC_INTERSECT1);
/* add cube */
addCube(g_scene);
/* add ground plane */
addGroundPlane(g_scene);
/* commit changes to scene */
rtcCommit (g_scene);
/* set start render mode */
renderPixel = renderPixelStandard;
}
void Object::embreeInit(RTCDevice device) {
Embree.scene = rtcDeviceNewScene(device, EMBREE_SFLAGS_OBJECT, EMBREE_AFLAGS_OBJECT);
// Init embree for meshes
for (uint i = 0; i < geometries.size(); i++) { // If it crashes here, then it can't find the .mtl or the last line is not empty
uint geomID = geometries[i]->embreeInit(Embree.scene);
Embree.geomIDmap[geomID] = geometries[i];
// Set filter functions
rtcSetOcclusionFilterFunction(Embree.scene, geomID, (RTCFilterFunc)&RayEngine::embreeOcclusionFilter);
rtcSetOcclusionFilterFunction8(Embree.scene, geomID, (RTCFilterFunc8)&RayEngine::embreeOcclusionFilter8);
rtcSetUserData(Embree.scene, geomID, userData);
}
rtcCommit(Embree.scene);
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const int width,
const int height,
const float time,
const Vec3fa& vx,
const Vec3fa& vy,
const Vec3fa& vz,
const Vec3fa& p)
{
/* recompute levels */
//updateEdgeLevelBuffer(g_scene,1,p);
/* rebuild scene */
rtcCommit (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;
launch_renderTile(numTilesX*numTilesY,pixels,width,height,time,vx,vy,vz,p,numTilesX,numTilesY);
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const int width,
const int height,
const float time,
const Vec3fa& vx,
const Vec3fa& vy,
const Vec3fa& vz,
const Vec3fa& p)
{
/* animate sphere */
for (int i=0; i<numSpheres; i++)
animateSphere(i,time+i);
/* commit changes to scene */
rtcCommit (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;
launch_renderTile(numTilesX*numTilesY,pixels,width,height,time,vx,vy,vz,p,numTilesX,numTilesY);
}
/* called by the C++ code to render */
extern "C" void device_render (int* pixels,
const int width,
const int height,
const float time,
const Vec3fa& vx,
const Vec3fa& vy,
const Vec3fa& vz,
const Vec3fa& p)
{
/* create identity matrix */
AffineSpace3fa xfm;
xfm.l.vx = Vec3fa(1,0,0);
xfm.l.vy = Vec3fa(0,1,0);
xfm.l.vz = Vec3fa(0,0,1);
xfm.p = Vec3fa(0,0,0);
float t = 0.7f*time;
/* move instances */
xfm.p = 2.0f*Vec3fa(+cos(t),0.0f,+sin(t));
rtcSetTransform(g_scene,g_instance0,RTC_MATRIX_COLUMN_MAJOR_ALIGNED16,(float*)&xfm);
xfm.p = 2.0f*Vec3fa(-cos(t),0.0f,-sin(t));
rtcSetTransform(g_scene,g_instance1,RTC_MATRIX_COLUMN_MAJOR_ALIGNED16,(float*)&xfm);
xfm.p = 2.0f*Vec3fa(-sin(t),0.0f,+cos(t));
rtcSetTransform(g_scene,g_instance2,RTC_MATRIX_COLUMN_MAJOR_ALIGNED16,(float*)&xfm);
xfm.p = 2.0f*Vec3fa(+sin(t),0.0f,-cos(t));
rtcSetTransform(g_scene,g_instance3,RTC_MATRIX_COLUMN_MAJOR_ALIGNED16,(float*)&xfm);
/* update scene */
rtcUpdate(g_scene,g_instance0);
rtcUpdate(g_scene,g_instance1);
rtcUpdate(g_scene,g_instance2);
rtcUpdate(g_scene,g_instance3);
rtcCommit (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;
launch_renderTile(numTilesX*numTilesY,pixels,width,height,time,vx,vy,vz,p,numTilesX,numTilesY);
}
RTCScene convertScene(ISPCScene* scene_in)
{
//scene_in->numHairSets = 0;
//scene_in->numMeshes = 0;
/* create scene */
RTCScene scene_out = rtcNewScene(RTC_SCENE_STATIC | RTC_SCENE_INCOHERENT, RTC_INTERSECT1);
/* add all hair sets to the scene */
for (int i=0; i<scene_in->numHairSets; i++)
{
ISPCHairSet* hair = scene_in->hairs[i];
unsigned int geomID = rtcNewHairGeometry (scene_out, RTC_GEOMETRY_STATIC, hair->numHairs, hair->numVertices, hair->v2 ? 2 : 1);
rtcSetBuffer(scene_out,geomID,RTC_VERTEX_BUFFER,hair->v,0,sizeof(Vertex));
if (hair->v2) rtcSetBuffer(scene_out,geomID,RTC_VERTEX_BUFFER1,hair->v2,0,sizeof(Vertex));
rtcSetBuffer(scene_out,geomID,RTC_INDEX_BUFFER,hair->hairs,0,sizeof(ISPCHair));
rtcSetOcclusionFilterFunction(scene_out,geomID,(RTCFilterFunc)&filterDispatch);
}
/* add all triangle meshes to the scene */
for (int i=0; i<scene_in->numMeshes; i++)
{
ISPCMesh* mesh = scene_in->meshes[i];
unsigned int geomID = rtcNewTriangleMesh (scene_out, RTC_GEOMETRY_STATIC, mesh->numTriangles, mesh->numVertices, mesh->positions2 ? 2 : 1);
rtcSetBuffer(scene_out,geomID,RTC_VERTEX_BUFFER,mesh->positions,0,sizeof(Vertex));
if (mesh->positions2) rtcSetBuffer(scene_out,geomID,RTC_VERTEX_BUFFER1,mesh->positions2,0,sizeof(Vertex));
rtcSetBuffer(scene_out,geomID,RTC_INDEX_BUFFER,mesh->triangles,0,sizeof(ISPCTriangle));
rtcSetOcclusionFilterFunction(scene_out,geomID,(RTCFilterFunc)&filterDispatch);
}
/* commit changes to scene */
#if !defined(PARALLEL_COMMIT)
rtcCommit (scene_out);
#else
launch[ getNumHWThreads() ] parallelCommit(scene_out);
#endif
return scene_out;
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create new Embree device */
g_device = rtcNewDevice(cfg);
/* set error handler */
rtcDeviceSetErrorFunction(g_device,error_handler);
/* create scene */
g_scene = rtcDeviceNewScene(g_device,RTC_SCENE_DYNAMIC | RTC_SCENE_ROBUST, RTC_INTERSECT1);
/* 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));
//RTCGeometryFlags flags = i%3 == 0 ? RTC_GEOMETRY_STATIC : i%3 == 1 ? RTC_GEOMETRY_DEFORMABLE : RTC_GEOMETRY_DYNAMIC;
RTCGeometryFlags flags = i%2 ? RTC_GEOMETRY_DEFORMABLE : RTC_GEOMETRY_DYNAMIC;
//RTCGeometryFlags flags = RTC_GEOMETRY_DEFORMABLE;
int id = createSphere(flags,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 */
rtcCommit (g_scene);
/* set start render mode */
renderPixel = renderPixelStandard;
key_pressed_handler = device_key_pressed_default;
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create new Embree device */
g_device = rtcNewDevice(cfg);
/* set error handler */
rtcDeviceSetErrorFunction(g_device,error_handler);
/* create scene */
g_scene = rtcDeviceNewScene(g_device,RTC_SCENE_STATIC,RTC_INTERSECT1);
/* instantiate geometry */
createGroundPlane(g_scene);
for (size_t i=0; i<numSpheres; i++) {
float a = 2.0*float(pi)*(float)i/(float)numSpheres;
createLazyObject(g_scene,i,10.0f*Vec3fa(cosf(a),0,sinf(a)),1);
}
rtcCommit (g_scene);
/* set start render mode */
renderPixel = renderPixelStandard;
key_pressed_handler = device_key_pressed_default;
}
extern "C" void ispcCommitScene (RTCScene scene) {
return rtcCommit(scene);
}
