def execute(self, context):
scs_globals = _get_scs_globals()
if self.type == "DefaultExportPath":
obj = context.scene.scs_props
prop = "default_export_filepath"
elif self.type == "GameObjectExportPath":
obj = context.active_object.scs_props
prop = "scs_root_object_export_filepath"
elif self.type == "GameObjectAnimExportPath":
obj = _object_utils.get_scs_root(
context.active_object).scs_props
prop = "scs_root_object_anim_export_filepath"
else:
obj = context.active_object.scs_props
prop = "scs_skeleton_custom_export_dirpath"
if _path_utils.startswith(self.directory,
scs_globals.scs_project_path):
setattr(
obj, prop,
_path_utils.relative_path(scs_globals.scs_project_path,
self.directory))
else:
setattr(obj, prop, "//")
self.report({
'ERROR'
}, "Selected path is not within SCS Project Base Path,\npath will be reset to SCS Project Base Path instead."
)
return {'CANCELLED'}
return {'FINISHED'}
def execute(self, context):
scs_globals = _get_scs_globals()
if self.type == "DefaultExportPath":
obj = context.scene.scs_props
prop = "default_export_filepath"
elif self.type == "GameObjectExportPath":
obj = context.active_object.scs_props
prop = "scs_root_object_export_filepath"
elif self.type == "GameObjectAnimExportPath":
obj = _object_utils.get_scs_root(context.active_object).scs_props
prop = "scs_root_object_anim_export_filepath"
else:
obj = context.active_object.scs_props
prop = "scs_skeleton_custom_export_dirpath"
if _path_utils.startswith(self.directory, scs_globals.scs_project_path):
setattr(obj, prop, _path_utils.relative_path(scs_globals.scs_project_path, self.directory))
else:
setattr(obj, prop, "//")
self.report({'ERROR'}, "Selected path is not within SCS Project Base Path,\npath will be reset to SCS Project Base Path instead.")
return {'CANCELLED'}
return {'FINISHED'}
def execute(self, context):
"""Set Shader Presets library file path."""
scs_globals = _get_scs_globals()
if self.rel_path:
scs_globals.shader_presets_filepath = _path_utils.relative_path(scs_globals.scs_project_path, self.filepath)
else:
scs_globals.shader_presets_filepath = str(self.filepath)
return {'FINISHED'}
def execute(self, context):
"""Set Sign directory path."""
scs_globals = _get_scs_globals()
if _path_utils.startswith(self.filepath, scs_globals.scs_project_path):
self.filepath = _path_utils.relative_path(scs_globals.scs_project_path, self.filepath)
scs_globals.sign_library_rel_path = self.filepath
return {'FINISHED'}
def execute(self, context):
"""Set Hookup directory path."""
scs_globals = _get_scs_globals()
if _path_utils.startswith(self.directory, scs_globals.scs_project_path):
self.directory = _path_utils.relative_path(scs_globals.scs_project_path, self.directory)
scs_globals.hookup_library_rel_path = self.directory
return {'FINISHED'}
def execute(self, context):
"""Set Material Substance library filepath."""
scs_globals = _get_scs_globals()
if _path_utils.startswith(self.filepath, scs_globals.scs_project_path):
self.filepath = _path_utils.relative_path(scs_globals.scs_project_path, self.filepath)
scs_globals.matsubs_library_rel_path = self.filepath
return {'FINISHED'}
def execute(self, context):
"""Set Sign directory path."""
scs_globals = _get_scs_globals()
if self.filepath.startswith(scs_globals.scs_project_path):
self.filepath = _path_utils.relative_path(scs_globals.scs_project_path, self.filepath)
scs_globals.sign_library_rel_path = self.filepath
return {'FINISHED'}
def execute(self, context):
"""Set Material Substance library filepath."""
scs_globals = _get_scs_globals()
if self.filepath.startswith(scs_globals.scs_project_path):
self.filepath = _path_utils.relative_path(scs_globals.scs_project_path, self.filepath)
scs_globals.matsubs_library_rel_path = self.filepath
return {'FINISHED'}
def execute(self, context):
"""Set Hookup directory path."""
scs_globals = _get_scs_globals()
if self.directory.startswith(scs_globals.scs_project_path):
self.directory = _path_utils.relative_path(scs_globals.scs_project_path, self.directory)
scs_globals.hookup_library_rel_path = self.directory
return {'FINISHED'}
def execute(self, context):
"""Set Traffic Rules library filepath."""
scs_globals = _get_scs_globals()
if self.filepath.startswith(scs_globals.scs_project_path):
self.filepath = _path_utils.relative_path(scs_globals.scs_project_path, self.filepath)
scs_globals.traffic_rules_library_rel_path = self.filepath
return {'FINISHED'}
def execute(self, context):
"""Set Traffic Semaphore Profile library filepath."""
scs_globals = _get_scs_globals()
if self.filepath.startswith(scs_globals.scs_project_path):
self.filepath = _path_utils.relative_path(scs_globals.scs_project_path, self.filepath)
scs_globals.tsem_library_rel_path = self.filepath
return {'FINISHED'}
def execute(self, context):
"""Set Traffic Rules library filepath."""
scs_globals = _get_scs_globals()
if _path_utils.startswith(self.filepath, scs_globals.scs_project_path):
self.filepath = _path_utils.relative_path(scs_globals.scs_project_path, self.filepath)
scs_globals.traffic_rules_library_rel_path = self.filepath
return {'FINISHED'}
def execute(self, context):
"""Set Traffic Semaphore Profile library filepath."""
scs_globals = _get_scs_globals()
if _path_utils.startswith(self.filepath,
scs_globals.scs_project_path):
self.filepath = _path_utils.relative_path(
scs_globals.scs_project_path, self.filepath)
scs_globals.tsem_library_rel_path = self.filepath
return {'FINISHED'}
def execute(self, context):
"""Set shader texture file path."""
scs_globals = _get_scs_globals()
material = context.active_object.active_material
scs_base = scs_globals.scs_project_path
if self.filepath.startswith(scs_base):
setattr(material.scs_props, self.shader_texture, _path_utils.relative_path(scs_base, self.filepath))
else:
setattr(material.scs_props, self.shader_texture, str(self.filepath))
return {'FINISHED'}
def execute(self, context):
"""Set shader texture file path."""
scs_globals = _get_scs_globals()
material = context.active_object.active_material
scs_base = scs_globals.scs_project_path
if self.filepath.startswith(scs_base):
setattr(material.scs_props, self.shader_texture, _path_utils.relative_path(scs_base, self.filepath))
else:
setattr(material.scs_props, self.shader_texture, str(self.filepath))
return {'FINISHED'}
def get_texture(texture_path, texture_type, report_invalid=False):
"""Creates and setup Texture and Image data on active Material.
:param texture_path: Texture path
:type texture_path: str
:param texture_type: Texture type keyword
:type texture_type: str
:param report_invalid: flag indicating if invalid texture should be reported in 3d view
:type report_invalid: bool
"""
# CREATE TEXTURE/IMAGE ID NAME
teximag_id_name = _path.get_filename(texture_path, with_ext=False)
# CREATE ABSOLUTE FILEPATH
abs_texture_filepath = _path.get_abs_path(texture_path)
# return None on non-existing texture file path
if not abs_texture_filepath or not os.path.isfile(abs_texture_filepath):
return None
if abs_texture_filepath.endswith(".tobj"):
abs_texture_filepath = _path.get_texture_path_from_tobj(abs_texture_filepath)
# if not existing or none supported file
if abs_texture_filepath is None or abs_texture_filepath[-4:] not in (".tga", ".png", ".dds"):
if report_invalid:
lprint("", report_warnings=-1, report_errors=-1)
# take care of none existing paths referenced in tobj texture names
if abs_texture_filepath:
lprint("W Texture can't be displayed as TOBJ file: %r is referencing non texture file:\n\t %r",
(texture_path, _path.readable_norm(abs_texture_filepath)))
else:
lprint("W Texture can't be displayed as TOBJ file: %r is referencing non existing texture file.",
(texture_path,))
if report_invalid:
lprint("", report_warnings=1, report_errors=1)
return None
texture = None
if abs_texture_filepath and os.path.isfile(abs_texture_filepath):
# find existing texture with this image
if teximag_id_name in bpy.data.textures:
# reuse existing image texture if possible
postfix = 0
postfixed_tex = teximag_id_name
while postfixed_tex in bpy.data.textures:
img_exists = bpy.data.textures[postfixed_tex].image is not None
if img_exists and _path.repair_path(bpy.data.textures[postfixed_tex].image.filepath) == _path.repair_path(abs_texture_filepath):
texture = bpy.data.textures[postfixed_tex]
break
postfix += 1
postfixed_tex = teximag_id_name + "." + str(postfix).zfill(3)
# if texture wasn't found create new one
if not texture:
texture = bpy.data.textures.new(teximag_id_name, 'IMAGE')
image = None
# reuse existing image if possible
postfix = 0
postfixed_img = teximag_id_name
while postfixed_img in bpy.data.images:
if _path.repair_path(bpy.data.images[postfixed_img].filepath) == _path.repair_path(abs_texture_filepath):
image = bpy.data.images[postfixed_img]
break
postfix += 1
postfixed_img = teximag_id_name + "." + str(postfix).zfill(3)
# if image wasn't found load it
if not image:
image = bpy.data.images.load(abs_texture_filepath)
image.name = teximag_id_name
# try to get relative path to the Blender file and set it to the image
if bpy.data.filepath != '': # empty file path means blender file is not saved
try:
rel_path = _path.relative_path(os.path.dirname(bpy.data.filepath), abs_texture_filepath)
except ValueError: # catch different mount paths: "path is on mount 'C:', start on mount 'E:'"
rel_path = None
if rel_path:
image.filepath = rel_path
# finally link image to texture
texture.image = image
image.use_alpha = True
# set proper color space depending on texture type
if texture_type == "nmap":
# For TGA normal maps texture use Non-Color color space as it should be,
# but for 16-bits PNG normal maps texture sRGB has to be used
# otherwise Blender completely messes up normals calculation
if texture.image.filepath.endswith(".tga"):
texture.image.colorspace_settings.name = "Non-Color"
else:
texture.image.colorspace_settings.name = "sRGB"
else:
texture.image.colorspace_settings.name = "sRGB"
# set usage of normal map if texture type is correct
texture.use_normal_map = (texture_type == "nmap")
if texture is None and texture_path.endswith(".tobj"):
if report_invalid:
lprint("", report_warnings=-1, report_errors=-1)
lprint("W Texture can't be displayed as TOBJ file: %r is referencing non existing texture file:\n\t %r",
(texture_path, _path.readable_norm(abs_texture_filepath)))
if report_invalid:
lprint("", report_warnings=1, report_errors=1)
return texture
def get_texture(texture_path, texture_type, report_invalid=False):
"""Creates and setup Texture and Image data on active Material.
:param texture_path: Texture path
:type texture_path: str
:param texture_type: Texture type keyword
:type texture_type: str
:param report_invalid: flag indicating if invalid texture should be reported in 3d view
:type report_invalid: bool
"""
# CREATE TEXTURE/IMAGE ID NAME
teximag_id_name = _path.get_filename(texture_path, with_ext=False)
# CREATE ABSOLUTE FILEPATH
abs_texture_filepath = _path.get_abs_path(texture_path)
# return None on non-existing texture file path
if not abs_texture_filepath or not os.path.isfile(abs_texture_filepath):
return None
if abs_texture_filepath.endswith(".tobj"):
abs_texture_filepath = _path.get_texture_path_from_tobj(
abs_texture_filepath)
# if not existing or none supported file
if abs_texture_filepath is None or abs_texture_filepath[-4:] not in (
".tga", ".png", ".dds"):
if report_invalid:
lprint("", report_warnings=-1, report_errors=-1)
# take care of none existing paths referenced in tobj texture names
if abs_texture_filepath:
lprint(
"W Texture can't be displayed as TOBJ file: %r is referencing non texture file:\n\t %r",
(texture_path, _path.readable_norm(abs_texture_filepath)))
else:
lprint(
"W Texture can't be displayed as TOBJ file: %r is referencing non existing texture file.",
(texture_path, ))
if report_invalid:
lprint("", report_warnings=1, report_errors=1)
return None
texture = None
if abs_texture_filepath and os.path.isfile(abs_texture_filepath):
# find existing texture with this image
if teximag_id_name in bpy.data.textures:
# reuse existing image texture if possible
postfix = 0
postfixed_tex = teximag_id_name
while postfixed_tex in bpy.data.textures:
img_exists = bpy.data.textures[postfixed_tex].image is not None
if img_exists and _path.repair_path(
bpy.data.textures[postfixed_tex].image.filepath
) == _path.repair_path(abs_texture_filepath):
texture = bpy.data.textures[postfixed_tex]
break
postfix += 1
postfixed_tex = teximag_id_name + "." + str(postfix).zfill(3)
# if texture wasn't found create new one
if not texture:
texture = bpy.data.textures.new(teximag_id_name, 'IMAGE')
image = None
# reuse existing image if possible
postfix = 0
postfixed_img = teximag_id_name
while postfixed_img in bpy.data.images:
if _path.repair_path(
bpy.data.images[postfixed_img].filepath
) == _path.repair_path(abs_texture_filepath):
image = bpy.data.images[postfixed_img]
break
postfix += 1
postfixed_img = teximag_id_name + "." + str(postfix).zfill(3)
# if image wasn't found load it
if not image:
image = bpy.data.images.load(abs_texture_filepath)
image.name = teximag_id_name
# try to get relative path to the Blender file and set it to the image
if bpy.data.filepath != '': # empty file path means blender file is not saved
try:
rel_path = _path.relative_path(
os.path.dirname(bpy.data.filepath),
abs_texture_filepath)
except ValueError: # catch different mount paths: "path is on mount 'C:', start on mount 'E:'"
rel_path = None
if rel_path:
image.filepath = rel_path
# finally link image to texture
texture.image = image
image.use_alpha = True
# set proper color space depending on texture type
if texture_type == "nmap":
# For TGA normal maps texture use Non-Color color space as it should be,
# but for 16-bits PNG normal maps texture sRGB has to be used
# otherwise Blender completely messes up normals calculation
if texture.image.filepath.endswith(".tga"):
texture.image.colorspace_settings.name = "Non-Color"
else:
texture.image.colorspace_settings.name = "sRGB"
else:
texture.image.colorspace_settings.name = "sRGB"
# set usage of normal map if texture type is correct
texture.use_normal_map = (texture_type == "nmap")
if texture is None and texture_path.endswith(".tobj"):
if report_invalid:
lprint("", report_warnings=-1, report_errors=-1)
lprint(
"W Texture can't be displayed as TOBJ file: %r is referencing non existing texture file:\n\t %r",
(texture_path, _path.readable_norm(abs_texture_filepath)))
if report_invalid:
lprint("", report_warnings=1, report_errors=1)
return texture
def load(context, filepath, name_suffix="", suppress_reports=False):
"""
:param context: Blender Context currently used for window_manager.update_progress and bpy_object_utils.object_data_add
:type context: bpy.types.Context
:param filepath: File path to be imported
:type filepath: str
:param name_suffix: files name suffix (exchange format is using .ef)
:type name_suffix: str
:param suppress_reports: True if you don't want for reports to be flushed & summaries to be printed out; False otherwise
:type suppress_reports: bool
:return: Return state statuses (Usually 'FINISHED')
:rtype: set
"""
import time
t = time.time()
bpy.context.window.cursor_modal_set('WAIT')
scs_globals = _get_scs_globals()
if not suppress_reports:
lprint("", report_errors=-1, report_warnings=-1
) # Clear the 'error_messages' and 'warning_messages'
collision_locators = []
prefab_locators = []
loaded_variants = []
loaded_looks = []
objects = []
locators = []
mats_info = []
scs_root_object = skeleton = bones = armature = None
# TRANSITIONAL STRUCTURES
terrain_points = TerrainPntsTrans()
# IMPORT PIP -> has to be loaded before PIM because of terrain points
if scs_globals.import_pip_file:
lprint("I Importing PIP ...")
pip_filepath = filepath + ".pip" + name_suffix
if os.path.isfile(pip_filepath):
lprint('\nD PIP filepath:\n %s', (pip_filepath, ))
# print('PIP filepath:\n %s' % pip_filepath)
result, prefab_locators = _pip.load(pip_filepath, terrain_points)
else:
lprint('\nI No PIP file.')
# print('INFO - No PIP file.')
# IMPORT PIM
if scs_globals.import_pim_file or scs_globals.import_pis_file:
lprint("I Importing PIM ...")
pim_filepath = filepath + ".pim" + name_suffix
if pim_filepath:
if os.path.isfile(pim_filepath):
lprint('\nD PIM filepath:\n %s',
(_path_utils.readable_norm(pim_filepath), ))
if pim_filepath.endswith(".pim"):
result, objects, locators, armature, skeleton, mats_info = _pim.load(
context,
pim_filepath,
terrain_points_trans=terrain_points)
elif pim_filepath.endswith(".pim.ef"):
result, objects, locators, armature, skeleton, mats_info = _pim_ef.load(
context,
pim_filepath,
terrain_points_trans=terrain_points)
else:
lprint(
"\nE Unknown PIM file extension! Shouldn't happen...")
else:
lprint('\nI No file found at %r!' %
(_path_utils.readable_norm(pim_filepath), ))
else:
lprint('\nI No filepath provided!')
# IMPORT PIT
bpy.context.view_layer.objects.active = None
if scs_globals.import_pit_file:
lprint("I Importing PIT ...")
pit_filepath = filepath + ".pit" + name_suffix
if os.path.isfile(pit_filepath):
lprint('\nD PIT filepath:\n %s', (pit_filepath, ))
# print('PIT filepath:\n %s' % pit_filepath)
result, loaded_variants, loaded_looks = _pit.load(pit_filepath)
else:
lprint('\nI No PIT file.')
# print('INFO - No PIT file.')
# IMPORT PIC
if scs_globals.import_pic_file:
lprint("I Importing PIC ...")
pic_filepath = filepath + ".pic" + name_suffix
if os.path.isfile(pic_filepath):
lprint('\nD PIC filepath:\n %s', (pic_filepath, ))
# print('PIC filepath:\n %s' % pic_filepath)
result, collision_locators = _pic.load(pic_filepath)
else:
lprint('\nI No PIC file.')
# print('INFO - No PIC file.')
# SETUP 'SCS GAME OBJECTS'
lprint("I Setup of SCS game object ...")
for item in collision_locators:
locators.append(item)
for item in prefab_locators:
locators.append(item)
path, filename = os.path.split(filepath)
if objects or locators or (armature and skeleton):
scs_root_object = _create_scs_root_object(filename, loaded_variants,
loaded_looks, mats_info,
objects, locators, armature)
# Additionally if user wants to have automatically set custom export path, then let him have it :P
if scs_globals.import_preserve_path_for_export:
relative_export_path = _path_utils.relative_path(
scs_globals.scs_project_path, path)
if path.startswith(scs_globals.scs_project_path
) and relative_export_path != path:
scs_root_object.scs_props.scs_root_object_export_filepath = relative_export_path
scs_root_object.scs_props.scs_root_object_allow_custom_path = True
else:
lprint(
"W Can not preserve import path for export on import SCS Root %r, "
"as import was done from outside of current SCS Project Base Path!",
(scs_root_object.name, ))
# IMPORT PIS
if scs_globals.import_pis_file:
lprint("I Importing PIS ...")
# pis file path is created from directory of pim file and skeleton definition inside pim header
pis_filepath = os.path.dirname(filepath) + os.sep + skeleton
if os.path.isfile(pis_filepath):
lprint('\nD PIS filepath:\n %s', (pis_filepath, ))
# strip off name suffix from skeleton path
skeleton = skeleton[:-len(name_suffix)]
# fill in custom data if PIS file is from other directory
if skeleton[:-4] != scs_root_object.name:
armature.scs_props.scs_skeleton_custom_export_dirpath = "//" + os.path.relpath(
os.path.dirname(pis_filepath),
scs_globals.scs_project_path)
armature.scs_props.scs_skeleton_custom_name = os.path.basename(
skeleton[:-4])
bones = _pis.load(pis_filepath, armature)
else:
bones = None
lprint('\nI No PIS file.')
# IMPORT PIA
if scs_globals.import_pia_file and bones:
lprint("I Importing PIAs ...")
basepath = os.path.dirname(filepath)
# Search for PIA files in model's directory and its subdirectiories...
lprint('\nD Searching the directory for PIA files:\n %s',
(basepath, ))
# print('\nSearching the directory for PIA files:\n %s' % str(basepath))
pia_files = []
index = 0
for root, dirs, files in os.walk(basepath):
if not scs_globals.import_include_subdirs_for_pia:
if index > 0:
break
# print(' root: %s - dirs: %s - files: %s' % (str(root), str(dirs), str(files)))
for file in files:
if file.endswith(".pia" + name_suffix):
pia_filepath = os.path.join(root, file)
pia_files.append(pia_filepath)
index += 1
if len(pia_files) > 0:
lprint('D PIA files found:')
for pia_filepath in pia_files:
lprint('D %r', pia_filepath)
# print('armature: %s\nskeleton: %r\nbones: %s\n' % (str(armature), str(skeleton), str(bones)))
_pia.load(scs_root_object, pia_files, armature, pis_filepath,
bones)
else:
lprint('\nI No PIA files.')
# fix scene objects count so it won't trigger copy cycle
bpy.context.scene.scs_cached_num_objects = len(bpy.context.scene.objects)
# FINAL FEEDBACK
bpy.context.window.cursor_modal_restore()
if suppress_reports:
lprint('\nI Import compleeted in %.3f sec.', time.time() - t)
else:
lprint('\nI Import compleeted in %.3f sec.',
time.time() - t,
report_errors=True,
report_warnings=True)
return True
def get_texture_image(texture_path, texture_type, report_invalid=False):
"""Creates and returns image for given texture path and type.
:param texture_path: Texture path
:type texture_path: str
:param texture_type: Texture type keyword
:type texture_type: str
:param report_invalid: flag indicating if invalid texture should be reported in 3d view
:type report_invalid: bool
:return: loaded image datablock to be used in SCS material
:rtype: bpy.types.Image
"""
# get reflection image texture
if texture_path.endswith(".tobj") and texture_type == "reflection":
return get_reflection_image(texture_path, report_invalid=report_invalid)
# CREATE TEXTURE/IMAGE ID NAME
teximag_id_name = _path.get_filename(texture_path, with_ext=False)
# CREATE ABSOLUTE FILEPATH
abs_texture_filepath = _path.get_abs_path(texture_path)
# return None on non-existing texture file path
if not abs_texture_filepath or not os.path.isfile(abs_texture_filepath):
return None
if abs_texture_filepath.endswith(".tobj"):
abs_texture_filepath = _path.get_texture_path_from_tobj(abs_texture_filepath)
# if not existing or none supported file
if abs_texture_filepath is None or abs_texture_filepath[-4:] not in (".tga", ".png", ".dds"):
if report_invalid:
lprint("", report_warnings=-1, report_errors=-1)
# take care of none existing paths referenced in tobj texture names
if abs_texture_filepath:
lprint("W Texture can't be displayed as TOBJ file: %r is referencing non texture file:\n\t %r",
(texture_path, _path.readable_norm(abs_texture_filepath)))
else:
lprint("W Texture can't be displayed as TOBJ file: %r is referencing non existing texture file.",
(texture_path,))
if report_invalid:
lprint("", report_warnings=1, report_errors=1)
return None
image = None
if abs_texture_filepath and os.path.isfile(abs_texture_filepath):
# reuse existing image texture if possible
postfix = 0
postfixed_tex = teximag_id_name
while postfixed_tex in bpy.data.images:
img_exists = postfixed_tex in bpy.data.images
if img_exists and _path.repair_path(bpy.data.images[postfixed_tex].filepath) == _path.repair_path(abs_texture_filepath):
image = bpy.data.images[postfixed_tex]
break
postfix += 1
postfixed_tex = teximag_id_name + "." + str(postfix).zfill(3)
# if image wasn't found create new one
if not image:
image = None
# reuse existing image if possible
postfix = 0
postfixed_img = teximag_id_name
while postfixed_img in bpy.data.images:
if _path.repair_path(bpy.data.images[postfixed_img].filepath) == _path.repair_path(abs_texture_filepath):
image = bpy.data.images[postfixed_img]
break
postfix += 1
postfixed_img = teximag_id_name + "." + str(postfix).zfill(3)
# if image wasn't found load it
if not image:
image = bpy.data.images.load(abs_texture_filepath)
image.name = teximag_id_name
image.alpha_mode = 'CHANNEL_PACKED'
# try to get relative path to the Blender file and set it to the image
if bpy.data.filepath != '': # empty file path means blender file is not saved
try:
rel_path = _path.relative_path(os.path.dirname(bpy.data.filepath), abs_texture_filepath)
except ValueError: # catch different mount paths: "path is on mount 'C:', start on mount 'E:'"
rel_path = None
if rel_path:
image.filepath = rel_path
if image is None and texture_path.endswith(".tobj"):
if report_invalid:
lprint("", report_warnings=-1, report_errors=-1)
lprint("W Texture can't be displayed as TOBJ file: %r is referencing non existing texture file:\n\t %r",
(texture_path, _path.readable_norm(abs_texture_filepath)))
if report_invalid:
lprint("", report_warnings=1, report_errors=1)
return image
def get_texture(texture_path, texture_type):
"""Creates and setup Texture and Image data on active Material.
:param texture_path: Texture path
:type texture_path: str
:param texture_type: Texture type keyword
:type texture_type: str
"""
# print(' texture_path: %s' % str(texture_path))
# CREATE TEXTURE/IMAGE ID NAME
teximag_id_name = _path.get_filename(texture_path, with_ext=False)
# CREATE ABSOLUTE FILEPATH
abs_texture_filepath = _path.get_abs_path(texture_path)
texture = None
if abs_texture_filepath and os.path.isfile(abs_texture_filepath):
# find existing texture with this image
if teximag_id_name in bpy.data.textures:
# reuse existing image texture if possible
postfix = 0
postfixed_tex = teximag_id_name
while postfixed_tex in bpy.data.textures:
if _path.repair_path(bpy.data.textures[postfixed_tex].image.filepath) == _path.repair_path(abs_texture_filepath):
texture = bpy.data.textures[postfixed_tex]
break
postfix += 1
postfixed_tex = teximag_id_name + "." + str(postfix).zfill(3)
# if texture wasn't found create new one
if not texture:
texture = bpy.data.textures.new(teximag_id_name, 'IMAGE')
image = None
# reuse existing image if possible
postfix = 0
postfixed_img = teximag_id_name
while postfixed_img in bpy.data.images:
if _path.repair_path(bpy.data.images[postfixed_img].filepath) == _path.repair_path(abs_texture_filepath):
image = bpy.data.images[postfixed_img]
break
postfix += 1
postfixed_img = teximag_id_name + "." + str(postfix).zfill(3)
# if image wasn't found load it
if not image:
image = bpy.data.images.load(abs_texture_filepath)
image.name = teximag_id_name
# try to get relative path to the Blender file and set it to the image
if bpy.data.filepath != '': # empty file path means blender file is not saved
try:
rel_path = _path.relative_path(os.path.dirname(bpy.data.filepath), abs_texture_filepath)
except ValueError: # catch different mount paths: "path is on mount 'C:', start on mount 'E:'"
rel_path = None
if rel_path:
image.filepath = rel_path
# finally link image to texture
texture.image = image
image.use_alpha = True
# normal map related settings
if texture_type == "nmap":
texture.image.colorspace_settings.name = "Raw"
texture.use_normal_map = True
else:
texture.image.colorspace_settings.name = "sRGB"
texture.use_normal_map = False
return texture
def load(context, filepath):
"""
:param context: Blender Context currently used for window_manager.update_progress and bpy_object_utils.object_data_add
:type context: bpy.types.Context
:param filepath: File path to be imported
:type filepath: str
:return: Return state statuses (Usually 'FINISHED')
:rtype: dict
"""
import time
t = time.time()
bpy.context.window.cursor_modal_set('WAIT')
scs_globals = _get_scs_globals()
lprint("", report_errors=-1, report_warnings=-1
) # Clear the 'error_messages' and 'warning_messages'
collision_locators = []
prefab_locators = []
loaded_variants = []
loaded_looks = []
objects = []
locators = []
mats_info = []
scs_root_object = skeleton = bones = armature = None
# TRANSITIONAL STRUCTURES
terrain_points = TerrainPntsTrans()
# IMPORT PIP -> has to be loaded before PIM because of terrain points
if scs_globals.import_pip_file:
pip_filepath = str(filepath[:-1] + 'p')
if os.path.isfile(pip_filepath):
lprint('\nD PIP filepath:\n %s', (pip_filepath, ))
# print('PIP filepath:\n %s' % pip_filepath)
result, prefab_locators = _pip.load(pip_filepath, terrain_points)
else:
lprint('\nI No PIP file.')
# print('INFO - No PIP file.')
# IMPORT PIM
if scs_globals.import_pim_file or scs_globals.import_pis_file:
if filepath:
if os.path.isfile(filepath):
lprint('\nD PIM filepath:\n %s',
(_path_utils.readable_norm(filepath), ))
result, objects, locators, armature, skeleton, mats_info = _pim.load(
context, filepath, terrain_points_trans=terrain_points)
# print(' armature:\n%s\n skeleton:\n%s' % (str(armature), str(skeleton)))
else:
lprint('\nI No file found at %r!' %
(_path_utils.readable_norm(filepath), ))
else:
lprint('\nI No filepath provided!')
# IMPORT PIT
bpy.context.scene.objects.active = None
if scs_globals.import_pit_file:
pit_filepath = str(filepath[:-1] + 't')
if os.path.isfile(pit_filepath):
lprint('\nD PIT filepath:\n %s', (pit_filepath, ))
# print('PIT filepath:\n %s' % pit_filepath)
result, loaded_variants, loaded_looks = _pit.load(pit_filepath)
else:
lprint('\nI No PIT file.')
# print('INFO - No PIT file.')
# IMPORT PIC
if scs_globals.import_pic_file:
pic_filepath = str(filepath[:-1] + 'c')
if os.path.isfile(pic_filepath):
lprint('\nD PIC filepath:\n %s', (pic_filepath, ))
# print('PIC filepath:\n %s' % pic_filepath)
result, collision_locators = _pic.load(pic_filepath)
else:
lprint('\nI No PIC file.')
# print('INFO - No PIC file.')
# SETUP 'SCS GAME OBJECTS'
for item in collision_locators:
locators.append(item)
for item in prefab_locators:
locators.append(item)
path, file = os.path.split(filepath)
# print(' path: %r\n file: %r' % (path, file))
lod_name, ext = os.path.splitext(file)
if objects or locators or (armature and skeleton):
scs_root_object = _create_scs_root_object(lod_name, loaded_variants,
loaded_looks, mats_info,
objects, locators, armature)
# Additionally if user wants to have automatically set custom export path, then let him have it :P
if scs_globals.import_preserve_path_for_export:
relative_export_path = _path_utils.relative_path(
scs_globals.scs_project_path, path)
if path.startswith(scs_globals.scs_project_path
) and relative_export_path != path:
scs_root_object.scs_props.scs_root_object_export_filepath = relative_export_path
scs_root_object.scs_props.scs_root_object_allow_custom_path = True
else:
lprint(
"W Can not preserve import path for export on import SCS Root %r, "
"as import was done from outside of current SCS Project Base Path!",
(scs_root_object.name, ))
# IMPORT PIS
if scs_globals.import_pis_file:
# pis file path is created from directory of pim file and skeleton definition inside pim header
pis_filepath = os.path.dirname(filepath) + os.sep + skeleton
if os.path.isfile(pis_filepath):
lprint('\nD PIS filepath:\n %s', (pis_filepath, ))
# fill in custom data if PIS file is from other directory
if skeleton[:-4] != scs_root_object.name:
armature.scs_props.scs_skeleton_custom_export_dirpath = "//" + os.path.relpath(
os.path.dirname(pis_filepath),
scs_globals.scs_project_path)
armature.scs_props.scs_skeleton_custom_name = os.path.basename(
skeleton[:-4])
bones = _pis.load(pis_filepath, armature)
else:
bones = None
lprint('\nI No PIS file.')
# IMPORT PIA
if scs_globals.import_pia_file and bones:
basepath = os.path.dirname(filepath)
# Search for PIA files in model's directory and its subdirectiories...
lprint('\nD Searching the directory for PIA files:\n %s',
(basepath, ))
# print('\nSearching the directory for PIA files:\n %s' % str(basepath))
pia_files = []
index = 0
for root, dirs, files in os.walk(basepath):
if not scs_globals.import_include_subdirs_for_pia:
if index > 0:
break
# print(' root: %s - dirs: %s - files: %s' % (str(root), str(dirs), str(files)))
for file in files:
if file.endswith(".pia"):
pia_filepath = os.path.join(root, file)
pia_files.append(pia_filepath)
index += 1
if len(pia_files) > 0:
lprint('D PIA files found:')
for pia_filepath in pia_files:
lprint('D %r', pia_filepath)
# print('armature: %s\nskeleton: %r\nbones: %s\n' % (str(armature), str(skeleton), str(bones)))
_pia.load(scs_root_object, pia_files, armature, pis_filepath,
bones)
else:
lprint('\nI No PIA files.')
# fix scene objects count so it won't trigger copy cycle
bpy.context.scene.scs_cached_num_objects = len(bpy.context.scene.objects)
# Turn on Textured Solid in 3D view...
for bl_screen in bpy.data.screens:
for bl_area in bl_screen.areas:
for bl_space in bl_area.spaces:
if bl_space.type == 'VIEW_3D':
bl_space.show_textured_solid = True
# Turn on GLSL in 3D view...
bpy.context.scene.game_settings.material_mode = 'GLSL'
# Turn on "Frame Dropping" for animation playback...
bpy.context.scene.use_frame_drop = True
# FINAL FEEDBACK
bpy.context.window.cursor_modal_restore()
lprint('\nI Import compleeted in %.3f sec.',
time.time() - t,
report_errors=True,
report_warnings=True)
return True
