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