def execute(self, context): lprint("I " + self.bl_label + "...") from io_scs_tools.internals.shader_presets import cache as _shader_presets_cache from io_scs_tools.utils import get_shader_presets_inventory as _get_shader_presets_inventory mat = context.material mat_scs_props = mat.scs_props """:type: io_scs_tools.properties.material.MaterialSCSTools""" preset = _get_shader_presets_inventory()[mat_scs_props.active_shader_preset_name] """:type: io_scs_tools.properties.world.ShaderPresetsInventoryItem""" # extract only flavor effect part of string flavor_effect_part = mat_scs_props.mat_effect_name[len(preset.effect):] new_flavor_state = not self.flavor_enabled flavors_suffix = "" for flavor in preset.flavors: flavor_variant_found = False for flavor_variant in flavor.variants: if flavor_variant.name == self.flavor_name: # add founded flavor to flavors suffix only if enabled if new_flavor_state: flavors_suffix += "." + flavor_variant.name flavor_variant_found = True break # if one variant of flavor is found skip all other variants if flavor_variant_found: continue # make sure to add all other enabled flavors to flavors suffix for flavor_variant in flavor.variants: is_in_middle = "." + flavor_variant.name + "." in flavor_effect_part is_on_end = flavor_effect_part.endswith("." + flavor_variant.name) if is_in_middle or is_on_end: flavors_suffix += "." + flavor_variant.name # finally set new shader data to material section = _shader_presets_cache.get_section(preset, flavors_suffix) context.material.scs_props.mat_effect_name = preset.effect + flavors_suffix _material_utils.set_shader_data_to_material(context.material, section) # sync shader types on all scs roots by updating looks on them # to avoid different shader types on different scs roots for same material for scs_root in _object_utils.gather_scs_roots(bpy.data.objects): _looks.update_look_from_material(scs_root, mat, True) return {'FINISHED'}
def execute(self, context): lprint("I " + self.bl_label + "...") from io_scs_tools.internals.shader_presets import cache as _shader_presets_cache from io_scs_tools.utils import get_shader_presets_inventory as _get_shader_presets_inventory mat = context.material mat_scs_props = mat.scs_props """:type: io_scs_tools.properties.material.MaterialSCSTools""" preset = _get_shader_presets_inventory()[ mat_scs_props.active_shader_preset_name] """:type: io_scs_tools.properties.world.ShaderPresetsInventoryItem""" # extract only flavor effect part of string flavor_effect_part = mat_scs_props.mat_effect_name[len(preset. effect):] new_flavor_state = not self.flavor_enabled flavors_suffix = "" for flavor in preset.flavors: flavor_variant_found = False for flavor_variant in flavor.variants: if flavor_variant.name == self.flavor_name: # add founded flavor to flavors suffix only if enabled if new_flavor_state: flavors_suffix += "." + flavor_variant.name flavor_variant_found = True break # if one variant of flavor is found skip all other variants if flavor_variant_found: continue # make sure to add all other enabled flavors to flavors suffix for flavor_variant in flavor.variants: is_in_middle = "." + flavor_variant.name + "." in flavor_effect_part is_on_end = flavor_effect_part.endswith( "." + flavor_variant.name) if is_in_middle or is_on_end: flavors_suffix += "." + flavor_variant.name # finally set new shader data to material section = _shader_presets_cache.get_section(preset, flavors_suffix) context.material.scs_props.mat_effect_name = preset.effect + flavors_suffix _material_utils.set_shader_data_to_material( context.material, section) return {'FINISHED'}
def export(root_object, filepath, used_materials, used_parts): """Export PIT. :param root_object: SCS root object :type root_object: bpy.types.Object :param filepath: PIT file path :type filepath: str :param used_materials: materials transitional structure for accessing stored materials from PIM :type used_materials: io_scs_tools.exp.transition_structs.materials.MaterialsTrans :param used_parts: parts transitional structure for accessing stored parts from PIM, PIC and PIP :type used_parts: io_scs_tools.exp.transition_structs.parts.PartsTrans :return: True if successful; False otherwise; :rtype: bool """ scs_globals = _get_scs_globals() output_type = scs_globals.output_type file_name = root_object.name print("\n************************************") print("** SCS PIT Exporter **") print("** (c)2014 SCS Software **") print("************************************\n") # DATA GATHERING look_list = [] variant_list = [] saved_active_look = root_object.scs_props.active_scs_look looks_inventory = root_object.scs_object_look_inventory looks_count = len(looks_inventory) if looks_count <= 0: looks_count = 1 used_materials_pairs = used_materials.get_as_pairs() for i in range(0, looks_count): # apply each look from inventory first if len(looks_inventory) > 0: root_object.scs_props.active_scs_look = i # actually write values to material because Blender might not refresh data yet _looks.apply_active_look(root_object) curr_look_name = looks_inventory[i].name else: # if no looks create default curr_look_name = "default" material_dict = {} material_list = [] # get materials data for material_name, material in used_materials_pairs: if material is None: material_name = str("_default_material_-_default_settings_") # DEFAULT MATERIAL material_export_data = _default_material(material_name) material_list.append(material_name) else: # print('material name: %r' % material.name) material_list.append(material) # MATERIAL EFFECT effect_name = material.scs_props.mat_effect_name # PRESET SHADERS flags = 0 def_cnt = attribute_cnt = texture_cnt = 0 def_sections = [] attribute_sections = [] texture_sections = [] active_shader_preset_name = material.scs_props.active_shader_preset_name # SUBSTANCE substance_value = material.scs_props.substance # only write substance to material if it's assigned if substance_value != "None" and substance_value != "": substance_data = _SectionData("Attribute") substance_data.props.append(("Format", "STRING")) substance_data.props.append(("Tag", "substance")) substance_data.props.append(("Value", ["i", (substance_value,)])) attribute_sections.append(substance_data) attribute_cnt += 1 if active_shader_preset_name in _get_shader_presets_inventory() and active_shader_preset_name != "<none>": preset = _get_shader_presets_inventory()[active_shader_preset_name] flavors_str = effect_name[len(preset.effect):] section = _shader_presets_cache.get_section(preset, flavors_str) # FLAGS for prop in section.props: if prop[0] == "Flags": flags = int(not material.scs_props.enable_aliasing) break # COLLECT ATTRIBUTES AND TEXTURES for item in section.sections: # DATA EXCHANGE FORMAT ATRIBUTE if item.type == "DataExchangeFormat": def_data = _SectionData("DataExchangeFormat") for rec in item.props: def_data.props.append((rec[0], rec[1])) def_sections.append(def_data) def_cnt += 1 # if attribute is hidden in shader preset ignore it on export # this is useful for flavor hiding some attributes from original material # eg: airbrush on "truckpaint" hides R G B aux attributes which are not present # when using airbrush flavor hidden = item.get_prop_value("Hide") if hidden and hidden == "True": continue preview_only = item.get_prop_value("PreviewOnly") if preview_only and preview_only == "True": continue # ATTRIBUTES if item.type == "Attribute": # print(' Attribute:') attribute_data = _SectionData("Attribute") for rec in item.props: # print(' rec: %r' % str(rec)) if rec[0] == "Format": attribute_data.props.append((rec[0], rec[1])) elif rec[0] == "Tag": # tag_prop = rec[1].replace("[", "").replace("]", "") # attribute_data.props.append((rec[0], tag_prop)) attribute_data.props.append((rec[0], rec[1])) elif rec[0] == "Value": format_prop = item.get_prop("Format")[1] tag_prop = item.get_prop("Tag")[1] tag_prop = tag_prop.replace("[", "").replace("]", "") # print(' format_prop: %r' % str(format_prop)) # print(' tag_prop: %r' % str(tag_prop)) if "aux" in tag_prop: aux_props = getattr(material.scs_props, "shader_attribute_" + tag_prop) value = [] for aux_prop in aux_props: value.append(aux_prop.value) # extract list if there is only one value inside and tagged as FLOAT # otherwise it gets saved as: "Value: ( [0.0] )" instead of: "Value: ( 0.0 )" if len(value) == 1 and format_prop == "FLOAT": value = value[0] else: value = getattr(material.scs_props, "shader_attribute_" + tag_prop, "NO TAG") # print(' value: %s' % str(value)) if format_prop == 'FLOAT': attribute_data.props.append((rec[0], ["&&", (value,)])) else: attribute_data.props.append((rec[0], ["i", tuple(value)])) attribute_sections.append(attribute_data) attribute_cnt += 1 # TEXTURES elif item.type == "Texture": # print(' Texture:') texture_data = _SectionData("Texture") for rec in item.props: # print(' rec: %r' % str(rec)) if rec[0] == "Tag": tag_prop = rec[1].split(":")[1] tag = str("texture[" + str(texture_cnt) + "]:" + tag_prop) texture_data.props.append((rec[0], tag)) elif rec[0] == "Value": tag_prop = item.get_prop("Tag")[1].split(":")[1] # print(' tag_prop: %r' % str(tag_prop)) # create and get path to tobj tobj_rel_path = _get_texture_path_from_material(material, tag_prop, os.path.dirname(filepath)) texture_data.props.append((rec[0], tobj_rel_path)) texture_sections.append(texture_data) texture_cnt += 1 material_export_data = _SectionData("Material") material_export_data.props.append(("Alias", material.name)) material_export_data.props.append(("Effect", effect_name)) material_export_data.props.append(("Flags", flags)) if output_type.startswith('def'): material_export_data.props.append(("DataExchangeFormatCount", def_cnt)) material_export_data.props.append(("AttributeCount", attribute_cnt)) material_export_data.props.append(("TextureCount", texture_cnt)) if output_type.startswith('def'): for def_section in def_sections: material_export_data.sections.append(def_section) for attribute in attribute_sections: material_export_data.sections.append(attribute) for texture in texture_sections: material_export_data.sections.append(texture) elif active_shader_preset_name == "<imported>": material_attributes = material['scs_shader_attributes']['attributes'].to_dict().values() material_textures = material['scs_shader_attributes']['textures'].to_dict().values() material_export_data = _SectionData("Material") material_export_data.props.append(("Alias", material.name)) material_export_data.props.append(("Effect", effect_name)) material_export_data.props.append(("Flags", int(not material.scs_props.enable_aliasing))) material_export_data.props.append(("AttributeCount", len(material_attributes))) material_export_data.props.append(("TextureCount", len(material_textures))) for attribute_dict in material_attributes: attribute_section = _SectionData("Attribute") format_value = "" for attr_prop in sorted(attribute_dict.keys()): # get the format of current attribute (we assume that "Format" attribute is before "Value" attribute in this for loop) if attr_prop == "Format": format_value = attribute_dict[attr_prop] if attr_prop == "Value" and ("FLOAT" in format_value or "STRING" in format_value): tag_prop = attribute_dict["Tag"].replace("[", "").replace("]", "") if "aux" in tag_prop: aux_props = getattr(material.scs_props, "shader_attribute_" + tag_prop) value = [] for aux_prop in aux_props: value.append(aux_prop.value) else: value = getattr(material.scs_props, "shader_attribute_" + tag_prop, None) if isinstance(value, float): value = [value] if value is None: attribute_section.props.append((attr_prop, ["i", tuple(attribute_dict[attr_prop])])) else: attribute_section.props.append((attr_prop, ["i", tuple(value)])) elif attr_prop == "Tag" and "aux" in attribute_dict[attr_prop]: attribute_section.props.append((attr_prop, "aux[" + attribute_dict[attr_prop][3:] + "]")) else: attribute_section.props.append((attr_prop, attribute_dict[attr_prop])) material_export_data.sections.append(attribute_section) for texture_dict in material_textures: texture_section = _SectionData("Texture") tag_id_string = "" for tex_prop in sorted(texture_dict.keys()): if tex_prop == "Tag": tag_id_string = texture_dict[tex_prop].split(':')[1] if tex_prop == "Value" and tag_id_string != "": tobj_rel_path = _get_texture_path_from_material(material, tag_id_string, os.path.dirname(filepath)) texture_section.props.append((tex_prop, tobj_rel_path)) else: texture_section.props.append((tex_prop, texture_dict[tex_prop])) material_export_data.sections.append(texture_section) else: # DEFAULT MATERIAL material_name = str("_" + material_name + "_-_default_settings_") material_export_data = _default_material(material_name) material_dict[material_name] = material_export_data # create materials sections for looks material_sections = _fill_material_sections(material_list, material_dict) look_data = { "name": curr_look_name, "material_sections": material_sections } look_list.append(look_data) # restore look applied before export root_object.scs_props.active_scs_look = saved_active_look # PARTS AND VARIANTS... used_parts_names = used_parts.get_as_list() part_list_cnt = len(used_parts_names) if len(root_object.scs_object_variant_inventory) == 0: # If there is no Variant, add the Default one... part_list = _fill_part_list(root_object.scs_object_part_inventory, used_parts_names, all_parts=True) variant_list.append((_VARIANT_consts.default_name, part_list), ) else: for variant in root_object.scs_object_variant_inventory: part_list = _fill_part_list(variant.parts, used_parts_names) variant_list.append((variant.name, part_list), ) # DATA CREATION header_section = _fill_header_section(file_name, scs_globals.sign_export) look_section = _fill_look_sections(look_list) # part_sections = fill_part_section(part_list) variant_section = _fill_variant_sections(variant_list) comment_header_section = _fill_comment_header_section(look_list, variant_list) global_section = _fill_global_section(len(look_list), len(variant_list), part_list_cnt, len(used_materials_pairs)) # DATA ASSEMBLING pit_container = [comment_header_section, header_section, global_section] for section in look_section: pit_container.append(section) for section in variant_section: pit_container.append(section) # FILE EXPORT ind = " " pit_filepath = str(filepath + ".pit") result = _pix_container.write_data_to_file(pit_container, pit_filepath, ind) # print("************************************") return result
def update_shader_presets_path(scs_shader_presets_inventory, shader_presets_filepath): """The function deletes and populates again a list of Shader Preset items in inventory. It also updates corresponding record in config file. :param shader_presets_filepath: Absolute or relative path to the file with Shader Presets :type shader_presets_filepath: str """ # print('shader_presets_filepath: %r' % shader_presets_filepath) if shader_presets_filepath.startswith("//"): # RELATIVE PATH shader_presets_abs_path = _path_utils.get_abs_path(shader_presets_filepath) else: shader_presets_abs_path = shader_presets_filepath # CLEAR INVENTORY AND CACHE scs_shader_presets_inventory.clear() _shader_presets_cache.clear() if os.path.isfile(shader_presets_abs_path): # ADD DEFAULT PRESET ITEM "<none>" INTO INVENTORY new_shader_preset = scs_shader_presets_inventory.add() new_shader_preset.name = "<none>" presets_container = _pix.get_data_from_file(shader_presets_abs_path, ' ') # ADD ALL SHADER PRESET ITEMS FROM FILE INTO INVENTORY if presets_container: # sort sections to shaders and flavors shaders = [] flavors = {} for section in presets_container: if section.type == "Shader": shaders.append(section) elif section.type == "Flavor": flavors[section.get_prop_value("Type")] = section for shader in shaders: unique_names = [] shader_flavors = shader.get_prop_value("Flavors") # create new preset item new_shader_preset = scs_shader_presets_inventory.add() new_shader_preset.name = shader.get_prop_value("PresetName") new_shader_preset.effect = shader.get_prop_value("Effect") unique_names.append("") _shader_presets_cache.add_section(new_shader_preset, "", shader) if shader_flavors: for j, flavor_types in enumerate(shader_flavors): # create new flavor item flavor_item = new_shader_preset.flavors.add() new_unique_names = [] for i, flavor_type in enumerate(flavor_types.split("|")): if flavor_type not in flavors: lprint("D Flavor used by shader preset, but not defined: %s", (flavor_type,)) continue # create new flavor variant item flavor_variant = flavor_item.variants.add() flavor_variant.name = flavors[flavor_type].get_prop_value("Name") flavor_variant.preset_name = new_shader_preset.name # modify and save section as string into cache for unique_name in unique_names: section = _shader_presets_cache.get_section(new_shader_preset, unique_name) for flavor_section in flavors[flavor_type].sections: flavor_section_tag = flavor_section.get_prop_value("Tag") # check if current flavor section already exists in section, # then override props and sections directly otherwise add flavor section for subsection in section.sections: subsection_tag = subsection.get_prop_value("Tag") if subsection_tag and subsection_tag == flavor_section_tag: subsection.props = flavor_section.props subsection.sections = flavor_section.sections break else: section.sections.append(flavor_section) new_unique_names.append(unique_name + "." + flavors[flavor_type].get_prop_value("Name")) assert section.set_prop_value("Effect", new_shader_preset.effect + new_unique_names[-1]) _shader_presets_cache.add_section(new_shader_preset, new_unique_names[-1], section) unique_names.extend(new_unique_names) update_item_in_file('Paths.ShaderPresetsFilePath', shader_presets_filepath)
def export(root_object, filepath, used_materials, used_parts): """Export PIT. :param root_object: SCS root object :type root_object: bpy.types.Object :param filepath: PIT file path :type filepath: str :param used_materials: materials transitional structure for accessing stored materials from PIM :type used_materials: io_scs_tools.exp.transition_structs.materials.MaterialsTrans :param used_parts: parts transitional structure for accessing stored parts from PIM, PIC and PIP :type used_parts: io_scs_tools.exp.transition_structs.parts.PartsTrans :return: True if successful; False otherwise; :rtype: bool """ scs_globals = _get_scs_globals() output_type = scs_globals.output_type file_name = root_object.name print("\n************************************") print("** SCS PIT Exporter **") print("** (c)2014 SCS Software **") print("************************************\n") # DATA GATHERING look_list = [] variant_list = [] saved_active_look = root_object.scs_props.active_scs_look looks_inventory = root_object.scs_object_look_inventory looks_count = len(looks_inventory) if looks_count <= 0: looks_count = 1 used_materials_pairs = used_materials.get_as_pairs() for i in range(0, looks_count): # apply each look from inventory first if len(looks_inventory) > 0: root_object.scs_props.active_scs_look = i # actually write values to material because Blender might not refresh data yet _looks.apply_active_look(root_object) curr_look_name = looks_inventory[i].name else: # if no looks create default curr_look_name = "default" material_dict = {} material_list = [] # get materials data for material_name, material in used_materials_pairs: if material is None: material_name = str("_default_material_-_default_settings_") # DEFAULT MATERIAL material_export_data = _default_material(material_name) material_list.append(material_name) else: # print('material name: %r' % material.name) material_list.append(material) # MATERIAL EFFECT effect_name = material.scs_props.mat_effect_name # PRESET SHADERS flags = 0 def_cnt = attribute_cnt = texture_cnt = 0 def_sections = [] attribute_sections = [] texture_sections = [] active_shader_preset_name = material.scs_props.active_shader_preset_name # SUBSTANCE substance_value = material.scs_props.substance # only write substance to material if it's assigned if substance_value != "None" and substance_value != "": substance_data = _SectionData("Attribute") substance_data.props.append(("Format", "STRING")) substance_data.props.append(("Tag", "substance")) substance_data.props.append( ("Value", ["i", (substance_value, )])) attribute_sections.append(substance_data) attribute_cnt += 1 if active_shader_preset_name in _get_shader_presets_inventory( ) and active_shader_preset_name != "<none>": preset = _get_shader_presets_inventory( )[active_shader_preset_name] flavors_str = effect_name[len(preset.effect):] section = _shader_presets_cache.get_section( preset, flavors_str) # FLAGS for prop in section.props: if prop[0] == "Flags": flags = int(not material.scs_props.enable_aliasing) break # COLLECT ATTRIBUTES AND TEXTURES for item in section.sections: # DATA EXCHANGE FORMAT ATRIBUTE if item.type == "DataExchangeFormat": def_data = _SectionData("DataExchangeFormat") for rec in item.props: def_data.props.append((rec[0], rec[1])) def_sections.append(def_data) def_cnt += 1 # if attribute is hidden in shader preset ignore it on export # this is useful for flavor hiding some attributes from original material # eg: airbrush on "truckpaint" hides R G B aux attributes which are not present # when using airbrush flavor hidden = item.get_prop_value("Hide") if hidden and hidden == "True": continue preview_only = item.get_prop_value("PreviewOnly") if preview_only and preview_only == "True": continue # ATTRIBUTES if item.type == "Attribute": # print(' Attribute:') attribute_data = _SectionData("Attribute") for rec in item.props: # print(' rec: %r' % str(rec)) if rec[0] == "Format": attribute_data.props.append( (rec[0], rec[1])) elif rec[0] == "Tag": # tag_prop = rec[1].replace("[", "").replace("]", "") # attribute_data.props.append((rec[0], tag_prop)) attribute_data.props.append( (rec[0], rec[1])) elif rec[0] == "Value": format_prop = item.get_prop("Format")[1] tag_prop = item.get_prop("Tag")[1] tag_prop = tag_prop.replace("[", "").replace( "]", "") # print(' format_prop: %r' % str(format_prop)) # print(' tag_prop: %r' % str(tag_prop)) if "aux" in tag_prop: aux_props = getattr( material.scs_props, "shader_attribute_" + tag_prop) value = [] for aux_prop in aux_props: value.append(aux_prop.value) # extract list if there is only one value inside and tagged as FLOAT # otherwise it gets saved as: "Value: ( [0.0] )" instead of: "Value: ( 0.0 )" if len( value ) == 1 and format_prop == "FLOAT": value = value[0] else: value = getattr( material.scs_props, "shader_attribute_" + tag_prop, "NO TAG") # print(' value: %s' % str(value)) if format_prop == 'FLOAT': attribute_data.props.append( (rec[0], ["&&", (value, )])) else: attribute_data.props.append( (rec[0], ["i", tuple(value)])) attribute_sections.append(attribute_data) attribute_cnt += 1 # TEXTURES elif item.type == "Texture": # print(' Texture:') texture_data = _SectionData("Texture") for rec in item.props: # print(' rec: %r' % str(rec)) if rec[0] == "Tag": tag_prop = rec[1].split(":")[1] tag = str("texture[" + str(texture_cnt) + "]:" + tag_prop) texture_data.props.append((rec[0], tag)) elif rec[0] == "Value": tag_prop = item.get_prop("Tag")[1].split( ":")[1] # print(' tag_prop: %r' % str(tag_prop)) # create and get path to tobj tobj_rel_path = _get_texture_path_from_material( material, tag_prop, os.path.dirname(filepath)) texture_data.props.append( (rec[0], tobj_rel_path)) texture_sections.append(texture_data) texture_cnt += 1 material_export_data = _SectionData("Material") material_export_data.props.append(("Alias", material.name)) material_export_data.props.append(("Effect", effect_name)) material_export_data.props.append(("Flags", flags)) if output_type.startswith('def'): material_export_data.props.append( ("DataExchangeFormatCount", def_cnt)) material_export_data.props.append( ("AttributeCount", attribute_cnt)) material_export_data.props.append( ("TextureCount", texture_cnt)) if output_type.startswith('def'): for def_section in def_sections: material_export_data.sections.append(def_section) for attribute in attribute_sections: material_export_data.sections.append(attribute) for texture in texture_sections: material_export_data.sections.append(texture) elif active_shader_preset_name == "<imported>": material_attributes = material['scs_shader_attributes'][ 'attributes'].to_dict().values() material_textures = material['scs_shader_attributes'][ 'textures'].to_dict().values() material_export_data = _SectionData("Material") material_export_data.props.append(("Alias", material.name)) material_export_data.props.append(("Effect", effect_name)) material_export_data.props.append( ("Flags", int(not material.scs_props.enable_aliasing))) material_export_data.props.append( ("AttributeCount", len(material_attributes))) material_export_data.props.append( ("TextureCount", len(material_textures))) for attribute_dict in material_attributes: attribute_section = _SectionData("Attribute") format_value = "" for attr_prop in sorted(attribute_dict.keys()): # get the format of current attribute (we assume that "Format" attribute is before "Value" attribute in this for loop) if attr_prop == "Format": format_value = attribute_dict[attr_prop] if attr_prop == "Value" and ( "FLOAT" in format_value or "STRING" in format_value): tag_prop = attribute_dict["Tag"].replace( "[", "").replace("]", "") if "aux" in tag_prop: aux_props = getattr( material.scs_props, "shader_attribute_" + tag_prop) value = [] for aux_prop in aux_props: value.append(aux_prop.value) else: value = getattr( material.scs_props, "shader_attribute_" + tag_prop, None) if isinstance(value, float): value = [value] if value is None: attribute_section.props.append( (attr_prop, [ "i", tuple(attribute_dict[attr_prop]) ])) else: attribute_section.props.append( (attr_prop, ["i", tuple(value)])) elif attr_prop == "Tag" and "aux" in attribute_dict[ attr_prop]: attribute_section.props.append( (attr_prop, "aux[" + attribute_dict[attr_prop][3:] + "]")) else: attribute_section.props.append( (attr_prop, attribute_dict[attr_prop])) material_export_data.sections.append(attribute_section) for texture_dict in material_textures: texture_section = _SectionData("Texture") tag_id_string = "" for tex_prop in sorted(texture_dict.keys()): if tex_prop == "Tag": tag_id_string = texture_dict[tex_prop].split( ':')[1] if tex_prop == "Value" and tag_id_string != "": tobj_rel_path = _get_texture_path_from_material( material, tag_id_string, os.path.dirname(filepath)) texture_section.props.append( (tex_prop, tobj_rel_path)) else: texture_section.props.append( (tex_prop, texture_dict[tex_prop])) material_export_data.sections.append(texture_section) else: # DEFAULT MATERIAL material_name = str("_" + material_name + "_-_default_settings_") material_export_data = _default_material(material_name) material_dict[material_name] = material_export_data # create materials sections for looks material_sections = _fill_material_sections(material_list, material_dict) look_data = { "name": curr_look_name, "material_sections": material_sections } look_list.append(look_data) # restore look applied before export root_object.scs_props.active_scs_look = saved_active_look # PARTS AND VARIANTS... used_parts_names = used_parts.get_as_list() part_list_cnt = len(used_parts_names) if len(root_object.scs_object_variant_inventory) == 0: # If there is no Variant, add the Default one... part_list = _fill_part_list(root_object.scs_object_part_inventory, used_parts_names, all_parts=True) variant_list.append((_VARIANT_consts.default_name, part_list), ) else: for variant in root_object.scs_object_variant_inventory: part_list = _fill_part_list(variant.parts, used_parts_names) variant_list.append((variant.name, part_list), ) # DATA CREATION header_section = _fill_header_section(file_name, scs_globals.sign_export) look_section = _fill_look_sections(look_list) # part_sections = fill_part_section(part_list) variant_section = _fill_variant_sections(variant_list) comment_header_section = _fill_comment_header_section( look_list, variant_list) global_section = _fill_global_section(len(look_list), len(variant_list), part_list_cnt, len(used_materials_pairs)) # DATA ASSEMBLING pit_container = [comment_header_section, header_section, global_section] for section in look_section: pit_container.append(section) for section in variant_section: pit_container.append(section) # FILE EXPORT ind = " " pit_filepath = str(filepath + ".pit") result = _pix_container.write_data_to_file(pit_container, pit_filepath, ind) # print("************************************") return result