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
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)
