def test_get_item(self): col = asr.ColorEntity("color", {}) self.color_vec.insert(col) col = asr.ColorEntity("another_color", {}) self.color_vec.insert(col) self.assertEqual(self.color_vec[0].get_name(), "color") self.assertEqual(self.color_vec[1].get_name(), "another_color") self.assertEqual(self.color_vec[-1].get_name(), "another_color")
def test_get_by_name(self): col = asr.ColorEntity("color", {}) self.color_vec.insert(col) col = asr.ColorEntity("another_color", {}) self.color_vec.insert(col) c = self.color_vec.get_by_name("color") self.assertEqual(c.get_name(), "color") c = self.color_vec.get_by_name("another_color") self.assertEqual(c.get_name(), "another_color") c = self.color_vec.get_by_name("no_such_color") self.assertEqual(c, None)
def create_entities(self, scene): lamp = self.bl_lamp as_lamp_data = lamp.data.appleseed type_mapping = {'POINT': 'point_light', 'SPOT': 'spot_light', 'HEMI': 'directional_light', 'SUN': 'sun_light'} model = type_mapping[lamp.data.type] light_params = {'intensity': "{0}_radiance".format(self.bl_lamp.name), 'intensity_multiplier': as_lamp_data.radiance_multiplier, 'exposure': as_lamp_data.exposure, 'cast_indirect_light': as_lamp_data.cast_indirect, 'importance_multiplier': as_lamp_data.importance_multiplier} if model == 'spot_light': self.__create_spot_lamp(as_lamp_data, lamp, light_params) if model == 'sun_light': self.__create_sun_lamp(as_lamp_data, light_params) if model == 'directional_light': light_params['irradiance'] = light_params.pop('intensity') light_params['irradiance_multiplier'] = light_params.pop('intensity_multiplier') self.__as_light = asr.Light(model, self.bl_lamp.name, light_params) self.__as_light.set_transform(self._convert_matrix(self.bl_lamp.matrix_world)) radiance = self._convert_color(as_lamp_data.radiance) lamp_radiance_name = "{0}_radiance".format(self.bl_lamp.name) self.__as_light_radiance = asr.ColorEntity(lamp_radiance_name, {'color_space': 'linear_rgb'}, radiance)
def test_get_by_uuid(self): col = asr.ColorEntity("color", {}) uid1 = col.get_uid() self.color_vec.insert(col) col = asr.ColorEntity("another_color", {}) uid2 = col.get_uid() self.color_vec.insert(col) c = self.color_vec.get_by_uid(uid1) self.assertEqual(c.get_name(), "color") c = self.color_vec.get_by_uid(uid2) self.assertEqual(c.get_name(), "another_color") c = self.color_vec.get_by_uid(77567) self.assertEqual(c, None)
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 __set_colors(self): as_world = self.bl_world.appleseed_sky if self.__as_env_type == 'constant': self.__as_colors.append( asr.ColorEntity('horizon_radiance_color', {'color_space': 'linear_rgb'}, self._convert_color(as_world.horizon_color))) elif self.__as_env_type in ('gradient', 'constant_hemisphere'): self.__as_colors.append( asr.ColorEntity('horizon_radiance_color', {'color_space': 'linear_rgb'}, self._convert_color(as_world.horizon_color))) self.__as_colors.append( asr.ColorEntity('zenith_radiance_color', {'color_space': 'linear_rgb'}, self._convert_color(as_world.zenith_color)))
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 test_insert_remove(self): col = asr.ColorEntity("color", {}) self.color_vec.insert(col) self.assertEqual(len(self.color_vec), 1) c = self.color_vec.get_by_name("color") col = self.color_vec.remove(c) self.assertEqual(len(self.color_vec), 0) self.color_vec.insert(col) self.assertEqual(len(self.color_vec), 1)
def convert_texture(parent, texture_name, element): type = element.attrib["type"] if type == "bitmap": filepath = element.find("string[@name='filename']").attrib["value"] return create_texture(parent, texture_name, filepath) else: warning("Don't know how to convert texture of type {0}".format(type)) color_params = {"color_space": "srgb", "multiplier": 1.0} parent.colors().insert( asr.ColorEntity(texture_name, color_params, [0.7, 0.7, 0.7])) return texture_name
def create_entities(self, depsgraph, deforms_length): logger.debug(f"appleseed: Creating lamp entity for {self.orig_name}") as_lamp_data = self.bl_lamp.data.appleseed self.__lamp_model = self.__get_lamp_model() if self.bl_lamp.data.type != 'AREA': self.__radiance = self._convert_color(as_lamp_data.radiance) lamp_radiance_name = f"{self.orig_name}_radiance" self.__as_lamp_radiance = asr.ColorEntity( lamp_radiance_name, {'color_space': 'linear_rgb'}, self.__radiance) if self.__lamp_model == 'point_light': self.__as_lamp_params = self.__get_point_lamp_params() if self.__lamp_model == 'spot_light': self.__as_lamp_params = self.__get_spot_lamp_params() if self.__lamp_model == 'directional_light': self.__as_lamp_params = self.__get_directional_lamp_params() if self.__lamp_model == 'sun_light': self.__as_lamp_params = self.__get_sun_lamp_params() self.__as_lamp = asr.Light(self.__lamp_model, self.orig_name, self.__as_lamp_params) else: shape_params = self._get_area_mesh_params() mesh_name = f"{self.orig_name}_mesh" self.__as_area_lamp_mesh = asr.create_primitive_mesh( mesh_name, shape_params) mat_name = f"{self.orig_name}_mat" shader_name = f"{self.orig_name}_tree" self.__instance_params = self._get_area_mesh_instance_params() if not self.bl_lamp.data.use_nodes: shader_name = f"{self.orig_name}_tree" self.__as_area_lamp_shadergroup = asr.ShaderGroup(shader_name) self._set_shadergroup() else: self.__node_tree = NodeTreeTranslator( self.bl_lamp.data.node_tree, self._asset_handler, self.orig_name) self.__node_tree.create_entities(depsgraph.scene_eval) self.__as_area_lamp_material = asr.Material( 'osl_material', mat_name, {'osl_surface': shader_name})
def test_iters(self): names = ['color', 'color2', 'color3'] uids = [] for name in names: col = asr.ColorEntity(name, {}) uids.append(col.get_uid()) self.color_vec.insert(col) result_names = [] result_uids = [] for col in self.color_vec: result_names.append(col.get_name()) result_uids.append(col.get_uid()) self.assertEqual(names, result_names) self.assertEqual(uids, result_uids)
def create_entities(self, scene): as_sky = self.bl_scene.world.appleseed_sky env_type = as_sky.env_type if env_type == 'sunsky': env_type = as_sky.sun_model if env_type == 'constant': self.__colors.append( asr.ColorEntity( 'horizon_radiance_color', {'color_space': 'linear_rgb'}, self._convert_color(self.bl_scene.world.horizon_color))) elif env_type in ('gradient', 'constant_hemisphere'): self.__colors.append( asr.ColorEntity( 'horizon_radiance_color', {'color_space': 'srgb'}, self._convert_color(self.bl_scene.world.horizon_color))) self.__colors.append( asr.ColorEntity( 'zenith_radiance_color', {'color_space': 'linear_rgb'}, self._convert_color(self.bl_scene.world.zenith_color))) if env_type in ('latlong_map', 'mirrorball_map'): try: filename = self.asset_handler.process_path( as_sky.env_tex.filepath, AssetType.TEXTURE_ASSET) except: logger.warning("No Texture Selected!") filename = "" tex_inst_params = { 'addressing_mode': 'wrap', 'filtering_mode': 'bilinear' } self.__env_tex = asr.Texture( 'disk_texture_2d', 'environment_tex', { 'filename': filename, 'color_space': as_sky.env_tex_colorspace }, []) self.__env_tex_inst = asr.TextureInstance( 'environment_tex_inst', tex_inst_params, 'environment_tex', asr.Transformf(asr.Matrix4f.identity())) if env_type == 'latlong_map': edf_params = { 'radiance': "environment_tex_inst", 'radiance_multiplier': as_sky.env_tex_mult, 'exposure': as_sky.env_exposure } elif env_type == 'mirrorball_map': edf_params = { 'radiance': "environment_tex_inst", 'exposure': as_sky.env_exposure, 'radiance_multiplier': as_sky.env_tex_mult } elif env_type == 'constant': edf_params = {'radiance': 'horizon_radiance_color'} elif env_type == 'gradient': edf_params = { 'horizon_radiance': "horizon_radiance_color", 'zenith_radiance': "zenith_radiance_color" } elif env_type == 'constant_hemisphere': edf_params = { 'lower_hemi_radiance': "horizon_radiance_color", 'upper_hemi_radiance': "zenith_radiance_color" } else: edf_params = { 'ground_albedo': as_sky.ground_albedo, 'sun_phi': as_sky.sun_phi, 'sun_theta': as_sky.sun_theta, 'turbidity': as_sky.turbidity, 'turbidity_multiplier': as_sky.turbidity_multiplier, 'luminance_multiplier': as_sky.luminance_multiplier, 'luminance_gamma': as_sky.luminance_gamma, 'saturation_multiplier': as_sky.saturation_multiplier, 'horizon_shift': as_sky.horizon_shift } self.__as_env_edf = asr.EnvironmentEDF(env_type + "_environment_edf", "sky_edf", edf_params) self.__as_env_shader = asr.EnvironmentShader( "edf_environment_shader", "sky_shader", { 'environment_edf': 'sky_edf', 'alpha_value': as_sky.env_alpha }) self.__as_env = asr.Environment("sky", { "environment_edf": "sky_edf", "environment_shader": "sky_shader" }) self.__as_env_edf.transform_sequence().set_transform( 0.0, asr.Transformd(self._convert_matrix(asr.Matrix4d.identity())))
def build_project(): # Create an empty project. project = asr.Project("grid-point-lights-generator") 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", 1) # Create a scene. scene = asr.Scene() # Create an assembly. assembly = asr.Assembly("assembly") # Prepare the orientation of all the objects in the scene. orientation = asr.Matrix4d.make_rotation(asr.Vector3d(1.0, 0.0, 0.0), math.radians(-90.0)) #------------------------------------------------------------------------ # Materials #------------------------------------------------------------------------ # Create a material called "01 - Default_mat" and insert it into the assembly. assembly.materials().insert( asr.Material( "disney_material", "01 - Default_mat", { "alpha_map": "1", "layer1": { "anisotropic": "0", "base_color": "[1, 1, 1]", "clearcoat": "0", "clearcoat_gloss": "0", "layer_name": "layer1", "layer_number": "0", "mask": "1.0", "metallic": "0", "roughness": "1", "sheen": "0", "sheen_tint": "0", "specular": "0", "specular_tint": "0", "subsurface": "0.0" } })) #------------------------------------------------------------------------ # Geometry #------------------------------------------------------------------------ # Load the scene geometry from disk. objects = asr.MeshObjectReader.read(project.get_search_paths(), "plane", {"filename": "Plane001.binarymesh"}) # 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_name = {"material_slot_0": "01 - Default_mat"} mat = orientation * asr.Matrix4d.make_translation( asr.Vector3d(0.0, 0.0, 0.0)) instance = asr.ObjectInstance( instance_name, { "visibility": { "camera": "true", "diffuse": "true", "glossy": "true", "light": "true", "probe": "true", "shadow": "true", "specular": "true", "subsurface": "true", "transparency": "true" } }, object.get_name(), asr.Transformd(mat), material_name, material_name) assembly.object_instances().insert(instance) # Insert this object into the scene. assembly.objects().insert(object) #------------------------------------------------------------------------ # Lights #------------------------------------------------------------------------ light_z_distance = 1.0 if color == "white": assembly.colors().insert( asr.ColorEntity("white", { "color_space": "linear_rgb", "multiplier": 1.0 }, [1.0, 1.0, 1.0])) step = float(plane_size) / grid_lights_count light_count = 0 grid_range = np.linspace(-plane_size / 2 + step, plane_size / 2 - step, grid_lights_count) for j in grid_range: for i in grid_range: # Create a point light called "light" and insert it into the assembly. light_name = "light_" + str(light_count) light_count = light_count + 1 light = asr.Light("point_light", light_name, { "intensity": "white", "intensity_multiplier": "3" }) light_position = asr.Vector3d(i, j, light_z_distance) mat = orientation * asr.Matrix4d.make_translation( light_position) light.set_transform(asr.Transformd(mat)) assembly.lights().insert(light) elif color == "mix": for i in xrange(0, grid_lights_count * grid_lights_count): s = random.uniform(0, 1) if s < 0.65: ran = random.gauss(1, 0.01) elif s < 0.9: ran = random.gauss(0.3, 0.1) else: ran = random.gauss(0.7, 0.01) random_color = list(colorsys.hls_to_rgb(ran, 0.5, 1.0)) assembly.colors().insert( asr.ColorEntity("color_" + str(i), { "color_space": "linear_rgb", "multiplier": 1.0 }, random_color)) step = float(plane_size) / grid_lights_count light_count = 0 grid_range = np.linspace(-plane_size / 2 + step, plane_size / 2 - step, grid_lights_count) for j in grid_range: for i in grid_range: # Create a point light called "light" and insert it into the assembly. light_name = "light_" + str(light_count) color_name = "color_" + str(light_count) light_count = light_count + 1 light = asr.Light("point_light", light_name, { "intensity": color_name, "intensity_multiplier": "3" }) light_position = asr.Vector3d(i, j, light_z_distance) mat = orientation * asr.Matrix4d.make_translation( light_position) light.set_transform(asr.Transformd(mat)) assembly.lights().insert(light) else: print("Unknown color: {0}".format(color)) return #------------------------------------------------------------------------ # 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 an environment called "env" and bind it to the scene. scene.set_environment(asr.Environment("env", {})) #------------------------------------------------------------------------ # Camera #------------------------------------------------------------------------ # Create an orthographic camera. params = { "controller_target": "0 0 0", "film_dimensions": "128 128", "near_z": "-0.1", "shutter_close_time": "1.0", "shutter_open_time": "0.0" } camera = asr.Camera("orthographic_camera", "camera", params) # Place and orient the camera. mat = orientation * asr.Matrix4d.make_translation( asr.Vector3d(0.0, 0.0, 0.0)) 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", "clamping": "false", "color_space": "srgb", "filter": "box", "filter_size": "0.5", "gamma_correction": "1.0", "pixel_format": "float", "premultiplied_alpha": "true", "resolution": "512 512", "tile_size": "64 64" } 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
def update_lamp(self, depsgraph, as_main_assembly, as_scene, as_project): logger.debug(f"appleseed: Updating lamp entity for {self.orig_name}") as_lamp_data = self.bl_lamp.data.appleseed current_model = self.__lamp_model self.__lamp_model = self.__get_lamp_model() if current_model == self.__lamp_model: if self.__lamp_model != 'area_lamp': # Check if the radiance has changed. current_radiance = self.__radiance self.__radiance = self._convert_color(as_lamp_data.radiance) if current_radiance != self.__radiance: as_main_assembly.colors().remove(self.__as_lamp_radiance) lamp_radiance_name = f"{self.orig_name}_radiance" self.__as_lamp_radiance = asr.ColorEntity( lamp_radiance_name, {'color_space': 'linear_rgb'}, self.__radiance) as_main_assembly.colors().insert(self.__as_lamp_radiance) self.__as_lamp_radiance = as_main_assembly.colors( ).get_by_name(lamp_radiance_name) # Update lamp parameters. if self.__lamp_model == 'point_light': self.__as_lamp_params = self.__get_point_lamp_params() if self.__lamp_model == 'spot_light': self.__as_lamp_params = self.__get_spot_lamp_params() if self.__lamp_model == 'directional_light': self.__as_lamp_params = self.__get_directional_lamp_params( ) if self.__lamp_model == 'sun_light': self.__as_lamp_params = self.__get_sun_lamp_params() self.__as_lamp.set_parameters(self.__as_lamp_params) else: self.__ass.object_instances().remove(self.__as_area_lamp_inst) self.__ass.objects().remove(self.__as_area_lamp_mesh) shape_params = self._get_area_mesh_params() mesh_name = f"{self.orig_name}_mesh" mat_name = f"{self.orig_name}_mat" self.__as_area_lamp_mesh = asr.create_primitive_mesh( mesh_name, shape_params) self.__instance_params = self._get_area_mesh_instance_params() self.__as_area_lamp_inst = asr.ObjectInstance( self.__as_area_lamp_inst_name, self.__instance_params, mesh_name, asr.Transformd(asr.Matrix4d().identity()), {"default": mat_name}, {"default": "__null_material"}) self.__ass.objects().insert(self.__as_area_lamp_mesh) self.__as_area_lamp_mesh = self.__ass.objects().get_by_name( mesh_name) self.__ass.object_instances().insert(self.__as_area_lamp_inst) self.__as_area_lamp_inst = self.__ass.object_instances( ).get_by_name(self.__as_area_lamp_inst_name) if self.bl_lamp.data.use_nodes: if self.__as_area_lamp_shadergroup is not None: as_main_assembly.shader_groups().remove( self.__as_area_lamp_shadergroup) self.__as_area_lamp_shadergroup = None self.__node_tree = NodeTreeTranslator( self.bl_lamp.data.node_tree, self._asset_handler, self.orig_name) self.__node_tree.create_entities(depsgraph.scene_eval) else: self.__node_tree.update_nodetree(depsgraph.scene_eval) else: if self.__node_tree is not None: self.__node_tree.delete_nodetree(as_main_assembly) self.__node_tree = None shader_name = f"{self.orig_name}_tree" self.__as_area_lamp_shadergroup = asr.ShaderGroup( shader_name) self._set_shadergroup() else: self._set_shadergroup() else: # Delete current light. if current_model != 'area_lamp': self.__ass.lights().remove(self.__as_lamp) as_main_assembly.colors().remove(self.__as_lamp_radiance) else: self.__ass.objects().remove(self.__as_area_lamp_mesh) self.__ass.object_instances().remove(self.__as_area_lamp_inst) as_main_assembly.materials().remove( self.__as_area_lamp_material) if self.__as_area_lamp_shadergroup is not None: as_main_assembly.shader_groups().remove( self.__as_area_lamp_shadergroup) self.__as_area_lamp_shadergroup = None else: self.__node_tree.delete_nodetree(as_main_assembly) # Create new light. self.create_entities(depsgraph, 0) if self.__lamp_model != 'area_lamp': radiance_name = self.__as_lamp_radiance.get_name() as_main_assembly.colors().insert(self.__as_lamp_radiance) self.__as_lamp_radiance = as_main_assembly.colors( ).get_by_name(radiance_name) self.__ass.lights().insert(self.__as_lamp) self.__as_lamp = self.__ass.lights().get_by_name( self.orig_name) else: mat_name = f"{self.orig_name}_mat" mesh_name = f"{self.orig_name}_mesh" self.__as_area_lamp_inst_name = f"{self.orig_name}_inst" as_main_assembly.materials().insert( self.__as_area_lamp_material) self.__as_area_lamp_material = as_main_assembly.materials( ).get_by_name(mat_name) if self.__as_area_lamp_shadergroup is not None: shadergroup_name = self.__as_area_lamp_shadergroup.get_name( ) as_main_assembly.shader_groups().insert( self.__as_area_lamp_shadergroup) self.__as_area_lamp_shadergroup = as_main_assembly.shader_groups( ).get_by_name(shadergroup_name) else: self.__node_tree.flush_entities(as_scene, as_main_assembly, as_project) self.__as_area_lamp_inst = asr.ObjectInstance( self.__as_area_lamp_inst_name, self.__instance_params, mesh_name, asr.Transformd(asr.Matrix4d().identity()), {"default": mat_name}, {"default": "__null_material"}) self.__ass.objects().insert(self.__as_area_lamp_mesh) self.__as_area_lamp_mesh = self.__ass.objects().get_by_name( mesh_name) self.__ass.object_instances().insert(self.__as_area_lamp_inst) self.__as_area_lamp_inst = self.__ass.object_instances( ).get_by_name(self.__as_area_lamp_inst_name)
def build_project(): # Create an empty project. project = asr.Project("4-point-lights") 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", 1) # Create a scene. scene = asr.Scene() # Create an assembly. assembly = asr.Assembly("assembly") # Prepare the orientation of all the objects in the scene. orientation = asr.Matrix4d.make_rotation(asr.Vector3d(1.0, 0.0, 0.0), math.radians(-90.0)) #------------------------------------------------------------------------ # Materials #------------------------------------------------------------------------ # Create a material called "01 - Default_mat" and insert it into the assembly. assembly.materials().insert( asr.Material( "disney_material", "01 - Default_mat", { "alpha_map": "1", "layer1": { "anisotropic": "0", "base_color": "[1, 1, 1]", "clearcoat": "0", "clearcoat_gloss": "0", "layer_name": "layer1", "layer_number": "0", "mask": "1.0", "metallic": "0", "roughness": "1", "sheen": "0", "sheen_tint": "0", "specular": "0", "specular_tint": "0", "subsurface": "0.0" } })) #------------------------------------------------------------------------ # Geometry #------------------------------------------------------------------------ # Load the scene geometry from disk. objects = asr.MeshObjectReader.read(project.get_search_paths(), "plane", {"filename": "Plane001.binarymesh"}) # 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_name = {"material_slot_0": "01 - Default_mat"} mat = orientation * asr.Matrix4d.make_translation( asr.Vector3d(0.0, 0.0, 0.0)) instance = asr.ObjectInstance( instance_name, { "visibility": { "camera": "true", "diffuse": "true", "glossy": "true", "light": "true", "probe": "true", "shadow": "true", "specular": "true", "subsurface": "true", "transparency": "true" } }, object.get_name(), asr.Transformd(mat), material_name, material_name) assembly.object_instances().insert(instance) # Insert this object into the scene. assembly.objects().insert(object) #------------------------------------------------------------------------ # Lights #------------------------------------------------------------------------ # Create a list of colors and for each of them create a light. light_colors = { "white": [1.0, 1.0, 1.0], "red": [1.0, 0.0, 0.0], "green": [0.0, 1.0, 0.0], "blue": [0.0, 0.0, 1.0] } light_positions = [ asr.Vector3d(25.0, -25.0, 5.0), asr.Vector3d(-25.0, -25.0, 5.0), asr.Vector3d(25.0, 25.0, 5.0), asr.Vector3d(-25.0, 25.0, 5.0) ] for key in light_colors: color_name = "color_" + key # Add colors to the project. assembly.colors().insert( asr.ColorEntity(color_name, { "color_space": "linear_rgb", "multiplier": 1.0 }, light_colors[key])) idx = light_colors.keys().index(key) light_name = "light_" + key # Create the light. light = asr.Light( "max_omni_light", light_name, { "decay_exponent": "0", "decay_start": "40", "intensity": color_name, "intensity_multiplier": "3.14159" }) mat = orientation * asr.Matrix4d.make_translation(light_positions[idx]) light.set_transform(asr.Transformd(mat)) assembly.lights().insert(light) #------------------------------------------------------------------------ # 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 an environment called "env" and bind it to the scene. scene.set_environment(asr.Environment("env", {})) #------------------------------------------------------------------------ # Camera #------------------------------------------------------------------------ # Create an orthographic camera with film dimensions 128 x 128 in. params = { "controller_target": "0 0 0", "film_dimensions": "128 128", "near_z": "-0.1", "shutter_close_time": "1.0", "shutter_open_time": "0.0" } camera = asr.Camera("orthographic_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 = orientation * asr.Matrix4d.make_translation( asr.Vector3d(0.0, 0.0, 0.0)) 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", "clamping": "false", "color_space": "srgb", "filter": "box", "filter_size": "0.5", "gamma_correction": "1.0", "pixel_format": "float", "premultiplied_alpha": "true", "resolution": "512 512", "tile_size": "64 64" } 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("grid-point-lights-generator") 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", 1) # Create a scene. scene = asr.Scene() # Create an assembly. assembly = asr.Assembly("assembly") # Prepare the orientation of all the objects in the scene. orientation = asr.Matrix4d.make_rotation(asr.Vector3d(1.0, 0.0, 0.0), math.radians(-90.0)) #------------------------------------------------------------------------ # COLOR #------------------------------------------------------------------------ assembly.colors().insert(asr.ColorEntity("light_color", { "color_space": "linear_rgb", "multiplier": 1.0, "wavelength_range": "400.0 700.0" }, [1.000000, 0.830634, 0.378440])) #------------------------------------------------------------------------ # EDF #------------------------------------------------------------------------ # Create light edfs. assembly.edfs().insert(asr.EDF( "diffuse_edf", "light_material_edf", { "cast_indirect_light": "true", "importance_multiplier": "1.0", "light_near_start": "0.0", "radiance": "light_color", "radiance_multiplier": "9" })) #------------------------------------------------------------------------ # Materials #------------------------------------------------------------------------ # Create a material called "01 - Default_mat" and insert it into the assembly. assembly.materials().insert(asr.Material( "disney_material", "01 - Default_mat", { "alpha_map": "1", "layer1": { "anisotropic": "0", "base_color": "[1, 1, 1]", "clearcoat": "0", "clearcoat_gloss": "0", "layer_name": "layer1", "layer_number": "0", "mask": "1.0", "metallic": "0", "roughness": "1", "sheen": "0", "sheen_tint": "0", "specular": "0", "specular_tint": "0", "subsurface": "0.0" } })) # Create light material. assembly.materials().insert(asr.Material( "generic_material", "light_material", { "bump_amplitude": "1.0", "displacement_method": "bump", "edf": "light_material_edf", "normal_map_up": "z", "shade_alpha_cutouts": "false" })) #------------------------------------------------------------------------ # Geometry #------------------------------------------------------------------------ # Load the scene geometry from disk. objects = asr.MeshObjectReader.read(project.get_search_paths(), "plane", {"filename": "Plane001.binarymesh"}) # 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_name = {"material_slot_0": "01 - Default_mat"} mat = orientation * asr.Matrix4d.make_translation(asr.Vector3d(0.0, 0.0, 0.0)) instance = asr.ObjectInstance( instance_name, {"visibility": {}}, object.get_name(), asr.Transformd(mat), material_name, material_name) assembly.object_instances().insert(instance) # Insert this object into the scene. assembly.objects().insert(object) #------------------------------------------------------------------------ # Lights #------------------------------------------------------------------------ light_z_distance = 1.0 lights = asr.MeshObjectReader.read(project.get_search_paths(), "rectangle", {"filename": "rectangle.obj"}) for light in lights: if Color == "white": step = float(PlaneSize) / GridLightsCount light_count = 0 grid_range = np.linspace((-PlaneSize + step) / 2, (PlaneSize - step) / 2, GridLightsCount) for j in grid_range: for i in grid_range: # Create an instance of this light and insert it into the assembly. instance_name = light.get_name() + "_inst_" + str(light_count) light_count = light_count + 1 material_front = {"material_slot_0": "01 - Default_mat"} material_back = {"material_slot_0": "light_material"} light_position = asr.Vector3d(i, j, light_z_distance) mat = orientation * asr.Matrix4d.make_translation(light_position) instance = asr.ObjectInstance( instance_name, {"visibility": { "camera": "false", "diffuse": "true", "glossy": "true", "light": "true", "probe": "true", "shadow": "true", "specular": "true", "subsurface": "true", "transparency": "true" }}, light.get_name(), asr.Transformd(mat), material_front, material_back) assembly.object_instances().insert(instance) else: print("Unknown Color: {0}".format(Color)) return # Insert this light into the scene. assembly.objects().insert(light) #------------------------------------------------------------------------ # 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 an environment called "env" and bind it to the scene. scene.set_environment(asr.Environment("env", {})) #------------------------------------------------------------------------ # Camera #------------------------------------------------------------------------ # Create an orthographic camera. params = { "controller_target": "0 0 0", "film_dimensions": "128 128", "near_z": "-0.1", "shutter_close_time": "1.0", "shutter_open_time": "0.0" } camera = asr.Camera("orthographic_camera", "camera", params) # Place and orient the camera. mat = orientation * asr.Matrix4d.make_translation(asr.Vector3d(0.0, 0.0, 0.0)) 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", "clamping": "false", "color_space": "srgb", "filter": "box", "filter_size": "0.5", "gamma_correction": "1.0", "pixel_format": "float", "premultiplied_alpha": "true", "resolution": "512 512", "tile_size": "64 64"} 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') 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 create_linear_rgb_color(parent, color_name, rgb, multiplier): color_params = {"color_space": "linear_rgb", "multiplier": multiplier} parent.colors().insert(asr.ColorEntity(color_name, color_params, rgb))