bl_info = {
"name": "ConverterPIX Wrapper for conversion & import of SCS Game Models",
"description": "Wrapper add-on to use ConvPIX within the Blender and import SCS
game models with ease.",
"author": "Simon Lusenc (50keda)",
"version": (2, 1),
"blender": (2, 81, 0),
"location": "File > Import > SCS Models - ConverterPIX & BT (*.scs)",
"category": "Import-Export",
"support": "COMMUNITY"
}
import bpy
import os
import subprocess
import shutil
from sys import platform
from tempfile import mkdtemp
from threading import Thread
from time import time
from bpy.props import StringProperty, CollectionProperty, IntProperty,
BoolProperty, PointerProperty, FloatProperty
from bpy.types import AddonPreferences
from bpy_extras.io_utils import ImportHelper
# use blender configuration directories to save converter pix binary,
# this way we can avoid permission problems of saving exe file
CONVERTER_PIX_DIR = os.path.join(bpy.utils.resource_path('USER'),
"config/ConverterPIXWrapper")
if not os.path.isdir(CONVERTER_PIX_DIR):
os.makedirs(CONVERTER_PIX_DIR, exist_ok=True)
if platform == "linux":
CONVERTER_PIX_URL =
"https://github.com/simon50keda/ConverterPIX/raw/master/bin/linux/converter_pix"
CONVERTER_PIX_PATH = os.path.join(CONVERTER_PIX_DIR, "converter_pix")
LINE_SPLITTER = "\n"
elif platform == "darwin":
CONVERTER_PIX_URL =
"https://github.com/theHarven/ConverterPIX/raw/MacOS_binary/bin/macos/
converter_pix"
CONVERTER_PIX_PATH = os.path.join(CONVERTER_PIX_DIR, "converter_pix")
LINE_SPLITTER = "\n"
else:
CONVERTER_PIX_URL =
"https://github.com/mwl4/ConverterPIX/raw/master/bin/win_x86/converter_pix.exe"
CONVERTER_PIX_PATH = os.path.join(CONVERTER_PIX_DIR, "converter_pix.exe")
LINE_SPLITTER = "\r\n"
def path_join(path1, path2):
"""Joins path1 with path2 and replaces backslashes with forward ones.
Needed for proper navigation inside archive tree on Windows.
"""
return os.path.join(path1, path2).replace("\\", "/")
def update_converter_pix():
"""Downloads ConverterPIX from github and saves it to CONVERTER_PIX_PATH.
:returns: True if successfully updated; False otherwise
:rtype: bool
"""
print("Downloading ConverterPIX...")
try:
from urllib3 import disable_warnings
from requests import get
# disable urllib warnings so we don't get complains over unauthorized
converter pix download
disable_warnings()
# create unauthorized get request and download converter pix
result = get(CONVERTER_PIX_URL, verify=False)
with open(CONVERTER_PIX_PATH, "wb") as f:
f.write(result.content)
# make it executable on linux
if platform == "linux" or platform == "darwin":
from stat import S_IEXEC, S_IXGRP
st = os.stat(CONVERTER_PIX_PATH)
os.chmod(CONVERTER_PIX_PATH, st.st_mode | S_IEXEC | S_IXGRP)
except Exception as e:
from traceback import format_exc
trace_str = format_exc().replace("\n", "\n\t")
print("Unexpected %s error accured duing updating of ConverterPIX:\n\t%s\n"
% (type(e).__name__, trace_str))
return False
print("ConverterPix updated!")
return True
def run_converter_pix(args):
"""Runs ConverterPIX via CLI.
1. On linux run it trough wine
2. Mac OS X currently not supported
In case return code is different from 0, sth went wrong.
:param args: Arguments for converter pix
:type args: list[str]
:return: return code and stdout from converter pix devided into lines; empty
list on error or not supported OS
:rtype: tuple[int, list[str]]
"""
final_command = [CONVERTER_PIX_PATH]
final_command.extend(args)
print(final_command)
result = subprocess.run(final_command, stdout=subprocess.PIPE)
# if there was some problem running converter pix just return empty list
if result.returncode != 0:
return result.returncode, []
# also return non-zero code if converter pix alone is reporting errors in
output
if "<error>".encode("utf-8") in result.stdout:
return -1, result.stdout.decode("utf-8").split(LINE_SPLITTER)
decoded_result = result.stdout.decode("utf-8").split(LINE_SPLITTER)
for line in decoded_result:
print(line)
return result.returncode, decoded_result
def get_archive_listdir(file_paths, current_subpath):
"""Get archive directory listing for given subpath.
:param file_paths: list of paths that should be used as base archives for
converter pix
:type file_paths: list[str]
:param current_subpath: current subpath inside of archives
:type current_subpath: str
:return: returns two lists: directories and files
:rtype: (list[str], list[str])
"""
args = []
for file_path in file_paths:
args.extend(["-b", file_path])
args.extend(["-listdir", current_subpath])
retcode, stdout = run_converter_pix(args)
dirs = []
files = []
if retcode != 0:
print("Error getting archive directory listing output from ConverterPIX!")
for line in stdout:
if line.startswith("[D] "):
dirs.append(os.path.relpath(line[4:], current_subpath))
elif line.startswith("[F] "):
files.append(os.path.relpath(line[4:], current_subpath))
return sorted(dirs), sorted(files)
# ### PROPERTIES ###
class ConvPIXWrapperAddonPrefs(AddonPreferences):
bl_idname = __name__
def draw(self, context):
layout = self.layout
col = layout.column(align=True)
col.operator("world.converter_pix_wrapper_update_exe", icon="URL")
class ConvPIXWrapperFileEntry(bpy.types.PropertyGroup):
"""Property group holding browser file entry data."""
do_import: BoolProperty(description="Proccess this entry for
conversion/import.")
name: StringProperty(description="Name of the entry represeting name of the
file or directory.")
is_dir: BoolProperty(description="Taging this entry as directory.")
class ConvPIXWrapperBrowserData(bpy.types.PropertyGroup):
"""Property group representing file browser data."""
def is_subpath_valid(self):
"""Checks if current set subpath is valid for currently set archives.
:return: True if any dirs and files is returned; False otherwise
:rtype: bool
"""
archive_paths = [archive_path.name for archive_path in self.archive_paths]
dirs, files = get_archive_listdir(archive_paths, self.current_subpath)
if len(dirs) > 0 or len(files) > 0:
return True
return False
def update_active_entry(self, context):
"""Update function for navigation trough tree of archive:
1. When directory is selected it advances to it and refreshes the list.
2. When parent directory '..' is selected it returns one level up and
refreshes the list.
3. When file is selected nothing happens.
"""
# update current subpath only if proper active entry selected
if 0 <= self.active_entry < len(self.file_entries):
active_file_entry = self.file_entries[self.active_entry]
print("New active item:", active_file_entry.name)
# only advance in tree if active entry is directory
if active_file_entry.is_dir:
if active_file_entry.name == "..":
if self.current_subpath != "/":
self.current_subpath =
os.path.dirname(self.current_subpath)
else:
self.current_subpath = path_join(self.current_subpath,
active_file_entry.name)
self.active_entry = -1
# abort execution here, as setting active entry to -1 will anyway
trigger another update
return
elif active_file_entry.name != "..": # file was selected just return
and do nothing with selection
return
# remove old entries
while len(self.file_entries) > 0:
self.file_entries.remove(0)
# add entry for navigating to parent directory
entry = self.file_entries.add()
entry.name = ".."
entry.is_dir = True
# add actual entries from archives
archive_paths = [archive_path.name for archive_path in self.archive_paths]
dirs, files = get_archive_listdir(archive_paths, self.current_subpath)
for dir_name in dirs:
entry = self.file_entries.add()
entry.name = dir_name
entry.is_dir = True
for file_name in files:
# ignore file that don't match prescribed extension, if asteriks then
everything should be displayed
if not file_name.endswith(self.file_extension) and
self.file_extension != "*":
continue
entry = self.file_entries.add()
entry.name = file_name
entry.is_dir = False
multi_select: BoolProperty(
description="Can multiple files be selected?"
)
file_extension: StringProperty(
description="File extension for the files that should be listed in this
browser data.",
default="*",
)
archive_paths: CollectionProperty(
description="Paths to archives from which directories and files should be
listed.",
type=bpy.types.OperatorFileListElement,
)
current_subpath: StringProperty(
description="Current position in archive tree.",
default="/",
)
file_entries: CollectionProperty(
description="Collection of file entries for current position in archive
tree.",
type=ConvPIXWrapperFileEntry,
)
active_entry: IntProperty(
description="Currently selected directory/file in browser.",
default=-1,
update=update_active_entry
)
class ConvPIXWrapperArchiveToUse(bpy.types.PropertyGroup):
"""Property group holding entry data for archives to use."""
path: StringProperty(description="Path to archive.")
selected: BoolProperty(description="Marking this path as selected. Once
selected it can be deleted or moved in the list.")
# ### OPERATORS ###
class CONV_PIX_WRAPPER_UL_FileEntryItem(bpy.types.UIList):
"""Class for drawing archive browser file entry."""
def draw_item(self, context, layout, data, item, icon, active_data,
active_property, index):
if item.name == "..":
icon = "FILE_PARENT"
elif item.is_dir:
icon = "FILE_FOLDER"
else:
icon = "FILE_BLANK"
split_line = layout.split(factor=0.8)
split_line.prop(item, "name", text="", emboss=False, icon=icon)
if data.multi_select and not item.is_dir:
row = split_line.row()
row.alignment = "RIGHT"
row.prop(item, "do_import", text="")
class CONV_PIX_WRAPPER_OT_ListImport(bpy.types.Operator):
bl_idname = "converter_pix_wrapper.list_and_import"
bl_label = "Converter PIX Wrapper"
bl_options = {'UNDO', 'INTERNAL'}
__static_last_model_subpath = "/"
__static_last_anim_subpath = "/"
__static_browsers_slider = 0.5
archive_paths: CollectionProperty(
description="Paths to archives from which directories and files should be
listed.",
type=bpy.types.OperatorFileListElement,
)
only_convert: BoolProperty(
description="Use ConverterPIX only for conversion of resources into SCS
Project Base Path and import manually later?",
)
textures_to_base: BoolProperty(
description="Should textures be copied into the sibling 'base' directory,
so they won't be included in mod packing?",
)
import_animations: BoolProperty(
name="Use Animations",
description="Select animations for conversion and import?\n"
"Gives you ability to convert and import animations for
selected model (use it only if you are working with animated model)."
)
model_browser_data: PointerProperty(
description="Archive browser data for model selection.",
type=ConvPIXWrapperBrowserData
)
anim_browser_data: PointerProperty(
description="Archive browser data for animations selection.",
type=ConvPIXWrapperBrowserData
)
browsers_slider: FloatProperty(
name="Browsers Slider",
min=0.0,
max=1.0,
subtype='FACTOR',
default=0.5
)
def check(self, context):
return True # always trigger redraw to avoid problems of popup dialog
UIList not drawing properly
def invoke(self, context, event):
# prepare browsers data and forcly trigger update, to load up root archive
entries
for archive_path in self.archive_paths:
entry = self.model_browser_data.archive_paths.add()
entry.name = archive_path.name
entry = self.anim_browser_data.archive_paths.add()
entry.name = archive_path.name
self.model_browser_data.current_subpath =
CONV_PIX_WRAPPER_OT_ListImport.__static_last_model_subpath
if not self.model_browser_data.is_subpath_valid():
self.model_browser_data.current_subpath = "/"
self.anim_browser_data.current_subpath =
CONV_PIX_WRAPPER_OT_ListImport.__static_last_anim_subpath
if not self.anim_browser_data.is_subpath_valid():
self.anim_browser_data.current_subpath = "/"
self.model_browser_data.file_extension = ".pmg"
self.anim_browser_data.file_extension = ".pma"
self.anim_browser_data.multi_select = True
self.model_browser_data.update_active_entry(context)
self.anim_browser_data.update_active_entry(context)
self.browsers_slider =
CONV_PIX_WRAPPER_OT_ListImport.__static_browsers_slider
return context.window_manager.invoke_props_dialog(self, width=500)
def execute(self, context):
from io_scs_tools.utils import get_scs_globals
self.save_current_operator_settings()
if self.model_browser_data.active_entry == -1:
self.report({'WARNING'}, "No active model selected, aborting import!")
return {'CANCELLED'}
model_file_entry_name =
self.model_browser_data.file_entries[self.model_browser_data.active_entry].name
model_archive_subpath = path_join(self.model_browser_data.current_subpath,
model_file_entry_name)
# collect all selected animations from animations browser
anim_archive_subpaths = []
if self.import_animations:
for anim_file_entry in self.anim_browser_data.file_entries:
if anim_file_entry.do_import:
anim_archive_subpaths.append(path_join(self.anim_browser_data.current_subpath,
anim_file_entry.name[:-4]))
# temporarly convert to temp directory to be able to extract textures and
models separately
export_path = mkdtemp()
# put together arguments for converter pix
args = []
for archive_path in self.archive_paths:
args.extend(["-b", archive_path.name])
args.extend(["-m", model_archive_subpath[:-4]])
args.extend(anim_archive_subpaths)
args.extend(["-e", export_path])
# execute conversion
retcode, stdout = run_converter_pix(args)
if retcode != 0:
msg = "ConverterPIX crashed or encountered error! Standard output
returned:"
print(msg)
self.report({'ERROR'}, msg)
for line in stdout:
if line != "":
print(line)
self.report({'ERROR'}, line)
return {'CANCELLED'}
# calculate models & textures project path
models_project_path = textures_project_path =
get_scs_globals().scs_project_path
if self.textures_to_base:
textures_project_path = os.path.join(models_project_path, os.pardir,
"base")
# distribute converted data to appropriate folder
for root, dirs, files in os.walk(export_path, topdown=False):
file_subdir = os.path.relpath(root, export_path)
for file in files:
if file.endswith(".tobj") or file.endswith(".dds") or
file.endswith(".png"):
file_dstdir = os.path.join(textures_project_path, file_subdir)
else:
file_dstdir = os.path.join(models_project_path, file_subdir)
os.makedirs(file_dstdir, exist_ok=True)
src_path = os.path.join(root, file)
dst_path = os.path.join(file_dstdir, file)
shutil.move(src_path, dst_path)
# dirs cleanup - with the help of disabled topdown listing, remove
empty dirs here including topmost export path
os.rmdir(root)
# now do actual import with BT
if not self.only_convert:
pim_import_file = model_file_entry_name[:-4] + ".pim"
pim_import_dir = path_join(get_scs_globals().scs_project_path,
self.model_browser_data.current_subpath[1:])
bpy.ops.scs_tools.import_pim(files=[{"name": pim_import_file}],
directory=pim_import_dir)
return {'FINISHED'}
def save_current_operator_settings(self):
# backup last sub-paths to return to them eventually
CONV_PIX_WRAPPER_OT_ListImport.__static_last_model_subpath =
self.model_browser_data.current_subpath
CONV_PIX_WRAPPER_OT_ListImport.__static_last_anim_subpath =
self.anim_browser_data.current_subpath
# backup ui browsers divider value
CONV_PIX_WRAPPER_OT_ListImport.__static_browsers_slider =
self.browsers_slider
print("Saving current settings for ConverterPIXWrapper import operator...")
def cancel(self, context):
self.save_current_operator_settings()
def draw(self, context):
layout = self.layout
# clip browsers slider to proper upper and lower values to avoid UI
problems with split
if self.browsers_slider < 0.1 or self.browsers_slider > 0.85:
self.browsers_slider = min(0.85, max(0.1, self.browsers_slider))
archive_names = [os.path.basename(archive_path.name) for archive_path in
self.archive_paths]
layout.label(text="Currently working upon: %r." % archive_names)
# browsers slider ratio
layout.prop(self, "browsers_slider")
browser_layout = layout.split(factor=self.browsers_slider)
left_column = browser_layout.column(align=True)
right_column = browser_layout.column(align=True)
usage_type = "convert" if self.only_convert else "convert & import"
# left browser
left_column.label(text="Model to %s:" % usage_type)
subpath_row = left_column.row(align=True)
subpath_row.enabled = False
subpath_row.prop(self.model_browser_data, "current_subpath", text="")
left_column.template_list(
'CONV_PIX_WRAPPER_UL_FileEntryItem',
list_id="ModelBrowser",
dataptr=self.model_browser_data,
propname="file_entries",
active_dataptr=self.model_browser_data,
active_propname="active_entry",
rows=20,
maxrows=20,
)
# right browser
import_anim_row = right_column.row()
import_anim_row.label(text="Animations to %s:" % usage_type)
import_anim_row = import_anim_row.row()
import_anim_row.alignment = "RIGHT"
import_anim_row.prop(self, "import_animations", text="")
subpath_row = right_column.row(align=True)
subpath_row.enabled = False
subpath_row.prop(self.anim_browser_data, "current_subpath", text="")
browser_row = right_column.row(align=True)
browser_row.enabled = self.import_animations
browser_row.template_list(
'CONV_PIX_WRAPPER_UL_FileEntryItem',
list_id="AnimBrowser",
dataptr=self.anim_browser_data,
propname="file_entries",
active_dataptr=self.anim_browser_data,
active_propname="active_entry",
rows=20,
maxrows=20,
)
class CONV_PIX_WRAPPER_OT_Import(bpy.types.Operator, ImportHelper):
bl_idname = "converter_pix_wrapper.import"
bl_label = "Import SCS Models - ConverterPIX & BT (*.scs)"
bl_description = "Converts and imports selected SCS model with the help of
ConvPIX and SCS Blender Tools."
bl_options = {'UNDO', 'PRESET'}
directory: StringProperty()
files: CollectionProperty(name="Selected Files",
description="File paths used for importing the SCS
files",
type=bpy.types.OperatorFileListElement)
ordered_files = [] # stores ordered list of currently selected files, first
selected is first, last selected is last
archives_to_use: CollectionProperty(name="Archives to Use",
description="Archives that should be used
on conversion/import.",
type=ConvPIXWrapperArchiveToUse)
archives_to_use_mode: BoolProperty(
default=False,
description="Add currently selected files to list of archives to be used
with ConverterPIX as bases."
)
delete_selected_archives_mode: BoolProperty(
default=False,
description="Delete selected archives from list."
)
move_up_selected_archives_mode: BoolProperty(
default=False,
description="Move selected archives up in the list."
)
move_down_selected_archives_mode: BoolProperty(
default=False,
description="Move selected archives down in the list."
)
scs_project_path_mode: BoolProperty(
default=False,
description="Set currently selected directory as SCS Project Path"
)
only_convert: BoolProperty(
name="Only convert?",
description="Use ConverterPIX only for conversion of resources into SCS
Project Base Path and import manually later?",
default=False
)
textures_to_base: BoolProperty(
name="Textures to Base?",
description="Should textures be copied into the sibling 'base' directory,
so they won't be included in mod packing?",
default=False
)
filter_glob: StringProperty(default="*.scs;*.zip;", options={'HIDDEN'})
def check(self, context):
# create/update ordered list of currently selected files
current_file_names = set([file.name for file in self.files])
# we can put together ordering by copying names into extra array
for file_name in current_file_names:
if file_name not in self.ordered_files:
self.ordered_files.append(file_name)
# similarly as adding we have to take care of removing items which are not
selected anymore
for file_name in self.ordered_files.copy(): # work upon copy as we are
removing items in this for
if file_name not in current_file_names:
self.ordered_files.remove(file_name)
# handle different actions depending on boolean modes variables
if self.scs_project_path_mode: # set SCS Project Base Path
from io_scs_tools.utils import get_scs_globals
get_scs_globals().scs_project_path = os.path.dirname(self.filepath)
self.scs_project_path_mode = False
elif self.archives_to_use_mode: # add selected archives from browser to
archives list
curr_archives_to_use = [archive.path for archive in
self.archives_to_use]
for file_name in self.ordered_files:
curr_filepath = path_join(self.directory, file_name)
# avoid duplicates
if curr_filepath in curr_archives_to_use:
continue
new_archive_to_use = self.archives_to_use.add()
new_archive_to_use.path = curr_filepath
self.archives_to_use_mode = False
elif self.delete_selected_archives_mode: # delete selected archives from
list
i = 0
while i < len(self.archives_to_use):
if self.archives_to_use[i].selected:
self.archives_to_use.remove(i)
i -= 1
i += 1
self.delete_selected_archives_mode = False
elif self.move_up_selected_archives_mode: # move up selected archives in
the list
i = 0
while i < len(self.archives_to_use):
if self.archives_to_use[i].selected:
if i - 1 >= 0 and not self.archives_to_use[i - 1].selected:
self.archives_to_use.move(i, i - 1)
i += 1
self.move_up_selected_archives_mode = False
elif self.move_down_selected_archives_mode: # move down selected archives
in the list
i = len(self.archives_to_use) - 1
while i >= 0:
if self.archives_to_use[i].selected:
if i + 1 < len(self.archives_to_use) and not
self.archives_to_use[i + 1].selected:
self.archives_to_use.move(i, i + 1)
i -= 1
self.move_down_selected_archives_mode = False
def execute(self, context):
archive_paths = [{"name": archive.path} for archive in
self.archives_to_use]
# additionally add currently selected archives
for file_name in self.ordered_files:
archive_paths.append({"name": os.path.join(self.directory, file_name)})
bpy.ops.converter_pix_wrapper.list_and_import("INVOKE_DEFAULT",
archive_paths=archive_paths,
only_convert=self.only_convert,
textures_to_base=self.textures_to_base)
return {'FINISHED'}
def invoke(self, context, event):
# quick check if BT are installed
if "io_scs_tools" not in context.preferences.addons:
self.report({"ERROR"}, "Can't run Converter PIX Wrapper! Please install
SCS Blender Tools add-on first & enable it!")
return {'CANCELLED'}
context.window_manager.fileselect_add(self)
return {'RUNNING_MODAL'}
def draw(self, context):
from io_scs_tools import SCS_TOOLS_OT_Import
from io_scs_tools.internals.containers.config import AsyncPathsInit
from io_scs_tools.utils import get_scs_globals
files_box = self.layout.box()
files_box.row().label(text="Extra Archives to Use:")
is_any_archive_selected = False
files_list_col = files_box.column(align=True)
if len(self.archives_to_use) > 0:
for archive in self.archives_to_use:
row = files_list_col.row(align=True)
path_col = row.column(align=True)
path_col.enabled = False
path_col.prop(archive, "path", text="")
row.prop(archive, "selected", text="", icon_only=True,
icon="CHECKMARK" if archive.selected else "BLANK1")
is_any_archive_selected |= archive.selected
else:
files_list_col.label(text="No extra archives!", icon="INFO")
# show controls of list only if sth is selected
if is_any_archive_selected:
row = files_list_col.row(align=True)
row.prop(self, "delete_selected_archives_mode", text="Remove",
icon="PANEL_CLOSE")
row.prop(self, "move_up_selected_archives_mode", text="Up",
icon="TRIA_UP")
row.prop(self, "move_down_selected_archives_mode", text="Down",
icon="TRIA_DOWN")
files_list_col.prop(self, "archives_to_use_mode", toggle=True, text="Add
Archives to List", icon='PASTEDOWN')
settings_col = self.layout.box().column(align=True)
settings_col.prop(self, "only_convert")
settings_col.prop(self, "textures_to_base")
if self.only_convert:
scs_globals = get_scs_globals()
# importer_version = round(import_pix.version(), 2)
layout = self.layout
# SCS Project Path
box1 = layout.box()
layout_box_col = box1.column(align=True)
layout_box_col.label(text='SCS Project Base Path:', icon='FILE_FOLDER')
layout_box_col.separator()
layout_box_row = layout_box_col.row(align=True)
layout_box_row.alert = not os.path.isdir(scs_globals.scs_project_path)
layout_box_row.prop(scs_globals, 'scs_project_path', text='')
layout_box_row = layout_box_col.row(align=True)
layout_box_row.prop(self, "scs_project_path_mode", toggle=True,
text="Set Current Dir as Project Base", icon='PASTEDOWN')
if AsyncPathsInit.is_running(): # report running path initialization
operator
layout_box_row = layout_box_col.row(align=True)
layout_box_row.label(text="Paths initialization in progress...")
layout_box_row.label(text="", icon='TIME')
else:
SCS_TOOLS_OT_Import.draw(self, context)
class CONV_PIX_WRAPPER_OT_UpdateEXE(bpy.types.Operator):
bl_idname = "world.converter_pix_wrapper_update_exe"
bl_label = "Update ConverterPIX Executable"
bl_description = "Not sure if your ConverterPIX is up-to date? Use this button
to download & update it!"
bl_options = {'INTERNAL'}
def execute(self, context):
if update_converter_pix():
self.report({"INFO"}, "ConverterPIX file updated!")
else:
self.report({"ERROR"}, "Problem updating ConverterPIX! Try again
later.")
return {'FINISHED'}
def menu_func_import(self, context):
self.layout.operator(CONV_PIX_WRAPPER_OT_Import.bl_idname, text="SCS Models -
ConverterPIX & BT (*.scs)")
classes = (
ConvPIXWrapperAddonPrefs,
ConvPIXWrapperFileEntry,
ConvPIXWrapperBrowserData,
ConvPIXWrapperArchiveToUse,
CONV_PIX_WRAPPER_UL_FileEntryItem,
CONV_PIX_WRAPPER_OT_ListImport,
CONV_PIX_WRAPPER_OT_Import,
CONV_PIX_WRAPPER_OT_UpdateEXE,
)
def register():
for cls in classes:
bpy.utils.register_class(cls)
bpy.types.TOPBAR_MT_file_import.append(menu_func_import)
# check if converter pix exists or it's not to more than 1 day old, otherwise
redownload it!
if not os.path.isfile(CONVERTER_PIX_PATH) or time() -
os.path.getmtime(CONVERTER_PIX_PATH) > 60 * 60 * 24:
t = Thread(name="update converterpix", target=update_converter_pix)
t.setDaemon(True)
t.start()
def unregister():
for cls in classes:
bpy.utils.unregister_class(cls)
bpy.types.TOPBAR_MT_file_import.remove(menu_func_import)
if __name__ == '__main__':
register()
