void Window::renderRayImage () {
qglviewer::Camera * cam = viewer->camera ();
RayTracer * rayTracer = RayTracer::getInstance ();
qglviewer::Vec p = cam->position ();
qglviewer::Vec d = cam->viewDirection ();
qglviewer::Vec u = cam->upVector ();
qglviewer::Vec r = cam->rightVector ();
Vec3Df camPos (p[0], p[1], p[2]);
Vec3Df viewDirection (d[0], d[1], d[2]);
Vec3Df upVector (u[0], u[1], u[2]);
Vec3Df rightVector (r[0], r[1], r[2]);
float fieldOfView = cam->fieldOfView ();
float aspectRatio = cam->aspectRatio ();
unsigned int screenWidth = cam->screenWidth ();
unsigned int screenHeight = cam->screenHeight ();
QTime timer;
timer.start ();
viewer->setRayImage(rayTracer->render (camPos, viewDirection, upVector, rightVector,
fieldOfView, aspectRatio, screenWidth, screenHeight));
statusBar()->showMessage(QString ("Raytracing performed in ") +
QString::number (timer.elapsed ()) +
QString ("ms at ") +
QString::number (screenWidth) + QString ("x") + QString::number (screenHeight) +
QString (" screen resolution"));
viewer->setDisplayMode (GLViewer::RayDisplayMode);
}
int main (int argc, char *argv[])
{
srand (time (NULL));
omp_set_nested (1);
omp_set_num_threads (16);
// process command line
parse_commandline (&argc, &argv);
LOG (INFO) << "rtrt init";
Window win (FLAGS_width, FLAGS_height, FLAGS_fullscreen, "Real-time Ray Tracer", FLAGS_interval);
Image front (win.width(), win.height()), back (win.width(), win.height()); // create the images
Image *front_p = &front, *back_p = &back;
World world;
//world.fill(75, 4);
world.demo0();
RayTracer rt (world);
#pragma omp parallel
{
#pragma omp single nowait
{
while (win.is_running())
{
// update frame
PerformanceMonitor::instance().RT_FPS.count();
//win.update_frame_rate();
win.clearXY();
// render the new back buffer
rt.render (back_p);
// swap buffers
std::swap (front_p, back_p);
}
}
#pragma omp master
{
while (win.is_running())
{
// main rendering loop, keep rendering the front buffer
PerformanceMonitor::instance().GL_FPS.count();
win.clear(); // clear the render windows back buffer
if (FLAGS_fps)
{
win.update_title_with_frame_rate(); // show the frame rate in the window title
}
win.render_image (*front_p); // render the image to the back buffer
win.update(); // swap the back buffer with the front buffer
PerformanceMonitor::instance().update();
}
}
}
LOG (INFO) << "shutting down";
LOG (INFO) << "Average frame rate was " << win.average_framerate();
front.destroy_image();
back.destroy_image();
win.destroy_window();
LOG (INFO) << PerformanceMonitor::instance();
return (0);
}
/**
* Simple program that starts our raytracer
*/
int main(int argc, char *argv[]) {
try {
RayTracer* rt;
Timer t;
rt = new RayTracer(800, 600);
std::shared_ptr<SceneObjectEffect> color(new ColorEffect(glm::vec3(0.0, 1.0, 0.0)));
std::shared_ptr<SceneObjectEffect> phong(new PhongEffect(glm::vec3(0.0, 0.0, 10.0)));
std::shared_ptr<SceneObjectEffect> steel(new SteelEffect());
std::shared_ptr<SceneObjectEffect> fresnel(new FresnelEffect());
std::shared_ptr<SceneObject> s1(new Sphere(glm::vec3(-3.0f, 0.0f, 6.0f), 2.0f, steel));
rt->addSceneObject(s1);
std::shared_ptr<SceneObject> s2(new Sphere(glm::vec3(3.0f, 0.0f, 3.0f), 2.0f, fresnel));
rt->addSceneObject(s2);
std::shared_ptr<SceneObject> s3(new Sphere(glm::vec3(0.0f, 3.0f, 9.0f), 2.0f, steel));
rt->addSceneObject(s3);
std::string path = "cubemaps/SaintLazarusChurch3/";
std::shared_ptr<SceneObject> cubeMap(new CubeMap(path + "posx.jpg", path + "negx.jpg",
path + "posy.jpg", path + "negy.jpg",
path + "posz.jpg", path + "negz.jpg"));
rt->addSceneObject(cubeMap);
std::shared_ptr<SceneObject> triangle(new Triangle(glm::vec3(0.0f, 2.0f, -1.0f),
glm::vec3(-2.0f, -2.0f, -1.0f), glm::vec3(2.0f, -2.0f, 0.0f), steel));
rt->addSceneObject(triangle);
t.restart();
rt->render();
double elapsed = t.elapsed();
std::cout << "Computed in " << elapsed << " seconds" << std::endl;
rt->save("test", "bmp"); //We want to write out bmp's to get proper bit-maps (jpeg encoding is lossy)
delete rt;
} catch (std::exception &e) {
std::string err = e.what();
std::cout << err.c_str() << std::endl;
return -1;
}
return 0;
}
int main(int argc, char *argv[]) {
settings.parse(argc, argv);
settings.print();
//Timer t;
//StopWatch sw;
//sw.setTimer(&t);
//sw.start("Begining");
Scene *scene = SceneFactory::load(settings.input());
//sw.lap("Datastructure built");
RayFrameBuffer fb(settings.width(), settings.height());
printf("..\n");
RayTracer *rayTracer = NULL;
if (settings.useThreads()) {
rayTracer = new ThreadedRayTracer(scene, &fb);
} else {
rayTracer = new RayTracer(scene, &fb);
}
//rayTracer.setEnvironmentMap(new EnvironmentMap("./texture/earth.jpg"));
//
if (settings.environmentMap()) {
rayTracer->setEnvironmentMap(new EnvironmentMap(settings.environmentMap()));
}
rayTracer->setAntiAliasingResolution(settings.valias(), settings.halias());
rayTracer->render();
//sw.lap("Scene Rendered");
printf("wtf\n");
fb.write(settings.output());
delete rayTracer;
//sw.stop();
delete scene;
//sw.print();
printLightStats();
return 0;
}
void Window::renderRayImage () {
// Modify scene to apply options if necessary
resampleScenesLights();
// Get camera informations
qglviewer::Camera * cam = viewer->camera ();
qglviewer::Vec p = cam->position ();
qglviewer::Vec d = cam->viewDirection ();
qglviewer::Vec u = cam->upVector ();
qglviewer::Vec r = cam->rightVector ();
Vec3Df camPos (p[0], p[1], p[2]);
Vec3Df viewDirection (d[0], d[1], d[2]);
Vec3Df upVector (u[0], u[1], u[2]);
Vec3Df rightVector (r[0], r[1], r[2]);
float fieldOfView = cam->fieldOfView ();
float aspectRatio = cam->aspectRatio ();
unsigned int screenWidth = cam->screenWidth ();
unsigned int screenHeight = cam->screenHeight ();
// Create a ray Iterator
RayIterator* rayIterator = new LensBlurIterator();
rayIterator->setCameraInformation(camPos, viewDirection, upVector, rightVector, fieldOfView, aspectRatio, screenWidth, screenHeight);
setRayIteratorOptions(rayIterator);
// Create the ray tracer
RayTracer * rayTracer = RayTracer::getInstance ();
rayTracer->rayIterator = rayIterator;
// Pass options down
rayTracer->enableCastShadows = shadowCheckBox->isChecked();
rayTracer->enableRefraction = transparencyCheckBox->isChecked();
rayTracer->enableMirrorEffet = mirrorCheckBox->isChecked();
rayTracer->shadingFunction = getShadingFunction();
rayTracer->bounces = (int)bouncesSlider->getValue();
QTime timer;
timer.start ();
#ifdef _OPENMP
QImage image(screenWidth, screenHeight, QImage::Format_RGB888);
bool over = false;
#pragma omp parallel num_threads(2)
{
int i = omp_get_thread_num();
//First thread is calculating image
if(i == 0)
over = rayTracer->render(camPos, viewDirection, upVector, rightVector, fieldOfView, aspectRatio, screenWidth, screenHeight, image);
//Second thread is getting image every refreshingTime
if(i == 1)
{
while (!over)
{
if(timer.elapsed() > lastTime + refreshTime)
{
lastTime = timer.elapsed();
viewer->setRayImage(image);
viewer->setDisplayMode (GLViewer::RayDisplayMode);
}
}
}
}
# elif __APPLE__
QImage image(screenWidth, screenHeight, QImage::Format_RGB888);
for(int i = 0 ; i < screenWidth ; i++)
{
for(int j = 0 ; j < screenHeight ; j++)
{
image.setPixel(i, j, qRgb(0, 0, 0));
}
}
__block bool over = false;
__block QImage& imgRef = image;
dispatch_queue_t rayTracerQueue = dispatch_queue_create("com.raymini.queue", 0);
dispatch_async(rayTracerQueue, ^{
over = rayTracer->render(camPos, viewDirection, upVector, rightVector, fieldOfView, aspectRatio, screenWidth, screenHeight, imgRef);
});
int gr_render_cmd(lua_State* L)
{
GRLUA_DEBUG_CALL;
gr_node_ud* root = (gr_node_ud*)luaL_checkudata(L, 1, "gr.node");
luaL_argcheck(L, root != 0, 1, "Root node expected");
const char* filename = luaL_checkstring(L, 2);
int width = (int)luaL_checknumber(L, 3);
int height = (int)luaL_checknumber(L, 4);
Point eye;
Vector view, up;
get_tuple(L, 5, &eye[0], 3);
get_tuple(L, 6, &view[0], 3);
get_tuple(L, 7, &up[0], 3);
double fov = luaL_checknumber(L, 8);
double ambient_data[3];
get_tuple(L, 9, ambient_data, 3);
Colour ambient(ambient_data[0], ambient_data[1], ambient_data[2]);
luaL_checktype(L, 10, LUA_TTABLE);
int light_count = luaL_getn(L, 10);
luaL_argcheck(L, light_count >= 1, 10, "Tuple of lights expected");
std::list<Light*> lights;
for (int i = 1; i <= light_count; i++) {
lua_rawgeti(L, 10, i);
gr_light_ud* ldata = (gr_light_ud*)luaL_checkudata(L, -1, "gr.light");
luaL_argcheck(L, ldata != 0, 10, "Light expected");
lights.push_back(ldata->light);
lua_pop(L, 1);
}
Scene* scene = new Scene(*root->node, lights, ambient);
scene->prepare();
// XXX come back and fix this for interactive.
RayTracer* rt = new RayTracer();
Camera *c = new PerspectiveCamera(eye, eye + view, up,
fov, 0.1, 1000000, width, height,
Prefs::sharedPrefs().lensRadius,
Prefs::sharedPrefs().focalDistance);
/*
* Choose a very large number for the far plane so that we can acomodate
* scenes with larger scales. This still won't work with all scenes.
* the lua command really should be updated to pass in near and far.
* Can't just use INFINITY because we get an error when constructing the
* perpective projection (ie the view volume must be finite).
*/
Stats::sharedStats().nextRender(); // prints the last render's stats if any.
std::cout << std::endl << std::endl << "Rendering " << filename << "..." << std::endl;
std::cout << Prefs::sharedPrefs();
Stats::sharedStats().imageWidth = width;
Stats::sharedStats().imageHeight = height;
rt->render(*scene, *c, width, height);
rt->getImage().savePng(*(new std::string(filename)));
delete rt;
return 0;
}
