//------------------------------------------------------------------- // FileName::dir_copy //------------------------------------------------------------------- void FileName::dir_copy(const String &strDest, bool bCreateDir, mode_t modeDir, uid_t uid, gid_t gid) throw( Exception ) { FileName fnDst; // Create destination path fnDst.set(strDest); fnDst.mkdir(modeDir, uid, gid); if( bCreateDir ) { // Create source directory name inside destination path fnDst.set(strDest + dir_name() + SEP_PATH); fnDst.mkdir(modeDir, uid, gid); } if( !fnDst.is_path_name() ) throw BadPathException(PSZ(String::str_format(ERR_BAD_DEST_PATH, PSZ(fnDst.full_name()))), "FileName::dir_copy"); // Recursively copying sub-directories FileEnum dirEnum(full_name(), FileEnum::ENUM_DIR); while( dirEnum.find() ) dirEnum.dir_copy(fnDst.path(), true, modeDir, uid, gid); // Copying directory files FileEnum fileEnum(full_name(), FileEnum::ENUM_FILE); while( fileEnum.find() ) // Copy with metadata fileEnum.copy(fnDst.path(), true); }
/* 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); /* create stream for parsing */ Ref<ParseStream> stream = new ParseStream(new CommandLineStream(argc, argv)); /* parse command line */ parseCommandLine(stream, FileName()); /* load default scene if none specified */ if (filename.ext() == "") { FileName file = FileName::executableFolder() + FileName("models/cornell_box.ecs"); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* configure number of threads */ if (g_numThreads) g_rtcore += ",threads=" + std::to_string((long long)g_numThreads); if (g_numBenchmarkFrames) g_rtcore += ",benchmark=1"; g_rtcore += g_subdiv_mode; /* load scene */ if (strlwr(filename.ext()) == std::string("obj")) { g_scene->add(loadOBJ(filename,g_subdiv_mode != "")); } else if (strlwr(filename.ext()) == std::string("xml")) { g_scene->add(loadXML(filename,one)); } else if (filename.ext() != "") THROW_RUNTIME_ERROR("invalid scene type: "+strlwr(filename.ext())); /* initialize ray tracing core */ init(g_rtcore.c_str()); /* send model */ g_obj_scene.add(g_scene.dynamicCast<SceneGraph::Node>(),g_instancing_mode); g_scene = nullptr; set_scene(&g_obj_scene); /* benchmark mode */ if (g_numBenchmarkFrames) renderBenchmark(outFilename); /* render to disk */ if (outFilename.str() != "") renderToFile(outFilename); /* interactive mode */ if (g_interactive) { initWindowState(argc,argv,tutorialName, g_width, g_height, g_fullscreen); enterWindowRunLoop(g_anim_mode); } return 0; }
/* opens a shared library */ lib_t openLibrary(const std::string& file) { std::string fullName = file+".dll"; FileName executable = getExecutableFileName(); HANDLE handle = LoadLibrary((executable.path() + fullName).c_str()); return lib_t(handle); }
static void parseCommandLine(Ref<ParseStream> cin, const FileName& path) { while (true) { std::string tag = cin->getString(); if (tag == "") return; /* parse command line parameters from a file */ if (tag == "-c") { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* load OBJ model*/ else if (tag == "-i") { filename = path + cin->getFileName(); } /* ambient light source */ else if (tag == "-ambientlight") { g_ambientLightIntensity = cin->getVector3f(); } /* point light source */ else if (tag == "-pointlight") { g_pointLightPosition = cin->getVector3f(); g_pointLightIntensity = cin->getVector3f(); } /* parse camera parameters */ else if (tag == "-vp") g_camera.from = cin->getVector3f(); else if (tag == "-vi") g_camera.to = cin->getVector3f(); else if (tag == "-vd") g_camera.to = g_camera.from + cin->getVector3f(); else if (tag == "-vu") g_camera.up = cin->getVector3f(); else if (tag == "-fov") g_camera.fov = cin->getFloat(); /* frame buffer size */ else if (tag == "-size") { g_width = cin->getInt(); g_height = cin->getInt(); } /* full screen mode */ else if (tag == "-fullscreen") g_fullscreen = true; /*! enable verbose output mode */ else if (tag == "-verbose") { g_verbose = 1; } /* skip unknown command line parameter */ else { std::cerr << "unknown command line parameter: " << tag << " "; while (cin->peek() != "" && cin->peek()[0] != '-') std::cerr << cin->getString() << " "; std::cerr << std::endl; } } }
void postParseCommandLine() { /* load default scene if none specified */ if (scene->size() == 0 && sceneFilename.ext() == "") { FileName file = FileName::executableFolder() + FileName("models/cornell_box.ecs"); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } }
static void parseCommandLine(Ref<ParseStream> cin, const FileName& path) { while (true) { std::string tag = cin->getString(); if (tag == "") return; /* parse command line parameters from a file */ else if (tag == "-c") { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* load OBJ model*/ else if (tag == "-i") { filename = path + cin->getFileName(); } /* parse camera parameters */ else if (tag == "-vp") g_camera.from = cin->getVec3fa(); else if (tag == "-vi") g_camera.to = cin->getVec3fa(); else if (tag == "-vd") g_camera.to = g_camera.from + cin->getVec3fa(); else if (tag == "-vu") g_camera.up = cin->getVec3fa(); else if (tag == "-fov") g_camera.fov = cin->getFloat(); /* frame buffer size */ else if (tag == "-size") { g_width = cin->getInt(); g_height = cin->getInt(); } /* full screen mode */ else if (tag == "-fullscreen") g_fullscreen = true; /* rtcore configuration */ else if (tag == "-rtcore") g_rtcore = cin->getString(); /* number of threads to use */ else if (tag == "-threads") g_numThreads = cin->getInt(); /* skip unknown command line parameter */ else { std::cerr << "unknown command line parameter: " << tag << " "; while (cin->peek() != "" && cin->peek()[0] != '-') std::cerr << cin->getString() << " "; std::cerr << std::endl; } } }
/* opens a shared library */ lib_t openLibrary(const std::string& file) { #if defined(__MACOSX__) std::string fullName = "lib"+file+".dylib"; #else std::string fullName = "lib"+file+".so"; #endif void* lib = dlopen(fullName.c_str(), RTLD_NOW); if (lib) return lib_t(lib); FileName executable = getExecutableFileName(); lib = dlopen((executable.path() + fullName).c_str(),RTLD_NOW); if (lib == NULL) THROW_RUNTIME_ERROR(dlerror()); return lib_t(lib); }
void loadKeyFrameAnimation(FileName &fileName) { PRINT(fileName); std::ifstream cin; cin.open(fileName.c_str()); if (!cin.is_open()) { std::cerr << "cannot open " << fileName.str() << std::endl; return; } FileName path; path = fileName.path(); char line[10000]; memset(line, 0, sizeof(line)); int cur = 0; while (cin.peek() != -1) { /* load next multiline */ char* pline = line; while (true) { cin.getline(pline, sizeof(line) - (pline - line) - 16, '\n'); ssize_t last = strlen(pline) - 1; if (last < 0 || pline[last] != '\\') break; pline += last; *pline++ = ' '; } OBJScene *scene = new OBJScene; FileName keyframe = path + FileName(line); loadOBJ(keyframe,one,*scene,true); PRINT(keyframe); if (g_obj_scene.subdiv.size() != scene->subdiv.size()) FATAL("#subdiv meshes differ"); for (size_t i=0;i<g_obj_scene.subdiv.size();i++) if (g_obj_scene.subdiv[i]->positions.size() != scene->subdiv[i]->positions.size()) FATAL("#positions differ"); g_keyframes.push_back(scene); } cin.close(); }
CoronaLoader::CoronaLoader(const FileName& fileName, const AffineSpace3fa& space) { path = fileName.path(); Ref<XML> xml = parseXML(fileName,"/.-",false); if (xml->name == "scene") { Ref<SceneGraph::GroupNode> group = new SceneGraph::GroupNode; for (size_t i=0; i<xml->children.size(); i++) { group->add(loadNode(xml->children[i])); } root = group.cast<SceneGraph::Node>(); } else THROW_RUNTIME_ERROR(xml->loc.str()+": invalid scene tag"); if (space == AffineSpace3fa(one)) return; root = new SceneGraph::TransformNode(space,root); }
void IsisMain() { //Get user parameters UserInterface &ui = Application::GetUserInterface(); FileName inFile = ui.GetFileName("FROM"); int numberOfLines = ui.GetInteger("NL"); int lineOverlap = ui.GetInteger("OVERLAP"); //Throws exception if user is dumb if(lineOverlap >= numberOfLines) { throw IException(IException::User, "The Line Overlap (OVERLAP) must be less than the Number of Lines (LN).", _FILEINFO_); } //Opens the cube Cube cube; cube.open(inFile.expanded()); //Loops through, cropping as desired int cropNum = 1; int startLine = 1; bool hasReachedEndOfCube = false; while(startLine <= cube.lineCount() && not hasReachedEndOfCube) { //! Sets up the proper paramaters for running the crop program QString parameters = "FROM=" + inFile.expanded() + " TO=" + inFile.path() + "/" + inFile.baseName() + ".segment" + toString(cropNum) + ".cub" + " LINE=" + toString(startLine) + " NLINES="; if(startLine + numberOfLines > cube.lineCount()) { parameters += toString(cube.lineCount() - (startLine - 1)); hasReachedEndOfCube = true; } else { parameters += toString(numberOfLines); } ProgramLauncher::RunIsisProgram("crop", parameters); //The starting line for next crop startLine = 1 + cropNum * (numberOfLines - lineOverlap); cropNum++; } }
FileName FileName::createTempFile(FileName templateFileName) { QString preppedFileName = QString("%1/%2XXXXXX.%3").arg(templateFileName.path()) .arg(templateFileName.baseName()).arg(templateFileName.extension()); QTemporaryFile tempFile(preppedFileName); tempFile.setAutoRemove(false); if (!tempFile.open()) { throw IException(IException::Io, QObject::tr("Could not create a unique temporary file name based on [%1]") .arg(templateFileName.original()), _FILEINFO_); } // We want to set the 'original' path as correctly as possible. So let's use the input original // path with the output temp file's file name in our result. FileName result; QString newTempFileNameStr = templateFileName.originalPath() + "/" + QFileInfo(tempFile.fileName()).fileName(); result = FileName(newTempFileNameStr); return result; }
SceneLoadingTutorialApplication::SceneLoadingTutorialApplication (const std::string& tutorialName, int features) : TutorialApplication(tutorialName, features), scene(new SceneGraph::GroupNode), convert_tris_to_quads(false), convert_tris_to_quads_prop(inf), convert_bezier_to_lines(false), convert_hair_to_curves(false), convert_bezier_to_bspline(false), convert_bspline_to_bezier(false), remove_mblur(false), remove_non_mblur(false), sceneFilename(""), instancing_mode(SceneGraph::INSTANCING_NONE), print_scene_cameras(false) { registerOption("i", [this] (Ref<ParseStream> cin, const FileName& path) { sceneFilename = path + cin->getFileName(); }, "-i <filename>: parses scene from <filename>"); registerOption("animlist", [this] (Ref<ParseStream> cin, const FileName& path) { FileName listFilename = path + cin->getFileName(); std::ifstream listFile; listFile.open(listFilename.c_str()); if (!listFile.is_open()) { THROW_RUNTIME_ERROR("cannot open " + listFilename.str()); } else { while (!listFile.eof()) { std::string line; listFile >> line; if (line != "") keyFramesFilenames.push_back(listFilename.path() + line); } } }, "-animlist <filename>: parses a sequence of .obj/.xml files listed in <filename> and adds them to the scene");
static void parseCommandLine(Ref<ParseStream> cin, const FileName& path) { while (true) { std::string tag = cin->getString(); if (tag == "") return; /* parse command line parameters from a file */ else if (tag == "-c") { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* load OBJ model*/ else if (tag == "-i") { filename = path + cin->getFileName(); } /* parse camera parameters */ else if (tag == "-vp") g_camera.from = cin->getVec3fa(); else if (tag == "-vi") g_camera.to = cin->getVec3fa(); else if (tag == "-vd") g_camera.to = g_camera.from + cin->getVec3fa(); else if (tag == "-vu") g_camera.up = cin->getVec3fa(); else if (tag == "-fov") g_camera.fov = cin->getFloat(); /* frame buffer size */ else if (tag == "-size") { g_width = cin->getInt(); g_height = cin->getInt(); } /* full screen mode */ else if (tag == "-fullscreen") g_fullscreen = true; /* output filename */ else if (tag == "-o") { outFilename = cin->getFileName(); g_interactive = false; } /* number of frames to render in benchmark mode */ else if (tag == "-benchmark") { g_skipBenchmarkFrames = cin->getInt(); g_numBenchmarkFrames = cin->getInt(); g_interactive = false; } /* rtcore configuration */ else if (tag == "-rtcore") g_rtcore = cin->getString(); /* number of threads to use */ else if (tag == "-threads") g_numThreads = cin->getInt(); /* ambient light source */ else if (tag == "-ambientlight") { const Vec3fa L = cin->getVec3fa(); g_obj_scene.ambientLights.push_back(OBJScene::AmbientLight(L)); } /* point light source */ else if (tag == "-pointlight") { const Vec3fa P = cin->getVec3fa(); const Vec3fa I = cin->getVec3fa(); g_obj_scene.pointLights.push_back(OBJScene::PointLight(P,I)); } /* directional light source */ else if (tag == "-directionallight" || tag == "-dirlight") { const Vec3fa D = cin->getVec3fa(); const Vec3fa E = cin->getVec3fa(); g_obj_scene.directionalLights.push_back(OBJScene::DirectionalLight(D,E)); } /* distant light source */ else if (tag == "-distantlight") { const Vec3fa D = cin->getVec3fa(); const Vec3fa L = cin->getVec3fa(); const float halfAngle = cin->getFloat(); g_obj_scene.distantLights.push_back(OBJScene::DistantLight(D,L,halfAngle)); } /* skip unknown command line parameter */ else { std::cerr << "unknown command line parameter: " << tag << " "; while (cin->peek() != "" && cin->peek()[0] != '-') std::cerr << cin->getString() << " "; std::cerr << std::endl; } } }
static void parseCommandLine(Ref<ParseStream> cin, const FileName &path) { for (std::string term = cin->getString() ; term != "" ; term = cin->getString()) { /*! Command line parameters from a file. */ if (term == "-c") { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* load OBJ model*/ else if (term == "-i") { filename = path + cin->getFileName(); } /*! Camera field of view. */ else if (term == "-fov") g_camera.fov = cin->getFloat(); /*! Full screen mode. */ else if (term == "-fullscreen") g_fullscreen = true; /* output filename */ else if (term == "-o") { g_interactive = false; outFilename = cin->getFileName(); } /*! Embree configuration. */ else if (term == "-rtcore") g_rtcore = cin->getString(); /*! Window size. */ else if (term == "-size") { g_width = cin->getInt(); g_height = cin->getInt(); } /*! Thread count. */ else if (term == "-threads") { g_numThreads = cin->getInt(); } /*! Camera view direction. */ else if (term == "-vd") g_camera.to = g_camera.from + cin->getVec3fa(); /*! Camera look point. */ else if (term == "-vi") g_camera.to = cin->getVec3fa(); /*! Camera position. */ else if (term == "-vp") g_camera.from = cin->getVec3fa(); /*! Camera up vector. */ else if (term == "-vu") g_camera.up = cin->getVec3fa(); else if (term == "-cache") g_subdiv_mode = ",subdiv_accel=bvh4.subdivpatch1cached"; else if (term == "-lazy") g_subdiv_mode = ",subdiv_accel=bvh4.grid.lazy"; else if (term == "-pregenerate") g_subdiv_mode = ",subdiv_accel=bvh4.grid.eager"; /*! Skip unknown command line parameters. */ else std::cerr << "Unknown command line parameter: " << getParameterString(cin, term) << std::endl; } }
TutorialApplication::TutorialApplication (const std::string& tutorialName, int features) : Application(features), tutorialName(tutorialName), shader(SHADER_DEFAULT), width(512), height(512), pixels(nullptr), outputImageFilename(""), skipBenchmarkFrames(0), numBenchmarkFrames(0), numBenchmarkRepetitions(1), interactive(true), fullscreen(false), window_width(512), window_height(512), windowID(0), time0(getSeconds()), debug_int0(0), debug_int1(0), mouseMode(0), clickX(0), clickY(0), speed(1.0f), moveDelta(zero), command_line_camera(false), print_frame_rate(false), avg_render_time(64,1.0), avg_frame_time(64,1.0), avg_mrayps(64,1.0), print_camera(false), debug0(0), debug1(0), debug2(0), debug3(0), iflags_coherent(RTC_INTERSECT_COHERENT), iflags_incoherent(RTC_INTERSECT_INCOHERENT) { /* only a single instance of this class is supported */ assert(instance == nullptr); instance = this; /* 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); registerOption("c", [this] (Ref<ParseStream> cin, const FileName& path) { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); }, "-c <filename>: parses command line option from <filename>"); registerOption("o", [this] (Ref<ParseStream> cin, const FileName& path) { outputImageFilename = cin->getFileName(); interactive = false; }, "-o <filename>: output image filename"); /* camera settings */ registerOption("vp", [this] (Ref<ParseStream> cin, const FileName& path) { camera.from = cin->getVec3fa(); command_line_camera = true; }, "--vp <float> <float> <float>: camera position"); registerOption("vi", [this] (Ref<ParseStream> cin, const FileName& path) { camera.to = cin->getVec3fa(); command_line_camera = true; }, "--vi <float> <float> <float>: camera lookat position"); registerOption("vd", [this] (Ref<ParseStream> cin, const FileName& path) { camera.to = camera.from + cin->getVec3fa(); command_line_camera = true; }, "--vd <float> <float> <float>: camera direction vector"); registerOption("vu", [this] (Ref<ParseStream> cin, const FileName& path) { camera.up = cin->getVec3fa(); command_line_camera = true; }, "--vu <float> <float> <float>: camera up vector"); registerOption("fov", [this] (Ref<ParseStream> cin, const FileName& path) { camera.fov = cin->getFloat(); command_line_camera = true; }, "--fov <float>: vertical field of view"); /* framebuffer settings */ registerOption("size", [this] (Ref<ParseStream> cin, const FileName& path) { width = cin->getInt(); height = cin->getInt(); }, "--size <width> <height>: sets image size"); registerOption("fullscreen", [this] (Ref<ParseStream> cin, const FileName& path) { fullscreen = true; }, "--fullscreen: starts in fullscreen mode"); registerOption("benchmark", [this] (Ref<ParseStream> cin, const FileName& path) { skipBenchmarkFrames = cin->getInt(); numBenchmarkFrames = cin->getInt(); if (cin->peek() != "" && cin->peek()[0] != '-') numBenchmarkRepetitions = cin->getInt(); interactive = false; rtcore += ",benchmark=1,start_threads=1"; }, "--benchmark <N> <M> <R>: enabled benchmark mode, builds scene, skips N frames, renders M frames, and repeats this R times"); registerOption("nodisplay", [this] (Ref<ParseStream> cin, const FileName& path) { skipBenchmarkFrames = 0; numBenchmarkFrames = 2048; interactive = false; }, "--nodisplay: enabled benchmark mode, continously renders frames"); registerOption("print-frame-rate", [this] (Ref<ParseStream> cin, const FileName& path) { print_frame_rate = true; }, "--print-frame-rate: prints framerate for each frame on console"); registerOption("print-camera", [this] (Ref<ParseStream> cin, const FileName& path) { print_camera = true; }, "--print-camera: prints camera for each frame on console"); registerOption("debug0", [this] (Ref<ParseStream> cin, const FileName& path) { debug0 = cin->getInt(); }, "--debug0: sets internal debugging value"); registerOption("debug1", [this] (Ref<ParseStream> cin, const FileName& path) { debug1 = cin->getInt(); }, "--debug1: sets internal debugging value"); registerOption("debug2", [this] (Ref<ParseStream> cin, const FileName& path) { debug2 = cin->getInt(); }, "--debug2: sets internal debugging value"); registerOption("debug3", [this] (Ref<ParseStream> cin, const FileName& path) { debug3 = cin->getInt(); }, "--debug3: sets internal debugging value"); /* output filename */ registerOption("shader", [this] (Ref<ParseStream> cin, const FileName& path) { std::string mode = cin->getString(); if (mode == "default" ) shader = SHADER_DEFAULT; else if (mode == "eyelight") shader = SHADER_EYELIGHT; else if (mode == "occlusion") shader = SHADER_OCCLUSION; else if (mode == "uv" ) shader = SHADER_UV; else if (mode == "texcoords") shader = SHADER_TEXCOORDS; else if (mode == "texcoords-grid") shader = SHADER_TEXCOORDS_GRID; else if (mode == "Ng" ) shader = SHADER_NG; else if (mode == "cycles" ) { shader = SHADER_CYCLES; scale = cin->getFloat(); } else if (mode == "geomID" ) shader = SHADER_GEOMID; else if (mode == "primID" ) shader = SHADER_GEOMID_PRIMID; else if (mode == "ao" ) shader = SHADER_AMBIENT_OCCLUSION; else throw std::runtime_error("invalid shader:" +mode); }, "--shader <string>: sets shader to use at startup\n" " default: default tutorial shader\n" " eyelight: eyelight shading\n" " occlusion: occlusion shading\n" " uv: uv debug shader\n" " texcoords: texture coordinate debug shader\n" " texcoords-grid: grid texture debug shader\n" " Ng: visualization of shading normal\n" " cycles <float>: CPU cycle visualization\n" " geomID: visualization of geometry ID\n" " primID: visualization of geometry and primitive ID\n" " ao: ambient occlusion shader"); if (features & FEATURE_STREAM) { /* register parsing of stream mode */ registerOption("mode", [] (Ref<ParseStream> cin, const FileName& path) { std::string mode = cin->getString(); if (mode == "normal") g_mode = MODE_NORMAL; else if (mode == "stream") g_mode = MODE_STREAM; else throw std::runtime_error("invalid mode:" +mode); }, "--mode: sets rendering mode\n" " normal : normal mode\n" " stream : stream mode\n"); } registerOption("coherent", [this] (Ref<ParseStream> cin, const FileName& path) { g_iflags_coherent = iflags_coherent = RTC_INTERSECT_COHERENT; g_iflags_incoherent = iflags_incoherent = RTC_INTERSECT_COHERENT; }, "--coherent: force using RTC_INTERSECT_COHERENT hint when tracing rays"); registerOption("incoherent", [this] (Ref<ParseStream> cin, const FileName& path) { g_iflags_coherent = iflags_coherent = RTC_INTERSECT_INCOHERENT; g_iflags_incoherent = iflags_incoherent = RTC_INTERSECT_INCOHERENT; }, "--incoherent: force using RTC_INTERSECT_INCOHERENT hint when tracing rays"); }
static void parseCommandLine(Ref<ParseStream> cin, const FileName& path) { while (true) { std::string tag = cin->getString(); if (tag == "") return; /* parse command line parameters from a file */ else if (tag == "-c") { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* load OBJ model*/ else if (tag == "-i") { filename = path + cin->getFileName(); } /* parse camera parameters */ else if (tag == "-vp") g_camera.from = cin->getVec3fa(); else if (tag == "-vi") g_camera.to = cin->getVec3fa(); else if (tag == "-vd") g_camera.to = g_camera.from + cin->getVec3fa(); else if (tag == "-vu") g_camera.up = cin->getVec3fa(); else if (tag == "-fov") g_camera.fov = cin->getFloat(); /* frame buffer size */ else if (tag == "-size") { g_width = cin->getInt(); g_height = cin->getInt(); } /* full screen mode */ else if (tag == "-fullscreen") g_fullscreen = true; /* output filename */ else if (tag == "-o") { outFilename = cin->getFileName(); g_interactive = false; } else if (tag == "-objlist") { keyframeList = cin->getFileName(); } /* subdivision mode */ else if (tag == "-cache") g_subdiv_mode = ",subdiv_accel=bvh4.subdivpatch1cached"; else if (tag == "-lazy") g_subdiv_mode = ",subdiv_accel=bvh4.grid.lazy"; else if (tag == "-pregenerate") g_subdiv_mode = ",subdiv_accel=bvh4.grid.eager"; else if (tag == "-loop") g_loop_mode = true; else if (tag == "-anim") g_anim_mode = true; else if (tag == "-shader") { std::string mode = cin->getString(); if (mode == "default" ) g_shader = SHADER_DEFAULT; else if (mode == "eyelight") g_shader = SHADER_EYELIGHT; else if (mode == "uv" ) g_shader = SHADER_UV; else if (mode == "Ng" ) g_shader = SHADER_NG; else if (mode == "geomID" ) g_shader = SHADER_GEOMID; else if (mode == "primID" ) g_shader = SHADER_GEOMID_PRIMID; else throw std::runtime_error("invalid shader:" +mode); } /* number of frames to render in benchmark mode */ else if (tag == "-benchmark") { g_skipBenchmarkFrames = cin->getInt(); g_numBenchmarkFrames = cin->getInt(); g_interactive = false; } /* rtcore configuration */ else if (tag == "-rtcore") g_rtcore = cin->getString(); /* number of threads to use */ else if (tag == "-threads") g_numThreads = cin->getInt(); /* ambient light source */ else if (tag == "-ambientlight") { const Vec3fa L = cin->getVec3fa(); g_obj_scene.ambientLights.push_back(OBJScene::AmbientLight(L)); } /* point light source */ else if (tag == "-pointlight") { const Vec3fa P = cin->getVec3fa(); const Vec3fa I = cin->getVec3fa(); g_obj_scene.pointLights.push_back(OBJScene::PointLight(P,I)); } /* directional light source */ else if (tag == "-directionallight" || tag == "-dirlight") { const Vec3fa D = cin->getVec3fa(); const Vec3fa E = cin->getVec3fa(); g_obj_scene.directionalLights.push_back(OBJScene::DirectionalLight(D,E)); } /* distant light source */ else if (tag == "-distantlight") { const Vec3fa D = cin->getVec3fa(); const Vec3fa L = cin->getVec3fa(); const float halfAngle = cin->getFloat(); g_obj_scene.distantLights.push_back(OBJScene::DistantLight(D,L,halfAngle)); } /* converts triangle meshes into subdiv meshes */ else if (tag == "-subdiv") { g_only_subdivs = true; } /* skip unknown command line parameter */ else { std::cerr << "unknown command line parameter: " << tag << " "; while (cin->peek() != "" && cin->peek()[0] != '-') std::cerr << cin->getString() << " "; std::cerr << std::endl; } } }
static void parseCommandLine(Ref<ParseStream> cin, const FileName& path) { while (true) { std::string tag = cin->getString(); if (tag == "") return; /* parse command line parameters from a file */ else if (tag == "-c") { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* load model */ else if (tag == "-i") { g_scene->add(SceneGraph::load(path + cin->getFileName())); } /* convert triangles to quads */ else if (tag == "-convert-triangles-to-quads") { g_scene->triangles_to_quads(); } /* convert to subdivs */ else if (tag == "-convert-to-subdivs") { g_scene->triangles_to_quads(); g_scene->quads_to_subdivs(); } /* convert bezier to lines */ else if (tag == "-convert-bezier-to-lines") { g_scene->bezier_to_lines(); } /* load terrain */ else if (tag == "-terrain") { Ref<Image> tex = loadImage(path + cin->getFileName()); const Vec3fa lower = cin->getVec3fa(); const Vec3fa upper = cin->getVec3fa(); g_height_field = new HeightField(tex,BBox3fa(lower,upper)); g_scene->add(g_height_field->geometry()); } /* distribute model */ else if (tag == "-distribute") { Ref<SceneGraph::Node> object = SceneGraph::load(path + cin->getFileName()); Ref<Image> distribution = loadImage(path + cin->getFileName()); const float minDistance = cin->getFloat(); const size_t N = cin->getInt(); Ref<Instantiator> instantiator = new Instantiator(g_height_field,object,distribution,minDistance,N); instantiator->instantiate(g_scene); } /* instantiate model a single time */ else if (tag == "-instantiate") { Ref<SceneGraph::Node> object = SceneGraph::load(path + cin->getFileName()); const float px = cin->getFloat(); const float py = cin->getFloat(); const Vec2f p(px,py); const float angle = cin->getFloat()/180.0f*float(pi); const AffineSpace3fa space = g_height_field->get(p)*AffineSpace3fa::rotate(Vec3fa(0,1,0),angle); g_scene->add(new SceneGraph::TransformNode(space,object)); } /* enable texture embedding */ else if (tag == "-embed-textures") { embedTextures = true; } /* enable texture referencing */ else if (tag == "-reference-textures") { embedTextures = false; } /* output filename */ else if (tag == "-o") { SceneGraph::store(g_scene.dynamicCast<SceneGraph::Node>(),path + cin->getFileName(),embedTextures); } /* skip unknown command line parameter */ else { std::cerr << "unknown command line parameter: " << tag << " "; while (cin->peek() != "" && cin->peek()[0] != '-') std::cerr << cin->getString() << " "; std::cerr << std::endl; } } }
OBJLoader::OBJLoader(const FileName &fileName, const bool subdivMode) : path(fileName.path()), group(new SceneGraph::GroupNode), subdivMode(subdivMode) { /* open file */ std::ifstream cin; cin.open(fileName.c_str()); if (!cin.is_open()) { THROW_RUNTIME_ERROR("cannot open " + fileName.str()); return; } /* generate default material */ Material objmtl; new (&objmtl) OBJMaterial; Ref<SceneGraph::MaterialNode> defaultMaterial = new SceneGraph::MaterialNode(objmtl); curMaterial = defaultMaterial; char line[10000]; memset(line, 0, sizeof(line)); while (cin.peek() != -1) { /* load next multiline */ char* pline = line; while (true) { cin.getline(pline, sizeof(line) - (pline - line) - 16, '\n'); ssize_t last = strlen(pline) - 1; if (last < 0 || pline[last] != '\\') break; pline += last; *pline++ = ' '; } const char* token = trimEnd(line + strspn(line, " \t")); if (token[0] == 0) continue; /*! parse position */ if (token[0] == 'v' && isSep(token[1])) { v.push_back(getVec3f(token += 2)); continue; } /* parse normal */ if (token[0] == 'v' && token[1] == 'n' && isSep(token[2])) { vn.push_back(getVec3f(token += 3)); continue; } /* parse texcoord */ if (token[0] == 'v' && token[1] == 't' && isSep(token[2])) { vt.push_back(getVec2f(token += 3)); continue; } /*! parse face */ if (token[0] == 'f' && isSep(token[1])) { parseSep(token += 1); std::vector<Vertex> face; while (token[0]) { Vertex vtx = getInt3(token); face.push_back(vtx); parseSepOpt(token); } curGroup.push_back(face); continue; } /*! parse edge crease */ if (token[0] == 'e' && token[1] == 'c' && isSep(token[2])) { parseSep(token += 2); float w = getFloat(token); parseSepOpt(token); int a = fix_v(getInt(token)); parseSepOpt(token); int b = fix_v(getInt(token)); parseSepOpt(token); ec.push_back(Crease(w, a, b)); continue; } /*! use material */ if (!strncmp(token, "usemtl", 6) && isSep(token[6])) { flushFaceGroup(); std::string name(parseSep(token += 6)); if (material.find(name) == material.end()) curMaterial = defaultMaterial; else curMaterial = material[name]; continue; } /* load material library */ if (!strncmp(token, "mtllib", 6) && isSep(token[6])) { loadMTL(path + std::string(parseSep(token += 6))); continue; } // ignore unknown stuff } flushFaceGroup(); cin.close(); }
void importOBJ(const std::shared_ptr<Node> &world, const FileName &fileName) { tinyobj::attrib_t attrib; std::vector<tinyobj::shape_t> shapes; std::vector<tinyobj::material_t> materials; std::string err; const std::string containingPath = fileName.path(); std::cout << "parsing OBJ input file... \n"; bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, fileName.c_str(), containingPath.c_str()); #if 0 // NOTE(jda) - enable if you want to see warnings from TinyOBJ if (!err.empty()) std::cerr << "#ospsg: obj parsing warning(s)...\n" << err << std::endl; #endif if (!ret) { std::cerr << "#ospsg: FATAL error parsing obj file, no geometry added" << " to the scene!" << std::endl; return; } auto sgMaterials = createSgMaterials(materials, containingPath); std::string base_name = fileName.name() + '_'; int shapeId = 0; std::cout << "...adding found triangle groups to the scene...\n"; size_t shapeCounter = 0; size_t numShapes = shapes.size(); size_t increment = numShapes / size_t(10); int incrementer = 0; #if !USE_INSTANCES auto objInstance = createNode("instance", "Instance"); world->add(objInstance); #endif for (auto &shape : shapes) { for (int numVertsInFace : shape.mesh.num_face_vertices) { if (numVertsInFace != 3) { std::cerr << "Warning: more thant 3 verts in face!"; PRINT(numVertsInFace); } } if (shapeCounter++ > (increment * incrementer + 1)) std::cout << incrementer++ * 10 << "%\n"; auto name = base_name + std::to_string(shapeId++) + '_' + shape.name; auto mesh = createNode(name, "TriangleMesh")->nodeAs<TriangleMesh>(); auto v = createNode("vertex", "DataVector3f")->nodeAs<DataVector3f>(); auto numSrcIndices = shape.mesh.indices.size(); v->v.reserve(numSrcIndices); auto vi = createNode("index", "DataVector3i")->nodeAs<DataVector3i>(); vi->v.reserve(numSrcIndices / 3); auto vn = createNode("normal", "DataVector3f")->nodeAs<DataVector3f>(); vn->v.reserve(numSrcIndices); auto vt = createNode("texcoord", "DataVector2f")->nodeAs<DataVector2f>(); vt->v.reserve(numSrcIndices); for (size_t i = 0; i < shape.mesh.indices.size(); i += 3) { auto idx0 = shape.mesh.indices[i + 0]; auto idx1 = shape.mesh.indices[i + 1]; auto idx2 = shape.mesh.indices[i + 2]; auto prim = vec3i(i + 0, i + 1, i + 2); vi->push_back(prim); v->push_back(vec3f(attrib.vertices[idx0.vertex_index * 3 + 0], attrib.vertices[idx0.vertex_index * 3 + 1], attrib.vertices[idx0.vertex_index * 3 + 2])); v->push_back(vec3f(attrib.vertices[idx1.vertex_index * 3 + 0], attrib.vertices[idx1.vertex_index * 3 + 1], attrib.vertices[idx1.vertex_index * 3 + 2])); v->push_back(vec3f(attrib.vertices[idx2.vertex_index * 3 + 0], attrib.vertices[idx2.vertex_index * 3 + 1], attrib.vertices[idx2.vertex_index * 3 + 2])); // TODO create missing normals&texcoords if only some faces have them if (!attrib.normals.empty() && idx0.normal_index != -1) { vn->push_back(vec3f(attrib.normals[idx0.normal_index * 3 + 0], attrib.normals[idx0.normal_index * 3 + 1], attrib.normals[idx0.normal_index * 3 + 2])); vn->push_back(vec3f(attrib.normals[idx1.normal_index * 3 + 0], attrib.normals[idx1.normal_index * 3 + 1], attrib.normals[idx1.normal_index * 3 + 2])); vn->push_back(vec3f(attrib.normals[idx2.normal_index * 3 + 0], attrib.normals[idx2.normal_index * 3 + 1], attrib.normals[idx2.normal_index * 3 + 2])); } if (!attrib.texcoords.empty() && idx0.texcoord_index != -1) { vt->push_back(vec2f(attrib.texcoords[idx0.texcoord_index * 2 + 0], attrib.texcoords[idx0.texcoord_index * 2 + 1])); vt->push_back(vec2f(attrib.texcoords[idx1.texcoord_index * 2 + 0], attrib.texcoords[idx1.texcoord_index * 2 + 1])); vt->push_back(vec2f(attrib.texcoords[idx2.texcoord_index * 2 + 0], attrib.texcoords[idx2.texcoord_index * 2 + 1])); } } mesh->add(v); mesh->add(vi); if (!vn->empty()) mesh->add(vn); if (!vt->empty()) mesh->add(vt); auto pmids = createNode("prim.materialID", "DataVector1i")->nodeAs<DataVector1i>(); auto numMatIds = shape.mesh.material_ids.size(); pmids->v.reserve(numMatIds); for (auto id : shape.mesh.material_ids) pmids->v.push_back(id); mesh->add(pmids); mesh->add(sgMaterials); auto model = createNode(name + "_model", "Model"); model->add(mesh); // TODO: Large .obj models with lots of groups run much slower with each // group put in a separate instance. In the future, we want to // support letting the user (ospExampleViewer, for starters) // specify if each group should be placed in an instance or not. #if USE_INSTANCES auto instance = createNode(name + "_instance", "Instance"); instance->setChild("model", model); model->setParent(instance); world->add(instance); #else (*objInstance)["model"].add(mesh); #endif } std::cout << "...finished import!\n"; }
/* 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); /* create stream for parsing */ Ref<ParseStream> stream = new ParseStream(new CommandLineStream(argc, argv)); /* parse command line */ parseCommandLine(stream, FileName()); /* load default scene if none specified */ if (filename.ext() == "") { FileName file = FileName::executableFolder() + FileName("models/cornell_box.ecs"); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* configure number of threads */ if (g_numThreads) g_rtcore += ",threads=" + std::to_string((long long)g_numThreads); if (g_numBenchmarkFrames) g_rtcore += ",benchmark=1"; g_rtcore += g_subdiv_mode; /* load scene */ if (strlwr(filename.ext()) == std::string("obj")) { if (g_subdiv_mode != "") { std::cout << "enabling subdiv mode" << std::endl; loadOBJ(filename,one,g_obj_scene,true); } else loadOBJ(filename,one,g_obj_scene); } else if (strlwr(filename.ext()) == std::string("xml")) loadXML(filename,one,g_obj_scene); else if (filename.ext() != "") THROW_RUNTIME_ERROR("invalid scene type: "+strlwr(filename.ext())); /* load keyframes */ if (keyframeList.str() != "") loadKeyFrameAnimation(keyframeList); /* initialize ray tracing core */ init(g_rtcore.c_str()); /* set shader mode */ switch (g_shader) { case SHADER_EYELIGHT: key_pressed(GLUT_KEY_F2); break; case SHADER_UV : key_pressed(GLUT_KEY_F4); break; case SHADER_NG : key_pressed(GLUT_KEY_F5); break; case SHADER_GEOMID : key_pressed(GLUT_KEY_F6); break; case SHADER_GEOMID_PRIMID: key_pressed(GLUT_KEY_F7); break; }; /* convert triangle meshes to subdiv meshes */ if (g_only_subdivs) g_obj_scene.convert_to_subdiv(); /* send model */ set_scene(&g_obj_scene); /* send keyframes */ if (g_keyframes.size()) set_scene_keyframes(&*g_keyframes.begin(),g_keyframes.size()); /* benchmark mode */ if (g_numBenchmarkFrames) renderBenchmark(outFilename); /* render to disk */ if (outFilename.str() != "") renderToFile(outFilename); /* interactive mode */ if (g_interactive) { initWindowState(argc,argv,tutorialName, g_width, g_height, g_fullscreen); enterWindowRunLoop(g_anim_mode); } return 0; }
static void parseCommandLine(Ref<ParseStream> cin, const FileName& path) { while (true) { std::string tag = cin->getString(); if (tag == "") return; /* parse command line parameters from a file */ if (tag == "-c") { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file,"#")),file.path()); } /* read model from file */ else if (tag == "-i") *g_scene += load(path+cin->getFileName()); /* triangulated sphere */ else if (tag == "-trisphere") { Ref<Device::RTShape> sphere = g_device->rtNewShape("sphere"); sphere->rtSetFloat3("P",cin->getVec3f()); sphere->rtSetFloat1("r",cin->getFloat()); sphere->rtSetInt1("numTheta",cin->getInt()); sphere->rtSetInt1("numPhi",cin->getInt()); sphere->rtCommit(); Ref<Device::RTMaterial> material = g_device->rtNewMaterial("matte"); material->rtSetFloat3("reflection",Col3f(1.0f,0.0f,0.0f)); material->rtCommit(); *g_scene += new ShapeNode(sphere,material); } /* ambient light source */ else if (tag == "-ambientlight") { Ref<Device::RTLight> light = g_device->rtNewLight("ambientlight"); light->rtSetFloat3("L",cin->getVec3f()); light->rtCommit(); *g_scene += new LightNode(light); } /* point light source */ else if (tag == "-pointlight") { Vec3f P = cin->getVec3f(); Vec3f I = cin->getVec3f(); std::cout << " P " << P.x << " : " << P.y << " : " << P.z << std::endl; std::cout << " I " << I.x << " : " << I.y << " : " << I.z << std::endl; Ref<Device::RTLight> light = g_device->rtNewLight("pointlight"); light->rtSetFloat3("P",P); light->rtSetFloat3("I",I); light->rtCommit(); *g_scene += new LightNode(light); } /* distant light source */ else if (tag == "-distantlight") { Ref<Device::RTLight> light = g_device->rtNewLight("distantlight"); light->rtSetFloat3("D",cin->getVec3f()); light->rtSetFloat3("L",cin->getVec3f()); light->rtSetFloat1("halfAngle",cin->getFloat()); light->rtCommit(); *g_scene += new LightNode(light); } /* triangular light source */ else if (tag == "-trianglelight") { Vec3f P = cin->getVec3f(); Vec3f U = cin->getVec3f(); Vec3f V = cin->getVec3f(); Vec3f L = cin->getVec3f(); Ref<Device::RTLight> light = g_device->rtNewLight("trianglelight"); light->rtSetFloat3("v0",P); light->rtSetFloat3("v1",P+U); light->rtSetFloat3("v2",P+V); light->rtSetFloat3("L" ,L); light->rtCommit(); *g_scene += new LightNode(light); } /* quad light source */ else if (tag == "-quadlight") { Vec3f P = cin->getVec3f(); Vec3f U = cin->getVec3f(); Vec3f V = cin->getVec3f(); Vec3f L = cin->getVec3f(); Ref<Device::RTLight> light0 = g_device->rtNewLight("trianglelight"); light0->rtSetFloat3("v0",P); light0->rtSetFloat3("v1",P+U); light0->rtSetFloat3("v2",P+U+V); light0->rtSetFloat3("L" ,L); light0->rtCommit(); *g_scene += new LightNode(light0); Ref<Device::RTLight> light1 = g_device->rtNewLight("trianglelight"); light1->rtSetFloat3("v0",P+U+V); light1->rtSetFloat3("v1",P+V); light1->rtSetFloat3("v2",P); light1->rtSetFloat3("L" ,L); light1->rtCommit(); *g_scene += new LightNode(light1); } /* HDRI light source */ else if (tag == "-hdrilight") { Ref<Device::RTLight> light = g_device->rtNewLight("hdrilight"); light->rtSetFloat3("L",cin->getVec3f()); light->rtSetImage("image",loadRTImage(path + cin->getFileName())); light->rtCommit(); *g_scene += new LightNode(light); } /* parse camera parameters */ else if (tag == "-vp") g_camPos = Vec3f(cin->getVec3f()); else if (tag == "-vi") g_camLookAt = Vec3f(cin->getVec3f()); else if (tag == "-vd") g_camLookAt = g_camPos+cin->getVec3f(); else if (tag == "-vu") g_camUp = cin->getVec3f(); else if (tag == "-angle") g_camAngle = cin->getFloat(); else if (tag == "-fov") g_camAngle = cin->getFloat(); else if (tag == "-radius") g_camRadius = cin->getFloat(); /* frame buffer size */ else if (tag == "-size") { g_width = cin->getInt(); g_height = cin->getInt(); g_frameBuffer = g_device->rtNewFrameBuffer("RGB_FLOAT32", g_width, g_height); } /* full screen mode */ else if (tag == "-fullscreen") { g_fullscreen = true; } /* refine rendering when not moving */ else if (tag == "-refine") g_refine = true; else if (tag == "-norefine") g_refine = false; /* acceleration structure to use */ else if (tag == "-accel") g_accel = cin->getString(); /* set renderer */ else if (tag == "-renderer") { std::string renderer = cin->getString(); if (renderer == "debug" ) g_renderer = parseDebugRenderer(cin,path); else if (renderer == "pt" ) g_renderer = parsePathTracer(cin,path); else if (renderer == "pathtracer") g_renderer = parsePathTracer(cin,path); else if (renderer == "material" ) g_renderer = parseMaterialRenderer(cin,path); else if (renderer == "opengl" ) g_renderer = parseOpenGLRenderer(cin); else throw std::runtime_error("unknown renderer: "+renderer); } /* set gamma */ else if (tag == "-gamma") { g_renderer->rtSetFloat1("gamma",g_gamma = cin->getFloat()); g_renderer->rtCommit(); } /* set recursion depth */ else if (tag == "-depth") { g_renderer->rtSetInt1("maxDepth",g_depth = cin->getInt()); g_renderer->rtCommit(); } /* set samples per pixel */ else if (tag == "-spp") { g_renderer->rtSetInt1("sampler.spp",g_spp = cin->getInt()); g_renderer->rtCommit(); } /* set the backplate */ else if (tag == "-backplate") { g_renderer->rtSetImage("backplate",g_backplate = loadRTImage(path + cin->getFileName())); g_renderer->rtCommit(); } /* render frame */ else if (tag == "-o") outputMode(path + cin->getFileName()); /* display image */ else if (tag == "-display") displayMode(); /* regression testing */ else if (tag == "-regression") { g_refine = false; g_regression = true; GLUTDisplay(OrthonormalSpace::lookAtPoint(g_camPos,g_camLookAt,g_camUp),0.01f); } else if (tag == "-version") { std::cout << "embree renderer version 1.0" << std::endl; exit(1); } else if (tag == "-h" || tag == "-?" || tag == "-help" || tag == "--help") { std::cout << std::endl; std::cout << "Embree Version 1.0" << std::endl; std::cout << std::endl; std::cout << " usage: embree -i model.obj -renderer debug -display" << std::endl; std::cout << " embree -i model.obj -renderer pathtracer -o out.tga" << std::endl; std::cout << " embree -c model.ecs -display" << std::endl; std::cout << std::endl; std::cout << "-renderer [debug,pathtracer]" << std::endl; std::cout << " Sets the renderer to use." << std::endl; std::cout << std::endl; std::cout << "-c file" << std::endl; std::cout << " Parses command line parameters from file." << std::endl; std::cout << std::endl; std::cout << "-i file" << std::endl; std::cout << " Loads a scene from file." << std::endl; std::cout << std::endl; std::cout << "-o file" << std::endl; std::cout << " Renders and outputs the image to the file." << std::endl; std::cout << std::endl; std::cout << "-display" << std::endl; std::cout << " Interactively displays the rendering into a window." << std::endl; std::cout << std::endl; std::cout << "-vp x y z" << std::endl; std::cout << " Sets camera position to the location (x,y,z)." << std::endl; std::cout << std::endl; std::cout << "-vi x y z" << std::endl; std::cout << " Sets camera lookat point to the location (x,y,z)." << std::endl; std::cout << std::endl; std::cout << "-vd x y z" << std::endl; std::cout << " Sets camera viewing direction to (x,y,z)." << std::endl; std::cout << std::endl; std::cout << "-vu x y z" << std::endl; std::cout << " Sets camera up direction to (x,y,z)." << std::endl; std::cout << std::endl; std::cout << "-fov angle" << std::endl; std::cout << " Sets camera field of view in y direction to angle." << std::endl; std::cout << std::endl; std::cout << "-size width height" << std::endl; std::cout << " Sets the width and height of image to render." << std::endl; std::cout << std::endl; std::cout << "-fullscreen" << std::endl; std::cout << " Enables full screen display mode." << std::endl; std::cout << std::endl; std::cout << "-accel [bvh2,bvh4,bvh4.spatial]" << std::endl; std::cout << " Sets the spatial index structure to use." << std::endl; std::cout << std::endl; std::cout << "-gamma v" << std::endl; std::cout << " Sets gamma correction to v (only pathtracer)." << std::endl; std::cout << std::endl; std::cout << "-depth i" << std::endl; std::cout << " Sets the recursion depth to i (default 16)" << std::endl; std::cout << std::endl; std::cout << "-spp i" << std::endl; std::cout << " Sets the number of samples per pixel to i (default 1) (only pathtracer)." << std::endl; std::cout << std::endl; std::cout << "-backplate" << std::endl; std::cout << " Sets a high resolution back ground image. (default none) (only pathtracer)." << std::endl; std::cout << std::endl; std::cout << "-ambientlight r g b" << std::endl; std::cout << " Creates an ambient light with intensity (r,g,b)." << std::endl; std::cout << std::endl; std::cout << "-pointlight px py pz r g b" << std::endl; std::cout << " Creates a point light with intensity (r,g,b) at position (px,py,pz)." << std::endl; std::cout << std::endl; std::cout << "-distantlight dx dy dz r g b halfAngle" << std::endl; std::cout << " Creates a distant sun light with intensity (r,g,b) shining into " << std::endl; std::cout << " direction (dx,dy,dz) from the cone spanned by halfAngle." << std::endl; std::cout << std::endl; std::cout << "-trianglelight px py pz ux uy uz vx vy vz r g b" << std::endl; std::cout << " Creates a triangle-light with intensity (r,g,b) spanned by the point " << std::endl; std::cout << " (px,py,pz) and the vectors (vx,vy,vz) and (ux,uy,uz)." << std::endl; std::cout << std::endl; std::cout << "-quadlight px py pz ux uy uz vx vy vz r g b" << std::endl; std::cout << " Creates a quad-light with intensity (r,g,b) spanned by the point " << std::endl; std::cout << " (px,py,pz) and the vectors (vx,vy,vz) and (ux,uy,uz)." << std::endl; std::cout << std::endl; std::cout << "-hdrilight r g b file" << std::endl; std::cout << " Creates a high dynamic range environment light from the image " << std::endl; std::cout << " file. The intensities are multiplies by (r,g,b)." << std::endl; std::cout << std::endl; std::cout << "-trisphere px py pz r theta phi" << std::endl; std::cout << " Creates a triangulated sphere with radius r at location (px,py,pz) " << std::endl; std::cout << " and triangulation rates theta and phi." << std::endl; std::cout << std::endl; std::cout << "-[no]refine" << std::endl; std::cout << " Enables (default) or disables the refinement display mode." << std::endl; std::cout << std::endl; std::cout << "-regression" << std::endl; std::cout << " Runs a stress test of the system." << std::endl; std::cout << std::endl; std::cout << "-version" << std::endl; std::cout << " Prints version number." << std::endl; std::cout << std::endl; std::cout << "-h, -?, -help, --help" << std::endl; std::cout << " Prints this help." << std::endl; exit(1); } /* skip unknown command line parameter */ else { std::cerr << "unknown command line parameter: " << tag << " "; while (cin->peek() != "" && cin->peek()[0] != '-') std::cerr << cin->getString() << " "; std::cerr << std::endl; } } }
static void parseCommandLine(Ref<ParseStream> cin, const FileName& path) { while (true) { std::string tag = cin->getString(); if (tag == "") return; /* parse command line parameters from a file */ else if (tag == "-c") { FileName file = path + cin->getFileName(); parseCommandLine(new ParseStream(new LineCommentFilter(file, "#")), file.path()); } /* load OBJ model*/ else if (tag == "-i") { filename = path + cin->getFileName(); } /* parse camera parameters */ else if (tag == "-vp") g_camera.from = cin->getVec3fa(); else if (tag == "-vi") g_camera.to = cin->getVec3fa(); else if (tag == "-vd") g_camera.to = g_camera.from + cin->getVec3fa(); else if (tag == "-vu") g_camera.up = cin->getVec3fa(); else if (tag == "-fov") g_camera.fov = cin->getFloat(); /* frame buffer size */ else if (tag == "-size") { g_width = cin->getInt(); g_height = cin->getInt(); } /* full screen mode */ else if (tag == "-fullscreen") g_fullscreen = true; /* output filename */ else if (tag == "-o") { outFilename = cin->getFileName(); g_interactive = false; } else if (tag == "-objlist") { keyframeList = cin->getFileName(); } /* subdivision mode */ else if (tag == "-cache") g_subdiv_mode = ",subdiv_accel=bvh4.subdivpatch1cached"; else if (tag == "-pregenerate") g_subdiv_mode = ",subdiv_accel=bvh4.grid.eager"; else if (tag == "-anim") g_anim_mode = true; else if (tag == "-instancing") { std::string mode = cin->getString(); if (mode == "none" ) g_instancing_mode = 0; else if (mode == "geometry") g_instancing_mode = 1; else if (mode == "scene" ) g_instancing_mode = 2; else throw std::runtime_error("unknown instancing mode: "+mode); } /* number of frames to render in benchmark mode */ else if (tag == "-benchmark") { g_skipBenchmarkFrames = cin->getInt(); g_numBenchmarkFrames = cin->getInt(); g_interactive = false; } /* rtcore configuration */ else if (tag == "-rtcore") g_rtcore = cin->getString(); /* number of threads to use */ else if (tag == "-threads") g_numThreads = cin->getInt(); /* ambient light source */ else if (tag == "-ambientlight") { const Vec3fa L = cin->getVec3fa(); g_scene->add(new SceneGraph::LightNode<AmbientLight>(AmbientLight(L))); } /* point light source */ else if (tag == "-pointlight") { const Vec3fa P = cin->getVec3fa(); const Vec3fa I = cin->getVec3fa(); g_scene->add(new SceneGraph::LightNode<PointLight>(PointLight(P,I))); } /* directional light source */ else if (tag == "-directionallight" || tag == "-dirlight") { const Vec3fa D = cin->getVec3fa(); const Vec3fa E = cin->getVec3fa(); g_scene->add(new SceneGraph::LightNode<DirectionalLight>(DirectionalLight(D,E))); } /* distant light source */ else if (tag == "-distantlight") { const Vec3fa D = cin->getVec3fa(); const Vec3fa L = cin->getVec3fa(); const float halfAngle = cin->getFloat(); g_scene->add(new SceneGraph::LightNode<DistantLight>(DistantLight(D,L,halfAngle))); } /* skip unknown command line parameter */ else { std::cerr << "unknown command line parameter: " << tag << " "; while (cin->peek() != "" && cin->peek()[0] != '-') std::cerr << cin->getString() << " "; std::cerr << std::endl; } } }