void MaterialItem::slot_export()
{
const char* project_path = m_editor_context.m_project.get_path();
const filesystem::path project_root_path = filesystem::path(project_path).parent_path();
const filesystem::path file_path = absolute("material.dmt", project_root_path);
const filesystem::path file_root_path = file_path.parent_path();
QString filepath =
get_save_filename(
0,
"Export...",
"Disney Materials (*.dmt)",
m_editor_context.m_settings,
SETTINGS_FILE_DIALOG_PROJECTS);
if (!filepath.isEmpty())
{
if (QFileInfo(filepath).suffix().isEmpty())
filepath += ".dmt";
filepath = QDir::toNativeSeparators(filepath);
ParamArray parameters = m_entity->get_parameters();
parameters.insert("__name", m_entity->get_name());
parameters.insert("__model", m_entity->get_model());
SettingsFileWriter writer;
if (!writer.write(filepath.toStdString().c_str(), parameters))
{
show_error_message_box(
"Exporting Error",
"Failed to export the Disney Material file " + filepath.toStdString() + ".");
}
}
}
void MainWindow::update_override_shading_menu_item()
{
const ParamArray project_params = get_project_params("interactive");
const ParamArray shading_engine_params = project_params.child("shading_engine");
if (shading_engine_params.dictionaries().exist("override_shading"))
{
const string shading_mode =
shading_engine_params.child("override_shading").get_optional<string>("mode", "coverage");
for (const_each<QList<QAction*> > i = m_ui->menu_diagnostics_override_shading->actions(); i; ++i)
{
QAction* action = *i;
if (action->data().toString().toStdString() == shading_mode)
{
action->activate(QAction::Trigger);
break;
}
}
}
else
{
m_ui->action_diagnostics_override_shading_no_override->activate(QAction::Trigger);
}
}
void TestFixtureBase::create_color_entity(const char* name, const Color3f& linear_rgb)
{
ParamArray params;
params.insert("color_space", "linear_rgb");
const ColorValueArray values(3, &linear_rgb[0]);
m_scene.colors().insert(
ColorEntityFactory::create(name, params, values));
}
void ShadingEngine::create_diagnostic_surface_shader(const ParamArray& params)
{
if (params.dictionaries().exist("override_shading"))
{
m_diagnostic_surface_shader =
DiagnosticSurfaceShaderFactory().create(
"__diagnostic_surface_shader",
params.child("override_shading"));
}
}
void TestFixtureBase::create_color_entity(const char* name, const Spectrum& spectrum)
{
ParamArray params;
params.insert("color_space", "spectral");
params.insert("wavelength_range", "400.0 700.0");
const ColorValueArray values(spectrum.Samples, &spectrum[0]);
m_scene.colors().insert(
ColorEntityFactory::create(name, params, values));
}
void TestFixtureBase::create_texture_instance(const char* name, const char* texture_name)
{
ParamArray params;
params.insert("addressing_mode", "clamp");
params.insert("filtering_mode", "bilinear");
m_scene.texture_instances().insert(
TextureInstanceFactory::create(
name,
params,
texture_name,
Transformf::identity()));
}
ParamArray Configuration::get_inherited_parameters() const
{
if (m_base)
{
ParamArray params = m_base->m_params;
params.merge(m_params);
return params;
}
else
{
return m_params;
}
}
auto_release_ptr<MeshObject> create_primitive_mesh(const char* name, const ParamArray& params)
{
const char* primitive_type = params.get("primitive");
// Parametric surfaces.
if (strcmp(primitive_type, "grid") == 0)
return create_parametric_surface<ParametricGrid>(name, params);
if (strcmp(primitive_type, "disk") == 0)
return create_parametric_surface<ParametricDisk>(name, params);
if (strcmp(primitive_type, "sphere") == 0)
return create_parametric_surface<ParametricSphere>(name, params);
if (strcmp(primitive_type, "torus") == 0)
return create_parametric_surface<ParametricTorus>(name, params);
// Other, non-parametric primitives.
if (strcmp(primitive_type, "cube") == 0)
return create_cube(name, params);
RENDERER_LOG_ERROR("unknown primitive type: %s", primitive_type);
return auto_release_ptr<MeshObject>();
}
void ObjectCollectionItem::insert_objects(const string& path) const
{
const string base_object_name =
bf::path(path).replace_extension().filename().string();
ParamArray params;
params.insert("filename", path);
SearchPaths search_paths;
MeshObjectArray mesh_objects;
if (!MeshObjectReader().read(
search_paths,
base_object_name.c_str(),
params,
mesh_objects))
return;
for (size_t i = 0; i < mesh_objects.size(); ++i)
{
MeshObject* object = mesh_objects[i];
m_parent_item->add_item(object);
m_parent.objects().insert(auto_release_ptr<Object>(object));
const string object_instance_name = string(object->get_name()) + "_inst";
auto_release_ptr<ObjectInstance> object_instance(
ObjectInstanceFactory::create(
object_instance_name.c_str(),
ParamArray(),
object->get_name(),
Transformd::identity(),
StringDictionary()));
m_parent_item->add_item(object_instance.get());
m_parent.object_instances().insert(object_instance);
}
if (!mesh_objects.empty())
{
m_parent.bump_version_id();
m_editor_context.m_project_builder.slot_notify_project_modification();
}
}
size_t get_rendering_thread_count(const ParamArray& params)
{
const size_t core_count = System::get_logical_cpu_core_count();
static const char* ThreadCountParameterName = "rendering_threads";
if (!params.strings().exist(ThreadCountParameterName))
return core_count;
const string thread_count_str = params.strings().get<string>(ThreadCountParameterName);
if (thread_count_str == "auto")
return core_count;
bool conversion_failed = false;
size_t thread_count;
try
{
const int num_threads = from_string<int>(thread_count_str);
if (num_threads < 0)
{
// If num_threads is negative, use all cores except -num_threads.
thread_count = max(static_cast<int>(core_count) + num_threads, 1);
}
else
thread_count = num_threads;
}
catch (const ExceptionStringConversionError&)
{
conversion_failed = true;
}
if (conversion_failed || thread_count == 0)
{
RENDERER_LOG_ERROR(
"invalid value \"%s\" for parameter \"%s\", using default value \"%s\".",
thread_count_str.c_str(),
ThreadCountParameterName,
"auto");
return core_count;
}
return thread_count;
}
ParamArray MainWindow::get_project_params(const char* configuration_name) const
{
ParamArray params;
Configuration* configuration =
m_project_manager.is_project_open()
? m_project_manager.get_project()->configurations().get_by_name(configuration_name)
: 0;
if (configuration && configuration->get_base())
params = configuration->get_base()->get_parameters();
params.merge(m_settings);
if (configuration)
params.merge(configuration->get_parameters());
return params;
}
size_t FrameRendererBase::get_rendering_thread_count(const ParamArray& params)
{
const size_t core_count = System::get_logical_cpu_core_count();
static const char* ThreadCountParameterName = "rendering_threads";
if (!params.strings().exist(ThreadCountParameterName))
return core_count;
const string thread_count_str = params.strings().get<string>(ThreadCountParameterName);
if (thread_count_str == "auto")
return core_count;
bool conversion_failed = false;
size_t thread_count;
try
{
thread_count = from_string<size_t>(thread_count_str);
}
catch (const ExceptionStringConversionError&)
{
conversion_failed = true;
}
if (conversion_failed || thread_count == 0)
{
RENDERER_LOG_ERROR(
"invalid value \"%s\" for parameter \"%s\", using default value \"%s\".",
thread_count_str.c_str(),
ThreadCountParameterName,
"auto");
return core_count;
}
return thread_count;
}
ObjectInstance::ObjectInstance(
const char* name,
const ParamArray& params,
const char* object_name,
const Transformd& transform,
const StringDictionary& front_material_mappings,
const StringDictionary& back_material_mappings)
: Entity(g_class_uid, params)
, impl(new Impl())
{
set_name(name);
impl->m_transform = transform;
impl->m_object_name = object_name;
impl->m_front_material_mappings = front_material_mappings;
impl->m_back_material_mappings = back_material_mappings;
const EntityDefMessageContext message_context("object instance", this);
// Retrieve visibility flags.
m_vis_flags = VisibilityFlags::parse(params.child("visibility"), message_context);
// Retrieve medium priority.
m_medium_priority = params.get_optional<uint8>("medium_priority", 0);
// Retrieve ray bias method.
const string ray_bias_method =
params.get_optional<string>(
"ray_bias_method",
"none",
make_vector("none", "normal", "incoming_direction", "outgoing_direction"),
message_context);
if (ray_bias_method == "none")
m_ray_bias_method = RayBiasMethodNone;
else if (ray_bias_method == "normal")
m_ray_bias_method = RayBiasMethodNormal;
else if (ray_bias_method == "incoming_direction")
m_ray_bias_method = RayBiasMethodIncomingDirection;
else m_ray_bias_method = RayBiasMethodOutgoingDirection;
// Retrieve ray bias distance.
m_ray_bias_distance = params.get_optional<double>("ray_bias_distance", 0.0);
// No bound object yet.
m_object = 0;
}
// Initialize rendering components and render a frame.
IRendererController::Status initialize_and_render_frame()
{
// Construct an abort switch that will allow to abort initialization or rendering.
RendererControllerAbortSwitch abort_switch(*m_renderer_controller);
// Create the texture store.
TextureStore texture_store(
*m_project.get_scene(),
m_params.child("texture_store"));
// Initialize OSL's shading system.
if (!initialize_osl_shading_system(texture_store, abort_switch) ||
abort_switch.is_aborted())
{
// If it wasn't an abort, it was a failure.
return
abort_switch.is_aborted()
? m_renderer_controller->get_status()
: IRendererController::AbortRendering;
}
// Let scene entities perform their pre-render actions. Don't proceed if that failed.
// This is done before creating renderer components because renderer components need
// to access the scene's render data such as the scene's bounding box.
OnRenderBeginRecorder recorder;
if (!m_project.get_scene()->on_render_begin(m_project, nullptr, recorder, &abort_switch) ||
abort_switch.is_aborted())
{
recorder.on_render_end(m_project);
return m_renderer_controller->get_status();
}
// Create renderer components.
RendererComponents components(
m_project,
m_params,
m_tile_callback_factory,
texture_store,
*m_texture_system,
*m_shading_system);
if (!components.create())
{
recorder.on_render_end(m_project);
return IRendererController::AbortRendering;
}
// Print renderer components settings.
components.print_settings();
// Report whether Embree is used or not.
#ifdef APPLESEED_WITH_EMBREE
const bool use_embree = m_params.get_optional<bool>("use_embree", false);
m_project.set_use_embree(use_embree);
#else
const bool use_embree = false;
#endif
if (use_embree)
RENDERER_LOG_INFO("using Intel Embree ray tracing kernel.");
else RENDERER_LOG_INFO("using built-in ray tracing kernel.");
// Updating the trace context causes ray tracing acceleration structures to be updated or rebuilt.
m_project.update_trace_context();
// Load the checkpoint if any.
Frame& frame = *m_project.get_frame();
const size_t pass_count = m_params.get_optional<size_t>("passes", 1);
if (!frame.load_checkpoint(&components.get_shading_result_framebuffer_factory(), pass_count))
{
recorder.on_render_end(m_project);
return IRendererController::AbortRendering;
}
// Let renderer components perform their pre-render actions. Don't proceed if that failed.
if (!components.on_render_begin(recorder, &abort_switch) ||
abort_switch.is_aborted())
{
recorder.on_render_end(m_project);
return m_renderer_controller->get_status();
}
// Execute the main rendering loop.
const auto status = render_frame(components, abort_switch);
// Perform post-render actions.
recorder.on_render_end(m_project);
// End light path recording.
const CanvasProperties& props = m_project.get_frame()->image().properties();
m_project.get_light_path_recorder().finalize(
props.m_canvas_width,
props.m_canvas_height);
// Print texture store performance statistics.
RENDERER_LOG_DEBUG("%s", texture_store.get_statistics().to_string().c_str());
return status;
}
// Initialize OSL's shading system.
bool initialize_osl_shading_system(
TextureStore& texture_store,
IAbortSwitch& abort_switch)
{
// Construct a search paths string from the project's search paths.
const string project_search_paths =
to_string(m_project.search_paths().to_string_reversed(SearchPaths::osl_path_separator()));
// Initialize OIIO.
const size_t texture_cache_size_bytes =
m_params.child("texture_store").get_optional<size_t>(
"max_size",
TextureStore::get_default_size());
RENDERER_LOG_INFO(
"setting oiio texture cache size to %s.",
pretty_size(texture_cache_size_bytes).c_str());
const float texture_cache_size_mb =
static_cast<float>(texture_cache_size_bytes) / (1024 * 1024);
m_texture_system->attribute("max_memory_MB", texture_cache_size_mb);
// Set OIIO search paths.
string prev_oiio_search_path;
m_texture_system->getattribute("searchpath", prev_oiio_search_path);
if (prev_oiio_search_path != project_search_paths)
{
RENDERER_LOG_INFO("setting oiio search paths to %s", project_search_paths.c_str());
m_texture_system->invalidate_all(true);
m_texture_system->attribute("searchpath", project_search_paths);
}
// Also use the project search paths to look for OpenImageIO plugins.
m_texture_system->attribute("plugin_searchpath", project_search_paths);
// Initialize OSL.
m_renderer_services->initialize(texture_store);
// Set OSL search paths.
string prev_osl_search_paths;
m_shading_system->getattribute("searchpath:shader", prev_osl_search_paths);
if (prev_osl_search_paths != project_search_paths)
{
RENDERER_LOG_INFO("setting osl shader search paths to %s", project_search_paths.c_str());
m_project.get_scene()->release_optimized_osl_shader_groups();
m_shading_system->attribute("searchpath:shader", project_search_paths);
}
// Initialize the shader compiler, if the OSL headers are found.
if (m_resource_search_paths.exist("stdosl.h"))
{
const APIString stdosl_path = m_resource_search_paths.qualify("stdosl.h");
RENDERER_LOG_INFO("found OSL headers in %s", stdosl_path.c_str());
m_osl_compiler = ShaderCompilerFactory::create(stdosl_path.c_str());
}
else
RENDERER_LOG_INFO("OSL headers not found.");
// Re-optimize shader groups that need updating.
return
m_project.get_scene()->create_optimized_osl_shader_groups(
*m_shading_system,
m_osl_compiler.get(),
&abort_switch);
}
int main(int argc, char *argv[])
{
Meas.TaskList.TaskList_len = 1;
Meas.TaskList.TaskList_val = &Task;
Meas.GaugeStem = "";
Meas.RNGStem = "";
Task.OutputFilestem = "";
Task.ArgFilename = "arg_stem";
ws_out.cg = "";
ws_out.cg2 = "filename";
ws_out.pbp = "filename";
ws_out.mid_point = "filename";
ws_out.nucleon = "filename";
ws_out.nucleon_prime = "filename";
ws_out.delta_x = "filename";
ws_out.delta_y = "filename";
ws_out.delta_z = "filename";
ws_out.delta_t = "filename";
evo_arg.ensemble_id = "id";
evo_arg.ensemble_label = "label";
evo_arg.creator = "creator";
evo_arg.gauge_file_stem = "ckpoint_lat";
evo_arg.rng_file_stem = "ckpoint_rng";
evo_arg.plaquette_stem = "plaq";
evo_arg.evo_stem = "hmd";
evo_arg.work_directory = "";
ws_arg.CgArgFile = "CgFile";
rat_arg.resize(4);
rat_arg.resize(0, 10, 16);
rat_arg.resize(1, 10, 16);
rat_arg.resize(2, 9, 14);
rat_arg.resize(3, 6, 9);
bsn_arg.resize(1);
frm_arg.resize(1);
split_arg.resize(2);
quo_arg.resize(1);
rat_quo_arg.resize(1);
rat_quo_arg.resize(0, 9, 15, 6, 9);
float_array.resize(4);
param_array.resize(3);
param_array.params.params_val[0].name="mass";
param_array.params.params_val[1].name="epsilon";
param_array.params.params_val[2].name="u0";
stag_quark_src.type = S_QUARK_POINT;
for(int i = 0; i < 4; i++)
{
stag_quark_src.origin[i] = 0;
stag_quark_src.end[i] = 0;
}
stag_quark_src.dir = HDM_T;
stag_quark_arg.qid = 0;
stag_quark_arg.cg.mass = 0.1;
stag_quark_arg.cg.max_num_iter = 5000;
stag_quark_arg.cg.stop_rsd = 1e-10;
stag_quark_arg.cg.true_rsd = 1e-10;
stag_quark_arg.cg.RitzMatOper = MATPCDAG_MATPC;
stag_quark_arg.cg.Inverter = CG;
stag_quark_arg.cg.bicgstab_n = 1;
stag_quark_arg.src = stag_quark_src;
stag_quark_arg.sln = LOCAL;
stag_meson_arg.qid0 = 0;
stag_meson_arg.qid1 = 1;
stag_meson_arg.dir = HDM_T;
stag_meson_arg.meson_buf = 0;
stag_mom_meson_arg.qid0 = 0;
stag_mom_meson_arg.qid1 = 1;
stag_mom_meson_arg.dir = HDM_T;
stag_mom_meson_arg.no_of_momenta = 4;
stag_mom_meson_arg.meson_buf = 0;
stag_nucleon_arg.qid0 = 0;
stag_nucleon_arg.qid1 = 1;
stag_nucleon_arg.qid2 = 2;
stag_nucleon_arg.dir = HDM_T;
stag_nucleon_arg.nucleon_buf = 0;
stag_non_local_arg.qid0 = 0;
stag_non_local_arg.qid1 = 1;
stag_non_local_arg.qid2 = 2;
stag_non_local_arg.dir = HDM_T;
stag_non_local_arg.nlocal_buf = 0;
for(int i = 0; i < 8; i++)
nlstag_meson_arg.qid0[i] = i;
nlstag_meson_arg.dir = HDM_T;
nlstag_meson_arg.nlocal_buf = 0;
nuc3pt_arg.cname="AlgNuc3pt";
nuc3pt_arg.ensemble_label="AlgNuc3pt";
mdwf_arg.M5 = 1.8;
// mdwf_arg.cg_arg_p = &cg_arg;
cg_arg.Encode("cg_arg.vml","cg_arg");
mdwf_arg.Encode("mdwf_arg.vml","mdwf_arg");
hmd_arg.Encode("hmd_arg.vml","hmd_arg");
evo_arg.Encode("evo_arg.vml","evo_arg");
do_arg.Encode("do_arg.vml","do_arg");
ws_arg.Encode("w_spect_arg.vml","w_spect_arg");
ws_out.Encode("w_spect_output.vml","w_spect_output");
Meas.Encode("meas_arg.vml","meas_arg");
pa.Encode("pot_arg.vml","pot_arg");
pbp.Encode("pbp_arg.vml","pbp_arg");
fga.Encode("fix_gauge_arg.vml","fix_gauge_arg");
hmc_arg.Encode("hmc_arg.vml","hmc_arg");
quo_arg.Encode("quo_arg.vml","quo_arg");
frm_arg.Encode("frm_arg.vml","frm_arg");
bsn_arg.Encode("bsn_arg.vml","bsn_arg");
rat_arg.Encode("rat_arg.vml","rat_arg");
rat_quo_arg.Encode("rat_quo_arg.vml","rat_quo_arg");
split_arg.Encode("split_arg.vml","split_arg");
gauge_arg.Encode("gauge_arg.vml","gauge_arg");
ab_arg.Encode("ab_arg.vml","ab_arg");
eig_arg.Encode("eig_arg.vml","eig_arg");
float_array.Encode("float_array.vml","float_array");
param_array.Encode("param_array.vml","param_array");
stag_quark_src.Encode("stag_quark_src.vml","stag_quark_src");
stag_quark_arg.Encode("stag_quark_arg.vml","stag_quark_arg");
stag_meson_arg.Encode("stag_meson_arg.vml","stag_meson_arg");
stag_mom_meson_arg.Encode("stag_mom_meson_arg.vml","stag_mom_meson_arg");
stag_nucleon_arg.Encode("stag_nucleon_arg.vml","stag_nucleon_arg");
stag_non_local_arg.Encode("stag_non_local_arg.vml","stag_non_local_arg");
nlstag_meson_arg.Encode("nlstag_meson_arg.vml","nlstag_meson_arg");
qpropw_arg.Encode("qpropw_arg.vml","qpropw_arg");
eigcg_arg.Encode("eigcg_arg.vml","eigcg_arg");
nuc3pt_arg.Encode("nuc3pt_arg.vml","nuc3pt_arg");
vml_markup_type(VML_XML);
cg_arg.Encode("cg_arg.xml","cg_arg");
hmd_arg.Encode("hmd_arg.xml","hmd_arg");
evo_arg.Encode("evo_arg.xml","evo_arg");
do_arg.Encode("do_arg.xml","do_arg");
ws_arg.Encode("w_spect_arg.xml","w_spect_arg");
ws_out.Encode("w_spect_output.xml","w_spect_output");
hmc_arg.Encode("hmc_arg.xml","hmc_arg");
quo_arg.Encode("quo_arg.xml","quo_arg");
frm_arg.Encode("frm_arg.xml","frm_arg");
bsn_arg.Encode("bsn_arg.xml","bsn_arg");
rat_arg.Encode("rat_arg.xml","rat_arg");
rat_quo_arg.Encode("rat_quo_arg.xml","rat_quo_arg");
split_arg.Encode("split_arg.xml","split_arg");
gauge_arg.Encode("gauge_arg.xml","gauge_arg");
ab_arg.Encode("ab_arg.xml","ab_arg");
eig_arg.Encode("eig_arg.xml","eig_arg");
stag_quark_src.Encode("stag_quark_src.xml","stag_quark_src");
stag_quark_arg.Encode("stag_quark_arg.xml","stag_quark_arg");
stag_meson_arg.Encode("stag_meson_arg.xml","stag_meson_arg");
stag_mom_meson_arg.Encode("stag_mom_meson_arg.xml","stag_mom_meson_arg");
stag_nucleon_arg.Encode("stag_nucleon_arg.xml","stag_nucleon_arg");
stag_non_local_arg.Encode("stag_non_local_arg.xml","stag_non_local_arg");
nlstag_meson_arg.Encode("nlstag_meson_arg.xml","nlstag_meson_arg");
qpropw_arg.Encode("qpropw_arg.xml","qpropw_arg");
eigcg_arg.Encode("eigcg_arg.xml","eigcg_arg");
nuc3pt_arg.Encode("nuc3pt_arg.xml","nuc3pt_arg");
return(0);
}
Impl(
const char* type,
const char* shader,
const char* layer,
const ParamArray& params)
: m_type(type)
, m_shader(shader)
{
for (const_each<StringDictionary> i = params.strings(); i; ++i)
{
try
{
ShaderParamParser parser(i.it().value());
switch (parser.param_type())
{
case OSLParamTypeColor:
{
float r, g, b;
parser.parse_three_values<float>(r, g, b, true);
m_params.insert(ShaderParam::create_color_param(i.it().key(), r, g, b));
}
break;
case OSLParamTypeColorArray:
{
vector<float> values;
parser.parse_float3_array(values);
m_params.insert(ShaderParam::create_color_array_param(i.it().key(), values));
}
break;
case OSLParamTypeFloat:
{
const float val = parser.parse_one_value<float>();
m_params.insert(ShaderParam::create_float_param(i.it().key(), val));
}
break;
case OSLParamTypeFloatArray:
{
vector<float> values;
parser.parse_float_array(values);
m_params.insert(ShaderParam::create_float_array_param(i.it().key(), values));
}
break;
case OSLParamTypeInt:
{
const int val = parser.parse_one_value<int>();
m_params.insert(ShaderParam::create_int_param(i.it().key(), val));
}
break;
case OSLParamTypeMatrix:
{
float val[16];
parser.parse_n_values(16, val);
m_params.insert(ShaderParam::create_matrix_param(i.it().key(), val));
}
break;
case OSLParamTypeNormal:
{
float x, y, z;
parser.parse_three_values<float>(x, y, z);
m_params.insert(ShaderParam::create_normal_param(i.it().key(), x, y, z));
}
break;
case OSLParamTypeNormalArray:
{
vector<float> values;
parser.parse_float3_array(values);
m_params.insert(ShaderParam::create_normal_array_param(i.it().key(), values));
}
break;
case OSLParamTypePoint:
{
float x, y, z;
parser.parse_three_values<float>(x, y, z);
m_params.insert(ShaderParam::create_point_param(i.it().key(), x, y, z));
}
break;
case OSLParamTypePointArray:
{
vector<float> values;
parser.parse_float3_array(values);
m_params.insert(ShaderParam::create_point_array_param(i.it().key(), values));
}
break;
case OSLParamTypeString:
{
m_params.insert(
ShaderParam::create_string_param(
i.it().key(),
parser.parse_string_value().c_str()));
}
break;
case OSLParamTypeVector:
{
float x, y, z;
parser.parse_three_values<float>(x, y, z);
m_params.insert(ShaderParam::create_vector_param(i.it().key(), x, y, z));
}
break;
case OSLParamTypeVectorArray:
{
vector<float> values;
parser.parse_float3_array(values);
m_params.insert(ShaderParam::create_vector_array_param(i.it().key(), values));
}
break;
default:
RENDERER_LOG_ERROR(
"error adding OSL param %s, of unknown type %s; will use the default value.",
i.it().key(),
i.it().value());
break;
}
}
catch (const ExceptionOSLParamParseError&)
{
RENDERER_LOG_ERROR(
"error parsing OSL param value, param = %s, value = %s; will use the default value.",
i.it().key(),
i.it().value());
}
}
}
void MaterialCollectionItem::slot_import_disney()
{
#ifdef APPLESEED_WITH_DISNEY_MATERIAL
QString filepath =
get_open_filename(
0,
"Import...",
"Disney Material (*.dmt);;All Files (*.*)",
m_editor_context.m_settings,
SETTINGS_FILE_DIALOG_PROJECTS);
if (!filepath.isEmpty())
{
filepath = QDir::toNativeSeparators(filepath);
const bf::path root_path(Application::get_root_path());
const bf::path schema_file_path = root_path / "schemas" / "settings.xsd";
SettingsFileReader reader(global_logger());
ParamArray parameters;
const bool success =
reader.read(
filepath.toStdString().c_str(),
schema_file_path.string().c_str(),
parameters);
if (!success)
{
show_error_message_box(
"Importing Error",
"Failed to import the Disney Material file " + filepath.toStdString());
return;
}
string name = parameters.get("__name");
const string model = parameters.get("__model");
parameters.strings().remove("__name");
parameters.strings().remove("__model");
if (model != "disney_material")
{
show_error_message_box(
"Importing Error",
"Material model " + model + " is not supported.");
return;
}
// If there is already a material with the same name, rename the imported material.
for (const_each<MaterialContainer> i = m_parent.materials(); i; ++i)
{
if (strcmp(i->get_name(), name.c_str()) == 0)
{
name = make_unique_name(name, m_parent.materials());
break;
}
}
auto_release_ptr<Material> material =
DisneyMaterialFactory().create(name.c_str(), parameters);
Material* material_ptr = material.get();
add_item(material_ptr);
EntityTraits<Material>::insert_entity(material, m_parent);
m_editor_context.m_project_builder.notify_project_modification();
m_editor_context.m_project_explorer.select_entity(material_ptr->get_uid());
}
#endif
}
// Create a new instance of the default project.
auto_release_ptr<Project> DefaultProjectFactory::create()
{
// Create a project.
auto_release_ptr<Project> project(ProjectFactory::create("default"));
// Add default configurations to the project.
project->add_default_configurations();
// Create a scene.
auto_release_ptr<Scene> scene(SceneFactory::create());
// Create an assembly.
auto_release_ptr<Assembly> assembly(
AssemblyFactory::create("assembly", ParamArray()));
// Create an instance of the assembly and insert it into the scene.
scene->assembly_instances().insert(
AssemblyInstanceFactory::create(
"assembly_inst",
ParamArray(),
*assembly,
Transformd(Matrix4d::identity())));
// Insert the assembly into the scene.
scene->assemblies().insert(assembly);
//
// Camera.
//
{
// Create a pinhole camera.
// Film dimensions are 0.980 in × 0.735 in (24.892 mm x 18.669 mm).
// Reference: http://en.wikipedia.org/wiki/Aspect_ratio_(image).
ParamArray params;
params.insert("film_dimensions", "0.024892 0.018669");
params.insert("focal_length", "0.035");
auto_release_ptr<Camera> camera(
PinholeCameraFactory().create("camera", params));
// Attach the camera to the scene.
scene->set_camera(camera);
}
//
// Frame.
//
{
// Create a frame.
ParamArray params;
params.insert("camera", scene->get_camera()->get_name());
params.insert("resolution", "640 480");
params.insert("color_space", "srgb");
auto_release_ptr<Frame> frame(FrameFactory::create("beauty", params));
// Attach the frame to the project.
project->set_frame(frame);
}
// Attach the scene to the project.
project->set_scene(scene);
// Return the newly created project.
return project;
}
