bool RendererComponents::create_pixel_renderer_factory() { const string name = m_params.get_optional<string>("pixel_renderer", ""); if (name.empty()) { return true; } else if (name == "uniform") { if (m_sample_renderer_factory.get() == 0) { RENDERER_LOG_ERROR("cannot use the uniform pixel renderer without a sample renderer."); return false; } ParamArray params = get_child_and_inherit_globals(m_params, "uniform_pixel_renderer"); copy_param(params, m_params, "passes"); m_pixel_renderer_factory.reset( new UniformPixelRendererFactory( m_sample_renderer_factory.get(), params)); return true; } else if (name == "adaptive") { if (m_sample_renderer_factory.get() == 0) { RENDERER_LOG_ERROR("cannot use the adaptive pixel renderer without a sample renderer."); return false; } m_pixel_renderer_factory.reset( new AdaptivePixelRendererFactory( m_frame, m_sample_renderer_factory.get(), get_child_and_inherit_globals(m_params, "adaptive_pixel_renderer"))); return true; } else { RENDERER_LOG_ERROR( "invalid value for \"pixel_renderer\" parameter: \"%s\".", name.c_str()); return false; } }
static struct lp_block *copy_block(struct lp_block *b) { int c; struct lp_block *result = calloc(1, sizeof(*result)); memcpy(result, b, sizeof(struct lp_block)); result->params = calloc(b->params_len, sizeof(result->params[0])); if(b->name) { result->name = strdup(b->name); } for(c = 0; c < b->params_len; c++) { if(b->params[c]) { result->params[c] = copy_param(b->params[c]); } } return result; }
// // コマンドラインパラメータ解析処理 // in: pt .. コマンドラインパラメータ // void analyze_args(TCHAR *pt) { TCHAR param[MAX_PATH]; TCHAR name[MAX_PATH]; TCHAR exe[MAX_PATH]; TCHAR option[MAX_PATH]; TCHAR description[MAX_PATH]; int autof, desktop, retry, end; int no; struct { TCHAR *name; int *flag; TCHAR *dst; } list[] = { { _T("install"), &install_flag, NULL }, { _T("uninstall"), &uninstall_flag, NULL }, { _T("ini"), &read_ini_flag, NULL }, { _T("name"), NULL, name }, { _T("exe"), NULL, exe }, { _T("option"), NULL, option }, { _T("description"), NULL, description }, { _T("desktop"), &desktop, NULL }, { _T("auto"), &autof, NULL }, { _T("start"), &start_flag, NULL }, { _T("no_error"), &no_error_flag, NULL }, { _T("ok"), &ok_flag, NULL }, { _T("question"), &question_flag, NULL }, { _T("retry"), &retry, NULL }, { _T("end"), &end, NULL }, { NULL, NULL, NULL } }; name[0] = _T('\0'); exe[0] = _T('\0'); option[0] = _T('\0'); description[0] = _T('\0'); desktop = FALSE; autof = FALSE; retry = FALSE; end = END_SYS_AND_CLOSE; while(*pt != _T('\0')) { if(*pt== '/' || *pt == '-') { pt++; for(no = 0 ; list[no].name != NULL ; no++) { if(!_tcsnicmp(pt, list[no].name, _tcslen(list[no].name))) { pt += _tcslen(list[no].name); if(list[no].flag != NULL) { if(!_tcsnicmp(list[no].name, _T("end"), _tcslen(list[no].name))) { copy_param(param, pt, MAX_PATH); if(!_tcsicmp(param, _T("close"))) { *list[no].flag = END_CLOSE; } else if(!_tcsicmp(param, _T("syscommand"))) { *list[no].flag = END_SYSCOMMAND; } else if(!_tcsicmp(param, _T("sysandclose"))) { *list[no].flag = END_SYS_AND_CLOSE; } else if(!_tcsicmp(param, _T("ctrlbreak"))) { *list[no].flag = END_CTRL_BREAK; // 2011/9/1 kimukou.buzz } else if(!_tcsicmp(param, _T("ctrlc"))) { *list[no].flag = END_CTRL_C; // 2011/9/1 kimukou.buzz } else if(param[0] >= _T('0') && param[0] <= _T('3')) { *list[no].flag = param[0] - _T('0'); } } else { *list[no].flag = TRUE; } } if(list[no].dst != NULL) { pt = copy_param(list[no].dst, pt, MAX_PATH); } } } } else { pt++; } } if(install_flag || uninstall_flag) { // インストールまたはアンインストールする場合 if(read_ini_flag) { // ini ファイルから設定値を読む get_inifile(); } else { // パラメータの値を使用する #if _MSC_VER >= 1400 _tcscpy_s(service_name, MAX_PATH, name); _tcscpy_s(exe_name, MAX_PATH, exe); _tcscpy_s(option_name, MAX_PATH, option); _tcscpy_s(description_name, MAX_PATH, description); #else _tcscpy(service_name, name); _tcscpy(exe_name, exe); _tcscpy(option_name, option); _tcscpy(description_name, description); #endif auto_flag = autof; desktop_flag = desktop; retry_flag = retry; end_pattern = end; } } else { // 通常起動の場合、ini ファイルから設定値を読む get_inifile(); } }
struct generic_section_config * parse_param(char const *path, FILE *f, const struct config_section_info *params, int quiet_flag, int _ncond_var, cfg_cond_var_t *_cond_vars, int *p_cond_count) { struct generic_section_config *cfg = NULL; struct generic_section_config **psect = &cfg, *sect = NULL; const struct config_section_info *cur_info = NULL; char sectname[32]; char varname[32]; char varvalue[1024]; int c, sindex; parsecfg_state.ncond_var = _ncond_var; parsecfg_state.cond_vars = _cond_vars; parsecfg_state.cond_stack = 0; parsecfg_state.output_enabled = 1; parsecfg_state.lineno = 1; if (p_cond_count) *p_cond_count = 0; /* found the global section description */ for (sindex = 0; params[sindex].name; sindex++) { if (!strcmp(params[sindex].name, "global")) { cur_info = ¶ms[sindex]; break; } } /* if (!cur_info) { fprintf(stderr, "Cannot find description of section [global]\n"); goto cleanup; } */ if (!f && !(f = fopen(path, "r"))) { fprintf(stderr, "Cannot open configuration file %s\n", path); goto cleanup; } if (cur_info) { cfg = (struct generic_section_config*) xcalloc(1, cur_info->size); if (cur_info->init_func) cur_info->init_func(cfg); cfg->next = NULL; psect = &cfg->next; } while (1) { c = read_first_char(f); if (c == EOF || c == '[') break; if (c == '#' || c== '%' || c == ';') { read_comment(f); continue; } if (c == '@') { if (handle_conditional(f) < 0) goto cleanup; if (p_cond_count) (*p_cond_count)++; continue; } if (!parsecfg_state.output_enabled) { read_comment(f); continue; } if (read_variable(f, varname, sizeof(varname), varvalue, sizeof(varvalue)) < 0) goto cleanup; if (!quiet_flag) { printf("%d: Value: %s = %s\n", parsecfg_state.lineno - 1, varname, varvalue); } if (!cur_info) { fprintf(stderr, "Cannot find description of section [global]\n"); goto cleanup; } if (copy_param(cfg, cur_info, varname, varvalue) < 0) goto cleanup; } while (c != EOF) { if (read_section_name(f, sectname, sizeof(sectname)) < 0) goto cleanup; if (!quiet_flag) { printf("%d: New section %s\n", parsecfg_state.lineno - 1, sectname); } if (!strcmp(sectname, "global")) { fprintf(stderr, "Section global cannot be specified explicitly\n"); goto cleanup; } for (sindex = 0; params[sindex].name; sindex++) { if (!strcmp(params[sindex].name, sectname)) { cur_info = ¶ms[sindex]; break; } } if (!cur_info) { fprintf(stderr, "Cannot find description of section [%s]\n", sectname); goto cleanup; } if (cur_info->pcounter) (*cur_info->pcounter)++; sect = (struct generic_section_config*) xcalloc(1, cur_info->size); strcpy(sect->name, sectname); if (cur_info->init_func) cur_info->init_func(sect); sect->next = NULL; *psect = sect; psect = §->next; while (1) { c = read_first_char(f); if (c == EOF || c == '[') break; if (c == '#' || c == '%' || c == ';') { read_comment(f); continue; } if (c == '@') { if (handle_conditional(f) < 0) goto cleanup; if (p_cond_count) (*p_cond_count)++; continue; } if (!parsecfg_state.output_enabled) { read_comment(f); continue; } if (read_variable(f, varname, sizeof(varname), varvalue, sizeof(varvalue)) < 0) goto cleanup; if (!quiet_flag) { printf("%d: Value: %s = %s\n", parsecfg_state.lineno - 1, varname, varvalue); } if (copy_param(sect, cur_info, varname, varvalue) < 0) goto cleanup; } } if (parsecfg_state.cond_stack) { fprintf(stderr, "%d: unclosed conditional compilation\n", parsecfg_state.lineno); goto cleanup; } fflush(stdout); if (f) fclose(f); return cfg; cleanup: xfree(cfg); if (f) fclose(f); return NULL; }
IRendererController::Status MasterRenderer::initialize_and_render_frame_sequence() { assert(m_project.get_scene()); assert(m_project.get_frame()); // Reset the abort switch. if (m_abort_switch) m_abort_switch->clear(); #ifdef WITH_OSL // Create the error handler. OIIOErrorHandler error_handler; // While debugging, we want all possible outputs. #ifndef NDEBUG error_handler.verbosity(OIIO::ErrorHandler::VERBOSE); #endif const size_t texture_cache_size = m_params.get_optional<size_t>("texture_cache_size", 256 * 1024 * 1024); // If the texture cache size changes, we have to recreate the texture system. if (texture_cache_size != m_texture_cache_size) { m_texture_cache_size = texture_cache_size; m_texture_system.reset(); } // Create the OIIO texture system, if needed. if (!m_texture_system) { m_texture_system.reset( OIIO::TextureSystem::create(false), bind(&OIIO::TextureSystem::destroy, _1)); } // Set the texture system mem limit. m_texture_system->attribute("max_memory_MB", static_cast<float>(m_texture_cache_size / 1024)); std::string search_paths; // Skip search paths for builtin projects. if (m_project.search_paths().has_root_path()) { // Setup texture / shader search paths. // In OIIO / OSL, the path priorities are the opposite of appleseed, // so we copy the paths in reverse order. const filesystem::path root_path = m_project.search_paths().get_root_path(); if (!m_project.search_paths().empty()) { for (size_t i = 0, e = m_project.search_paths().size(); i != e; ++i) { filesystem::path p(m_project.search_paths()[e - 1 - i]); if (p.is_relative()) p = root_path / p; search_paths.append(p.string()); search_paths.append(";"); } } search_paths.append(root_path.string()); } if (!search_paths.empty()) m_texture_system->attribute("searchpath", search_paths); // TODO: set other texture system options here. // Create our renderer services. RendererServices services(m_project, *m_texture_system); // Create our OSL shading system. boost::shared_ptr<OSL::ShadingSystem> shading_system( OSL::ShadingSystem::create( &services, m_texture_system.get(), &error_handler), bind(&destroy_osl_shading_system, _1, m_texture_system.get())); if (!search_paths.empty()) shading_system->attribute("searchpath:shader", search_paths); shading_system->attribute("lockgeom", 1); shading_system->attribute("colorspace", "Linear"); shading_system->attribute("commonspace", "world"); // This array needs to be kept in sync with the ShadingRay::Type enumeration. static const char* ray_type_labels[] = { "camera", "light", "shadow", "probe", "diffuse", "glossy", "specular" }; shading_system->attribute( "raytypes", OSL::TypeDesc( OSL::TypeDesc::STRING, sizeof(ray_type_labels) / sizeof(ray_type_labels[0])), ray_type_labels); #ifndef NDEBUG // While debugging, we want all possible outputs. shading_system->attribute("debug", 1); shading_system->attribute("statistics:level", 1); shading_system->attribute("compile_report", 1); shading_system->attribute("countlayerexecs", 1); shading_system->attribute("clearmemory", 1); #endif register_closures(*shading_system); #endif // WITH_OSL // We start by binding entities inputs. This must be done before creating/updating the trace context. if (!bind_scene_entities_inputs()) return IRendererController::AbortRendering; m_project.create_aov_images(); m_project.update_trace_context(); const Scene& scene = *m_project.get_scene(); Frame& frame = *m_project.get_frame(); frame.print_settings(); const TraceContext& trace_context = m_project.get_trace_context(); // Create the texture store. TextureStore texture_store(scene, m_params.child("texture_store")); // Create the light sampler. LightSampler light_sampler(scene, m_params.child("light_sampler")); // Create the shading engine. ShadingEngine shading_engine(m_params.child("shading_engine")); // // Create a lighting engine factory. // auto_ptr<IPassCallback> pass_callback; auto_ptr<ILightingEngineFactory> lighting_engine_factory; { const string value = m_params.get_required<string>("lighting_engine", "pt"); if (value == "drt") { lighting_engine_factory.reset( new DRTLightingEngineFactory( light_sampler, m_params.child("drt"))); // todo: change to "drt_lighting_engine" -- or? } else if (value == "pt") { lighting_engine_factory.reset( new PTLightingEngineFactory( light_sampler, m_params.child("pt"))); // todo: change to "pt_lighting_engine" -- or? } else if (value == "sppm") { const SPPMParameters params(m_params.child("sppm")); SPPMPassCallback* sppm_pass_callback = new SPPMPassCallback( scene, light_sampler, trace_context, texture_store, #ifdef WITH_OSL *shading_system, #endif params); pass_callback.reset(sppm_pass_callback); lighting_engine_factory.reset( new SPPMLightingEngineFactory( *sppm_pass_callback, light_sampler, params)); } else { RENDERER_LOG_ERROR( "invalid value for \"lighting_engine\" parameter: \"%s\".", value.c_str()); return IRendererController::AbortRendering; } } // // Create a sample renderer factory. // auto_ptr<ISampleRendererFactory> sample_renderer_factory; { const string value = m_params.get_required<string>("sample_renderer", "generic"); if (value == "generic") { sample_renderer_factory.reset( new GenericSampleRendererFactory( scene, frame, trace_context, texture_store, lighting_engine_factory.get(), shading_engine, #ifdef WITH_OSL *shading_system, #endif m_params.child("generic_sample_renderer"))); } else if (value == "blank") { sample_renderer_factory.reset(new BlankSampleRendererFactory()); } else if (value == "debug") { sample_renderer_factory.reset(new DebugSampleRendererFactory()); } else { RENDERER_LOG_ERROR( "invalid value for \"sample_renderer\" parameter: \"%s\".", value.c_str()); return IRendererController::AbortRendering; } } // // Create a sample generator factory. // auto_ptr<ISampleGeneratorFactory> sample_generator_factory; { const string value = m_params.get_optional<string>("sample_generator", ""); if (value == "generic") { sample_generator_factory.reset( new GenericSampleGeneratorFactory( frame, sample_renderer_factory.get())); } else if (value == "lighttracing") { sample_generator_factory.reset( new LightTracingSampleGeneratorFactory( scene, frame, trace_context, texture_store, light_sampler, #ifdef WITH_OSL *shading_system, #endif m_params.child("lighttracing_sample_generator"))); } else if (!value.empty()) { RENDERER_LOG_ERROR( "invalid value for \"sample_generator\" parameter: \"%s\".", value.c_str()); return IRendererController::AbortRendering; } } // // Create a pixel renderer factory. // auto_ptr<IPixelRendererFactory> pixel_renderer_factory; { const string value = m_params.get_optional<string>("pixel_renderer", ""); if (value == "uniform") { pixel_renderer_factory.reset( new UniformPixelRendererFactory( sample_renderer_factory.get(), m_params.child("uniform_pixel_renderer"))); } else if (value == "adaptive") { pixel_renderer_factory.reset( new AdaptivePixelRendererFactory( frame, sample_renderer_factory.get(), m_params.child("adaptive_pixel_renderer"))); } else if (!value.empty()) { RENDERER_LOG_ERROR( "invalid value for \"pixel_renderer\" parameter: \"%s\".", value.c_str()); return IRendererController::AbortRendering; } } // // Create a shading result framebuffer factory. // auto_ptr<IShadingResultFrameBufferFactory> shading_result_framebuffer_factory; { const string value = m_params.get_optional<string>("shading_result_framebuffer", "ephemeral"); if (value == "ephemeral") { shading_result_framebuffer_factory.reset( new EphemeralShadingResultFrameBufferFactory()); } else if (value == "permanent") { shading_result_framebuffer_factory.reset( new PermanentShadingResultFrameBufferFactory(frame)); } else if (!value.empty()) { RENDERER_LOG_ERROR( "invalid value for \"shading_result_framebuffer\" parameter: \"%s\".", value.c_str()); return IRendererController::AbortRendering; } } // // Create a tile renderer factory. // auto_ptr<ITileRendererFactory> tile_renderer_factory; { const string value = m_params.get_optional<string>("tile_renderer", ""); if (value == "generic") { tile_renderer_factory.reset( new GenericTileRendererFactory( frame, pixel_renderer_factory.get(), shading_result_framebuffer_factory.get(), m_params.child("generic_tile_renderer"))); } else if (value == "blank") { tile_renderer_factory.reset(new BlankTileRendererFactory()); } else if (value == "debug") { tile_renderer_factory.reset(new DebugTileRendererFactory()); } else if (!value.empty()) { RENDERER_LOG_ERROR( "invalid value for \"tile_renderer\" parameter: \"%s\".", value.c_str()); return IRendererController::AbortRendering; } } // // Create a frame renderer. // auto_release_ptr<IFrameRenderer> frame_renderer; { const string value = m_params.get_required<string>("frame_renderer", "generic"); if (value == "generic") { ParamArray params = m_params.child("generic_frame_renderer"); copy_param(params, m_params, "rendering_threads"); frame_renderer.reset( GenericFrameRendererFactory::create( frame, tile_renderer_factory.get(), m_tile_callback_factory, pass_callback.get(), params)); } else if (value == "progressive") { ParamArray params = m_params.child("progressive_frame_renderer"); copy_param(params, m_params, "rendering_threads"); frame_renderer.reset( ProgressiveFrameRendererFactory::create( m_project, sample_generator_factory.get(), m_tile_callback_factory, params)); } else { RENDERER_LOG_ERROR( "invalid value for \"frame_renderer\" parameter: \"%s\".", value.c_str()); return IRendererController::AbortRendering; } } // Execute the main rendering loop. const IRendererController::Status status = render_frame_sequence( frame_renderer.get() #ifdef WITH_OSL , *shading_system #endif ); // Print texture store performance statistics. RENDERER_LOG_DEBUG("%s", texture_store.get_statistics().to_string().c_str()); return status; }
int spawnFilter(Connection *Conn,int iomode,int tofil[],int sock,iFUNCP func,PCStr(args)) { CStr(ein,32); int ac; const char *av[256]; /**/ CStr(epath,1024); CStr(logtype,64); CStr(logtype2,64); int fin; /* input at the filter side */ int fout; /* output at the DeleGate side */ int pid; int wcc; int wi; int fio[2]; /* a pipe to inherit Conn. */ FILE *out; SpawnArgs spawnArgs; iLog("--- spawnFilter sock=%d func=%X args=%X",sock,xp2i(func),p2i(args)); fin = tofil[0]; fout = tofil[1]; pipeX(fio,8*1024); out = fdopen(fio[1],"w"); sprintf(ein,"%d/%d/%d/%d %d/%d",fio[0],fio[1],fin,fout, CHILD_SERNO,CHILD_SERNO_MULTI); /* sprintf(ein,"%d/%d/%d/%d",fio[0],fio[1],fin,fout); */ /* sprintf(ein,"%d/%d",fin,fout); */ sprintf(epath,"%s=%s",P_EXEC_PATH,EXEC_PATH); ac = 0; av[ac++] = /*DeleGate1*/ "DeleGate"; av[ac++] = /*FuncFILTER*/ "(Filter)"; av[ac++] = ein; av[ac++] = epath; /* sprintf(logtype,"-L0x%x",LOG_type); */ sprintf(logtype,"-L0x%x/%d",LOG_type,curLogFd()); av[ac++] = logtype; if( LOG_type2 || LOG_bugs ){ sprintf(logtype2,"-L20x%x/%x",LOG_type2,LOG_bugs); av[ac++] = logtype2; } ac += copy_param("f",elnumof(av)-ac,&av[ac],&main_argv[1]); av[ac] = NULL; Conn->fi_func = func; if( args == NULL ) Conn->fi_arglen = 0; else Conn->fi_arglen = strlen(args)+1; Conn->fi_iomode = iomode; Conn->fi_logfd = curLogFd(); if( file_isreg(sock) ){ /* it might be TMPFILE() with CloseOnExec flag set */ clearCloseOnExec(sock); } Conn->fi_topeer = sock; Conn->fi_dupclsock = 0; if( Conn->fi_issock = file_ISSOCK(sock) ){ setclientsock(sock); if( sock == ClientSock || SocketOf(sock) == SocketOf(ClientSock) ) Conn->fi_dupclsock = 1; } /* might be emulating spawn() on Unix */ sigsetmask(sigblock(0) & ~sigmask(SIGHUP) ); pid = Spawnvp("openFilter",EXEC_PATH,av); Verbose("## spawnFilter: %d -> %d\n",getpid(),pid); if( pid <= 0 ){ /* 9.6.3 don't freeze in fwrite() to the pipe ... */ fclose(out); close(fio[0]); daemonlog("F","spawnFilter: FAILED %d\n",pid); porting_dbg("--FATAL: spawnFilter: FAILED spawn %d",pid); putpplog("--FATAL: spawnFilter: FAILED spawn %d\n",pid); return pid; } /* wcc = write(fout,Conn,sizeof(Connection)); if( Conn->cl_reqbuf ) write(fout,Conn->cl_reqbuf,Conn->cl_reqbufsize); if( args != NULL ) write(fout,args,strlen(args)+1); */ close(fio[0]); /* close here to get EPIPE on write(fio[1]) */ if( MountOptions ){ spawnArgs.sa_mountserno = MountSerno(MountOptions); spawnArgs.sa_moptslen = strlen(MountOptions)+1; }else{ spawnArgs.sa_mountserno = 0; spawnArgs.sa_moptslen = 0; } wcc = fwrite(&spawnArgs,1,sizeof(spawnArgs),out); wcc = fwrite(Conn,1,sizeof(Connection),out); if( Conn->cl_reqbuf ) fwrite(Conn->cl_reqbuf,1,Conn->cl_reqbufsize,out); if( args != NULL ) fwrite(args,1,strlen(args)+1,out); if( MountOptions && spawnArgs.sa_moptslen ){ fwrite(MountOptions,1,spawnArgs.sa_moptslen,out); setMountOptions(FL_ARG,Conn,0); } fclose(out); /* If the iomode == READ then * must wait till the client finish to read the written environment * not to read it by myself. * (in the case of FFROMCL, payload data may be ready, but cannot * identify whether or not it is env. data or payload data ...) * If the iomode == WRITE and filter is direct system-command then * must wait not to make buffered data be not passed to the filter. */ /* if( iomode == 0 || iomode != 0 && 0 < PollIn(fin,1) ){ sv1log("## wait the filter finish reading enviroment\n"); msleep(100); } */ return pid; }