def execute(self, context): _LOG.debug("filepath", self.filepath) from mpfb.ui.assetlibrary.assetsettingspanel import ASSET_SETTINGS_PROPERTIES # pylint: disable=C0415 scene = context.scene skin_type = ASSET_SETTINGS_PROPERTIES.get_value("skin_type", entity_reference=scene) material_instances = ASSET_SETTINGS_PROPERTIES.get_value( "material_instances", entity_reference=scene) blender_object = context.active_object basemesh = ObjectService.find_object_of_type_amongst_nearest_relatives( blender_object, "Basemesh") bodyproxy = ObjectService.find_object_of_type_amongst_nearest_relatives( blender_object, "Proxymeshes") HumanService.set_character_skin(self.filepath, basemesh, bodyproxy=bodyproxy, skin_type=skin_type, material_instances=material_instances) self.report({'INFO'}, "Skin was loaded") return {'FINISHED'}
def execute(self, context): _LOG.enter() if context.object is None or context.object.type != 'ARMATURE': self.report({'ERROR'}, "Must have armature as active object") return {'FINISHED'} armature_object = context.object basemesh = ObjectService.find_object_of_type_amongst_nearest_relatives(armature_object, mpfb_type_name="Basemesh") if basemesh is None: self.report({'ERROR'}, "Could not find related base mesh. It should have been parent or child of armature object.") return {'FINISHED'} rig = Rig.from_given_basemesh_and_armature_as_active_object(basemesh) _LOG.dump("final rig_definition", rig.rig_definition) unmatched_bone_names = rig.list_unmatched_bones() unmatched = len(unmatched_bone_names) if unmatched > 0: self.report({'WARNING'}, "There were " + str(unmatched) + " bones that could not be matched to cube or vertex") _LOG.warn("Unmatched bone names:", unmatched_bone_names) absolute_file_path = bpy.path.abspath(self.filepath) _LOG.debug("absolute_file_path", absolute_file_path) with open(absolute_file_path, "w") as json_file: json.dump(rig.rig_definition, json_file, indent=4, sort_keys=True) self.report({'INFO'}, "JSON file written to " + absolute_file_path) return {'FINISHED'}
def _populate_human_info_with_eye_material_info(human_info, basemesh): eyes = ObjectService.find_object_of_type_amongst_nearest_relatives(basemesh, "Eyes") if not eyes: return if not MaterialService.has_materials(eyes): human_info["eyes_material_type"] = "NONE" return material_settings = dict() _LOG.debug("material_slots", eyes.material_slots) slot = eyes.material_slots[0] material = slot.material group_node = NodeService.find_first_node_by_type_name(material.node_tree, "ShaderNodeGroup") if group_node: material_settings = NodeService.get_socket_default_values(group_node) if "IrisMinorColor" not in material_settings: # Material exists, but does not seem procedural. Assume it is a MAKESKIN material human_info["eyes_material_type"] = "MAKESKIN" else: human_info["eyes_material_type"] = "PROCEDURAL_EYES" human_info["eyes_material_settings"] = material_settings
def _populate_human_info_with_proxy_info(human_info, basemesh): proxy = ObjectService.find_object_of_type_amongst_nearest_relatives(basemesh, "Proxymeshes") if not proxy: return asset_source = GeneralObjectProperties.get_value("asset_source", entity_reference=proxy) if not asset_source is None: human_info["proxy"] = str(asset_source).strip()
def _set_eyes(human_info, basemesh): _LOG.enter() eyes = ObjectService.find_object_of_type_amongst_nearest_relatives(basemesh, "Eyes") if not eyes: _LOG.debug("There are no eyes") return if not "eyes_material_type" in human_info or not human_info["eyes_material_type"]: _LOG.debug("Eyes material type not specified") return if human_info["eyes_material_type"] != "PROCEDURAL_EYES": _LOG.debug("Eyes material is not procedural") return if not "eyes_material_settings" in human_info or not human_info["eyes_material_settings"]: _LOG.debug("There are no eye material overrides, going with the default") return settings = human_info["eyes_material_settings"] _LOG.dump("Eye material overrides", settings) slot = eyes.material_slots[0] material = slot.material group_node = NodeService.find_first_node_by_type_name(material.node_tree, "ShaderNodeGroup") if group_node: material_settings = NodeService.get_socket_default_values(group_node) if "IrisMinorColor" in material_settings: _LOG.dump("will try to apply settings", settings) NodeService.set_socket_default_values(group_node, settings) else: _LOG.warn("Material group node did not have expected key -> not procedural eyes") else: _LOG.warn("Material had no group node -> not procedural eyes")
def execute(self, context): _LOG.enter() if context.object is None or context.object.type != 'ARMATURE': self.report({'ERROR'}, "Must have armature as active object") return {'FINISHED'} armature_object = context.object basemesh = ObjectService.find_object_of_type_amongst_nearest_relatives( armature_object, mpfb_type_name="Basemesh") if basemesh is None: self.report({ 'ERROR' }, "Could not find related basemesh. It should have been parent or child of armature object." ) return {'FINISHED'} absolute_file_path = bpy.path.abspath(self.filepath) _LOG.debug("absolute_file_path", absolute_file_path) weights = RigService.get_weights(armature_object, basemesh) with open(absolute_file_path, "w") as json_file: json.dump(weights, json_file, indent=4, sort_keys=True) self.report({'INFO'}, "JSON file written to " + absolute_file_path) return {'FINISHED'}
def _populate_human_info_with_bodyparts_info(human_info, basemesh): for bodypart in ["Eyes", "Eyelashes", "Eyebrows", "Tongue", "Teeth", "Hair"]: bodypart_obj = ObjectService.find_object_of_type_amongst_nearest_relatives(basemesh, bodypart) _LOG.debug(bodypart, bodypart_obj) if not bodypart_obj is None: asset_source = GeneralObjectProperties.get_value("asset_source", entity_reference=bodypart_obj) if not asset_source is None: human_info[str(bodypart).lower()] = str(asset_source).strip()
def _save_material(self, context, file_name): body = ObjectService.find_object_of_type_amongst_nearest_relatives( context.object, "Basemesh") if not body: body = ObjectService.find_object_of_type_amongst_nearest_relatives( context.object, "Proxymesh") if not body: self.report( {'ERROR'}, "Could not find basemesh or body proxy amongst nearest relatives") return {'FINISHED'} if not MaterialService.has_materials(body): self.report({'ERROR'}, "Body does not have a material") return {'FINISHED'} material_settings = dict() _LOG.debug("material_slots", body.material_slots) for slot in body.material_slots: material = slot.material group_node = NodeService.find_first_node_by_type_name( material.node_tree, "ShaderNodeGroup") if group_node: values = NodeService.get_socket_default_values(group_node) if "colorMixIn" in values: # This seems to be an enhanced skin material name = material.name if "." in name: (prefix, name) = name.split(".", 2) if "." in name: (name, number) = name.split(".", 2) material_settings[name] = values _LOG.dump("material_settings", material_settings) with open(file_name, "w") as json_file: json.dump(material_settings, json_file, indent=4, sort_keys=True) UiService.rebuild_enhanced_settings_panel_list() #UiService.rebuild_importer_panel_list() self.report({'INFO'}, "Presets were written to " + file_name) return {'FINISHED'}
def _populate_human_info_with_rig_info(human_info, basemesh): armature_object = ObjectService.find_object_of_type_amongst_nearest_relatives(basemesh, "Skeleton") if not armature_object is None: rig_type = RigService.identify_rig(armature_object) if rig_type is None or rig_type == "unkown": raise ValueError("Could not identify rig type. Custom rigs cannot be serialized.") if rig_type is None or rig_type == "rigify_generated": raise ValueError("Generated rigify rigs cannot be serialized. If you want to serialize the rig you have to do it before generating the final rig.") human_info["rig"] = rig_type
def _populate_human_info_with_skin_info(human_info, basemesh): proxymesh = ObjectService.find_object_of_type_amongst_nearest_relatives(basemesh, "Proxymeshes") bodyobject = basemesh if proxymesh and not proxymesh is None: bodyobject = proxymesh skin = HumanObjectProperties.get_value("material_source", entity_reference=bodyobject) if skin is None: skin = "" human_info["skin_mhmat"] = skin slots = bodyobject.material_slots if not slots or len(slots) < 1: return material = slots[0].material group_node = NodeService.find_first_node_by_type_name(material.node_tree, "ShaderNodeGroup") values = None if group_node: values = NodeService.get_socket_default_values(group_node) if values is None or not "colorMixIn" in values: human_info["skin_material_type"] = "MAKESKIN" return human_info["skin_material_type"] = "ENHANCED" if "SSS Color" in values: human_info["skin_material_type"] = "ENHANCED_SSS" for slot in slots: material = slot.material group_node = NodeService.find_first_node_by_type_name(material.node_tree, "ShaderNodeGroup") if group_node: values = NodeService.get_socket_default_values(group_node) if "colorMixIn" in values: # This seems to be an enhanced skin material name = material.name if "." in name: name = str(name).split(".", maxsplit=1)[1] if "." in name: name = str(name).split(".", maxsplit=1)[0] human_info["skin_material_settings"][name] = values
def _save_material(self, context, file_name): eyes = ObjectService.find_object_of_type_amongst_nearest_relatives( context.object, "Eyes") if not eyes: self.report({'ERROR'}, "Could not find eyes amongst nearest relatives") return {'FINISHED'} if not MaterialService.has_materials(eyes): self.report({'ERROR'}, "Eyes do not have a material") return {'FINISHED'} material_settings = dict() _LOG.debug("material_slots", eyes.material_slots) slot = eyes.material_slots[0] material = slot.material group_node = NodeService.find_first_node_by_type_name( material.node_tree, "ShaderNodeGroup") if group_node: material_settings = NodeService.get_socket_default_values(group_node) if "IrisMinorColor" not in material_settings: self.report({'ERROR'}, "Eyes do not seem to have procedural eyes material") return {'FINISHED'} else: self.report({'ERROR'}, "Eyes do not seem to have procedural eyes material") return {'FINISHED'} _LOG.dump("material_settings", material_settings) with open(file_name, "w") as json_file: json.dump(material_settings, json_file, indent=4, sort_keys=True) UiService.rebuild_eye_settings_panel_list() UiService.rebuild_importer_eye_settings_panel_list() self.report({'INFO'}, "Settings were written to " + file_name) return {'FINISHED'}
def execute(self, context): _LOG.enter() if context.object is None: self.report({'ERROR'}, "Must have a selected object") return {'FINISHED'} name = HUMAN_PRESETS_PROPERTIES.get_value("name", entity_reference=context) if not name is None: name = str(name).strip() if name == "" or name is None: self.report({'ERROR'}, "A valid name must be given") return {'FINISHED'} if " " in str(name): self.report({'ERROR'}, "Human presets names should not contain spaces") return {'FINISHED'} confdir = LocationService.get_user_config() file_name = os.path.join(confdir, "human." + name + ".json") if os.path.exists(file_name): self.report({'ERROR'}, "Presets with that name already exist") return {'FINISHED'} basemesh = None if ObjectService.object_is_basemesh(context.object): basemesh = context.object else: basemesh = ObjectService.find_object_of_type_amongst_nearest_relatives( context.object, "Basemesh") if basemesh is None: self.report( {'ERROR'}, "Could not find basemesh amongst relatives of selected object") return {'FINISHED'} HumanService.serialize_to_json_file(basemesh, file_name, True) self.report({'INFO'}, "Human saved as " + file_name) return {'FINISHED'}
def execute(self, context): _LOG.debug("filepath", self.filepath) from mpfb.ui.assetlibrary.assetsettingspanel import ASSET_SETTINGS_PROPERTIES # pylint: disable=C0415 scene = context.scene object_type = self.object_type material_type = "MAKESKIN" # TODO: some kind of operator argument fit_to_body = ASSET_SETTINGS_PROPERTIES.get_value("fit_to_body", entity_reference=scene) delete_group = ASSET_SETTINGS_PROPERTIES.get_value("delete_group", entity_reference=scene) specific_delete_group = ASSET_SETTINGS_PROPERTIES.get_value("specific_delete_group", entity_reference=scene) set_up_rigging = ASSET_SETTINGS_PROPERTIES.get_value("set_up_rigging", entity_reference=scene) interpolate_weights = ASSET_SETTINGS_PROPERTIES.get_value("interpolate_weights", entity_reference=scene) makeclothes_metadata = ASSET_SETTINGS_PROPERTIES.get_value("makeclothes_metadata", entity_reference=scene) add_subdiv_modifier = ASSET_SETTINGS_PROPERTIES.get_value("add_subdiv_modifier", entity_reference=scene) subdiv_levels = ASSET_SETTINGS_PROPERTIES.get_value("subdiv_levels", entity_reference=scene) mask_base_mesh = ASSET_SETTINGS_PROPERTIES.get_value("mask_base_mesh", entity_reference=scene) blender_object = context.active_object rig = None basemesh = None if blender_object and not blender_object is None: if ObjectService.object_is_basemesh(blender_object): basemesh = blender_object else: basemesh = ObjectService.find_object_of_type_amongst_nearest_relatives(blender_object, "Basemesh") rig = ObjectService.find_object_of_type_amongst_nearest_relatives(blender_object, "Skeleton") if fit_to_body and basemesh is None: self.report({'ERROR'}, "Fit to body is enabled, but active object is not a base mesh") return {'FINISHED'} if delete_group and basemesh is None: self.report({'ERROR'}, "Set up delete group is enabled, but active object is not a base mesh") return {'FINISHED'} if interpolate_weights and basemesh is None: self.report({'ERROR'}, "interpolate weights is enabled, but active object is not a base mesh") return {'FINISHED'} if set_up_rigging and rig is None: self.report({'ERROR'}, "set up rigging is enabled, but could not find a rig to attach to") return {'FINISHED'} mhclo = Mhclo() mhclo.load(self.filepath) # pylint: disable=E1101 clothes = mhclo.load_mesh(context) if not clothes or clothes is None: self.report({'ERROR'}, "failed to import the proxy") return {'FINISHED'} asset_dir = os.path.basename(os.path.dirname(os.path.realpath(self.filepath))) asset_source = asset_dir + "/" + os.path.basename(self.filepath) GeneralObjectProperties.set_value("object_type", "Proxymeshes", entity_reference=clothes) GeneralObjectProperties.set_value("asset_source", asset_source, entity_reference=clothes) bpy.ops.object.shade_smooth() if not material_type == "PRINCIPLED": MaterialService.delete_all_materials(clothes) if material_type == "MAKESKIN" and not mhclo.material is None: makeskin_material = MakeSkinMaterial() makeskin_material.populate_from_mhmat(mhclo.material) name = os.path.basename(mhclo.material) blender_material = MaterialService.create_empty_material(name, clothes) makeskin_material.apply_node_tree(blender_material) if fit_to_body: ClothesService.fit_clothes_to_human(clothes, basemesh, mhclo) mhclo.set_scalings(context, basemesh) if set_up_rigging: clothes.location = (0.0, 0.0, 0.0) clothes.parent = rig modifier = clothes.modifiers.new("Armature", 'ARMATURE') modifier.object = rig if interpolate_weights: ClothesService.interpolate_weights(basemesh, clothes, rig, mhclo) if add_subdiv_modifier: modifier = clothes.modifiers.new("Subdivision", 'SUBSURF') modifier.levels = 0 modifier.render_levels = subdiv_levels if mask_base_mesh: modifier = basemesh.modifiers.new("Hide base mesh", 'MASK') modifier.vertex_group = "body" modifier.invert_vertex_group = True #if makeclothes_metadata: # ClothesService.set_makeclothes_object_properties_from_mhclo(clothes, mhclo, delete_group_name=delete_name) _LOG.debug("clothes, uuid", (clothes, mhclo.uuid)) if clothes and mhclo.uuid: GeneralObjectProperties.set_value("uuid", mhclo.uuid, entity_reference=clothes) _LOG.debug("Has extra vgroups", mhclo.uuid in ALL_EXTRA_GROUPS) if mhclo.uuid in ALL_EXTRA_GROUPS: for vgroup_name in ALL_EXTRA_GROUPS[mhclo.uuid].keys(): _LOG.debug("Will create vgroup", vgroup_name) vgroup = clothes.vertex_groups.new(name=vgroup_name) vgroup.add(ALL_EXTRA_GROUPS[mhclo.uuid][vgroup_name], 1.0, 'ADD') self.report({'INFO'}, "Proxy was loaded") return {'FINISHED'}
def set_character_skin(mhmat_file, basemesh, bodyproxy=None, skin_type="ENHANCED_SSS", material_instances=True, slot_overrides=None): if bodyproxy is None: bodyproxy = ObjectService.find_object_of_type_amongst_nearest_relatives(basemesh, "Proxymeshes") material_source = os.path.basename(os.path.dirname(mhmat_file)) + "/" + os.path.basename(mhmat_file) _LOG.debug("material_source", material_source) HumanObjectProperties.set_value("material_source", material_source, entity_reference=basemesh) if not bodyproxy is None: HumanObjectProperties.set_value("material_source", material_source, entity_reference=bodyproxy) MaterialService.delete_all_materials(basemesh) if bodyproxy: MaterialService.delete_all_materials(bodyproxy) name = basemesh.name if not str(name).endswith(".body"): name = name + ".body" if skin_type == "MAKESKIN": makeskin_material = MakeSkinMaterial() makeskin_material.populate_from_mhmat(mhmat_file) blender_material = MaterialService.create_empty_material(name, basemesh) makeskin_material.apply_node_tree(blender_material) if skin_type in ["ENHANCED", "ENHANCED_SSS"]: presets = dict() presets["skin_material_type"] = skin_type scale_name = "METER" scale_factor = GeneralObjectProperties.get_value("scale_factor", entity_reference=basemesh) if scale_factor > 0.9: scale_name = "DECIMETER" if scale_factor > 9: scale_name = "CENTIMETER" presets["scale_factor"] = scale_name enhanced_material = EnhancedSkinMaterial(presets) enhanced_material.populate_from_mhmat(mhmat_file) blender_material = MaterialService.create_empty_material(name, basemesh) enhanced_material.apply_node_tree(blender_material) if material_instances: _LOG.debug("Will now attempt to create material slots for", (basemesh, bodyproxy)) MaterialService.create_and_assign_material_slots(basemesh, bodyproxy) file_name = LocationService.get_user_config("enhanced_settings.default.json") settings = dict() _LOG.debug("Will attempt to load", file_name) with open(file_name, "r") as json_file: settings = json.load(json_file) _LOG.dump("Settings before overrides", settings) _LOG.dump("Overrides", slot_overrides) if not slot_overrides is None: for slot_name in slot_overrides.keys(): _LOG.debug("Reading overrides for slot", slot_name) if not slot_name in settings: settings[slot_name] = dict() for key_name in slot_overrides[slot_name].keys(): _LOG.dump("Reading overrides for slot key", (slot_name, key_name, slot_overrides[slot_name][key_name])) settings[slot_name][key_name] = slot_overrides[slot_name][key_name] _LOG.dump("Settings after overrides", settings) for slot in basemesh.material_slots: material = slot.material group_node = NodeService.find_first_node_by_type_name(material.node_tree, "ShaderNodeGroup") if group_node: values = NodeService.get_socket_default_values(group_node) if "colorMixIn" in values: # This seems to be an enhanced skin material name = material.name _LOG.debug("Material name", name) if "." in name: name = str(name).split(".", maxsplit=1)[1] if "." in name: name = str(name).split(".", maxsplit=1)[0] _LOG.debug("final name", name) if name in settings: _LOG.debug("will try to apply settings", settings[name]) NodeService.set_socket_default_values(group_node, settings[name])
def add_mhclo_asset(mhclo_file, basemesh, asset_type="Clothes", subdiv_levels=1, material_type="MAKESKIN"): mhclo = Mhclo() mhclo.load(mhclo_file) # pylint: disable=E1101 clothes = mhclo.load_mesh(bpy.context) clothes.location = (0.0, 0.0, 0.0) if not clothes or clothes is None: raise IOError("failed to import the clothes mesh: object was None after import") afn = os.path.abspath(mhclo_file) asset_source = os.path.basename(os.path.dirname(afn)) + "/" + os.path.basename(afn) GeneralObjectProperties.set_value("asset_source", asset_source, entity_reference=clothes) atype = str(asset_type).lower().capitalize() GeneralObjectProperties.set_value("object_type", atype, entity_reference=clothes) bpy.ops.object.shade_smooth() name = basemesh.name if "." in name: name = str(name).split(".")[0] name = name + "." + str(os.path.basename(mhclo_file)).replace(".mhclo", "").replace(".proxy", "") clothes.name = name _LOG.debug("Given name (basemesh, variable, clothes)", (basemesh.name, name, clothes.name)) colors = MaterialService.get_diffuse_colors() _LOG.dump("Colors, atype, exists, mhclo.material, material_type", (colors, atype, atype in colors, mhclo.material, material_type)) color = (0.8, 0.8, 0.8, 1.0) if atype in colors: color = colors[atype] if not mhclo.material: _LOG.debug("Material is not set in mhclo") if not mhclo.material is None and material_type == "MAKESKIN": _LOG.debug("Setting up MAKESKIN material", mhclo.material) MaterialService.delete_all_materials(clothes) makeskin_material = MakeSkinMaterial() makeskin_material.populate_from_mhmat(mhclo.material) blender_material = MaterialService.create_empty_material(name, clothes) makeskin_material.apply_node_tree(blender_material) blender_material.diffuse_color = color if material_type == "PROCEDURAL_EYES": MaterialService.delete_all_materials(clothes) _LOG.debug("Setting up procedural eyes") tree_dir = LocationService.get_mpfb_data("node_trees") json_file_name = os.path.join(tree_dir, "procedural_eyes.json") with open(json_file_name, "r") as json_file: node_tree_dict = json.load(json_file) _LOG.dump("procedural_eyes", node_tree_dict) blender_material = MaterialService.create_empty_material(name, clothes) NodeService.apply_node_tree_from_dict(blender_material.node_tree, node_tree_dict, True) blender_material.blend_method = "BLEND" blender_material.show_transparent_back = True blender_material.diffuse_color = color ClothesService.fit_clothes_to_human(clothes, basemesh, mhclo) mhclo.set_scalings(bpy.context, basemesh) delete_name = str(os.path.basename(mhclo_file)) # pylint: disable=E1101 delete_name = delete_name.replace(".mhclo", "") delete_name = delete_name.replace(".MHCLO", "") delete_name = delete_name.replace(" ", "_") delete_name = "Delete." + delete_name ClothesService.update_delete_group(mhclo, basemesh, replace_delete_group=False, delete_group_name=delete_name) rig = ObjectService.find_object_of_type_amongst_nearest_relatives(basemesh, "Skeleton") if rig: clothes.parent = rig modifier = clothes.modifiers.new("Armature", 'ARMATURE') modifier.object = rig ClothesService.interpolate_weights(basemesh, clothes, rig, mhclo) else: clothes.parent = basemesh ClothesService.set_makeclothes_object_properties_from_mhclo(clothes, mhclo, delete_group_name=delete_name) if subdiv_levels > 0: modifier = clothes.modifiers.new("Subdivision", 'SUBSURF') modifier.levels = 0 modifier.render_levels = subdiv_levels if mhclo.uuid: GeneralObjectProperties.set_value("uuid", mhclo.uuid, entity_reference=clothes) return clothes
def execute(self, context): from mpfb.ui.loadclothes.loadclothespanel import LOAD_CLOTHES_PROPERTIES # pylint: disable=C0415 scene = context.scene object_type = LOAD_CLOTHES_PROPERTIES.get_value("object_type", entity_reference=scene) material_type = LOAD_CLOTHES_PROPERTIES.get_value( "material_type", entity_reference=scene) fit_to_body = LOAD_CLOTHES_PROPERTIES.get_value("fit_to_body", entity_reference=scene) delete_group = LOAD_CLOTHES_PROPERTIES.get_value( "delete_group", entity_reference=scene) specific_delete_group = LOAD_CLOTHES_PROPERTIES.get_value( "specific_delete_group", entity_reference=scene) set_up_rigging = LOAD_CLOTHES_PROPERTIES.get_value( "set_up_rigging", entity_reference=scene) interpolate_weights = LOAD_CLOTHES_PROPERTIES.get_value( "interpolate_weights", entity_reference=scene) makeclothes_metadata = LOAD_CLOTHES_PROPERTIES.get_value( "makeclothes_metadata", entity_reference=scene) blender_object = context.active_object rig = None basemesh = None if blender_object and not blender_object is None: if ObjectService.object_is_basemesh(blender_object): basemesh = blender_object else: basemesh = ObjectService.find_object_of_type_amongst_nearest_relatives( blender_object, "Basemesh") rig = ObjectService.find_object_of_type_amongst_nearest_relatives( blender_object, "Skeleton") if fit_to_body and basemesh is None: self.report( {'ERROR'}, "Fit to body is enabled, but active object is not a base mesh") return {'FINISHED'} if delete_group and basemesh is None: self.report({ 'ERROR' }, "Set up delete group is enabled, but active object is not a base mesh" ) return {'FINISHED'} if interpolate_weights and basemesh is None: self.report({ 'ERROR' }, "interpolate weights is enabled, but active object is not a base mesh" ) return {'FINISHED'} if set_up_rigging and rig is None: self.report({ 'ERROR' }, "set up rigging is enabled, but could not find a rig to attach to" ) return {'FINISHED'} mhclo = Mhclo() mhclo.load(self.filepath) # pylint: disable=E1101 clothes = mhclo.load_mesh(context) if not clothes or clothes is None: self.report({'ERROR'}, "failed to import the clothes mesh") return {'FINISHED'} GeneralObjectProperties.set_value("object_type", object_type, entity_reference=clothes) bpy.ops.object.shade_smooth() if not material_type == "PRINCIPLED": MaterialService.delete_all_materials(clothes) if material_type == "MAKESKIN" and not mhclo.material is None: makeskin_material = MakeSkinMaterial() makeskin_material.populate_from_mhmat(mhclo.material) name = os.path.basename(mhclo.material) blender_material = MaterialService.create_empty_material( name, clothes) makeskin_material.apply_node_tree(blender_material) if fit_to_body: ClothesService.fit_clothes_to_human(clothes, basemesh, mhclo) mhclo.set_scalings(context, basemesh) delete_name = "Delete" if delete_group: if specific_delete_group: delete_name = str(os.path.basename(self.filepath)) # pylint: disable=E1101 delete_name = delete_name.replace(".mhclo", "") delete_name = delete_name.replace(".MHCLO", "") delete_name = delete_name.replace(" ", "_") delete_name = "Delete." + delete_name ClothesService.update_delete_group(mhclo, basemesh, replace_delete_group=False, delete_group_name=delete_name) if set_up_rigging: clothes.location = (0.0, 0.0, 0.0) clothes.parent = rig modifier = clothes.modifiers.new("Armature", 'ARMATURE') modifier.object = rig if interpolate_weights: ClothesService.interpolate_weights(basemesh, clothes, rig, mhclo) if makeclothes_metadata: ClothesService.set_makeclothes_object_properties_from_mhclo( clothes, mhclo, delete_group_name=delete_name) self.report({'INFO'}, "Clothes were loaded") return {'FINISHED'}
def execute(self, context): _LOG.debug("filepath", self.filepath) _LOG.debug("object_type", self.object_type) _LOG.debug("material_type", self.material_type) from mpfb.ui.assetlibrary.assetsettingspanel import ASSET_SETTINGS_PROPERTIES # pylint: disable=C0415 scene = context.scene fit_to_body = ASSET_SETTINGS_PROPERTIES.get_value( "fit_to_body", entity_reference=scene) delete_group = ASSET_SETTINGS_PROPERTIES.get_value( "delete_group", entity_reference=scene) # TODO: specific_delete_group = ASSET_SETTINGS_PROPERTIES.get_value("specific_delete_group", entity_reference=scene) set_up_rigging = ASSET_SETTINGS_PROPERTIES.get_value( "set_up_rigging", entity_reference=scene) interpolate_weights = ASSET_SETTINGS_PROPERTIES.get_value( "interpolate_weights", entity_reference=scene) # TODO: makeclothes_metadata = ASSET_SETTINGS_PROPERTIES.get_value("makeclothes_metadata", entity_reference=scene) add_subdiv_modifier = ASSET_SETTINGS_PROPERTIES.get_value( "add_subdiv_modifier", entity_reference=scene) subdiv_levels = ASSET_SETTINGS_PROPERTIES.get_value( "subdiv_levels", entity_reference=scene) blender_object = context.active_object rig = None basemesh = None if blender_object and not blender_object is None: if ObjectService.object_is_basemesh(blender_object): basemesh = blender_object else: basemesh = ObjectService.find_object_of_type_amongst_nearest_relatives( blender_object, "Basemesh") rig = ObjectService.find_object_of_type_amongst_nearest_relatives( blender_object, "Skeleton") if fit_to_body and basemesh is None: self.report( {'ERROR'}, "Fit to body is enabled, but active object is not a base mesh") return {'FINISHED'} if delete_group and basemesh is None: self.report({ 'ERROR' }, "Set up delete group is enabled, but active object is not a base mesh" ) return {'FINISHED'} if interpolate_weights and basemesh is None: self.report({ 'ERROR' }, "interpolate weights is enabled, but active object is not a base mesh" ) return {'FINISHED'} if set_up_rigging and rig is None: self.report({ 'ERROR' }, "set up rigging is enabled, but could not find a rig to attach to" ) return {'FINISHED'} if not add_subdiv_modifier: subdiv_levels = 0 _LOG.debug("Will call add_mhclo_asset: (asset_type, material_type)", (self.object_type, self.material_type)) HumanService.add_mhclo_asset(self.filepath, basemesh, asset_type=self.object_type, subdiv_levels=subdiv_levels, material_type=self.material_type) self.report({'INFO'}, "Clothes were loaded") return {'FINISHED'}
def execute(self, context): _LOG.enter() if context.object is None: self.report({'ERROR'}, "Must have a selected object") return {'FINISHED'} name = ENHANCED_SETTINGS_PROPERTIES.get_value("available_settings", entity_reference=context) if not name: self.report({'ERROR'}, "Must select settings to load") return {'FINISHED'} file_name = LocationService.get_user_config("enhanced_settings." + name + ".json") if not os.path.exists(file_name): _LOG.error("Settings did not exist despite being in list:", file_name) self.report({'ERROR'}, "Settings did not exist!?") return {'FINISHED'} settings = dict() _LOG.debug("Will attempt to load", file_name) with open(file_name, "r") as json_file: settings = json.load(json_file) body = ObjectService.find_object_of_type_amongst_nearest_relatives( context.object, "Basemesh") if not body: body = ObjectService.find_object_of_type_amongst_nearest_relatives( context.object, "Proxymesh") if not body: self.report({ 'ERROR' }, "Could not find basemesh or body proxy amongst nearest relatives" ) return {'FINISHED'} if not MaterialService.has_materials(body): self.report({'ERROR'}, "Body does not have a material") return {'FINISHED'} _LOG.debug("material_slots", body.material_slots) for slot in body.material_slots: material = slot.material group_node = NodeService.find_first_node_by_type_name( material.node_tree, "ShaderNodeGroup") if group_node: values = NodeService.get_socket_default_values(group_node) if "colorMixIn" in values: # This seems to be an enhanced skin material name = material.name if "." in name: (prefix, name) = str(name).split(".", maxsplit=1) if "." in name: (name, number) = str(name).split(".", maxsplit=1) _LOG.debug("final name", name) if name in settings: _LOG.debug("will try to apply settings", settings[name]) NodeService.set_socket_default_values( group_node, settings[name]) self.report({'INFO'}, "Presets were loaded from " + file_name) return {'FINISHED'}
def execute(self, context): _LOG.enter() if context.object is None: self.report({'ERROR'}, "Must have a selected object") return {'FINISHED'} name = EYE_SETTINGS_PROPERTIES.get_value("available_settings", entity_reference=context) if not name: self.report({'ERROR'}, "Must select settings to load") return {'FINISHED'} file_name = LocationService.get_user_config("eye_settings." + name + ".json") if not os.path.exists(file_name): _LOG.error("Settings did not exist despite being in list:", file_name) self.report({'ERROR'}, "Settings did not exist!?") return {'FINISHED'} settings = dict() _LOG.debug("Will attempt to load", file_name) with open(file_name, "r") as json_file: settings = json.load(json_file) eyes = ObjectService.find_object_of_type_amongst_nearest_relatives( context.object, "Eyes") if not eyes: self.report({'ERROR'}, "Could not find eyes amongst nearest relatives") return {'FINISHED'} if not MaterialService.has_materials(eyes): self.report({'ERROR'}, "Eyes do not have a material") return {'FINISHED'} _LOG.debug("material_slots", eyes.material_slots) slot = eyes.material_slots[0] material = slot.material group_node = NodeService.find_first_node_by_type_name( material.node_tree, "ShaderNodeGroup") if group_node: material_settings = NodeService.get_socket_default_values( group_node) if "IrisMinorColor" in material_settings: _LOG.debug("will try to apply settings", settings) NodeService.set_socket_default_values(group_node, settings) else: self.report( {'ERROR'}, "Eyes do not seem to have procedural eyes material") return {'FINISHED'} else: self.report({'ERROR'}, "Eyes do not seem to have procedural eyes material") return {'FINISHED'} self.report({'INFO'}, "Settings were loaded from " + file_name) return {'FINISHED'}