def create_entities(self, scene):
self.__mat_name = self.appleseed_name + "_mat" if not self.__preview else "preview_mat"
as_mat_data = self.bl_mat.appleseed
osl_params = {
'surface_shader': "{0}_surface_shader".format(self.__mat_name)
}
shader_params = {
'lighting_samples': as_mat_data.shader_lighting_samples
} if hasattr(as_mat_data, "shader_lighting_samples") else {}
self.__surface_name = "{0}_surface_shader".format(self.__mat_name)
self.__as_shader = asr.SurfaceShader("physical_surface_shader",
self.__surface_name,
shader_params)
if self.bl_node_tree:
shadergroup_name = self.bl_node_tree.name if not self.__preview else "preview_mat_tree"
osl_params['osl_surface'] = shadergroup_name
if self.__shader_group is None:
self.__shader_group = asr.ShaderGroup(shadergroup_name)
self.__set_shader_group_parameters(scene)
self.__as_mat = asr.Material('osl_material', self.__mat_name,
osl_params)
def __create_default_material(self):
logger.debug("Creating default material")
surface_shader = asr.SurfaceShader("diagnostic_surface_shader", "__default_surface_shader", {'mode': 'facing_ratio'})
material = asr.Material('generic_material', "__default_material", {'surface_shader': '__default_surface_shader'})
self.__main_assembly.surface_shaders().insert(surface_shader)
self.__main_assembly.materials().insert(material)
def __create_preview_scene(self, scene):
"""This function creates the scene that is used to render material previews. It consists of:
A background plane
A single mesh lamp
A sphere with the material being previewed
"""
# Create the project
self.__project = asr.Project("preview_render")
# Render settings.
self.__project.add_default_configurations()
# Create the scene.
self.__project.set_scene(asr.Scene())
preview_template_dir = self.__create_project()
self.__create_camera(scene)
plane, plane_bsdf, plane_inst, plane_mat, plane_tex, plane_tex_inst = self.__create_backdrop(
preview_template_dir)
sphere, sphere_inst = self.__create_sphere(preview_template_dir)
lamp, lamp_edf, lamp_inst, lamp_mat = self.__create_lamp(
preview_template_dir)
# Create the base shader used for all preview set items
shader = asr.SurfaceShader("physical_surface_shader", "base_shader",
{})
# Insert all objects into the scene
for obj in lamp:
self.__main_assembly.objects().insert(obj)
self.__main_assembly.object_instances().insert(lamp_inst)
self.__main_assembly.materials().insert(lamp_mat)
self.__main_assembly.edfs().insert(lamp_edf)
self.__main_assembly.surface_shaders().insert(shader)
for obj in sphere:
self.__main_assembly.objects().insert(obj)
self.__main_assembly.object_instances().insert(sphere_inst)
for obj in plane:
self.__main_assembly.objects().insert(obj)
self.__main_assembly.object_instances().insert(plane_inst)
self.__main_assembly.materials().insert(plane_mat)
self.__main_assembly.bsdfs().insert(plane_bsdf)
self.__main_assembly.textures().insert(plane_tex)
self.__main_assembly.texture_instances().insert(plane_tex_inst)
def create_entities(self, bl_scene):
logger.debug("Creating entity for %s", self.appleseed_name)
as_mat_data = self.bl_mat.appleseed
if self.bl_mat.node_tree is not None:
self.__as_nodetree = NodeTreeTranslator(self.bl_mat.node_tree,
self.asset_handler,
self.appleseed_name)
self.__as_nodetree.create_entities(bl_scene)
mat_name = f"{self.appleseed_name}_mat"
surface_name = f"{self.appleseed_name}_surface"
self.__as_shader_params = self.__get_shader_params()
self.__as_shader = asr.SurfaceShader("physical_surface_shader",
surface_name, {})
self.__as_mat_params = self.__get_mat_params()
if as_mat_data.mode == 'surface':
self.__as_mat = asr.Material('osl_material', mat_name, {})
else:
vol_name = f"{self.appleseed_name}_volume"
self.__as_volume_params = self.__get_vol_params()
self.__as_colors.append(
asr.ColorEntity(
f"{vol_name}_absorption_color",
{'color_space': 'linear_rgb'},
self._convert_color(as_mat_data.volume_absorption)))
self.__as_colors.append(
asr.ColorEntity(
f"{vol_name}_scattering_color",
{'color_space': 'linear_rgb'},
self._convert_color(as_mat_data.volume_scattering)))
self.__as_mat = asr.Material('generic_material', mat_name, {})
self.__as_volume = asr.Volume('generic_volume', vol_name, {})
self.__as_volume.set_parameters(self.__as_volume_params)
self.__as_mat.set_parameters(self.__as_mat_params)
self.__as_shader.set_parameters(self.__as_shader_params)
def convert(tree):
project = asr.Project("project")
# Search paths.
paths = project.get_search_paths()
paths.append("models")
paths.append("textures")
project.set_search_paths(paths)
# Add default configurations to the project.
project.add_default_configurations()
# Enable caustics.
project.configurations().get_by_name("final").insert_path(
"pt.enable_caustics", True)
project.configurations().get_by_name("interactive").insert_path(
"pt.enable_caustics", True)
# Create a scene.
scene = asr.Scene()
# Create an assembly.
assembly = asr.Assembly("assembly")
assembly.surface_shaders().insert(
asr.SurfaceShader("physical_surface_shader",
"physical_surface_shader"))
# Convert the Mitsuba scene.
convert_scene(project, scene, assembly, tree.getroot())
# Create an instance of the assembly.
assembly_inst = asr.AssemblyInstance("assembly_inst", {},
assembly.get_name())
assembly_inst.transform_sequence().set_transform(
0.0, asr.Transformd(asr.Matrix4d.identity()))
scene.assembly_instances().insert(assembly_inst)
# Insert the assembly into the scene.
scene.assemblies().insert(assembly)
# Bind the scene to the project.
project.set_scene(scene)
return project
def create_entities(self, scene):
mat_name = self.appleseed_name + "_mat" if not self.__preview else "preview_mat"
as_mat_data = self.bl_mat.appleseed
shader_params = {'lighting_samples': as_mat_data.shader_lighting_samples} if hasattr(as_mat_data, "shader_lighting_samples") else {}
surface_name = "{0}_surface_shader".format(mat_name)
self.__as_shader = asr.SurfaceShader("physical_surface_shader",
surface_name, shader_params)
if as_mat_data.mode == 'surface':
mat_params = {'surface_shader': "{0}_surface_shader".format(mat_name)}
if self.bl_node_tree:
shadergroup_name = self.bl_node_tree.name if not self.__preview else "preview_mat_tree"
mat_params['osl_surface'] = shadergroup_name
if self.__shader_group is None:
self.__shader_group = asr.ShaderGroup(shadergroup_name)
self.__set_shader_group_parameters(scene)
self.__as_mat = asr.Material('osl_material', mat_name, mat_params)
else:
vol_name = mat_name + "_volume"
self.__colors.append(asr.ColorEntity(vol_name + "_absorption_color", {'color_space': 'linear_rgb'},
self._convert_color(as_mat_data.volume_absorption)))
self.__colors.append(asr.ColorEntity(vol_name + "_scattering_color", {'color_space': 'linear_rgb'},
self._convert_color(as_mat_data.volume_scattering)))
vol_params = {'absorption': vol_name + "_absorption_color",
'scattering': vol_name + "_scattering_color",
'absorption_multiplier': as_mat_data.volume_absorption_multiplier,
'scattering_multiplier': as_mat_data.volume_scattering_multiplier,
'phase_function_model': as_mat_data.volume_phase_function_model,
'average_cosine': as_mat_data.volume_average_cosine}
self.__volume = asr.Volume('generic_volume', vol_name, vol_params)
mat_params = {'surface_shader': "{0}_surface_shader".format(mat_name),
'volume': vol_name}
self.__as_mat = asr.Material('generic_material', mat_name, mat_params)
def create_entities(self, depsgraph, engine):
logger.debug(
f"appleseed: Creating material entity for {self.orig_name}")
surface_name = f"{self.orig_name}_surface"
if self.bl_mat.node_tree is not None:
self.__as_nodetree = NodeTreeTranslator(self.bl_node_tree,
self._asset_handler,
self.orig_name)
self.__as_nodetree.create_entities(depsgraph, engine)
self.__as_shader_params = self.__get_shader_params()
self.__as_mat_params = self.__get_mat_params()
self.__as_shader = asr.SurfaceShader("physical_surface_shader",
surface_name, {})
self.__as_mat = asr.Material('osl_material', self.orig_name, {})
self.__as_mat.set_parameters(self.__as_mat_params)
self.__as_shader.set_parameters(self.__as_shader_params)
def build_project():
# Create an empty project.
project = asr.Project('test project')
paths = project.get_search_paths()
paths.append('data')
project.set_search_paths(paths)
# Add default configurations to the project.
project.add_default_configurations()
# Set the number of samples. This is basically the quality parameter: the higher the number
# of samples, the smoother the image but the longer the rendering time.
# todo: fix.
conf = project.configurations()['final']
conf.insert_path('uniform_pixel_renderer.samples', 25)
# Create a scene.
scene = asr.Scene()
# Create an assembly.
assembly = asr.Assembly("assembly")
#------------------------------------------------------------------------
# Materials
#------------------------------------------------------------------------
# Create a color called "gray" and insert it into the assembly.
GrayReflectance = [0.5, 0.5, 0.5]
assembly.colors().insert(
asr.ColorEntity("gray", {'color_space': 'srgb'}, GrayReflectance))
# Create a BRDF called "diffuse_gray_brdf" and insert it into the assembly.
assembly.bsdfs().insert(
asr.BSDF("lambertian_brdf", "diffuse_gray_brdf",
{'reflectance': 'gray'}))
# Create a physical surface shader and insert it into the assembly.
assembly.surface_shaders().insert(
asr.SurfaceShader("physical_surface_shader",
"physical_surface_shader"))
# Create a material called "gray_material" and insert it into the assembly.
assembly.materials().insert(
asr.Material(
"gray_material", {
"surface_shader": "physical_surface_shader",
"bsdf": "diffuse_gray_brdf"
}))
#------------------------------------------------------------------------
# Geometry
#------------------------------------------------------------------------
# Load the scene geometry from disk.
objects = asr.MeshObjectReader.read(project.get_search_paths(), "cube",
{'filename': 'scene.obj'})
# Insert all the objects into the assembly.
for object in objects:
# Create an instance of this object and insert it into the assembly.
instance_name = object.get_name() + "_inst"
material_names = {
"default": "gray_material",
"default2": "gray_material"
}
instance = asr.ObjectInstance(instance_name, {}, object.get_name(),
asr.Transformd(asr.Matrix4d.identity()),
material_names)
assembly.object_instances().insert(instance)
# Insert this object into the scene.
assembly.objects().insert(object)
#------------------------------------------------------------------------
# Light
#------------------------------------------------------------------------
# Create a color called "light_intensity" and insert it into the assembly.
LightRadiance = [1.0, 1.0, 1.0]
assembly.colors().insert(
asr.ColorEntity("light_intensity", {
'color_space': 'srgb',
'multiplier': 30.0
}, LightRadiance))
# Create a point light called "light" and insert it into the assembly.
light = asr.Light("point_light", "light", {'intensity': 'light_intensity'})
light.set_transform(
asr.Transformd(asr.Matrix4d.translation(asr.Vector3d(0.6, 2.0, 1.0))))
assembly.lights().insert(light)
# Create an instance of the assembly and insert it into the scene.
assembly_inst = asr.AssemblyInstance("assembly_inst", {},
assembly.get_name())
assembly_inst.transform_sequence().set_transform(
0.0, asr.Transformd(asr.Matrix4d.identity()))
scene.assembly_instances().insert(assembly_inst)
# Insert the assembly into the scene.
scene.assemblies().insert(assembly)
#------------------------------------------------------------------------
# Environment
#------------------------------------------------------------------------
# Create a color called "sky_radiance" and insert it into the scene.
SkyRadiance = [0.75, 0.80, 1.0]
scene.colors().insert(
asr.ColorEntity("sky_radiance", {
'color_space': 'srgb',
'multiplier': 0.5
}, SkyRadiance))
# Create an environment EDF called "sky_edf" and insert it into the scene.
scene.environment_edfs().insert(
asr.EnvironmentEDF("constant_environment_edf", "sky_edf",
{'radiance': 'sky_radiance'}))
# Create an environment shader called "sky_shader" and insert it into the scene.
scene.environment_shaders().insert(
asr.EnvironmentShader("edf_environment_shader", "sky_shader",
{'environment_edf': 'sky_edf'}))
# Create an environment called "sky" and bind it to the scene.
scene.set_environment(
asr.Environment("sky", {
"environment_edf": "sky_edf",
"environment_shader": "sky_shader"
}))
#------------------------------------------------------------------------
# Camera
#------------------------------------------------------------------------
# Create a pinhole camera with film dimensions 0.980 x 0.735 in (24.892 x 18.669 mm).
params = {
'film_dimensions': asr.Vector2f(0.024892, 0.018669),
'focal_length': 0.035
}
camera = asr.Camera("pinhole_camera", "camera", params)
# Place and orient the camera. By default cameras are located in (0.0, 0.0, 0.0)
# and are looking toward Z- (0.0, 0.0, -1.0).
mat = asr.Matrix4d.rotation(asr.Vector3d(1.0, 0.0, 0.0),
math.radians(-20.0))
mat = mat * asr.Matrix4d.translation(asr.Vector3d(0.0, 0.8, 11.0))
camera.transform_sequence().set_transform(0.0, asr.Transformd(mat))
# Bind the camera to the scene.
scene.set_camera(camera)
#------------------------------------------------------------------------
# Frame
#------------------------------------------------------------------------
# Create a frame and bind it to the project.
params = {
'camera': scene.get_camera().get_name(),
'resolution': asr.Vector2i(640, 480),
'color_space': 'srgb'
}
project.set_frame(asr.Frame("beauty", params))
# Bind the scene to the project.
project.set_scene(scene)
return project
