def _create_scs_root_object(name, loaded_variants, loaded_looks, mats_info,
objects, locators, armature):
"""Creates an 'SCS Root Object' (Empty Object) for currently imported
'SCS Game Object' and parent all import content to it.
:param name:
:type name: str
:param loaded_variants: X
:type loaded_variants: list
:param loaded_looks: X
:type loaded_looks: list
:param mats_info: list of material info, one material info consists of list: [ blend_mat_name, mat_effect, original_mat_alias ]
:type mats_info: list of list
:param objects: X
:type objects: list
:param locators: X
:type locators: list
:param armature: Armature Object
:type armature: bpy.types.Object
:return: SCS Root Object
:rtype: bpy.types.Object
"""
context = bpy.context
# MAKE THE 'SCS ROOT OBJECT' NAME UNIQUE
name = _name_utils.get_unique(name, bpy.data.objects)
# CREATE EMPTY OBJECT & MAKE A PROPER SETTINGS TO THE 'SCS Game Object' OBJECT
scs_root_object = bpy.data.objects.new(name, None)
bpy.context.view_layer.active_layer_collection.collection.objects.link(
scs_root_object)
bpy.context.view_layer.objects.active = scs_root_object
scs_root_object.scs_props.scs_root_object_export_enabled = True
scs_root_object.scs_props.empty_object_type = 'SCS_Root'
# print('LOD.pos: %s' % str(scs_root_object.location))
# print('CUR.pos: %s' % str(context.space_data.cursor_location))
# PARENTING
bpy.ops.object.select_all(action='DESELECT')
if armature:
# if armature is present we can specify our game object as animated
scs_root_object.scs_props.scs_root_animated = "anim"
# print('ARM.pos: %s' % str(armature.location))
armature.select_set(True)
armature.scs_props.parent_identity = scs_root_object.name
for obj in objects:
# print('OBJ.pos: %s' % str(object.location))
obj.select_set(True)
obj.scs_props.parent_identity = scs_root_object.name
for obj in locators:
obj.select_set(True)
obj.scs_props.parent_identity = scs_root_object.name
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
bpy.ops.object.parent_clear(type='CLEAR_INVERSE')
# LOCATION
scs_root_object.location = context.scene.cursor.location
# MAKE ONLY 'SCS GAME OBJECT' SELECTED
bpy.ops.object.select_all(action='DESELECT')
scs_root_object.select_set(True)
context.view_layer.objects.active = scs_root_object
# MAKE PART RECORD
part_inventory = scs_root_object.scs_object_part_inventory
parts_dict = _object_utils.collect_parts_on_root(scs_root_object)
for part_name in parts_dict:
_inventory.add_item(part_inventory, part_name)
# MAKE VARIANT RECORD
variant_inventory = scs_root_object.scs_object_variant_inventory
for variant_i, variant_record in enumerate(loaded_variants):
variant_name = variant_record[0]
variantparts = variant_record[1]
variant = _inventory.add_item(variant_inventory, variant_name)
# for every variant create all of the part entries and mark them included properly
for part in part_inventory:
part = _inventory.add_item(variant.parts, part.name)
if part.name in variantparts:
part.include = True
# cleanup generated terrain points vertex layers by variant
for obj in parts_dict[part.name]:
if obj.type != "MESH":
continue
vg_to_delete = []
accepted_vg_nodes = {}
for vertex_group in obj.vertex_groups:
# ignore any vertex group which isn't from terrain points
# (others might come from skinning)
if _OP_consts.TerrainPoints.vg_name_prefix not in vertex_group.name:
continue
# ignore already fixed vertex group
if vertex_group.name.startswith(
_OP_consts.TerrainPoints.vg_name_prefix):
continue
# get variant index from first 6 chars -> check PIM importer for more info
vg_var_index = int(vertex_group.name[:6])
# ignore other variant vertex groups and add them to delete list
if vg_var_index >= 0 and vg_var_index != variant_i:
vg_to_delete.append(vertex_group)
continue
# finally remove variant prefixing name if variant is not defined (-1)
# or index matches current one
vertex_group.name = vertex_group.name[6:]
# log accepted node index for identifying which vertex groups
# really have to be deleted
accepted_vg_nodes[vertex_group.name[-1]] = 1
# cleanup possible duplicates for the same node
# because one object anyway can not have terrain points vertex groups for multiple variants
while len(vg_to_delete) > 0 and len(accepted_vg_nodes) > 0:
curr_vg = vg_to_delete.pop()
# extra caution step where group can be deleted
# only if one of vertex groups for this node was accepted
if curr_vg.name[-1] in accepted_vg_nodes:
obj.vertex_groups.remove(curr_vg)
else:
part.include = False
# MAKE LOOK RECORDS
for look_i, look in enumerate(loaded_looks):
look_name = look[0]
look_mat_settings = look[1]
# setup all the materials. NOTE: They should be already created by PIM import.
for mat_info in mats_info:
mat = bpy.data.materials[mat_info[0]]
if mat_info[2] in look_mat_settings:
# extract imported shader data
material_effect, material_attributes, material_textures, material_section = _get_shader_data(
look_mat_settings[mat_info[2]])
# try to find suitable preset
(preset_name, preset_section) = _material_utils.find_preset(
material_effect, material_textures)
# we don't support effect mismatch between looks, even if game works with it, somehow.
# most probably imported model is result of third party software, thus let user know and skip look for this material
if look_i != 0 and material_effect != mat.scs_props.mat_effect_name:
lprint(
"E Look %r skipped on material %r, mismatched material effect: %r but should be %r.",
(look_name, mat.name, material_effect,
mat.scs_props.mat_effect_name))
continue
# preset name is found & shader data are compatible with found preset
if preset_name and _are_shader_data_compatible(
preset_section, material_attributes, material_textures,
mat_info[0]):
mat.scs_props.active_shader_preset_name = preset_name
if preset_section:
preset_effect = preset_section.get_prop_value("Effect")
mat.scs_props.mat_effect_name = preset_effect
if look_i == 0:
# apply default shader settings
_material_utils.set_shader_data_to_material(
mat, preset_section, is_import=True)
# reapply settings from material
_material_utils.set_shader_data_to_material(
mat,
material_section,
is_import=True,
override_back_data=False)
lprint("D Using shader preset on material %r.",
(mat.name, ))
else:
print('''NO "preset_section"! (Shouldn't happen!)''')
else: # import shader directly from material and mark it as imported
mat.scs_props.active_shader_preset_name = "<imported>"
_material_utils.set_shader_data_to_material(
mat, material_section, is_import=True)
lprint(
"W Using imported shader on material %r, effect: %r.",
(mat.name, mat.scs_props.mat_effect_name))
if look_i == len(loaded_looks) - 1:
# delete not needed data on material
if "scs_tex_aliases" in mat:
del mat["scs_tex_aliases"]
# create new look entry on root
bpy.ops.object.scs_tools_add_look(look_name=look_name,
instant_apply=False)
# apply first look after everything is done
scs_root_object.scs_props.active_scs_look = 0
# fix scs root children objects count so it won't trigger persistent cycle
scs_root_object.scs_cached_num_children = len(scs_root_object.children)
return scs_root_object
def _create_scs_root_object(name, loaded_variants, loaded_looks, mats_info, objects, locators, armature):
"""Creates an 'SCS Root Object' (Empty Object) for currently imported
'SCS Game Object' and parent all import content to it.
:param name:
:type name: str
:param loaded_variants: X
:type loaded_variants: list
:param loaded_looks: X
:type loaded_looks: list
:param mats_info: list of material info, one material info consists of list: [ blend_mat_name, mat_effect, original_mat_alias ]
:type mats_info: list of list
:param objects: X
:type objects: list
:param locators: X
:type locators: list
:param armature: Armature Object
:type armature: bpy.types.Object
:return: SCS Root Object
:rtype: bpy.types.Object
"""
context = bpy.context
# MAKE THE 'SCS ROOT OBJECT' NAME UNIQUE
name = _name_utils.get_unique(name, bpy.data.objects)
# CREATE EMPTY OBJECT
bpy.ops.object.empty_add(
view_align=False,
location=(0.0, 0.0, 0.0),
# rotation=rot,
) # , layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False,
# False, False))
# MAKE A PROPER SETTINGS TO THE 'SCS Game Object' OBJECT
scs_root_object = context.active_object
scs_root_object.name = name
scs_root_object.scs_props.scs_root_object_export_enabled = True
scs_root_object.scs_props.empty_object_type = 'SCS_Root'
# print('LOD.pos: %s' % str(scs_root_object.location))
# print('CUR.pos: %s' % str(context.space_data.cursor_location))
# PARENTING
if armature:
# if armature is present we can specify our game object as animated
scs_root_object.scs_props.scs_root_animated = "anim"
# print('ARM.pos: %s' % str(armature.location))
bpy.ops.object.select_all(action='DESELECT')
armature.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
armature.scs_props.parent_identity = scs_root_object.name
for obj in objects:
# print('OBJ.pos: %s' % str(object.location))
bpy.ops.object.select_all(action='DESELECT')
obj.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
obj.scs_props.parent_identity = scs_root_object.name
for obj in locators:
bpy.ops.object.select_all(action='DESELECT')
obj.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
obj.scs_props.parent_identity = scs_root_object.name
# LOCATION
scs_root_object.location = context.scene.cursor_location
# MAKE ONLY 'SCS GAME OBJECT' SELECTED
bpy.ops.object.select_all(action='DESELECT')
for obj in bpy.data.objects:
obj.select = False
scs_root_object.select = True
context.scene.objects.active = scs_root_object
# MAKE PART RECORD
part_inventory = scs_root_object.scs_object_part_inventory
parts_dict = _object_utils.collect_parts_on_root(scs_root_object)
for part_name in parts_dict:
_inventory.add_item(part_inventory, part_name)
# MAKE VARIANT RECORD
variant_inventory = scs_root_object.scs_object_variant_inventory
for variant_i, variant_record in enumerate(loaded_variants):
variant_name = variant_record[0]
variantparts = variant_record[1]
variant = _inventory.add_item(variant_inventory, variant_name)
# for every variant create all of the part entries and mark them included properly
for part in part_inventory:
part = _inventory.add_item(variant.parts, part.name)
if part.name in variantparts:
part.include = True
# cleanup generated terrain points vertex layers by variant
for obj in parts_dict[part.name]:
if obj.type != "MESH":
continue
vg_to_delete = []
accepted_vg_nodes = {}
for vertex_group in obj.vertex_groups:
# ignore any vertex group which isn't from terrain points
# (others might come from skinning)
if _OP_consts.TerrainPoints.vg_name_prefix not in vertex_group.name:
continue
# ignore already fixed vertex group
if vertex_group.name.startswith(_OP_consts.TerrainPoints.vg_name_prefix):
continue
# get variant index from first 6 chars -> check PIM importer for more info
vg_var_index = int(vertex_group.name[:6])
# ignore other variant vertex groups and add them to delete list
if vg_var_index >= 0 and vg_var_index != variant_i:
vg_to_delete.append(vertex_group)
continue
# finally remove variant prefixing name if variant is not defined (-1)
# or index matches current one
vertex_group.name = vertex_group.name[6:]
# log accepted node index for identifying which vertex groups
# really have to be deleted
accepted_vg_nodes[vertex_group.name[-1]] = 1
# cleanup possible duplicates for the same node
# because one object anyway can not have terrain points vertex groups for multiple variants
while len(vg_to_delete) > 0 and len(accepted_vg_nodes) > 0:
curr_vg = vg_to_delete.pop()
# extra caution step where group can be deleted
# only if one of vertex groups for this node was accepted
if curr_vg.name[-1] in accepted_vg_nodes:
obj.vertex_groups.remove(curr_vg)
else:
part.include = False
# MAKE LOOK RECORDS
for look_i, look in enumerate(loaded_looks):
look_name = look[0]
look_mat_settings = look[1]
# SETUP ALL THE MATERIALS, NOTE: They should be already created by PIM import.
for mat_info in mats_info:
mat = bpy.data.materials[mat_info[0]]
if mat_info[2] in look_mat_settings:
# ASSIGN IMPORTED SHADER DATA
material_effect, material_attributes, material_textures, material_section = _get_shader_data(look_mat_settings[mat_info[2]])
# TRY TO FIND SUITABLE PRESET
(preset_name, preset_section) = _material_utils.find_preset(material_effect, material_textures)
if preset_name: # preset name is found within presets shaders
mat.scs_props.active_shader_preset_name = preset_name
if preset_section:
preset_effect = preset_section.get_prop_value("Effect")
mat.scs_props.mat_effect_name = preset_effect
if look_i == 0:
# apply default shader settings
_material_utils.set_shader_data_to_material(mat, preset_section, is_import=True)
# reapply settings from material
_material_utils.set_shader_data_to_material(mat, material_section, is_import=True, override_back_data=False)
lprint("D Using shader preset on material %r.", (mat.name,))
else:
print('''NO "preset_section"! (Shouldn't happen!)''')
else: # import shader directly from material and mark it as imported
mat.scs_props.active_shader_preset_name = "<imported>"
_material_utils.set_shader_data_to_material(mat, material_section, is_import=True)
lprint("W Using imported shader on material %r, effect: %r.", (mat.name, mat.scs_props.mat_effect_name))
if look_i == len(loaded_looks) - 1:
# delete not needed data on material
if "scs_tex_aliases" in mat:
del mat["scs_tex_aliases"]
# CREATE NEW LOOK ENTRY ON ROOT
bpy.ops.object.add_scs_look(look_name=look_name, instant_apply=False)
# apply first look after everything is done
scs_root_object.scs_props.active_scs_look = 0
# fix scs root children objects count so it won't trigger persistent cycle
scs_root_object.scs_cached_num_children = len(scs_root_object.children)
return scs_root_object
def _create_scs_root_object(name, loaded_variants, loaded_looks, mats_info,
objects, skinned_objects, locators, armature):
"""Creates an 'SCS Root Object' (Empty Object) for currently imported
'SCS Game Object' and parent all import content to it.
:param name:
:type name: str
:param loaded_variants: X
:type loaded_variants: list
:param loaded_looks: X
:type loaded_looks: list
:param mats_info: list of material info, one material info consists of list: [ blend_mat_name, mat_effect, original_mat_alias ]
:type mats_info: list of list
:param objects: X
:type objects: list
:param skinned_objects: X
:type skinned_objects: list
:param locators: X
:type locators: list
:param armature: Armature Object
:type armature: bpy.types.Object
:return: SCS Root Object
:rtype: bpy.types.Object
"""
context = bpy.context
# MAKE THE 'SCS ROOT OBJECT' NAME UNIQUE
name = _name_utils.get_unique(name, bpy.data.objects)
# CREATE EMPTY OBJECT
bpy.ops.object.empty_add(
view_align=False,
location=(0.0, 0.0, 0.0),
# rotation=rot,
) # , layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False,
# False, False))
# MAKE A PROPER SETTINGS TO THE 'SCS Game Object' OBJECT
scs_root_object = context.active_object
scs_root_object.name = name
scs_root_object.scs_props.scs_root_object_export_enabled = True
scs_root_object.scs_props.empty_object_type = 'SCS_Root'
# print('LOD.pos: %s' % str(scs_root_object.location))
# print('CUR.pos: %s' % str(context.space_data.cursor_location))
# PARENTING
if armature:
# if armature is present we can specify our game object as animated
scs_root_object.scs_props.scs_root_animated = "anim"
# print('ARM.pos: %s' % str(armature.location))
bpy.ops.object.select_all(action='DESELECT')
armature.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
armature.scs_props.parent_identity = scs_root_object.name
for obj in objects:
if obj not in skinned_objects:
# print('OBJ.pos: %s' % str(object.location))
bpy.ops.object.select_all(action='DESELECT')
obj.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
obj.scs_props.parent_identity = scs_root_object.name
for obj in locators:
bpy.ops.object.select_all(action='DESELECT')
obj.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
obj.scs_props.parent_identity = scs_root_object.name
# LOCATION
scs_root_object.location = context.scene.cursor_location
# MAKE ONLY 'SCS GAME OBJECT' SELECTED
bpy.ops.object.select_all(action='DESELECT')
for obj in bpy.data.objects:
obj.select = False
scs_root_object.select = True
context.scene.objects.active = scs_root_object
# MAKE PART RECORD
part_inventory = scs_root_object.scs_object_part_inventory
for part_name in _object_utils.collect_parts_on_root(scs_root_object):
_inventory.add_item(part_inventory, part_name)
# MAKE VARIANT RECORD
variant_inventory = scs_root_object.scs_object_variant_inventory
for variant_record in loaded_variants:
variant_name = variant_record[0]
variantparts = variant_record[1]
variant = _inventory.add_item(variant_inventory, variant_name)
# fore every variant create all of the part entries and mark them included properly
for part in part_inventory:
part = _inventory.add_item(variant.parts, part.name)
if part.name in variantparts:
part.include = True
else:
part.include = False
# MAKE LOOK RECORDS
# get preset container only once to speed up import process
presets_container = _material_utils.get_shader_presets_container(
_get_scs_globals().shader_presets_filepath)
for look_i, look in enumerate(loaded_looks):
look_name = look[0]
look_mat_settings = look[1]
# SETUP ALL THE MATERIALS, NOTE: They should be already created by PIM import.
for mat_info in mats_info:
mat = bpy.data.materials[mat_info[0]]
if mat_info[2] in look_mat_settings:
# ASSIGN IMPORTED SHADER DATA
material_effect, material_attributes, material_textures, material_section = _get_shader_data(
look_mat_settings[mat_info[2]])
# TRY TO FIND SUITABLE PRESET
(preset_index, preset_name,
preset_section) = _find_preset(presets_container,
material_effect,
material_textures)
if preset_index: # preset name is found within presets shaders
mat.scs_props.active_shader_preset_name = preset_name
if preset_section:
preset_effect = preset_section.get_prop_value("Effect")
mat.scs_props.mat_effect_name = preset_effect
if look_i == 0:
# apply default shader settings
_material_utils.set_shader_data_to_material(
mat,
preset_section,
preset_effect,
is_import=True)
# reapply settings from material
_material_utils.set_shader_data_to_material(
mat,
material_section,
material_effect,
is_import=True,
override_back_data=False)
lprint("I Using shader preset on material %r.",
(mat.name, ))
else:
print('''NO "preset_section"! (Shouldn't happen!)''')
else: # import shader directly from material and mark it as imported
mat.scs_props.active_shader_preset_name = "<imported>"
_material_utils.set_shader_data_to_material(
mat, material_section, material_effect, is_import=True)
lprint("I Using imported shader on material %r.",
(mat.name, ))
if look_i == len(loaded_looks) - 1:
# delete not needed data on material
if "scs_tex_aliases" in mat:
del mat["scs_tex_aliases"]
# CREATE NEW LOOK ENTRY ON ROOT
bpy.ops.object.add_scs_look(look_name=look_name, instant_apply=False)
# apply first look after everything is done
scs_root_object.scs_props.active_scs_look = 0
# fix scs root children objects count so it won't trigger persistent cycle
scs_root_object.scs_cached_num_children = len(scs_root_object.children)
return scs_root_object
def _create_scs_root_object(name, loaded_variants, loaded_looks, mats_info, objects, skinned_objects, locators, armature):
"""Creates an 'SCS Root Object' (Empty Object) for currently imported
'SCS Game Object' and parent all import content to it.
:param name:
:type name: str
:param loaded_variants: X
:type loaded_variants: list
:param loaded_looks: X
:type loaded_looks: list
:param mats_info: list of material info, one material info consists of list: [ blend_mat_name, mat_effect, original_mat_alias ]
:type mats_info: list of list
:param objects: X
:type objects: list
:param skinned_objects: X
:type skinned_objects: list
:param locators: X
:type locators: list
:param armature: Armature Object
:type armature: bpy.types.Object
:return: SCS Root Object
:rtype: bpy.types.Object
"""
context = bpy.context
# MAKE THE 'SCS ROOT OBJECT' NAME UNIQUE
name = _name_utils.get_unique(name, bpy.data.objects)
# CREATE EMPTY OBJECT
bpy.ops.object.empty_add(
view_align=False,
location=(0.0, 0.0, 0.0),
# rotation=rot,
) # , layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False,
# False, False))
# MAKE A PROPER SETTINGS TO THE 'SCS Game Object' OBJECT
scs_root_object = context.active_object
scs_root_object.name = name
scs_root_object.scs_props.scs_root_object_export_enabled = True
scs_root_object.scs_props.empty_object_type = 'SCS_Root'
# print('LOD.pos: %s' % str(scs_root_object.location))
# print('CUR.pos: %s' % str(context.space_data.cursor_location))
# PARENTING
if armature:
# if armature is present we can specify our game object as animated
scs_root_object.scs_props.scs_root_animated = "anim"
# print('ARM.pos: %s' % str(armature.location))
bpy.ops.object.select_all(action='DESELECT')
armature.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
armature.scs_props.parent_identity = scs_root_object.name
for obj in objects:
if obj not in skinned_objects:
# print('OBJ.pos: %s' % str(object.location))
bpy.ops.object.select_all(action='DESELECT')
obj.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
obj.scs_props.parent_identity = scs_root_object.name
for obj in locators:
bpy.ops.object.select_all(action='DESELECT')
obj.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
obj.scs_props.parent_identity = scs_root_object.name
# LOCATION
scs_root_object.location = context.scene.cursor_location
# MAKE ONLY 'SCS GAME OBJECT' SELECTED
bpy.ops.object.select_all(action='DESELECT')
for obj in bpy.data.objects:
obj.select = False
scs_root_object.select = True
context.scene.objects.active = scs_root_object
# MAKE PART RECORD
part_inventory = scs_root_object.scs_object_part_inventory
for part_name in _object_utils.collect_parts_on_root(scs_root_object):
_inventory.add_item(part_inventory, part_name)
# MAKE VARIANT RECORD
variant_inventory = scs_root_object.scs_object_variant_inventory
for variant_record in loaded_variants:
variant_name = variant_record[0]
variantparts = variant_record[1]
variant = _inventory.add_item(variant_inventory, variant_name)
# fore every variant create all of the part entries and mark them included properly
for part in part_inventory:
part = _inventory.add_item(variant.parts, part.name)
if part.name in variantparts:
part.include = True
else:
part.include = False
# MAKE LOOK RECORDS
# get preset container only once to speed up import process
presets_container = _material_utils.get_shader_presets_container(_get_scs_globals().shader_presets_filepath)
for look_i, look in enumerate(loaded_looks):
look_name = look[0]
look_mat_settings = look[1]
# SETUP ALL THE MATERIALS, NOTE: They should be already created by PIM import.
for mat_info in mats_info:
mat = bpy.data.materials[mat_info[0]]
if mat_info[2] in look_mat_settings:
# ASSIGN IMPORTED SHADER DATA
material_effect, material_attributes, material_textures, material_section = _get_shader_data(look_mat_settings[mat_info[2]])
# TRY TO FIND SUITABLE PRESET
(preset_index, preset_name, preset_section) = _find_preset(presets_container, material_effect, material_textures)
if preset_index: # preset name is found within presets shaders
mat.scs_props.active_shader_preset_name = preset_name
if preset_section:
preset_effect = preset_section.get_prop_value("Effect")
mat.scs_props.mat_effect_name = preset_effect
if look_i == 0:
# apply default shader settings
_material_utils.set_shader_data_to_material(mat, preset_section, preset_effect,
is_import=True)
# reapply settings from material
_material_utils.set_shader_data_to_material(mat, material_section, material_effect,
is_import=True, override_back_data=False)
lprint("I Using shader preset on material %r.", (mat.name,))
else:
print('''NO "preset_section"! (Shouldn't happen!)''')
else: # import shader directly from material and mark it as imported
mat.scs_props.active_shader_preset_name = "<imported>"
_material_utils.set_shader_data_to_material(mat, material_section, material_effect,
is_import=True)
lprint("I Using imported shader on material %r.", (mat.name,))
if look_i == len(loaded_looks) - 1:
# delete not needed data on material
if "scs_tex_aliases" in mat:
del mat["scs_tex_aliases"]
# CREATE NEW LOOK ENTRY ON ROOT
bpy.ops.object.add_scs_look(look_name=look_name, instant_apply=False)
# apply first look after everything is done
scs_root_object.scs_props.active_scs_look = 0
# fix scs root children objects count so it won't trigger persistent cycle
scs_root_object.scs_cached_num_children = len(scs_root_object.children)
return scs_root_object
def _create_scs_root_object(name, loaded_variants, objects, skinned_objects,
locators, armature):
"""Creates an 'SCS Root Object' (Empty Object) for currently imported
'SCS Game Object' and parent all import content to it.
:param name:
:type name: str
:param loaded_variants: X
:type loaded_variants: list
:param objects: X
:type objects: list
:param skinned_objects: X
:type skinned_objects: list
:param locators: X
:type locators: list
:param armature: Armature Object
:type armature: bpy.types.Object
:return: SCS Root Object
:rtype: bpy.types.Object
"""
context = bpy.context
# MAKE THE 'SCS ROOT OBJECT' NAME UNIQUE
if name in bpy.data.objects:
name = _name_utils.make_unique_name(bpy.data.objects[0], name)
# CREATE EMPTY OBJECT
bpy.ops.object.empty_add(
type='PLAIN_AXES',
view_align=False,
location=(0.0, 0.0, 0.0),
# rotation=rot,
) # , layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False,
# False, False))
# MAKE A PROPER SETTINGS TO THE 'SCS Game Object' OBJECT
scs_root_object = context.active_object
scs_root_object.name = name
scs_root_object.show_name = True
scs_root_object.show_x_ray = True
scs_root_object.scs_props.scs_root_object_export_enabled = True
scs_root_object.scs_props.empty_object_type = 'SCS_Root'
# print('LOD.pos: %s' % str(scs_root_object.location))
# print('CUR.pos: %s' % str(context.space_data.cursor_location))
# PARENTING
if armature:
# print('ARM.pos: %s' % str(armature.location))
bpy.ops.object.select_all(action='DESELECT')
armature.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
armature.scs_props.parent_identity = scs_root_object.name
for obj in objects:
if obj not in skinned_objects:
# print('OBJ.pos: %s' % str(object.location))
bpy.ops.object.select_all(action='DESELECT')
obj.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
obj.scs_props.parent_identity = scs_root_object.name
for obj in locators:
bpy.ops.object.select_all(action='DESELECT')
obj.select = True
bpy.ops.object.parent_set(type='OBJECT', keep_transform=False)
obj.scs_props.parent_identity = scs_root_object.name
# LOCATION
scs_root_object.location = context.scene.cursor_location
# MAKE ONLY 'SCS GAME OBJECT' SELECTED
bpy.ops.object.select_all(action='DESELECT')
for obj in bpy.data.objects:
obj.select = False
scs_root_object.select = True
context.scene.objects.active = scs_root_object
# MAKE PART RECORD
part_inventory = scs_root_object.scs_object_part_inventory
for part_name in _object_utils.collect_parts_on_root(scs_root_object):
_inventory.add_item(part_inventory, part_name)
# MAKE VARIANT RECORD
variant_inventory = scs_root_object.scs_object_variant_inventory
for variant_record in loaded_variants:
variant_name = variant_record[0]
variantparts = variant_record[1]
variant = _inventory.add_item(variant_inventory, variant_name)
# fore every variant create all of the part entries and mark them included properly
for part in part_inventory:
part = _inventory.add_item(variant.parts, part.name)
if part.name in variantparts:
part.include = True
else:
part.include = False
# fix scs root children objects count so it won't trigger persistent cycle
scs_root_object.scs_cached_num_children = len(scs_root_object.children)
return scs_root_object
