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