ShaderGroup::ShaderGroup(const char* name)
: ConnectableEntity(g_class_uid, ParamArray())
, impl(new Impl())
{
set_name(name);
clear();
}
void AssemblyItem::slot_instantiate()
{
const string instance_name_suggestion =
get_name_suggestion(
string(m_assembly.get_name()) + "_inst",
m_parent.assembly_instances());
const string instance_name =
get_entity_name_dialog(
treeWidget(),
"Instantiate Assembly",
"Assembly Instance Name:",
instance_name_suggestion);
if (!instance_name.empty())
{
auto_release_ptr<AssemblyInstance> assembly_instance(
AssemblyInstanceFactory::create(
instance_name.c_str(),
ParamArray(),
m_assembly.get_name()));
m_parent_item->get_assembly_instance_collection_item().add_item(assembly_instance.get());
m_parent.assembly_instances().insert(assembly_instance);
m_project_builder.get_project().get_scene()->bump_version_id();
m_project_builder.notify_project_modification();
}
}
auto_release_ptr<Configuration> BaseConfigurationFactory::create_base_final()
{
auto_release_ptr<Configuration> configuration(new Configuration("base_final"));
ParamArray& parameters = configuration->get_parameters();
parameters.insert("spectrum_mode", "rgb");
parameters.insert("sampling_mode", "qmc");
parameters.insert("passes", 1);
parameters.insert("frame_renderer", "generic");
parameters.insert("tile_renderer", "generic");
parameters.insert("pixel_renderer", "uniform");
parameters.dictionaries().insert(
"uniform_pixel_renderer",
ParamArray()
.insert("samples", "64"));
parameters.insert("sample_renderer", "generic");
parameters.insert("lighting_engine", "pt");
return configuration;
}
DisneyLayeredBRDF::DisneyLayeredBRDF(const DisneyMaterial* parent)
: BSDF("disney_layered_brdf", Reflective, BSDFSample::Diffuse | BSDFSample::Glossy, ParamArray())
, m_parent(parent)
, m_brdf(DisneyBRDFFactory().create("disney_brdf", ParamArray()))
{
assert(parent);
}
void AssemblyCollectionItem::slot_create()
{
const string assembly_name =
get_entity_name_dialog(
treeWidget(),
"Create Assembly",
"Assembly Name:",
make_unique_name("assembly", m_parent.assemblies()));
// todo: schedule creation of assembly when rendering.
if (!assembly_name.empty())
{
auto_release_ptr<Assembly> assembly(
AssemblyFactory().create(assembly_name.c_str(), ParamArray()));
AssemblyItem* assembly_item =
static_cast<AssemblyItem*>(m_parent_item->add_item(assembly.get()));
m_parent.assemblies().insert(assembly);
const string assembly_instance_name =
make_unique_name(
assembly_name + "_inst",
m_parent.assembly_instances());
assembly_item->instantiate(assembly_instance_name);
m_editor_context.m_project_builder.slot_notify_project_modification();
}
}
TestFixtureBaseProjectHolder::TestFixtureBaseProjectHolder()
: m_project(ProjectFactory::create("project"))
{
m_project->set_scene(SceneFactory::create());
m_project->get_scene()->assemblies().insert(
AssemblyFactory().create("assembly", ParamArray()));
};
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"));
// Create an instance of the assembly and insert it into the scene.
scene->assembly_instances().insert(
AssemblyInstanceFactory::create(
"assembly_inst",
ParamArray(),
"assembly"));
// Insert the assembly into the scene.
scene->assemblies().insert(assembly);
// Create a pinhole camera and attach it to the scene.
scene->set_camera(
PinholeCameraFactory().create(
"camera",
ParamArray()
.insert("film_dimensions", "0.01024 0.00576")
.insert("focal_length", "0.035")));
// Create a frame (quarter 2K resolution) and attach it to the project.
project->set_frame(
FrameFactory::create(
"beauty",
ParamArray()
.insert("camera", scene->get_camera()->get_name())
.insert("resolution", "1024 576")));
// Attach the scene to the project.
project->set_scene(scene);
// Return the newly created project.
return project;
}
explicit Impl(Entity* parent)
: m_environment_edfs(parent)
, m_environment_shaders(parent)
, m_default_surface_shader(
PhysicalSurfaceShaderFactory().create(
"default_surface_shader",
ParamArray()))
{
}
ParamArray& ParamArray::push(const char* name)
{
assert(name);
if (!dictionaries().exist(name))
dictionaries().insert(name, ParamArray());
return static_cast<ParamArray&>(dictionaries().get(name));
}
BSSRDF::BSSRDF(
const char* name,
const ParamArray& params)
: ConnectableEntity(g_class_uid, params)
, impl(new Impl())
{
impl->m_brdf =
LambertianBRDFFactory().create(
(string(name) + "_brdf").c_str(),
ParamArray().insert("reflectance", "1.0"));
set_name(name);
}
void AssemblyItem::do_instantiate(const string& name)
{
auto_release_ptr<AssemblyInstance> assembly_instance(
AssemblyInstanceFactory::create(
name.c_str(),
ParamArray(),
m_assembly.get_name()));
m_parent_item->get_assembly_instance_collection_item().add_item(assembly_instance.get());
m_parent.assembly_instances().insert(assembly_instance);
m_editor_context.m_project.get_scene()->bump_version_id();
m_editor_context.m_project_builder.slot_notify_project_modification();
}
const Material& MaterialCollectionItem::create_default_disney_material(const string& material_name)
{
auto_release_ptr<Material> material =
DisneyMaterialFactory().create(material_name.c_str(), ParamArray());
static_cast<DisneyMaterial*>(material.get())->add_new_default_layer();
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();
return *material_ptr;
}
void ObjectItem::do_instantiate(const string& name)
{
auto_release_ptr<ObjectInstance> object_instance(
ObjectInstanceFactory::create(
name.c_str(),
ParamArray(),
m_entity->get_name(),
Transformd::identity(),
StringDictionary()));
m_parent_item->add_item(object_instance.get());
m_parent.object_instances().insert(object_instance);
m_parent.bump_version_id();
m_project_builder.notify_project_modification();
}
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();
}
}
ShaderConnection::ShaderConnection(
const char* src_layer,
const char* src_param,
const char* dst_layer,
const char* dst_param)
: Entity(g_class_uid, ParamArray())
, impl(new Impl)
{
impl->m_src_layer = src_layer;
impl->m_src_param = src_param;
impl->m_dst_layer = dst_layer;
impl->m_dst_param = dst_param;
const string entity_name =
string(get_src_layer()) + ":" + get_src_param() + "->" + get_dst_layer() + ":" + get_dst_param();
set_name(entity_name.c_str());
}
// 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;
}
BoundingBoxObject::BoundingBoxObject(const char* name, const GAABB3& bbox)
: Object(name, ParamArray())
, m_bbox(bbox)
, m_lazy_region_kit(&m_region_kit)
{
}
