def convert_plastic_bsdf(assembly, bsdf_name, element, roughness=0.0):
bsdf_params = {}
distribution_element = element.find("string[@name='distribution']")
if distribution_element is not None:
distribution = distribution_element.attrib["value"]
if distribution == "phong":
warning(
"Phong distribution not supported by appleseed's plastic BRDF, defaulting to GGX"
)
distribution = "ggx"
bsdf_params["mdf"] = distribution
else:
bsdf_params["mdf"] = "beckmann"
specular_reflectance_element = element.find(
"*[@name='specularReflectance']")
bsdf_params["specular_reflectance"] = convert_colormap(assembly, bsdf_name, specular_reflectance_element) \
if specular_reflectance_element is not None else 1.0
bsdf_params["roughness"] = roughness
diffuse_reflectance_element = element.find("*[@name='diffuseReflectance']")
bsdf_params["diffuse_reflectance"] = convert_colormap(assembly, bsdf_name, diffuse_reflectance_element) \
if diffuse_reflectance_element is not None else 0.5
ior_element = element.find("float[@name='intIOR']")
bsdf_params["ior"] = float(
ior_element.attrib["value"]) if ior_element is not None else 1.49
nonlinear_element = element.find("boolean[@name='nonlinear']")
bsdf_params["internal_scattering"] = 1.0 if nonlinear_element is not None and \
nonlinear_element.attrib["value"] == "true" else 0.0
assembly.bsdfs().insert(asr.BSDF("plastic_brdf", bsdf_name, bsdf_params))
def __create_backdrop(self, preview_template_dir):
# Define the background plane
plane = asr.MeshObjectReader.read(
[], "plane_obj", {
'filename':
os.path.join(preview_template_dir,
'material_preview_ground.binarymesh')
})
plane_inst = asr.ObjectInstance(
"plane", {}, "plane_obj.part_0",
asr.Transformd(asr.Matrix4d.identity()), {'default': "plane_mat"})
plane_mat = asr.Material("generic_material", "plane_mat", {
'bsdf': "plane_bsdf",
'surface_shader': "base_shader"
})
plane_bsdf = asr.BSDF("lambertian_brdf", "plane_bsdf",
{'reflectance': "plane_tex"})
plane_tex = asr.Texture(
"disk_texture_2d", "plane_tex_tex", {
'filename':
os.path.join(preview_template_dir, "checker_texture.png"),
'color_space':
'srgb'
}, [])
plane_tex_inst = asr.TextureInstance(
"plane_tex", {}, "plane_tex_tex",
asr.Transformf(asr.Matrix4f.identity()))
return plane, plane_bsdf, plane_inst, plane_mat, plane_tex, plane_tex_inst
def convert_diffuse_bsdf(assembly, bsdf_name, element):
bsdf_params = {}
reflectance = element.find("*[@name='reflectance']")
bsdf_params["reflectance"] = convert_colormap(assembly, bsdf_name, reflectance)
assembly.bsdfs().insert(asr.BSDF("lambertian_brdf", bsdf_name, bsdf_params))
def convert_roughdiffuse_bsdf(assembly, bsdf_name, element):
bsdf_params = {}
reflectance = element.find("*[@name='reflectance']")
bsdf_params["reflectance"] = convert_colormap(assembly, bsdf_name, reflectance)
bsdf_params["roughness"] = convert_alpha_to_roughness(element, 0.2)
assembly.bsdfs().insert(asr.BSDF("orennayar_brdf", bsdf_name, bsdf_params))
def convert_conductor_bsdf(assembly, bsdf_name, element, roughness=0.0):
bsdf_params = {}
material_element = element.find("string[@name='material']")
if material_element is not None:
material = material_element.attrib["value"]
if material == "none":
bsdf_params["mdf"] = "ggx"
bsdf_params["normal_reflectance"] = 1.0
bsdf_params["edge_tint"] = 0.0
bsdf_params["roughness"] = roughness
assembly.bsdfs().insert(
asr.BSDF("metal_brdf", bsdf_name, bsdf_params))
return
eta_element = element.find("rgb[@name='eta']")
eta_rgb = get_rgb(eta_element)
k_element = element.find("rgb[@name='k']")
k_rgb = get_rgb(k_element)
normal_reflectance_rgb, edge_tint_rgb = fresnel_conductor_inverse_reparam(
eta_rgb, k_rgb)
normal_reflectance_color_name = "{0}_normal_reflectance".format(bsdf_name)
create_linear_rgb_color(assembly, normal_reflectance_color_name,
normal_reflectance_rgb, 1.0)
edge_tint_color_name = "{0}_edge_tint".format(bsdf_name)
create_linear_rgb_color(assembly, edge_tint_color_name, edge_tint_rgb, 1.0)
bsdf_params["mdf"] = "ggx"
bsdf_params["normal_reflectance"] = normal_reflectance_color_name
bsdf_params["edge_tint"] = edge_tint_color_name
bsdf_params["roughness"] = roughness
specular_reflectance_element = element.find(
"*[@name='specularReflectance']")
bsdf_params["reflectance_multiplier"] = convert_colormap(assembly, bsdf_name, specular_reflectance_element) \
if specular_reflectance_element is not None else 1.0
assembly.bsdfs().insert(asr.BSDF("metal_brdf", bsdf_name, bsdf_params))
def convert_dielectric_bsdf(assembly, bsdf_name, element, roughness=0.0):
bsdf_params = {}
# todo: support textured IOR.
bsdf_params["ior"] = float(element.find("float[@name='intIOR']").attrib["value"])
bsdf_params["mdf"] = "ggx"
bsdf_params["surface_transmittance"] = 1.0
bsdf_params["roughness"] = roughness
specular_reflectance_element = element.find("*[@name='specularReflectance']")
bsdf_params["reflection_tint"] = convert_colormap(assembly, bsdf_name, specular_reflectance_element) \
if specular_reflectance_element is not None else 1.0
specular_transmittance_element = element.find("*[@name='specularTransmittance']")
bsdf_params["refraction_tint"] = convert_colormap(assembly, bsdf_name, specular_transmittance_element) \
if specular_transmittance_element is not None else 1.0
assembly.bsdfs().insert(asr.BSDF("glass_bsdf", bsdf_name, bsdf_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
def build_project():
# Create an empty project.
project = asr.Project('test project')
# 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', 16)
# Create a scene.
scene = asr.Scene()
# Create an assembly.
assembly = asr.Assembly("assembly")
#------------------------------------------------------------------------
# Materials
#------------------------------------------------------------------------
for i in range(0, 10):
assembly.bsdfs().insert(
asr.BSDF(
"glossy_brdf", "glossy" + str(i), {
"mdf": "ggx",
"reflectance": 1.0,
"roughness": i / 9.0,
"energy_compensation": 0.0
}))
assembly.bsdfs().insert(
asr.BSDF(
"glossy_brdf", "glossy_ec" + str(i), {
"mdf": "ggx",
"reflectance": 1.0,
"roughness": i / 9.0,
"energy_compensation": 1.0
}))
for i in range(0, 10):
assembly.materials().insert(
asr.Material("generic_material", "mat" + str(i),
{"bsdf": "glossy" + str(i)}))
assembly.materials().insert(
asr.Material("generic_material", "mat_ec" + str(i),
{"bsdf": "glossy_ec" + str(i)}))
#------------------------------------------------------------------------
# Geometry
#------------------------------------------------------------------------
object_name = "sphere"
object = asr.MeshObject(object_name, {
"primitive": "sphere",
"radius": 0.4
})
assembly.objects().insert(object)
obj_instance_params = {'visibility': {"glossy": False, "shadow": False}}
for i in range(0, 10):
instance_name = object_name + "_inst" + str(i)
material_names = {"default": "mat" + str(i)}
mat = asr.Matrix4d.make_translation(asr.Vector3d(-5.0 + i, -0.5, 0.0))
instance = asr.ObjectInstance(instance_name,
obj_instance_params, object_name,
asr.Transformd(mat), material_names)
assembly.object_instances().insert(instance)
for i in range(0, 10):
instance_name = object_name + "_ec_inst" + str(i)
material_names = {"default": "mat_ec" + str(i)}
mat = asr.Matrix4d.make_translation(asr.Vector3d(-5.0 + i, 0.5, 0.0))
instance = asr.ObjectInstance(instance_name,
obj_instance_params, object_name,
asr.Transformd(mat), material_names)
assembly.object_instances().insert(instance)
#------------------------------------------------------------------------
# Assembly instance
#------------------------------------------------------------------------
# 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 "gray" and insert it into the scene.
Gray = [0.5, 0.5, 0.5]
scene.colors().insert(
asr.ColorEntity("gray", {
'color_space': 'linear_rgb',
'multiplier': 1.0
}, Gray))
# Create an environment EDF called "gray_edf" and insert it into the scene.
scene.environment_edfs().insert(
asr.EnvironmentEDF("constant_environment_edf", "gray_edf",
{'radiance': 'gray'}))
# Create an environment shader called "gray_shader" and insert it into the scene.
scene.environment_shaders().insert(
asr.EnvironmentShader("edf_environment_shader", "gray_shader",
{'environment_edf': 'gray_edf'}))
# Create an environment called "sky" and bind it to the scene.
scene.set_environment(
asr.Environment("sky", {
"environment_edf": "gray_edf",
"environment_shader": "gray_shader"
}))
#------------------------------------------------------------------------
# Camera
#------------------------------------------------------------------------
params = {
'film_dimensions': asr.Vector2f(0.0640, 0.0200),
'focal_length': 0.035
}
camera = asr.Camera("pinhole_camera", "camera", params)
mat = asr.Matrix4d.make_translation(
asr.Vector3d(-0.444315058060864, -0.071277492791890,
5.674764299781837))
camera.transform_sequence().set_transform(0.0, asr.Transformd(mat))
# Bind the camera to the scene.
scene.cameras().insert(camera)
#------------------------------------------------------------------------
# Frame
#------------------------------------------------------------------------
# Create a frame and bind it to the project.
params = {'camera': 'camera', 'resolution': asr.Vector2i(640, 200)}
project.set_frame(asr.Frame("beauty", params))
# Bind the scene to the project.
project.set_scene(scene)
return project
